<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
    <title>Simple IoT</title>
    <subtitle>Add remote sensor data, telemetry, configuration, and device management to your product. One application runs in the cloud and at the edge, synchronizing data in both directions.</subtitle>
    <link rel="self" type="application/atom+xml" href="https://simpleiot.org/atom.xml"/>
    <link rel="alternate" type="text/html" href="https://simpleiot.org"/>
    <generator uri="https://www.getzola.org/">Zola</generator>
    <updated>2026-11-05T00:00:00+00:00</updated>
    <id>https://simpleiot.org/atom.xml</id>
    <entry xml:lang="en">
        <title>Custom dashboard widgets from SVG files</title>
        <published>2026-11-05T00:00:00+00:00</published>
        <updated>2026-11-05T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/custom-widgets/"/>
        <id>https://simpleiot.org/blog/custom-widgets/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/custom-widgets/">&lt;p&gt;The &lt;a href=&quot;/blog/dashboards/&quot;&gt;dashboards&lt;/a&gt; introduced recently come with a set of
built-in components: gauges, switches, tanks, pumps, and so on. Simple IoT can
now also draw your own SVG files as dashboard widgets, so the graphics on a
dashboard can be whatever your equipment needs.&lt;/p&gt;
&lt;p&gt;The &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://youtu.be/nr9swaWLc68&quot;&gt;video demo&lt;/a&gt; starts with a blank system and
imports the custom widget demo from the source tree:&lt;/p&gt;
&lt;pre class=&quot;giallo&quot; style=&quot;color: #CDD6F4; background-color: #1E1E2E;&quot; &gt;&lt;code data-lang=&quot;shellscript&quot;&gt;&lt;span class=&quot;giallo-l&quot;&gt;&lt;span style=&quot;color: #89B4FA;font-style: italic;&quot;&gt;siot&lt;/span&gt;&lt;span style=&quot;color: #A6E3A1;&quot;&gt; import&lt;/span&gt;&lt;span style=&quot;color: #94E2D5;&quot;&gt; &amp;lt;&lt;/span&gt;&lt;span style=&quot;color: #A6E3A1;&quot;&gt; testdata/custom-widget-demo.yaml&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This adds a group of variables, signal generators, and dashboards. It also adds
a handful of file nodes, each holding an SVG drawing. Every widget on the demo
dashboard is drawn by one of those files.&lt;/p&gt;
&lt;h2 id=&quot;how-a-widget-binds-to-data&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#how-a-widget-binds-to-data&quot; aria-label=&quot;Permalink to this section&quot;&gt;How a widget binds to data&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;Setting one up takes two steps. Add a widget, pick the &lt;strong&gt;svg&lt;/strong&gt; component, and
point it at the file node that holds the drawing. You can view and edit the SVG
contents in the browser, or upload a new file.&lt;/p&gt;
&lt;p&gt;Inside the SVG, &lt;code&gt;data-siot-*&lt;/code&gt; attributes on elements declare what follows a node
value. The demo’s pump drawing declares two bindings, running and speed. When
you add the widget, SIOT lists every binding the drawing declares, and you bind
each one to a node. The pump’s running binding is bound to the same pump command
variable as the switches on the dashboard, so flipping a switch starts and stops
the pump graphic.&lt;/p&gt;
&lt;p&gt;There is not much more to it than that. The
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/user/dashboards.html#custom-drawings&quot;&gt;dashboards guide&lt;/a&gt;
lists the attributes: text with decimals and units, rotation for dials, level
for vessels, toggle and set for clickable controls, and ports so links on a
canvas can attach to the drawing.&lt;/p&gt;
&lt;h2 id=&quot;creating-a-new-widget-with-ai&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#creating-a-new-widget-with-ai&quot; aria-label=&quot;Permalink to this section&quot;&gt;Creating a new widget with AI&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;The SVG files are short and simple, but writing one by hand means working out
coordinates and element positions, which is tedious. The source tree includes
several Claude Code skills, and the &lt;code&gt;siot-build&lt;/code&gt; skill knows how to build
dashboards and widgets.&lt;/p&gt;
&lt;p&gt;In the video, I ask Claude to create a blank canvas dashboard named Rover, and
then to add a widget for an autonomous off-road rover with four-wheel drive,
turning wheels, and separate front and rear drive controls. A few minutes later
there is a rover on the dashboard.&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;https://simpleiot.org/images/blog/custom-widget-rover.png&quot; alt=&quot;A dashboard with a rover widget: front and rear drive switches on the left, a top-down drawing of a four-wheel rover with a speed readout and FRONT and REAR buttons in the middle, and a speed gauge on the right&quot; /&gt;&lt;/p&gt;
&lt;p&gt;The front and rear wheels can be started from the switches beside the widget, or
from the buttons drawn inside it. Stop the wheels, and the speed drops to zero
right away.&lt;/p&gt;
&lt;p&gt;The demos so far have been industrial control applications. This one is
different, perhaps monitoring an autonomous vehicle, and that is the point.
Simple IoT is for rich, real-time interaction with any kind of equipment, and
custom widgets let you draw graphics that clearly show what the equipment is
doing.&lt;/p&gt;
&lt;p&gt;Thoughts, questions, feedback,
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://community.tmpdir.org/c/simple-iot/5&quot;&gt;let me know&lt;/a&gt;.&lt;/p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Dashboards that sync like everything else</title>
        <published>2026-11-04T00:00:00+00:00</published>
        <updated>2026-11-04T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/dashboards/"/>
        <id>https://simpleiot.org/blog/dashboards/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/dashboards/">&lt;p&gt;Simple IoT now has dashboards. This continues the SIOT tradition of rich,
real-time interaction with remote devices and extends it from sensor data and
configuration to the dashboard and HMI views that operators actually look at.&lt;/p&gt;
&lt;p&gt;The &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://youtu.be/5WxccstXRwM&quot;&gt;video demo&lt;/a&gt; runs two instances, one local and
one on a cloud server, and starts by importing the demo data set from the source
tree:&lt;/p&gt;
&lt;pre class=&quot;giallo&quot; style=&quot;color: #CDD6F4; background-color: #1E1E2E;&quot; &gt;&lt;code data-lang=&quot;shellscript&quot;&gt;&lt;span class=&quot;giallo-l&quot;&gt;&lt;span style=&quot;color: #89B4FA;font-style: italic;&quot;&gt;siot&lt;/span&gt;&lt;span style=&quot;color: #A6E3A1;&quot;&gt; import&lt;/span&gt;&lt;span style=&quot;color: #94E2D5;&quot;&gt; &amp;lt;&lt;/span&gt;&lt;span style=&quot;color: #A6E3A1;&quot;&gt; testdata/dashboard-demo.yaml&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This adds a small water system: five dashboards, a couple of rules, some signal
generators to produce live data, and the variables the rules act on. The home
screen then shows an overview dashboard.&lt;/p&gt;
&lt;p&gt;There are two kinds of dashboards:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Grid:&lt;/strong&gt; widgets arranged in columns. On a narrow screen like a phone the
grid reflows to a single column.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Canvas:&lt;/strong&gt; a process mimic drawn on a fixed plane, with tank, pump, and valve
components and links between them.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The way I like to lay things out is to build smaller canvases and then arrange
them on a grid. A phone shows everything in a usable column, and a large screen
shows it all at once. The demo also includes a server dashboard that shows CPU,
memory, storage, and other host metrics.&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;https://simpleiot.org/images/blog/dashboard-overview.png&quot; alt=&quot;The demo’s Overview dashboard: a grid of four canvases for the supply pump, storage tank, heating loop, and alarms, each with switches, gauges, and process mimics&quot; /&gt;&lt;/p&gt;
&lt;p&gt;The web UI now has two views: the traditional node tree, and a Dashboards tab
that lists every dashboard you can reach. Set a home dashboard on your user
node, and that is what you see when you sign in.&lt;/p&gt;
&lt;h2 id=&quot;syncing-the-hmi&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#syncing-the-hmi&quot; aria-label=&quot;Permalink to this section&quot;&gt;Syncing the HMI&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;The interesting part comes when the local instance connects to the cloud. In the
demo, the local instance enrolls with the server using an enrollment token, the
server accepts it, and a minute later the two instances are connected. The demo
site now shows up on the server with the same tree, and the same dashboards.&lt;/p&gt;
&lt;p&gt;Make an operational change on the cloud, such as flipping a switch, and the
local instance reflects it right away. Make it locally, and the cloud follows.
This is the same real-time sync SIOT already does for data, now covering the HMI
as well.&lt;/p&gt;
&lt;p&gt;Layout syncs too. A typical scenario is configuring a system remotely while the
local UI needs to show the same thing. Put the dashboard in edit mode on the
server, move a widget and make it bigger, and the edge instance redraws it as
you drag. Edit on the edge, and the server follows.&lt;/p&gt;
&lt;p&gt;The reason this works is that dashboards and their widgets are just more nodes
and points in the tree, and SIOT is good at synchronizing trees. Look at the raw
data for a widget and you find a handful of properties: the node it is bound to,
the point it reads, its position, and a few options. There is no separate
dashboard database or layout file to keep in sync.&lt;/p&gt;
&lt;p&gt;Binding a widget to a different source is a matter of picking another node. In
the demo, the line pressure widget reads a random walk signal generator. Clear
that and type to search, and it can read the motor temperature instead.&lt;/p&gt;
&lt;p&gt;The &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/user/dashboards.html&quot;&gt;dashboards guide&lt;/a&gt;
covers building a dashboard, canvas layouts, controls, relative bindings for
mirroring one dashboard under many devices, nested dashboards, and kiosk mode.
We hope to do a lot more here.&lt;/p&gt;
&lt;p&gt;The widget design took inspiration from
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://github.com/joyautomation/nautilus&quot;&gt;Nautilus&lt;/a&gt;, Joy Automation’s
open-source toolkit for building control and supervisory systems in Go. Thanks
to that project for showing what a modern, code-first HMI can look like.&lt;/p&gt;
&lt;p&gt;Thoughts, questions, feedback,
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://community.tmpdir.org/c/simple-iot/5&quot;&gt;let me know&lt;/a&gt;.&lt;/p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Some dependencies make your life easier</title>
        <published>2026-11-03T00:00:00+00:00</published>
        <updated>2026-11-03T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/dependencies/"/>
        <id>https://simpleiot.org/blog/dependencies/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/dependencies/">&lt;p&gt;Some dependencies cause pain when updated, and others quietly improve a system.
I noticed this in the Simple IoT changelog after a recent Go dependency update.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Sync and the store recover more reliably from dropped connections.&lt;/strong&gt; The
NATS Go client 1.55.0 fixes deadlocks, leaks, and stalls in reconnect, drain,
and ordered consumers, so a device on a flaky link reconnects and resumes
cleanly.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Handling all the edge conditions of a flaky network link is indeed one of the
hard parts of IIoT systems, and it is nice when dependencies do some of this
work for us. The &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://nats.io/&quot;&gt;NATS.io&lt;/a&gt; dependencies in the Simple IoT
system are stable and are always improving. I’ve not encountered any problems
and update without hesitation when there are new versions available.&lt;/p&gt;
&lt;p&gt;Simple IoT stands on the shoulders of giants to provide a reliable real-time
system for device manufacturers who want rich, real-time interaction with remote
systems.&lt;/p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Scaling the UI to large data sets</title>
        <published>2026-10-30T00:00:00+00:00</published>
        <updated>2026-10-30T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/scaling-ui-large-data-sets/"/>
        <id>https://simpleiot.org/blog/scaling-ui-large-data-sets/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/scaling-ui-large-data-sets/">&lt;p&gt;How do you show thousands of devices in a browser without loading them all?
Pagination loads a page at a time as you scroll. Search loads only the matches.
Simple IoT takes a third approach and follows the structure of the data: the
system is a tree of nodes, so the UI loads a node when you expand it and watches
only the nodes on screen.&lt;/p&gt;
&lt;p&gt;The &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://youtu.be/nTNtVRTNRHQ&quot;&gt;video demo&lt;/a&gt; shows this with two browser
windows open on one instance. It starts by importing
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://github.com/simpleiot/simpleiot/blob/master/testdata/large-tree.yaml&quot;&gt;&lt;code&gt;large-tree.yaml&lt;/code&gt;&lt;/a&gt;,
a test data set of 1,457 nodes that reaches 50 levels deep:&lt;/p&gt;
&lt;pre class=&quot;giallo&quot; style=&quot;color: #CDD6F4; background-color: #1E1E2E;&quot; &gt;&lt;code data-lang=&quot;shellscript&quot;&gt;&lt;span class=&quot;giallo-l&quot;&gt;&lt;span style=&quot;color: #89B4FA;font-style: italic;&quot;&gt;siot&lt;/span&gt;&lt;span style=&quot;color: #A6E3A1;&quot;&gt; import&lt;/span&gt;&lt;span style=&quot;color: #94E2D5;&quot;&gt; &amp;lt;&lt;/span&gt;&lt;span style=&quot;color: #A6E3A1;&quot;&gt; testdata/large-tree.yaml&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The browser debugger in the right window shows the WebSocket messages arriving
over NATS. When we edit a node in the left window, here is what the right window
receives:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Node on screen:&lt;/strong&gt; a message arrives right away and the value updates.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Node collapsed or never expanded:&lt;/strong&gt; no messages arrive.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Node expanded again:&lt;/strong&gt; the UI fetches it and shows the latest value.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Interest drives the data flow. Expanding a node says you want to see it, so the
UI fetches that node’s children and subscribes to the nodes on screen.
Collapsing a node ends those subscriptions. The browser’s work follows what you
are viewing, so it stays small even as the tree grows.&lt;/p&gt;
&lt;p&gt;&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://nats.io/&quot;&gt;NATS&lt;/a&gt; subscriptions make this control simple. Each node has
its own subject, so the UI chooses what data it sees by subscribing to the
subjects for the nodes on screen, and the server sends nothing else.&lt;/p&gt;
&lt;p&gt;The tree does this work for us. Every SIOT system already has this structure, so
the UI needs no separate paging or caching scheme. The
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/ref/frontend.html&quot;&gt;frontend reference&lt;/a&gt; covers
the details.&lt;/p&gt;
&lt;p&gt;Thoughts, questions, feedback,
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://community.tmpdir.org/c/simple-iot/5&quot;&gt;let me know&lt;/a&gt;.&lt;/p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Rich, real-time interaction with remote devices</title>
        <published>2026-10-15T00:00:00+00:00</published>
        <updated>2026-10-15T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/rich-realtime-interaction/"/>
        <id>https://simpleiot.org/blog/rich-realtime-interaction/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/rich-realtime-interaction/">&lt;p&gt;While recording the
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://simpleiot.org/blog/realtime-edge-to-browser/&quot;&gt;last demo&lt;/a&gt;, I had an
insight:&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;em&gt;SIOT is for people who want rich, real-time interaction with remote
devices.&lt;/em&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;While we
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/ref/bandwidth.html#ideas&quot;&gt;have a path to fairly low&lt;/a&gt;
data usage, this is not the first priority. The first priority is that when we
see data in the portal, we know it is current. When we turn on a pump remotely,
it turns on instantly. When a condition happens that causes a rule to activate,
it happens immediately, not minutes later when the system gets around to running
that rule. These priorities drive the design and architecture of SIOT. I’ve
spent too much time with consumer IoT technologies watching spinners spin for
tens of seconds while waiting for my garage door to close, only to be told
“something went wrong.” SIOT is something different, designed for industrial
reliability and responsiveness. In that demo, a button press on a Raspberry Pi
travels to the cloud server, through a rule, and back to an LED in about 100 ms.&lt;/p&gt;
&lt;p&gt;This focus requires some tradeoffs. You probably can’t get this responsiveness
using lambda functions in a hyperscale serverless cloud system. You can’t easily
scale it to a bazillion devices, or implement it with a 2 MB/month device
bandwidth budget. But the goal we are working toward is to support thousands of
devices and hundreds of users in real time with a relatively modest cloud server
running SIOT.&lt;/p&gt;
&lt;p&gt;This is the vision. It’s not for everyone or everything, but if you want a great
user experience for a connected industrial product, SIOT may be the technology
for you.&lt;/p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Real-time edge-to-browser connectivity</title>
        <published>2026-10-13T00:00:00+00:00</published>
        <updated>2026-10-13T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/realtime-edge-to-browser/"/>
        <id>https://simpleiot.org/blog/realtime-edge-to-browser/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/realtime-edge-to-browser/">&lt;p&gt;Have you ever wanted to see the state of your remote devices in real time,
without lag, spinners, or stale check-ins? Simple IoT now has real-time
connectivity from edge to browser based on &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://nats.io/&quot;&gt;NATS&lt;/a&gt;, which is a
high-performance, lightweight, open-source messaging system. This allows for
rich, efficient interaction with remote devices, where remote state updates
instantly and configuration changes take effect right away.&lt;/p&gt;
&lt;p&gt;In the demo below, we have SIOT running on a Raspberry Pi 5 connected to another
SIOT instance running on a cloud server.&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;https://simpleiot.org/images/blog/realtime-edge-to-browser-setup.svg&quot; alt=&quot;Demo setup: a Raspberry Pi 5 with a push button and LED syncs to the siot3 server, and a browser connects to both over NATS WebSocket&quot; /&gt;&lt;/p&gt;
&lt;p&gt;The &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://youtu.be/lqM4MPVNHsc&quot;&gt;video demo&lt;/a&gt; walks through how this works.&lt;/p&gt;
&lt;p&gt;A rule on the server watches a push button on the Pi 5 and then turns on an LED
when the button is pressed. This demonstrates a round trip of data from the Pi 5
switch, to the server, through the rules, and then back to the Pi 5 LED. The LED
lights nearly instantaneously when the button is pressed. The round trip is
barely perceptible, roughly 100 ms.&lt;/p&gt;
&lt;p&gt;If the connection drops, NATS JetStream queues data at both ends, and
functionality resumes nearly instantly once the connection returns.&lt;/p&gt;
&lt;p&gt;The NATS project is what makes this possible. NATS provides essential bits like
JetStream that allows efficient synchronization between systems, and web client
libraries that push data efficiently to the browser in real time.&lt;/p&gt;
&lt;p&gt;SIOT models the entire system as a tree of nodes where each node is a set of
points. Telemetry, IoT data, and configuration are all just points and are
handled the same way. Write a point, and SIOT synchronizes it wherever it needs
to go. This simplicity allows SIOT to efficiently synchronize data from a fleet
of devices to your browser and makes it straightforward to extend with custom
functionality for just about any application.&lt;/p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>GPIO, IIO, and Shelly device improvments</title>
        <published>2026-09-02T00:00:00+00:00</published>
        <updated>2026-09-02T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/hardware-io/"/>
        <id>https://simpleiot.org/blog/hardware-io/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/hardware-io/">&lt;p&gt;The &lt;a href=&quot;/blog/mqtt/&quot;&gt;MQTT post&lt;/a&gt; covered the 0.25 release. Several things have
landed since then, mostly around reading real hardware.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Read a switch or drive a relay from a GPIO line.&lt;/strong&gt; A &lt;code&gt;gpio&lt;/code&gt; node reads or
drives one line on a Linux GPIO character device, so a rule can watch a float
switch and run a pump. Set the chip to &lt;code&gt;sim&lt;/code&gt; to develop rules before the
hardware exists. See the
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/user/gpio.html&quot;&gt;GPIO client&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Analog IO through the Linux IIO subsystem.&lt;/strong&gt; An &lt;code&gt;iio&lt;/code&gt; node reads ADCs, DACs,
and the sensors the kernel presents the same way: accelerometers, pressure,
humidity, light. Name the device and its channels are detected and added as
children, each publishing a reading in volts, amps, or degrees Celsius. See
the &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/user/iio.html&quot;&gt;IIO documentation&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Shelly devices are more discoverable and efficient.&lt;/strong&gt; A Shelly Gen2 or later
device answers with its own component list, so any such device works,
including models released after this one. Status now arrives over a WebSocket
instead of polling, so a relay switched at the wall shows up right away. See
the &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/user/shelly.html&quot;&gt;Shelly documentation&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Mirroring a hardware node now creates a view of it&lt;/strong&gt;, so only the instance
where the node actually lives talks to the device, and a value set on the
mirror travels back down to the hardware. See
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/ref/data.html#primary-and-mirror-edges&quot;&gt;primary and mirror edges&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;User passwords are stored hashed.&lt;/strong&gt; The store, sync streams, and exports
carry only a bcrypt hash. Existing passwords convert the next time each user
signs in.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;upgrading&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#upgrading&quot; aria-label=&quot;Permalink to this section&quot;&gt;Upgrading&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;Node replies over NATS now use the binary point encoding instead of protobuf.
This is an incompatible wire change, so instances and devices that sync with
each other need to be upgraded together. The
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://github.com/simpleiot/simpleiot/blob/master/CHANGELOG.md&quot;&gt;changelog&lt;/a&gt; has
the full list of changes.&lt;/p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>MQTT Support</title>
        <published>2026-08-20T00:00:00+00:00</published>
        <updated>2026-08-20T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/mqtt/"/>
        <id>https://simpleiot.org/blog/mqtt/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/mqtt/">&lt;p&gt;Simple IoT now supports MQTT and is possibly the easiest way to get MQTT data
into Grafana. See also the &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://youtu.be/ffo5BhcioWY&quot;&gt;MQTT demo&lt;/a&gt; on the
Simple IoT YouTube channel.&lt;/p&gt;
&lt;p&gt;There are three ways to configure MQTT:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Detail each measurement (OK for a small number of measurements)&lt;/li&gt;
&lt;li&gt;Automatic nodes with a topic schema&lt;/li&gt;
&lt;li&gt;Sparkplug B&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;(see the &lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/user/mqtt.html&quot;&gt;MQTT docs&lt;/a&gt; for more
information)&lt;/p&gt;
&lt;p&gt;The second method is generally the most useful. Define a topic schema like:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;{site}/{gateway}/{device}&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;And then when a message is received with the following topic:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;plant-07/kepware-l3/press/tank_level&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;SIOT will automatically create a tree of nodes, and then
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/user/database.html#tag-inheritance&quot;&gt;assign the following tags&lt;/a&gt;
to the nodes and data:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;site:plant-07&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;gateway:kepware-l3&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;device:press&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;key:tank_level&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;These tags then travel with the data into the VictoriaMetrics time-series
database, which makes it easy to visualize in Grafana.&lt;/p&gt;
&lt;p&gt;The key point in all this is you only define the topic schema, and the rest
happens automatically. There is no mapping of tags or manual configuration for
new data that shows up.&lt;/p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Sync is now stream replication</title>
        <published>2026-08-18T00:00:00+00:00</published>
        <updated>2026-08-18T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/sync-replication/"/>
        <id>https://simpleiot.org/blog/sync-replication/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/sync-replication/">&lt;p&gt;The &lt;a href=&quot;/blog/jetstream-store/&quot;&gt;previous post&lt;/a&gt; covered moving the Simple IoT store
to NATS JetStream. This post covers how we use streams to synchronize
offline/catch-up data. There is also a
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://www.youtube.com/watch?v=THmQkxWp9fo&quot;&gt;demo of offline synchronization&lt;/a&gt;
on the Simple IoT YouTube channel.&lt;/p&gt;
&lt;p&gt;Offline synchronization provides several key benefits:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Nothing is lost during network disruptions, which are a fact of life in
distributed systems, especially edge systems.&lt;/li&gt;
&lt;li&gt;We can take down cloud/upstream services (including databases) at any time and
no data is lost. This drastically simplifies operations and maintenance if we
don’t need always-on, highly available infrastructure.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;the-old-way&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#the-old-way&quot; aria-label=&quot;Permalink to this section&quot;&gt;The old way&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;In the past, SIOT has synchronized cloud and edge instances using a Merkle-style
hash tree: hash every node, compare hashes up the tree, and push the subtrees
that differ. It worked, but there was a lot of overhead in calculating the
hashes and updating every upstream node every time a point changed.&lt;/p&gt;
&lt;h2 id=&quot;the-new-way&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#the-new-way&quot; aria-label=&quot;Permalink to this section&quot;&gt;The new way&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;Since the SIOT store is now on JetStream, we already have history data
available. The only tricky parts are:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;How do we handle multiple writers (downstream and upstream)?&lt;/li&gt;
&lt;li&gt;Where do we draw the stream boundaries?&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;I originally planned one stream per node, but ended up with streams at the
device boundaries, which is simpler and has less overhead.&lt;/p&gt;
&lt;p&gt;Because both the downstream and upstream can write data, there needs to be a
stream for each writer. Sync means each side holds a replica of the other’s
stream, driven by durable NATS consumers: a push pump copies the device’s stream
up, a pull pump copies the hub’s configuration stream down. Current state on
either side is the merge of the two, newest timestamp winning.&lt;/p&gt;
&lt;p&gt;Because no instance ever writes remote data into its own streams, points cannot
echo back and forth between instances. There is no loop to suppress, which
removes an entire class of sync bug by construction.&lt;/p&gt;
&lt;p&gt;A durable consumer remembers its position across disconnects, so a device that
has been offline for two weeks reconnects and receives exactly the backlog, in
order, with original timestamps. No rescan, no comparison, no sync period to
configure. Replication is continuous: a write on one side shows up on the other
as fast as the connection carries it.&lt;/p&gt;
&lt;h2 id=&quot;siot-drastically-simplifies-stream-based-replication&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#siot-drastically-simplifies-stream-based-replication&quot; aria-label=&quot;Permalink to this section&quot;&gt;SIOT drastically simplifies stream-based replication&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;With SIOT, the developer rarely has to be concerned with the low-level stream
details. SIOT handles all of those details under the hood, and all the developer
needs to do is create nodes, points, and the clients that respond to and send
points. The rest happens automatically.&lt;/p&gt;
&lt;p&gt;Distributed systems are hard, especially systems where you can’t assume the
connection is solid and all services will be running all the time. With SIOT, a
lot of this complexity is eliminated. NATS JetStream provides the building
blocks (streams, durable consumers, etc.), and SIOT manages them in a way that
is transparent to the developer.&lt;/p&gt;
&lt;p&gt;The full design is in the
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/ref/sync.html&quot;&gt;sync reference&lt;/a&gt; and
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/adr/7-jetstream-store.html&quot;&gt;ADR-7&lt;/a&gt;.&lt;/p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>The store is now a stream</title>
        <published>2026-08-13T00:00:00+00:00</published>
        <updated>2026-08-13T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/jetstream-store/"/>
        <id>https://simpleiot.org/blog/jetstream-store/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/jetstream-store/">&lt;p&gt;Simple IoT 0.23 replaces the SQLite store with
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.nats.io/nats-concepts/jetstream&quot;&gt;NATS JetStream&lt;/a&gt;. This is the
biggest architectural change in the project’s history, and it is the first of a
series of posts on what we’ve been building this year. This one covers the store
itself; the next covers what it does for synchronization.&lt;/p&gt;
&lt;h2 id=&quot;two-shapes-of-the-same-data&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#two-shapes-of-the-same-data&quot; aria-label=&quot;Permalink to this section&quot;&gt;Two shapes of the same data&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;SIOT has always been a NATS application. Every component, whether a Modbus
client, a rule, or the UI, communicates by publishing points as messages. The
store’s job was to catch those messages and keep them.&lt;/p&gt;
&lt;p&gt;For years it did that by translating each point into rows in SQLite (and before
that, Bolt and Genji). SQLite served us well, and I would still reach for it in
plenty of applications. But it meant we maintained two shapes of the same data:
the message in flight and the row at rest, with translation code in between, and
a Merkle-style hash tree bolted on top so two instances could figure out how
their rows differed.&lt;/p&gt;
&lt;p&gt;The real problem was never the database. It was that we were translating between
two data models when one of them already did everything we needed.&lt;/p&gt;
&lt;h2 id=&quot;points-are-already-messages&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#points-are-already-messages&quot; aria-label=&quot;Permalink to this section&quot;&gt;Points are already messages&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;A JetStream stream is an append-only log of messages with sequence numbers and
per-subject indexing. That shape matches IoT data unusually well:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Persisting a point means capturing it.&lt;/strong&gt; The same message that moves between
components lands in a stream. No translation layer, no second data model.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;History is the natural byproduct.&lt;/strong&gt; A stream retains every point written to
a subject, so time-series history lives in the same place as current state.
The current value of a point is simply the last message on its subject.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Sequence numbers replace the hash tree.&lt;/strong&gt; Streams are ordered, so another
instance can replicate one and know exactly what it has and has not seen. More
on this in the next post.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;It is already there.&lt;/strong&gt; JetStream runs inside the NATS server every SIOT
instance ships, on cloud machines and small edge devices alike. There is no
separate database process to install or operate.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Reads never touch JetStream directly. The store keeps the merged current state
in in-memory caches, populated from the subject tips at startup, so queries stay
fast.&lt;/p&gt;
&lt;h2 id=&quot;retention-that-understands-configuration&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#retention-that-understands-configuration&quot; aria-label=&quot;Permalink to this section&quot;&gt;Retention that understands configuration&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;Retention is per subject: each point type on each node keeps its own most recent
20,000 messages by default. Per-subject limits have a property that time- or
size-based retention cannot give you: configuration points, written a handful of
times, are effectively kept forever, while a sensor reporting every minute wraps
after about two weeks. Current state is always preserved.&lt;/p&gt;
&lt;p&gt;The default works out to about four months of history for 10-minute data,
bounded on disk even for a device nobody visits. A device with little flash can
lower it with &lt;code&gt;SIOT_STORE_MAX_MSGS_PER_SUBJECT&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id=&quot;compression-pays-exactly-where-it-matters&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#compression-pays-exactly-where-it-matters&quot; aria-label=&quot;Permalink to this section&quot;&gt;Compression pays exactly where it matters&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;Streams are compressed with S2 by default. Point data compresses unusually well,
because the same type repeats in every message, keys come from a small set, and
timestamps march forward. In our testing, a store of 100,000 scraped points went
from 33.4 MB to 11.7 MB. A small store gives up nothing, and compression starts
paying exactly where disk begins to matter.&lt;/p&gt;
&lt;h2 id=&quot;migrating&quot;&gt;&lt;a class=&quot;heading-anchor&quot; href=&quot;#migrating&quot; aria-label=&quot;Permalink to this section&quot;&gt;Migrating&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;Existing SQLite databases migrate with &lt;code&gt;siot export&lt;/code&gt; on v0.22.0 followed by
&lt;code&gt;siot import&lt;/code&gt; on 0.23. The full design analysis is recorded in
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/adr/7-jetstream-store.html&quot;&gt;ADR-7&lt;/a&gt;, and the
&lt;a rel=&quot;noopener noreferrer external&quot; target=&quot;_blank&quot; href=&quot;https://docs.simpleiot.org/docs/ref/store.html&quot;&gt;store reference&lt;/a&gt; covers
retention, compression, and durability tuning in detail.&lt;/p&gt;
&lt;p&gt;This is the kind of simplification that feels right. Stay tuned for how
synchronization works, and how streams simplify so many things.&lt;/p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Hello</title>
        <published>2020-06-23T00:00:00+00:00</published>
        <updated>2020-06-23T00:00:00+00:00</updated>
        
        <author>
          <name>Unknown</name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://simpleiot.org/blog/hello/"/>
        <id>https://simpleiot.org/blog/hello/</id>
        
        <content type="html" xml:base="https://simpleiot.org/blog/hello/">&lt;p&gt;The Simple IoT project now has a web site. Stay tuned for more updates!&lt;/p&gt;
</content>
        
    </entry>
</feed>
