Translate Like a Pro | Plurals, Gender & Dynamic Variables

Dynamic text is where word-for-word localization breaks most visibly. A software message such as “Alex added 1 file” can change according to the person’s name, the number of files, grammatical gender, noun form, case, article, word order and locale-specific plural rules. A source language with two simple forms can map to a target language with several grammatical categories.

Searches for localization plural rules, ICU MessageFormat, grammatical gender localization, dynamic string translation, pluralization internationalization, localize variables, translation placeholders, select plural message format and software message localization describe one core problem: translators need control over the complete grammatical message, not a bag of fragments joined by code.

This guide shows how to design and translate dynamic messages so number, gender and runtime variables remain natural across languages. It covers complete-message authoring, plural categories, select logic, variable semantics, unknown values, ordinal forms, nested choices, agreement, rich-text placeholders, validation, screenshots, fallback, testing and the practical use of ICU-style MessageFormat patterns.

This article sits inside eduKateSG’s Master Art of Translation architecture and extends the professional operating layer. It does not replace the existing owners for project management, terminology, translation memory, release control or file preparation; it connects to them where those systems become relevant.

Quick answer

The safest dynamic-message design gives translators one complete sentence or message pattern, meaningful named variables, clear examples and locale-aware plural/select logic. Do not ask translators to assemble grammar from fixed fragments. The program supplies data; the localized message pattern decides how that data belongs in the sentence.

Write complete messages: avoid runtime concatenation.
Name arguments: tell translators what each variable means.
Use locale plural rules: do not copy English singular/plural assumptions.
Use select logic carefully: gender or category can affect surrounding grammar.
Keep an other path: handle unknown or uncategorized values safely.
Test real values: zero, one, two, large numbers, names and edge cases.
Validate syntax: message patterns are executable data as well as language.

1. Translate the complete message, not fragments

Natural grammar requires visibility of the full sentence. Word order, agreement and articles can change around variables in ways developers cannot predict from the source language.

Professional method. Expose complete message patterns such as ‘{user} added {count} files’ rather than translating ‘added’, ‘file’ and plural ‘s’ separately. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. Runtime concatenation freezes source-language grammar into code. A target language may place the count before the verb or change the verb and noun together.

Verification. Ask whether the translator can reorder every semantic unit needed for natural target syntax. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

2. Use meaningful variable names

A placeholder is easier to translate when its meaning is obvious. {0} and {1} hide whether values are names, dates, counts, products or destinations.

Professional method. Prefer named arguments such as {userName}, {fileCount} and {cityName}, and supply descriptions with realistic values. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. A translator cannot tell whether {1} is singular, plural, human or machine-generated. Knowing that {count} is an integer controls plural choice; knowing that {ownerName} is a person may affect case or agreement.

Verification. Give the pattern to a reviewer without source-code access and see whether each argument is understandable. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

3. Treat plural categories as locale data

Languages do not share one universal singular-versus-plural system. Unicode CLDR defines locale-specific plural categories such as one, few, many and other according to language rules.

Professional method. Use locale plural-rule engines instead of hard-coded source-language conditions. Provide all required submessages, with ‘other’ as a mandatory safety path where the message system requires it. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. Developers write count == 1 ? singular : plural and reuse it globally. A language may use different forms for numbers ending in particular digits or for fractions, while another may use one form for most values.

Verification. Test the locale’s representative plural categories using the actual formatter. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

4. Do not equate zero with one universal plural form

Zero can follow different grammatical patterns by language and message. Some locales map zero to a category that differs from English expectations, while product copy may also use a special semantic message such as ‘No files’.

Professional method. Decide whether zero is a grammatical plural case or a deliberate product-specific special message, and encode it explicitly when needed. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. Translators receive a single English ‘0 files’ pattern and assume it controls every locale. A product may choose ‘No messages’ as a distinct user-friendly branch while other languages still require locale-correct grammar inside that branch.

Verification. Test zero separately in every supported locale. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

5. Distinguish cardinal from ordinal plural logic

Counting objects and expressing order are different grammatical jobs. Languages can use different rules for ‘1 file’ versus ‘1st place’.

Professional method. Use the correct cardinal or ordinal rule set supported by the internationalization library. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. A generic plural function is reused for ordinal suffixes. English itself distinguishes 1st, 2nd, 3rd and 4th, illustrating that number morphology depends on function.

Verification. Test representative ordinal values including teens and boundary numbers. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

6. Model grammatical gender separately from person identity

Grammatical gender is a property of language forms, not a universal statement about a person. Agreement may depend on the grammatical class of nouns as well as natural gender or other categories.

Professional method. Keep data fields precise: person-gender information when legitimately available, noun grammatical class in locale resources, and an ‘other’ or unknown path where required. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. A system assumes English he/she categories are enough for every language. An adjective may agree with a localized noun’s grammatical gender even when no person is involved.

Verification. Review each selection input with a linguist for that locale rather than importing source-language categories. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

7. Provide a safe unknown or other case

Dynamic systems encounter missing, mixed or unexpected values. Message selection must remain grammatical and respectful when category data is absent.

Professional method. Design an ‘other’ branch that does not depend on unavailable information, and avoid manufacturing identity attributes solely to satisfy grammar. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. The UI crashes or misgenders users when a field is missing. A neutral rephrasing can avoid a pronoun altogether in the unknown branch.

Verification. Test null, missing and unexpected selector values. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

8. Use select logic for categories, not hidden translation fragments

A select branch should choose complete meaningful submessages. Nested fragments can become impossible to translate because agreement spans across the branch boundary.

Professional method. Keep enough surrounding text inside each selected message for natural grammar. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. The developer selects one adjective form while the translator needs to change the article, noun and word order too. A gender-dependent participle may require the whole clause to be selectable in one locale.

Verification. Ask the translator whether changing the selector requires edits outside the selected fragment. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

9. Nest plural and select only when the language job requires it

Dynamic messages sometimes depend on both count and another category. ICU MessageFormat supports nested plural/select patterns, but complexity grows quickly.

Professional method. Model the simplest complete pattern that preserves grammar, document arguments and validate it with tooling. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. A single message becomes unreadable code because every optional stylistic variation is encoded as a branch. A message may select by count first and then by grammatical agreement category only within the singular branch.

Verification. Test every reachable combination and have a linguist read the full set. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

10. Keep values and formatting separate from grammar when possible

Dates, numbers and currency have locale-specific formatting independent of sentence structure. A translator should not manually format every runtime value in text.

Professional method. Pass typed values to locale-aware formatters and let the message pattern place them grammatically. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. Source-formatted ‘$1,234.50’ is inserted unchanged in every locale. The same numeric amount can be formatted under locale rules while the surrounding sentence is translated once.

Verification. Run the message under several locales with the same underlying value. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

11. Do not hide variable semantics behind screenshots alone

A screenshot shows appearance but not the full runtime value space. Translators need to know whether a variable can contain one word, a sentence, a list, an empty value or user-generated text.

Professional method. Provide argument type, examples, length expectations and whether values are already localized. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. A translator writes punctuation assuming the variable never contains its own punctuation. {itemList} may expand to multiple localized names and require different conjunction handling.

Verification. Review documentation for every dynamic argument, not just the screenshot. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

12. Protect variables without freezing word order

Syntax must remain intact while placement stays flexible. A placeholder is machine data, but its position belongs to target-language grammar.

Professional method. Use protected-variable handling from file preparation while allowing the translator to move the placeholder anywhere within the complete message pattern. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. The tool locks the entire surrounding fragment to keep one placeholder safe. {userName} stays unchanged but can move from sentence start to a later position.

Verification. Confirm placeholder identity and count after translation while allowing reordered positions. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

13. Avoid concatenating punctuation around variables in code

Punctuation often belongs to the localized message. Spacing and punctuation conventions vary, and bidirectional text can make fixed separators especially fragile.

Professional method. Include human-facing punctuation inside the translatable message pattern unless it is machine syntax. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. Code always appends ‘:’ after a label even in locales that use a different pattern. A translator may need a different colon spacing convention or no colon at all.

Verification. Inspect the final rendered label, not just the translated word. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

14. Handle rich text with controlled placeholders

Links, emphasis and UI components can sit inside translatable messages. Splitting at formatting boundaries can destroy grammar.

Professional method. Use structured rich-text placeholders that let translators reorder complete elements while preventing arbitrary markup edits. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. A sentence is split into three resource strings around a hyperlink. A target language may need the linked phrase earlier in the sentence than English.

Verification. Render and click all structured elements after translation. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

15. Give translators examples for each branch

Message syntax is abstract; concrete values reveal grammar. A translator may not visualize how nested branches render.

Professional method. Provide preview tooling or sample outputs for plural/select combinations. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. The pattern is linguistically approved without anyone seeing the actual one, few, many or other outputs. A preview panel can render {count}=0,1,2,5,21 with representative selector values.

Verification. Compare preview outputs against expected grammar before release. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

16. Validate MessageFormat syntax automatically

Dynamic message patterns are executable configuration. A missing brace or selector can break rendering.

Professional method. Parse and validate message patterns in CI or localization QA before they reach production. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. A linguistically good translation contains one unmatched brace and the application displays an error. The build can reject invalid ICU patterns just as it rejects malformed JSON.

Verification. Inject a known syntax defect and expect the pipeline to fail. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

17. Test every reachable branch

A pattern can be syntactically valid while one branch is never linguistically reviewed. Rare plural categories or unknown-selector paths may appear only under specific runtime data.

Professional method. Generate branch-coverage tests from locale plural categories and selector values. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. Production users are the first to see the ‘many’ branch. Automated snapshots can render representative values for every locale category.

Verification. Compare the test matrix with the actual branches defined in each message. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

18. Avoid encoding social assumptions into grammar

Dynamic language systems should not infer sensitive attributes unnecessarily. A grammatical convenience is not sufficient reason to collect or guess personal data.

Professional method. Prefer neutral sentence designs when the product does not already have legitimate, consented information needed for another purpose. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. The localization layer guesses a user’s gender from name or profile photo simply to select a pronoun. Rewriting ‘He/She uploaded a file’ as ‘{name} uploaded a file’ can remove the need for gender data.

Verification. Ask whether the message can be grammatical without collecting or inferring the attribute. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

19. Version message schemas as well as translations

Changing variable names or branch structure changes the translation contract. Old target patterns may not be compatible with the new runtime arguments.

Professional method. Treat message-schema changes as source changes, migrate translations and invalidate incompatible approvals. The rule should be explicit enough that a translator, reviewer, developer or project manager can apply it again without relying on the memory of the person who first solved the problem.

Failure mode. A developer changes {count} to {fileCount} and production keeps an old localized pattern that references the missing argument. Schema validation can identify target messages with arguments that no longer exist.

Verification. Compare source and target argument sets during every build. If the check fails, repair the upstream rule or system rather than merely polishing the latest output.

A repeatable operating sequence

Dynamic-message localization is easiest when the application exposes linguistic choices as structured message patterns and keeps raw runtime data separate.

Write each user-facing message as a complete translatable unit.
Name variables by meaning and document types and examples.
Use locale-aware number, date and currency formatting.
Use locale plural rules for cardinal and ordinal cases.
Add select logic only for information the product legitimately has.
Provide safe other/unknown branches.
Keep agreement-sensitive grammar inside complete selectable messages.
Protect placeholder syntax while allowing reordering.
Preview representative runtime values.
Parse and validate patterns automatically.
Test every plural and selector branch for supported locales.
Reopen translations whenever the message schema changes.

The sequence should be treated as a loop rather than a one-way checklist. If a late-stage test exposes a hidden assumption, return to the earlier design decision and repair that source. This is how a translation operation becomes more reliable over time instead of accumulating workarounds.

Worked scenarios

1. File-upload notification

The message contains a user name and a file count. The hidden constraint is assuming English singular/plural and fixed word order.

Use a complete localized pattern with named arguments and locale plural rules, then preview zero, one, two and larger values. Then verify the result in the environment where it will actually be used. The same linguistic choice can behave differently once variables, locale settings, indexing, build automation or project assets enter the system.

2. Activity feed with unknown user gender

The source uses an English pronoun generated from profile data that may be absent. The hidden constraint is making grammar depend on unreliable personal attributes.

Prefer a name-based or otherwise neutral formulation where possible and keep an explicit unknown branch if selection remains necessary. Then verify the result in the environment where it will actually be used. The same linguistic choice can behave differently once variables, locale settings, indexing, build automation or project assets enter the system.

3. Localized subscription price

The message combines plan name, amount, billing period and renewal date. The hidden constraint is mixing grammatical placement with source-formatted values.

Pass typed values, use locale formatters for money/date and let the localized message control the order. Then verify the result in the environment where it will actually be used. The same linguistic choice can behave differently once variables, locale settings, indexing, build automation or project assets enter the system.

4. Link inside an error message

The source splits text before and after a ‘Learn more’ link. The hidden constraint is source-order fragmentation.

Use a structured rich-text placeholder so the translator can move the link phrase within a complete sentence. Then verify the result in the environment where it will actually be used. The same linguistic choice can behave differently once variables, locale settings, indexing, build automation or project assets enter the system.

5. Schema update changes one argument

Development renames a variable and adds a new selector. The hidden constraint is old approved target patterns remaining syntactically valid-looking but incompatible.

Treat the schema change as a source revision, invalidate affected approvals and run argument-set validation. Then verify the result in the environment where it will actually be used. The same linguistic choice can behave differently once variables, locale settings, indexing, build automation or project assets enter the system.

6. Locale with several plural categories

The translation platform exposes only singular and plural fields. The hidden constraint is tooling that cannot represent target-language grammar.

Move to a message format or localization system capable of locale plural categories rather than forcing the target into an English-shaped form. Then verify the result in the environment where it will actually be used. The same linguistic choice can behave differently once variables, locale settings, indexing, build automation or project assets enter the system.

Dynamic message localization: twenty practice cases

These cases are designed to turn the mechanism into operating judgment. For each one, identify the controlling layer, the evidence you need, the safest reversible action and the final acceptance test.

1. A new source string arrives five minutes before code freeze

Decide whether it enters the current release, inherits an existing approved translation, falls back safely, or waits for the next release. Record the decision rather than letting timing choose the policy. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

Then test the decision one level beyond the immediate sentence: another locale, another release, another runtime value, another search query, or a recovery scenario. Durable translation operations survive changed conditions.

2. A message contains two variables and a plural

Keep the complete sentence available to the translator. Test one, two, zero and large-number cases where the locale’s grammar requires them. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

3. A multilingual name list sorts strangely

Check locale-aware collation rather than alphabetic code-point order. Test the locale actually shown to users. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

4. A translation memory is accidentally overwritten

Restore from a known backup copy, verify the version and provenance, and compare new work before merging it back. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

5. A developer renames a resource key

Preserve translation identity through stable mapping or controlled migration instead of treating the content as a brand-new sentence without history. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

6. A source string changes punctuation only

Decide whether the change is semantically meaningful, formatting-only or an extraction artefact before sending the entire segment for retranslation. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

7. A locale needs three plural categories while the source has one singular and one plural

Model the target-language choices from locale plural rules rather than copying English grammar. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

8. Search finds ‘resume’ but misses ‘résumé’ or vice versa

Separate display spelling from search normalization and test the intended user behaviour instead of changing authoritative text. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

9. A termbase exists only inside one vendor account

Export a portable copy with definitions, locale scope, status fields and provenance so the organization can recover the asset independently. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

10. A branch is released while one locale is still reviewing

Use explicit release policy, coverage status and fallback behaviour rather than silently mixing approved and unapproved strings. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

11. A translator sees a sentence fragment with no variable examples

Provide the complete message, argument meanings and realistic sample values. Context is part of message design. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

12. A database sort puts accented names in a surprising order

Use locale-tailored collation appropriate to the application rather than Unicode code-point order. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

13. A cloud localization account becomes unavailable

Confirm that source files, bilingual assets, TMs, termbases, style guides and decision logs can be restored from independent backups. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

14. A developer concatenates translated fragments at runtime

Replace the fragments with a complete translatable message so grammar and variable order remain under translator control. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

15. A translation passes QA but was built from an obsolete source commit

Bind localization work to source version and release identity, then reject stale output at the gate. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

16. A target language has grammatical agreement with a user’s gender

Use structured selection logic and a safe unknown/other path rather than inserting English pronoun assumptions into every locale. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

17. A search index lowercases text using one global rule

Test locale-aware case behaviour because case mapping and search expectations vary across scripts and languages. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

18. A backup file exists but nobody has restored it in years

Run restoration drills. A backup that cannot be restored under pressure is only a comforting file. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

19. A localization job re-translates thousands of unchanged strings

Use source diffs, stable keys and translation memory carefully so genuine changes receive attention while unchanged approved content is reused. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

20. A product supports a new locale derived from an existing regional parent

Seed from the right parent and mark inherited versus locally reviewed content so reuse does not masquerade as locale approval. Write down what would make you change the decision. That final condition converts a habit or preference into a controlled professional rule.

Release checklist

Messages are complete units rather than concatenated fragments.
Variables have meaningful names and descriptions.
Plural logic is locale-aware.
Cardinal and ordinal rules are not confused.
Zero and other special cases are intentional.
Unknown selector values have safe branches.
Dynamic values use locale-aware formatters.
Placeholders are protected but reorderable.
Rich-text elements can move with grammar.
Patterns are parsed and validated automatically.
Every reachable branch is previewed and reviewed.
Sensitive personal attributes are not inferred merely for grammar.

Frequently asked questions

What is ICU MessageFormat?

It is a message-pattern system from ICU that supports arguments plus structured choices such as plural and select, allowing translators to control complete dynamic messages. The practical test is whether the rule remains reliable across the next update, locale or handoff rather than working only for the current example.

Why is ‘one versus other’ not enough for every language?

Plural categories vary by locale, and some languages distinguish several forms based on the number. The practical test is whether the rule remains reliable across the next update, locale or handoff rather than working only for the current example.

Should translators edit variable names?

No. Variable identifiers are machine syntax, but translators should be free to move the protected placeholder to the grammatically correct position. The practical test is whether the rule remains reliable across the next update, locale or handoff rather than working only for the current example.

What is the ‘other’ branch?

It is the fallback branch required by many plural/select message systems for values not matched by a more specific branch. The practical test is whether the rule remains reliable across the next update, locale or handoff rather than working only for the current example.

Can gender selection be used for grammatical gender of nouns?

Yes when modeled correctly, but noun grammatical class and person identity are different kinds of data and should not be conflated. The practical test is whether the rule remains reliable across the next update, locale or handoff rather than working only for the current example.

Why avoid concatenation?

Because languages differ in word order, agreement, articles and punctuation. Joining translated fragments freezes assumptions from the source language. The practical test is whether the rule remains reliable across the next update, locale or handoff rather than working only for the current example.

Do dynamic messages need special QA?

Yes. Validate syntax, arguments and branch coverage in addition to linguistic review. The practical test is whether the rule remains reliable across the next update, locale or handoff rather than working only for the current example.

Can AI translate MessageFormat patterns safely?

It can assist, but outputs still require syntax validation and human linguistic review because a fluent branch can be grammatically wrong or structurally invalid. The practical test is whether the rule remains reliable across the next update, locale or handoff rather than working only for the current example.

Selected technical and operational references

Conclusion

Dynamic localization succeeds when software provides data and the target language controls grammar. The application should not hard-code the linguistic decisions that only the target sentence can make.

Complete messages, meaningful arguments, locale plural rules, safe selection logic and automatic validation give translators enough control without sacrificing runtime reliability. That combination is what makes one dynamic feature truly multilingual rather than merely translated.

Translate Like a Pro | Localize Plurals, Grammatical Gender and Dynamic Variables Without Breaking Sentences