Skip to content
KinetixUI

Connected Product Lab

Build connected products that tell the truth about device state.

Controls, telemetry, pairing and automation patterns for real asynchronous hardware. A switch that has been pressed is a request. It becomes a state when the device says so.

Experimental · 0.5.0

React only, and experimental: the API may still change. There is no transport, no automation engine and no video. Everything interactive on this page is simulation, which is demo state and nothing else.

Explore IoT
bash
pnpm add @kinetixui/iot
SimulationWater pump · demo device
Pump 01Online
Off

Ready

Requested
Unknown
Device reports
off

No change requested. The device reports off.

Simulated — no device is contacted. Readings, commands and delays are scripted in your browser; nothing is sent over a network.

[01]Reference environmentssimulation

Three products, one interaction model.

A home, a farm and a production line name their places differently and want different controls. They still ask the same three questions of every device, and the same components answer them.

  1. What did I ask for?

    A request is drawn and announced as a request until the device confirms it.

  2. What did the device confirm?

    The reported state stays authoritative, and the last known value is labelled as last known.

  3. How much should I trust this number?

    Readings carry their age, a missing value is never zero, and simulated data says so.

  • Smart space

    Home → Floor → Room

    A home end to end: rooms with rolled-up health, light, thermostat, plug and lock controls, air quality, a sample camera frame, energy, alerts and scenes.

  • Agritech

    Farm → Field → Irrigation zone

    Greenhouse A: climate and soil readings, a soil-moisture trend against its threshold, valve and pump controls with a flaky valve, zones, alerts and an irrigation rule.

  • Operations

    Organization → Site → Line → Machine

    Site 04: fleet health, a hierarchy with a rollup at every level, equipment health, energy, faults and the command history.

Each environment is fabricated and scripted in your browser. Nothing is measured, and no device is contacted.

Operate an environment

Home → Floor → Room

Smart space environment

A home end to end: rooms with rolled-up health, light, thermostat, plug and lock controls, air quality, a sample camera frame, energy, alerts and scenes.

Built from 12 parts
  • DevicePowerControl
  • DeviceLevelControl
  • DeviceSetpointControl
  • DeviceModeControl
  • TelemetryGrid
  • TelemetryMetric
  • CameraDeviceCard
  • BatteryIndicator
  • EnergySummary
  • AlertList
  • ActivityTimeline
  • RoutineCard
SimulatedSimulated — no device is contacted. Readings, commands and delays are scripted in your browser; nothing is sent over a network.
[02]Explore by task

Pick the job you are building for.

Six groups, covering every component the package exports. Each starts with the problem it solves and the state model behind it, then lets you operate one focused example. The category bar stays in reach while you read.

Control

A request is not a state.

Almost every device UI fills the gap between asked and confirmed with an optimistic update: the switch slides, the icon lights, and the screen asserts a state the device has not reported. On a lamp that is harmless. On a lock, a valve or a pump it is a lie the user finds out about later.

Every control draws the request differently from the confirmed state, in the picture and in the accessible name, and one function decides what “pending” means so the controls on a screen cannot disagree.

The state model

  1. Off

    The device last confirmed it is off. That is the only thing the switch may claim.

  2. Turning on

    You asked. The track moves so the press feels received; the knob stays hollow and the label does not say “On”.

  3. Timed out

    No confirmation arrived inside the window. The screen says so, and still shows what the device last reported.

  4. Unreachable

    The device did not answer at all. A different sentence from a timeout, because the next step differs.

  5. Retry

    A new attempt, counted and bounded, that begins again from “requested” rather than pretending the first one worked.

Try it

Every change below is a request first. The dashed treatment is what the device has not agreed to yet, and it disappears when the (scripted) device confirms. Nothing here is connected to anything.

SimulatedStudio 2 · two demo devices, one command queue
Ceiling lightOnline
Off
Brightness35%
The ceiling light is off. Turn it on to set a brightness.
Climate unitOnline
20.5°CNow 19°C · Heating
Studio 2 temperature: target 20.5°C, currently 19°C

Last command

Requested
Unknown
Device reports
Light off

No change requested. The device reports Light off.

Simulated — no device is contacted. Readings, commands and delays are scripted in your browser; nothing is sent over a network.

See a reliable, a flaky and an unreachable device side by side

Requested is not confirmed

A live demo of the gap most device UIs hide: what you asked for against what the device reported, through acknowledged, confirmed, failed, timed out and unreachable.

Built from 3 parts
  • CommandLifecycle
  • DevicePowerControl
  • DeviceModeControl
SimulatedSimulated — no device is contacted. Readings, commands and delays are scripted in your browser; nothing is sent over a network.
[03]Device detail

One device, in depth.

The flagship composition: a pump station with Overview, Controls, Telemetry, Automations, Activity and Settings, built entirely from the parts above. It is source you copy, not a component you install, because a screen layout is where your product’s decisions live.

Device detail

The flagship: one pump in full, with Overview, Controls, Telemetry, Automations, Activity and Settings tabs, and every command showing requested against confirmed.

Built from 12 parts
  • DeviceStatusBadge
  • LastSync
  • ConnectionHealth
  • TelemetryTrend
  • AlertList
  • DevicePowerControl
  • RoutineCard
  • AutomationRuleView
  • ActivityTimeline
  • CommandLifecycle
  • SpaceBreadcrumb
  • TelemetryMetric
SimulatedSimulated — no device is contacted. Readings, commands and delays are scripted in your browser; nothing is sent over a network.
[04]Architecture

Bring your own connection.

KinetixUI IoT starts above the transport. Your application receives device state through whatever it already uses, an adapter turns that into the module’s shapes, and everything from there down is state, controls and patterns.

The protocols in the diagram are examples of infrastructure your application might use. This module opens no connection, holds no credential and parses no device payload.

Read the transport boundary in the docs

Where KinetixUI IoT sits, from the application down to the interface. Everything above the boundary is yours.
  1. Application and provider layerYours

    Wherever device state actually comes from. These are examples of what your application might use; KinetixUI ships none of them.

    • MQTT
    • BLE
    • Matter
    • REST
    • WebSocket
    • Vendor SDK
    • Cloud service
  2. Application adapterYours

    Your code turns whatever the provider sends into KinetixUI's shapes: a device with a status, a reading with a timestamp, a command that was confirmed or was not. It also carries intent the other way, from a callback to the provider.

    The boundary: KinetixUI does not own the transport.

  3. @kinetixui/iot/functionsKinetixUI IoT

    The state model as pure functions: device status and health, telemetry quality and thresholds, the command lifecycle, pairing stages, automation rules, the space hierarchy. No React, no DOM, no clock unless you pass one.

  4. @kinetixui/iot/reactKinetixUI IoT

    Primitives, controls and patterns that draw that state, and report intent through callbacks. They send nothing.

  5. CompositionsYours

    Whole screens assembled from those parts, published as source on this site to copy into your own product. Your layout, your copy, your decisions.

[05]What ships0.5.0

Two layers. The useful half has nothing to do with rendering.

The package is 3 entry points over one codebase. The functions half imports no React and touches no DOM, so it runs in a server route, a worker or a test. That is asserted against the source import graph and the built output, not promised.

Functions and models

ts
import {
  classifyBatteryLevel,
  evaluateReading,
  normalizeDeviceStatus,
} from "@kinetixui/iot/functions";

classifyBatteryLevel(72);        // "high"
normalizeDeviceStatus("ONLINE"); // "online"
evaluateReading({ value: null, metric: "temperature" }).state; // "unavailable"
Device state
Status, health and connectivity kept apart, and a normaliser for whatever spelling a backend sends.
Command lifecycle
Requested, acknowledged, confirmed, timed out, unreachable, retrying — a machine that refuses an illegal step.
Telemetry
A metric registry, thresholds, staleness, gaps, and the sentence a screen reader gets for a series.
Alerts and activity
Severity, acknowledgement, and the reduction a list needs: which of forty devices is asking for help.
Automation rules
A rule model with validation and a plain-language summary. It describes a rule; nothing evaluates one.
Pairing
Stages, methods and a failure registry with recovery actions. No discovery and no connection.
Places
A space tree with a health rollup, for a home, a farm or a factory without hard-coding any of them.
Battery, signal, firmware, energy
Bands and comparisons that keep “not reported” apart from a number.

React components

Module components, not entries in the component catalogue. They are React only.

Primitives
10

One fact, rendered: a status, a connection, a battery, a signal, a timestamp, a reading, an identity.

Controls
7

One thing a user can change: power, level, setpoint, mode, colour, lock and media playback.

Patterns
29

Compositions with a rule or two: cards, lists, telemetry, command feedback, alerts, activity, automation, pairing, places, energy and a camera that is never a feed.

Full props and behaviour are in the IoT documentation.

[06]Accessibility, RTL and motion

A green dot is not a device state.

Device dashboards lean on colour harder than almost any other interface, and colour is the one channel that disappears in greyscale, in forced-colors mode and for a screen reader. Every state here is a glyph with its own silhouette and a word; colour is only ever a second encoding.

Where a visual shorthand is used, such as a battery bar or 5m ago, the visual is hidden from assistive technology and the full sentence is the accessible name. Nothing is announced twice.

Right-to-left

The components use logical properties (start and end, not left and right), so a right-to-left page mirrors without a second stylesheet. The power switch reverses its knob travel. Time-series plots keep a left-to-right time axis, and identifiers, code and units stay left-to-right inside right-to-left text.

Motion

Motion uses Tailwind’s own motion-reduce: variant, so a reader who asks for reduced motion gets the static version, and no animation carries information that is not also written down. In the simulations, reduced motion stops ambient drift; a request you make still settles.

What assistive technology receives

Online
Online
Battery 72%, high
Signal 84%, excellent
Last seen 5 minutes ago
Temperature23.4 °C
Temperature 23.4 °C

Missing values are stated rather than implied: Battery level unknown, Never seen.

[07]Install@kinetixui/iot

One package, 3 entry points.

bash
pnpm add @kinetixui/iot

react is an optional peer (>=18). The components need it; the functions and models need nothing at all, so a server-side or worker consumer can install this package on its own.

The components style themselves with Tailwind utilities on the token contract rather than importing a stylesheet, so an app needs the tokens loaded and this package inside its Tailwind content. The functions subpath needs neither; the docs have the exact config.

ts
// models and pure functions — no React required
import { classifyBatteryLevel } from "@kinetixui/iot/functions";

// the React components
import { DeviceStatusBadge } from "@kinetixui/iot/react";

// or everything, from the root
import { SensorReading, formatLastSeen } from "@kinetixui/iot";
  • @kinetixui/ioteverything
  • @kinetixui/iot/functionsmodels and pure functions, no React
  • @kinetixui/iot/reactprimitives, controls and patterns
[08]Roadmapno dates

What exists, what does not, and what is only open.

Nothing outside the first column is scheduled. The second column is a set of decisions, not a backlog; the third is work that is deliberately waiting on something.

In the module

In the module
  • 10 primitives, 7 controls and 29 patterns for React
  • Models and pure functions for device state, commands, telemetry, alerts, automation rules, pairing and places
  • Three reference environments on this page, as source to copy
  • Status that is a glyph and a word, never colour alone

Not in the module, by design

Excluded
  • A transport of any kind: no protocol client, no discovery, no vendor adapter
  • An automation engine: rules are edited here and run by your application
  • Video: a camera card is a poster and a state, never a feed
  • Any implementation outside React

Deferred, not scheduled

Deferred
  • A grouped or scheduled command queue, which needs a real product's requirements before it is modelled

The reference, the models, and every prop.

The documentation carries the type definitions, the command lifecycle, the metric and failure registries, the accessibility contract and the module’s stated limits.