Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
skills-il avatar

Hebrew Rtl Best Practices

skills-il/localization

  • 229 installs
  • 21 repo stars
  • Updated August 3, 2026
  • skills-il/localization

hebrew-rtl-best-practices is a localization agent skill that ships correct Hebrew RTL web UIs using logical CSS, bidi text, and Next/React setup for developers building right-to-left interfaces.

About

hebrew-rtl-best-practices is a version 1.3.0 localization skill from skills-il that teaches developers how to build and fix Hebrew right-to-left web interfaces without guessing mirror and typography rules. The skill covers CSS logical properties (margin-inline, padding-inline), the :dir() pseudo-class, Tailwind RTL utilities, Next.js and React RTL configuration, icon mirroring, Hebrew font selection, and bidirectional text handling for numbers, URLs, and emails embedded in Hebrew copy. Triggers include RTL layout questions, Hebrew text direction, bidi bugs, and Hebrew CSS setup. The skill explicitly scopes to Hebrew web UIs and excludes native mobile RTL (React Native I18nManager, SwiftUI) unless shared patterns are requested. Reach for hebrew-rtl-best-practices when converting an LTR site to Hebrew, fixing misaligned components, or setting up next-intl or MUI for Israeli audiences.

  • CSS logical properties and :dir() for direction-aware layout without hard-coded left/right
  • Tailwind RTL patterns and React/Next.js RTL configuration
  • Hebrew typography and font-selection guidance distinct from Arabic RTL
  • Icon mirroring and bidirectional (bidi) text handling for mixed Hebrew/Latin UI
  • Explicit out-of-scope: native mobile RTL unless user requests shared patterns only

Hebrew Rtl Best Practices by the numbers

  • 229 all-time installs (skills.sh)
  • Ranked #820 of 2,245 Frontend Development skills by installs in the Skillselion catalog
  • Security screen: LOW risk (skills.sh audit)
  • Data as of Aug 4, 2026 (Skillselion catalog sync)
npx skills add https://github.com/skills-il/localization --skill hebrew-rtl-best-practices

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs229
repo stars★ 21
Security audit3 / 3 scanners passed
Last updatedAugust 3, 2026
Repositoryskills-il/localization ↗

How do you implement Hebrew RTL layout in React?

Ship Hebrew web UIs with correct RTL layout, bidi text, logical CSS, and Next/React setup without guessing mirror and typography rules.

Who is it for?

Frontend developers shipping Hebrew web apps with React, Next.js, Tailwind, or MUI who need correct RTL without layout bugs.

Skip if: Arabic-only typography projects or native mobile RTL apps outside the skill's web-focused scope.

When should I use this skill?

A developer asks about Hebrew RTL layout, bidi text, logical CSS properties, Tailwind RTL, or converting an LTR site to Hebrew.

What you get

RTL-correct layouts with logical CSS, :dir() rules, mirrored icons, Hebrew typography, and bidi-safe mixed-direction text.

  • RTL layout configuration
  • Logical CSS and bidi text fixes
  • Hebrew typography setup

By the numbers

  • Version 1.3.0 localization skill from skills-il
  • Covers CSS logical properties, :dir(), and Tailwind RTL utilities

Files

SKILL.mdMarkdownGitHub ↗

Hebrew RTL Best Practices

Instructions

Step 1: Set Up Document Direction

Always start with the HTML attribute (not just CSS):

<html lang="he" dir="rtl">

This tells browsers, screen readers, and CSS to use RTL as the base direction.

Step 2: Use CSS Logical Properties

NEVER use physical directional properties for layout:

Physical (avoid)Logical (use)
margin-leftmargin-inline-start
margin-rightmargin-inline-end
padding-leftpadding-inline-start
padding-rightpadding-inline-end
border-leftborder-inline-start
text-align: lefttext-align: start
text-align: righttext-align: end
float: leftfloat: inline-start
left: 10pxinset-inline-start: 10px

This ensures the layout automatically mirrors in RTL mode.

When you genuinely need a direction-specific rule that logical properties cannot express, prefer the :dir() pseudo-class over [dir="rtl"] attribute selectors:

/* Modern: matches the resolved direction, including dir="auto" and inheritance */
.chevron:dir(rtl) { transform: scaleX(-1); }

/* Older approach: only matches an explicit dir attribute on/above the element */
[dir="rtl"] .chevron { transform: scaleX(-1); }

:dir() is part of Selectors Level 4 and resolves the computed direction, so it also works for elements whose direction comes from dir="auto" or from an ancestor, where an attribute selector would miss them. Browser support: Chrome and Edge shipped it in version 120 (late 2023), Firefox has supported it for years, and Safari added it in 16.4, so it is now Baseline (widely available). For older-browser support, keep an [dir="rtl"] fallback rule or use a logical property instead. Check current support at https://caniuse.com/css-dir-pseudo.

Step 3: Handle Bidirectional Text

When mixing Hebrew and English/numbers:

/* Isolate embedded LTR content */
.ltr-content {
  unicode-bidi: isolate;
  direction: ltr;
}

/* For inline elements with mixed content */
.bidi-override {
  unicode-bidi: bidi-override;
}

Common bidi issues:

  • Phone numbers appearing reversed: Wrap in <bdo dir="ltr">
  • Punctuation at wrong end of sentence: Use unicode-bidi: isolate
  • URLs/emails in Hebrew text: Wrap in <span dir="ltr">

Numbers and dates: Standalone numbers and DD/MM/YYYY dates inside Hebrew text usually render fine because digits are weak-LTR, but a number that is immediately followed by a sign, currency, or a second number can flip. When a value must keep a fixed visual order, isolate it with <span dir="ltr"> or unicode-bidi: isolate rather than trusting the default bidi resolution.

Format the value, then isolate it. Bidi isolation only stops a correct string from flipping; it does not produce the right string. Use Intl to format, then isolate: Intl.NumberFormat('he-IL', { style: 'currency', currency: 'ILS' }) for shekel amounts and Intl.DateTimeFormat('he-IL') for dates, and wrap the output in <span dir="ltr"> (or unicode-bidi: isolate) if it sits inline in Hebrew prose. Devs commonly conflate the two and apply bidi fixes to a formatting bug (or vice versa).

Form inputs need `dir="auto"`. Put dir="auto" on every <input> and <textarea> so each value resolves its own base direction. This is the most visible end-user RTL bug: an email or an English word typed into a Hebrew form jumps to the wrong side without it. Note that the placeholder does not trigger auto-detection, so set the resting direction with CSS if the empty-field look matters.

`<bdi>` vs `<bdo>`: use <bdo dir="ltr"> only when you want to force a direction (it overrides the bidi algorithm). For user-generated or unknown-direction content, prefer <bdi>, which isolates the content so its direction is auto-detected and cannot leak into the surrounding text:

<!-- User name could be Hebrew or Latin; bdi isolates it either way -->
<p>שלום, <bdi>{{ userName }}</bdi>, ברוך הבא</p>

For free-text fields, dir="auto" (or unicode-bidi: plaintext in CSS) lets the browser pick the base direction per value, which is the correct default for comments, names, and search queries where you do not know the language in advance.

Shadows and gradients do not auto-flip. CSS logical properties mirror layout, but box-shadow, text-shadow, and linear-gradient offsets/angles are physical and stay fixed when direction flips. A shadow offset of 4px 4px that looks correct in LTR will point the "wrong" way relative to an RTL layout. The same physical-not-logical trap applies to transform-origin, background-position, and translateX-based keyframe animations (slide-in drawers, carousels, progress shimmer). Flip each explicitly with a :dir(rtl) (or [dir="rtl"]) override when its direction is meaningful.

Step 4: Mirror Directional Icons

Icon mirroring is one of the highest-frequency RTL bugs. The rule: mirror icons whose meaning is tied to reading direction, leave everything else alone.

Mirror these (their direction encodes "forward/back/next/previous" relative to reading order):

  • Navigation arrows, back/forward buttons, breadcrumb chevrons
  • "Send" / submit arrows, carousel and pagination arrows
  • Indentation, list-nesting, and reply arrows
  • Progress indicators that imply forward motion

Do NOT mirror these (mirroring makes them wrong or unrecognizable):

  • Logos and brand marks
  • Checkmarks and X / close icons
  • Media play buttons (a play button always points right, it refers to the timeline, not reading direction)
  • Clocks and analog-time icons (clockwise is universal)
  • Icons depicting real-world objects with a fixed orientation (a phone handset, a magnifying glass with the handle, most product icons)

Technique, mirror with a horizontal flip transform:

/* Flip only when the document direction is RTL */
.icon-directional:dir(rtl) { transform: scaleX(-1); }
<!-- Tailwind: rtl: variant for the cases logical properties cannot cover -->
<button class="rtl:-scale-x-100">
  <ArrowLeftIcon />
</button>

Many icon sets (for example Material Symbols) already ship RTL-aware variants, prefer those over flipping when available, because a flipped icon can mis-render fine detail or embedded text.

Step 5: Hebrew Typography

Recommended font stack:

font-family: 'Heebo', 'Assistant', 'Rubik', 'Noto Sans Hebrew', sans-serif;

Typography settings:

body[dir="rtl"] {
  font-size: 16px; /* Hebrew needs slightly larger than Latin */
  line-height: 1.7;
  letter-spacing: normal; /* NEVER add letter-spacing for Hebrew */
  word-spacing: 0.05em; /* Slight word spacing improves readability */
}

Step 6: Framework-Specific Setup

Tailwind CSS RTL (v4, current; logical utilities since v3.3):

Prefer logical property utilities over rtl:/ltr: variants:

Physical classLogical classCSS property
ml-4ms-4margin-inline-start
mr-4me-4margin-inline-end
pl-4ps-4padding-inline-start
pr-4pe-4padding-inline-end
left-4inset-s-4 (was start-4)inset-inline-start
right-4inset-e-4 (was end-4)inset-inline-end
rounded-l-lgrounded-s-lgborder-start-start-radius + border-end-start-radius
rounded-r-lgrounded-e-lgborder-start-end-radius + border-end-end-radius
<!-- Bad: requires two classes, breaks without dir attribute -->
<div class="ltr:ml-4 rtl:mr-4">...</div>

<!-- Good: single class, auto-mirrors based on dir -->
<div class="ms-4">...</div>

Reserve rtl: / ltr: variants only for cases logical properties cannot handle (e.g., directional icons, transforms).

Tailwind v4 note: v4 (GA since early 2025, currently v4.3) uses CSS-first configuration (@import "tailwindcss" in CSS) instead of tailwind.config.js. Logical utilities work identically in both v3 and v4. As of v4.3 (May 2026) the logical inset utilities start-*/end-* are deprecated in favor of inset-s-*/inset-e-* (the old names still work); the margin/padding utilities ms-*/me-*/ps-*/pe-* are unaffected.

Next.js App Router:

// app/layout.tsx
import { Heebo } from 'next/font/google';

const heebo = Heebo({
  subsets: ['hebrew', 'latin'],
  weight: ['400', '500', '700'],
});

export default async function RootLayout({
  children,
  params,
}: {
  children: React.ReactNode;
  params: Promise<{ locale: string }>;
}) {
  const { locale } = await params;
  const isRTL = locale === 'he';

  return (
    <html lang={locale} dir={isRTL ? 'rtl' : 'ltr'}>
      <body className={heebo.className}>{children}</body>
    </html>
  );
}

next/font self-hosts the font (no external Google Fonts requests, zero layout shift).

React with MUI:

Current MUI (v9 as of 2026) uses the official fork @mui/stylis-plugin-rtl, not the older community stylis-plugin-rtl package. The official fork fixes CSS-layers issues and supports current Stylis versions; this has been the recommended setup since MUI v6.

import { createTheme, ThemeProvider } from '@mui/material/styles';
import { CacheProvider } from '@emotion/react';
import createCache from '@emotion/cache';
import { rtlPlugin } from '@mui/stylis-plugin-rtl';
import { prefixer } from 'stylis';

const cacheRtl = createCache({
  key: 'muirtl',
  stylisPlugins: [prefixer, rtlPlugin],
});

const theme = createTheme({ direction: 'rtl' });

Confirm the exact import name and setup against the current MUI RTL guide (https://mui.com/material-ui/customization/right-to-left/) for your MUI version.

Portalled UI (modals, dropdowns, tooltips, toasts). Components rendered through a portal (React createPortal, Radix, MUI Menu, Floating UI) mount at document.body and inherit direction from there, but many libraries assume LTR. Set dir on <html> AND pass the library's own direction setting: Radix needs a <DirectionProvider dir="rtl"> wrapper, MUI needs direction: 'rtl' in the theme. Otherwise popovers open on the wrong side even when the rest of the page is correct.

Step 7: Common Pitfalls to Check

1. Directional icons -- mirror them (see Step 4 for which icons to flip and which to leave) 2. Progress bars -- should fill from right to left 3. Sliders/carousels -- swipe direction should reverse 4. Form labels -- should be right-aligned 5. Breadcrumbs -- separator direction should reverse 6. Tables -- columns reorder automatically, but force numeric, code, and date cells back to LTR with <td dir="ltr"> or text-align: end 7. Charts -- x-axis may need to reverse for Hebrew readers (SVG has no logical properties, so use the charting library's reversed/rtl option, not CSS) 8. Shadows and gradients -- physical offsets/angles do not auto-flip (see Step 3) 9. Fixed and sticky chrome (headers, toasts, FABs, drawers) -- hardcoded left: 0 / right: 0 does not flip; use inset-inline-start / inset-inline-end 10. Scrollbars sit on the left in RTL -- reserve space with scrollbar-gutter: stable to avoid reflow; text-wrap: balance improves Hebrew headings

Step 8: Verify the RTL Layout

Authoring rules are not enough, verify before shipping:

  • Flip the whole app to dir="rtl" and scan for anything that did not move (it is still using a physical property).
  • Test one canonical mixed string in every text surface: שלום John 050-1234567 ₪1,234 exercises Hebrew, Latin, a phone number, and a currency amount at once.
  • Open every modal, dropdown, tooltip, and toast (portalled UI is the most common RTL miss).
  • Check fixed/sticky chrome, charts/SVG, and form fields with dir="auto".

Examples

Example 1: Convert LTR Component to RTL

User says: "Make this card component work in Hebrew"

Before (LTR-only):

.card {
  margin-left: 16px;
  padding-right: 12px;
  text-align: left;
  border-left: 3px solid blue;
}

After (RTL-compatible):

.card {
  margin-inline-start: 16px;
  padding-inline-end: 12px;
  text-align: start;
  border-inline-start: 3px solid blue;
}

With Tailwind, replace ml-4 pr-3 text-left border-l-4 with ms-4 pe-3 text-start border-s-4.

Example 2: Bidi Text Issue

User says: "Numbers are showing backwards in my Hebrew text"

<!-- Wrong: phone number renders as 0544-123-050 -->
<p>התקשרו אלינו: 050-321-4450</p>

<!-- Correct: isolate the LTR content -->
<p>התקשרו אלינו: <span dir="ltr">050-321-4450</span></p>

Use unicode-bidi: isolate on the containing span for CSS-only solutions.

Example 3: Tailwind RTL Navigation

User says: "My sidebar is on the wrong side in Hebrew"

<!-- Bad: sidebar stuck on left -->
<aside class="fixed left-0 w-64">...</aside>

<!-- Good: sidebar auto-mirrors (inset-s-0; start-0 is the deprecated alias) -->
<aside class="fixed inset-s-0 w-64">...</aside>

<!-- Back arrow icon still needs rtl: variant (horizontal flip, not rotate-180 which also flips vertically) -->
<button class="rtl:-scale-x-100">
  <ArrowLeftIcon />
</button>

Bundled Resources

References

  • references/css-logical-properties.md - Complete physical-to-logical CSS property mapping table (margin, padding, border, positioning, text alignment, sizing) plus Hebrew font stack recommendations for sans-serif, serif, and monospace. Consult when converting any LTR stylesheet to RTL-compatible logical properties or choosing Hebrew web fonts.

Gotchas

  • CSS text-align: left is wrong for Hebrew. Use text-align: start which respects the document direction. Agents frequently hardcode left alignment in CSS.
  • margin-left and padding-right do not flip in RTL mode. Use CSS logical properties: margin-inline-start and padding-inline-end instead. Agents trained on LTR CSS will generate physical properties.
  • Flexbox row direction auto-reverses in RTL, but row-reverse also reverses, causing a double-flip back to LTR order. Agents may add row-reverse thinking it creates RTL, but it actually creates LTR within an RTL context.
  • Phone numbers, credit card numbers, and code snippets must remain LTR even inside RTL containers. Wrap them in <bdo dir="ltr"> or use direction: ltr on the containing element. Agents often let these inherit RTL.

Reference Links

SourceURLWhat to Check
MDN CSS Logical Propertieshttps://developer.mozilla.org/en-US/docs/Web/CSS/CSS_logical_properties_and_valuesFull property list, browser support tables
MDN :dir() pseudo-classhttps://developer.mozilla.org/en-US/docs/Web/CSS/:dirSyntax, behavior vs [dir] attribute selectors
Can I use: :dir()https://caniuse.com/css-dir-pseudoCurrent browser support table
MDN <bdi> elementhttps://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/bdiIsolating user-generated bidi content
Tailwind CSS RTL Supporthttps://tailwindcss.com/docs/hover-focus-and-other-states#rtl-supportrtl: / ltr: variant syntax
Tailwind Logical Propertieshttps://tailwindcss.com/docs/marginms-*, me-*, ps-*, pe-* utilities
MUI Right-to-lefthttps://mui.com/material-ui/customization/right-to-left/@mui/stylis-plugin-rtl setup for current MUI
Google Fonts Hebrewhttps://fonts.google.com/?subset=hebrewAvailable Hebrew font families
W3C Internationalizationhttps://www.w3.org/International/articles/inline-bidi-markup/Unicode bidi algorithm, markup best practices

Troubleshooting

Error: "Text alignment looks wrong"

Cause: Using text-align: left instead of text-align: start Solution: Replace all left/right in text-align with start/end.

Error: "Layout not mirroring"

Cause: Using physical margin/padding instead of logical properties Solution: Replace all margin-left/margin-right with margin-inline-start/margin-inline-end.

Related skills

vercel-labsVercel React Best PracticesAutomatically apply Vercel’s official React and Next.js performance rules during code generation and review.587k29.6kvercel-labsVercel Composition PatternsGenerate and refactor React components that stay maintainable as complexity grows without boolean prop explosion.267k29.6kshadcnShadcnAdd, compose, search, fix, and style production-grade React components directly from source without leaving their editor.257k120kxixu-meDevelop UserscriptsCorrectly write, debug, and package userscripts for Tampermonkey and ScriptCat with proper metadata, GM APIs, and runtime decisions.224k72leonxlnxMinimalist UiGenerate clean, editorial-style web interfaces with warm monochrome palettes, typographic hierarchy, bento grids and flat components that feel premium and utilita212k69.4kleonxlnxImage To CodeConvert high-fidelity design images into production-ready, visually accurate frontend code that avoids generic AI design pitfalls.177k69.4k

How it compares

Pick hebrew-rtl-best-practices over generic i18n skills when Hebrew-specific typography, bidi edge cases, and Tailwind/Next.js RTL setup are the blockers.

FAQ

What does hebrew-rtl-best-practices cover for Hebrew web apps?

hebrew-rtl-best-practices covers CSS logical properties, the :dir() pseudo-class, Tailwind RTL utilities, Next.js/React RTL setup, icon mirroring, Hebrew typography, and bidi handling for mixed Hebrew-Latin content on web interfaces.

Does hebrew-rtl-best-practices support mobile RTL apps?

hebrew-rtl-best-practices focuses on Hebrew web UIs. Native mobile RTL via React Native I18nManager, SwiftUI, or Android is out of scope unless the developer explicitly requests shared RTL patterns applicable to both.

When should developers use hebrew-rtl-best-practices?

hebrew-rtl-best-practices applies when building new Hebrew web apps, converting LTR sites to RTL, fixing bidirectional text bugs, or configuring Tailwind, Next.js, or MUI for Israeli Hebrew interfaces.

Is Hebrew Rtl Best Practices safe to install?

skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.

Frontend Developmentfrontend
Browse by category
AI & AgentsFrontend & DesignBackend & DataDev ToolsAutomationTesting & ReviewSecurityMonitoring & CloudDocs & Planning
Design & frontend
Design systemsAnimation & motionAccessibility (a11y)CSS & TailwindUI designUXDesign to codeshadcn/uiLanding pagesBest design skills
Most searched skills
find-skillscavemanfrontend-designbrainstormingsystematic-debuggingstop-slopemil-design-engui-ux-pro-maxkarpathy-guidelinesweb-design-guidelinesreact-best-practicesgrill-meimprovemicrosoft-foundryagent-browser
Browse all listings
All agent skillsAll MCP serversAll marketplacesAll plugins

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.