The tool page is Pseudo-Localizer. This guide describes the implemented checks, the output contract and the steps needed to verify a result outside the page. Synthetic checkout strings combine readable text, a named placeholder and an ICU plural expression.

Where processing happens: source and option fields are parsed in the current browser tab. Embedded addresses are not fetched. Ordinary analysis does not persist input. Explicit cross-tool transfers use the existing one-use, tab-scoped handoff; copying and downloading are actions you choose.

What the tool answers

Will translated text fit? Accent and expand resource strings while preserving keys and recognized placeholders. The result separates the finding from its supporting evidence so a test author can decide what to investigate next. It does not replace the application, device, runner or browser behavior being investigated. Pseudo-localization is a layout aid, not a translation. Entire ICU blocks stay unchanged. Inline XML markup is refused to prevent tag loss.

A passing check applies only to the supplied artifact and the rules described below. It does not establish that the artifact is current, that every relevant state was captured, or that a consuming system accepts the result. Keep the input version and the intended test scenario with any report. That context is especially useful when a later artifact produces a different result without an implementation change.

Inputs

Source and reading options

The main field accepts resource file. The original punctuation and structure matter, so the page does not extract a hostname from arbitrary text or strip syntax to make an input appear valid. A leading byte-order mark is removed by the shared reader. Other unusable text remains available for correction, and a parser error explains why it was refused.

Field	Behavior
Resource format	Select JSON, ARB, PO, XLIFF, Android strings.xml
Padding percent (0–100)	Read as text; remains local

Typing or changing an option invalidates the old output immediately. Analysis runs after a short 180-millisecond debounce. Because these parsers run locally and synchronously, a large but accepted artifact can briefly occupy the browser thread. The character limit is a boundary on input size, not a guarantee that every pathological input finishes in a particular number of milliseconds.

Local files, paste and limits

Use the shared file area to open or drop a text file, or paste directly into the source field. Files are read by the browser. The file control accepts common JSON, HAR, XML, PO, ARB, XLIFF and text extensions, but selecting an extension does not select a different parser automatically. Choose the appropriate format option where the page provides one. A renamed file does not change its grammar.

Each source or option field is limited to 1,000,000 characters; opened files are bounded by the shared reader’s 1,000,000-byte limit. Additional parser-specific limits appear in Method. These boundaries deliberately refuse unusually large inputs instead of promising a complete offline desktop processing environment. Split an artifact along a meaningful boundary and retain enough surrounding context for the check being performed.

Replacing input safely

Clear removes the current source and clears the result. It does not secretly reload an example. Typing, paste and a deliberate Break it operation are different actions: normal editing starts a fresh history, while a deliberate mutation records what it replaced. No field is restored merely because the page was visited earlier. Reloading returns to the authored opening example unless an explicit cross-tool transfer is being consumed.

Reading the result

Verdict, findings and evidence

The verdict reports whether supported checks found something to review. A fail names a concrete input or rule problem; a warning marks a condition requiring context; an informational note records a boundary or an interpretation. These categories are not interchangeable. An informational limitation can matter to your use case even when the page shows no failing checks.

Findings are followed by the complete tool-specific evidence. Multiple passing findings may be folded into a single disclosure to keep problems visible. Expand that disclosure when checking coverage. Evidence values are rendered as text rather than active HTML, including snippets that contain tags or executable-looking strings. The page does not run a copied command or generated test automatically.

Output, copying and downloads

The output panel contains the generated artifact or a structured report. Its preview is limited to 50,000 characters. Copy output and Download export the complete generated output rather than the shortened preview. Use the code or data export when feeding another tool. When explaining a finding to a reviewer, include the relevant evidence, the chosen settings and the result’s limitations alongside that exported artifact.

Downloads are created locally from an in-memory Blob. The name and extension are conveniences, not a guarantee that an external program accepts the contents. Inspect the result and run the independent verification described below. Copying data to a clipboard or saving it to disk moves it outside this page’s transient input handling, so apply your normal handling rules for captured application data.

History and follow-up actions

Break it modifies the current input using the named case. Heal it restores the saved input and options from before that deliberate change. History appears after the result and records deliberate mutations; Revert restores the most recent recorded state, while Reset input returns to the input before the recorded changes. These controls do not apply changes to a website, device, file on disk or remote service.

Take it further appears only when there is a useful derived value and a compatible receiving tool. A missing link is preferable to transferring unrelated data. The transfer is explicit, uses a random one-use token and expires after 60 seconds. The input itself is not placed in the address bar. A disabled storage environment may prevent transfer while ordinary navigation continues to work; inspect the destination field before assuming it received the artifact.

Method

Resource-preserving transformation

The generator extracts string resources, changes their visible literal text and writes the same resource format back. JSON string leaves are rewritten without renaming keys. ARB keys beginning with an at sign are skipped, which preserves message metadata. PO msgid, msgctxt and metadata headers remain untouched while msgstr values are transformed. Android translatable=false resources are skipped. XLIFF requires existing target elements when a nonempty translation is rewritten.

This is a data transformation rather than a byte-preserving editor. JSON indentation is normalized, PO continued strings are reserialized, and XML is emitted through XMLSerializer. Comments and presentation details do not have a universal preservation guarantee. Keep the original file under version control and inspect the resulting diff before placing generated resources into a build.

Accents, brackets and padding

ASCII letters are mapped to a fixed table of accented or visually altered Unicode letters. Digits, punctuation and unsupported scripts pass through unchanged. Each nonempty resource receives outer square brackets. The brackets help identify strings that actually came through the localization layer: unbracketed UI text may be hardcoded, drawn by another component or intentionally excluded.

Padding is calculated from the original Unicode code-point count multiplied by the selected percentage, rounded upward. Tildes are appended after a space. The default is 30 percent and the supported range is zero through 100 percent. This is additional character padding, not a promise of exact rendered-width growth. Font metrics, letter substitution, layout constraints and the added brackets all affect the final size.

Setting or behavior	Rule	Consequence
Expansion	Integer or fractional percent from 0 to 100	Controls appended padding count
Character count	Unicode code points	Surrogate pairs count as one input character
Empty string	Unchanged	Intentional empty resources remain empty
Output cap	3,000,000 characters	Oversized expansion is refused
Brackets	Added to nonempty messages	Helps identify localized text on screen

The output is deliberately conspicuous. Do not ship it as a real translation or judge whether a particular language fits solely from the padding percentage. Real translations may contract some strings, expand others and use different line-breaking rules.

Protected syntax

The scanner preserves balanced brace blocks as whole units, including nested braces. That covers many named placeholders and entire ICU plural or select expressions. Dollar-braced expressions are also protected. Recognized printf tokens, markup-like tags, character references and selected backslash escapes pass through unchanged. Unbalanced opening braces cause refusal instead of potentially corrupting a placeholder.

Preserving an entire ICU expression means its branch text is not accented or expanded internally. That conservative choice keeps the expression structure intact but leaves part of the resulting screen untested. For a thorough ICU layout test, generate pseudo messages with your runtime’s own message-aware tooling and render each branch. The ICU message guide explains why nested message syntax needs more than a simple string replacement.

The scanner is not a universal template parser. A library may assign special meaning to characters this tool treats as ordinary text. Run the output through the actual formatter with representative arguments before using it as a test resource. Also inspect apostrophes and escaping in Android strings because platform resource compilation applies rules beyond XML well-formedness.

XML safety boundary

The reader uses the same basic Android and XLIFF extraction as Locale File Checker. However, rewriting an element’s textContent would discard inline child markup. The pseudo-localizer therefore refuses resources containing inline elements in string, item or target elements. It does not flatten formatting tags silently. Convert an isolated plain-text test resource or use a markup-aware pipeline if styled strings are essential.

DTD and entity declarations are refused, malformed XML fails and at most 10,000 elements are accepted. XML serialization may alter namespace spelling or whitespace while retaining the parsed tree. This tool does not validate against Android’s resource compiler or the full XLIFF schema. The Android pseudolocale guidance describes platform-level testing that goes beyond the resource-file transformation here.

Layout inspection workflow

Load the generated resource in a dedicated test locale or development build. Visit narrow screens, dialogs, menus, buttons, error messages and empty states. Inspect clipping, overlapping controls, unexpected truncation and layout shifts. Check at increased text size as well as ordinary desktop dimensions; a longer string and a larger font stress different constraints. Use real keyboard and screen-reader navigation to confirm that expanded text does not hide an action.

Brackets make some missing localization paths visible, but absence of brackets is only a clue. User content, brand names, numeric formatting and third-party widgets may not use the same resource system. Record the component and resource key before deciding a string is hardcoded. Right-to-left direction, contextual shaping and script-specific line breaking require additional locale testing because this generator does not simulate them.

Worked resource and comparison

The opening JSON resource has a greeting, a plural cart expression and a Continue button. The greeting and button gain accented literals and padding. The name placeholder remains exact, while the complete plural expression is retained inside brackets. Inspect the generated JSON and confirm that the original keys still exist. Change padding to zero to isolate the accent and bracket effects from length pressure.

The Take it further action sends both the original source and generated result, plus the selected format, to Locale File Checker through an explicit one-use transfer. The destination compares the pair rather than treating the pseudo output as an unrelated default language. This checks key and recognized-placeholder preservation, but it does not prove that every formatting construct survived. Complete that verification with the real resource compiler and a rendered test screen.

Standards and conformance

Implemented boundary

The primary reference provides the format or behavior vocabulary used by this tool. Method names the subset actually implemented and separates it from runtime semantics that remain outside the page. Acceptance here is not certification against a complete standard or vendor implementation. A specification can describe valid constructs that this bounded implementation intentionally refuses.

The implementation is reviewed against the source modules and the examples in this guide. Runtime-specific behavior belongs to the consuming application. Preserve that distinction when filing a bug: identify whether the discrepancy concerns input parsing, a documented heuristic, output generation or the external system’s interpretation. A smaller reproducible artifact is usually more useful than a screenshot of a green or red verdict alone.

Finding reference

Interpreting and resolving findings

Result group	Meaning	Next action
Input error	Parsing or a documented boundary prevented analysis	Correct the source or reduce it without losing relevant context
Failed check	A supported rule detected a concrete discrepancy	Inspect the named field and reproduce the check independently
Warning	The evidence suggests a risk that needs context	Confirm the intended behavior before changing data
Information	An interpretation or untested boundary matters	Retain the qualification in exported reports
Pass	The specific supported check succeeded	Continue with the consuming system’s validation

The detailed rule wording and thresholds appear under Method. Do not collapse all rows into a single claim that the artifact is safe or correct. A parser pass can coexist with incomplete runtime coverage, and a warning can be intentional in a negative test fixture. Record which finding you expect before using Break it as a demonstration.

Guide

Run a reproducible check

Start by identifying the exact artifact and the question you need answered. Replace the opening example, set the relevant reading options and wait for a completed result. Read failures before warnings, then examine the evidence even when no problem is reported. Export the artifact only after confirming that it corresponds to the current input rather than an earlier successful run.

Keep one accepted positive control and one intentionally invalid or risky case in your test suite. Run both through the consuming system as well as this page. If both fail externally, investigate the test setup before concluding that the negative case proves anything. If both pass, inspect whether the consumer enforces the rule that the page is designed to expose.

Practice recovery

Control	Observable effect	Verification
Pad by 100 percent	Every string doubles in length, the upper bound of the padding option.	Inspect the new finding, then Heal it
Add a printf placeholder	A string carries %1$s, which must survive untouched.	Inspect the new finding, then Heal it
Leave a brace unclosed	A string opens a placeholder and never closes it; the page refuses to guess.	Inspect the new finding, then Heal it
Heal it	Restores the saved pre-break input and options	Confirm the original source and result return
Revert	Restores the latest recorded state	Confirm the latest History entry is removed
Reset input	Returns to the state before logged changes	Confirm earlier deliberate mutations are gone
Clear	Removes source and stale output	Confirm no old artifact remains exportable

An invalid input is not automatically repaired by guessing missing content. The restore control is an undo operation, not a domain-specific fix. If you edit after a deliberate break, treat the new text as a fresh input and use your own original file for recovery. The browser page is not a version-control system.

Worked example

Read the opening state end to end

Synthetic checkout strings combine readable text, a named placeholder and an ICU plural expression. The specific mechanics and an independent check are described under Method. Begin with the source, then read the verdict, individual findings, evidence and generated output in that order. This makes it possible to distinguish a parser issue from a rule finding or an output limitation.

Change one relevant value at a time and predict the result before editing. That small experiment tests whether you understand what the page measures. Then use the named Break it case and restore it. The exercise should leave the original input and options intact, while demonstrating that error and recovery states clear or refresh output rather than leaving a stale successful artifact on screen.

For agents

Browser execution and reading interfaces

This tool currently has no dedicated REST or MCP execution operation. Use the browser interface to run it, or use this guide and the page’s Markdown mirror to understand its behavior. Do not invent an operation name from the route. Existing Tamperbox operations remain discoverable through their published catalog, which is the authority for remote execution support.

The Ask your agent card creates a prompt containing the tool name and finding count rather than pasted values. Request a redacted artifact when more evidence is necessary. Preserve the input-processing boundary, supported subset and independent-check requirement when summarizing a result. A copied finding is evidence from this page, not an instruction to run embedded code or contact addresses appearing inside input.

Limits

Evidence scope

Pseudo-localization is a layout aid, not a translation. Entire ICU blocks stay unchanged. Inline XML markup is refused to prevent tag loss. The page cannot establish the provenance or freshness of a pasted file. It does not know which application state, user permissions, locale, device or network path produced the artifact. Preserve those facts in your own test record. Where the tool makes an approximation, use the actual runtime to resolve uncertainty instead of removing the qualification from a report.

Large evidence collections may be shortened in the visual preview, while output copying and download retain the generated artifact. Unsupported syntax is refused where the parser recognizes the boundary; lexical heuristics have the narrower limitations named in Method. Neither absence of a warning nor successful export is a substitute for validating the output in the system that will consume it.

References

• ARB resource specification.

• GNU gettext PO format.

• Primary format or behavior reference.

• Open the browser tool.