---
license: apache-2.0
language: [hi, en]
tags: [udgamlabs, transliteration, hindi, hinglish, devanagari, romanized-hindi, in-browser, javascript, tiny-model]
datasets: [ai4bharat/Aksharantar, ai4bharat/IndicCorpV2]
---

![Lekhani · Udgam Labs](./banner.png)

**UDGAM LABS** · Transliterator · 0.88 MB, Hindi, runs in the browser

# Lekhani

Lekhani turns Hindi typed in Latin letters into Devanagari: you type `kaise ho`, it writes कैसे हो. The whole thing
is a 0.88 MB download (a 0.81M-parameter model at 4 bits, a list of 200,000 common Hindi words and a 10 KB JavaScript
runner with no dependencies), and it runs in a web page on your own device, so nothing you type is sent anywhere. On
the Aksharantar Hindi test it gets 65.9% of words exactly right, 7 points more than IndicXlit's model on its own
(58.9%), which has 14 times as many parameters. IndicXlit's full Python package is still ahead (68.7%): it re-ranks
with a 4.2-million-word list that takes 358 MB of memory.

**Try it:** [on your device, in the browser](https://udgamlabs.com/models/lekhani#try) · [udgamlabs.com/models/lekhani](https://udgamlabs.com/models/lekhani)

## Quick start

Download the five files in this repository and serve them next to your page (any static host works).

```html
<input id="in" placeholder="mera naam">
<p id="out"></p>
<script type="module">
  import { Transliterator } from "./translit.js";
  const tr = await Transliterator.load({
    model: "model.q4.gz", json: "model.json.gz", words: "words.bin.gz", rerank: "rerank.json",
  });
  const box = document.getElementById("in");
  box.addEventListener("input", () => {
    document.getElementById("out").textContent = tr.text(box.value);   // "kaise ho" → "कैसे हो"
  });
</script>
```

In Node 18 or newer:

```js
import fs from "node:fs";
import { Transliterator } from "./translit.js";

const tr = await Transliterator.load({
  model: fs.readFileSync("model.q4.gz"), json: fs.readFileSync("model.json.gz"),
  words: fs.readFileSync("words.bin.gz"), rerank: JSON.parse(fs.readFileSync("rerank.json", "utf8")),
});
console.log(tr.text("aaj office mein meeting hai"));   // आज ऑफिस में मीटिंग है
console.log(tr.word("namaste").candidates.slice(0, 4).map((c) => c.text));
```

- `tr.text(s)` writes every run of Latin letters in Devanagari and keeps everything else (spaces, digits,
  punctuation, Devanagari) as it is.
- `tr.word(w)` returns `best` and `candidates`: the 8 spellings the model considered, best first, each with `inList`
  (whether it is one of the 200,000 listed words). Show the runners-up as suggestions if you build a keyboard.

| File | What it is | Size (gzip) |
|---|---|---|
| `model.q4.gz` | the model: encoder-decoder transformer, 2 + 2 layers, width 128, 811,904 parameters at 4 bits | 432,512 bytes |
| `words.bin.gz` | 200,000 common Hindi words in 8 frequency bands | 432,193 bytes |
| `translit.js` | the runner (30.9 KB as written) | 10,900 bytes |
| `model.json.gz`, `rerank.json` | settings and alphabet | 1,248 bytes |
| **Total download** | | **876,853 bytes (0.88 MB)** |

Speed: about 2 ms a word with WebAssembly SIMD, which current browsers have (1.9 ms a word in Node on a Mac mini over all
9,991 Aksharantar test words; 2.4 to 2.8 ms on everyday words in Chrome and Firefox on an Intel laptop). Without SIMD it
falls back to plain JavaScript, about 11 ms a word. The 1.0.0 runner took 18 ms a word.

## Results

**Aksharantar Hindi test** (AI4Bharat): 9,991 romanised words, top-1 exact match against any reference spelling,
scored word by word with one script on the same words for every system; 95% intervals from 2,000 bootstrap resamples,
paired for gaps. Measured by us on 28 October 2026.

| System | What you download or hold | Aksharantar Hindi | Hinglish chat set (of 122) |
|---|---|---|---|
| **Lekhani** | **0.88 MB** | **65.9%** (64.9 to 66.8) | **113** |
| IndicXlit, model on its own (beam 4, its default) | 11.5M parameters (46 MB fp32; a third-party 8-bit browser export is 14.4 MB) | 58.9% | 102 |
| IndicXlit, full Python package (model + word list) | the model + a 4.2M-word list, 358 MB in memory | 68.7% | 112 |

- **Against IndicXlit's model on its own: +7.0 points** (paired 95% interval +6.1 to +8.0).
- **Against IndicXlit's full package: -2.8 points** (-3.6 to -2.1). The package is more accurate if you can afford its
  word list.
- **Hinglish chat set:** 122 words people type in chat (everyday words, English words used in Hindi, brands, names),
  written by us and checked word by word by a native Hindi speaker. Lekhani gets 113, one more than IndicXlit's package (112).
  The set is too small to call a few words' difference.
- **Other open transliterators** we ran on the same test, word by word, scored far lower: IB-Emper
  hindi-translit-v3 (15M parameters, its model on its own) 48.6%, UnimeType Transliteration 4B 24.6% (v1.0) and
  20.0% (v2.0, released 28 Oct 2026, on a fixed 2,000-word sample), indic-xlit-270M 21.7%, indic-xlit-50M 14.8%,
  romanized-hindi-transliterator-60M 9.1%, UnimeType 2.0 0.8B 8.0%, rule-based typing schemes 5-12%. UnimeType's
  models are built for whole sentences, so their numbers are word-level results only.
- The browser runner gives the same answer and the same 8 candidates as our Python reference on all 9,991 test words.

## Where it falls short

- **About one word in three on this test is wrong at top-1.** The test is hard: many rare words and names. On
  everyday chat words it does much better (42 of 44 in our chat set), but it still makes mistakes there.
- **Some common words come out wrong:** `kal` → काल (कल is its second choice), `delhi` → देल्ही (should be दिल्ली).
- **No sentence context.** It writes one word at a time, so `main` ("I") and `mein` ("in") both become में:
  `main ghar ja raha hoon` → में घर जा रहा हूं (should be मैं).
- **IndicXlit's full package is 2.8 points more accurate** on the main test.
- **Hindi only**, Latin to Devanagari only.
- **Speed was measured on one Mac mini.** Phones and older laptops are not measured yet.

## How it was trained

A small encoder-decoder transformer (811,904 parameters), trained from random weights on about 4.3 million pairs of
romanised and Devanagari Hindi words, and stored at 4 bits. The pairs come from Aksharantar
(its CC0 and CC-BY parts; not its share-alike part) and from a teacher: IndicXlit wrote the many ways people type common
Hindi words from IndicCorp v2, and the Hindi spellings of English words. At run time the model proposes 8 spellings and
the 200,000-word list, built from IndicCorp v2 word counts, moves a common real word up when the model is unsure.
Words that are not in the list still work from the model alone. No test word was in the training pairs.

## Intended use and limitations

For typing Hindi in Latin letters on websites, apps and tools: search boxes, forms, chat, notes, a keyboard's
suggestions. It works one word at a time and does not translate. Show users the runners-up so they can fix a wrong
word, and keep their own spelling if they do. It is not meant for names on legal or official documents without a
human check.

## Changes

- **1.2.0 (4 Nov 2026):** common words cut short are fixed. When the best spelling ends in a bare virama (्), which a
  Hindi word almost never does, the runner now takes the best candidate without one, also trying a few spelling
  variants of the input (for example `acha` → `accha`) and keeping only listed words. `acha` and `achha` now give
  अच्छा. It changes about 0.1% of words: the Aksharantar Hindi test is unchanged at 65.9% (one word fixed, one broken),
  and the Hinglish chat set rises from 112 to 113. Same model and word list; speed is unchanged.
- **1.1.0 (2 Nov 2026):** the runner is about 10 times faster (batched beam search, WebAssembly SIMD kernels with a
  plain-JavaScript fallback, a GELU table, leaner beam search and a 2,000-word cache), contributed by Manit Roy
  ([GitHub #1](https://github.com/udgamlabs/lekhani/pull/1)). Same model and word list: the same best word and the same 8
  candidates, in the same order, on all 9,991 Aksharantar Hindi test words. The download is 0.88 MB (was 0.87 MB).
- **1.0.0 (30 Oct 2026):** first release.

## Licence

Model weights and `translit.js`: Apache-2.0. The word list (`words.bin.gz`): CC0. See `NOTICE` for the credits:
Aksharantar (AI4Bharat; CC-BY hand-collected part, CC0 mined parts), IndicXlit (AI4Bharat, MIT) as the teacher,
IndicCorp v2 (AI4Bharat, CC0) for the word counts, and the CMU Pronouncing Dictionary (BSD-style) for English words.

## Citation

```bibtex
@misc{udgamlabs2026lekhani,
  title  = {Lekhani: a 0.87 MB in-browser Hindi transliterator},
  author = {Prasad, Jitesh K},
  year   = {2026},
  howpublished = {Udgam Labs},
  url    = {https://huggingface.co/udgamlabs/Lekhani}
}
```

Please also cite Aksharantar (Madhani et al., 2022, arXiv:2205.03018), whose data and IndicXlit model made this
possible.

---

**About Udgam Labs.** Udgam Labs is an independent AI research lab. We work from first principles: before we build, we understand why things work, whether we are training a model, fine-tuning one or applying AI to a new problem. Udgam (उद्गम) is Sanskrit for origin. [udgamlabs.com](https://udgamlabs.com)