How do you translate a SCORM 2004 Fourth Edition course without damaging its learning sequence, reporting fields or completion logic? SCORM is not merely a folder of lessons that can be copied into another language. It connects a packaged content hierarchy to a learning management system through a manifest, launch resources, run-time communication and sequencing rules. The learner sees a local-language course, but the LMS must still recognize each sharable content object, the correct navigation choices and the intended completion and success states. Getting that boundary right is what professional localization means.
This SCORM 2004 4th Edition localization guide explains imsmanifest.xml, organizations and items, SCOs and assets, run-time API calls, cmi.completion_status, cmi.success_status, normalized scores, progress measures, objectives, sequencing rules, multilingual course menus, translated assessment feedback and package testing. It is written for eLearning translators, corporate training teams, universities, compliance departments, LMS administrators, instructional designers and vendors moving training between countries. Examples are fictional and use safe test records; they are designed to reveal where language belongs and where technical identifiers must remain exact.
SCORM 2004 Fourth Edition is a particular edition of a long-established technical specification, not a promise that every LMS implements every feature equally. It separates completion and success, supports sequencing and navigation behavior, and uses a defined JavaScript run-time interface. Its underlying packaging and run-time concepts differ from SCORM 1.2, cmi5 and general xAPI. The goal of this article is a careful method for translating what the learner needs to understand while validating what the LMS actually interprets. When uncertain, check the deployed LMS and the SCORM conformance documents rather than replacing technical fields with guesses.
A practical reading map
Begin with the architectural foundations, study thirty concrete failure and repair situations, then use the review questions, four-week plan and FAQ to test your own course. The purpose is not to make a document look international; it is to ensure that learners understand the training while the LMS still receives and evaluates the evidence the course was designed to generate.
How SCORM 2004 localization actually works
The four layers of a SCORM course
Think of the course in four layers: the package that can be imported, the organization describing navigation, the SCOs that run in a browser, and the runtime records exchanged with the LMS. The same word can appear in all four layers but serve different functions. A translated table of contents is not itself a replacement for the underlying activity hierarchy.
An effective handover includes both a file map and a behavioral map. The first says where resources live; the second says how learners enter, complete and leave them. Translation quality must be evaluated against both.
SCORM 2004 is not SCORM 1.2
SCORM 1.2 commonly uses cmi.core.lesson_status, whereas SCORM 2004 separates cmi.completion_status from cmi.success_status and introduces its own sequencing model. The runtime API names are different too. A package labeled as SCORM 2004 does not become SCORM 1.2 because an LMS accepts both formats.
Verify the version in the package and in the target system. Do not copy status-field examples, launch calls or data limits from an older training manual without checking their edition. A translation reviewer who ignores version can accidentally approve technically false documentation.
What the manifest actually owns
The imsmanifest.xml file tells the LMS about organizations, items, resource references and other structural information. Many human-facing titles live near technical attributes such as identifier and identifierref. The two types of data must be reviewed separately even when they are adjacent in XML.
Translate the intended display labels. Preserve link targets, IDs, namespace rules and file paths unless a carefully planned package migration changes them. XML that remains well formed can still point to a resource that no longer exists.
SCOs versus ordinary assets
A sharable content object communicates with the LMS through the SCORM runtime API. A supporting asset might be an image, stylesheet or file that does not report progress itself. Translators may change both kinds of resources, but breaking a SCO has different consequences from breaking a decorative image.
Mark each launchable SCO and identify its dependencies. Test a complete launch and reporting sequence from within the LMS. Opening its HTML file outside the LMS is useful for text proofreading but insufficient for verifying standards behavior.
The SCORM 2004 runtime contract
A SCO finds and calls the appropriate API, initializes communication, reads or writes defined cmi elements, commits data and terminates the session. Its exact call names and data fields are technical vocabulary. Localized interface strings should not replace them or change code paths that govern the transaction.
Separate the translation bundle from runtime JavaScript and cmi field names wherever possible. When text is embedded in code, use context-aware extraction rather than blanket string replacement.
Completion and success are separate judgments
Completion answers whether the course activity is complete under the applicable criteria. Success answers whether the mastery or passing standard was met. A learner can finish the lesson and still fail an assessment. Translation must not merge these ideas simply to make progress messages shorter.
Build a status matrix with completed, incomplete, passed, failed and unknown states as relevant. Check the exact platform behavior and phrase the learner-facing explanations so they agree with the reported fields.
Scores are values with declared meanings
The data model can include scaled and raw scores as well as minimum or maximum values. A value of 0.75 in a normalized field is not automatically the same string as 75 points in a raw-score field. Regional decimal symbols and percentage presentation require care.
Document which field supplies every score display. Translate the label and formatting as appropriate while leaving the underlying numerical record unchanged. Verify rounding thresholds at the pass boundary.
Sequencing is a rule system, not merely a list
SCORM 2004 can express sequencing and navigation rules that restrict or guide learning paths. An item can be displayed in a translated menu while its availability still depends on objectives and prior attempts. Rearranging headings in the user interface may create a false sense that the course allows a different order.
Keep a clear distinction between visual order, authored curriculum order and LMS-enforced sequencing. Test what learners can actually choose instead of assuming the screenshot describes the behavior.
Objectives and rollup need exactness
A course may use objectives and aggregation of progress or success across activities. Localized descriptions can explain what a learner is trying to achieve, but objective identifiers and rule logic are part of the machine contract. A progress bar may depend on results from more than one SCO.
Trace how each child result contributes to the parent status. Confirm that translated messages do not claim a course is complete before the actual required combination is satisfied.
Resume, suspend and session state
A long course often stores a bookmark, suspend data or progress in runtime fields. The text the learner sees upon returning depends on the actual saved state. Localizing a course can inadvertently change data encoding, sequence or field limits in ways that lose the bookmark.
Try interruption at several points and resume under the target language. Compare saved state and visible page, including after a browser restart and a platform update. Avoid translating serialized control data unless its schema explicitly supports it.
Accessible learning is part of the package
Localized captions, transcripts, alternative text, keyboard labels and feedback belong to the learner’s training experience. A technically valid SCORM file can still be inaccessible or teach a different concept through its accessible alternatives.
Use subject-matter review for safety claims and accessibility review for multimodal equivalence. Test the lesson without relying solely on sound, color or mouse interaction.
Why ‘import success’ is not course success
An LMS can accept a zipped package while one SCO fails to launch, a resource returns an error, a passing score is misread or navigation traps the learner. Import validation is only one gate. Professional localization needs functional verification from first click to transcript.
Create a small, repeatable test run for every supported LMS and locale. Collect the exact version, observed fields and actual outcomes, not a vague note saying ‘works in browser’.
Thirty real-world SCORM localization decisions
The examples are fictional, but the boundaries are real. In each case, ask what the user sees, what the specification requires, which system makes the decision and which test demonstrates that the localized course has preserved the intended behavior.
1. Translate the item title, not the identifier
An XML item contains a friendly English title beside a machine identifier. A translator updates both because they look like neighboring labels. The localized course menu reads well, but references to the item no longer match.
The identifier is not an English phrase merely because it uses English-looking characters. Other parts of the manifest can rely on its exact bytes, so a change breaks relationships rather than helping learners.
Keep identifiers and identifier references stable. Translate the title element or authorized display field. If identifiers genuinely need a migration, manage it as an engineering change with full dependency review.
Verification exercise: Parse the manifest and compare references before and after translation, then import the package and navigate into the item.
2. Repackage without losing imsmanifest.xml
A vendor creates a translated zip file with an extra parent folder above the manifest. The LMS rejects the package, although the translated HTML and images are all present.
Packaging structure is a technical requirement. Good language quality cannot compensate for a misplaced entry point, and different import tools may provide confusing error text.
Preserve the expected archive-root structure and manifest location. Use a packaging checklist before transferring the course to another organization.
Verification exercise: Open the archive as a tree and conduct an actual LMS import in a clean staging course.
3. Keep identifierref matched to resources
A designer renames a course resource folder and changes its file path in one place but leaves the identifierref relationship untouched. The LMS points to an absent resource.
The resource identifier and the resource path participate in distinct relationships. One connects an item to a resource; the other tells the system where a file lives.
Maintain a resource mapping table and change the package in a controlled way. Translate descriptions without treating these structural links as prose.
Verification exercise: Follow every identifierref to a declared resource and every href to a real file or intentional external destination.
4. A SCO loads but never initializes
The localized lesson opens in a new browser frame but does not find the API interface, so no progress is reported. The design team considers it a translation success because the text appears.
Rendering and runtime communication are separate states. The learner may spend an hour on a lesson whose completion evidence is never stored.
Inspect launch context and JavaScript initialization behavior. Avoid changing code or frame paths while extracting translatable strings.
Verification exercise: Complete a short test SCO and confirm valid initialize, set, commit and terminate behavior in the LMS trace.
5. Confuse a completion label with a pass result
An assessment’s success field reports failed while its completion field reports completed. The translated end screen says ‘You passed’ because the reviewer assumes finishing means passing.
The learner receives false information about certification eligibility. Such a mistake can be especially serious in regulated training where a completed attempt is not a qualified result.
Create two separate target-language expressions for finishing the activity and meeting the pass threshold. Tie each message to the proper data field.
Verification exercise: Test a finished failed attempt and a finished passed attempt. The LMS transcript and screen must agree about both dimensions.
6. Convert cmi.score.scaled into an unqualified percent
The SCO records a scaled score of 0.72. A localized dashboard simply displays ‘0.72%’ while the course report elsewhere says 72%.
A scaled value and its percentage rendering differ in unit and representation. Some reports may display raw scores on different scales, making careless conversions misleading.
Define calculation and rounding rules. Only show a percentage if conversion is appropriate for that field and the interface clearly says what the number measures.
Verification exercise: Test values at zero, the pass boundary, one, missing and outside the documented range.
7. Use the wrong runtime field names
A translator works from an old SCORM 1.2 manual and inserts cmi.core.lesson_status into instructions for a SCORM 2004 SCO. The instructions are fluent but technically wrong.
Status names are not stylistic alternatives. The runtime may reject an unknown element or silently fail to record the intended result.
Maintain an edition-specific glossary and require technical review for code examples and field names. Mark all literal identifiers as protected.
Verification exercise: Execute the described procedure in a SCORM 2004 test environment rather than checking only spelling.
8. Turn Continue into Resume where it means something else
A navigation button requests the next eligible activity, but the localized label implies reopening the previous suspended activity. Learners choose it expecting an outcome the sequencing engine does not deliver.
Navigation words reflect actions, not isolated dictionary entries. A short label can be functionally inaccurate even though it is a valid translation.
Test the button in its real sequence state. Localize by intended action: proceed, return, exit, restart or resume only when that is what happens.
Verification exercise: Ask a native-language tester to predict the result before clicking; compare their expectation with the next activity.
9. Hide a disabled activity without explaining why
A prerequisite rule prevents entry into a SCO. The localized menu merely dims it; learners assume a technical error or permission problem.
A disabled control may represent curriculum sequencing, failed prerequisites, a planned release date or actual access restriction. The support message must not invent a cause.
Where the system knows the reason, explain the governing rule in the local language without exposing unnecessary personal data.
Verification exercise: Attempt access with unmet and met prerequisites. The wording should correspond to the actual rule and change when eligibility changes.
10. Translate XML namespace strings
A reviewer sees a namespace URI containing familiar words and adapts it to the destination language. The XML stays syntactically well formed but no longer identifies the same vocabulary.
Namespaces are symbolic identifiers, not documentation prose. Validators and LMS imports depend on the exact standards vocabulary associated with them.
Protect schema locations and namespace URIs. Translate only permitted text nodes and selected values that the specification defines as human-readable.
Verification exercise: Validate against the expected schema and import on the supported LMS, checking for unknown element or namespace errors.
11. Break filename capitalization during localization
A course package developed on a case-insensitive machine is transferred to a stricter server. Its translated resource path differs in uppercase letters from the actual file.
The mismatch may appear only after deployment and can leave a blank panel or missing accessibility file. Readers naturally blame the translation when the problem is filesystem behavior.
Normalize path conventions and check exact resource references. Do not alter extension or case as a side effect of renaming the display title.
Verification exercise: Test the archive in an environment that detects mismatched capitalization and open every referenced asset.
12. Rewrite a quiz explanation but retain the old answer
An example is localized from one workplace to another. The correct multiple-choice answer was based on the original situation, yet the answer key and feedback were not reviewed together.
The same learning objective may need a different example, but that does not mean any replacement is safe. The translated question can acquire two defensible answers.
Have a subject expert approve adaptations and link each prompt with its keyed answer and feedback. Preserve the assessed skill rather than its incidental setting.
Verification exercise: Run blind learner testing with the localized item and investigate answers that differ from the intended response.
13. Translate a bookmark as if it were prose
A course stores a technical bookmark that happens to look like ‘chapter-two’. An extraction script treats it as learner-visible text and rewrites the internal value.
A serialized location is a machine pointer. Converting it to a translated phrase can make a resume request point nowhere.
Classify state fields as control data. Translate a displayed chapter name separately and preserve saved references or migrate them with defined compatibility rules.
Verification exercise: Suspend a learner mid-course, reopen it after localization and verify that the intended screen and progress reappear.
14. Lose suspend data after adding long localized text
A localized activity stores additional interface text in a persistence field originally designed for compact state. The returned data becomes too large for the intended runtime handling.
State capacity belongs to the platform contract and implementation, not the length of visible prose. Overloading it can cause failed commits or incomplete restoration.
Keep localized text in dedicated resources; store only necessary state. Review any size limit with the platform’s documented edition and implementation.
Verification exercise: Test the longest plausible session and resume it. Inspect commit results and restored values, not just the first few pages.
15. A progress measure is mistaken for an exam score
A translated dashboard labels cmi.progress_measure as ‘Grade’. The learner sees 90% and assumes a high examination result when the number reflects work completed.
Progress and mastery are different concepts even if both are represented numerically between zero and one. Labeling them incorrectly changes the educational meaning.
Map each display to the originating data element. Use separate words and icons for progress through material and success against standards.
Verification exercise: Generate a learner who has visited most content but failed the assessment. The dashboard must remain intelligible.
16. Passing score gets rounded incorrectly
A course uses a threshold and a localized report rounds a score upward before comparison, displaying a pass that the underlying rule would not award.
Presentation rounding must not redefine the scoring boundary. The difference may affect certification, workplace records and perceived fairness.
Apply passing logic according to the SCO and LMS rule; round for display only afterwards, with enough precision to explain close cases.
Verification exercise: Test scores just below, at and just above the threshold; verify success status as well as text.
17. An activity item is rearranged outside its sequencing rule
A translator reorganizes the menu to improve readability in a right-to-left language. The visual order now contradicts which SCO must be completed first.
Reordering can be appropriate when it is purely visual, but it is unsafe when the reader infers a different learning sequence. A document’s order is sometimes instructional.
Coordinate visual direction, actual item order and sequencing semantics. Explain prerequisite stages clearly without changing the rule silently.
Verification exercise: Try the course with a new learner from the first activity to final completion in the target-language interface.
18. A global objective name becomes localized only in one SCO
A developer renames a shared objective identifier in a translated activity, leaving other activities pointing to the original identifier.
Shared objectives allow sequencing and tracking logic to connect results. Renaming one side of the relationship separates records that were intended to work together.
Keep objective identifiers stable across SCOs. Translate their human-friendly descriptions instead, and keep any actual objective migration coordinated.
Verification exercise: Examine inter-SCO rollup after a passing and failing attempt. A single changed label must not sever the relationship.
19. A local-language tooltip explains the wrong navigation state
A tooltip says ‘Next lesson is available’ although the LMS is currently withholding navigation under sequencing rules.
Tooltips need real functional context. They are not harmless decorations when a learner relies on them to decide what to do.
Use state-aware wording where possible. If the application cannot determine the reason for restriction, use a neutral statement rather than a guessed explanation.
Verification exercise: Check the same tooltip when the next activity is available, unavailable and blocked by failure.
20. Keyboard labels disagree with on-screen text
A localized exit button is correctly translated visually, but its accessible label still says ‘Submit’. Screen-reader users may end the course when they intended to submit a response.
Accessibility metadata is part of the action semantics. Two contradictory names for one control create unequal risk and confusion.
Extract aria labels, captions and keyboard help along with visible strings. Review the outcome of each control in context.
Verification exercise: Complete the SCO by keyboard and screen reader, including cancellation, pause, submit and exit paths.
21. Missing image alt text changes a technical lesson
A diagram explains an equipment inspection sequence. The localized image file appears correctly, but the alternative description is absent or describes a different step.
For some learners the alt text carries essential information. Accessibility and instructional correctness are therefore inseparable.
Write alternative descriptions that convey the relevant relationships and actions, not merely an aesthetic summary of the image.
Verification exercise: Attempt the instructional task without viewing the diagram. The learner should receive equivalent information.
22. A learning record is saved only after closing
A translated exit message claims completion is recorded, but the SCO has not successfully committed its runtime values and the browser closes too quickly.
Closing a window is an interface action, not proof that the LMS accepted a record. An inaccurate farewell message can conceal a tracking failure.
Ensure runtime commit and termination behavior is tested. Write confirmation based on actual save state rather than hopeful wording.
Verification exercise: Throttle the network and reproduce a failed save. Verify whether the message matches what the LMS ultimately stores.
23. Date formats change an event’s meaning
A localized certificate view presents a raw date without specifying time zone or whether the first number is day or month. Two audiences interpret the training deadline differently.
Regional formatting can improve readability, but only if conversion preserves the actual instant and makes the convention clear.
Keep stored timestamps unchanged. Format the display according to the documented locale and show time zone where a deadline could be ambiguous.
Verification exercise: Test dates on the first day of a month and across local midnight, comparing the original event time.
24. An import tool reports no errors but a resource is missing
A package upload returns success while one target-language audio asset is absent. The first lesson works, but a later safety module is silent.
Import success validates only part of the delivery chain. Dependencies, permissions and file presence still need explicit checks.
Create an asset manifest with required files and verify it after packaging. Include non-text media and accessible alternatives in the signoff process.
Verification exercise: Launch every SCO and inspect resource requests, especially language-specific media under nested paths.
25. A review mode overwrites a credited score
A learner reopens an already passed activity in review mode. A localized script triggers a scoring event and changes the recorded result.
The learner intended to inspect material, not retake a credited assessment. Mode-sensitive behavior is part of reliable educational reporting.
Document what each run-time mode permits and ensure localization does not change the condition that gates updates.
Verification exercise: Pass a course, reopen it in review mode, and verify that the previously earned result stays intact.
26. A course claims certification when prerequisites remain
The last translated screen congratulates learners with ‘Certified’ even when an upstream required SCO remains incomplete or a supervisory approval is pending.
SCORM course completion, examination success and organizational certification may be different decisions owned by different systems.
Make the end screen state the result it can truly know. Explain any further administrative steps without implying they have happened.
Verification exercise: Inspect the SCO result, rolled-up course state and downstream award workflow for a partially satisfied learner.
27. Marketing says ‘SCORM compliant’ without evidence
A course provider publishes a local-language brochure claiming universal SCORM compliance after testing only the HTML pages.
A functioning page does not establish packaging, runtime or sequencing conformance. The claim can mislead customers whose LMS behaves differently.
State the actual edition, tested LMS environments and test scope. Use available conformance tools where appropriate and do not overclaim certification.
Verification exercise: Retain test reports and confirm import, launch, reporting, sequence and resume in each advertised environment.
28. Localized legal training changes a governing rule
A compliance course is adapted for a new country. The translator replaces a legal term with a superficially similar local one without expert assessment.
Regulations, permissions and sanctions differ by jurisdiction. Language equivalence does not prove legal applicability or transfer professional responsibility.
Separate translation from regulatory adaptation. Ask a competent local reviewer to approve claims and clearly mark jurisdiction-specific content.
Verification exercise: Trace every legal claim to an authoritative source for the destination and keep a dated content-review record.
29. A learner cannot see why the attempt failed
An LMS sends failed and completed states, but the localized message only says ‘Unsuccessful’ without explaining whether retry is permitted.
Learners need a useful next action, while the message must not invent permissions that the course design does not grant.
Write context-aware status messages describing the outcome and allowed follow-up. Keep retake policy controlled by the proper LMS settings.
Verification exercise: Test failed attempts with retries enabled and disabled. The translated wording should distinguish both experiences.
30. A package update overwrites the only working course
A team imports a localized revision directly into a live course without keeping a baseline. The new package changes SCO references and older learners cannot resume.
Publication is a deployment event. It can alter learner state and course availability independently of whether the translation itself is accurate.
Test in staging, keep backups and plan migration or separate course versions when learner state requires protection. Document rollback steps.
Verification exercise: Resume a test learner from the old version under the intended migration plan before any production change.
Eight questions that make translation safer
What exactly is translatable?
Read the file and application context before extracting strings. Titles, captions, narration, learner prompts and understandable error descriptions are natural candidates. Resource IDs, cmi element names, namespace URIs, package controls and score values are not a free-text translation surface. Some names have both a machine and a display representation; edit the latter through the authorized format.
Create a small side-by-side table with source string, context, owner, allowed change and test. That table does more to prevent breakage than a generic instruction to avoid technical terms.
What does the LMS calculate?
Determine whether a displayed result comes from a SCO, the course sequencing engine or another organizational workflow. SCORM 2004 can distinguish progress, completion, success and objective status. A dashboard that mixes them is misleading regardless of translation quality.
For each result message, record its exact field and the conditions under which it appears. Test it against values that differ: finished-but-failed, partly-complete, passed-with-prerequisites, and unknown.
How does a browser return?
Resume depends on what state was actually committed and how the SCO interprets it. Different locales might load different content bundles, and changing the bundle can alter page numbering or internal bookmarks. A reader sees this as a broken resume even when the LMS saves data successfully.
Maintain stable logical references where possible. If a localized course needs different pagination, design a deliberate state mapping and verify real interrupted attempts.
Where should local examples change?
A culturally understandable example is useful only when it teaches the same concept. This matters for financial scenarios, medical wording, workplace safety and regulatory training. Superficial replacement of names and measurements can alter what is true or what the question actually asks.
Review the instructional claim, not just the language. Document why a new example is equivalent or why a jurisdiction-specific course edition is required.
What can testing actually prove?
An XML validator can detect certain structural problems, while a real LMS exercise can expose broken launch paths, field names or sequencing. Accessibility checks reveal yet another class of defect. None of these checks proves all the others.
Combine document validation, package audit, runtime tracing, native-language learner review and LMS transcript reconciliation. Keep the limitations of each test explicit.
How should teams handle mixed support?
Some organizations must deliver the same course to several LMS platforms with different behaviors. A narrowly tested source package might require platform-specific adjustments. Translators should not conceal that practical limitation behind broad compatibility claims.
Maintain a versioned matrix of target locales, package revisions, LMS versions, browsers and confirmed behaviors. If unsupported, state the limitation precisely and avoid promising equivalence.
How can source and target remain auditable?
Maintain the approved source, localized assets, human review notes, changed files, test results and release version. This audit trail should be useful when a learner challenges a score or a compliance officer asks which course version was delivered.
Keep personal records out of localization workspaces. Use fabricated learner accounts for routine tests and restrict access to production evidence.
What does quality mean beyond grammar?
A readable course may still have broken navigation, insufficient captions, wrong scores or unsafe instructions. Conversely, a technically valid package can sound stilted and confuse readers. Quality is the combination of human understanding, pedagogical equivalence, accessibility and correct software behavior.
Define acceptance criteria for each dimension and appoint appropriate reviewers. No single spell checker, validator or LMS import success should stand in for the whole evaluation.
A four-week learning and implementation plan
Week 1 — Inventory the course and its rules
Export a baseline and identify the SCORM edition. List imsmanifest.xml, organizations, items, resource references, each SCO, assets, sequencing settings and run-time data used by the lessons. Write the original learning objectives and score interpretation before translating. Capture one complete and one incomplete test attempt in the target LMS.
Week 2 — Translate instructional material in context
Work through titles, instructions, media, assessments and feedback, including accessible alternatives. Preserve the XML identifiers, runtime field names and schema structure. Ask subject experts to review any altered examples or law-related information. Keep exact-file changes documented so the package can be rebuilt reliably.
Week 3 — Test package, runtime and learner journey
Validate the XML and archive layout, import into a clean staging LMS and launch every SCO. Test failed and passed attempts, incomplete and completed outcomes, progress measures, sequencing restrictions, bookmarks and resumption. Ask a native-language learner to complete the course without knowledge of the original interface.
Week 4 — Release with evidence and rollback
Approve the final package only after language, engineering, accessibility and instructional checks agree. Publish tested version information and known limitations. Retain a previous working package, plan how existing enrollments will be handled and monitor early learner reports. Keep learner records private and maintain reproducible defect notes.
Frequently asked questions
Is SCORM 2004 the same as SCORM 1.2?
No. It uses a different runtime API and data model, with separated completion and success and sequencing features. Check the edition before translating technical instructions.
What is imsmanifest.xml?
It is the package’s structural description of organizations, activities and resources. Some text is for readers, while identifiers and links are for software.
May I translate a SCO identifier?
Not as ordinary text. Treat machine identifiers as protected and translate the permitted visible title or description.
Why is ‘complete’ not ‘passed’?
Completing assigned activity and meeting a mastery threshold answer different questions. A learner may do one without the other.
Does a successful zip import prove localization works?
No. The learner must still launch, navigate, save progress, receive feedback and produce the intended LMS record.
What happens when a course uses prerequisites?
Sequencing rules determine which activities are eligible. The translated menu needs to explain that behavior without silently changing it.
Should a translator alter JavaScript API names?
No. Preserve normative call names and cmi field identifiers. Translate the human-facing strings around them.
Can a translated course change legal examples?
Only with appropriate instructional and jurisdictional review. A fluent translation alone does not establish that a local rule applies.
What is the minimum useful QA?
Package validation, a real LMS launch, completion and failure cases, sequencing tests, resume, accessibility and target-language comprehension review.
Where can I study neighboring formats?
SCORM has distinct responsibilities from xAPI, cmi5, Common Cartridge and LTI. Read each format’s guide before borrowing its assumptions.
Authoritative references and related reading
For original edition details and 4th Edition changes, consult SCORM 2004 Fourth Edition background and the ADL SCORM 2004 Fourth Edition test-suite source. Use the actual edition and implementation documentation shipped with your LMS to interpret its test outcomes. No external tool can guarantee compatibility with all platforms merely by opening the package.
Related eduKateSG guides: xAPI learning statements; Common Cartridge course packaging; narrow SCORM course-menu QA; and the Translate Like a Pro index. These serve complementary tasks; this article covers the end-to-end SCORM 2004 Fourth Edition contract.