Translate Like a Pro | 8140 — Kotlin Mordant Terminal Localization, Prompt Choices, Text Styles, Layout, Keyboard and Unicode QA

Kotlin Mordant terminal localization combines language-sensitive prompts with readable styled output, robust input handling and evidence-based status messages. This guide explains how to internationalize Mordant Terminal.prompt, choice lists, confirmation prompts, text wrapping, color and keyboard interactions for multilingual command-line applications. It addresses a practical problem: a screen can look polished in one language yet become ambiguous or unusable when the sentence expands or the script changes.

Picture an international emergency-management training exercise. A coordinator uses a Kotlin terminal utility to register volunteers for a simulated scenario, select a training role and acknowledge a safety briefing. Completing that registration does not deploy the volunteer to an actual incident, establish professional certification or prove a briefing was understood. The text must keep ‘exercise registration complete’ separate from those stronger outcomes so an enthusiastic translation cannot create a false operational record.

We begin with what a reliable translated terminal interaction must accomplish, then examine Mordant’s prompt and rendering responsibilities, canonical role codes, wording review, visible focus, line wrapping, screen-reader concerns and release checks. Practical scenarios and a step-by-step implementation plan help technical and language teams deliver tools that remain clear across platforms and locales.

Quick answer: how to localize this terminal workflow safely

Translate every reader-facing prompt, choice, error, help line, cancellation and truthful result in Mordant.
Preserve domain values including participant_reference, exercise_role_code, scenario_language, briefing_acknowledgement_state across language changes.
Validate local syntax separately from server existence, permission and final approval.
Choose defaults deliberately; never let Enter imply an unauthorized decision.
Distinguish local draft, submitted request, verified response and unknown acknowledgement.
Test actual keyboards, terminals, narrow screens, Unicode, RTL where needed and no-color output.
Have target-language readers complete a realistic task and explain its consequence.
Do not substitute the unsupported claim "The participant is certified and deployed to an emergency." for "Exercise registration was recorded; the participant is not assigned to an operational response.".
Maintain term sheets, semantic message keys, exact dependency versions and regression records.

A working data dictionary

Field	Meaning	Evidence rule
`participant_reference`	pseudonymous trainee registration key	must not reveal a participant’s full personal profile
`exercise_role_code`	stable training role identifier	does not grant real-world responder qualifications
`scenario_language`	chosen exercise language setting	should be independent of role assignment
`briefing_acknowledgement_state`	record of a training-screen response	is not proof of comprehension or authorization to deploy

1. Start with the actual task, not the translated sentence

A useful command-line question does not exist in isolation. an emergency-training exercise coordinator is trying to register a participant, assign a simulation role, and request a briefing acknowledgement. Begin by following that journey as an observer. What facts arrive with the person, what must be typed, what must be selected, and what can the application truly decide? Make a sketch of an ordinary session, an interrupted session and a case where the external authority refuses the request. This exercise clarifies the job of every prompt before anybody opens a localization file. If the original language is vague about the actor, action or consequence, translating it faithfully will preserve that vagueness rather than solve it.

Define the exact moment when data stops being a draft and becomes a request, and when a request becomes a verified outcome. In an international simulated disaster-response training program, that distinction matters to both operators and people who read exported records. A polished interface may make every stage feel complete, but the underlying services and human processes do not collapse into one event. For the workflow in this guide, a safe limited message is “Exercise registration was recorded; the participant is not assigned to an operational response.” The stronger statement “The participant is certified and deployed to an emergency.” requires independent evidence. Explain this distinction to reviewers before they accept any final translated label.

Create a task inventory that includes the first screen, help and empty-state messages, typing errors, option summaries, confirmation, cancellation, remote failures and final outcomes. Include keyboard hints and status text that appears only on uncommon branches. The quickest way to miss a consequential translation is to collect strings from screenshots of successful sessions only. Record for each message who sees it, what they know at that point and which next action the interface actually supports.

2. Draw the data contract before writing locale strings

Create a data dictionary for participant_reference, exercise_role_code, scenario_language, briefing_acknowledgement_state. Explain each field’s kind of evidence, expected type, allowed values, owner and downstream consumers. participant_reference means pseudonymous trainee registration key; its purpose is not established by the English label alone. exercise_role_code means stable training role identifier. Ask a subject-matter reviewer to confirm the meaning of these names before the first translated release. A schema that has been defined clearly provides a stable foundation for many language editions.

The language team should receive a description of which properties are identifiers, which are free-text annotations, which are controlled choices and which are claims of verified state. For example, scenario_language is chosen exercise language setting, whereas briefing_acknowledgement_state is record of a training-screen response. They may appear beside one another in a terminal summary, but they do not have the same authority. In the interface, distinguish entering a claim, asking for a review and observing a result of that review.

Write a separate rule for every invariant: the same selected item must produce the same canonical value in every locale, a permission may not increase merely because the text changes, and a status may not move from pending to completed without evidence. Build those expectations into tests at the serialized-record boundary. Translators can then exercise considerable freedom to produce natural, clear expressions without being forced to preserve the precise word order of the source.

3. Assign responsibility to the prompt library and to the application

Mordant is a modular Kotlin terminal library. Its guide documents Terminal.prompt with choices, advanced Prompt subclasses including StringPrompt, YesNoPrompt and ConfirmationPrompt, and facilities for wrapping, styling, tables, cursor control and terminal capability detection. Platform modules differ, so check your JVM and other target configurations against the installed version. Its useful role is visible interaction. The surrounding application still chooses a locale, loads strings, validates domain values, enforces access control, persists records and checks external acknowledgements. Put these responsibilities in separate modules or at least separate functions, so a later translation edit cannot accidentally change security or business behavior. A localized prompt is a view of a process; it is not the process itself.

Inspect all the visible material generated by Mordant, including its default hints, invalid response wording, keyboard instructions and end-of-session presentation. Decide what can be provided through documented public APIs and what requires your application’s own text or an alternative prompt. Do not assume that every built-in error or keystroke is automatically localized. If the installed version cannot offer a necessary multilingual behavior, choose a different supported interaction and state the limitation rather than suggesting that a translation string changes the library’s parser.

Maintain a pinned dependency and a small implementation note for reviewers. List the exact components your application uses: Mordant Terminal and modular interfaces; Terminal.prompt and Prompt classes; StringPrompt, YesNoPrompt and ConfirmationPrompt; colored and wrapped textual output; keyboard and terminal capability detection; real-world training-vs-deployment distinctions. Each component creates a different type of language risk. The benefit of a scoped inventory is that a developer can answer a precise question such as ‘Where does the visible cancellation sentence originate?’ without searching an entire codebase or guessing from translated screenshots.

4. Build a translation brief that protects the reader

For every important message, record its intention in plain language. Is the line asking for information, warning of a consequence, describing a required format, offering a choice or reporting verified completion? State whether the audience is a novice, a trained operator or a specialist. Write one example of a successful use and one of a wrong interpretation. A translation brief gives the reviewer enough context to judge meaning instead of replacing a short English string with an equally short but misleading phrase.

Make a terminology sheet for the four domain fields and important verbs such as create, save, submit, acknowledge, approve, reject, verify and activate. These verbs must not be treated as synonyms. The words used to describe briefing_acknowledgement_state should reflect is not proof of comprehension or authorization to deploy. If a professional term has several plausible translations, include a definition and an example of what it does not mean. Avoid unexplained abbreviations unless the audience already uses them in the actual workflow.

Invite a fluent target-language reviewer to explain a complete screen in their own words. Ask what will be stored after Enter, what permission is being requested and what remains unknown. Such interpretation tests are stronger than a simple comparison of translated sentences. They also reveal whether a polite phrase hides a command, whether an apparent suggestion is actually a requirement, or whether a phrase is too broad for the status that the program can establish.

5. Use semantic message keys and complete sentences

A message catalog should be indexed by intent rather than by a fragment of the English source. Favor keys such as station_id_label, save_draft_status, invalid_value_explanation and request_review_question over keys that encode whole English sentences. Keep confirmation text, the explanation of consequences and the resulting status as separate messages. Doing so makes it possible to change one domain step without silently repurposing a translation in a different workflow.

Whenever a message contains a changing value, use a named placeholder such as {record_reference} or {count} rather than concatenating fragments. Languages may move the variable to a different position, require a different plural form or change prepositions. Identify the placeholder’s type and whether it can contain user-generated text. Escape untrusted values when the terminal renderer interprets markup or style syntax. A stored identifier must remain distinguishable from commentary around it.

Define how a missing catalog entry behaves. For low-risk decorative content, a reviewed source-language fallback may be workable. For a warning or a confirmation with consequences, either show a fully understandable fallback or mark that locale path unavailable until reviewed. Do not silently replace an unknown error with success. Log missing keys in test and staging environments and track catalog completeness against the actual application branches, not the number of translated strings in a spreadsheet.

6. Keep translated labels separate from returned values

A localized choice list can contain beautiful, comprehensible wording while still returning the wrong internal value. That happens when developers persist a row number, a visible translation or a mutable display order as though it were a permanent identity. Build a deliberate mapping from the user’s selected presentation to an immutable code or typed value. The label can change next month; the meaning of an earlier record must not. This is the core round-trip property of reliable multilingual software.

In the running example, make two versions of the list and deliberately sort them differently. Select the same semantic item in both versions. Compare the stored exercise_role_code and scenario_language with the expected canonical values, rather than comparing the displayed words. Repeat with a missing option, a disabled option and two descriptions that look alike. If the system can reopen an earlier draft after switching locale and still show the correct chosen item, the mapping has survived an important real-world test.

Do not confuse normalization with translation. A domain identifier may legitimately require ASCII, a specified Unicode normalization form or a standard code format. Human names and descriptive notes have different rules. Apply conversions because of documented data contracts, not because a translated label happens to look unfamiliar. Record when input is rejected, when a suggested correction is offered and whether the user’s original text is retained for review.

7. Write validations that enable a correction

Separate errors into input syntax, unsupported selection, conflict with another field, missing domain record, insufficient permission, service interruption and unknown acknowledgement. The same short English message should not be reused for all of them. A useful translation says what failed at the level the user can act on, why the value cannot be accepted and what step can repair it. It should not shame the operator or imply the local language is itself the problem.

The field participant_reference is a useful example. A string may match the expected format but refer to no real record. A record may exist but not be visible to the current operator. The local prompt can check format; the authorized service must check existence and permissions. If the tool cannot reach that service, show a connectivity state rather than making up a business rejection. Record safe diagnostic codes for support without echoing protected input into terminal scrollback.

Validation wording should survive changing locale while its rules remain consistent. If a number is parsed differently in one region, be explicit about accepted decimal syntax, separators and units. If an error contains a count, use the target language’s normal plural forms. Test examples that nearly pass, not just obviously invalid inputs: whitespace, visually similar characters, mixed case, an old but well-formed ID, a field omitted intentionally and a value outside the current set of allowed choices.

8. Defaults must represent decisions, not developer convenience

A default has a special effect in a terminal: pressing Enter can become a decision without a typed answer. That is a useful convenience for low-consequence fields and a serious hazard for approval, publication, payment, notification or destructive actions. Review every default as if a hurried user will accept it without reading. Is the chosen value genuinely safe, reversible and appropriate to the person’s task? If not, ask explicitly and describe the consequence before the response.

A preselected first row may also appear to be a recommended answer. Languages sort option lists differently, so first-row behavior is not stable if the application mistakes display ordering for policy. Give an intentional domain default, not an accidental localization default. For optional entries, distinguish ‘none’ from ‘not yet chosen’ and from an input that was cancelled. A dashboard or exported record should never silently equate these states.

Test default behavior on a fresh profile, on a reopened draft, after changing locale and after upgrading the dependency. Check which key causes submission and whether the prompt library accepts immediate letter responses. The visible text should describe the actual behavior of the exact installed version. A translation cannot make a nonexistent shortcut work; an honest line of help may be more useful than a short but inaccurate translated hint.

9. Cancellation and interruption are independent outcomes

A person may press Escape, Ctrl-C, close a terminal, lose a network session or deliberately choose not to continue. These events are not identical. Some are local cancellations before any record exists; others may happen after a request has reached a remote service. Plan for both states and explain the difference in the interface. If an acknowledgement was lost, the answer may be unknown even though work happened on the server.

Use a stable reference and, where supported, an idempotent request or safe status lookup for operations that can be retried. Never encourage blind resubmission when it could create a duplicate or unexpectedly repeat a consequential action. The message after interruption should state what is known and what the operator can verify, rather than dramatizing the problem or assuming the request failed. The same rule applies in every locale.

During QA, interrupt each significant step rather than only the first. Look for a misleading outro, leaked input, a partial state that cannot be reopened, or a local confirmation that was mistaken for remote acceptance. Make a transcript that records the keyboard event, persisted state and visible outcome. A clear cancellation experience is evidence of careful international design because interrupted tasks are often where language and software assumptions diverge.

10. Numbers, units, dates and local conventions

Natural language localization involves more than vocabulary. Time and date order, decimal separators, unit labels, plural forms, address conventions and the reading direction of identifiers can alter interpretation. Format human-facing values with a deliberate locale policy while storing typed canonical values. A translated description of a number is not permission to alter the number itself, and a visible conversion should never silently change scientific or operational data.

Use the fields in the running example to identify what should be formatted and what must remain fixed: participant_reference may be an exact identifier; exercise_role_code may have a controlled internal representation; scenario_language may need a helpful description; briefing_acknowledgement_state needs an authoritative state. Spell out a unit or time zone when a shorthand might be ambiguous. If the audience works across regions, display both the local interpretation and an unambiguous machine-facing reference when useful.

Rehearse tricky values: 1 versus 1,000; decimal comma versus decimal point; dates where both day and month could be valid; a time near midnight in another region; and units with similar names but different quantities. Test that the same record is reconstructed after switching language. Where conversion is required, log it as a mathematical operation with rules and precision, not as a translator’s choice.

11. Unicode layout is an observed behavior

Unicode strings are not uniformly one cell wide in a terminal. Combining sequences, East Asian wide characters, variation selectors and emoji may occupy surprising widths, and bidirectional scripts can reorder nearby Latin codes visually. A program may accept such text as bytes while its cursor movement or wrapping remains unusable. Real Unicode QA therefore asks a person to navigate and interpret the full interaction, not merely to confirm that the file can store UTF-8.

Test a narrow and wide terminal, several fonts, ordinary and non-Latin keyboards, no-color mode and redirected standard output. Look at the placement of error text, arrows, option descriptions and the final action. Check whether a long label hides a required instruction or whether adjacent wrapped lines make two options appear to belong together. Use grapheme-aware length limits for human notes where appropriate and explicitly different rules for machine identifiers.

Do not claim universal right-to-left or screen-reader support on the basis of a successful screenshot. Document the exact profiles that have been tested and offer a simpler interaction when a complex terminal display is unreliable. Include practical language speakers in the review. A developer who knows the English workflow can unconsciously guess the intended meaning even when the target-language version is misleading.

12. Accessibility is a property of the complete interaction

Readable contrast and stable focus are important, but they are not sufficient. A person needs to know which answer is selected, whether a choice is required, which key advances and what happened after an error. Icons and color should reinforce words, not replace them. Animated progress displays may be clear visually yet extremely noisy in assistive technology or recorded terminal sessions. Offer a quiet mode if your audience and terminal stack need one.

Test keyboard-only completion from an empty state through a verified outcome. Observe an actual user navigating backwards, repairing a mistake, dismissing help and recovering from an interruption. If a list has hundreds of options, provide a search or narrowing strategy and show the exact chosen object before submission. A screen reader may read a textual transcript rather than your intended layout, so also review the output after styling is removed.

Accessibility reviews benefit from the same questions as translation reviews: what does this control do, what will be stored, and what remains uncertain? If the answer depends on seeing color, remembering English labels or reading a long line before it disappears, the design needs revision. Document findings as concrete defects with reproduction steps rather than an unverified statement that the program is accessible to everyone.

13. Privacy and logging belong in the translation brief

A terminal is often shared, remotely recorded or copied into a support ticket. Some values in an international simulated disaster-response training program can be confidential even if they are ordinary strings from the application’s perspective. Review what appears in prompts, summaries, error messages, debug output, stack traces and saved drafts. Avoid echoing secrets or protected personal data merely to make a translated error more descriptive. The privacy policy should not change depending on which locale encounters a failure.

Separate user-visible explanatory text from diagnostic metadata. A stable error identifier can allow technical support to investigate without exposing the full original input. When records need to be audited, design access-controlled evidence capture instead of asking the operator to send a screenshot containing everything. A language team should know which nouns refer to protected categories of information, because a mistranslated status can cause people to share more than intended.

Masking input is useful when the library supports it, but masking alone is not data protection. Consider shell history, saved crash dumps, local temporary files, clipboard behavior and transcripts. A professional translation explains the safe action available to the reader without making them disclose a password, exact private location, unpublished media or confidential identifier to prove that a problem occurred.

14. Distinguish a local action from an external fact

The terminal can collect answers, render them clearly and perhaps save a local file. It cannot independently prove that a remote service accepted a request, that a human reviewer made a decision or that a physical event occurred. Translate completion messages at the narrowest level supported by verified evidence. In the example here, “Exercise registration was recorded; the participant is not assigned to an operational response.” may be justified by the right record. “The participant is certified and deployed to an emergency.” must not appear without a separate authoritative event.

Model statuses such as draft, locally saved, submission pending, accepted for processing, rejected, unknown after timeout and final verified outcome. The exact names will vary by domain, but the distinction between what was asked and what happened is universal. Build message templates around those states and require the service response that moves each state forward. A translation that makes a pending state sound final is not a harmless editorial choice.

This principle also improves support. When readers see an honest reference and an exact current state, they can ask a more precise question. When they see an overconfident success caption, they may not discover a missing authorization or incomplete review until much later. Accuracy at the end of a prompt matters more than exuberant reassurance.

15. Make release testing about equivalence of meaning

Build fixtures for ordinary input, invalid input, conflicting input, denied permission, missing remote data, no network, timeout and interruption. Each fixture should record locale, visible text, selected machine value, persisted state, authority response and next action. Automate equality of canonical values across locales and add human review of interpretation. Neither method substitutes for the other: code can prove a value stayed stable; only a reader can tell you what the sentence appears to promise.

Use a testing matrix with at least one long-text language and one non-Latin script where your audience requires them. Test the actual dependency and target terminals, including how the interface behaves with color disabled and with output redirected. Review the cases below as starting points; choose the specific risks that matter to your institution. When a defect is repaired, preserve the original failure as a regression case so it does not return during the next translation or package upgrade.

A reliable launch has a modest set of supported claims. It names the locales that have complete consequential strings, the terminal profiles observed, the domain values compared and the unresolved limitations. Record who approved domain terminology and who verified the final status wording. Treat a translation update as a product change when it alters a permission, required action or meaning of an outcome.

16. Design a maintainable review and return path

The first release is not the end of translation. Domain states change, libraries gain features, prompts are reordered and terminology evolves. Maintain a small ownership table: a developer owns the API contract, a domain reviewer owns factual status definitions, a language reviewer owns natural expression, and a product owner approves what the tool may promise. Make each reviewer’s responsibility specific enough that corrections can be routed without reopening the entire application.

When someone reports confusing text, collect the locale, dependency version, terminal type, message key, anonymized state and the interpretation they drew. Fix the source ambiguity where it exists, not only the translated sentence. A correction that makes one language clearer but leaves the English intent wrong will generate more problems as additional locales are added. Put approved changes in the term sheet and add a targeted regression fixture.

Finally, design a return path for the user. A translated warning should tell people whether they can edit the field, reopen a draft, check a remote status or contact the right authority. A program that handles all four languages gracefully yet leaves the reader unable to act has not finished its job. International quality is measured by accurate decisions, recoverable errors and the preservation of trust over time.

Mordant implementation: source-level decisions

The following Kotlin sketch illustrates the interface boundary. It is not a complete production system and deliberately does not invent an external authorization, validation or submission service. Check the public API against the installed Mordant version before using it as application code. Its main lesson is to keep prompts responsible for acquiring answers and separate the point where those answers are mapped into typed domain records and verified against an authority.

import com.github.ajalt.mordant.terminal.Terminal

val terminal = Terminal()
val role = terminal.prompt(
    "Choose an exercise role",
    choices = listOf("observer", "logistics", "communications")
)
terminal.println("Role selected for exercise: $role")
// Save a canonical role code only after validating the return value.
// A training role is not an operational deployment authorization.

For a multilingual edition, replace English literals in the sketch with reviewed catalog messages; maintain a locale-neutral representation of every returned choice. Do not generate the next text by simply concatenating the selected description. A responsible implementation should also define cancellation, retry behavior, structured errors, logging redaction and status persistence. Write small tests around the conversion between display and domain fields before integrating the finished screen into an international simulated disaster-response training program.

17. Modules are part of the release contract

Mordant is modular, with terminal backends and optional rendering features. A command-line utility that works on a developer’s JVM setup may not have the same keyboard or size-detection behavior in a packaged artifact with a different interface module. Treat platform choice as part of translation QA, not as an invisible build detail.

Document the precise runtime, terminal backend and feature modules selected for the release. Rehearse a complete prompt, not just a print statement, in each supported deployment profile. If raw-mode features are unavailable, show a simpler supported interaction or an explicit limitation rather than suggesting the same shortcut keys work everywhere.

18. Prompt classes and target-language grammar

Terminal.prompt gives an approachable entry point; more specialized Prompt classes provide different response behaviors. Translate the question and the surrounding choices as complete utterances. A language may require changes to sentence order, particles or politeness rather than one-to-one replacement of English words.

Create catalog entries for the full question, help line and validation message. If a YesNoPrompt displays a response convention unfamiliar to a target-language audience, test whether the user knows which keys to press. Never assert that a translated yes/no label changes how keystrokes are parsed without checking the actual configured prompt behavior.

19. Styled terminal content without color dependence

Mordant can render styled text and adapt color to terminal capabilities. That does not make red text alone a safe way to communicate ‘not approved’ or green text a safe way to imply readiness. Pair emphasis with status words, clear references and the next permitted action.

Test without ANSI styling and with low-contrast displays. A briefing acknowledgement needs readable context before confirmation; a color block cannot substitute for a sentence that distinguishes simulated training from an actual event. Review the plain-text transcript as a separate artifact, because logs and accessibility tools may expose that representation rather than the full colored display.

20. Text wrapping and the hidden action

A short English role description may become much longer in Indonesian, Arabic, German or a local language. Mordant’s text wrapping and alignment facilities can help, but you still need to choose what to put first. Put the required action and the consequence in the first visible lines; place background explanation later.

Check long unbroken identifiers, lists, East Asian full-width characters and bidirectional text. A label can be technically wrapped yet semantically separated from its choice. Use distinct numbering or stable code prefixes when a large list might be misunderstood. Ask bilingual testers to read the rendered choice and say what will be recorded.

21. Acknowledgement versus demonstrated competence

A training system might record that a participant saw or acknowledged a briefing. The prompt does not measure whether they understood every safety instruction, and a selected role does not make them an accredited responder. Translate these concepts precisely; they are different states with different evidentiary requirements.

If a regulator, employer or training organization defines a certification step, represent that in an independent process with its own authenticated evidence. A simulated training application should not generate operational status claims. This distinction is especially important if terminal output is copied into shared reports and then read by people who were not present at the exercise.

22. Key input and assistive technologies

Mordant supports different kinds of keyboard and mouse input depending on modules and terminals. The visible instructions must describe the actual interaction configured by the developer. A translated ‘press a letter’ is not enough if the trainee uses a keyboard where that letter requires a modifier or if focus changes unexpectedly.

Test Enter, cancellation and invalid responses under actual terminal emulators. Observe keyboard-only use and investigate whether plain prompts work better for the audience than animated or cursor-intensive interfaces. Publish supported profiles rather than a blanket accessibility claim.

Practical field investigations: how small translation errors change decisions

The following cases are designed as exercises, not as claims that these incidents have occurred. Each describes an observable condition, a possible mistaken inference, a safer design and a reproducible test. They can be handed to a developer, language reviewer and actual an emergency-training exercise coordinator to examine together. The key is to distinguish how the terminal looks from what it returns and what the wider application knows.

Case 1: Role changed with sorting

The useful starting point is a real task transcript. Localized role names are alphabetized differently. The danger is not an unattractive sentence; it is that a saved index accidentally becomes a different training role. A better implementation should map display names to stable role codes. This change needs to operate on the underlying record or message selection, rather than only on a decorative color or an English screenshot. The explicit check is to choose one role under two locale sort orders.

For Mordant, record both what was displayed and what the library returned. Compare the canonical participant_reference with its value in a second locale. A correct translation is one that supports the same decision and the same permission boundary, not merely one that looks natural on a screenshot.

Case 2: Exercise mistaken for real dispatch

Follow the entire interaction rather than checking a single line. In this scenario, the completion screen says ‘deployed’. Someone can reasonably but incorrectly conclude that a downstream reader believes the person is attending an emergency. Prevent that reading by arranging to use explicit simulation-only language and verify source state. Then copy the transcript into a mock duty report and assess interpretation and compare both visible output and saved data.

Add a negative example alongside the successful path. A language reviewer should be able to describe the correction or uncertainty, and the developer should be able to show that the system did not convert an unverified state into a positive claim. Preserve the case in the regression set.

Case 3: Long safety warning

A translation reviewer should ask what fact the program can establish here. The translated briefing overflows a narrow pane. Without additional safeguards, the confirmation appears before readers can see the consequence. The practical repair is to use readable wrapping, paging or a shorter verified summary. Test this by arranging to render at small widths and ask testers to explain the prompt; a reader must understand the resulting state even without the English source.

Invite a target-language reader to perform the task without looking at an English version. Ask what they think happened and what they would do next. If the interpretation differs from the authoritative record, repair the original message intent as well as its translated form.

Case 4: Color-only critical status

This case illustrates why localization is a form of operational testing. A red label marks an incomplete briefing. The resulting misunderstanding is that a no-color terminal loses the distinction. Make the interaction safer: Add text states and next actions independent of style. Demonstrate it through a controlled reproduction: Capture monochrome and redirected output. Record the exact prompt text, returned value and authoritative state after the test.

If the problem appears only in one locale, avoid a local patch that changes business rules. Examine the data mapping, input parser, defaults and state transitions. The same invariant should hold in every language: presentation can vary, but saved identity and authority cannot.

Case 5: Keyboard mismatch

The useful starting point is a real task transcript. The help line names a localized shortcut. The danger is not an unattractive sentence; it is that the backend still recognizes different keys. A better implementation should align instructions with actual keyboard behavior. This change needs to operate on the underlying record or message selection, rather than only on a decorative color or an English screenshot. The explicit check is to rehearse each supported keyboard layout.

Case 6: Participant reference in logs

Follow the entire interaction rather than checking a single line. In this scenario, debug output prints an identifiable full profile. Someone can reasonably but incorrectly conclude that training records leak into terminal history. Prevent that reading by arranging to use pseudonymous references and scrub logs. Then review normal and failure transcripts and compare both visible output and saved data.

Case 7: Unrecognized role

A translation reviewer should ask what fact the program can establish here. A previously available training role is removed. Without additional safeguards, the catalog still offers it as an option. The practical repair is to load and validate current allowed values from policy. Test this by arranging to try an obsolete role after configuration update; a reader must understand the resulting state even without the English source.

Case 8: Prompt cancellation

This case illustrates why localization is a form of operational testing. The coordinator cancels during role selection. The resulting misunderstanding is that a success line is printed regardless of result. Make the interaction safer: Return an explicit cancellation path and avoid submission. Demonstrate it through a controlled reproduction: Cancel at every step and inspect persistence. Record the exact prompt text, returned value and authoritative state after the test.

Case 9: Ambiguous acknowledgement

The useful starting point is a real task transcript. A yes answer means only ‘I opened the screen’. The danger is not an unattractive sentence; it is that another screen describes it as proven competence. A better implementation should use precisely scoped acknowledgement language. This change needs to operate on the underlying record or message selection, rather than only on a decorative color or an English screenshot. The explicit check is to interview trainees about what their click meant.

Case 10: Incomplete locale bundle

Follow the entire interaction rather than checking a single line. In this scenario, a fallback error is blank. Someone can reasonably but incorrectly conclude that the trainee cannot tell why registration failed. Prevent that reading by arranging to show reviewed source-language error with a stable code. Then remove one catalog key and run the affected path and compare both visible output and saved data.

Case 11: Non-ASCII identifier

A translation reviewer should ask what fact the program can establish here. A locale-specific keyboard enters combining marks. Without additional safeguards, the system normalizes a stable code incorrectly. The practical repair is to validate identifier representation separately from display text. Test this by arranging to round-trip codes with combining sequences; a reader must understand the resulting state even without the English source.

Case 12: Terminals disagree on width

This case illustrates why localization is a form of operational testing. The same table lines wrap differently across systems. The resulting misunderstanding is that a role appears next to another role’s description. Make the interaction safer: Use real terminal measurements and grouping. Demonstrate it through a controlled reproduction: Compare visual output in each supported backend. Record the exact prompt text, returned value and authoritative state after the test.

Case 13: Animation during screen reader

The useful starting point is a real task transcript. A frequently updating progress display repeats output. The danger is not an unattractive sentence; it is that assistive technology cannot follow the state. A better implementation should offer reduced-motion/plain text or a less noisy view. This change needs to operate on the underlying record or message selection, rather than only on a decorative color or an English screenshot. The explicit check is to observe a screen-reader session rather than inferring support.

Case 14: Offline acknowledgement

Follow the entire interaction rather than checking a single line. In this scenario, the terminal saves a local response only. Someone can reasonably but incorrectly conclude that the server is reported as having accepted the exercise registration. Prevent that reading by arranging to separate local draft and server acknowledgement. Then disconnect before sync and inspect reported state and compare both visible output and saved data.

Case 15: Incorrect time zone

A translation reviewer should ask what fact the program can establish here. A briefing deadline appears in ambiguous local time. Without additional safeguards, remote coordinators make different schedule decisions. The practical repair is to format an explicit zone and complete date. Test this by arranging to test across time zones and daylight transitions; a reader must understand the resulting state even without the English source.

Case 16: Dependency-backend upgrade

This case illustrates why localization is a form of operational testing. A new module configuration changes terminal behavior. The resulting misunderstanding is that previously translated shortcut hints become inaccurate. Make the interaction safer: Revalidate platform, prompt and rendering assumptions. Demonstrate it through a controlled reproduction: Compare regression evidence across released packages. Record the exact prompt text, returned value and authoritative state after the test.

Four-week plan for a reliable multilingual release

Week 1 — observe real work and collect evidence

Interview an emergency-training exercise coordinator and observe the real process to register a participant, assign a simulation role, and request a briefing acknowledgement. Diagram a normal path, a missing-value path, a denied-action path and an interrupted path. Collect every Mordant label, choice, hint, error and final-status message into an inventory, including text provided by dependencies. Write definitions and examples for participant_reference, exercise_role_code, scenario_language, briefing_acknowledgement_state. Choose the intended locales based on actual user needs, not a maximum-language marketing count.

By the end of the week, every important sentence should have an owner, a semantic key, the exact state that permits it to appear and a known reader action. The team should be able to say why “Exercise registration was recorded; the participant is not assigned to an operational response.” is a narrower claim than “The participant is certified and deployed to an emergency.”. This early work prevents attractive translations from concealing unresolved product decisions.

Week 2 — wire catalogs to typed, locale-neutral values

Introduce reviewed locale resources and use the supported Mordant APIs to render messages. Implement one tested mapping for user-visible options to stable domain identifiers. Keep typed values in storage and design explicit outcomes for blank input, local validation failure, server rejection, cancellation and uncertain acknowledgement. Validate participant_reference independently from its displayed label; handle briefing_acknowledgement_state only through the appropriate authority.

Use two locales to round-trip a saved record, deliberately change the order of options and verify that the same domain values survive. Add missing-key detection and a review process for consequential strings. The team should produce a short readable dependency and runtime matrix, plus tests that fail when a translated option accidentally changes the stored object.

Week 3 — observe readers using actual terminals

Test natural phrasing with bilingual reviewers and representative users who do not rely on the English screen. Include a long-label locale and non-Latin text if needed by the audience. Test narrow and wide windows, no-color mode, terminal emulators, real keyboards, wrong inputs and repeated choices. Exercise all of the field investigations most relevant to an international simulated disaster-response training program and capture sanitized transcripts with the returned values.

Ask each reader to explain the consequence of a confirmation and the meaning of a pending outcome. A test is successful only when the user knows what was recorded, what remains uncertain and which action is permitted next. Rework confusing copy instead of teaching people to memorize an English workflow. Update the message catalog and the term sheet together.

Week 4 — test failure, freeze ownership and release

Run the release candidate through missing services, delayed acknowledgements, stale data, permission denials, cancellation at each step and dependency-version checks. Compare canonical values and authorization outcomes across locales. Review privacy and support transcripts so that protected data does not leak through a translated failure path. Document a rollback mechanism for content and software versions, and name who approves changes to outcome wording.

Publish only the languages and environments supported by evidence. Record remaining limitations plainly and provide a channel for reporting misleading output with locale, message key, anonymized state and terminal profile. Schedule a review when the application contract, library API or terminology changes. A smaller tested release is more valuable than a long list of partially supported languages.

Release checklist for the reader and the maintainer

Every user-visible question, help text, default, error, cancellation and final status has a reviewed meaning.
Returned values and persisted identifiers remain identical for equivalent choices in different locales.
No prompt claims a verified external outcome when only local input or submission is known.
Consequential actions use intentional, tested defaults and appropriate authorization checks.
Error text distinguishes syntax, missing records, permission, outages and unknown acknowledgement.
Unicode, wrapping, keyboard, no-color and terminal profiles have actual observed test evidence.
Private fields are not echoed in ordinary terminal transcripts or shared diagnostics.
An end-user can explain the consequence of a choice and next step without reading English source text.
Catalog keys, terminology, status definitions and runtime dependencies have named owners.
The product documents which locales and terminal combinations are truly supported.

Frequently asked questions

Does Mordant itself translate all strings?

No. The library provides terminal and prompting facilities. Your application owns catalogs, locale selection, supported prompts and domain meaning. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

What is Terminal.prompt useful for?

It gathers input and can display choices. The returned response still needs validation against a stable application contract. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

Should I translate role identifiers?

Translate descriptions but preserve canonical machine-facing codes so sorting and language changes do not change an assignment. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

Is a yes/no answer proof a trainee understood the briefing?

No. It can record the limited action asked by the prompt; understanding or certification needs separate evidence. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

Does color detection guarantee accessibility?

No. Readability requires explicit status words, contrast consideration, keyboard use, terminal testing and audience research. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

Can Mordant handle longer translated messages?

Its text facilities support wrapping and alignment, but each real locale must be tested for layout, order and reader comprehension. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

How should a cancelled training prompt appear?

As cancelled or incomplete, depending on what was saved. It must not be confused with permission denial or an operational decision. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

Do all Mordant platform modules behave alike?

No. Capabilities vary with target and configured interface modules; test the specific artifact and document limitations. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

What is the safest first supported locale set?

A small set with complete reviewed consequential strings and real terminal tests is better than many partially translated locales. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

Can an application be bilingual within one screen?

Sometimes, but mixed-language status messages should be deliberate, clearly separated and tested for interpretability. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

How should deadlines be localized?

Use complete dates, time zones and typed values rather than relying on ambiguous short date formats. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

When should catalogs be retested?

Whenever role definitions, business rules, terminal modules, keyboard behavior or prompt API versions change. The broader test is whether the reader’s understanding, the saved values and the system’s evidence agree. A fluent phrase that changes the actual decision is not a successful translation.

References and further learning

Conclusion: change the language without changing the evidence

The most effective Mordant translation helps an emergency-training exercise coordinator understand a task, make a consistent choice and recognize the actual result. It preserves identifiers, typed values, review authority, cancellation and uncertainty as the surrounding words change. Begin with one complete workflow in an international simulated disaster-response training program; test it as a user would rather than merely counting translated strings.

When the evidence only supports “Exercise registration was recorded; the participant is not assigned to an operational response.”, publish that message plainly. Do not substitute “The participant is certified and deployed to an emergency.” just because it reads more confidently. A professional multilingual interface is not a collection of fluent labels. It is an agreement between what a person thinks the tool did, what the application stored and what the responsible authority can verify.