AltSql is a project to build a very small database engine for connected devices. A sensor keeps its readings and settings in its own flash memory, reads them back to decide on the spot, and sends only what matters. Its gateway keeps the very same records, byte for byte, and answers questions about them in SQL.

The engine works today in simulation. It is one C file, tested through hundreds of thousands of simulated power cuts, and a live demo runs it in your browser. The next step is real chips.

Why Put a Database on the Sensor

A device that can read its own records doesn’t have to wait for a server to tell it what to do. The whole project rests on that idea, and it pays off in four ways. More autonomy: devices keep working and deciding when the connection drops. Less bandwidth: results and alerts go upstream instead of every raw reading. Local decisions: devices act on their own data, with no round trip to the cloud. No translator: one format and one sync protocol run from sensor to cloud.

Before: the device keeps readings in its own key-value store and sends messages to a converter that reshapes them for a SQL database with a different format. After: the device runs the small AltSql build and the same records go byte for byte to the gateway, which answers SQL over them.

Today a device and its gateway usually keep data in two different formats. Converter code sits between them, and somebody has to write it for every product and keep it working for the ten or more years the device stays in service. AltSql keeps one format on both sides, so there is nothing to convert. How it works

What the Alpha Has Shown So Far

The sensor build takes about 15 KB of code on a Cortex-M4, with key-value, time-series and sync. The three demo devices use 672 to 1,048 bytes of engine RAM, plus up to 1.4 KB of stack. In one test run the power was cut 400,000 times, and after each cut everything reported as saved was still there. In the demo, the devices sent 26 to 76 times less data over their weak links than sending every record would take.

All of this was measured on a PC, with flash chips and radio links simulated. The engine compiles for four microcontroller families but has not run on one yet. That is what the Beta is for. The Alpha in detail

Where the Project Stands

The Alpha is done: a working engine in one C file, tested hard in simulation, with a demo of three devices in three industries. The Beta comes next: the same engine on real boards from five chip families, 10,000 real power cuts per board, and three devices running for a week. After it, the Advanced Beta adds the Learned Query Optimizer, and v1.0 freezes the on-flash format and the API. See the roadmap

Try It in Your Browser

The live demo runs the real Alpha engine inside your browser. Three simulated devices go through an hour, two days and a month of readings in under a minute, each deciding for itself and syncing to its gateway. Pull the plug whenever you like: the device loses power in the middle of a write, reboots, checks every record it had saved and carries on. It is open to everyone, with no sign-up and nothing to install. Open the live demo

Recent Pages

About

AltSql is a project at an early stage. Its engine works in simulation, a live demo runs it in your browser, and the next step is to prove it on real chips. This site shows where the project stands, gaps included.

Why the Project Exists

A connected product usually has two computers that handle its data. One is the device: a microcontroller with kilobytes of RAM and flash memory that wears with every erase, where power can vanish mid-write. The other is a gateway that gathers data from many devices and passes it on, often to a cloud.

Contact

The project would like to hear from:

Device makers who would like to try the Beta on their own hardware, or run a pilot after it.
Engineers with a chip, a flash part or an industry the project should test.
Anyone with a question about the engine, the demo or the figures on this site.

Write to info@altsql.com.

If you are writing about a device, it helps to mention its chip, how much flash and RAM it has, how it connects (Wi-Fi, cellular, LoRaWAN or something else), how often it measures, and what it should decide on its own.

The idea. Put a very small database on the device that reads the sensors, and store its data so that the gateway’s database can use it as it is, byte for byte, with no translation step.

Before and After

Today a device and its gateway keep data in two different formats. A converter has to sit between them and turn the device’s key-value data into rows for the gateway’s SQL database. AltSql uses one format on both sides and takes the converter out:

Live Demo

Three simulated devices run the real AltSql Alpha engine right here in your browser. Each one keeps its own records and decides for itself. Only what matters goes to its gateway, where the same records arrive byte for byte. The demo is open to everyone: there is no sign-up, nothing to install, and nothing you do here leaves this page.

Simulated devices, real Alpha engine. The sensors, networks and flash chips are simulated. The database is the Alpha engine itself, compiled to WebAssembly.

Roadmap

The Alpha proves the design in simulation. What comes next takes the same engine onto real chips, then toward a first release, and later adds a learned layer that lets each device adapt to its situation. Durations are estimates, and hardware surprises could stretch them.

Two lanes. The engine: Alpha, done; Beta, next, about 16 weeks on real chips; toward v1.0, 6 to 9 months of product work (estimate); v1.0, the first release with format and API frozen. The Learned Query Optimizer: concept tested during the Alpha; waits for the Beta; phases 1 and 2 over 5 to 7 months; phases 3 and 4 after that.

The Alpha

The Alpha is the working prototype of the AltSql engine: one C file, its tests, a few tools and a demo that runs one engine on three simulated devices. It stores key-value pairs and time-series readings in flash on a microcontroller, answers SQL on a gateway, and copies records from device to gateway byte for byte.

Everything so far runs on a PC. The flash chips and radio links are simulated, carefully, but simulated. The code also compiles for four microcontroller families and its size was measured on each, but it has not yet run on any of them. That is the job of the Beta.

The Learned Query Optimizer

Status: planned for the Advanced Beta.

The Alpha answers every query the same way, whatever state the device is in. A device in the field is rarely in the same state twice: its battery runs down, its link comes and goes, its flash fills and wears, and its data turns from routine to alarming. The Learned Query Optimizer (LQO) is a planned, optional layer that lets AltSql take its situation into account.

AltSql

A tiny database for sensors: key-value and time-series on the device, SQL on the gateway, and the same records on both, copied byte for byte.