One server for every instrument in your lab. Scriptable, visual, AI-aware.
// control a power supply const psu = connector("psu"); psu.voltage = 12; // read a temperature sensor const temp = connector("sensor").temperature; log.info(`Temperature: ${temp}°C`); // move a robot const robot = connector("robot"); robot.moveTo(100, 200, 50);
Plug in a new device, point the AI at its programming manual, and Muxit drafts a working driver in minutes. No boilerplate, no weeks hunting for the right SCPI commands.
Drop a datasheet or vendor programming manual into your workspace. A manual is not required — but it helps the AI pick the right commands.
The AI runs *IDN? over TCP, serial, or USB-TMC to confirm the vendor, model, serial, and firmware it's talking to — so the draft matches the actual device in front of you.
A JavaScript connector config using the built-in generic SCPI driver, with a declarative command block for properties and methods — or, for non-SCPI gear, a full custom JavaScript driver.
Write safety gates are on by default. Every generated connector is inspectable JavaScript — no black box. You can hot-reload into the running server to test.
Why this matters: driver coverage is the single biggest reason lab-automation tools fail to adopt. Muxit turns that problem on its head — every new instrument the AI learns expands the platform for everyone.
Muxit runs as a native background service on your machine and serves its GUI over a local web server. Open it in any browser — or let it run headless on a lab PC and connect from your laptop across the network.
Scripts, drivers, and device communications all run sandboxed inside the Muxit service. Your automation keeps running even when the browser is closed.
The GUI puts hardware on the left, scripts and dashboards in the middle, and AI on the right — all sharing the same live state. Drag a property from the hardware table straight into a script and Muxit inserts the right code for you.
Every connector with its live properties. Read values update in real-time; writable fields are editable inline. Drag any property onto a script or dashboard — Muxit inserts the right code or widget automatically.
The center workspace holds both your automation scripts and live dashboards. Switch between code and drag-and-drop control panels in the same tab. Autocomplete knows every connected device.
Ask questions about your hardware or have the AI drive it directly. Tool calls are visible and gated — you stay in control.
Muxit sits between your physical hardware and your software. Devices talk their native protocols — Muxit translates everything into clean JavaScript.
Robots, power supplies, spectrometers, sensors, ESP32 — anything with a port or IP address.
Lightweight adapters that speak the device's native protocol. JavaScript modules, definition files, or compiled plugins.
Wrap a driver with your config, custom methods, and computed properties — giving each device a friendly name and API.
Scripts, dashboards, external apps, or AI — all using the same natural JavaScript API.
Drivers speak the device's native protocol. Connectors wrap a driver with your configuration and custom methods — giving each device a friendly name and API. You write connectors, the community builds drivers.
From simple serial devices to complex robotic systems — one platform, one API, one language.
Wrap hardware drivers with friendly APIs. Custom methods, computed properties, and reactive polling out of the box.
Sandboxed JavaScript automation with natural syntax. Control, measure, and coordinate across all connected devices.
Drag-and-drop layouts with live gauges, charts, sliders, buttons, terminals, and video streams. All real-time.
Control your lab with natural language. Chat, voice commands, or autonomous agents with configurable safety gates.
Build drivers in JavaScript or C#. From simple serial commands to complex vendor SDKs. A 20-line JS file is enough.
Access your lab from anywhere — LAN, VPN, or secure tunnel. Control equipment from your laptop, phone, or another city.
No core modification needed. Pick the driver format that matches your instrument — and let the AI handle the details.
Use the built-in generic SCPI driver and describe the device's commands in a short declarative block inside a connector config. The AI can draft the whole config from a programming manual. Works with oscilloscopes, power supplies, multimeters, SMUs, and RF gear from every major vendor.
.js · AI-assisted Write a driver in plain JavaScript. Export get, set, execute — done. Community-driven, open, and fast to build for anything from ESP32 firmware to vendor-specific serial protocols.
.driver.js When a vendor ships a closed-source C/C++ or .NET SDK, we wrap it as a premium C# DLL plugin. Full hardware integration, built by the Muxit team.
.dll A complete JavaScript driver — 20 lines:
export default { meta: { name: "SimplePSU", properties: { voltage: { type: "number", access: "rw", unit: "V" }, current: { type: "number", access: "r", unit: "A" }, }, actions: { reset: { description: "Reset to defaults" } }, }, async init(config) { this.transport = createSerialTransport( config.port, { baudRate: 9600 } ); }, async get(prop) { return await this.transport.query(`${prop}?`); }, async set(prop, val) { await this.transport.send(`${prop} ${val}`); }, async execute(action) { await this.transport.send("*RST"); }, };
SCPI is the lingua franca of lab instruments. Muxit ships with a generic SCPI driver and an AI that drafts a device-specific connector on demand — so any SCPI-compliant instrument works out of the box, regardless of vendor.
Don't see your vendor or instrument type? That's the point — Muxit isn't tied to a curated list. Any instrument that accepts standard SCPI (over TCP, serial, or USB-TMC) works, and for anything non-standard the AI will draft a JavaScript driver from the programming manual.
All product names, logos, and brands are property of their respective owners. Their use is for identification purposes only and does not imply any affiliation with, or endorsement by, the respective trademark holders. Muxit is an independent project and is not affiliated with any of the vendors listed above.
Not just a chat window — a full AI agent framework with tool-calling, safety gates, and hardware awareness.
Native Model Context Protocol integration. Bring your own AI client — Claude Desktop, Claude Code, or any MCP-aware tool connects directly to your lab. No API key needed.
"Set the voltage to 12V", "Move the robot up 5 centimeters", "Run the calibration sequence" — plain English, real hardware.
Hands-free operation with wake word detection. Say "Muxit, read the temperature" while your hands are on the bench.
AI agents chain multiple tool calls for complex tasks. Configurable safety gates — confirm mode or trust mode, your choice.
"Make a script that scans the spectrometer every 10 seconds" — AI generates runnable code from natural language.
x: 340.2, y: 120.5, z: 85.0 with the gripper open. The joint angles are within normal range.
z: 135.0 and closed the gripper. Force feedback reads 12N — good grip.
If it has a port, Muxit can talk to it — and help you build workflows around it, whether you're running overnight characterization sweeps or a live art installation.
Automated measurement rigs, data logging, instrument coordination. Run overnight test sequences with a 10-line script.
Collaborative robots integrated with sensors, cameras, and tools. Coordinate pick-and-place with measurement in one script.
Responsive installations connecting sensors to lights, motors, and sound. React to visitors in real-time with live dashboards.
ESP32, Arduino, and MQTT devices on real-time dashboards. Bridge the gap between cheap sensors and serious data logging.
No await, no callbacks, no boilerplate. Read properties directly, write with assignment. That's it.
Log measurements to file
const psu = connector("psu"); const file = connector("file-access"); while (script.running) { const v = psu.measured_voltage; const i = psu.measured_current; file.appendLine({ path: "log.csv", text: `${timestamp()},${v},${i}` }); delay(1000); }
Safety interlock between devices
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); }
AI vision inspection
const cam = connector("webcam"); const snap = cam.snapshot; const result = ai( "Is the solder joint good?", snap ); log.info(result);
Voltage ramp with monitoring
const psu = connector("psu"); psu.output = true; for (let v = 0; v <= 12; v += 0.5) { psu.voltage = v; log.info(`${v}V → ${psu.measured_current}A`); delay(200); }
Build live control panels from widgets. Bind them to device properties — they update automatically.
Drag properties from the hardware panel onto a dashboard to create widgets. Drag scripts onto the grid for start/stop controls. Everything is JSON — version control friendly.
Muxit is in active development. Join the waitlist for early access and updates.
No spam. Unsubscribe anytime.