Construct 3 Localization Guide

Construct 3 localization is the process of making a game’s menus, instructions, rewards and errors understandable in different languages while keeping event-sheet behavior unchanged. This Construct 3 translation guide explains the official Internationalization plugin, JSON language files, AJAX resource loading, Lookup, LookupPlural, locale switching, substitution arguments, date and number formatting, and exported-game testing. It is aimed at creators who want practical implementation rather than a generic translation checklist.

The official Construct manual describes a dedicated Internationalization object. A language JSON file needs a strings object, can include a locale tag, and can be loaded through an AJAX request followed by the Internationalization Load from JSON action. The documented Lookup and LookupPlural features handle ordinary keys and locale-sensitive counting messages. Those features help, but they cannot decide whether an instruction is accurate or guarantee every device displays the translated text correctly.

Imagine a puzzle adventure called Signal Garden. The player chooses a language, collects seeds, uses energy to repair relays and reads warnings before resetting a level. We will use that one game to connect resource files, event sheets, object text, timed loading, dynamic values, plural grammar, locale preferences, export packaging and real player decisions. Every step should explain not merely what to click but why the resulting game remains trustworthy.

Quick answer: make Construct 3 localization work

Use the official Internationalization object and its documented actions.
Keep separate well-formed JSON resources with a required strings object.
Load locale files through a controlled asynchronous sequence; do not look up missing data.
Use Lookup for fixed keys and LookupPlural for locale-dependent counts.
Keep event-sheet state, IDs and purchase mechanics independent from translated copy.
Test language switching, fonts, exported files and real player decisions.

In the Signal Garden example, a player must know whether using energy is optional, how many seeds remain and whether resetting will erase progress. The translation succeeds only when those facts are conveyed correctly and the game follows them.

Understand the working architecture

Source strings communicate the rules; keys identify their purpose; language JSON maps keys to appropriate messages; the Internationalization plugin retrieves and formats them. Event sheets choose when and where the resulting text appears. The browser draws the characters while the game-state variables keep counts, unlocks and progress. Treat each as a different failure domain so the fix addresses the real cause.

This is a platform-specific implementation guide, not a substitute for the wider theory of translation, a general QA checklist or a review of third-party plugins. Always compare a working small example against the current official Construct documentation before adopting more elaborate patterns.

Step-by-step implementation and worked troubleshooting

1. Map every player-facing text object

The title screen has Start, Continue, Options and Clear Save, while the first puzzle displays an energy warning beside a moving relay. Begin with the actual player action rather than the translation file. A fluent sentence can still misrepresent the risk or next step. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Static labels and state-dependent event-sheet strings are different sources of text; a full inventory must include both, rather than exporting only obvious menus. Identify whether the problem comes from resource identity, asynchronous loading, text rendering or the event logic that controls the game. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Walk one complete gameplay path and record each Text object, event action and modal that supplies visible words; note conditions under which a message appears. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Switch the test build to another locale and verify every essential instruction and destructive action appears in that language. A pass must include a real action that confirms the UI sentence matched the underlying gameplay result. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

2. Add the official Internationalization object

A developer installs an unrelated third-party translation addon even though the project already includes the built-in Internationalization functionality. Treat a short label as a promise about behavior. The reader needs enough context to make a decision without knowing the source language. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Construct’s documented Internationalization plugin has particular expressions, actions and JSON expectations; instructions for a marketplace addon may use incompatible schemas. Do not repair a display bug by changing a game variable or a pricing condition; keep language resources separate from executable state. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Use the official plugin described by the current Construct manual and distinguish its object actions from any separate addon before implementing event sheets. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Create a minimal two-language demonstration with a single Lookup expression; it must work without relying on undocumented addon-specific calls. Check the failure condition as well as the expected path, because missing files and restarts reveal many hidden English literals. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

3. Design stable language keys

Two buttons say Open, one opens an inventory and another unlocks a paid shortcut; giving both a common key may create misleading wording. The practical risk is that a localization spreadsheet may look complete while a layout remains unusable to a real person. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

A key is an application identifier, not the visible English sentence; its stable purpose enables different target terms for different interface actions. Make the source, the resource revision and the triggering event observable so another developer can reproduce and review the fix. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Choose structured keys such as inventory.open and shortcut.unlock, and write a glossary for action consequences and currency names. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Translate each button in its actual screen and ask a tester to predict the result before pressing it. Testing should compare the same input and saved state under different locales, never two unrelated sessions. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

4. Create valid JSON string resources

A translator submits a file with a localized title but forgets the required strings object and the game cannot load the catalog. Meaning is a system property here: it depends on text, timing, values, layout and the action a control performs. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

The official plugin documentation specifies a required strings property, while locale is optional and must be a valid parsable language tag when provided. A good intervention changes as little as needed and leaves other event-sheet conditions alone, making regressions easier to detect. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Keep a language-specific JSON file with a strings object, valid key hierarchy and reviewed values; validate JSON syntax before loading it through the game. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Test a deliberately malformed file in a separate test build, then verify the production build reports or handles errors without presenting empty action buttons. Release only when a target-language player can explain the consequence of a choice and the exported build behaves accordingly. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

5. Choose consistent BCP 47 locale tags

One resource file is labeled pt_BR, another pt-BR and the project uses an informal language nickname in the selection menu. Begin with the actual player action rather than the translation file. A fluent sentence can still misrepresent the risk or next step. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Construct’s Internationalization system documents standard BCP 47 locale identifiers; inconsistent identifiers can break locale association and formatting expectations. Identify whether the problem comes from resource identity, asynchronous loading, text rendering or the event logic that controls the game. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Choose canonical tags such as en-GB and pt-BR, keep filenames and menu names mapped to those tags, and avoid inventing tags for unsupported custom categories. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Load each file, inspect the active locale and compare the intended regional number and date formatting. A pass must include a real action that confirms the UI sentence matched the underlying gameplay result. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

6. Load files with AJAX at the right time

A text object evaluates Lookup before the requested language file has completed downloading, so the player sees a missing key on startup. Treat a short label as a promise about behavior. The reader needs enough context to make a decision without knowing the source language. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

The documented pattern uses an AJAX request followed by Load from JSON when the request completes; network timing means the language table may be unavailable during layout creation. Do not repair a display bug by changing a game variable or a pricing condition; keep language resources separate from executable state. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Create an explicit ready state that waits for the requested catalog before populating translated text; provide a readable fallback if loading fails. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Throttle the test network and confirm the game never displays raw resource keys or lets a player commit to an unclear purchase. Check the failure condition as well as the expected path, because missing files and restarts reveal many hidden English literals. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

Catalogs, lookups and message structure

7. Handle the wrong AJAX response safely

The file request returns an HTML error page rather than JSON, yet the game passes that text to a JSON loader without checking its source. The practical risk is that a localization spreadsheet may look complete while a layout remains unusable to a real person. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

A successful event trigger and a valid language catalog are separate facts; wrong content types, missing files and stale paths can imitate translation errors. Make the source, the resource revision and the triggering event observable so another developer can reproduce and review the fix. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Check response success, expected resource identity and loader outcome before setting a catalog-ready flag; keep failure messaging independent of the missing catalog. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Remove the file in a test build and verify the user still understands the safe next action, without a silent transition into broken gameplay. Testing should compare the same input and saved state under different locales, never two unrelated sessions. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

8. Organize nested keys by feature

The same key name help appears in the title screen, puzzle tutorial and accessibility menu but means different information in each location. Meaning is a system property here: it depends on text, timing, values, layout and the action a control performs. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

The required strings object can contain nested JSON structures according to the application’s preferred organization; structure should reflect meaning rather than arbitrary spreadsheet order. A good intervention changes as little as needed and leaves other event-sheet conditions alone, making regressions easier to detect. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Group resources by menu, tutorial, objective, result and settings, and keep feature boundaries stable when more languages arrive. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Ask a translator to find every relay-specific message without reading event-sheet source code; missing or duplicate keys should be obvious. Release only when a target-language player can explain the consequence of a choice and the exported build behaves accordingly. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

9. Use Lookup for fixed messages

A menu refresh uses a hard-coded English string after the language switch, even though its initial title came from the resource catalog. Begin with the actual player action rather than the translation file. A fluent sentence can still misrepresent the risk or next step. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Lookup returns translated text for a specified key, but the application must call it whenever the displayed state changes or a view is rebuilt. Identify whether the problem comes from resource identity, asynchronous loading, text rendering or the event logic that controls the game. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Replace fixed display literals with catalog lookups at the point of presentation, while keeping state identifiers and event conditions in their original machine representation. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Leave and re-enter the options layout in two locales; menu text should remain localized after every transition. A pass must include a real action that confirms the UI sentence matched the underlying gameplay result. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

10. Use substitution arguments responsibly

The message says You have {0} seeds and the new translator accidentally removes the placeholder while moving the unit name. Treat a short label as a promise about behavior. The reader needs enough context to make a decision without knowing the source language. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

The plugin documentation describes numbered substitution tokens, which allow values to be inserted into translated messages in locale-appropriate positions. Do not repair a display bug by changing a game variable or a pricing condition; keep language resources separate from executable state. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Document what each argument means, preserve the exact placeholder syntax supported by the plugin, and never concatenate a source-language grammar fragment around a translated sentence. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Test zero, one and large seed counts with the same live inventory value; no raw placeholder must remain and the count must be correct. Check the failure condition as well as the expected path, because missing files and restarts reveal many hidden English literals. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

11. Use LookupPlural for counts

A prize dialogue displays 1 relays repaired and a target language uses different forms for counts that English treats alike. The practical risk is that a localization spreadsheet may look complete while a layout remains unusable to a real person. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Plural selection is language-dependent, and the plugin has a documented LookupPlural expression rather than relying on English string suffixes. Make the source, the resource revision and the triggering event observable so another developer can reproduce and review the fix. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Create the plural variants expected by the plugin and target locale, then pass the actual numeric count from the event sheet rather than a formatted label. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Verify 0, 1, 2, 5 and a larger count in relevant languages; compare message grammar and saved repaired-relay total. Testing should compare the same input and saved state under different locales, never two unrelated sessions. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

Numbers, time, purchase meanings and accessibility

12. Format numbers according to locale

The energy meter displays a decimal score, but the localized sentence and meter use different separators and imply different quantities. Meaning is a system property here: it depends on text, timing, values, layout and the action a control performs. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Internationalized presentation is distinct from game arithmetic; the same numeric game value can require a different localized display form. A good intervention changes as little as needed and leaves other event-sheet conditions alone, making regressions easier to detect. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Use available Intl-related formatting facilities documented for the plugin or browser and keep arithmetic variables numeric until the presentation layer. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Compare one authoritative numeric value displayed in two locales, then complete the same action and verify identical energy deduction. Release only when a target-language player can explain the consequence of a choice and the exported build behaves accordingly. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

13. Handle currencies and purchases accurately

The player buys an optional seed pack and a translated label calls it a free reward even though the associated purchase is unchanged. Begin with the actual player action rather than the translation file. A fluent sentence can still misrepresent the risk or next step. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

A translated shop label is an explanation of existing game economics and must not invent price discounts, availability or entitlements. Identify whether the problem comes from resource identity, asynchronous loading, text rendering or the event logic that controls the game. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Keep purchase logic and product identifiers outside the language resource; give translators context for cost, billing and confirmation wording. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Require a tester to explain the price and consequence before completing a simulated purchase; compare with actual transaction behavior. A pass must include a real action that confirms the UI sentence matched the underlying gameplay result. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

14. Format dates and time for the audience

A daily puzzle resets at a globally defined instant, but the local date label suggests the reset happened earlier for some players. Treat a short label as a promise about behavior. The reader needs enough context to make a decision without knowing the source language. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Timezone policy, stored timestamps and localized date formats are separate; translating month names cannot change the scheduled event. Do not repair a display bug by changing a game variable or a pricing condition; keep language resources separate from executable state. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Define the actual reset clock and format only its human-readable representation for the selected locale, with clear timezone wording when relevant. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Test just before and just after reset from two device timezones; the game should offer the same eligibility for the same actual time. Check the failure condition as well as the expected path, because missing files and restarts reveal many hidden English literals. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

15. Implement a reliable language menu

The user changes language while a pause dialog remains open, but only the background screen updates and the dialog stays in English. The practical risk is that a localization spreadsheet may look complete while a layout remains unusable to a real person. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Language changes need an intentional refresh of every visible translated Text object and any cached result, not only the screen first drawn at startup. Make the source, the resource revision and the triggering event observable so another developer can reproduce and review the fix. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Store the selected locale in one place, reload or select the matching catalog, then refresh active overlays, dialogs and late-created objects once data is ready. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Change language with the settings screen, a tooltip and the pause dialog visible; no component should remain stale unless clearly marked unavailable. Testing should compare the same input and saved state under different locales, never two unrelated sessions. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

Language preference, text layout and assets

16. Separate preference from current session state

After a player chooses French and restarts the exported game, the start screen unexpectedly returns to English while stored levels remain untouched. Meaning is a system property here: it depends on text, timing, values, layout and the action a control performs. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Remembered preference and saved game progress are different types of state; the localization design needs a predictable preference persistence and default fallback policy. A good intervention changes as little as needed and leaves other event-sheet conditions alone, making regressions easier to detect. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Persist the selected language through the project’s normal storage system when appropriate, validate it against available catalogs, and restore display after loading. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Restart and clear progress separately; a saved language should not corrupt level state, and resetting a puzzle should not silently change locale. Release only when a target-language player can explain the consequence of a choice and the exported build behaves accordingly. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

17. Design text containers for expansion

A compact English Retry button becomes a longer translated instruction and overlaps the countdown in portrait mobile view. Begin with the actual player action rather than the translation file. A fluent sentence can still misrepresent the risk or next step. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

String length, font metrics and line wrapping interact with Construct layouts and resolution scaling; correct JSON does not guarantee readable rendering. Identify whether the problem comes from resource identity, asynchronous loading, text rendering or the event logic that controls the game. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Use flexible object sizing, tested wrap rules and adequate spacing for target strings; reserve full translations for important actions rather than cryptic abbreviations. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Capture narrow and wide screens in every shipped language; the complete action label must be available without collision or accidental tap targets. A pass must include a real action that confirms the UI sentence matched the underlying gameplay result. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

18. Review glyph coverage and direction

A Hindi label renders as squares and a mixed Arabic-number status appears with an unexpected visual order. Treat a short label as a promise about behavior. The reader needs enough context to make a decision without knowing the source language. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

The browser text system, the selected font and the surrounding layout determine what is rendered; translation resources cannot compensate for missing glyphs. Do not repair a display bug by changing a game variable or a pricing condition; keep language resources separate from executable state. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Choose fonts that cover target scripts, validate punctuation and mixed-language strings, and test direction-sensitive interfaces with fluent users. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Render full warnings on target devices, including digits, punctuation and names, and check usability rather than only whether one character appears. Check the failure condition as well as the expected path, because missing files and restarts reveal many hidden English literals. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

19. Protect audio and image text

A puzzle voice line says Turn left while the translated on-screen sign says Go right and the background texture still contains English directions. The practical risk is that a localization spreadsheet may look complete while a layout remains unusable to a real person. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

The Internationalization catalog generally serves program text; speech, textures and embedded labels may need separate localized assets or subtitles. Make the source, the resource revision and the triggering event observable so another developer can reproduce and review the fix. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Audit each instruction-bearing medium and align its semantic content with game mechanics, including voice-off and muted play modes. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Complete the maze by sound alone and then by text alone in each language; both paths should lead to the same correct route. Testing should compare the same input and saved state under different locales, never two unrelated sessions. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

20. Handle unavailable language files

A player selects a newly announced language whose catalog was omitted from the hosted export and all lookups return missing values. Meaning is a system property here: it depends on text, timing, values, layout and the action a control performs. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

A visible language choice should correspond to a shipped resource that has been loaded and tested, not merely to a configuration label. A good intervention changes as little as needed and leaves other event-sheet conditions alone, making regressions easier to detect. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

List only ready languages, fall back to a complete reviewed source catalog when needed and show an intelligible status if a requested pack cannot load. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Test offline startup, deleted file paths and ordinary network failure without allowing raw keys into a live purchase or reset dialog. Release only when a target-language player can explain the consequence of a choice and the exported build behaves accordingly. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

Multi-layout testing, exports and release control

21. Test events across multiple layouts

The menu is translated but a game-over layout sets Retry and Quit using old literal strings on layout start. Begin with the actual player action rather than the translation file. A fluent sentence can still misrepresent the risk or next step. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Localization work can be scattered across Construct event sheets, functions and layout-specific events, creating missed paths after a language change. Identify whether the problem comes from resource identity, asynchronous loading, text rendering or the event logic that controls the game. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Inventory every source of visible text, centralize lookup where practical, and trigger translation refresh after layout transitions and new object creation. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Win, lose, pause, resume and restart in the second language without going through the English main menu. A pass must include a real action that confirms the UI sentence matched the underlying gameplay result. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

22. Export a realistic production build

Preview mode finds the JSON catalog, but a published web build uses the wrong relative path and stalls on language selection. Treat a short label as a promise about behavior. The reader needs enough context to make a decision without knowing the source language. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Project-file availability and exported resource paths can differ from editor expectations, especially with asynchronous loading and hosting configuration. Do not repair a display bug by changing a game variable or a pricing condition; keep language resources separate from executable state. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Check the packaged files, deploy to the intended host and test an actual published artifact with a fresh browser profile and slow connection. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Verify at least two locales on the public URL, inspect network failures and prove the final export contains the correct catalog revisions. Check the failure condition as well as the expected path, because missing files and restarts reveal many hidden English literals. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

23. Control translation updates and rollback

A teammate edits the tutorial key after translators finish, and a later patch quietly restores an outdated catalog. The practical risk is that a localization spreadsheet may look complete while a layout remains unusable to a real person. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

Without source and catalog revision tracking, a successful one-off test cannot identify which translations were approved for each build. Make the source, the resource revision and the triggering event observable so another developer can reproduce and review the fix. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Version the source baseline, JSON files and reviewer decisions, reconcile changed keys before deployment and preserve an earlier verified export. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Publish a controlled test release and compare its message set to the approved manifest, then demonstrate a rollback if a critical instruction is wrong. Testing should compare the same input and saved state under different locales, never two unrelated sessions. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

24. Measure player comprehension rather than coverage

A dashboard shows 100 percent catalog keys populated while beginners still misread the reset warning and lose their puzzle history. Meaning is a system property here: it depends on text, timing, values, layout and the action a control performs. For the multilingual Signal Garden puzzle game, first record which object the player sees, what state has been reached and whether the decision is reversible. This prevents an apparently minor linguistic edit from becoming a misleading game instruction.

A populated lookup is not proof that the player understood the warning, timed decision or irreversible action. A good intervention changes as little as needed and leaves other event-sheet conditions alone, making regressions easier to detect. When investigating, compare the literal source, its JSON key, the active locale, the event-sheet conditions and the resulting visible Text object. A missing value and a perfectly translated value displayed at the wrong time are different defects.

Test important user journeys with first-time players speaking the target language, record hesitation and error patterns, and prioritize unclear decisions over cosmetic completion. Make the change in a small reproducible example before applying it to every layout. Note the target language, input state, key name and the assumptions the translator should not need to guess. Avoid hard-coded English fragments outside the language resource if a complete message can be localized.

Have each tester explain what Reset, Continue and Buy do before acting, then verify event-sheet behavior matches their understanding. Release only when a target-language player can explain the consequence of a choice and the exported build behaves accordingly. Include at least one ordinary outcome and one adverse condition in the verification log, with the exact resource revision and exported build. This turns a subjective language review into a practical acceptance criterion that another tester can repeat.

A realistic four-week training and rollout plan

Week 1 — source audit and key design

Finish an inventory of player-facing Text objects, event-sheet literals, error messages and text-bearing assets. Implement two layouts and clarify destructive controls before introducing multiple locales. Record the owner of each unresolved issue and a concrete release decision. Do not count an untested translation as ready merely because the JSON file parses correctly; it has to survive an actual interaction and the final deployed artifact.

Week 2 — catalogs and formatting

Build two valid catalogs, test asynchronous AJAX loading, nested keys, substitutions, plural categories and culturally appropriate number formatting. Work with fluent reviewers on context-dependent labels. Record the owner of each unresolved issue and a concrete release decision. Do not count an untested translation as ready merely because the JSON file parses correctly; it has to survive an actual interaction and the final deployed artifact.

Week 3 — interaction and device tests

Test language switching while dialogs are open, restarts, fresh saves, small devices, font coverage, RTL reading order and missing resource behavior. Compare the same underlying game state in each locale. Record the owner of each unresolved issue and a concrete release decision. Do not count an untested translation as ready merely because the JSON file parses correctly; it has to survive an actual interaction and the final deployed artifact.

Week 4 — publish and refine

Export to the actual host, validate paths and catalog revisions, run a live first-player journey for every supported language and keep a rollback artifact. Prioritize the highest-impact misunderstanding rather than superficial coverage figures. Record the owner of each unresolved issue and a concrete release decision. Do not count an untested translation as ready merely because the JSON file parses correctly; it has to survive an actual interaction and the final deployed artifact.

Frequently asked questions

Is the Construct 3 Internationalization plugin the same as a third-party I18N addon?

No. The official object has documented actions, expressions, locale handling and JSON expectations. An addon may use a different schema or workflow. Identify your actual project dependency before applying instructions. Use the Signal Garden seed-and-relay example to check the answer in an observable screen state. The decisive question is whether a new player understands the intended action without needing the original English sentence.

Does a JSON language file need both locale and strings?

The official documentation requires strings; locale is optional. When supplied, a locale identifier must be parsable and valid. A syntactically valid file without the required strings property is not a correct catalog. Use the Signal Garden seed-and-relay example to check the answer in an observable screen state. The decisive question is whether a new player understands the intended action without needing the original English sentence.

Why are raw keys visible when I launch?

The lookup may happen before the resource loads, the key may be absent or the language may be wrong. Test AJAX completion, JSON loading, active locale and key path before changing translations. Use the Signal Garden seed-and-relay example to check the answer in an observable screen state. The decisive question is whether a new player understands the intended action without needing the original English sentence.

When should I use LookupPlural?

Use plural-aware selection for messages whose grammar depends on a count. A single English singular/plural suffix is not sufficient across languages. Test culturally appropriate count categories with real game values. Use the Signal Garden seed-and-relay example to check the answer in an observable screen state. The decisive question is whether a new player understands the intended action without needing the original English sentence.

Can I let users switch language halfway through?

Yes as an application feature if you implement and test it. Selecting a locale alone may not refresh every pre-existing Text object; explicitly update visible UI and new layouts after the resource is ready. Use the Signal Garden seed-and-relay example to check the answer in an observable screen state. The decisive question is whether a new player understands the intended action without needing the original English sentence.

How do I keep prices and progress consistent?

The event-sheet game variables remain authoritative. Localize how the values are explained, never the numeric logic or saved state. Compare identical transactions and resets in two languages. Use the Signal Garden seed-and-relay example to check the answer in an observable screen state. The decisive question is whether a new player understands the intended action without needing the original English sentence.

How do I know whether an export contains its language files?

Open the actual deployed artifact, inspect requests for catalogs and complete one target-language journey. Editor preview success does not prove exported paths, hosting cache or error handling are correct. Use the Signal Garden seed-and-relay example to check the answer in an observable screen state. The decisive question is whether a new player understands the intended action without needing the original English sentence.

What should be translated first in a small project?

Prioritize menu navigation, instructions needed to progress, warnings about irreversible actions, purchases, recovery paths and status messages. Decorative narrative can follow once players can safely understand the game. Use the Signal Garden seed-and-relay example to check the answer in an observable screen state. The decisive question is whether a new player understands the intended action without needing the original English sentence.

Official technical references

For language principles and wider terminology, use Master Art of Translation. For related platform implementations, use the Translate Like a Pro series index. This guide is scoped to implementing multilingual Construct 3 projects, not to generic translation-speed or quality-assurance articles.

The final test

A genuinely localized Construct game is not defined by how many JSON entries it contains. It succeeds when players can choose the right action, understand the energy cost, follow the puzzle conditions and recover from failure, while the event sheets perform the same intended logic in every language.

Translate Like a Pro | 7160 — Construct 3 Internationalization JSON, Lookup, Plurals, Event Sheets and Release QA