nativeLan
NativeLan 3.0 Live:Over-The-Air Localization for Flutter, Android, iOS & Web

Ship Copy Updates in Milliseconds.
Without App Store Reviews.

NativeLan combines high-density virtualized translation sheets, context-aware AI autofills, live presence cursors, and zero-code native SDKs to deliver instant Over-The-Air string updates globally.

Get Started
flutter pub add nativelan
< 15msGlobal CDN Sync Latency
0 App StoreResubmissions Required
10,000+Virtualized Keys @ 60 FPS
100%Offline-First Uptime Guarantee
Official SDK Documentation & Technical Specs

Client SDKs & Integration Guides

Technical architecture, zero-code interception mechanisms, and step-by-step setup guides for Flutter, Android, iOS, and Web/Backend APIs.

Flutter (Dart)

Kurdish & RTL Native

Native LocalizationsDelegate with zero-crash Kurdish & RTL engines

pubspec.yaml:flutter pub add nativelan
main.dart
import 'package:flutter/material.dart';
import 'package:flutter_localizations/flutter_localizations.dart';
import 'package:nativelan/nativelan.dart';

void main() {
  // Wrap root app inside NativeLanScope for reactive OTA updates
  runApp(
    const NativeLanScope(
      child: MyApp(),
    ),
  );
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Global Mobile App',
      // Configure NativeLan localization delegates
      localizationsDelegates: [
        NativeLanLocalizationsDelegate(
          config: NativeLanConfig(
            projectId: "01M1XNWZBBG2QEYFA2VQ7HHBXQ",
            sdkKey: "nlk_live_q2xyr0MM2i...",
            baseUrl: "https://api.nativelan.com",
            prerelease: false, // Set true for QA staging bundles
            appVersion: "1.0.0", // Enables bundle freeze targeting
          ),
        ),
        // Fallbacks preventing CLDR crashes on Kurdish (ckb, badini, ku)
        ...NativeLanLocalizations.fallbackDelegates,
        GlobalMaterialLocalizations.delegate,
        GlobalWidgetsLocalizations.delegate,
      ],
      supportedLocales: const [
        Locale('en', 'US'),
        Locale('ar', 'IQ'),
        Locale('ckb'), // Kurdish Sorani — Automatic RTL layout
        Locale('badini'), // Kurdish Badini — Automatic RTL layout
      ],
      home: const HomeScreen(),
    );
  }
}

// In any widget:
class HomeScreen extends StatelessWidget {
  const HomeScreen({super.key});

  @override
  Widget build(BuildContext context) {
    // 0ms instant lookup from memory cache with fallback
    final welcome = NativeLanLocalizations.of(context)?.translate('welcome_title') ?? 'Welcome';
    final userMsg = NativeLanLocalizations.of(context)?.translate('user_greeting', ['Sarah']);
    
    return Scaffold(
      appBar: AppBar(title: Text(welcome)),
      body: Center(child: Text(userMsg ?? '')),
    );
  }
}
Architectural Note: Wrapping your root with NativeLanScope allows the entire UI tree to update smoothly when a new translation delta is fetched over-the-air, without app restarts.

Platform Features & Compliance

Built-in unlisted locale fallback delegates (Kurdish Sorani `ckb`, Badini, Arabic `ar`, Persian `fa`)
Automatic Directionality(textDirection) injection without manual widget wrappers
NativeLanScope state container automatically triggers smooth UI rebuild on OTA sync
WidgetsBindingObserver triggers background foreground re-sync on app resume
Continuous Copy Delivery

Stop Waiting for App Store Reviews to Fix Copy

Traditional mobile localization forces your team to rebuild binaries and wait 3 days for Apple and Google approval. NativeLan OTA delivers string fixes straight to your users in 15 milliseconds.

Traditional App Store Release

The Slow, Rigid Cycle
3 to 7 Days
1
Developer Ticket Required: Copywriters cannot edit code directly; engineering must pull requests and update string XML / localizable files.
2
Binary Compilation: CI/CD rebuilds APK and IPA files, runs full test suites, taking 30–60 minutes.
3
App Store Review Wait: Apple and Google review queues take 24–72 hours, with constant risk of unexpected rejection.
4
Fragmented User Adoption:30–50% of users don't have auto-updates turned on, leaving them on outdated, broken copy for months.
Result: High engineering overheadLost conversions

NativeLan Over-The-Air (OTA)

Instant Global Deployment
< 15 Milliseconds
1
Edit in Browser: Product managers and translators refine strings directly in the NativeLan Collaborative Studio.
2
1-Click Publish:Click "Publish Release". Active release version increments and instantly pushes to edge CDN nodes worldwide.
3
Compressed Delta Sync: The SDK only downloads changed strings (JSON delta), reducing payload size by 98%.
4
100% Instant Reach: Every active user gets updated copy dynamically on next launch with zero App Store download!
Result: Zero developer interruption 100% Store Policy Compliant

Offline-First Resilience

Translations cache in local device storage. Apps boot instantly in 0ms with zero blank screens, even without an active internet connection.

98% Delta Compression

Server computes exact string diffs. If you change 2 keys out of 5,000, only those 2 keys are downloaded, saving massive mobile bandwidth.

App Version Freezing

Lock bundle releases to specific semantic app versions (e.g. 1.0.01.2.0) to prevent breaking legacy production builds.

Prerelease QA Track

Stage builds for internal QA testers using the prerelease: true flag. Verify changes live on device before flipping to production.

Apple App Store & Google Play Guideline Compliant: Localization strings are data content, not executable binary code (Apple Guideline 2.5.2). Over-the-air updates are 100% permitted.
Platform Capabilities

Engineered for Scale, Speed, & Precision

Explore the core architectural pillars powering mission-critical localization for enterprise applications.

Frame Rate60 FPS @ 10k rows
TanStack Virtualized EngineFrame Rate: 60 FPS @ 10k rows

High-Density Virtualized Studio

Handle 10,000+ keys simultaneously at buttery-smooth 60fps with zero DOM degradation.

Virtual Window: Row 4,520 - 4,526 of 12,480FPS: 60.0 (0ms jank)
billing.invoice_overdueYour invoice #%s is overdueOK
auth.mfa_push_promptTap approve on your mobile appOK
cart.empty_state_descAdd items from catalog to startREVIEWED
Zero layout shifts with dynamic height virtualization
Instant multi-column sorting and complex regex key filtering
Batch edit, tag assignment, and status approvals across thousands of keys
Memory consumption kept under 45MB regardless of dataset size
Production ready across iOS, Android, and FlutterActive in Studio
System Architecture

How OTA-to-SDK-to-App Works Under the Hood

From a translator's keystroke in the studio to native screen rendering on iOS, Android, and Flutter — trace the exact data flow.

01
Phase 1: Cloud Publishing

Studio Edits & Build Release

Translators or developers edit strings in the NativeLan Studio. Clicking "Create Build" packages the release snapshot and increments the project version (V → V+1).

Dashboard & AIInspecting
02
Phase 2: Global Distribution

Edge CDN Delta Generation

The CDN calculates exact string diffs against the previous build. Only modified or added keys are bundled into a compressed JSON delta.

15ms Edge SyncClick to inspect
03
Phase 3: Client Sync Engine

Offline-First Local Storage

When your app starts, the NativeLan SDK checks for updates in the background. If a newer version exists, it downloads the delta and updates the local storage cache.

Local Disk CacheClick to inspect
04
Phase 4: Runtime Swizzling

Zero-Code Resource Resolution

Standard getString(R.string.key) or NSLocalizedString calls are intercepted dynamically. If the key exists in OTA memory, it renders the live string; otherwise, it falls back to local files.

Swizzling & WrapperClick to inspect
Phase 1: Cloud PublishingDashboard & AI

Studio Edits & Build Release

Translators or developers edit strings in the NativeLan Studio. Clicking "Create Build" packages the release snapshot and increments the project version (V → V+1).

Automatic string validation & token security check
Target track selection: Staging (prerelease) or Production
Release snapshot immutable packaging
Offline Safe: Device never blocks on network failure; cached local data renders immediately.
GET /api/v1/sdk/ota/updates
Request Headers: X-SDK-Key: nlk_live_...
Query: ?locale=en-US&transVersion=42&platform=android
{
  "success": true,
  "data": {
    "version": 43,
    "delta": true,
    "strings": {
      "hero.title": "Deploy Global Apps at Instant Speed",
      "checkout.cta": "Upgrade to Professional Plan",
      "auth.welcome_back": "Welcome back, enter your password"
    },
    "removedKeys": []
  },
  "timestamp": "2026-09-23T12:00:00.000Z"
}
Simple, Transparent Pricing

Plans Built to Scale With Your Product

Choose the plan tailored for your team and translation volume.

Starter
$23 /month

Ideal for individual developers and growing apps shipping global copy.

Up to 2,500 translation keys 5 target languagesFull SDK & API access (Flutter, Android, iOS, Web) Standard Over-The-Air releases Email support
Get Started
Most Popular
Professional Pro
$63 /month

Designed for growing teams needing real-time collaboration and continuous OTA releases.

Unlimited translation keys Unlimited target locales & RTL engines WebSocket live cell locks & cursors Context-aware AI copilot translation Edge CDN delta sync delivery
Get Started with Pro
Scale Enterprise
Custom

Dedicated infrastructure, SLA guarantees, SSO SAML, and custom translation model fine-tuning.

Custom enterprise LLM fine-tuning Dedicated edge CDN endpoints SAML / Okta SSO & audit logging 99.99% uptime SLA with dedicated Slack
Contact Enterprise Sales
Frequently Asked Questions

Everything You Need to Know

Clear answers regarding compliance, offline resilience, architecture, and security.

Yes, absolutely. Under Apple App Store Review Guideline 2.5.2, apps may not download executable code, but downloading non-executable assets — such as translation strings, localization dictionaries, and visual configuration — is explicitly permitted. NativeLan delivers pure string key-value dictionaries and does not touch executable binaries.

Ready to Localize at Instant Speed?

Join modern engineering and localization teams deploying dynamic global copy with zero App Store friction. Get started in minutes.

Get Started Now