shallok logo
Shallok
Get Started
Shallok

The MCP-first, AI-powered, AST-safe agentic localization engine

Extract strings cleanly, track changes with per-key SHA-256 hashes, and let your AI coding agent translate with zero external API fees.

$npx shallok setup
Explore WalkthroughOpen Dashboard
25 Official AST Adapters & Agent Skills

First-Class AST Framework Adapters & Pre-Packaged AI Agent Skills

Next.js(next-intl)
React(react-i18next)
Vue.js(vue-i18n)
Nuxt(@nuxtjs/i18n)
Svelte(svelte-i18n)
Astro(astro:i18n)
Angular(@angular/localize)
Remix(remix-i18next)
SolidJS(@solid-primitives/i18n)
Qwik(qwik-speak)
Expo(expo-localization)
React Native(react-native-localize)
Preact(preact-i18n)
TanStack(tanstack/start)
Gatsby(gatsby-plugin-i18n)
Alpine.js(alpinejs-i18n)
Lit(@lit/localize)
Ember.js(ember-intl)
HTMX(server-templates)
Hono(hono/jsx)
Cursor(.cursor/rules)
Claude Code(CLAUDE.md / skills)
Antigravity(.agents/skills)
GitHub Copilot(copilot-instructions)
Windsurf(.windsurfrules)
The Walkthrough

How Shallok Works

A deterministic 5-phase pipeline from raw hardcoded UI strings to verified, AI-translated multi-locale applications.

SHALLOK PIPELINE BUS // ARCHITECTURE SCHEMATIC
IntakeArchiveFresh from the codebaseReady for the briefNext.js / TSXAstro / VueGit ReposBabel ASTSHALLOK CORESHA-256 EngineAI AgentsLocales (JSON)MCP RouteCatalog Sync
Continuous Pipeline Flow: AST Extraction → Per-Key SHA-256 → Active Agent Translation → Telemetry & Sync
Phase 01 • Intake & Scaffolding

One Command.
Auto-Detects Everything.

Developers run npx shallok setup in any repository. Shallok inspects your project root, package configuration, and existing routing architecture.

  • ✔Auto-Detects Framework: Next.js App/Pages Router, Astro, React Vite, Expo, Vue, or Svelte.
  • ✔Zero Global Bloat: Installs shallok directly into project devDependencies.
  • ✔Injects AI Skills: Drops rules into .agents/skills/ and .cursor/rules/.
terminal
pipeline-step-1.sh
$ npx shallok setup
Analyzing repository architecture...
✔ Detected framework: Next.js (App Router with TypeScript)
✔ Package manager: pnpm
📦 Installing shallok into devDependencies... (done in 1.1s)
✔ Dropped skill: .agents/skills/shallok-nextjs/SKILL.md
🤖 Prompt your AI coding agent (Cursor, Antigravity, Claude Code):
"Add localization to this application with Kannada and Hindi"
✨ Project ready for Babel AST extraction.
src/components/Checkout.tsxAST Diff
// Injects translation hook safely via Babel AST
+ import { useTranslations } from 'next-intl';
export function Checkout({ items, total }) {
+ const t = useTranslations('checkout');
return (
<div className="p-4">
- <h2>Order Summary</h2>
+ <h2>{t('order_summary')}</h2>
- <button>Pay {total} now</button>
+ <button>{t('pay_now', { total })}</button>
</div>
);
}
Phase 02 • AST Code Extraction

Babel AST Parsing.
Never Fragile Regex.

Legacy tools use regular expressions that break nested JSX children, props, conditional ternary operators, and template literals.

Shallok parses the real TypeScript / JavaScript syntax tree, replacing hardcoded strings with t('key') and injecting the translation hooks automatically.

  • ✔Preserves complex JSX expressions and nested children trees.
  • ✔Automatically injects useTranslations() hooks into component headers.
  • ✔Extracts strings with deterministic key generation into the root catalog.
Phase 03 • Cryptographic Integrity

Per-Key SHA-256.
No Overwrite Collisions.

When you edit 1 English sentence out of 500, legacy systems invalidate entire language catalogs or lose your git history.

Shallok cryptographically hashes each string. Only the modified key bumps its version (v1 → v2). The remaining 499 keys remain untouched, eliminating accidental re-translations.

  • ✔Zero accidental re-translations for unchanged strings.
  • ✔Tracks version lineage per key in localization.json.
  • ✔Stale key detector triggers agent translation only where diffs exist.
localization.json (Catalog Inspector)Deterministic Hashing
checkout.order_summaryv1 • Synced
"Order Summary"
sha256: 4f9b2a7d1e8c... (Untouched)
checkout.pay_nowv1 → v2 • Stale
"Pay {total} now with 1-click checkout"
Hash changed → Only this key dispatches to AI agent!
shallok translate0 API Keys Required
kn (Kannada)
"1-ಕ್ಲಿಕ್ ಚೆಕ್‌ಔಟ್‌ನೊಂದಿಗೆ ಈಗ {total} ಪಾವತಿಸಿ"
Passed
hi (Hindi)
"1-क्लिक चेकआउट के साथ अब {total} भुगतान करें"
Passed
es (Spanish)
"Paga {total} ahora con el pago en 1 clic"
Passed
✔ Integrity validation: 0 missing keys, 0 placeholder leaks, 0 stale hashes.
Phase 04 • Agent Translation

Zero API Fees.
Uses Your Active Agent.

No $400/month SaaS translation bills or external OpenAI API keys to configure and maintain.

Shallok orchestrates the coding agent already active in your IDE (Antigravity, Cursor, Claude Code) to translate missing keys contextually, verifying ICU interpolation tokens {count} with 100% rigor.

  • ✔0 External API Bills: Leverage existing subscription agent seats.
  • ✔ICU Integrity Validation: Guarantees variable placeholders are never scrambled.
  • ✔Supports Indic languages (Kannada, Hindi, Tamil) & global locales out-of-the-box.
Phase 05 • Telemetry & MCP Protocol

Real-Time Telemetry.
Native MCP Route.

The companion shallok-dash delivers real-time visibility across all translation catalogs, audit statuses, and localization health.

Exposes a native Model Context Protocol route at /mcp so Claude Desktop, Cursor AI, or Antigravity can inspect live telemetry and query keys via structured tool calls.

  • ✔Globally synchronized catalog storage with sub-10ms query latency.
  • ✔JSON-RPC 2.0 MCP tools: list_items, create_item, get_system_stats.
  • ✔Exports verified multi-locale JSON catalogs into production builds.
Open Shallok Dash ↗
Total Keys
482
Catalog Synced
Locales
6
kn, hi, es, fr, ja, de
Stale Keys
0
100% Up to date
Live Endpoint: /mcp
JSON-RPC 2.0
Connects to Claude Desktop, Cursor AI, and Antigravity:
• list_items: Filter and query translation keys from catalog
• create_item: Add AST extracted keys into catalog
• get_system_stats: Live system health and translation stats
Architectural Contrast

Built for Git & AI Agents. Not Marketing Portals.

Legacy cloud TMS platforms were designed in 2014 for manual web portal workflows. Shallok was engineered from the ground up for AST safety, Git determinism, and autonomous AI agents.

Approach 01SaaS Silo

Legacy Cloud TMS

Crowdin · Lokalise · Phrase

Centralized web portals that isolate translations away from code. Requires expensive monthly licenses, manual review dashboards, and creates massive Git diff noise.

  • ✕$140 – $500+/mo per-seat SaaS license fees
  • ✕Whole-catalog invalidation on small copy edits
  • ✕Proprietary web silos with no native MCP agent access
PR Bot Sync RequiredHeavy Lock-in
The Modern StandardRecommended

Shallok

Agent-Native · Babel AST · Per-Key SHA-256

Developer-first localization engine that lives inside your Git workflow. Uses Babel AST for zero syntax corruption and executes translations directly via your active IDE coding agent.

  • ✓$0 Software Cost: 100% Free & Open Source (MIT)
  • ✓Babel AST-Safe: Never breaks props, ternaries, or JSX
  • ✓Per-Key SHA-256: Surgical diffs; 1 edit touches 1 key
  • ✓Native MCP Route: Claude, Cursor, & Antigravity tool calling
Git-DeterministicZero Runtime Fees
Approach 03Brittle Scripts

Ad-Hoc Regex Scripts

i18next-parser · DIY string regex

Basic regex string matching without syntax tree comprehension. High risk of breaking nested JSX children, corrupting template literals, and crashing at runtime.

  • ✕Fragile regex matching breaks on multi-line props
  • ✕Destructive overwrites scramble JSON key order
  • ✕No ICU validation causes runtime production crashes
High Developer LaborZero Agent Awareness

Detailed Architectural Matrix

Deep engineering comparison across syntax safety, diff determinism, and ecosystem integration.

Supported Absent / Risk
Capability & Metric
Shallok
Agent-Native
Legacy Cloud TMSCrowdin, LokaliseAd-Hoc Regexi18next-parser
1. Code Extraction & Syntax Safety
AST-Safe Code Extraction
Handling of nested JSX, complex props, and ternary expressions
✓Pure Babel AST Parser
Full syntax tree awareness; zero code corruption
Manual Wrapping
Requires manual wrapping or web dashboard edits
Fragile Regex
Prone to corrupting multi-line and nested props
ICU Placeholder Linting
Detects missing or mangled {variable} parameters
✓Automated CI/CD Linting
shallok validate
Manual Review
Relies on human proofreading in external portal
None
Mangled placeholders trigger app runtime crash
2. Git Lineage & Versioning
Diffing & Change Tracking
Behavior when 1 source string out of 500 is modified
✓Per-Key SHA-256 Hashes
Only modified keys trigger translation updates
Whole-Catalog Diffs
Invalidates entire file; generates noisy PR merges
Destructive Re-write
Re-orders keys arbitrarily; destroys git history
CI/CD Pipeline Determinism
Reproducibility in automated build runners and air-gapped environments
✓100% Deterministic Lockfile
Validates without network or cloud credentials
External Webhook
Requires outbound API tokens & network access
Basic Formatter
No integrity or missing key verification
3. Economics & AI Workflow
Monthly Software Cost
Per-seat licenses and character translation quotas
✓$0 · 100% Free & Open Source
MIT License
$140 – $500+/mo
+ Per-word fees & translator add-ons
Free Software
Hidden cost: High developer debugging labor
Translation Token Model
Management of OpenAI, Claude, or DeepL API credits
✓Runs on Active IDE Agent
Zero external API keys or prepaid credits
Prepaid Credits
Vendor marked-up AI tokens or external API bills
Manual Execution
Developers manually copy-paste into ChatGPT
AI Agent MCP Protocol
Native tool querying for Claude Desktop, Cursor AI, & Antigravity
✓Native /mcp Server
Autonomous tool querying & catalog management
No MCP Support
Closed vendor APIs requiring custom connectors
None
No agent tools or machine-readable interface
⚡

Already using Crowdin, Lokalise, or next-intl?

Shallok operates directly on existing JSON and PO catalogs without modifying your codebase or runtime configuration.

Explore CLI Reference →
Questions & Answers

Frequently Asked Questions

Why does Shallok require zero external API keys?

Shallok uses an agent-native architecture. The AI coding agent running directly inside your IDE (Antigravity, Cursor, Claude Code, GitHub Copilot) already possesses deep cultural fluency and context about your codebase. Shallok provides the structured task skills, context extraction, and integrity validation so your agent translates directly without third-party SaaS tokens.

How does Babel AST extraction differ from regex tools?

Regular expression extractors treat your code as raw flat text. They routinely break on multi-line strings, nested JSX elements, conditional ternary operators, and component attributes. Shallok compiles your code into a real Babel Abstract Syntax Tree, understands the syntactic roles of every token, and safely replaces text with t(...) calls without corrupting syntax.

How does deterministic per-key SHA-256 versioning work?

Every source string has an immutable cryptographic SHA-256 hash stored in localization.json. When you edit a single sentence in English, Shallok detects that only that specific key's hash has changed and bumps its version (v1 → v2). The remaining 500 keys stay untouched, preserving existing translations and eliminating mass re-translation costs.

Can I integrate Shallok into my CI/CD GitHub Actions?

Yes! Simply add shallok validate to your test suite or GitHub Actions pull request checks. It will verify that zero keys are missing, zero source versions are stale, and all ICU interpolation placeholders match between source and targets.

How does shallok-dash and the Model Context Protocol (MCP) fit in?

shallok-dash is a web telemetry and key management platform. It exposes an official Localization MCP server at /mcp, allowing AI coding assistants like Claude Desktop, Cursor AI, or Antigravity to query translation metrics, audit statuses, and manage keys directly via structured tool calls.

What is the difference between i18n and i10n (or l10n)?

Internationalization (i18n) is the engineering architecture that prepares a codebase to handle multiple languages and locales without code modifications. Localization (l10n or i10n) is the process of translating and culturally adapting that platform for specific locales. Shallok automates both through agentic localization. Read our detailed i10n vs i18n guide →.