How do you translate MediaWiki pages with the Translate extension while keeping translation units, source changes, language links and reviewer decisions under control? This MediaWiki page translation guide explains translatable source pages, marking versions for translation, message groups, the translator interface, unit markers, fuzzy or outdated content and multilingual release testing. It is written for public documentation communities, software projects, nonprofits and knowledge-base editors serving readers around the world.
Installing or enabling translation features does not mean that a page is translated. The Translate extension organizes eligible text into manageable translation units, but translators still need a reliable source, preserved links and syntax, current terminology and a way to detect changes. A page can appear in a target language while containing an out-of-date permission rule, an untranslated template parameter or a misleading destination link. Those errors matter more than a high completion percentage.
This tutorial follows a fictional open-source marine-data community that publishes installation instructions, field protocols and contribution guidance in English, French, Spanish and Arabic. It draws on MediaWiki’s documented Translate extension behavior while separating technical page preparation from language and subject-matter approval. The goal is to teach editors to make each version trustworthy and navigable without breaking the collaborative wiki’s structure.
Quick answer: how to translate a MediaWiki page with Translate
Install and configure the extension with appropriate roles; choose a stable source page and source language; wrap reader-facing text using the supported translation markup; let a translation administrator mark the page version; translate coherent units; preserve identifiers and markup; monitor changed units; and release only after the target-language page passes factual, functional, accessibility and navigation tests.
From source page to maintainable translations
Understand what the Translate extension adds
MediaWiki can display pages in multiple languages through different approaches. The Translate extension provides structured translation of wiki pages and interface messages, using smaller translatable units and a translator workspace. It is not simply a machine translation button; it maintains relationships between source text and individual target-language messages.
Use the extension when a wiki wants organized, reviewable translation of shared documentation. Identify whether the task concerns page content, software messages or a manually managed separate language wiki. Those approaches have different ownership and migration consequences.
Open an existing translatable page and inspect its translation entry point. Compare an original paragraph with the target-language translation unit and confirm the source page remains the place where shared instructions change.
Make sure the extension and rights exist
The documented Translate extension has configuration requirements and translation-related user rights. The exact configuration depends on MediaWiki and extension versions. A contributor who can edit an ordinary page does not automatically have the rights to mark an entire source page for translation.
Confirm installation and enabled features with the site administrator before drafting a rollout. Assign rights deliberately: translators edit translations; translation administrators manage translatable page versions and related message groups.
Test access using a normal editor, translator and translation administrator. Record which person can prepare a source page, mark it for translation, review target content and publish sensitive changes.
Choose a stable source before segmentation
Every target version depends on a source that is reasonably authoritative. If the source page is changing rapidly, translators may keep updating text that will be replaced before review. MediaWiki’s own page-translation example recommends planning for source volatility.
Choose a pilot page with a clearly named owner and a stable purpose. Fix factual errors before inviting translations. Record its language and current revision. For an installation guide, verify the commands and supported versions first.
Ask the project maintainer to approve a short change window. Translate only after the source instruction has been tested by someone using the documented software version.
Set the source page language correctly
A wiki’s default interface language and an individual page’s original language need not be identical. MediaWiki documentation advises setting a source page’s actual language with the relevant page-language mechanism before it is marked for translation.
If a French-origin page is mistakenly treated as English source, downstream review and language metadata become confusing. Inspect the page’s actual prose, provenance and intended maintainer instead of assuming English is always the master.
Use a test browser with a different interface language. Confirm which page is the source and whether the system labels the content language correctly. Correct errors before expanding the translation tree.
Prepare source text inside translation tags
MediaWiki’s page translation feature uses translate markup to identify source content that should be split into translation units. Text outside those tags can remain common across language versions. That separation is powerful, but a misplaced boundary can leave important wording untranslated or expose markup to translators.
Prepare a small sample page with one title, two prose paragraphs, a list and a link. Review the rendered source before asking a translation administrator to mark it. Keep syntax that should remain fixed separate from human-facing language where appropriate.
Inspect the preview in both source and rendered forms. If an English warning sits outside translation tags and should be translated, revise the markup before publishing target-language versions.
Do not create unit markers by hand
The Translate extension adds unique translation unit identifiers after a page is marked. MediaWiki documentation explicitly warns editors not to add markers such as the T-number comment syntax themselves. The system needs stable identifiers to track changes to translation units.
Source maintainers should preserve existing markers when making reasonable edits and follow the documented rules for moving, splitting or deleting units. Manually inventing identifiers risks disrupting the update relationship.
Review a source revision after the page has been marked. Make sure markers remain in the intended positions and do not move between unrelated paragraphs. Test the target-language update flow before a large restructure.
Choose unit size for meaningful review
A translation unit should be large enough to preserve meaning and small enough to update without invalidating entire chapters. The Translate system commonly separates paragraphs and other elements based on its documented markup rules. Very long units are expensive to review; tiny fragments can lose context.
Prefer clear paragraphs that express a complete idea. Keep headings, warnings and examples in units that can be interpreted coherently. Protect the structure of tables and complex templates rather than slicing their syntax arbitrarily.
Ask a translator to explain a unit without looking at the entire document. If the fragment lacks the subject or condition necessary to choose the correct words, revise segmentation or provide context.
Mark a version for translation as a release step
After prepared source markup is saved, a translation administrator can mark a particular page version for translation. MediaWiki’s example describes the page-marking step and the appearance of the translate action for contributors. It is distinct from simply saving an edited source page.
Have the source owner confirm the material is fit for translation; then the translation administrator reviews units and marks the version. Record the revision being exposed to target teams.
Make a small test edit to the source and verify that translators can distinguish already-marked content from new changes awaiting marking. Do not promise fresh translations when the new source revision has not entered the workflow.
Understand translation pages and unit storage
The documented page translation structure includes the source page, language-specific page versions and separate translation-unit records that the extension uses to assemble translated pages. This structure explains why direct manual edits to generated target pages can conflict with the managed workflow.
Teach editors to use the translation interface for managed content rather than treating each generated target page as an unrelated article. Verify how the current extension handles manual edits and generated updates before attempting migrations.
Open a translation through its normal link, then inspect where the editor is directed for changes. Confirm the desired update survives regeneration, and use staging for any experiment that touches internal translation pages.
Protect page titles and headings
Titles tell readers whether a page solves their problem. A source titled ‘Contribute observations’ should not become a target-language phrase that implies submitting official regulatory data. Headings also influence translation units and navigation, so a careless restructure can trigger widespread updates.
Write a terminology note for high-traffic titles and headings before translating paragraphs. Test candidate wording with people who would genuinely seek the task. Include common regional phrasing where appropriate.
Check the target title in navigation, search results and the page itself. The reader should anticipate the correct action. If a title promises approval when the workflow merely requests review, change it before release.
Use variables to protect untranslatable text
The Translate documentation describes translation variables that keep certain text, such as fixed link targets or file names, out of the normal translator-editable sentence. This helps a translator change the visible label without breaking a destination or identifier.
Separate technical constants from the translatable explanation. Use the extension’s supported variable syntax, not an improvised string substitution. Keep variable names meaningful and document their role for translators.
Translate a sample sentence containing one variable and render it in every target language. The label may change, but the protected target must stay correct. Also verify that punctuation and reading order remain natural.
Watch templates, links and complex wikitext
MediaWiki pages can contain templates, nested links, parser functions, tables and code examples. Translation markup interacts with that syntax. MediaWiki documentation warns about placing tags in unnamed template parameters and across incompatible structural boundaries.
Inventory complex constructs before segmentation. Use named parameters when required, preserve actual commands and link targets, and avoid asking a translator to repair broken source markup. Consider a dedicated template localization strategy if the visible text originates there.
Render a test translation containing the exact template and a table. Verify that parameters, column alignment and links still work. An editor preview alone may not expose every runtime issue.
Handle translation-unit changes precisely
When the source changes, Translate can compare it to existing units. Keeping appropriate markers lets translators see what changed. Removing markers unnecessarily can make valid translations appear as completely new work. Conversely a major conceptual rewrite may justify a new unit.
Categorize updates as typographical, contextual or substantive. Leave stable units alone. When a source sentence changes a safety limit, highlight that meaning for reviewers rather than burying it inside dozens of cosmetic changes.
Change a short installation requirement in staging. Inspect the target-language status and verify that the correct unit—not the entire chapter—is identified for attention. Confirm the update’s impact before moving it to public pages.
Understand outdated and fuzzy status
The Translate ecosystem uses outdated or fuzzy states to indicate content that may not match the current source. Documentation describes change tracking and how stale units may be visibly distinguished. A target page existing is not the same as a target page fully updated.
Develop an editorial rule for outdated material. A minor spelling change can await normal review; a changed instruction about data access requires rapid action. Do not use a single percentage threshold as a substitute for assessing risk.
Visit the language page as an anonymous reader after a controlled source change. Verify how the installed extension presents outdated text and whether the notification is clear enough for the page’s risk level.
Keep page-language links honest
MediaWiki supports patterns such as Special:MyLanguage links that can direct readers to a suitable available translation. Their behavior depends on the content structure and translation setup. Links that always point to a source-only subpage can break the multilingual experience.
Use link conventions recommended for the site’s Translate workflow. When the intended destination has no translation, disclose that it is available in another language instead of creating a page with empty filler.
Follow related documentation through at least three links in each language. The route should stay connected to the relevant topic and not unexpectedly land on a generic home page.
Do not mistake interface localization for page translation
MediaWiki has interface messages and content pages. The Translate extension can support both kinds of work, but their review and deployment paths differ. A translated editor button does not show that the target reader’s install instructions have been reviewed.
Build separate coverage summaries: software interface, documentation pages, templates, generated notices and downloaded material. Name who maintains each set.
Change the interface language and inspect a page without a target translation. Record what still appears in the source language. This simple demonstration prevents many false completion claims.
Use message groups for coherent translation work
The extension manages groups of translatable messages, including those used for pages and software localization. Group-level statistics and workflow controls can help coordinate contributors across a large project.
Organize work around audience tasks or software components rather than arbitrary batches of isolated messages. Give translators context, term definitions and example output. Prefer a coherent guide over a pile of unrelated fragments.
Have a reviewer inspect the same term across five related messages in a group. If the translated wording changes a technical concept, correct the glossary or source context before accepting it.
Distinguish roles in translation review
Translation and translation-management rights are not interchangeable. MediaWiki’s documented rights model includes permissions for translating, managing groups, importing and marking pages. Depending on configuration, review rights can also be assigned.
Design a small responsibility matrix: source maintainer, translator, target-language reviewer, translation administrator and release owner. Avoid making all contributors system administrators simply to let them suggest a word.
Test privileges with separate accounts. Confirm target contributors can edit intended translations without changing protected site settings or moving unrelated source pages.
Preserve technical commands and version facts
An installation guide may include package names, shell commands, environment variables, version numbers and configuration file paths. Their spelling can be operationally significant. Translating a fixed code token can break software even when the surrounding sentence reads naturally.
Mark code and identifiers as protected where appropriate. Provide natural-language explanations for commands rather than trying to localize the executable bytes. Review locale-specific formatting separately from machine-readable syntax.
Run the instruction in a disposable test environment or conduct an expert command review. A language reviewer alone cannot certify a translated code example works.
Build an accessible target-language reader journey
Longer translated headings can overflow small screens. Right-to-left text can interact awkwardly with left-to-right code and numbers. Link labels, assistive-language metadata and keyboard navigation still need testing after the prose has been approved.
Include a right-to-left language where the project actually serves those readers. Test headings, punctuation, mixed-script identifiers, code blocks and language navigation. Never treat visual rearrangement as a substitute for readable semantics.
Ask a reader to locate the setup command and interpret an error explanation without switching back to the source. Repeat with keyboard navigation and a narrow viewport.
Handle images and downloadable documentation separately
A diagram with embedded English labels is not localized by translating a paragraph beneath it. A PDF attachment might remain in an older revision. These assets need their own language coverage and sign-off.
Maintain a list of linked downloads, image text, alternative text and file revisions. Where no approved translation exists, label the original language rather than renaming the file to imply otherwise.
Download each target-language asset from the published page, open it and confirm the instruction is current. Check that the visible file label matches its actual contents.
Make a real translation quality policy
Fluent wording can obscure a wrong condition. The source might say access is allowed only after account verification; the target may say it is allowed after registration alone. That is not a cosmetic difference.
For each critical page, make a meaning-check table covering actors, conditions, negation, dates, quantities, permission levels and next actions. Have a subject expert and target-language reviewer validate the same statements.
Give two reviewers the same task scenario in different languages and ask for the required decision. If their answers differ, the target is not ready even if the extension reports all units translated.
Review machine suggestions carefully
Translation memory and machine-aided tools can support productivity, but a suggestion is evidence of a plausible wording, not evidence that the source’s current meaning survives. A reused string may be wrong in a different software version.
Check each suggestion for context, sensitive data handling and exact technical terms. Keep accountable approval before high-impact instructions go public. Do not automatically publish raw output just because it fills an empty translation unit.
Sample units containing version constraints, negative instructions and permissions. Require reviewers to explain the actions implied by the translated text, not merely whether it sounds familiar.
Plan migration from manually translated pages
An older wiki may already contain language-specific subpages maintained outside Translate. Moving them into a managed unit workflow can overwrite expected content structures or require alignment. MediaWiki documents migration approaches and administrative considerations.
Inventory old translations and histories first. Pilot one low-risk page using the documented migration facility for the installed extension. Preserve attribution, active links and revision evidence where possible.
Compare the old target page, imported translation units and the new generated page. Do not declare migration complete merely because a language selector appears; verify meaning, history and all linked destinations.
Decide how to release or withdraw incorrect translations
The extension manages translation status, but site owners still need a policy for unsafe or misleading material. Leaving a wrong permission statement visible while waiting for a contributor is not a defensible release strategy.
Define who may block a target version, how readers are informed of incompleteness and where the current authoritative information lives. Distinguish a noncritical typo from an operationally dangerous instruction.
Simulate an urgent source change and a broken link. Check whether staff can identify the affected unit, alert reviewers and make a safe public decision without breaking other languages.
Track maintenance instead of celebrating a percentage
A 100 percent translated page can become outdated minutes after a source revision. Community translation work is continuous, especially for software documentation whose procedures change with releases.
Measure source revisions awaiting target review, high-impact stale units, broken language routes, unresolved terminology issues and completion of real user tasks. Keep a named owner for each serious exception.
Review the measures after a release. If the French installation guide still references an unsupported package version, prioritize that fact over a perfect completion chart.
Teach new contributors with a small practice page
A structured practice exercise can demonstrate what the extension protects and what it cannot guarantee. It also reduces the risk that a new volunteer will damage markup while trying to improve a sentence.
Give trainees one paragraph, one heading, a link, an immutable code token and a short table. Let them work through the translation interface, use context, check the rendered page and explain how a source edit affects the translation unit.
The exercise passes when the trainee preserves functional syntax, produces natural target language and can locate the stale-unit indicator after a source change.
Document evidence for audit and future updates
A multilingual documentation project should retain what version was translated, why a technical term was chosen, who approved a sensitive instruction and how the target page was tested. Without that history, every later correction starts from guesswork.
Use concise revision notes and issue links rather than copying entire confidential documents into uncontrolled spreadsheets. Include page identity, language, source revision, date and test result.
When a reader reports a wrong instruction, another maintainer should be able to reproduce the relevant version and see whether the issue arose in source content, translation or later configuration.
Ten failure cases to rehearse before public release
Case 1: Source changes one permission rule
A project changes from allowing access after registration to allowing it only after account verification. The French translation unit still states the old condition. The translation administrator makes the new source available, the target reviewer checks the changed unit and the project blocks misleading guidance until it is corrected.
For this case, compare a source-language reader and a target-language reader using the same assumptions. Preserve the exact revision and any technical identifiers. If the action differs, identify whether source content, translation unit, markup, template or user-language routing caused the failure. Correct that layer, repeat the task and keep a short review note. A test that cannot be reproduced by another contributor is less useful than it first appears.
Case 2: A manually inserted unit marker
A contributor creates their own T-number comment while preparing a new page. The page appears confusing after marking, and later updates cannot be reliably interpreted. The correction removes improvised markers in a safe copy, follows the extension’s documented marking process and checks existing unit IDs before publishing.
For this case, compare a source-language reader and a target-language reader using the same assumptions. Preserve the exact revision and any technical identifiers. If the action differs, identify whether source content, translation unit, markup, template or user-language routing caused the failure. Correct that layer, repeat the task and keep a short review note. A test that cannot be reproduced by another contributor is less useful than it first appears.
Case 3: Code token translated into a word
The source contains an uppercase environment variable that resembles an ordinary English noun. A translator replaces the identifier with a natural target-language equivalent. The instruction then fails in testing. Reviewers preserve the literal token and translate only the surrounding explanation.
For this case, compare a source-language reader and a target-language reader using the same assumptions. Preserve the exact revision and any technical identifiers. If the action differs, identify whether source content, translation unit, markup, template or user-language routing caused the failure. Correct that layer, repeat the task and keep a short review note. A test that cannot be reproduced by another contributor is less useful than it first appears.
Case 4: An Arabic page with mixed-script commands
The target-language paragraph is right-to-left, but shell commands, file paths and version numbers remain left-to-right tokens. The editor tests the result with actual devices and assistive technologies. The goal is not to translate command syntax but to make the mixed-script reading order unambiguous.
For this case, compare a source-language reader and a target-language reader using the same assumptions. Preserve the exact revision and any technical identifiers. If the action differs, identify whether source content, translation unit, markup, template or user-language routing caused the failure. Correct that layer, repeat the task and keep a short review note. A test that cannot be reproduced by another contributor is less useful than it first appears.
Case 5: A generated subpage edited directly
A volunteer sees a language-specific page and changes its prose outside the supported translation workflow. The next generation cycle overwrites the edit or leaves inconsistent state. The correction is made through the managed translation unit and verified after a fresh assembly of the page.
For this case, compare a source-language reader and a target-language reader using the same assumptions. Preserve the exact revision and any technical identifiers. If the action differs, identify whether source content, translation unit, markup, template or user-language routing caused the failure. Correct that layer, repeat the task and keep a short review note. A test that cannot be reproduced by another contributor is less useful than it first appears.
Case 6: A source paragraph split into many tiny units
A heavily segmented instruction breaks a condition away from the action it governs. Translators produce fluent fragments that imply incompatible rules. The source maintainer revises the boundaries to preserve meaningful units and requires a task-level review.
For this case, compare a source-language reader and a target-language reader using the same assumptions. Preserve the exact revision and any technical identifiers. If the action differs, identify whether source content, translation unit, markup, template or user-language routing caused the failure. Correct that layer, repeat the task and keep a short review note. A test that cannot be reproduced by another contributor is less useful than it first appears.
Case 7: A stale translation hidden by completion statistics
Every French unit was translated last month, but the source guide changed after a release. A dashboard still looks reassuring to casual readers. The maintenance queue distinguishes existence from currency and prioritizes source-revision differences that affect the actual instruction.
For this case, compare a source-language reader and a target-language reader using the same assumptions. Preserve the exact revision and any technical identifiers. If the action differs, identify whether source content, translation unit, markup, template or user-language routing caused the failure. Correct that layer, repeat the task and keep a short review note. A test that cannot be reproduced by another contributor is less useful than it first appears.
Case 8: A wrong-language linked policy
A Spanish translated page links to a superseded English data-retention policy. The reader assumes the link describes the current policy. The site corrects the destination, labels the available language and opens a translation task for the missing Spanish policy instead of linking to a fabricated stub.
For this case, compare a source-language reader and a target-language reader using the same assumptions. Preserve the exact revision and any technical identifiers. If the action differs, identify whether source content, translation unit, markup, template or user-language routing caused the failure. Correct that layer, repeat the task and keep a short review note. A test that cannot be reproduced by another contributor is less useful than it first appears.
Case 9: An imported translation without proper alignment
A legacy German page is migrated into Translate, but paragraphs do not align with the source units. Reviewers identify shifted meaning and correct the import alignment in staging. They only release the generated page after the procedure passes a real-user task test.
For this case, compare a source-language reader and a target-language reader using the same assumptions. Preserve the exact revision and any technical identifiers. If the action differs, identify whether source content, translation unit, markup, template or user-language routing caused the failure. Correct that layer, repeat the task and keep a short review note. A test that cannot be reproduced by another contributor is less useful than it first appears.
Case 10: A translation that changes an exception
The English source says every file is public except restricted records. The target says restricted records may be shared with requesters. A subject expert catches the reversal, corrects it and records the negative condition as a protected meaning checkpoint for future edits.
For this case, compare a source-language reader and a target-language reader using the same assumptions. Preserve the exact revision and any technical identifiers. If the action differs, identify whether source content, translation unit, markup, template or user-language routing caused the failure. Correct that layer, repeat the task and keep a short review note. A test that cannot be reproduced by another contributor is less useful than it first appears.
Hands-on examples, review tools and frequently asked questions
A complete page-preparation example
Imagine a short English source article explaining how field researchers upload a validated ocean-temperature file. It has a descriptive title, an introductory paragraph, a list of requirements, a sample filename and a link to the validation tool. A good preparation process identifies which parts are reader-facing language and which parts are executable or fixed references. The descriptive prose belongs in coherent translation units. The filename pattern and command flags must remain technically correct. The link target should be protected from accidental editing, while the visible label can be natural in French or Spanish. A translation administrator then marks the reviewed source version, and a translator works within the supported interface. The rendered target is checked by someone who can actually complete the upload. This sequence teaches both language control and software correctness.
A source-change simulation for maintainers
Take a staging page whose current instruction says that records may be submitted within thirty days. Translate that paragraph into French, then change the source to require submission within fourteen days. Observe how the extension identifies the changed unit and which target version is presented to readers. Record the status before and after source marking, review and acceptance. Next make a spelling-only change elsewhere and compare the amount of review demanded. This test reveals whether staff understand the difference between a substantive stale instruction and a minor revision. It also checks that notifications, permissions and public labels work in the installed configuration. A team that cannot trace this controlled example will struggle with a real urgent policy change.
A translator checklist for protected material
Before accepting a unit, ask which tokens must remain exact: filenames, API endpoints, variable names, command options, code samples, version ranges, digital identifiers and referenced page titles. Then ask which words need adaptation: imperatives, explanations, headings, alt text and link labels. These are different tasks. A correct French sentence should not silently turn a machine-readable parameter into a French string. Likewise an unchanged code sample should not excuse an English-only explanation of what it does. Keep examples small and reproducible. Use a disposable environment for executing commands, and never put live credentials in a translation test. Record any translation variable or protected-token convention in the contributor documentation so new volunteers understand the reason.
The reader-journey test plan
Choose three tasks: locate the correct installation guide, identify a software requirement and submit a practice contribution. Create one English source and its approved French and Spanish versions. Ask participants to start from search results or a shared deep link, not from an editor preview. Measure whether they reach the right target page, understand a permission or condition, and complete the intended step. Include one intentionally unavailable language and one page with a recently changed source unit. The test should distinguish a missing translation from a stale one. After corrections, repeat the same routes with the same account state and browser language. The results are meaningful because the task outcome—not subjective fluency alone—is checked.
A review model for public technical documentation
The source maintainer knows the current software behavior; the translator knows target-language expression; a regional contributor knows local vocabulary; an administrator understands translation markup and permissions; and a release owner decides whether a known limitation is acceptable. One person may hold several roles on a small project, but their responsibilities should remain explicit. The translation administrator should not be expected to certify every scientific claim. A translator should not change API semantics to make a sentence sound smoother. A developer should not override regional language feedback without examining the actual reader task. This division supports careful decisions without slowing ordinary edits unnecessarily.
Questions readers and contributors often ask
Does enabling the Translate extension automatically translate every page? No: source pages must be prepared, marked and translated through appropriate workflows. Can a translator edit units without being able to mark source page versions? Yes, roles and user rights are distinct. Should contributors type translation unit markers manually? No; the extension creates them. Can translated pages become outdated? Yes; source changes may require target review. Does a translated interface mean the article was localized? No; messages and page content are different surfaces. What happens to old manual translations during migration? That depends on the migration procedure and requires careful alignment and verification. What is the most useful acceptance test? Ask a real reader to complete a task with the translated page and confirm the action matches the source.
A practical release gate
Before announcing a new language, confirm that the source page is correct and marked for translation, key target units are reviewed, formatting and variables render, code and identifiers remain valid, navigation reaches the intended versions and critical figures are unchanged. Inspect how outdated units are signalled to readers. Test both anonymous and logged-in access. Review search snippets and language metadata for major pages. Finally, keep a rollback decision and named contacts for urgent corrections. Do not claim universal coverage simply because one page has all its units filled. A clear partial-coverage statement is more useful than an impressive but misleading number.
How to investigate a failed translation report
Ask for the source page, target language, exact destination URL, user account state, the last source revision and a screenshot or verbatim error if possible. Check whether the symptom is a missing target unit, an outdated source relationship, a broken template, a right-to-left display issue, a permission denial or a language-link problem. Reproduce the fault on a private test page before changing public content. Apply the smallest safe fix and rerun the reader’s original route. Write down whether the correction belonged in the source page, the target translation unit, the template, the configuration or the release process. This prevents unnecessarily re-translating valid material.
Official MediaWiki references and the translation library
Feature availability and configuration details can vary by MediaWiki and Translate extension version. Use the official help pages below to check markup, version marking, rights and translation-unit behavior in the deployed installation.
MediaWiki Translate extension · Page translation administration · Page translation example · Master Art of Translation · Translate Like a Pro series index.
Final principle: translation units protect work, not meaning by themselves
The Translate extension gives a multilingual wiki a better framework for maintaining source-to-target relationships. The responsible team still needs to check what readers understand, whether a changed source makes a version stale, and whether links, scripts and permissions work. A useful page translation is one a reader can trust to complete the task, not one that merely fills every available unit.