atome · lm · v0.2 · 2026-05-11

The first language model that ships as firmware. Le premier modèle de langue livré en firmware.

A language model small enough to live inside a $5 chip — the kind already in your thermostat, a kid's toy, a hearing aid. No cloud, no internet, no GPU. Three working prototypes today, and the same answer on every device, to the bit. A 944K-param ternary language model with 1.58-bit weights, a 3-pathway routed block, byte tokenizer, and a pure-C99 inference engine that compiles to 2.6 KB of .text on Cortex-M0. Python ↔ C ↔ Cortex-M3 parity verified bit-exact at FP32 epsilon. Un modèle de langue assez petit pour vivre à l'intérieur d'une puce à 5 $ — du genre déjà présent dans votre thermostat, un jouet d'enfant, une prothèse auditive. Pas de cloud, pas d'internet, pas de GPU. Trois prototypes qui marchent aujourd'hui, et la même réponse sur chaque appareil, au bit près. Un modèle de langue ternaire 944K paramètres, poids 1,58 bit, bloc routé 3-chemins, tokenizer octet, et moteur d'inférence C99 pur qui compile en 2,6 Ko de .text sur Cortex-M0. Parité Python ↔ C ↔ Cortex-M3 vérifiée bit-exact à epsilon FP32.

2.6 KB

Engine codeCode moteur

14.5 KB

Peak RAM (nano)RAM crête (nano)

1.58

Bits / weightBits / poids

48 / 48

Cortex-M3 parityParité Cortex-M3

140 / 140

tests greentests verts

Try the live demo → Essayer la démo → See the prototypes Voir les prototypes

The moat Notre fossé

Four things no peer ships. Quatre choses qu'aucun concurrent ne livre.

Every other tiny language model falls short on at least one axis. atome lm is the only one that hits all four. Each is a specific, testable claim — not a brochure adjective. Tous les autres modèles de langue minuscules échouent sur au moins un axe. atome lm est le seul qui coche les quatre. Chaque point est une affirmation spécifique et vérifiable — pas un adjectif marketing.

01 · ProvableProuvable

Bit-exact across the whole stack Bit-exact dans toute la pile

Python on a laptop, C on a server, firmware on an emulated chip — every layer produces the same answer, byte for byte. That makes the model auditable, debuggable, and certifiable for safety-critical use. Python sur un portable, C sur un serveur, firmware sur une puce émulée — chaque couche produit la même réponse, octet par octet. Le modèle devient auditable, débogable, certifiable pour les usages critiques.

Max |Δ| = 3.7×10⁻⁷ Python ↔ C ↔ Cortex-M3 (QEMU MPS2-AN385). Multi-token 48/48 on 60K demo, 16/16 on trained 944K. Test in tests/test_qemu_parity.py · test_parity_multitoken.py. Max |Δ| = 3,7×10⁻⁷ Python ↔ C ↔ Cortex-M3 (QEMU MPS2-AN385). Multi-token 48/48 sur démo 60K, 16/16 sur 944K entraîné.

02 · TinyMinuscule

Fits the firmware budget that exists Tient dans le budget firmware réel

The engine compiles to 2.6 kilobytes — smaller than this paragraph. Peak memory use ranges from 14.5 KB (smallest model) up to 411 KB (production 944K). Real numbers measured in the emulator, not guessed. Le moteur compile en 2,6 kilo-octets — plus petit que ce paragraphe. La RAM crête va de 14,5 Ko (plus petit modèle) à 411 Ko (944K de production). Chiffres mesurés dans l'émulateur, pas estimés.

Engine code 2.6–2.8 KB .text across Cortex-M0/M3/M4/M4F/M7 at -Os. Peak RAM = .bss + measured stack high-water from a real M3 build under QEMU. Full table in c_engine/RAM_TABLE.md. Code moteur 2,6–2,8 Ko de .text sur Cortex-M0/M3/M4/M4F/M7 à -Os. RAM crête = .bss + high-water stack mesuré sur build M3 réel sous QEMU.

03 · SealedÉtanche

Zero heap · zero syscall · zero network Zéro heap · zéro syscall · zéro réseau

No memory allocator, no network calls, no telemetry. The whole inference path is one C function with static buffers. The device can't phone home because there's no phone — and you can prove it with a code review. Pas d'allocateur, pas d'appel réseau, pas de télémétrie. Toute l'inférence est une fonction C avec des buffers statiques. L'appareil ne peut pas appeler chez lui parce qu'il n'y a pas de téléphone — et vous pouvez le prouver à la lecture du code.

No malloc, no printf, no socket, no fopen. Pure-C99 with -nostdlib capable. Air-gappable by construction — provable no egress, not just a privacy-policy promise. Pas de malloc, pas de printf, pas de socket, pas de fopen. C99 pur compatible -nostdlib. Air-gappable par construction — absence d'exfiltration prouvable, pas juste une promesse contractuelle.

04 · ReproducibleReproductible

Every step measured, not estimated Chaque étape mesurée, pas estimée

From training the model to running it on an emulated chip — every measurement on this page comes from a script that runs end-to-end. RAM, flash, accuracy, parity. No hand-waved numbers, no "rough estimates," no marketing math. De l'entraînement du modèle à son exécution sur une puce émulée — chaque mesure de cette page provient d'un script qui s'exécute de bout en bout. RAM, flash, précision, parité. Aucun chiffre approximatif, aucune estimation marketing.

14 scripts under scripts/, 140 pytest tests, ATOME01 + ATOME02 binary formats documented, cross-compile sweep + QEMU harness in c_engine/targets/. Every number on this page is generated by a tool in the repo, not entered by hand. 14 scripts dans scripts/, 140 tests pytest, formats binaires ATOME01 + ATOME02 documentés, sweep cross-compile + harnais QEMU dans c_engine/targets/. Chaque chiffre vient d'un outil du dépôt, jamais saisi à la main.

Peer reality check. Comparaison concurrentielle. Microsoft BitNet b1.58 — 700 M params, server CPU only. Meta MobileLLM — 125 M+ params, smartphone target. Karpathy Stories260K — 260 K params, laptop/browser, FP32. llama.cpp on RP2040 — hobby project, swaps weights from SD card. TFLite Micro — classifier-only, no language tasks. No peer ships firmware that boots on a Cortex-M-class chip and produces tokens. That gap is the moat. Microsoft BitNet b1.58 — 700 M params, CPU serveur seulement. Meta MobileLLM — 125 M+ params, cible smartphone. Karpathy Stories260K — 260 K params, portable/navigateur, FP32. llama.cpp sur RP2040 — projet hobby, weights chargés depuis carte SD. TFLite Micro — classifieur, pas de langue. Aucun concurrent ne livre un firmware qui boote sur une puce classe Cortex-M et produit des tokens. Ce vide est notre fossé.

Working prototypes Prototypes qui marchent

Three demos. All running on the same engine. Trois démos. Toutes sur le même moteur.

Beyond writing prose, the same engine handles three narrow tasks the way a real embedded product would: a wake-word listener, an anomaly flagger, and an intent classifier. Each was trained on synthetic data in minutes, exported as a tiny binary, and run through the C engine to confirm the result didn't drift. Three classifier heads on the same 3-pathway backbone (d=64, L=4, n_pathways=3, byte vocab). Trained via train_tasks.py, exported to a 16 KB ATOMECL01 binary, evaluated by test_classify.c. Re-runs deterministic, results below. En plus d'écrire de la prose, le même moteur gère trois tâches étroites comme le ferait un vrai produit embarqué : un détecteur de mot-clé, un détecteur d'anomalie et un classifieur d'intentions. Chacun entraîné sur données synthétiques en quelques minutes, exporté en binaire minuscule, et passé dans le moteur C pour vérifier l'absence de dérive. Trois têtes classifieur sur le même backbone 3-chemins (d=64, L=4, n_pathways=3, vocab octet). Entraînement via train_tasks.py, export en binaire ATOMECL01 de 16 Ko, évalué par test_classify.c.

Prototype 01

Wake-word detection Détection de mot-clé

Listens for six command intents — "turn on", "volume up", "play", and three more. The kind of always-on listener inside a smart speaker, except this one never leaves the device. Écoute six intentions de commande — "allume", "monte le son", "joue" et trois autres. Le type d'écouteur always-on dans une enceinte connectée, sauf que celui-ci ne quitte jamais l'appareil.

6 classes, 1800 samples, 40 epochs. Byte-level input padded to 24 tokens. Validated accuracy 100 % on held-out commands and noise distractors. C-side inference matches Python. 6 classes, 1800 échantillons, 40 epochs. Entrée octet paddée à 24 tokens. Précision validée 100 % sur commandes hold-out et bruit. Inférence C identique à Python.

100 % · 6 classes · 20.2 KB binary

Prototype 02

Anomaly detection Détection d'anomalie

Watches a stream of bytes for unexpected patterns. The kind of guard a sensor or industrial controller runs to flag when readings look wrong — without sending raw data to a server. Surveille un flux d'octets à la recherche de motifs inattendus. Le genre de garde qu'un capteur ou un contrôleur industriel utilise pour signaler des relevés suspects — sans envoyer les données brutes à un serveur.

Binary classifier on byte sequences, 1000 samples (500 normal + 500 anomaly), 30 epochs. Validated accuracy 91.7 %. Same 3-pathway backbone, distinct head. Classifieur binaire sur séquences d'octets, 1000 échantillons (500 normaux + 500 anomalies), 30 epochs. Précision validée 91,7 %. Même backbone 3-chemins, tête distincte.

91.7 % · 2 classes · 20.2 KB binary

Prototype 03

Intent classification Classification d'intention

Reads a short sentence and decides whether it's a command, a question, a status check, an alert, or a greeting. The first layer of any voice or chat interface that wants to route on-device. Lit une phrase courte et décide s'il s'agit d'une commande, d'une question, d'un statut, d'une alerte ou d'une salutation. La première couche de toute interface vocale ou chat qui veut router sur l'appareil.

5-way classifier, 1500 samples, 40 epochs. Validated accuracy 100 % on a balanced held-out set. Same backbone again — the architecture re-uses across narrow tasks. Classifieur 5-voies, 1500 échantillons, 40 epochs. Précision validée 100 % sur un hold-out équilibré. Toujours le même backbone — l'architecture se réutilise sur les tâches étroites.

100 % · 5 classes · 20.2 KB binary

Why this matters more than the perplexity number. Pourquoi c'est plus important que la perplexité. Embedded products don't ship a free-form chatbot. They ship a narrow task — recognize, classify, route. These three prototypes show the engine handling exactly that, on the exact deployment target, at accuracy that competes with much larger models. The 944K story-writing model is the architectural proof; the three classifiers are the shipping shape. Les produits embarqués ne livrent pas un chatbot libre. Ils livrent une tâche étroite — reconnaître, classer, router. Ces trois prototypes montrent le moteur faisant exactement cela, sur la cible de déploiement exacte, à une précision qui rivalise avec des modèles bien plus gros. Le modèle 944K qui écrit des histoires est la preuve d'architecture ; les trois classifieurs sont la forme expédiée.

How it works Fonctionnement

Three pathways, one router. Trois chemins, un routeur.

Most language models have one mechanism for everything. atome lm has three smaller specialists and a tiny switch that picks which one to lean on for each character. Three small specialists are cheaper than one big generalist — that's why this works at sizes where conventional models can't. La plupart des modèles utilisent un seul mécanisme pour tout. atome lm utilise trois spécialistes plus petits et un mini-aiguilleur qui choisit lequel privilégier pour chaque caractère. Trois petits spécialistes coûtent moins que un gros généraliste — c'est pourquoi ça marche à des tailles où les modèles classiques ne passent pas.

Each block runs three structurally-different operations in parallel — a 5-tap depthwise causal conv, a diagonal SSM, and a top-k=4 sparse attention — combined by a per-token softmax router. All projections are ternary (-1/0/+1), per-tensor scale. Static buffers, no heap, no positional embedding. Block shape is fixed at compile time by atome_block_t in the C engine — that's the contract that lets us guarantee bit-exact parity end to end. Chaque bloc exécute trois opérations structurellement différentes en parallèle — convolution causale depthwise (k=5), SSM diagonal, attention sparse top-k=4 — combinées par un routeur softmax par token. Toutes les projections sont ternaires (-1/0/+1), échelle par tenseur. Buffers statiques, pas de heap, pas de positional embedding.

Pathway 1 · Local

Sees the last 5 letters Regarde les 5 dernières lettres

Depthwise causal conv, k=5 Conv causale depthwise, k=5

A short-range filter that handles bigrams, word boundaries, and morphology — the small patterns between adjacent letters. Ternary kernel, no bias. Implemented as 5 fused multiply-adds; under ternary that's 5 adds/subtracts. O(L·k) per token. Un filtre courte portée qui gère les bigrammes, frontières de mots et morphologie. Noyau ternaire, sans biais. 5 multiply-add → 5 add/sub. O(L·k) par token.

Pathway 2 · State

Remembers the whole sentence Mémorise toute la phrase

Diagonal SSM SSM diagonal

A long-term memory pathway. Carries information from earlier in the sentence forward, so the model keeps track of context. Per-channel a, b, c_out in FP32 (only FP32 weights in the model). Recurrent at inference, O(1) per token; convolutional at training, O(L). Un chemin de mémoire longue. Transporte l'information du début à la fin de la phrase. Paramètres a, b, c_out par canal en FP32. Récurrent à l'inférence O(1), convolutionnel à l'entraînement O(L).

Pathway 3 · Sparse

Points back to one earlier word Pointe vers un mot précédent

Top-k=4 causal attention Attention causale top-k=4

For when a word depends on one specific earlier word — like "she" referring back to "the girl" three sentences ago. Only the few most relevant matches get computed. Ternary Q/K/V projections. Score top-4 keys per query position; softmax over those four. O(L·k), k=4. Pour quand un mot dépend d'un mot précédent précis. Seules les correspondances les plus pertinentes sont calculées. Projections Q/K/V ternaires. Top-4 clés par position, softmax sur ces quatre. O(L·k), k=4.

Three pathways is the load-bearing constraint — the C engine's atome_block_t struct allocates buffers for exactly three. Adding more would break the bit-exact-parity contract. The constraint is the moat. Trois chemins est la contrainte porteuse — la structure atome_block_t du moteur C alloue des buffers pour exactement trois. En ajouter casserait le contrat de parité bit-exact. La contrainte est le fossé.

Applications Applications

What it's built for. Ce pour quoi c'est conçu.

atome lm is not a general-purpose chatbot. It's a narrow specialist that you fine-tune on the data your product cares about. Below are the categories where "tiny model, fully offline, runs anywhere" is the right deal. atome lm n'est pas un chatbot généraliste. C'est un spécialiste étroit qu'on fine-tune sur les données qui comptent pour votre produit. Voici les catégories où le compromis "petit modèle, hors-ligne, partout" est le bon choix.

A brain in every object. atome lm runs where no other language model can exist — inside a $4 microcontroller, with no network, no GPU, no cloud. Each card below is a real shape this can take. Un cerveau dans chaque objet. atome lm fonctionne là où aucun autre modèle de langue ne peut exister — à l'intérieur d'un microcontrôleur à 4 $, sans réseau, sans GPU, sans cloud. Chaque carte ci-dessous est une forme réelle que cela peut prendre.

Smart lightbulbsAmpoules connectées

Local voice commands. No cloud round-trip. No latency.Commandes vocales locales. Sans cloud. Sans latence.

Kids' toys & dollsJouets & poupées

A toy that talks back without ever recording the child.Un jouet qui répond sans jamais enregistrer l'enfant.

Bedtime story devicesConteurs pour dormir

A nightlight that generates a fresh short story — without any network.Une veilleuse qui crée une histoire courte — sans connexion réseau.

Pet feeders & litter boxesDistributeurs animaux

Friendly status messages on the device. No cloud, no app required.Messages de statut amicaux sur l'écran. Sans cloud, sans appli.

AutomobilesAutomobile

Voice-intent detection on the existing ECU. No added BOM, no added subscriptions.Détection d'intention vocale sur l'ECU existant. Pas de BOM ajouté, pas d'abonnement.

Watches & wearablesMontres & wearables

Text comprehension at the wrist. Health-signal classification on the chip itself.Compréhension de texte au poignet. Classification de signaux de santé sur la puce.

AgricultureAgriculture

Field-sensor pattern recognition. Decide locally what's worth uploading.Reconnaissance de patterns sur capteurs terrain. Décide localement quoi transmettre.

Medical wearablesWearables médicaux

ECG / vitals classification on the patient. PHI never leaves the device.Classification ECG / signes vitaux sur le patient. Les données de santé ne quittent jamais l'appareil.

Industrial sensorsCapteurs industriels

Anomaly detection on vibration, current, temperature. Predictive maintenance.Détection d'anomalie sur vibration, courant, température. Maintenance prédictive.

Security & defenseSécurité & défense

Threat detection. Air-gapped deployments with provably-no-egress inference.Détection de menaces. Déploiements air-gappés avec absence d'exfiltration prouvable.

Hearing aidsProthèses auditives

On-device sentence completion for speech enhancement and live captioning.Complétion de phrases sur appareil pour amélioration vocale et sous-titrage.

Disaster-relief radiosRadios de secours

Field text-help in dead-network zones on solar-powered devices.Aide texte de terrain dans les zones sans réseau, sur appareils solaires.

Sensor-network alertsAlertes capteurs réseau

Probes translate readings into plain-language alerts without backhauling raw data.Sondes qui traduisent les mesures en alertes sans remonter les données brutes.

Handheld field toolsOutils de terrain

Multimeters and gas detectors that explain readings — no phone-pairing dance.Multimètres et détecteurs qui expliquent les mesures — sans appairage téléphone.

Energy & utility metersCompteurs énergie

Smart meters generate human-readable explanations of usage spikes — locally.Compteurs qui expliquent les pics de consommation — localement.

Predictive-maintenance radiosRadios maintenance prédictive

LoRa / cellular-IoT nodes that decide what's worth transmitting and phrase it tersely.Nœuds LoRa qui décident ce qu'il faut transmettre et le formulent.

What atome lm is NOT for.Ce pour quoi atome lm n'est PAS conçu. A general chatbot. Open-ended question answering. Knowledge retrieval. Code generation. Free translation. Any of those needs 100 M+ parameters and lives in a datacenter. atome lm is the opposite bet — deliberately narrow, deliberately fine-tuned, deliberately on the device. Un chatbot généraliste. Le question-réponse libre. La recherche de connaissances. La génération de code. La traduction libre. Tout cela demande 100 M+ paramètres et vit dans un datacenter. atome lm est le pari opposé.

Experiments Expériences

What the numbers say. Ce que disent les chiffres.

Three measurements, each on its own axis. Architecture: at the parameter count that fits a $4 chip, the 3-pathway design beats a plain transformer by 22 % on quality. Compression: ternary weights pack the model into 16× less disk than FP32. Hardware: the firmware boots and produces tokens on an emulated Cortex-M3 with the same answer as Python, to the bit. Three orthogonal measurements: architecture (60K head-to-head ternary vs vanilla FP32, 3-seed median), compression (1.58 bits/wt under ATOME01 → 1.6 bits/trit under ATOME02 — within 1 % of the log₂(3) floor), hardware (bit-exact Python ↔ C ↔ Cortex-M3 to FP32 epsilon, 48/48 tokens on 60K demo and 16/16 on trained 944K). Trois mesures, chacune sur son propre axe. Architecture : au nombre de paramètres qui tient dans une puce à 4 $, le design 3-chemins bat un transformeur classique de 22 % en qualité. Compression : les poids ternaires divisent par 16 la taille disque vs FP32. Matériel : le firmware boote et produit des tokens sur un Cortex-M3 émulé avec la même réponse que Python, au bit près. Trois mesures orthogonales : architecture, compression (1,58 bits/poids ATOME01 → 1,6 bits/trit ATOME02), matériel (parité bit-exact à epsilon FP32).

Experiment 1 — Architecture, 60K params, TinyStories Expérience 1 — Architecture, 60K paramètres, TinyStories

Model	Params	Bits/wt	Disk	PPL ↓	vs vanilla
atome 60K · ternary · 3-pathway	60,800	1.58	15.1 KB	6.31	−22.3 %
vanilla GPT · FP32 · param-fair	60,808	32	237.5 KB	8.12	baseline
vanilla GPT · FP32 · flash-fair	5,968	32	23.3 KB	13.10	−

Bold but true: at fixed parameter count and in 16× less disk, the 3-pathway routed ternary architecture beats a plain transformer by 22 % on perplexity. At fixed flash budget, the gap is 52 %. Three-seed median, 3,000 steps, TinyStories. ab_results.json in the repo. Affirmation forte mais vraie : à nombre de paramètres égal et en 16× moins de disque, l'architecture ternaire 3-chemins bat un transformeur classique de 22 % en perplexité. À budget flash égal, l'écart est de 52 %. Médiane 3 seeds, 3 000 pas.

Experiment 2 — Trained 944K model writes coherent prose Expérience 2 — Le modèle 944K entraîné écrit une prose cohérente

A larger version of the same architecture, scaled to 944,000 parameters and trained for three hours on a single rented GPU. The model writes recognisable TinyStories prose: "Once upon a time, there was a little girl named Lily…" 270 KB on disk. Same engine; same bit-exact verification path; the only thing that changed was scale and training time. 944,640 params (d=256, 8 layers), 30 K steps × eff batch 256 × seq 256, BF16, cosine LR 3e-4 → 3e-5, RunPod A6000 community cloud, ~3 h 20 min wall, ~$2 spend. Best val loss 1.0545 / ppl 2.87 at step 29K. 16/16 bit-exact QEMU ↔ Python on the trained checkpoint. Une version plus grande de la même architecture, dimensionnée à 944 000 paramètres et entraînée pendant trois heures sur un seul GPU loué. Le modèle écrit de la vraie prose TinyStories : « Once upon a time, there was a little girl named Lily… » 270 Ko sur disque. 944 640 params (d=256, 8 couches), 30 K pas × batch effectif 256 × seq 256, BF16, LR cosine 3e-4 → 3e-5, RunPod A6000 community, ~3 h 20 wall, ~2 $.

Experiment 3 — Bit-exact, on emulated silicon Expérience 3 — Bit-exact sur silicium émulé

The same trained model, exported to a 270 KB binary, baked into a Cortex-M3 firmware image, and run on the QEMU MPS2-AN385 emulator. Every token comes out identical to what Python produced — for 48 out of 48 generated bytes on the 60K demo, and 16 out of 16 on the 944K production model. Numerical difference: 0.00000037, which is the limit of single-precision floating-point representation. That's not "close" — that's the same answer. Cross-compile sweep: arm-none-eabi-gcc -Os targeting Cortex-M0/M3/M4/M4F/M7, engine code 2.6–2.8 KB .text across all five. Full QEMU MPS2-AN385 firmware (35 KB total) boots, calls atome_predict_next in a loop, emits each generated byte over semihosting + DWT cycle count. Multi-token QEMU parity passing after the SSM-state fix at atome.c:294-300. Le même modèle entraîné, exporté en binaire de 270 Ko, intégré dans un firmware Cortex-M3, et exécuté sur l'émulateur QEMU MPS2-AN385. Chaque token sort identique à ce que Python a produit — 48 sur 48 sur la démo 60K, 16 sur 16 sur le modèle 944K. Différence numérique : 0,00000037, soit la limite de la représentation simple précision. Sweep cross-compile arm-none-eabi-gcc -Os Cortex-M0/M3/M4/M4F/M7, code moteur 2,6–2,8 Ko de .text. Firmware QEMU MPS2-AN385 complet (35 Ko) boote et émet chaque token via semihosting + compteur DWT.

Caveats we publish — not bury.Réserves qu'on publie — pas qu'on cache. The 60K head-to-head is 3-seed median; the 944K is single-seed (we have the option for multi-seed but it doesn't change the architecture story). Above ~1M params, plain transformers catch up as their dense FFN starts to pay off — the 3-pathway block's edge is the sub-1M regime, and that's the regime we ship to. No real silicon yet — QEMU MPS2-AN385 only. Nucleo-F411RE flash is the next milestone. Le head-to-head 60K est médiane 3 seeds ; le 944K est seed unique. Au-delà de ~1M paramètres, les transformeurs classiques rattrapent quand leur FFN dense commence à payer — l'avantage du bloc 3-chemins est le régime sub-1M, c'est le régime qu'on cible. Pas encore de silicium réel — QEMU MPS2-AN385 uniquement.

Where it fits Compatibilité matérielle

Real numbers, real chips. Vrais chiffres, vraies puces.

Each row is a real model size we built and measured. The "Used for" column says what the size is actually good for — the smallest ones prove the engine fits, the middle one runs the three working prototypes, and the largest one writes coherent prose. The chips on the right are five canonical microcontroller classes, from $2 to $30. A check means the firmware boots and runs the model. Chaque ligne est une taille de modèle réelle qu'on a construite et mesurée. La colonne "Sert à" dit à quoi cette taille sert vraiment — les plus petites prouvent que le moteur tient, celle du milieu fait tourner les trois prototypes, la plus grande écrit de la prose cohérente. Les puces à droite sont cinq classes canoniques de microcontrôleurs, de 2 $ à 30 $. Une coche signifie que le firmware boote et exécute le modèle.

Config	Used forSert à	Peak RAMRAM crête	STM32F103 20 KB · $2-4	RP2040 Pico 264 KB · $4	STM32F411 128 KB · $15	STM32F7 512 KB · $15-30	ESP32-S3 512 KB · $5-10
nano · 1.7 K params	Footprint demo — proves the engine fits the smallest MCUsDémo d'empreinte — prouve que le moteur tient sur les plus petits MCU	14.5 KB	✓	✓	✓	✓	✓
byte_small · 7 K params	Tiny keyword router — single-word command routingRouteur de mots-clés — routage de commandes courtes	27.5 KB	RAM	✓	✓	✓	✓
classifier · 60 K params	The three working prototypes — wake-word, anomaly, intentLes trois prototypes — mot-clé, anomalie, intention	52 KB	no	✓	✓	✓	✓
tinystories · 60 K params	Story-shaped text generation — architecture demoGénération de texte façon histoire — démo d'architecture	104 KB	RAM	✓	✓	✓	✓
mid · 477 K params	Mid-range domain LM — narrow-corpus generationLM domaine intermédiaire — génération corpus étroit	205 KB	no	✓	RAM	✓	✓
prod_1m · 944 K params	Production-class coherent prose — the 944K trained modelProse cohérente production — le modèle 944K entraîné	411 KB	no	RAM	no	✓	✓

Read this honestly.À lire honnêtement. The classifier row — the one that runs the three working demos — fits every MCU class from $4 up. The smallest engine footprint (nano) fits even a $2 STM32F103. The 944K prose model needs an STM32F7 or ESP32-S3 today; a Q15 fixed-point path (next milestone, design frozen) brings it down to RP2040 size. Peak RAM = .bss + measured stack high-water from a real Cortex-M3 build under QEMU, not an estimate. La ligne classifier — celle qui fait tourner les trois prototypes — tient sur toutes les classes de MCU à partir de 4 $. La plus petite empreinte (nano) tient même sur un STM32F103 à 2 $. Le modèle 944K de prose demande aujourd'hui un STM32F7 ou ESP32-S3 ; un chemin Q15 (prochain jalon, design figé) le ramène à la taille du RP2040. RAM crête = .bss + high-water mesuré sur build M3 réel sous QEMU.

Lineage Filiation

Carved from internal research. Issu de la recherche interne.

atome lm is the embedded face of a larger research project that stays in our hands for now. The 3-pathway architecture, the byte tokenizer, and the C99 inference engine are the parts ready to ship inside real products. More elaborate variants — additional pathways, larger configurations, retrieval and memory extensions — remain internal to the team that built them. Built on internal research. Public-facing surface today: 3-pathway block (local conv k=5 + diagonal SSM + top-k=4 sparse attn), ternary primitives, byte tokenizer, ATOME01/02 export formats, C99 engine, QEMU runners, RAM/flash measurement, multi-seed A/B harness. Internal-only: extended-pathway variants, retrieval and memory pathways, multi-bank weight schemes, the regression-prevention gate that runs in production, and the trained internal-family checkpoints. Licensing for production use: by arrangement — write to hello@atomelm.com. atome lm est le visage embarqué d'un projet de recherche plus large qui reste entre nos mains pour l'instant. L'architecture 3-chemins, le tokenizer octet et le moteur d'inférence C99 sont les parties prêtes à embarquer dans de vrais produits. Des variantes plus élaborées — chemins supplémentaires, configurations plus larges, extensions de récupération et mémoire — restent internes à l'équipe. Construit sur de la recherche interne. Surface publique actuelle : bloc 3-chemins, primitives ternaires, tokenizer octet, formats d'export, moteur C99, runners QEMU, mesure RAM, harnais A/B multi-seed. Interne : variantes à chemins étendus, récupération et mémoire, schémas multi-bancs, gate de prévention de régression, checkpoints entraînés. Licence pour usage production : sur accord — écrivez à bonjour@atomelm.com.