What CMS Supports Right-to-Left Languages Alongside Left-to-Right

A launch that ships perfectly in English breaks the moment your Arabic or Hebrew market goes live: prices land on the wrong side of the layout, mixed Latin-and-Arabic strings scramble into gibberish mid-sentence, and an editor in Dubai cannot see whether the paragraph they just wrote will render correctly until it hits production. For enterprises expanding into the Middle East, North Africa, or bidirectional markets, right-to-left support is not a checkbox. It decides whether an entire region of your business is legible to customers.

The uncomfortable truth is that most CMS platforms treat RTL as a frontend styling problem, when it is actually a content-modeling, editorial, and governance problem that reaches all the way into the data layer. Sanity, the Content Operating System for the enterprise, reframes RTL as a first-class attribute of your content model rather than a CSS afterthought, which is what lets one editorial team govern LTR and RTL markets from a single system.

This article walks through what genuine bidirectional support requires: per-field direction in the model, editors who can preview mixed-direction content, translation workflows that respect script, and the governance to ship it all safely across many markets.

Why RTL is a content-model problem, not a CSS problem

The most common enterprise mistake is delegating right-to-left support entirely to the frontend. A developer sets `direction: rtl` on the Arabic locale, ships it, and assumes the job is done. Then the real content arrives. A product description mixes an Arabic sentence with a Latin-script brand name and an SKU. A price string carries a currency symbol that needs to sit on the correct side of the number. A rich-text field embeds a link whose anchor text is Hebrew but whose surrounding clause is English. CSS direction alone cannot resolve any of these, because the direction of a run of text is a property of the content itself, not of the container it lands in.

This is why bidirectional support has to reach into the data layer. Each field, and sometimes each span within a field, needs to carry or infer its own direction so that mixed-script content renders predictably rather than relying on the browser's best guess. When direction lives only in a stylesheet, editors have no way to correct a run that the Unicode bidirectional algorithm mishandles, and QA teams cannot audit whether a given locale is modeled correctly.

Sanity treats content as queryable structured data in Content Lake, which means direction can be modeled as an explicit attribute rather than inferred at render time. A locale document can declare its script direction, individual fields can be typed per market, and rich text stored as Portable Text preserves the structure of mixed-direction spans instead of flattening them into an HTML blob. That structured foundation is what separates a CMS that tolerates RTL from one that actually governs it across a large multi-market estate.

Modeling bidirectional content across many markets

An enterprise running Arabic, Hebrew, English, and French markets is not managing two directions, it is managing a matrix of locales, each with its own script, direction, formatting conventions, and editorial owners. The modeling decision you make early determines whether that matrix stays manageable at fifty markets or collapses into a tangle of duplicated documents. Broadly there are two patterns: field-level localization, where a single document holds every locale's values in parallel fields, and document-level localization, where each locale gets its own document linked by reference. RTL markets stress-test whichever you pick, because direction has to travel with the content, not with the presentation.

Field-level works well when markets share structure and you want editors comparing translations side by side. Document-level works better when RTL markets diverge in structure, imagery, or legal copy, which is common in regulated regions. The point is that the model, not the theme, should encode which markets are RTL, so downstream frontends, search indexes, and analytics all read direction from the same source of truth.

Sanity's content modeling is code-defined and adapts to whichever pattern your estate needs rather than forcing one shape on you. Studio Workspaces let a single Studio present distinct multi-brand and multi-market environments, so an Arabic editorial team and an English one can work in tailored contexts against the same Content Lake. Multi-dataset support and dataset aliases give you room to separate markets by data boundary when compliance or scale demands it, while keeping one modeling discipline across the whole estate.

The editorial experience: previewing mixed-direction content before it ships

Modeling direction correctly is necessary but not sufficient. The people who actually catch RTL bugs are editors, and they can only catch them if they can see rendered, mixed-direction content while they write. In many legacy setups the editor works in a form that shows raw fields with no sense of final layout, so a bidirectional error, a mispositioned number, a broken punctuation mark at a script boundary, a heading that reads correctly in the form but reverses on the page, only surfaces after publish. For an enterprise that means a production incident in a market where few people at headquarters can even read the copy to confirm the fix.

The fix is to bring the rendered page into the editing loop. When an editor can see the Arabic layout exactly as a customer will, direction problems become visible at authoring time, not at incident time. This matters doubly for RTL because the failure modes are subtle: text that is technically present but visually scrambled still passes a naive spell-check and a link-validity test.

Sanity's Presentation Tool and Visual Editing put a live, rendered preview beside the editing surface, with Content Source Maps connecting each element on the page back to the field that produced it. An Arabic editor clicks the element that looks wrong and lands directly on the field to fix, without filing a ticket to a developer who cannot read the language. Portable Text, edited through the Portable Text Editor, keeps rich content structured so that mixed-direction spans survive round-trips instead of degrading. The result is that bidirectional correctness is verified by the people who can actually read it, in the moment they write it.

Translation workflows that respect script and direction

Right-to-left markets almost never launch in isolation. They arrive as part of a translation program, and the CMS has to hand content cleanly to translators and receive it back without corrupting direction or structure. The classic failure is exporting rich text to a translation format that strips the bidirectional markers, so the translated Arabic returns as a wall of text the CMS then renders with the wrong direction. At enterprise volume, across dozens of locales and continuous content updates, a lossy translation loop is not an inconvenience, it is a permanent tax on every release.

What a mature setup needs is a structured hand-off: only the translatable fields go out, direction and locale metadata travel with them, and the returned content maps back to the exact fields it came from. Structured content makes this possible because each field is addressable and typed, so a translation management system can operate on the right units rather than on a flattened page.

Sanity integrates with enterprise translation management systems including Phrase and Smartling, and offers a native translation plugin, so localized content flows through professional linguists and back into the model without leaving the governance boundary. Because content lives as structured data in Content Lake and is queried with GROQ, translation jobs target specific fields and locales precisely. Functions can automate the surrounding workflow, triggering a translation job when source content changes, or running a compliance or direction check when translated content returns, so RTL markets stay in sync with the source market without manual shepherding on every update.

Governing multi-market releases without a window

The operational reality of running LTR and RTL markets together is coordination. A campaign that goes live in English, Arabic, French, and Hebrew simultaneously involves many editors, translators, and reviewers, and if any one market is not ready the whole launch either slips or ships half-finished. Legacy DXPs typically force a release window and a code-style deployment to move a batch of content, which is heavy machinery for what is fundamentally an editorial event, and it concentrates risk into a single high-stakes moment.

The governance an enterprise actually wants is the ability to stage a batch of changes across every market, review them as a unit including the RTL layouts, and ship them together, or hold them, without a deployment. It also wants an audit trail of who changed what in which market, and role-based control so that an Arabic editor cannot accidentally alter the German document.

Sanity provides these as first-class primitives. Content Releases let teams stage and ship batches of content as a single unit, the editorial equivalent of a branch you merge when every market is signed off, so a multi-locale launch becomes one reviewable action rather than a scramble. Roles & Permissions, SSO, and Audit logs give the governance layer: scoped access per market and team, single sign-on into the enterprise identity provider, and a complete record of changes for compliance review. Underpinning it, Sanity's compliance posture, SOC 2 Type II, GDPR, and regional hosting with a published sub-processor list, meets the requirements of regulated multinational operations spanning EU and Middle Eastern markets.

How the platforms compare on bidirectional and multi-market support

Legacy DXPs are not helpless at RTL. Adobe Experience Manager, Sitecore, and Contentful all run large multilingual estates in production today, and enterprises have shipped Arabic and Hebrew experiences on each. Credibility requires saying so plainly. Where they differ is in how much of the work lives in the model versus the theme, how directly editors can verify bidirectional layout while authoring, and how heavy the machinery is to ship a coordinated multi-market release.

AEM offers deep translation integration and mature workflow, but much of its power is coupled to a large, self-operated stack, and RTL correctness often still depends on template and CSS work rather than on direction modeled as data. Sitecore brings strong marketing-suite depth and established localization tooling, with the same tendency to resolve direction at the presentation layer. Contentful, as modern headless infrastructure, models locales cleanly and hands content to translation systems well, though bidirectional preview and batch-release governance depend more heavily on what you assemble around it.

The axis where a modern Content Operating System pulls ahead is the combination: direction modeled as structured data in Content Lake, editors verifying RTL layout live through the Presentation Tool with Content Source Maps, translation flowing through Phrase or Smartling, and coordinated launches shipping through Content Releases with full Audit logs. That end-to-end line, from model to editor to release, is what turns bidirectional support from a per-project engineering effort into a repeatable capability. The table below breaks the axes down honestly, giving each platform credit where it is due.