--- license: cc-by-4.0 language: - hi tags: - devanagari - hindi - text-rendering - synthetic - diffusion - stable-diffusion task_categories: - text-to-image size_categories: - 1K **Note on scale.** This is a *pilot*: 72 distinct words. It exists to answer > "can a model learn Devanagari glyph shapes at all", not to teach the script > broadly. See [Limitations](#limitations) before using it as a training set. ## Why this exists Most Devanagari datasets target **recognition** (OCR) and are deliberately adversarial — blur, occlusion, low resolution. A *generator* trained on those learns to produce blurry text. This is the opposite: clean, sharp, and size-constrained so every sample is something a generator should aim to match. ## What makes Devanagari hard - **Shirorekha** — a continuous horizontal bar joins letters across a word. Latin-trained models produce broken or wavy bars. - **Conjuncts** — क् + ष → क्ष. Hundreds of ligatures whose shapes are not compositional from their parts. - **Reordering** — the matra ि is *written before* the consonant it follows logically. - **Three vertical zones** — matras sit above and below the base line. - **Fine diacritics** — nukta ़, anusvara ं, chandrabindu ँ are 2–8 pixel features that vanish under aggressive downsampling. ## Contents ``` data/images/ 4,000 × 512×512 JPEG (quality 95) data/masks/ 4,000 × 512×512 PNG, 8-bit glyph coverage masks data/metadata.jsonl one record per sample data/train_words.txt 72 words used in the images data/holdout_words.txt 20 words deliberately NOT rendered fonts/ 22 OFL Devanagari fonts + fonts/licenses/ corpus/pilot_words.txt the source word list src/ the generator — this dataset is reproducible FINDINGS.md the measurements behind the design ``` ### `metadata.jsonl` | field | meaning | |---|---| | `file` | path relative to `data/` | | `text` | the Hindi string rendered — exact ground truth | | `caption` | training caption (varied template) | | `tokens` | CLIP token count of the caption, template included | | `font` | filename in `fonts/` | | `em` | font em size in pixels | | `x`, `y`, `w`, `h` | text bounding box | | `glyphs` | shaped glyph count — differs from character count due to ligatures | ```json {"file": "images/000000.jpg", "text": "रुकें", "caption": "Hindi text \"रुकें\" on a board, flat design", "tokens": 18, "font": "Khand-Regular.ttf", "em": 40, "x": 150, "y": 405, "w": 62, "h": 48, "glyphs": 3} ``` ## Statistics | | | |---|---| | samples | 4,000 | | resolution | 512 × 512 | | words | 72 train, 20 held out (never rendered) | | fonts | 22, evenly sampled (156–211 samples each) | | font em size | 32–120 px, mean 75.5 | | text box | 44–454 px wide, 30–161 px tall | | caption tokens | 11–29 of CLIP's 77 | | glyphs per sample | 2–8 | Vocabulary spans four groups: simple no-conjunct words, real signage terms, conjunct-bearing words (क्ष ज्ञ त्र श्र द्व ह्म), and diacritic stress cases (nukta, anusvara, chandrabindu, visarga). ## How it was generated Text is shaped with **HarfBuzz** (`uharfbuzz`) and rasterised per-glyph with **FreeType** (`freetype-py`). > ### ⚠️ If you extend this, do not use Pillow for the text > > Pillow's published wheels ship **without Raqm**, so `ImageDraw.text()` renders > Devanagari **unshaped**: conjuncts break into separate letters and pre-base ि > lands on the wrong side of its consonant. The output looks plausible to a > non-reader while being wrong, and silently corrupts the dataset. > > Check with `PIL.features.check('raqm')`. If it returns `False`, use > `src/render/shaper.py` here instead. Verified by `src/diag/verify_shaping.py`, which passes on all 22 fonts: क्ष / त्र / ज्ञ each collapse 3 codepoints → 1 glyph, and the base consonant lands *second* in कि, proving the matra reordered ahead of it. Backgrounds are flat, gradient or lightly textured, with foreground/background luminance contrast **enforced** (≥ 0.35) rather than sampled and hoped for. Captions use 10 templates × 12 surface nouns with the quoted Hindi string as the single invariant anchor; the phrase "Hindi text" is dropped in ~20% of samples so a model does not become dependent on a trigger phrase. ## The 32px rule **Every sample renders text at font em size ≥ 32px, asserted at generation time.** SD1.5's 4-channel VAE downsamples 8×; measured encode→decode round-trips show Devanagari diacritics are destroyed below ~24px em and clean at 32px: | font em size | VAE reconstruction | |---|---| | 12–20 px | destroyed — nuktas gone, conjuncts illegible | | 24 px | marginal — nukta merges into the stroke | | **32 px** | **clean — minimum safe size** | | 48–64 px | near-perfect | Note this is **em size**, not ink-box height: the measured ink/em ratio varies 0.67–1.08 depending on which matras a word carries, so ink height is content-dependent and unsuitable as a threshold. Consequence: this covers **headline- and signage-sized text**, roughly 1–4 words. It is not suitable for training small or body-sized text rendering on a 4-channel VAE at 512px — that is a reconstruction limit no training run can overcome. ## Intended use - Fine-tuning diffusion models (LoRA or full) for Devanagari text - Evaluating text-rendering quality, with exact transcriptions as ground truth - Glyph-conditioned approaches (ControlNet, GlyphControl, AnyText) — masks are included for this - The 20 held-out words test generalisation rather than memorisation **Not suitable for** OCR / scene-text recognition training (these are clean synthetic renders, not photographs), or small-text rendering. ## Limitations - **Synthetic only.** No photographic backgrounds, perspective, occlusion or real-world lighting. A model trained solely on this renders clean text but may not composite convincingly into photographs. - **72 words is pilot scale** — far too small to teach the script broadly. - **Partial conjunct coverage.** श्च has zero coverage in the rendered samples. - **One script, one language.** Devanagari as used for Hindi. Marathi and Nepali share the script with minor differences and are not specifically covered. ## Licensing - **Images, masks, metadata, generator code** — generated from the hand-written word list in `corpus/pilot_words.txt` using OFL fonts. No third-party data. **CC BY 4.0.** - **`fonts/`** — 22 families from Google Fonts under the **SIL Open Font License 1.1**, which permits redistribution. Full licence texts are included in `fonts/licenses/`. The OFL applies to those files, not CC BY. Nothing in this repository is derived from any dataset whose terms prohibit redistribution. ## Reproducing ```bash pip install uharfbuzz freetype-py pillow numpy transformers python src/diag/get_fonts.py # fetch the 22 OFL fonts python src/diag/font_audit.py # coverage + conjunct-formation check python src/diag/verify_shaping.py # prove HarfBuzz shaping is active python src/data/gen_pilot.py --n 4000 --out data/pilot --masks --seed 42 ``` ## Citation ```bibtex @misc{hinditext_pilot_2026, title = {HindiText-Pilot: synthetic Devanagari text-rendering pairs}, author = {Sinhal}, year = {2026}, url = {https://huggingface.co/datasets/sinhal/HindiText-Pilot} } ```