We Stopped Estimating Our Own Footprint and Compiled It Instead
Every edge AI vendor quotes a model size. Almost nobody compiles the thing and measures the binary. We did — and found our own numbers were wrong in both directions.
The number everyone quotes, and nobody checks
Ask any edge AI platform how big its models are and you will get a confident figure in kilobytes. Ask how that figure was obtained and the answer is almost always the same: parameter count multiplied by bytes per parameter, plus an allowance for the runtime.
It is a reasonable approximation. It is also, as we discovered in our own codebase, capable of being wrong by a factor of four.
Two errors pointing opposite ways
We had two independent footprint estimators, written at different times for different purposes. Both were wrong.
The first overstated flash by roughly 4x. It counted the generated C source text as if it were firmware — but the source stores each weight as a decimal literal, seven or so characters for a two-byte value. The weights were being counted twice, once as bytes and once as the text describing those bytes. A model that really occupies 6.3 KB was reported as 23.9 KB.
The second understated flash by 19-62%. It assumed one byte per parameter. Our arithmetic is 8-bit, so this seemed right, but the arithmetic width and the storage width are different things: the exported code stores weights as 16-bit integers. The real cost lands between one and two bytes per parameter, because part of the model is bit-packed.
The published figures on this site came from the second estimator. They were too optimistic. We have corrected them.
What the compiler actually says
We took the exported C for a bearing-fault detection model, compiled it for two real targets, and measured the binary sections. No estimates, no extrapolation — the number the linker reports.
| Target | Flash | RAM |
|---|---|---|
| ARM Cortex-M0+ (thumbv6m) | 6.3 KB | 65 bytes |
| RISC-V RV32EC | 7.3 KB | 65 bytes |
Sixty-five bytes of RAM. Not kilobytes.
The generated code contains no floating-point arithmetic and depends on no math library — the only external symbols are integer division and a memory clear, a few hundred bytes from the compiler support library.
What that buys you in silicon
A footprint like this changes which chip you can specify, and chip choice is where bill-of-materials cost actually lives.
| Chip | Flash / RAM | Unit cost | Fits? |
|---|---|---|---|
| CH32V003 (RISC-V) | 16 KB / 2 KB | ~EUR 0.12 | Yes, 8.6 KB spare |
| STM32C0 (Cortex-M0+) | 32 KB / 6 KB | ~EUR 0.45 | Yes, 5x margin |
| ESP32-S3 | 8 MB / 512 KB | ~EUR 3.00 | Vastly oversized |
Across five hundred nodes, the difference between a three-euro module and a twelve-cent one is fifteen hundred euros versus one hundred and eighty.
The accuracy behind the number
A small model is worthless if it does not work. This one was evaluated on the CWRU bearing dataset using a cross-load split: trained on motors under 0-1 HP load, tested on 2-3 HP — operating conditions the model never saw during training. This matters, because a random split lets windows from the same recording appear in both sets and inflates the result.
Over five independent runs: 99.69% accuracy, standard deviation 0.07%. A slightly larger configuration reached 99.80%, still in 10 KB.
The part we will not overclaim
This result is specific to bearing fault detection. We ran the same downsizing on two other benchmarks to see whether it generalised, and it does not.
On human activity recognition the small model matched its larger sibling within noise, at a third of the footprint — a clear win. But on NASA turbofan remaining-useful-life prediction, the larger configuration beat the small one by 8.3 percentage points. There, the capacity is genuinely needed.
So the honest claim is not “our models run in 10 KB.” It is: for bearing fault detection, verified by compilation, 99.8% accuracy fits in 10 KB of flash and 65 bytes of RAM on a sub-euro microcontroller. Model size is a per-task decision, and pretending otherwise would just be a different estimate dressed up as a fact.
Why publish a correction
We could have quietly fixed the formula. But a footprint figure is a procurement input — someone selects a chip based on it, orders ten thousand units, and discovers the truth at flash time. That is an expensive way to learn that a vendor was rounding in its own favour.
The numbers on our benchmarks page now come from compiled binaries. Where we have not compiled, we say so.
Talk to us about a pilot if you want these measured on your own data and your own target.