muxit.io — Connect anything. Control everything.

The app

One window for your whole lab

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.

Muxit app showing hardware devices, script editor, and AI chat panels

Hardware panel

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.

Scripts & dashboards

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.

AI chat

Ask questions about your hardware or have the AI drive it directly. Tool calls are visible and gated — you stay in control.

How it works

One server. Every device.

Muxit sits between your physical hardware and your software. Devices talk their native protocols — Muxit translates everything into clean JavaScript.

Devices

Robots, power supplies, spectrometers, sensors, ESP32 — anything with a port or IP address.

→

{ }

Drivers

Lightweight adapters that speak the device's native protocol. JavaScript modules, definition files, or compiled plugins.

→

⚡

Connectors

Wrap a driver with your config, custom methods, and computed properties — giving each device a friendly name and API.

→

Your code

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.

Features

Everything you need to orchestrate hardware

From simple serial devices to complex robotic systems — one platform, one API, one language.

⚡

Connectors

Wrap hardware drivers with friendly APIs. Custom methods, computed properties, and reactive polling out of the box.

Scripts

Sandboxed JavaScript automation with natural syntax. Control, measure, and coordinate across all connected devices.

◩

Dashboards

Drag-and-drop layouts with live gauges, charts, sliders, buttons, terminals, and video streams. All real-time.

AI & voice

Control your lab with natural language. Chat, voice commands, or autonomous agents with configurable safety gates.

🔧

Driver SDK

Build drivers in JavaScript or C#. From simple serial commands to complex vendor SDKs. A 20-line JS file is enough.

🌐

Remote access

Access your lab from anywhere — LAN, VPN, or secure tunnel. Control equipment from your laptop, phone, or another city.

Driver ecosystem

Three ways to add a device

No core modification needed. Pick the driver format that matches your complexity.

JavaScript drivers

JS drivers

Write a driver in plain JavaScript. Export get, set, execute — done. Community-driven, open, and fast to build.

.driver.js

Definition files · Coming soon

SCPI & serial

Text files listing commands and properties. No code needed — just define your instrument's protocol in a structured format.

.scpi · .serial

Compiled plugins

C# DLL plugins

For instruments requiring native vendor SDKs. Premium drivers built by the Muxit team with full hardware integration.

.dll

A complete JavaScript driver — 20 lines:

psu.driver.js

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"); },
};

AI-powered

AI infrastructure for physical systems

Not just a chat window — a full AI agent framework with tool-calling, safety gates, and hardware awareness.

MCP server

Native Model Context Protocol integration. Claude Code and Claude Desktop connect directly — no API key needed.

Natural language control

"Set the voltage to 12V", "Move the robot up 5 centimeters", "Run the calibration sequence" — plain English, real hardware.

Voice control

Hands-free operation with wake word detection. Say "Muxit, read the temperature" while your hands are on the bench.

Autonomous agents

AI agents chain multiple tool calls for complex tasks. Configurable safety gates — confirm mode or trust mode, your choice.

Script generation

"Make a script that scans the spectrometer every 10 seconds" — AI generates runnable code from natural language.

Muxit AI

What's the robot's current position?

The FR5 is at x: 340.2, y: 120.5, z: 85.0 with the gripper open. The joint angles are within normal range.

Move it 50mm up and close the gripper

Done. Moved to z: 135.0 and closed the gripper. Force feedback reads 12N — good grip.

Use cases

Built for tinkerers, artists, and makers

From automated test benches to interactive art installations — if it has a port, Muxit can talk to it.

Lab automation

Automated measurement rigs, data logging, instrument coordination. Run overnight test sequences with a 10-line script.

Robot workflows

Collaborative robots integrated with sensors, cameras, and tools. Coordinate pick-and-place with measurement in one script.

Art installations

Responsive installations connecting sensors to lights, motors, and sound. React to visitors in real-time with live dashboards.

IoT & sensors

ESP32, Arduino, and MQTT devices on real-time dashboards. Bridge the gap between cheap sensors and serious data logging.

Scripting

Simple scripts, real hardware

No await, no callbacks, no boilerplate. Read properties directly, write with assignment. That's it.

Log measurements to file

log-voltage.js

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

thermal-guard.js

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

inspect.js

const cam = connector("webcam");
const snap = cam.snapshot;
const result = ai(
  "Is the solder joint good?", snap
);
log.info(result);

Voltage ramp with monitoring

ramp.js

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);
}

Dashboards

Real-time monitoring, drag and drop

Build live control panels from widgets. Bind them to device properties — they update automatically.

gauge chart scope slider knob button toggle indicator terminal video stream

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.