2026

Continuous glucose monitoring on a $4 microcontroller.

A linear-attention sequence model, an autograd engine, a multi-threaded trainer, and an on-device inference kernel. Written from scratch in 5,500 lines of C++17 and shipped to an ESP32-S3.

1. Abstract

A recent linear-attention architecture, reimplemented from scratch in pure C++ with its own autograd engine, trained on real clinical data, and run on a $4 microcontroller to predict hypoglycemia 60 minutes ahead. Everything is built from the C++17 standard library: no PyTorch, TensorFlow, Eigen, BLAS, OpenMP or NumPy. The shipped FP32 inference kernel runs on an ESP32-S3 in 20% of its RAM and agrees with the FP64 training reference.

Two linear-recurrent backbones are compared. S4D (diagonal structured state-space, Gu et al. 2022) fits slow, long-range glucose dynamics at tiny parameter count. OSDN (online spectral delta network, arXiv:2605.13473, May 2026) is a recent DeltaNet-family variant that should be faster in principle, reproduced from the paper's math.

The novelty is the path, not the architectures: the first pure-C++ stdlib reproduction of a DeltaNet-family model, the first end-to-end training of either model through a hand-rolled scalar autograd, and the first bit-equivalent port of either to a $4 microcontroller, gated by make check.

~5,500 lines of pure C++17. Autograd engine, optimizer, trainer, data pipeline, two models, on-disk weight format, embedded inference kernel, triple-redundant correctness proof.
S4D reaches 0.9113 test AUROC on held-out patients; OSDN reaches 0.7669.
Footprint on the $4 ESP32-S3: 20.1% RAM (65,964 B) and 8.4% Flash (281,161 B).
FP32 device kernel agrees with the FP64 trainer to 7.97 × 10⁻⁷, held bit-for-bit by make check.
Raises a hypoglycemia alarm 60 minutes ahead of onset, on the sensor itself: no phone, no cloud, no network.

Figure 1. The project in 90 seconds: the trained model on an ESP32-S3, raising a hypoglycemia alarm from live glucose input over serial.

2. Introduction

Closed-loop insulin systems live or die by the latency and reliability of their glucose forecast. That forecast usually lives on a phone or in the cloud, adding round-trip latency and a failure surface for someone whose blood sugar is dropping.

Dead phone, lost network, cloud outage. Each one breaks the alarm path. Moving the model onto the sensor removes that surface.
$4 of silicon is the price ceiling that lets safer continuous monitoring reach more people.
The open question: can a model small enough for a $4 microcontroller, written without a modern ML stack, still match full-fat baselines?

2.1 Why a linear-attention sequence model

Both architectures keep a fixed-size recurrent state that absorbs the whole window, so inference cost is constant in window length. A transformer at the same accuracy would not fit on an ESP32-S3; a linear-attention model can.

S4D unrolls a continuous-time state-space model with complex poles learned per channel. The diagonal structure keeps parameters tiny (562 shipped); the complex arithmetic captures circadian rhythm and post-meal spike-and-decay. Glucose is exactly the long-horizon, low-dimensional, slowly varying regime it was built for.
OSDN replaces the state-space layer with an online delta rule: a learned associative memory whose write step is preconditioned by a closed-form spectral update. Its forward pass is real-valued, sidestepping the complex-arithmetic overhead behind S4D's parameter cost. Published in May 2026 with no independent implementation, it was the obvious second backbone to stress-test the pipeline.

2.2 What is actually new

The two architectures are existing math. The novelty is the build, and three findings fall out of it.

Pure C++17 stdlib, end to end. The autograd engine, trainer, and OSDN forward / backward are written from primitives, with nothing imported at any point.
First DeltaNet-family reproduction outside the OSDN authors' codebase. Implementing the §4.2 d-update faithfully exposed a deployment-breaking omission in the paper's pseudocode (§3.2).
First bit-equivalent port to a $4 microcontroller. One C++ header runs on host and device, proven in §3.5. The hardware path is part of the build's contract, not bolted on at the end.

Every layer below is something most stacks would simply import.

3. System

3.1 The math engine

A scalar reverse-mode automatic differentiation engine (src/value.{hpp,cpp}, 268 lines). Every arithmetic operation is a heap node recording a closure that pushes gradients backward.

backward() runs an explicit-stack topological traversal. Plain recursion overflows the stack on a 144-step graph.
Extended to complex numbers (src/complex_value.{hpp,cpp}) so S4D's complex hidden state backpropagates through the same engine. In a normal stack this is torch.autograd.
Verified by a finite-difference gradient checker (src/grad_check.cpp, 284 lines): 12 primitives across 61 test points, with analytical fallbacks at singularities.

3.2 The models

S4D (src/s4d.{hpp,cpp}, 108 lines): a diagonal state-space layer with complex poles and hybrid ZOH / Euler discretization, backpropagating through the complex-value engine.
OSDN (src/osdn.{hpp,cpp}, 218 lines), built directly from the §4.2 online-preconditioned delta rule in arXiv:2605.13473.

An implementation finding. The paper's §4.2 Equation (4) includes a box-projection on the preconditioner, d ← clamp(d, 0.5, 2.0); Algorithm 1 omits it "for clarity." Implement the pseudocode as written and FP32 inference silently produces NaN on trained weights, because the preconditioner drifts out of its stable band. The clamp costs roughly 0.07 test AUROC versus an unclamped run, yet it is the only configuration that survives float32 on the device. The deployable number is the one reported here.

Both models share the wrapper network, 7-channel input, trainer, patient-disjoint split, and threshold methodology, so any comparison measures the recurrent backbone, not scaffolding.

3.3 The training infrastructure

A hand-built fork-join thread pool on raw std::thread, std::mutex, and std::condition_variable (src/cgm_train.cpp, roughly 997 lines) drives synchronous data-parallel training.

Each worker holds its own network replica and parameter nodes; batches are round-robin sharded.
Per-worker gradients are summed into the master before each Adam step: PyTorch's DataParallel, written by hand because scalar-Value parameter nodes cannot be shared across threads.
Adam with NaN-gradient rejection. Skips the update rather than poisoning the moment estimates, which never recover from a non-finite value.
Hardened JSON resume parser. A stateful character scanner replacing a brittle reader that threw out of main() on malformed input.

3.4 The data

Ohio T1DM (obtained under a data-use agreement), parsed and windowed from scratch (src/cgm_data.cpp, 373 lines). Seven channels per window: glucose, its first and second differences, sine and cosine of time-of-day, insulin-on-board, and carbs-on-board (both with exponential-decay pharmacokinetics).

Seven input channels stacked over a 12-hour window: glucose, first and second glucose differences, sine and cosine of time-of-day, insulin-on-board, and carbs-on-board. — Figure 2. What the model sees: seven channels of physiology and pharmacokinetics per window, built from raw CSV without pandas or scikit-learn.

Patient-disjoint splits verified twice.
Normalization computed on the training fold only.
Classification threshold selected on validation at a fixed specificity, then frozen for test, so test labels never enter model selection.
Every column is a hand-managed vector.

3.5 Paper to silicon, proven

A header-only FP32 inference kernel (src/osdn_inference.h, 297 lines): allocation-free, stack-only, and the same physical file compiled into both the host test and the firmware. Three independent implementations of the OSDN math (the training autograd, an independently written reference network, and the FP32 kernel) agree at |diff| = 7.96795993 × 10⁻⁷, held bit for bit through the entire hardening sequence by make check.

The ESP32-S3 firmware (roughly 716 lines) is a complete on-device alarm.

Serial protocol for glucose, bolus, and meal events.
On-device feature recomputation matching the trainer byte for byte, tested by compiling the production code into a host binary against a double-precision reference (src/features_host_test.cpp, maximum difference 4.8 × 10⁻⁷).
Fail-open clinical alarm. A non-finite logit raises the alarm rather than silently passing, because "I don't know" must surface on a medical predictor.

Horizontal bar chart of ESP32-S3 footprint: RAM 20.1% used (65,964 of 327,680 bytes), Flash 8.4% used (281,161 of 3,342,336 bytes). — Figure 3. Footprint on a $4 ESP32-S3-DevKitC-1. RAM 20.1%, Flash 8.4%.

4. Evaluation

Patient-disjoint Ohio T1DM. Validation = {584, 588}, test = {591, 596}. 8 train, 2 validation, 2 test. Identical wrapper across both architectures: 7-channel input, H = 16, lookback = 144 (~12 hours), horizon = 12 (~60 minutes ahead), stride = 12, seed = 42.

Bar chart comparing S4D and OSDN on validation AUROC, test AUROC, recall at specificity 0.80, and milliseconds per window. — Figure 4. S4D versus OSDN on the held-out test split. Only the recurrent backbone differs.

Architecture	Params	Val AUROC	Test AUROC	Recall @ spec 0.80	ms / window
S4D	562	0.9510	0.9113	0.918	189.8
OSDN	747	0.9220	0.7669	0.718	236.4

S4D scores higher on test AUROC (0.9113 vs 0.7669), recall (0.918 vs 0.718), and post-bolus recall (0.919 vs 0.676), at roughly matched specificity (0.67 vs 0.68) and lower per-window inference cost.

FP32 device kernel agreement with the FP64 host autograd: |diff| = 7.97 × 10⁻⁷ (tolerance 1 × 10⁻⁴; agreement within float rounding, reported to 8 digits for drift detection, not a deterministic byte match). With n = 2 test patients, absolute AUROC is high-variance: read the validation-to-test gaps, not the point estimates.

5. Conclusion and Implications

A glucose forecaster that runs on the sensor itself removes a whole class of failure modes from closed-loop insulin delivery: dead phones, lost networks, cloud outages. The math says it is achievable at $4 of silicon. Cheaper to ship means safer continuous monitoring can reach more people, and "more people" is the part of the healthcare story that gets harder, not easier, with cloud-dependent designs.

5.1 Limitations and future work

n = 2 test patients on a custom split. AUROC is high-variance and not comparable to the canonical Marling and Bunescu BGLP leaderboard; trust the validation-to-test gap (OSDN 15.5 pp, S4D 4.0 pp). Next: leave-one-patient-out cross-validation across all 12 patients.
Single seed (42), global normalization. Next: multi-seed runs for a variance bound, and per-patient normalization to test how much of the gap is distribution shift between individuals.
Protocol shortcuts. Validation is reused for early stopping and threshold selection; AUROC is rank-based without tie-handling (auroc_approx); window stride is 12, not 1.
"From the paper" covers the OSDN d-update kernel only. The wrapper (per-row sigmoid(log_lambda) decay, LayerNorm on the K-readout, per-channel residual, tanh input embedding) is not vanilla OSDN and is identical across both runs. S4D's 14-point lead is a direct report, not a state-of-the-art claim.
Narrow kernel envelope, no hardware replay yet. n_layers >= 2 with K = 16 produces NaN in FP32; the shipped n_layers=1, K=8 sits inside the verified envelope. Next: replay a held-out patient's trace into the ESP32-S3 over serial and confirm the on-chip alarm fires against host expectations.

6. Acknowledgments

Thanks to Cindy Marling and Razvan Bunescu (Ohio University) for the OhioT1DM dataset, obtained under a data-use agreement. The OSDN formulation is from arXiv:2605.13473.

@inproceedings{marling2020ohiot1dm,
  title     = {The OhioT1DM dataset for blood glucose level prediction: Update 2020},
  author    = {Marling, Cindy and Bunescu, Razvan},
  booktitle = {The 6th International Workshop on Knowledge Discovery from Healthcare Data (KDH)},
  year      = {2020},
  url       = {https://pmc.ncbi.nlm.nih.gov/articles/PMC7881904}
}