The cheapest computer in most homes already has a CPU, a gigabyte or so of RAM and flash storage that sits idle most of the day. smolmaxxing asks how large a language model that hardware can run, and answers the question on the hardware itself. Its headline result is Ling-mini-2.0, a model with 16.3 billion parameters, generating text at 5.1 tok/s on a Xiaomi TV Box S 3rd Gen with about 1 GB of usable RAM. The same 16B model also runs on a jailbroken iPad Air from 2013, with about 700 MB of usable memory.
None of that works the normal way. The model file for Ling-mini-2.0 takes close to 6 GB of flash on the TV box once its cache is written. What makes it run is a set of patches that keep only part of the model in memory at any moment and read the rest from flash as each token needs it.
smolmaxxing
Official siteA patch set and lab notebook for running the biggest language model you can on the smallest hardware you own. Primary use case: local inference on TV boxes, old tablets and phones with far more flash storage than RAM, where a stock build of llama.cpp either cannot load the model or crawls.
Key features: an expert pager that keeps popular experts in RAM and reads the rest from flash on demand; kernels written for the Cortex-A55 and the Apple A7, including a 1 bit lookup table kernel; pruned output heads that cut 0.2 to 0.5 GB from a model file; a streaming engine for dense models bigger than RAM; and published model files with rebuild scripts.
Advantages: the numbers are unusually honest, measured on each device with raw logs kept in the repo, and nothing needs a network once the files are on the device. Limitations: the model files need the patched build; the iPad route needs a jailbreak; and the fastest settings for the biggest models carry quality costs the project itself measures.
What it is
smolmaxxing is a project by the GitHub account hyperionaidev. The repo opened on November 4, 2026 and had 735 stars when checked on November 15. It is not a product and does not present itself as one. It holds patches for llama.cpp, tools for rebuilding model files, chat pages, benchmark logs for every run, and a notebook that records 165 experiments in order, failures included.
Three devices carry results so far. This piece is about the two that work with about 1 GB of memory, because that is where the interesting engineering sits.
| Device | Chip | Usable RAM | System | Everyday model | Biggest model |
|---|---|---|---|---|---|
| Xiaomi TV Box S (3rd Gen) | Amlogic S7D, 4 Cortex-A55 cores | About 1 GB of 1.9 GB | Android 14, no root | Qwen3.5-2B at 7.7 tok/s | Ling-mini-2.0 at 5.1 tok/s |
| iPad Air (2013) | Apple A7, 2 cores | About 700 MB of 1 GB | iOS 12.5.7, jailbroken | Bonsai-1.7B (1 bit) at 24 to 26 tok/s | Ling-mini-2.0 at 2.6 to 4.5 tok/s |
The range on those two devices runs from stories260K, a 260K parameter model that writes short stories at about 650 tok/s on the TV box, up to the 16.3B Ling-mini-2.0. A third device, a OnePlus Nord CE 2 phone from 2022 with about 3 GB of free memory, plays in a bigger league, up to an 80B model. Its results are covered in the choice section below.
How it works
Experts live on flash, not in RAM
A mixture of experts model holds many expert networks per layer and uses only a few of them for each token. Ling-mini-2.0 has 256 experts per layer at about 1 MB each, and a token on the TV box uses 8 of them. Most of the model is idle at any given moment, which makes it a poor fit for RAM and a good fit for flash.
The pager keeps a pool of experts in RAM, 43 per layer for Ling-mini-2.0 on the TV box, reads the missing ones from flash when the router asks for them, and prefetches the experts the next layer is likely to pick. A small bonus for experts already in RAM cut misses from 13 percent to about 2 percent, at a quality cost the notebook measures rather than hides.
Dense models get a streaming engine instead. It reads their weights ahead of the work at the full speed of the flash, 278 MB/s on the TV box, and frees each block right after use. A model that pulls a lot of weight bytes per token cannot outrun the flash it pulls them from.
Kernels written for weak cores
The TV box runs on Cortex-A55 cores and the iPad on an Apple A7 with no dot product instructions, so the patch carries kernels shaped for each chip: a 1 bit lookup table kernel, repacked 2 bit and ternary formats, and ports of the same ideas to the older instruction set on the A7.
The iPad history for Bonsai-1.7B shows what that work is worth. The same model file ran at 2.75 tok/s on stock llama.cpp. A kernel that needs no multiplication, because 1 bit weights are only plus or minus one, took it to 3.45, and the lookup table kernel took it to about 11. The largest single step came from a discovery: the output head, with 151,669 rows, had never reached the fast kernel because its row count is not a multiple of 32, and it was spending 45 of every 72 ms per token on the slow path. With the head fixed, the model reached 23.7 to 25.8 tok/s.
Less model to keep in RAM
Small models spend a surprising share of their size on vocabulary. The patch prunes the output head down to the rows real text actually uses, between about 49K and 66K rows, chosen by token frequency across English, code and seven other languages. The saving is 0.2 to 0.5 GB per model. The cost is that about 1 percent of English tokens fall outside the kept rows and can never be produced.
That pruning is why the files are tied to the patch. Stock llama.cpp cannot load the pruned heads. The iPad mixture of experts files are stranger still: the project notes that another build will load them and produce scrambled experts, which is worse than a clean refusal.
On the TV box, a mode called headless stops the launcher and Google services while a model runs. Free RAM rises from about 1,000 MB to about 1,300 MB, the difference between Bonsai-8B sitting fully in RAM and spilling to flash.
The speeds, and what they cost
All of these figures are the project measurements, taken on the devices through chat requests, and the repo warns that the TV box drifts by about 10 percent over a day. Read them as a careful record from the project, not as lab results from this magazine.
| Model | TV box | iPad Air |
|---|---|---|
| Ling-mini-2.0, 16.3B mixture of experts | 5.1 tok/s | 2.6 tok/s at full quality, up to about 4.5 with routing bias |
| Moon-Beam-8B-A1B, 8B mixture of experts | 7.2 tok/s | About 3.5 tok/s |
| Bonsai-8B, 1 bit dense | 5.2 tok/s | 0.08 tok/s |
| Qwen3.5-9B, dense | 0.27 tok/s | Not in the iPad results |
The pattern in that table is the lesson of the project. Mixture of experts models run at usable speeds because each token touches a small part of the weights. A dense model that streams from flash crawls, and on the iPad the dense Bonsai-8B is more than forty times slower than its mixture of experts rival.
Speed past a point is bought with quality, and the notebook prices each dial. On the iPad, a routing bias of 0.1 lifts Ling-mini-2.0 from 2.6 to 3.3 tok/s at a cost of 2.6 percent in perplexity, the project measure of how well a model predicts a fixed text. Running Moon-Beam-8B-A1B with 4 experts per token instead of 8 reaches about 5 tok/s on the iPad and costs 27 percent.
Long answers exposed a failure that perplexity could not see. The 2 bit experts scored fine one token at a time and still fell into loops after about 250 to 300 words, in 12 of 13 long answers in one project test. A repeat penalty of 1.15 over 256 tokens brought that down to 1 in 13.
Bigger is not better here either. Ling-mini-2.0 is twice the size of Moon-Beam-8B-A1B, runs slower than it on the TV box, and scores worse per byte on both devices. The 16B result proves what the pager can carry. The 8B model is the better machine.
Where it falls short
The everyday models are small models, with small model judgement. The iPad notes record Bonsai getting plain facts wrong, including calling Mercury the closest planet to Earth in one test, even while answering the project three question test well and writing correct code.
The iPad route is fragile in ways the repo lists without flinching. A process has to stay under about 700 MB or iOS starts killing things. Setting the expert pool to 16 caused a kernel panic and a reboot during the project work. The jailbreak does not survive a reboot, and the iOS memory watchdog resets even the 4B chat server within minutes, so the model the project serves from the iPad is the 1.7B.
And there is no product polish anywhere in this, by design. You chat in a terminal or in a plain web page the device serves itself. Setup is scripts, cables and patience.
What Works
- A 16.3B model runs at a usable 5.1 tok/s on a TV box with about 1 GB of usable RAM
- Every figure was measured on the device itself, with raw logs and failures kept in the notebook
- Free and open source under the MIT License, with model files and rebuild scripts published
- The techniques travel beyond one box, as the phone results with 35B and 80B models show
What Does Not
- Model files need the patched build, and stock llama.cpp cannot load the pruned heads
- The fastest settings for the biggest models carry quality costs measured in perplexity
- Dense models bigger than RAM crawl, at 0.27 tok/s for a 9B model on the TV box
- The iPad route needs a jailbreak that does not survive a reboot, on a device that kills processes past about 700 MB
Which should you choose
Choose the TV box route if you have a cheap Android box in a drawer. It is the least fragile path in the repo, it needs no root, and it gives you two sensible models: Qwen3.5-2B at 7.7 tok/s for daily use, and Ling-mini-2.0 when you want to watch a 16B model work on hardware that has no business running one.
Choose the iPad route if the 2013 tablet is the device you have and you accept the jailbreak terms. Bonsai-1.7B at 24 to 26 tok/s is the fastest everyday chat on any 1 GB device in the project results, and it is not close.
Choose the phone route if your hardware has more memory. On the project phone, a OnePlus Nord CE 2 from 2022 with about 3 GB free, Qwen3.6-35B-A3B runs at 4.9 to 5.7 tok/s and Qwen3-Next-80B-A3B at 2.6 to 3.1 tok/s. The phone model files are standard GGUF files that load in any build, though the speeds need the pager from the patch.
Look elsewhere if you want local models on a machine with real memory. On a modern laptop, stock llama.cpp and a normal model file will be faster, simpler and better, and our coverage of Local Code on the Mac covers that end of the scale.
Final thoughts
The models in this story will be replaced within months. The durable part of smolmaxxing is the record: 165 experiments, each one measured on the device it claims to describe, with the loops, panics and wrong turns kept in the same file as the wins.
It also leaves a useful correction to the way small hardware gets discussed. Past a certain size, the ceiling for a model is not its parameter count. It is the bytes that must stay resident, the speed of the flash behind them, and how much of the model each token truly needs. A TV box cannot run a 16B model, until somebody counts those three things carefully enough. Then it can.
Sources
- Overview, device table, techniques and license: smolmaxxing repository, hyperionaidev on GitHub
- TV box results, limits and scoreboard: Device 1, Xiaomi TV Box S (3rd Gen), smolmaxxing docs
- iPad results, setup and failure notes: Device 2, iPad Air (2013), smolmaxxing docs
- Kernels, memory savings, expert pager and streaming: How it works, smolmaxxing docs
- Model downloads, file sizes and rebuild targets: Models, smolmaxxing docs
- Lessons, including what did not work: Lessons, smolmaxxing docs
- The full experiment record: EXPERIMENT.md, smolmaxxing repository
- Screenshots of the token stream page: smolmaxxing project
- Hero illustration: Dirty Static, generated in house style
END OF TRANSMISSION
Stay curious. Question everything.


