Device → dashboard streaming

Turn any device into a live web dashboard.

BlinkPose™ is a family of small, self-contained modules that each take one physical device and stream its live data to a local web dashboard — a depth camera, a motion-capture rig, your keyboards and joysticks, a handful of BLE motion and pressure boards, a motorized force platform, a flatbed scanner, a body scale or a blood pressure monitor. Same message shape, same look, no build step.

localhost — BlinkPose · live dashboards
BlinkPose cycling through its nine dashboards — camera, motion capture, input hardware, BLE orientation and pressure boards, a body scale with a blood pressure monitor, a force platform, a remote screen read by probes, clock offsets across PCs, and a flatbed scanner

All nine dashboards — in turn: depth camera, motion capture, input hardware, BLE boards, scale and blood pressure, force platform, remote screen, clock sync, scanner. Each is a static page served from the module's own process.

One device, one process

Each module runs a tight loop: poll, detect, build one message per tick, push it out. Run several at once for several devices.

One JSON shape

Every module speaks the same { timestamp, device_id, entries[] } envelope. Learn one client, read them all.

Zero-build dashboards

Static index.html + style.css + script.js. They discover a running instance by probing localhost.

One visual identity

One shared set of design tokens behind every dashboard — dark by default, light a click away, and the whole family reads as one product in either.

The family

Nine modules. One pattern.

Each module is a shipped, working implementation of the same idea, adapted to what its device actually produces.

localhost — BlinkPose.Track
BlinkPose.Track dashboard with live camera view and detected markers updating

Track dashboard — live camera feed, the detection table, and the in-browser 3D view of everything in frame.

01
Intel RealSense camera

BlinkPose.Track

The richest module. It runs computer vision on an Intel RealSense depth camera, detecting ArUco markers, full-body pose down to the feet, both hands finger by finger, faces and circular markers in a single pass — each tagged with a real 3D position deprojected from the depth stream, and a full 6-DOF pose for the marker types. It's the only module with a live video feed and an in-browser 3D view of everything it sees, and it can record and replay sessions.

Vision 6 entry types media: MJPEG 3D view
View details →
localhost — BlinkPose.OptiTrack
BlinkPose.OptiTrack dashboard listing tracked rigid bodies and markers updating

OptiTrack dashboard — tracked rigid bodies and their individual markers, straight from the mocap solver.

02
OptiTrack / Motive · NatNet

BlinkPose.OptiTrack

Bridges a professional OptiTrack / Motive motion-capture rig over NatNet. It streams every tracked rigid body with full 6-DOF pose plus its individual markers, straight from the mocap solver — already in millimetre-accurate 3D, so there's no depth math to do. Each frame carries the solver's own frame id, so anything downstream lines up exactly with the capture.

Mocap rigidbody · marker 6-DOF pose no media
View details →
localhost — BlinkPose.Periphery
BlinkPose.Periphery dashboard showing keyboards and joysticks with live axes and buttons

Periphery dashboard — the roster of connected keyboards and joysticks, axes and buttons updating live.

03
Keyboards + joysticks

BlinkPose.Periphery

Turns ordinary input hardware into a clean data stream. It reports key presses per physical keyboard through Win32 Raw Input — so it can even tell two identical keyboards apart — plus joystick axes and buttons over SDL2. It keeps a live roster of every connected device (each with an editable friendly name), and can inject synthetic keystrokes back out to the OS.

Input key · axis · button device roster no media
View details →
localhost — BlinkPose.BLE.Stream
BlinkPose.BLE.Stream dashboard showing orientation gizmos, pressure sensor bars and a chest strap's heart rate and ECG trace updating live

BLE dashboard — orientation boards, pressure boards and a chest strap side by side: tareable 3D gizmos, ten-channel sensor bars, and heart rate with a live ECG trace.

04
IMU · pressure · heart · Bluetooth LE

BlinkPose.BLE.Stream

Connects over Bluetooth LE to a mixed set of small wireless devices at once — IMU boards republishing a fused orientation quaternion, pressure boards republishing ten live load channels each, and a chest strap republishing heart rate, RR intervals and its raw ECG trace. Because the devices are small and wireless, it's the natural fit for wearables, props and mats — and you can tare any orientation board straight from the dashboard, capturing its current pose as a new zero reference on the fly.

Orientation Pressure Heart rate · ECG quaternion 10 channels mixed rosters tare
View details →
localhost — BlinkPose.BLE.Event
BlinkPose.BLE.Event dashboard: a weighing arrives from the body scale, then the finished measurement with weight, impedance and heart rate beside the body-composition estimates and coloured bands showing where each value falls; then a blood pressure monitor hands over a new reading with systolic, diastolic and pulse

BLE Event dashboard — two people in turn: the scale sends each finished weighing, and it lands in the history with what the scale measured, the estimates for that person, and coloured bands that show where each value falls. After each weighing a blood pressure reading arrives the same way.

05
Bluetooth scale · blood pressure

BlinkPose.BLE.Event

A consumer body-composition scale as a data source: weight, bioimpedance and heart rate, read straight from its Bluetooth broadcasts — no phone, no app, no cloud. Every weighing is logged, and with the person's height, age and sex the module adds the body-composition estimates the scale's app would show, clearly marked as estimates. A Bluetooth blood pressure monitor is read the same way: each reading arrives by itself a few seconds after it is taken.

Body weight · impedance blood pressure estimates daily log
View details →
localhost — BlinkPose.LLD
BlinkPose.LLD dashboard: dual force platform with live load cells, weight chart and platform controls

LLD dashboard — eight load cells, six actuators, and the controls that drive both plates.

06
Dual force platform

BlinkPose.LLD

The one device that talks back. A leg-length-discrepancy platform with two motorized foot plates — it streams 8 load cells, 6 actuators and each plate's live pose, and it also takes motion commands, driving the plates to a target height, roll and pitch straight from the browser.

Bidirectional 8 load cells 6 actuators measure + move
View details →
localhost — BlinkPose.Glance
BlinkPose.Glance viewer showing a pump-station HMI on another PC: probes read its pressure, temperature and flow readouts and its alarm lamp, and a client plots the probe feed as the pressure trips the alarm

Glance viewer — a pump-station HMI on another PC, in the browser. Four probes read its gauges' readouts and its alarm lamp; below, a client plots that feed as the pressure trips the alarm and recovers.

07
Remote desktop + screen probes

BlinkPose.Glance

Turns the numbers on a machine's screen into live data: mark a rectangle on an HMI, an instrument's software or a legacy program, and Glance publishes the text, number or colour it sees there — no driver, no PLC access, no change to the program. Around it, a full remote desktop in any browser on the network, with mouse and keyboard control and copy-paste of files and text, to set the probes up and keep an eye on the machine.

Screen ocr · color view + control media: MJPEG
View details →
localhost — BlinkPose.Time
BlinkPose.Time on the central PC: six lab PCs with each clock's offset from the central PC in milliseconds, its uncertainty and Windows Time's state

Time dashboard — the central PC's table: every PC's clock offset, measured every five seconds; one drifts past 2 ms and is pulled back.

08
Clock sync across PCs

BlinkPose.Time

For a setup spread over several PCs — a camera on one, the platform on another. Time keeps every PC's clock in step with one central PC through Windows' own time service, and checks every few seconds how far each really is from it, to a fraction of a millisecond. The other modules stay as they are: their timestamps simply line up.

Multi-PC offset ± ms central · clients daily log
View details →
localhost — BlinkPose.Scan
BlinkPose.Scan dashboard: a form is scanned in grey and opens in the list; then an object scan runs - a blue anodized plate, an orange gasket and a colour card on the glass - and the finished 300 dpi scan opens with millimetre rulers and the plate's hole spacing measured

Scan dashboard — first a form, scanned in grey; then a colour scan of parts at 300 dpi, the plate's hole spacing measured in millimetres with two clicks.

09
Flatbed scanner

BlinkPose.Scan

Any ordinary flatbed scanner Windows knows, as a measuring device on the network: documents, parts, samples and other objects — or, in a clinic, feet and hands. Each kind of scan is a profile of its own, and every scan is saved with its true resolution, so each pixel has a size in millimetres: measure on it right in the dashboard, print it 1:1, or let your software read it.

Imaging document · object mm ruler PNG 1:1
View details →

Under the hood

How a module works

One process owns one device. It runs four tiny network servers, and the browser dashboard finds it by probing localhost — no configuration handshake, no central registry.

Physical device camera · mocap · IMU One process poll → detect → build 1 msg / tick → push to servers four small servers raw TCP feed · base+0 media / MJPEG · base+1 control API · base+2 events (SSE) · base+3 Browser dashboard discovers by probing

Signal path — one process owns one device and answers on four consecutive ports; the dashboard finds it by probing localhost.

  1. Discover. The dashboard probes a range of localhost control ports; any that answer /status with a device_id is a live instance.
  2. Stream. It opens a Server-Sent Events connection to that instance's events port and receives one JSON message per tick — the same payload the raw TCP feed sends.
  3. Render. Each tick carries a flat entries[] list, discriminated by type and sorted deterministically, drawn into a live table (and, for Track, a 3D view).
  4. Control. Toggles and device-specific actions are plain GET calls to the control API, which always returns the full current /status.
Specimen: one tickidentical over TCP and SSE
{
  "timestamp_ms": 1730563200123,
  "device_id": "optitrack",
  "entries": [
    {
      "type": "rigidbody",
      "id": 1,
      "rt": [ /* row-major 4×4 pose */ ]
    },
    {
      "type": "marker",
      "id": 101,
      "parent_id": 1,
      "rt": null
    }
  ]
}

One envelope type per tick · entries[] sent even when empty · id = parent_id·100 + index.

Consistent by design

Different data, one product

The pieces that make nine independent apps feel like one system.

Shared palette, two themes

Every dashboard starts from a byte-identical :root token block — one accent, a green/red/amber status set, and no rule outside that block naming a colour. The light theme re-states the same names, so one attribute re-skins all nine.

  • bg
  • panel
  • accent
  • good
  • bad
  • warn

left half dark · right half light

Finds its own instance

Open a dashboard and it discovers the running process by itself, probing localhost — nothing to type in, no address to configure. Start the process, open the page, and it just connects.

GET /status → device_id ✓

One message shape

Every module serializes the same { timestamp_ms, device_id, entries[] } envelope, with a single type-discriminated entries[] list — read one module and you can read them all.