EmbermoteExplore models
All models
TEXT / LANGUAGE IDENTIFICATION

Lilt

Every language has a rhythm.

A small first step toward understanding. Identify eight languages, directly on the device.

Try Lilt ↓Download weights
Artifact size146.5 KB
RunsLocally
Output classes8
Release stageResearch
01 / WHAT IT DOES

One focused task.
A closer look.

Lilt looks for short character patterns associated with eight languages. Give it a sentence and it ranks the supported languages, without sending the sentence to a server. It identifies language; it does not translate or generate text.

EnglishSpanishFrenchGermanItalianPortugueseHindiJapanese

Research v0.1.0 · A statistical classifier, not a generative foundation model.

  1. 01

    Read the characters

    Lowercase the sentence, normalize whitespace, and extract character pairs and triples.

  2. 02

    Compare language patterns

    Sum learned log-likelihoods for vocabulary features, using add-one smoothing and equal class priors.

  3. 03

    Rank the languages

    Return the highest-scoring language and normalized scores. No known features produces Unknown.

02 / TRY IT HERE

Get a feel for Lilt.

Actual model inference, inside your browser.
No input is uploaded.

MODEL OUTPUT

Ready when
you are.

Scores are relative model outputs, not calibrated confidence.

Know the boundaries. An eight-language research baseline trained on a small authored corpus. Short, mixed-language, and unsupported-language text can be misclassified.
03 / IDEAS TO EXPLORE

What could you make?

Starting points for prototypes.
Validate the model for your use case.

01

Route messages to the right language experience.

Experiment with choosing a language-specific interface from a full sentence. Always let the user override the suggestion.

Build with Lilt
02

Organize a multilingual collection of notes.

Group a small personal notebook by language and inspect mistakes before applying tags.

Build with Lilt
03

Choose a language before a larger model runs.

Explore a cheap first-stage router before a larger model, with an explicit fallback for unsupported languages.

Build with Lilt
04 / DATA, WITH CONTEXT

What went into Lilt.

Read the model card

Where the examples came from

80 sentences authored by the coding assistant inside the training script: ten in each of eight languages. These follow similar everyday themes and are not a collected multilingual corpus. No external dataset or pretrained weights were used.

How the split works

The first eight sentences per language train the classifier; the last two are held out. This is a fixed split of closely related examples, with no independent author or domain separation.

No third-party model weights, external datasets, or user inputs were used to train this version. Training records are kept private. We publish weights, model cards, aggregate results, and the limitations of each release.

TRAINING SUMMARY

Multinomial naïve Bayes · character pairs and triples

Weights you can inspect.

Each release includes its model card, measured artifact size, and SHA-256 checksum. Training data and working checkpoints stay private.

Download model card
05 / GETTING STARTED

Build with Lilt.

Full SDK guide

Use the local workspace packages today. These packages have not been published to npm or Maven Central.

Node.js / TypeScript

Run from the repository root, then import the model from a workspace example.

bun install
bun run sdk:build

Kotlin / JVM

With JDK 17+ and Gradle 8.10+, publish the modules to your local Maven repository.

gradle test
gradle publishToMavenLocal
Local Gradle dependency
repositories {
    mavenLocal()
    mavenCentral()
}
dependencies {
    implementation("dev.embermote:lilt:0.1.0")
}

Kotlin/JVM tests pass. Android device validation, Swift, and native Core ML/LiteRT adapters are not available.

import { createModel } from '@embermote/lilt';

const model = createModel();
const input = "Les enfants jouent près de la maison.";

const result = model.predict(input);
console.log(result.label);
// Scores are not calibrated confidence.
Local artifact → local inferenceNo API key.
06 / SPECIFICATIONS

Specs.

Model
Multinomial naïve Bayes · character pairs and triples
Input
A nonempty text string, up to 20,000 UTF-16 code units in the SDK.
Output
A label, ranked scores, and a supported flag. Scores are uncalibrated; supported is not a guarantee that the input is in distribution.
Classes
English, Spanish, French, German, Italian, Portuguese, Hindi, Japanese
On-device size
146.5 KB · downloadable JSON weights · v0.1.0
Size includes
Labels, vocabulary or numeric statistics, and learned weights. Excludes SDK code, application assets, download compression, and runtime memory.
Platforms
Browser and Node.js via TypeScript runtime; Kotlin/JVM via bundled resources.
License
MIT for the original code and research artifacts.
Status
Research baseline · not published to package registries
SHA-256
6ed25e6ad7de36bcdce12b99c2a11bffd43a58e891c7f6595e9eaf6cf1d770d4
07 / GOOD QUESTIONS

A little more clarity.

Will it detect any language?

No. It ranks only the eight supported languages. Unknown means no vocabulary overlap; it is not a reliable detector for every unsupported language.

Does my input leave the device?

Inference runs locally. The website and artifact download make ordinary network requests, but the demos do not upload your input. Bundled SDK inference does not need an inference server.

Why is the model so small?

Lilt stores a compact statistical representation for a narrow task. Its 146.5 KB artifact is not equivalent to a neural model of a different size, and the file size is not its total runtime memory.

Is the model ready to ship in my product?

This is a research baseline. Independent evaluation, task-specific acceptance criteria, real-device measurements, and release packaging remain necessary before production use.

KEEP EXPLORING

The open notebook.

Inspect the pieces behind this model.