Web Assembly

Lipi Lekhika includes a blazing-fast 🦀 Rust-based WebAssembly (WASM) module that brings high-performance transliteration to all JavaScript environments. The WASM implementation provides significant performance improvements while maintaining the same easy-to-use API.

Features

The WASM module offers several advantages over the pure JavaScript implementation:

• ⚡ Superior Performance — Rust’s compiled WASM code executes significantly faster than JavaScript
• 📦 Compact Size — Only 114 KB gzipped (base64), including all script data embedded
• 🌍 Universal Compatibility — Works seamlessly in Node.js, browsers, Deno, Bun, and more
• 🔒 Type Safety — Built with Rust’s type system for reliability
• 🎯 Same API — Drop-in replacement for the standard transliterate function

Installation

The WASM module is included in the main lipilekhika package — no additional installation required!

npm

npm install lipilekhika

pnpm

pnpm add lipilekhika

bun

bun add lipilekhika

yarn

yarn add lipilekhika

Basic Usage

Simple Transliteration

The transliterate_wasm function provides the same interface as transliterate (text: string | string[]):

import { transliterate_wasm } from 'lipilekhika';

const result = await transliterate_wasm('na jAyatE mriyatE vA', 'Normal', 'Devanagari');
console.log(result); // न जायते म्रियते वा

With Custom Options

You can pass custom transliteration options just like the standard function:

import { transliterate_wasm } from 'lipilekhika';

const result = await transliterate_wasm(
  'गङ्गा',
  'Devanagari',
  'Gujarati',
  { 'brahmic_to_brahmic:replace_pancham_varga_varna_with_anusvAra': true }
);
console.log(result); // ગંગા (instead of ગઙ્ગા)

Custom Transliteration OptionsA detailed overview of all available custom transliteration options

Preloading the WASM Module

To avoid the initial loading delay when first calling transliterate_wasm, you can preload the WASM module:

import { preloadWasm, transliterate_wasm } from 'lipilekhika';

// Preload during app initialization
await preloadWasm();

// Later calls will be instant (no loading delay)
const result = await transliterate_wasm('namaste', 'Normal', 'Devanagari');
console.log(result); // नमस्ते

Tip

Best Practice: Call preloadWasm() during your application’s initialization phase (e.g., in a loader, startup hook, or top-level await) to ensure the WASM module is ready before users interact with transliteration features.

API Reference

transliterate_wasm(text, from, to, options?)

WASM-based transliteration using the Rust implementation.

Parameters:

• text: string | string[] — One string or many (same options for all)
• from: ScriptLangType — Source script/language name
• to: ScriptLangType — Target script/language name
• options?: TransliterationOptions — Optional custom transliteration options

Returns: Promise<string | string[]> — shape matches text

Example:

const result = await transliterate_wasm('hello', 'Normal', 'Telugu');
console.log(result); // హెల్లొ

preloadWasm()

Preloads the WASM module to eliminate initial loading delay.

Returns: Promise<void>

Example:

// During app initialization
await preloadWasm();

// Now WASM calls are instant
const result = await transliterate_wasm('text', 'Normal', 'Devanagari');

Performance Comparison

The WASM implementation provides significant performance improvements, especially for:

• Large text blocks — Faster processing of lengthy documents
• Batch operations — Efficient when transliterating multiple texts
• Complex scripts — Better performance with intricate character mappings
• Repeated calls — Lower overhead after initial load
• Benchmarks - 2x faster than the JavaScript implementation

Note

For small, one-off transliterations, the performance difference may be negligible due to WASM initialization overhead. The WASM module shines with repeated use or larger text processing.

Cross-Environment Support

The WASM module works seamlessly across all JavaScript environments:

Node.js

import { transliterate_wasm } from 'lipilekhika';

const result = await transliterate_wasm('text', 'Normal', 'Devanagari');
console.log(result);

Browser (ESM)

<script type="module">
  import { transliterate_wasm } from 'https://cdn.jsdelivr.net/npm/lipilekhika/dist/esm/index.mjs';

  const text = await transliterate_wasm('namaste', 'Normal', 'Devanagari');
  console.log(text); // नमस्ते
</script>

Deno

import { transliterate_wasm } from 'npm:lipilekhika';

const result = await transliterate_wasm('text', 'Normal', 'Devanagari');
console.log(result);

Bun

import { transliterate_wasm } from 'lipilekhika';

const result = await transliterate_wasm('text', 'Normal', 'Devanagari');
console.log(result);

When to Use WASM vs JavaScript

Use WASM (transliterate_wasm) when:

• Processing large volumes of text
• Performance is critical
• You’re making repeated transliteration calls
• Building production applications

Use JavaScript (transliterate) when:

• Making occasional, small transliterations
• Bundle size is extremely constrained
• You need maximum compatibility with older environments
• Debugging or development (easier stack traces)

Bundle Size

The WASM module adds only 114 KB (gzipped base64) to your bundle, which includes:

• The compiled Rust WASM binary
• All script data embedded (no external data files needed)
• Complete transliteration logic

This is remarkably compact considering it includes all the data and logic for 15+ scripts!

Technical Details

How It Works

1. The WASM module is compiled from the Rust implementation of Lipi Lekhika
2. All script data is embedded directly into the WASM binary at compile time
3. The module is lazy-loaded on first use (or via preloadWasm())
4. Subsequent calls reuse the loaded module for optimal performance

Browser Compatibility

The WASM module requires WebAssembly support, which is available in:

• Chrome/Edge 57+
• Firefox 52+
• Safari 11+
• Node.js 8+
• Deno (all versions)
• Bun (all versions)

Caution

Very old browsers (IE11, old mobile browsers) do not support WebAssembly. For maximum compatibility, fall back to the standard transliterate function or use feature detection.

Additional Resources

JavaScript GuideComplete guide for using Lipi Lekhika in JavaScript/TypeScript

Rust PackageLearn about the native Rust implementation

Supported ScriptsList of all supported scripts/languages and their aliases