I ran MNIST digit recognition on an ESP32-C3 — without TensorFlow, TFLite, or any ML runtime.
The neural network is compiled directly into a C header and executed as firmware.
From Perceptrons to a Cross-Platform NN CLI for Edge Inference
It started, like many questionable engineering projects, with curiosity about a perceptron.
I wasn’t trying to build anything serious. Just a small experiment to understand how far I could push a minimal neural network implementation without relying on any framework.
That experiment didn’t stay small for long.
Once the basic forward/backward pass worked, I started wondering whether the same approach could be useful outside of toy problems. Specifically, I had recently built a ratiometric thermometer system, and it quickly became clear that the analog measurements were noisy and sensitive to supply variation.
That’s where the idea clicked: instead of fitting everything with fixed equations, what if I used a lightweight neural network as an inference layer for correction?
Not training in the field — just inference on constrained hardware.
Building a Minimal Neural Network Toolchain
That idea turned into a CLI tool, not a library. Not a framework. A command-line tool.
The goal was simple:
- Define a network architecture
- Train it on a dataset
- Export a standalone model
- Run inference anywhere
No heavy dependencies. No runtime frameworks required on the target side, just portable inference.
Over time, this evolved into a cross-platform tool supporting Linux, macOS, and Windows, with a fully deterministic inference pipeline.
The Unexpected Benchmark: MNIST
At some point I needed a sanity check, so I ran MNIST through it.
~59,999 training samples~1,000 test samples
Nothing exotic — just a standard benchmark to validate the pipeline end-to-end.
The interesting part wasn’t accuracy. It was stability.
Training, export, and inference all behaved consistently across platforms. No drift between environments, no dependency on external runtimes, and no hidden assumptions about floating-point behavior beyond what was explicitly defined.
For a homegrown stack, that was the real milestone.
Why This Matters for Edge Systems
The original motivation was never image classification, it was edge inference under constraints:
- limited memory
- limited compute
- unstable or variable power conditions
- need for deterministic behavior
In that context, most modern ML stacks are overkill. Even lightweight frameworks often assume too much infrastructure.
So the focus shifted toward something more specific:
A minimal neural network runtime that could be compiled down and deployed without dependencies.
What the Tool Actually Is
Today, the project is essentially three things:
A minimal neural network training engine
A model exporter that produces standalone inference graphs
A CLI runtime for cross-platform execution
It is not meant to compete with full frameworks.
It is meant to answer a narrower question:
How small can a usable neural inference stack get while remaining practical?
Repo
https://github.com/AlexRosito67/hasaki-mnist-esp32
Want to train your own models?
Let your creativity flow and make your own projects.
Final thought
This started as an experiment to understand perceptrons and a thermometer, it ended as a small toolchain for compiling neural networks into embedded firmware.
And I'm still not entirely sure where the boundary between "software" and "firmware" is anymore.
