// led-iv.js const psu = connector("psu"); const dmm = connector("multimeter"); const csv = connector("file-access").file("iv.csv"); psu.output = true; for (let v = 0; v <= 3.5; v += 0.05) { psu.voltage = v; delay(100); csv.append(`${v},${dmm.measured_current}\n`); } psu.output = false;
For your bench
Lab-grade automation that doesn't fight you back.
From the ESP32 you wired yourself to a rack of Keysight gear: scripted control, live dashboards, and AI that helps without taking over. One server, every device, one JavaScript layer. Runs local on your own machine.
What you actually get
One server. Every device on your bench. One API.
A single server running on your machine, talking to every device over its native protocol. A clean JavaScript API for everything. Read a value, set a value, run a sequence. Live dashboards bound to real-time state. AI integration with safety gates. Scripts that keep running while the browser is closed.
No NI license. No LabVIEW dialect. No Python environment that broke last week.
In the home lab
A second-hand Rigol, a budget PSU, the ESP32 you flashed last weekend. Slightly messy, entirely yours.
On the R&D bench
Rack-mounted Keysight, a thermal chamber, an electronic load, an SMU. One server, all instruments.
Your gear
We work with what you already have.
Muxit ships with three declarative protocols: Scpi for SCPI instruments, LineText for devices that print text lines, and BinaryStream for binary frames. Point one at a device over TCP, serial, or USB-TMC and the built-in AI assistant probes it, reads the programming manual, and drafts the connector config, usually in under ten minutes. You review and approve; the connector lives in your workspace and is yours to keep, edit, and version-control. How that works in practice →
In the home lab
Brands you'll recognise from the home-lab world: Rigol, Siglent, Owon, Aim-TTi, GW Instek, Hantek, Riden, BK Precision. Your second-hand HP from a decade ago and your friend's new Keysight scope use exactly the same code.
On the R&D bench
Keysight, Tektronix, Rohde & Schwarz, Keithley, Fluke, Yokogawa and the rest of the rack. Instruments with native vendor SDKs ship as compiled plugins, built and signed by the Muxit team. One-time purchase, lifetime access.
Categories: oscilloscopes, multimeters, power supplies, power analyzers, electronic loads, source/measure units, signal generators, spectrum and network analyzers, frequency counters, data acquisition.
Beyond SCPI, Muxit ships drivers for ONVIF cameras, MQTT brokers, MIDI controllers, and raw serial, plus a handful of free add-ons and JS examples for the gear that doesn't fit a category.
Already have a Python script for your gear? Drop a plain
.py file into workspace/python/ and a connector
calls its top-level functions. No Driver class, no JSON-RPC
boilerplate. A sibling requirements.txt auto-installs into a
per-script virtual environment on first use, so vendor SDKs and torch,
numpy, or pyserial work out of the box. Each Python connector runs as an
isolated subprocess in its own environment, so your numpy 1.x stage
controller can't fight the torch-based vision rig running next to it.
What it's actually for
Real things you'll actually run.
home lab led-iv.js
Characterisation runs
IV curves, frequency response, temperature coefficients. The kind of measurement you'd do by hand, then realise you should have automated, then do by hand again next week. Write the script once, run it whenever.
R&D bench burn-in.js
Long-running tests that watch themselves
Burn-in a salvaged supply for a week, or run an overnight qualification sequence. Define what "still healthy" means once. Current in range, temperature stable, indicator still lit. Muxit logs everything, halts the moment something is off, and hands you the data in the morning.
// burn-in.js const lamp = connector("lamp-psu"); const cam = connector("webcam"); const csv = connector("file-access").file("burn-in.csv"); let anomalies = 0; while (script.running) { const current = lamp.measured_current; const lit = ai("Is the lamp still on?", cam.snapshot) === "yes"; csv.append(`${timestamp()},${current},${lit}\n`); if (current < 0.05 || !lit) { anomalies++; if (anomalies > 3) { lamp.output = false; log.error("Test halted, too many anomalies."); break; } } delay(60_000); }
both
Voice control while your hands are full
Hands full and iron hot, or two probes on the board and both eyes on the scope, and you still need the supply at 5 volts. Just say it.
- "Set channel A to 5.2 volts."
- "What's the current draw?"
- "Start logging temperature to bench.csv."
- "Run the LED sweep."
- "Save the scope screenshot to today's folder."
Voice in, hardware responds. Tool calls are visible and gated.
both vision.js
Camera-aware automation
Point a webcam at your setup. Ask whether the LED is still lit, whether a non-programmable display has changed, whether the solder joint looks right, and turn the answer into action. Vision turns any camera into a sensor, and any instrument with a display into something readable. It's the only way to read instruments that don't have a port.
const cam = connector("webcam"); if (ai("Is the LED still on?", cam.snapshot) === "no") { psu.output = false; log.warn("LED failed. PSU disabled."); }
R&D bench interlock.js
Safety interlocks across instruments that don't normally talk
Over-temp shutdown, over-current cutoff, dead-man checks. The kind of thing you'd hard-wire if you could, written in ten lines instead.
const sensor = connector("thermocouple"); const psu = connector("psu"); while (script.running) { if (sensor.temperature > 60) { psu.voltage = 0; log.warn("Over-temp! PSU disabled."); } delay(500); }
home lab
Reactive setups that aren't quite a "lab"
Sensors driving lights, motors, and sound. A homemade environmental monitor that pings you when the basement floods. A grow-light controller that watches the plant. Muxit doesn't care whether you call it a lab, an installation, or just the thing on the desk.
both
Multi-device orchestration
The point of Muxit isn't any one of these jobs. It's that they're all the same script. PSU, scope, DMM, sensor, ESP32, webcam, all in one place, all in one language, all in one dashboard.
Homemade hardware
Your homemade hardware fits.
ESP32, Arduino, Pi-zero, anything you wired yourself, anything running custom firmware. There's no Muxit-specific protocol to flash. If your microcontroller publishes data on MQTT, Muxit can read it. If it speaks a few lines of serial, Muxit can read that too. Bring the hardware as it is; Muxit meets it where it lives.
// esp32-temp.js: your microcontroller publishes on MQTT const esp = connector("esp32-bench"); log.info(`Bench temperature: ${esp.temperature}°C`);
A connector is a small JavaScript file that says here's how to talk to this thing. Twenty lines, sometimes less. You write one once and the rest of Muxit treats your homemade hardware exactly like a commercial instrument. Same scripts, same dashboards, same AI access.
AI integration
AI you actually use.
Not a chat gimmick stapled to the side. The AI in Muxit drives real hardware, with real safety gates.
Natural language, real hardware.
"Set the voltage to 12V", "Run the calibration sequence", "Move the robot up 5 millimeters." Plain English, real instruments responding.
Tool calls are visible and gated.
Every action the AI takes is logged. Write operations require explicit approval by default; you choose what the AI is allowed to do unsupervised.
MCP integration is free, on every tier.
Bring your own AI client. Claude Desktop, Claude Code, ChatGPT, any MCP-aware tool, and connect it directly to your bench. No Muxit AI credits required if you'd rather use your own provider.
Local LLM, free on every tier.
Point Muxit at Ollama or LM Studio and run AI features fully offline, air-gapped. Your prompts and your data never leave the network. Free included.
The AI drafts drivers.
New instrument arrives, you point the AI at its programming manual, and it writes a working connector in plain JavaScript you approve before it runs. How the AI connects a new device →
Built to be defensible
The kind of facts you want when someone asks why.
Plain JavaScript end to end.
Connectors and scripts are readable JavaScript files in a folder you can put under version control. Diff them, review them, commit them. Nothing is hidden.
Local-first, no lock-in.
The server runs on your machine and can run fully air-gapped. Drivers, connectors, scripts, and data are open and yours, in formats you choose.
Underneath, scripts run in a locked-down V8 sandbox and compiled plugins are RSA-signed and verified at load time. How the sandbox and signing work →
The small things
Plus the small things that make it nice.
One window for everything.
Hardware on the left, scripts and dashboards in the middle, AI on the right. Drag a property into a script or onto a dashboard widget and Muxit does the wiring. See how the app fits together →
Headless if you want it.
Run Muxit on a Pi or an old laptop in the corner of the room and connect to it from your real computer. Your tests keep running when you close the lid.
Remote access that isn't terrifying.
HTTPS with password auth on your LAN, plus mDNS so any device on the network finds the server by name. Drop it behind a VPN of your choice when you need to reach it from elsewhere.
When you need to prove it: Lab
Engineering work that has to defend itself.
Pro is for engineering work. Lab is for engineering work that has to defend itself, to a QA manager, an auditor, a customer, a regulator.
Audit log.
Full history of every device interaction on the installation, exportable to CSV or JSON. Who or what did what, when, with which value.
Safety policy engine.
Per-connector write limits, confirm gates, AI agent restrictions. Define the rules once, enforce them across every script and AI call.
Running Muxit on multiple lab PCs across an organisation? Get in touch and we'll work out a multi-installation arrangement.
Where we are
A note on where we are.
Muxit is in public beta. Free is downloadable today; Maker, Pro, and Lab open after the waitlist. It's built and maintained by a small, technical team with hands-on experience in industrial measurement and control. The same people who got tired of the gap between five vendor apps that don't talk to each other and the ten-thousand-euro LabVIEW license. Rough edges in places, yes. It also means the roadmap is shaped by a small number of early users with real benches, not by committee. Adopt it now and you have a direct line to the people building it, and you'll see your feedback in the next release.
If lab automation is something you've quietly wished worked better for years, this is the rare moment to influence what it becomes.
Pricing
Free to start. Maker, Pro, and Lab when you need more.
- Free. €0, forever. Three connectors, unlimited scripts (max three running at once), unlimited dashboards. Ships with the built-in protocols (Scpi, LineText, BinaryStream), MCP integration, and Ollama / LM Studio support.
- Maker. €9/month or €89/year. Muxit-managed AI with 500 credits a month, AI-assisted SCPI connector authoring, 10 connectors, two instances per machine, remote access.
- Pro. €29/month or €289/year. AI image analysis, autonomous agents, unlimited connectors, premium drivers & extensions (incl. the Vision engine), and 1500 credits a month.
- Lab. €99/month or €989/year per installation. Pro plus audit log, safety policy engine, and 4000 credits a month.
50% academic discount for verified students, educators, and researchers. Multiple installations across one organisation? Get in touch.
Two ways in
Download Free now. Maker, Pro, and Lab are next.
Muxit Free is in public beta. Three connectors, the built-in protocols, MCP, local LLM, free forever. Maker, Pro, and Lab open after the waitlist; first-year pricing is locked in for everyone who signs up now.