ChoiceScript Translation: Scenes, Choices and QA

How do you translate and localize ChoiceScript projects professionally without breaking the experience? This complete ChoiceScript localization guide explains the actual text and language mechanisms, how to make the interface understandable across countries, and how to test the final release. It is written for interactive-fiction authors, language editors, accessibility reviewers and developers planning lawful multilingual ChoiceScript releases. You can follow the decisions in order and use the troubleshooting section when a real game behaves differently from its translated source files.

The essential platform distinction is this: ChoiceScript authors narratives in text scene files with commands such as *scene_list, *choice, *if and *goto. Translation must protect that executable structure. Teams may prepare separately maintained language editions or another specifically engineered text-resource layer; a universal built-in locale-catalog feature should not be assumed. A working language file is only one part of a usable product. A player has to see the correct message, understand the available action, and receive the intended result. Before committing to several languages, confirm the toolchain and release format for the version of ChoiceScript your project actually uses.

This guide follows a civic-choice story in which a town officer must allocate a public water budget, answer a council question and decide whether to open a temporary shelter. It covers translation scope, text identities, interface wording, language selection, content revisions, real-player testing and delivery checks. The practical objective is source code commands, internal scene names, label targets, variable identifiers, indentation and numeric state are not free-form prose; different wording must not silently introduce different branch logic. You will also find a four-week rollout, a symptom-first fault finder and frequently asked questions for teams preparing their first multilingual edition.

Quick answer: the reliable localization route

Identify the player-visible content and all non-translatable program identifiers in ChoiceScript.
Create stable source references and give translators scene, speaker and decision context.
Translate complete meanings, not disconnected words; protect variables, logic, format markers and resource keys.
Test each choice and message in the actual running product in a supported target language.
Package the complete release and keep evidence of source version, language coverage, fallback and player outcomes.

Contents and how to use this guide

What a translated game must preserve
A worked story and the language-versus-logic boundary
Twenty-five practical decisions from source preparation to distribution
A symptom-first troubleshooting reference
Three complete player journeys and a testing matrix
A four-week plan, reader questions and primary documentation

ChoiceScript: what language changes and what must remain the same

In our running example, a civic-choice story in which a town officer must allocate a public water budget, answer a council question and decide whether to open a temporary shelter. A translator is not merely replacing captions. The words must give the player enough information to decide what to do next, but not more information than the original game intended. A menu term, a puzzle clue and a conditional response may all need different review methods, even if they share a word in English.

Consider this specific source moment: If the visible choice says ‘Ask the council for a delay’, the translated option must still lead to the delay branch. Translating an internal *goto label or changing indentation could make the game follow another route or fail altogether. This demonstrates the core boundary: language communicates a decision while program state controls its consequences. If you preserve only the visible words, readers may receive natural prose that leads to a wrong outcome. If you preserve only code, they may receive an accurate branch with an incomprehensible choice. Both must agree.

A useful small-scale trial is one route through the game: first launch, language selection, an instruction, a decision, a state change, a surprising result, recovery and a saved-session return. Choose one target language with a competent human reviewer. Keep the source-language journey beside it. A successful comparison is not identical sentence length; it is equivalent information, choice and outcome.

ChoiceScript localization: twenty-five implementation decisions

1. Choose a legitimate publication route first

ChoiceScript’s public source license distinguishes permitted noncommercial activity from commercial use. Translation and redistribution plans can raise rights questions separate from linguistic quality.

For a practical first pass, Read the current license and get appropriate authorization for the engine and narrative content before advertising a downloadable or commercial localized edition. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

A flawlessly translated story does not create redistribution permission. Keep legal review distinct from the text-quality gate and avoid providing unsupported licensing assurances. The editorial review should ask what a reader will infer at precisely this moment. Check the surrounding scene and whether the text introduces a new fact or a new obligation. A translation that reads smoothly in isolation can still give the wrong instruction during play.

2. Understand scene files as executable narrative

A ChoiceScript scene combines paragraphs that a reader sees with commands that control branching and persistent state. Translating every line indiscriminately destroys the program.

On a small project, Make a copy of the source and annotate which lines are display text, player options, directives, identifiers and comments. Decide the allowed editing scope for translators. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

A word that looks like English in a *goto target may still be a machine identifier. Require the game to parse and run after every localization change. Check the full path from source data through language selection to the running interface. A file may contain the right phrase while a cache, scene property or compiled artifact continues to display an older version. Name the exact location and build when reporting a discrepancy.

3. Keep startup.txt structurally sound

The startup scene establishes game metadata, sequence and persistent variables. Its commands are not merely introductory wording.

To make this operational, Compare *title, *author, *scene_list and *create entries before and after localization; translate reader-facing titles only where appropriate. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Changing the scene list or creating a different variable set between editions can change available game routes. Verify that initial state is equivalent across languages. Treat author intent and player behavior as separate checks. The original author should confirm the meaning, while a target-language reader should explain what action they expect to take. Agreement between those two observations is stronger evidence than a word-for-word comparison.

4. Preserve the scene list and filenames

Scene transitions rely on scene identifiers and file organization. A localized chapter heading shown to the reader is not the same as the file named in a scene list.

In the working story, Keep filename and scene-list mappings stable unless the program deliberately supports mapped variants and tests them. Let visible headings carry the translation. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

A renamed scene in display text is harmless, but a renamed executable scene target can break *finish progression or *goto_scene. Run through the complete chapter sequence. When several languages are supported, repeat the same state and control sequence in each one. A translation should not change hidden game values or which choices are available. If the text is deliberately adapted, record why the player’s understanding remains equivalent.

5. Do not translate command keywords

ChoiceScript uses command tokens such as *choice, *set, *if, *elseif, *goto and *finish. These form the scripting language and are not English prose.

For a practical first pass, Provide a protected-code list in the translation brief. Use an editor diff that flags changed directive names while allowing surrounding narrative text to vary. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Replacing a command with an apparent target-language equivalent can cause parser errors. Validate syntax immediately rather than finding the problem only at the ending. The editorial review should ask what a reader will infer at precisely this moment. Check the surrounding scene and whether the text introduces a new fact or a new obligation. A translation that reads smoothly in isolation can still give the wrong instruction during play.

6. Respect indentation under choice branches

Indentation is part of the syntax that distinguishes nested actions and options from parent text. Translated strings may wrap visually without changing source indentation.

On a small project, Use a plain-text editor that preserves leading spaces. Show translators examples of translated option labels that leave their child command blocks in place. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

A single misplaced indent can attach a consequence to the wrong choice. Compare branch depth and run the affected choice path after each structural edit. Check the full path from source data through language selection to the running interface. A file may contain the right phrase while a cache, scene property or compiled artifact continues to display an older version. Name the exact location and build when reporting a discrepancy.

7. Translate # option labels as promises

A # line below a *choice is what the player believes they are selecting. It may be short, but its pragmatic meaning is central to fair gameplay.

To make this operational, Explain the next branch action in a note and ask translators to preserve commitment, risk, uncertainty and politeness level. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

If the source option is ‘Consider opening the shelter’ and the target says ‘Open the shelter now’, the player is not making the same decision. Treat author intent and player behavior as separate checks. The original author should confirm the meaning, while a target-language reader should explain what action they expect to take. Agreement between those two observations is stronger evidence than a word-for-word comparison.

8. Keep conditional logic independent of language

A *if expression checks game state, not localized wording. Stable numeric and Boolean conditions should decide whether a route becomes available.

In the working story, Test the same variable state against each edition and compare visible options and outcomes. Do not insert translated sentences into condition identifiers. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

A culturally adapted explanation is acceptable; a different threshold or hidden condition is a design change. Log deliberate adaptations rather than slipping them into translation. When several languages are supported, repeat the same state and control sequence in each one. A translation should not change hidden game values or which choices are available. If the text is deliberately adapted, record why the player’s understanding remains equivalent.

9. Protect *goto labels and jumps

Labels are destinations inside a scene. A visible chapter heading may change but a *goto reference must match the intended *label.

For a practical first pass, Validate every jump target with automated tests and a scene-level link map. Preserve internal labels unless a coordinated code migration updates all references. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

A dialogue that seems correct on the default route may crash after a rare option because a translated label was changed in only one location. The editorial review should ask what a reader will infer at precisely this moment. Check the surrounding scene and whether the text introduces a new fact or a new obligation. A translation that reads smoothly in isolation can still give the wrong instruction during play.

10. Separate variable names from their displayed values

A variable can represent money, relationships, safety or public trust. Its name is a program symbol; the phrase used to describe it to the reader is prose.

On a small project, Maintain an invariant variable schema and a separate glossary of readable labels. For example, keep a trust statistic numerically identical while translating its screen caption. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Do not localize the source identifier and silently create a new variable. The visible statistic might look right while branching checks the old one. Check the full path from source data through language selection to the running interface. A file may contain the right phrase while a cache, scene property or compiled artifact continues to display an older version. Name the exact location and build when reporting a discrepancy.

11. Control interpolated names and values

Stories often insert player-provided names, numbers or pronouns into sentences. Other languages may require changes in word order and agreement.

To make this operational, Test target sentences with short and long names, unexpected punctuation, and several grammatical forms. Where a single template is impossible, write authorized contextual alternatives. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Never assume that concatenating translated fragments will be grammatical. A readable full sentence is preferable to forcing source-language order. Treat author intent and player behavior as separate checks. The original author should confirm the meaning, while a target-language reader should explain what action they expect to take. Agreement between those two observations is stronger evidence than a word-for-word comparison.

12. Review tense and reference across scenes

A choice may be mentioned later as a past event. Target-language grammar must preserve whether a promise, completed action or hypothetical branch is being described.

In the working story, Create a chronology table for the civic budget decision and inspect the later council meeting in each meaningful branch. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

A translation that reports an unmade choice as completed confuses continuity even when the underlying variables are correct. When several languages are supported, repeat the same state and control sequence in each one. A translation should not change hidden game values or which choices are available. If the text is deliberately adapted, record why the player’s understanding remains equivalent.

13. Treat statistics screens as part of localization

Readers consult stats to understand character traits, relationships and consequences. Labels, help text and explanation are a language surface, while quantities remain shared game data.

For a practical first pass, Inventory the stats screen separately from narrative chapters. Confirm labels make sense after each major choice and numeric indicators retain their defined meaning. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Changing a percentage or scale threshold is not translating the statistic. Compare data before and after each locale test. The editorial review should ask what a reader will infer at precisely this moment. Check the surrounding scene and whether the text introduces a new fact or a new obligation. A translation that reads smoothly in isolation can still give the wrong instruction during play.

14. Distinguish source prose from code comments

Comments can be useful instructions to translators or developer-only explanations. Changing them may be allowed, but they should not leak into reader-visible copy accidentally.

On a small project, Define an annotation convention and instruct reviewers which notes are context, which are source text and which must stay attached to commands. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

If a translator mistakes a comment for a visible sentence, the delivered game may contain gaps while the spreadsheet appears complete. Check the full path from source data through language selection to the running interface. A file may contain the right phrase while a cache, scene property or compiled artifact continues to display an older version. Name the exact location and build when reporting a discrepancy.

15. Keep multiple language editions synchronized

Without a guaranteed turnkey localization table for every ChoiceScript project, separate editions are a pragmatic method but require disciplined state and code parity.

To make this operational, Keep one canonical gameplay logic baseline; apply approved prose changes into each language branch and compare scene names, commands and variable initialization. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Parallel manuscripts can drift. A bug fixed in only one language is not a translation issue alone; it is a release governance problem. Treat author intent and player behavior as separate checks. The original author should confirm the meaning, while a target-language reader should explain what action they expect to take. Agreement between those two observations is stronger evidence than a word-for-word comparison.

16. Define what may be culturally adapted

Historical institutions, forms of address and civic terminology may not have one-to-one equivalents. A translator may need explanation rather than substitution.

In the working story, Prepare a world glossary distinguishing fictional institutions from real legal terms and flag where the narrative’s stakes must remain unchanged. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Renaming a fictional office is different from claiming a real authority would behave the same way. Preserve the story’s fictional boundaries. When several languages are supported, repeat the same state and control sequence in each one. A translation should not change hidden game values or which choices are available. If the text is deliberately adapted, record why the player’s understanding remains equivalent.

17. Handle Unicode and visual presentation

ChoiceScript may run within browser-based interfaces whose fonts and input behavior vary. Text data being Unicode is not proof that every writing system is readable.

For a practical first pass, Open actual target-language scenes in supported browsers and devices. Test quotes, diacritics, non-Latin names, long buttons and right-to-left input where intended. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

A branch can be syntactically valid yet visually unusable. Evaluate touch targets, reading order and text scaling on small screens. The editorial review should ask what a reader will infer at precisely this moment. Check the surrounding scene and whether the text introduces a new fact or a new obligation. A translation that reads smoothly in isolation can still give the wrong instruction during play.

18. Plan for saved games across editions

Saved state may contain variables and scene positions associated with a particular story version. Switching language editions can be more complex than switching a label.

On a small project, Declare whether cross-edition saves are supported, then test explicit migration or separate saves. Record a clear user warning if continuity is not guaranteed. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Do not promise seamless locale switching when the storage model has not been validated. Protect the player’s ability to finish a game already in progress. Check the full path from source data through language selection to the running interface. A file may contain the right phrase while a cache, scene property or compiled artifact continues to display an older version. Name the exact location and build when reporting a discrepancy.

19. Use QuickTest to catch structure errors

ChoiceScript has testing utilities that can help check scenes and commands without manually choosing every path. Structural validation is essential after a translation round.

To make this operational, Run the project’s documented QuickTest workflow on each language edition and inspect reported failures, including malformed choice blocks. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

QuickTest passing does not prove natural translation, but failure is a release blocker. Pair automated syntax checks with human route reading. Treat author intent and player behavior as separate checks. The original author should confirm the meaning, while a target-language reader should explain what action they expect to take. Agreement between those two observations is stronger evidence than a word-for-word comparison.

20. Use RandomTest for branch exploration

Automated route exploration can expose combinations that a linear playthrough misses. Different locales should not introduce different story paths accidentally.

In the working story, Run RandomTest with documented settings and record failures, unreachable scenes and the distribution of tested routes. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Random route coverage cannot replace judgment about story meaning. Compare decisions and consequences from a small set of representative paths. When several languages are supported, repeat the same state and control sequence in each one. A translation should not change hidden game values or which choices are available. If the text is deliberately adapted, record why the player’s understanding remains equivalent.

21. Verify endings and restart flow

The final scenes often contain the most important consequences. They can also be the least tested because players take a long time to reach them.

For a practical first pass, Prepare saved or test-start states for each ending category, inspect ending text and test the restart or play-again experience. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

An untranslated ending is not a harmless low-priority string. It is often the player’s strongest memory of the experience. The editorial review should ask what a reader will infer at precisely this moment. Check the surrounding scene and whether the text introduces a new fact or a new obligation. A translation that reads smoothly in isolation can still give the wrong instruction during play.

22. Review accessibility for reading-heavy play

Interactive fiction relies on sustained reading. Paragraph structure, focus order, keyboard controls and screen readability are core features rather than optional cosmetics.

On a small project, Test with larger browser text, keyboard-only navigation and assistive technology where relevant. Verify that choice labels remain understandable out of context. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Translated text that exceeds a control’s layout or loses heading semantics may bar a player from participating despite accurate prose. Check the full path from source data through language selection to the running interface. A file may contain the right phrase while a cache, scene property or compiled artifact continues to display an older version. Name the exact location and build when reporting a discrepancy.

23. Track translation coverage by scene and route

Simple line counts can hide untranslated rare branches. The coverage report should make narrative reachability and consequence importance visible.

To make this operational, Group coverage by scene, decision path, stats screen and ending. Mark source-only fallback explicitly and recruit reviewers for the lowest-coverage routes. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

A 95-percent text coverage figure can still conceal the game’s entire final chapter. Do not let aggregate numbers replace route review. Treat author intent and player behavior as separate checks. The original author should confirm the meaning, while a target-language reader should explain what action they expect to take. Agreement between those two observations is stronger evidence than a word-for-word comparison.

24. Protect authorship and editorial intent

Interactive fiction includes voice, pacing, deliberate ambiguity and moral framing. A translation can be factually correct while steering players toward a different interpretation.

In the working story, Use a character voice guide and ask the original author to approve changes involving implied consent, blame, duty and uncertainty. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

Never make a morally difficult option sound obviously correct or wrong unless the source intends that emphasis. When several languages are supported, repeat the same state and control sequence in each one. A translation should not change hidden game values or which choices are available. If the text is deliberately adapted, record why the player’s understanding remains equivalent.

25. Ship an auditable edition

A world-facing release should identify the authorized story version, engine version, language edition, tests and limitations. Readers need a reliable text experience.

For a practical first pass, Archive source diffs, automated test results, reviewer notes and a short supported-language statement. Test the same downloadable or hosted package users receive. Start with one identifiable screen, scene, file or dialogue line rather than changing the entire project. Keep a short record of the input, the selected language, the expected player response and the result you actually observed. This creates a reproducible test of the decision rather than a subjective impression that the words sound good.

A passing local preview cannot prove distribution works. Check public deployment, browser behavior, rights and accessibility in the final route. The editorial review should ask what a reader will infer at precisely this moment. Check the surrounding scene and whether the text introduces a new fact or a new obligation. A translation that reads smoothly in isolation can still give the wrong instruction during play.

A practical review of three complete player journeys

1. The first five minutes

Open a clean build of the ChoiceScript project with no saved preferences. Invite someone who reads the target language but does not know the game’s source dialogue. Ask them to select a language, interpret the opening instruction, navigate the first choice and describe what they believe just happened. Observe hesitation rather than correcting it. Record the wording, the corresponding program state and whether the player reached the intended destination. If the test fails, distinguish an inaccurate sentence from an inaccessible control or missing language resource.

Pass when the reader can identify the language, perform the first meaningful task, understand the result and return to the menu without coaching. Keep the exact steps, language, expected action, screenshot or excerpt, and source revision in the review record so another tester can reproduce the journey.

2. A consequential decision

Use the central decision in a civic-choice story in which a town officer must allocate a public water budget, answer a council question and decide whether to open a temporary shelter. Create two controlled test states that differ in one relevant flag or variable. In the source and target languages, present the same available options and ask the reviewer to predict the consequences before choosing. Then execute the action and compare branch destinations, values, explanations and later references. Review whether any option sounds mandatory when it is actually tentative, or harmless when it carries a cost.

Pass when the translated choice communicates the same commitment and the same intended state transition, even where sentence structure is different. Keep the exact steps, language, expected action, screenshot or excerpt, and source revision in the review record so another tester can reproduce the journey.

3. Failure, recovery and returning later

Begin from a previously saved session shortly before an error or blocked action. Resume in the target language, read the warning, take a recovery route and complete the next scene. Where the design permits language switching, repeat the transition once during the same session and look for stale captions, audio or labels. Finally reinstall or reload the distributed build in a clean profile to verify assets do not depend on an editor-only path.

Pass when the player recovers without losing the intended state, can interpret every critical warning and sees the promised language in the actual release. Keep the exact steps, language, expected action, screenshot or excerpt, and source revision in the review record so another tester can reproduce the journey.

ChoiceScript troubleshooting: symptoms, causes, repairs and proof

1. The localized story fails to start

A command keyword, scene name or startup structure may have been translated accidentally. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Diff directive lines and startup.txt against the canonical program, then rerun QuickTest. Load the opening chapter and proceed to the next scene. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

2. A choice selects the wrong outcome

Source indentation or conditional branches may have shifted. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Inspect the option block boundaries and restore exact executable structure. Choose the same option in both languages and compare state values. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

3. An ending crashes

A rare *goto or *goto_scene target was renamed or removed. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Trace the jump target and run RandomTest plus a focused ending-path test. Reach the affected ending from a legal in-game state. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

4. A stats label changed but its value did not

This may be expected: display wording is separate from numerical game state. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Confirm the intended statistic, then compare the underlying value and its translated description. Check that choices still update the same statistic. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

5. The player reads a choice as a different commitment

The target wording altered modality or degree of obligation. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Revisit the subsequent action and retune the verb or condition with a translator. Ask a new player what they expect before selecting it. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

6. A source edit appears in only one language

Parallel edition branches have diverged. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Compare canonical narrative source and localized counterparts with scene-by-scene change tracking. Verify the changed event and its consequences in every supported edition. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

7. A translated name breaks grammar

The surrounding sentence cannot accommodate arbitrary name forms. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Recast the complete sentence or use authorized grammatical variants. Test several names and honorifics with native reviewers. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

8. A mobile option overflows the screen

The target choice is longer and the browser layout lacks room. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Review wrapping, focus visibility and font scaling. Select the longest option on a small touch device. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

9. Saving in one edition does not restore in another

Stored scene and state format may not be compatible across editions. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Declare cross-edition behavior honestly; implement and test migration only if required. Restore known saves and verify scene, variables and options. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

10. QuickTest passes but readers are confused

Syntax correctness does not measure implied meaning, tone or fairness. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Arrange target-language decision interviews and compare expectations with actual outcomes. Have a reviewer narrate their decision reasoning before clicking. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

11. RandomTest exposes a missing branch

A conditional or variable initialization differs between language versions. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Align executable logic with the canonical program and rerun branch exploration. Compare reachable endings under equivalent starting conditions. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

12. A displayed title is untranslated

The title or stats screen may live outside the main narrative paragraphs. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Inventory game metadata and presentation surfaces, then localize only visible values. Check title, restart and stats views in the hosted edition. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

13. Non-Latin text appears as squares

The deployment font or browser stack lacks necessary glyph support. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Test a suitable font and inspect text rendering in supported browsers. Read a complete translated chapter rather than a short menu. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

14. A publisher questions rights for an edition

Translation permission, engine license and distribution rights were not checked separately. Start by checking the actual user-facing state and locating the last point where the correct translation or correct branch was observed. This distinction matters because a linguistically sound target sentence may not have been selected by the runtime at all.

Review the current ChoiceScript license and story rights before releasing a derivative edition. Document the permission route; do not infer it from technical access. Record the precise locale, screen or story position, build identity and whether the defect reproduces after a clean start. A correction is accepted only when the relevant player action works, not merely when an editor warning disappears.

A language-quality testing matrix that goes beyond string counts

Meaning and decision

Review a direct instruction, a tentative request, a refusal and a consequential choice in a civic-choice story in which a town officer must allocate a public water budget, answer a council question and decide whether to open a temporary shelter. Ask a native-language reader to paraphrase each action before execution. Similar words are not required, but the degree of obligation, knowledge and risk must remain accurate.

For acceptance, record the exact test state and its observed result. Separate linguistic defects from interface faults, stale data, missing assets and changed gameplay. These distinctions tell the team who should repair the issue and whether the next release must be blocked.

State and branch parity

Capture a small set of authoritative game-state values before and after important choices. Confirm that language changes the presentation, not the action’s hidden effect. Where a local adaptation intentionally changes puzzle design, treat it as a tested product variant rather than an unrecorded linguistic correction.

Typography and device behavior

Use the longest approved target-language menu label, a phrase with accented or non-Latin characters, a number embedded in prose and punctuation at the end of a line. Test actual fonts, direction, wrapping, focus and readability on supported devices.

Missing translations and fallback

Select one deliberately missing noncritical string in a test build and confirm the declared fallback. Confirm that missing critical warnings and options are reported as release blockers. A visible English fallback should never be counted as a completed translation.

Release packaging and accessibility

Install from the same artifact the public receives. Repeat the first meaningful interaction without editor data or local caches, then test keyboard and touch navigation as appropriate. Use a reader who can report confusion, not only a script that sees successful file loading.

Four-week ChoiceScript localization and validation plan

Week 1: source map and controlled scope

Confirm rights, define a canonical gameplay branch and mark protected command lines; create a scene/branch map and select the supported edition strategy.

The week’s exit test is an actual player journey with a named source version and target language. Capture what passed and what remains incomplete. Keep the scope small enough to review fully; adding a language name to a menu is not a substitute for tested comprehension. The plan should be adapted to the team and game’s scale, not treated as a promise that every project can finish in exactly four weeks.

Week 2: first complete target-language experience

Translate one complete path with source notes, validate startup and scene structure, and run QuickTest after each substantive scene merge.

Week 3: coverage, variation and repair

Translate remaining options and endings, align variables and labels, run RandomTest and test mobile reading and saved-state policy.

Week 4: release proof and maintenance

Review major moral choices with native readers, verify permissions, package or host the authorized edition, and archive test evidence per language.

ChoiceScript localization: frequently asked questions

Can I translate every line of a ChoiceScript file?

No. Scene files contain executable commands and identifiers as well as display text. Translate narrative paragraphs and option labels while protecting syntax, indentation, labels and variable names.

For this particular project, the best next step is to test the answer against the real scene and release configuration. Preserve the source meaning and verify what the player actually experiences rather than relying on a file existing or a setting appearing in an editor.

Is there a built-in multi-language CSV feature?

Do not assume a universal turnkey catalog mechanism for every ChoiceScript project. Decide whether you will maintain separate language editions or engineer a resource layer and test its runtime behavior.

Why is indentation so important?

ChoiceScript uses indentation to organize branches and consequences. Changing it can alter which actions occur after a selection even when all visible wording sounds reasonable.

Should I translate scene filenames and variable names?

Generally preserve executable identifiers. Localize reader-facing labels and headings separately unless a coordinated code change updates all references and passes tests.

How do QuickTest and RandomTest help?

They help detect structural problems and explore branching behavior. Neither can certify that every translated choice gives readers the same understanding, so add human decision testing.

Can a save game move between languages?

Only if your edition architecture deliberately supports it and testing confirms state compatibility. Otherwise explain the limitation rather than implying a safe cross-edition switch.

Does distributing a translated edition require permission?

Rights to the story and rights to the engine are distinct. Read the current ChoiceScript license and obtain necessary authorization before commercial or other restricted redistribution.

How can I test fairness of translated choices?

Ask a new target-language reader what action each option promises before clicking it, then compare that prediction with the actual branch consequence and original design intention.

Primary documentation and further reading

These are technical starting points rather than substitutes for version-specific testing. The workflow above combines the documented behavior of ChoiceScript with editorial and release practices. Always confirm features against the actual version of the game engine or library that will ship.

For the broader principles of transferring meaning across languages, see Master Art of Translation: The Complete System. For other tool-specific implementations, use the Translate Like a Pro series index. This guide focuses on ChoiceScript projects; it is not a substitute for general literary translation advice or unrelated language-learning articles.

Final release standard: a player can understand, decide and recover

The purpose of localization is not to increase the number of entries in a file. A successful edition lets a reader choose a language, understand a meaningful situation, make the intended decision and recognize its result. For ChoiceScript, that requires text, resource identities, program logic, rendering and delivery to agree. Maintain honest coverage records, preserve the author’s intentions and repeat the same player journeys after changes.

Translate Like a Pro | 7050 — ChoiceScript Scene Translation, Choices, Variables, Branch Testing and Multilingual Edition QA