›_ webtm
Self-hosted · Single 10 MB binary · Zero dependencies

One browser tab for SSH, serial,
and the whole embedded bench.

Most web terminals stop at SSH. webtm also speaks serial/UART, CAN / CAN-FD, UDS and XCP — live hardware and vehicle diagnostics, with AI-assisted debugging on top. All of it self-hosted, on a single static binary you run yourself.

$ curl -fsSL https://webtm.dev/install.sh | sh
Get started See the diagnostics suite

Free for personal use · Works on iPad · No account to try

webtm — rpi-fleet-01
webtm running in a browser tab — SSH session to rpi-fleet-01, with a session sidebar (bench-stm32, gateway, rpi-fleet-01) and a live shell showing systemctl, dmesg CAN init, and a firmware flash with a Verify OK.
SSH Serial / UART CAN / CAN-FD UDS · ISO 14229 XCP · DAQ Broadcast AI debug
⌨

SSH terminal

Full xterm.js emulation over WebSocket. tmux keeps every session alive across disconnects — close the tab, come back, nothing lost.

🔌

Serial / UART

Open /dev/ttyUSB*, ttyACM*, tty.* from the browser. Hot-plug detection finds new adapters with no restart — even from an iPad.

⌁

Hardware diagnostics

CAN / CAN-FD monitor, UDS vehicle diagnostics over DoIP & ISO-TP, and XCP measurement with live DAQ — all on one unified transport.

✦

AI debugging & agent

Bring your own model (BYOK). Feed a serial log for root-cause, a code fix, a build and a shareable report — or just ask in plain language: “send start to every serial.” The agent lists the targets, proposes the action, and waits for your approval before it runs.

Diagnostics suite

The browser is now your bench

Serial, CAN, automotive UDS, and XCP calibration — multiplexed over a single /ws/x WebSocket. Pick a device with a URI; the panel renders the protocol.

CAN bus monitor

classic + FD

Live frame stream with hex filter, pause, and a frame injector. Classic CAN and CAN-FD with BRS — extended IDs, RTR, the lot.

Live CAN bus monitor connected to can0 — a streaming frame table with standard, 29-bit extended, and CAN-FD frames, plus a frame injector.

UDS vehicle diagnostics

ISO 14229

Service builder over DoIP/TCP and ISO-TP/CAN (CAN-FD too). Flow-control pacing, read-only gating, and DoIP UDP Discover for announced ECUs.

UDS diagnostics over DoIP — a request/response log showing ReadDataByIdentifier (VIN), ReadDTCInformation, and DiagnosticSessionControl exchanges.

XCP measurement

ASAM MCD-1

XCP on Ethernet (TCP/UDP) and CAN. Command builder plus a live DAQ view — periodic measurement streamed straight into the browser.

XCP measurement over Ethernet — a live DAQ view streaming two measurement channels as sparklines at 28 Hz.

Embedded framing

webtm-embed

Open serial://…?framing=cobs for COBS+CRC channel-multiplexed links — split one UART into clean logical channels in the 🧩 Embed panel.

Embedded device panel over a COBS-framed serial link — a channel-multiplexed frame log with per-channel hex and decoded ASCII text.
One socket, every transport

Every device is just a URI on /ws/x.

# serial byte stream / COBS-framed
serial:///dev/ttyUSB0?baud=115200
serial:///dev/ttyUSB0?framing=cobs

# CAN / CAN-FD
can://can0?fd=1

# UDS over DoIP (TCP) / over ISO-TP (CAN-FD)
uds://doip/192.168.0.10:13400
uds://can0/0x7E0?rx=0x7E8&fd=1

# XCP on Ethernet / on CAN
xcp://eth/192.168.0.10:5555
xcp://can0/0x100?rx=0x101&fd=1

# remote device via agent (Ultra)
agent://rpi-001/serial/ttyUSB0?baud=115200
Features

Everything a remote console should be

One web screen for the whole job — connect, persist, broadcast, debug.

Never-dies terminal

A 256 KB ring buffer per session plus smart reconnect replays every byte you missed. Flaky Wi-Fi stops being a problem.

1:N Broadcast Ultra

Send one command to many boards at once — parallel, sequential, or rolling — and watch each device's output side by side.

Built for touch

A virtual key bar (Esc, Tab, Ctrl, arrows) and a ⌘K command palette make a real terminal usable on a phone or tablet.

Remote federation Ultra

An agent exposes a remote board's serial or CAN as agent:// — self-registers with a join token, then debug hardware on the other side of the world.

Session sharing Pro

Hand someone a read-only URL to your live session — no install, no account, no setup on their end.

Install anywhere

One 10 MB static binary, CGO_ENABLED=0, web assets embedded. PWA install, offline-capable, expose via Cloudflare Tunnel in one flag.

AI debugging Ultra · BYOK

From crash log to a shipped fix

Bring your own model — Claude, OpenAI, or a local Ollama. The whole loop happens in the tab.

1

Capture

A HardFault or stack trace lands on the serial console.

→
2

Diagnose

The model reads the log and pins the root cause.

→
3

Fix & build

It proposes a patch; you approve; it builds.

→
4

Report

A shareable web report captures what changed and why.

Why webtm

One tab replaces the whole toolchain

SSH clients stop at SSH. Serial tools stop at serial. CAN and diag suites are each their own app. webtm is the entire bench.

Teleport
tmate		minicomSavvyCANCANapewebtm
SSH terminal✓———✓
Serial / UART—✓——✓
CAN / CAN-FD monitor——✓✓✓
UDS diagnostics (DoIP/ISO-TP)———✓✓
XCP measurement / DAQ———✓✓
1:N broadcast · AI agent————✓
In a browser · runs on iPad————✓
Self-hosted, one binary—✓✓—✓

Each rival is a single point on the bench. webtm is the only one that does all of it — from a browser, self-hosted.

On the bench, on the move

Debug UART from your iPad browser

webtm installs as a PWA and goes full-screen on touch. A virtual key bar puts Esc, Tab, Ctrl, and arrows under your thumb, and a swipe drawer holds your sessions, ports, and diagnostics. The thing nobody else lets you do: open a serial console on hardware from a tablet.

PWA · offline-capable virtual key bar swipe session drawer ⌘K palette
webtm on a phone — the swipe drawer open over a live SSH session, showing the gateway session, discovered serial ports (cu.usbserial-1420 · 115200, cu.debug-console · 921600), and one-tap tools for CAN, UDS, XCP, TRACE32, LIN and Embed.
Yours, end to end

Your data never leaves your machine

webtm is self-hosted. ttyd and the serial manager bind to 127.0.0.1 only — the gateway is the single door, where auth, license, and session limits live. Raw automotive egress (DoIP/XCP) is opt-in and off by default; tcp:// has an SSRF guard. Licenses validate offline with Ed25519 signatures: no call-home on startup, ever.

bcrypt / JWT auth localhost-only backends offline Ed25519 license egress-gated diagnostics audit logs (Ultra)
Pricing

Start free, self-hosted

Run it yourself — free for personal and non-commercial use. Upgrade only when you need teams, scale, or the hardware-fleet features.

Community

Free

Personal & non-commercial

  • 2 SSH sessions
  • 1 local serial port
  • CAN · UDS · XCP diagnostics
  • tmux persistence · PWA · virtual keys
Install free

Pro

$9 / mo

For working developers

  • Unlimited sessions & serial ports
  • Read-only session sharing
  • Multi-user accounts
  • Per-device access control
Choose Pro

Ultra

$39 / mo

For embedded teams & fleets

  • Everything in Pro
  • Remote serial / CAN (Agent)
  • 1:N broadcast
  • AI debugging (BYOK)
  • Conditional access · audit logs
Choose Ultra
See the full feature matrix
CommunityProUltra
SSH terminal sessions2UnlimitedUnlimited
Local serial / UART ports1UnlimitedUnlimited
CAN · UDS · XCP diagnostics✓✓✓
tmux persistence · PWA · ⌘K✓✓✓
Read-only session sharing—✓✓
Multi-user accounts—✓✓
Per-device access control—✓✓
Remote serial / CAN (Agent)——✓
1:N broadcast——✓
AI debugging (BYOK)——✓
Conditional access policy——✓
Audit logs——✓

Billed via Paddle · licenses are Ed25519-signed and validate offline.

Get started

Running in three lines

1

Install

curl -fsSL https://webtm.dev/install.sh | sh

One static binary lands in your PATH. No runtime, no dependencies.

2

Run

webtm up

Starts on localhost:4100. Add --auth or --tunnel when you're ready to expose it.

3

Open

open http://localhost:4100

Terminal, serial, CAN, UDS, XCP, and the AI panel — in the browser, on any device.

View on GitHub Compare plans