Atome lm is a ternary, zero-heap language model small enough to live inside a $2 microcontroller. A 944K-parameter model packs to 271 KB and its pure-C99 inference engine compiles to about 2.6 KB of .text, running with no heap, no syscalls and no network. It is AI for things, not chatbots, and is open source under Apache-2.0.

Can a language model really run on a $2 microcontroller?

Yes. The 944K-parameter Atome model runs on a physical ESP32-WROOM-32 (about $5) generating coherent text fully offline at roughly 1 token per second. Smaller configurations from about 14 KB of RAM fit chips as small as an STM32F103. RAM, not parameter count, is the binding constraint.

What makes Atome lm different from other tiny LLMs?

Its specific combination: ternary weights (BitNet b1.58 style), a zero-heap pure-C99 engine, and bit-exact parity between Python, C and an emulated Cortex-M3 verified under QEMU to FP32 epsilon (max |Δ| = 3.7e-7). The same model gives byte-for-byte identical output on a laptop, a server and an emulated chip, which makes it auditable for certified products.

Is Atome lm free and open source?

Yes. The architecture, C99 engine, training code, benchmarks and a 944K checkpoint are public on GitHub under the Apache-2.0 license, with weights on Hugging Face and a citable Zenodo DOI. You can use, modify, redistribute and ship it in commercial products with no per-seat or per-device fees.

What can you build with Atome lm?

Three classes of task fit the engine: a tiny narrow language model fine-tuned on a single domain (FAQ, command help, embedded Q&A); on-device text classifiers (wake-word and command intent, anomaly flags, intent buckets); and a per-token router uncertainty signal. It is a building block that ships inside firmware, not a general-purpose chatbot.

Atome lm — l'IA que vous pouvez mettre dans la puce

Le modèle est le firmware.

Un modèle de langue en 271 Ko.

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. Modèle de langue ternaire 944K paramètres, parité bit-exacte Python ↔ C99 ↔ Cortex-M3. 2,6 Ko de moteur + 271 Ko de poids. Sur un MCU à 5 $.

Trois choses qu'elle fait déjà.

Au-delà d'écrire des histoires, le moteur tourne comme classifieur texte étroit — le genre qu'un vrai produit embarqué livre. Trois prototypes internes, entraînés, exportés et exécutés sur l'émulateur Cortex-M3. Les scripts d'entraînement ne sont pas dans le kit public ; le chemin moteur l'est.

Taille	Sert à	RAM	STM32F103$2-4	RP2040$4	STM32F411$15	STM32F7$15-30	ESP32-S3$5-10
nano	Prouve que le moteur tient sur les plus petites puces	14.5 KB	✓	✓	✓	✓	✓
small	Routage de mots-clés courts	27.5 KB	no RAM	✓	✓	✓	✓
classifier	Têtes de classification on-device	52 KB	no	✓	✓	✓	✓
tinystories	Écriture façon histoire pour enfants	104 KB	no RAM	✓	✓	✓	✓
mid	Écriture sur un sujet précis	205 KB	no	✓	no RAM	✓	✓
prod (944K)	Prose complète — le modèle qui écrit en haut	411 KB	no	no RAM	no	✓	✓

Taille

Sert à

RAM

STM32F103$2-4

RP2040$4

STM32F411$15

STM32F7$15-30

ESP32-S3$5-10

nano

Prouve que le moteur tient sur les plus petites puces

14.5 KB

✓

small

Routage de mots-clés courts

27.5 KB

no RAM

✓

classifier
Têtes de classification on-device
52 KB
no
✓
✓
✓
✓

tinystories

Écriture façon histoire pour enfants

104 KB

no RAM

✓

mid

Écriture sur un sujet précis

205 KB

✓

no RAM

✓

prod (944K)

Prose complète — le modèle qui écrit en haut

411 KB

no RAM

✓

aq u/aquoad l'a exécuté sur sa carte

Plutôt cool. Le modèle complet tourne (lentement, c'en est comique) sur une carte ESP32-S2 de 6 ans avec PSRAM SPI externe — j'ai dû désactiver le watchdog de la tâche idle.

==================== ATOME on SILICON ====================
chip   : ESP32-S2 rev v0.0   cores=1   flash : 4 MB
PSRAM  : 2048 KB (detected)
model  : 276655 bytes embedded in flash
config : d=256 layers=8 head=64 seq=128 state=811 KB
---------------------------------------------------------
prompt: Once  >>> upon a time, there was a little girl named Lily
average: 0.1 tok/s | heap low-water: 243 KB internal

reproduction indépendante · journal série publié

Ic u/IcestormsEdr/esp32

Je vais clairement essayer. Merci beaucoup.

ur u/urgeekyduder/esp32

En tant qu'étudiant en systèmes embarqués, merci pour ce beau travail, continuez 🔥

Mo u/MossiGuyr/esp32

wow je dois essayer ça, c'est franchement impressionnant qu'un LLM tourne sur un microcontrôleur

We u/Wemos_D1r/esp32

Qu'il détecte les lectures de capteur erronées est un super cas d'usage pour un si petit modèle. Beau boulot :p

sh u/shisohanr/esp32

Imaginez un cluster beowulf : 64 ESP32 et vous avez vos 60 t/s pour 300 $ !

Le modèle est le firmware.

Une IA pour les objets, pas pour les chatbots.

Quatre choses qui tiennent ensemble.

Bit-exact dans toute la pile

Tient dans le budget firmware réel

Zéro heap · zéro syscall · zéro réseau

Chaque étape mesurée, pas estimée

Trois petits spécialistes. Un aiguilleur.

Voit les 5 dernières lettres Conv causale depthwise, k=5

Garde la phrase en mémoire SSM diagonal

Pointe vers un mot précédent Attention causale top-k=4

Ce pour quoi c'est conçu.

Ampoules connectées

Jouets & poupées

Conteurs pour dormir

Distributeurs animaux

Automobile

Montres & wearables

Agriculture

Wearables médicaux

Capteurs industriels

Compteurs énergie & eau

Prothèses auditives

Radios de secours

Trois choses qu'elle fait déjà.

Choisit la bonne commande

Repère les lectures suspectes

Range une phrase dans 5 buckets

Vrais chiffres, vraies puces.

Trois environnements. Une réponse.

Une victoire mesurée, et une défaite mesurée.

Une revendication plus étroite mais vérifiable.

BitNet b1.58

llama2.cStories260K

TinyMaixesp32-llm

Atome lm

Une brique, pas un produit.

LM étroit, sur un seul domaine

Classifieurs texte on-device

Signal de routeur par token

Issu de la recherche interne.

Elle est partie dans la nature.