Connected products, without the complexity
Simple IoT lets you add remote sensor data, telemetry, configuration, and device management to your product. One binary runs in the cloud and on your edge devices, keeping configuration, state, and history synchronized in both directions, even over slow or intermittent connections.
A complete platform in a single binary.
Simple IoT grew out of shipping real connected products. Everything below is included in one self-contained application with no external dependencies, so a single engineer can build and deploy a custom IoT system.
Data that flows both ways
Configuration and state can change at the edge or in the cloud. Simple IoT merges the changes efficiently and keeps every instance in agreement, so you are never reconciling two sources of truth by hand.
A user facing portal
A web UI for viewing live values and editing configuration, with users, groups, and permissions built in. Give customers access to their own devices without building a portal from scratch.
Rules and notifications
A rules engine runs on every instance, in the cloud or on the gateway. Trigger notifications through Twilio or email, or write points back into the system to control equipment.
Industrial protocols included
Modbus client and server, CAN bus, 1-Wire, GPS, USB and serial devices, Particle.io, and Shelly. Connect to the hardware already in the field instead of writing another integration layer.
Extend it in any language
Every instance speaks NATS. Add a Python script, a C++ machine learning process, or a Go service alongside Simple IoT and give it full access to configuration and state.
Storage built in, no database to run
Instances, users, groups, rules, and configuration live in a flexible graph, persisted by the NATS JetStream server embedded in the same binary. Forward history to VictoriaMetrics or InfluxDB when you want long term trends and dashboards.
Most IoT projects take longer than they should.
The fundamental problem is moving data from remote locations to a place where people can use it, and moving configuration back the other way in real time. These are the constraints that shaped Simple IoT.
Changes happen everywhere
A technician edits settings on a local display, a customer changes them in the browser, and a rule changes them again at 3 a.m. All of it has to converge on the same answer.
Connectivity is not a given
Cat-M modems give you well under 100 Kb/sec, and coverage comes and goes. Devices need to keep working while offline and catch up when the link returns.
Two codebases, two mental models
Writing separate cloud and edge applications doubles the work and the bugs. Running the same application in both places removes an entire class of problems.
Operations should be a small job
A 10 to 1000 device system does not need twenty microservices. One binary on one server that you can rebuild quickly is often more reliable and far less work.
Off the shelf platforms pull in two directions
Device clouds handle connectivity but leave the customer portal to you. Hyperscaler IoT stacks handle scale you may never need, at a cost in moving parts.
Custom systems deserve real tools
There is lasting value in programming a system rather than assembling it from drag and drop blocks. That works best when the building blocks are simple and open.
Six ideas that make the rest simple.
Building Simple IoT has been a process of peeling layers off a fairly complex system. These are the ideas that survived, and together they make Simple IoT a distributed graph database tuned for IoT datasets.
One kind of data
Configuration and state are stored and synchronized the same way, so there is a single path for every change in the system.
Nodes and points
Everything is described with two simple types. Points carry the metadata needed to merge changes from any instance without conflict.
Organized as a graph
A node can belong to more than one parent, which maps cleanly onto real fleets, sites, customers, and permissions.
Everything flows through NATS
A message bus at the center means any process, in any language, can observe and change the system through one API. The same server stores the data, so points are never translated into a second data model.
The same application everywhere
Cloud, local server, or edge gateway all run the same binary, so logic can move to wherever it makes the most sense.
Sync comes for free
Connect an instance to an upstream and common data and history synchronizes automatically, at any number of levels.
Running in about a minute.
Simple IoT is a self contained binary with no dependencies. Download the release for your platform, run it, and open the UI in a browser. The machine you are reading this on is a fine place to start, as is a Raspberry Pi or any other embedded Linux board.
It runs on ARM, x86, and RISC-V Linux, along with macOS and Windows.
On Linux, siot install sets up a systemd service, and
siot update keeps it current.
# Download the release for your platform from
# https://github.com/simpleiot/simpleiot/releases
chmod +x simpleiot-vX.Y.Z-linux-x86_64
mv simpleiot-vX.Y.Z-linux-x86_64 siot
./siot
# Open http://localhost:8118 and log in with admin / admin.
# Run it as a systemd service (Linux):
sudo ./siot install
# Later, update in place:
siot update
Built for the long tail of IoT.
Simple IoT is aimed at systems in the 10 to 1000 device range where you run embedded Linux at the edge and have configuration and state worth synchronizing. Teams are using it for work like this today.
Irrigation monitoring
Pumps, valves, and tank levels spread across a property, reporting back over a modem and controllable from anywhere.
Building and alarm control
Schedules, setpoints, and alerts that keep working when the connection to the cloud drops.
Industrial vehicles and equipment
Commercial mowers, agricultural machinery, and other mobile assets that need telemetry and remote configuration.
Factory automation
Modbus and CAN devices on the plant floor, surfaced in one place with rules running locally.
Server monitoring
CPU, memory, disk, and network metrics for the cloud and edge machines in your system, with the same rules and notifications watching them as watch your devices.
A distributed config store
Run Simple IoT alongside an existing application purely for the synchronized state and configuration it provides over NATS.
Go packages for your own app
Use the Modbus, serial, and other packages on their own if that is all you need. See the package documentation.
Start building your system
Simple IoT is Apache 2.0 licensed and has been used on real products for several years. The documentation covers installation, the data model, the NATS API, and how to extend the system with your own clients.
Questions, ideas, or feedback?
We would like to hear from you, whether you are evaluating Simple IoT, already running it, or want to contribute. If you use the project, telling us about it genuinely helps.