Open-source remote workspace Linux · macOS · Windows

Your whole dev machine. One browser tab.

blit turns any machine into a fast browser workspace—with persistent terminals, files, Git, code intelligence, port forwarding, and even GUI apps. Share it with a link. Drive it with an agent.

Install and open about 3 seconds

Linux / macOS

$ curl -sf https://install.blit.sh | sh

Windows

> irm https://install.blit.sh/install.ps1 | iex

Both install one binary. Then run blit open.

See everything blit does View on GitHub

No install · Docker demo

$ docker run --rm --shm-size=1g grab/blit-demo

The actual blit workspace Real recorded session

1: binary
0: required dependencies
3: desktop platforms
MIT: open-source core

Six jobs. One binary.

Everything between `ssh` and a cloud IDE—without moving your work to the cloud.

Run blit on a machine and it becomes a browser workspace, a persistent terminal server, a secure share link, and a computer API. Use only the parts you need; they all see the same live state.

01 / 06 Workspace

Open the machine, not just another shell.

blit open puts terminals, files, editors, search, diffs, and the commit graph in one tiled tab. The heavy work stays beside your code; the browser remains a fast, disposable client.

✓Processes and scrollback survive a closed tab or dropped connection.
✓Language servers run on the box, with completion, diagnostics, navigation, and cross-file rename.
✓Your tile layout lives in the URL, so the exact workspace reopens anywhere.

One connection carries all of this

TERMINALS: Persistent PTYs and scrollback
FILES: Live tree, grep, create, move, sync
GIT: Status, history, branches, staged + unstaged diffs
LSP: Completion, diagnostics, definitions, rename

Entry point: blit open

Commands, exactly as used

$ blit remote add prod ssh:alice@prod.co
$ blit remote set-default prod

$ blit open
$ blit --on prod terminal list

$ blit forward 8080:localhost:3000
$ blit forward udp/5353:resolver.internal:53

SSHauto-install

TCP + UDPforwarding

0reconnect ritual

02 / 06 Remotes

Every machine feels local.

Name an SSH host once. blit installs itself there on first contact, keeps the connection warm, and shows every remote beside your local machine. No separate fleet of browser terminals to manage.

✓Jump between local, production, a home server, and a dev container from one tab.
✓Forward TCP or UDP ports to anything the remote can reach.
✓Pre-warmed connections remove the SSH handshake from every new tab.

03 / 06 Share

Send the live workspace, not a screen share.

blit share creates one link with control and another that is read-only. Your teammate opens the same terminals, files, and editor in their browser—no account, SSH key, VPN, or local setup.

✓WebRTC connects peer to peer when it can, with relay fallback when it cannot.
✓Each viewer is paced independently, so a slow phone never stalls your desktop.
✓The signaling hub never receives the share secret.

The CLI prints both links

$ blit share
Terminals at https://blit.sh/s#psk=rf6e…
Read-only:   https://blit.sh/s#psk=EMPs…

no accountno inbound portno install

One CLI surface SKILL.md →

blit terminal

start · show · send · wait

blit fs

cat · find · grep · write · sync

blit git

status · log · diff · show

blit lsp

def · refs · hover · diag · rename

blit surface

capture · click · type · key

blit kv

get · put · watch · compare-and-swap

$ blit terminal start -t build make -j8
1
$ blit terminal wait 1 --pattern 'BUILD OK'
$ blit terminal show 1 | tail -2

04 / 06 Agents

Give agents handles, not pixels.

Agents can start a process, wait for output, read the parsed screen, edit files, inspect Git, ask a real language server, and control GUI windows. They operate the same workspace you can watch and take over.

✓No ANSI scraping, expect scripts, or brittle terminal coordinates.
✓Every command works locally, over SSH, or through a share link.
✓One compact skill file teaches an agent the entire interface.

05 / 06 GUI apps · experimental

A display server for servers without displays.

On Linux, every terminal gets a built-in headless Wayland compositor. Launch a browser, editor, media player, or your own app; blit streams its surfaces to the browser and exposes them to the CLI.

✓Capture, click, type, send keys, and move clipboard data programmatically.
✓H.264 or AV1, encoded on the GPU by Vulkan Video, NVENC, or VA-API, with software fallback.
✓No X server, physical display, or GPU required.

Surface commands

$ blit terminal start foot
1
$ blit surface list
$ blit surface capture 1
$ blit surface click 1 100 50
$ blit surface type 1 "hello{Return}"

The browser renders the encoded surface; the CLI addresses it by ID.

Your product, blit underneath

import { BlitTerminal, BlitWorkspaceProvider }
  from "@blit-sh/react";
import { BlitWorkspace }
  from "@blit-sh/core";

// WebSocket, WebTransport, WebRTC,
// Unix socket—or implement your own transport.

React

Solid

Core API

06 / 06 Embed

Ship the terminal without building the terminal stack.

MIT-licensed React and Solid packages expose the same workspace, terminal, surface, and transport primitives used by blit.sh. Put a production terminal—or a full remote workspace—inside your app.

✓Use the UI components or build your own against the headless core.
✓Bring WebSocket, QUIC, WebRTC, Unix sockets, or your own reliable byte stream.
✓Run the core in Node, Bun, or Deno for server-side automation.

Read the embedding guide →

Why it feels fast

Send what changed. Paint it locally.

blit does not stream a terminal as video or replay a river of ANSI bytes. The server understands the screen, computes a binary diff for each viewer, and sends only the cells that changed. The browser applies that diff in WASM and renders it on the GPU.

Every browser reports its own display rate, apply time, and backlog. That lets a workstation run at full speed while a slow phone catches up independently. Keystrokes take the reverse path without a frame queue, so input latency is bounded by the connection itself.

Parser: alacritty_terminal
Render: WebGPU · WebGL2 · canvas2d
Compression: LZ4 · binary diff
Encode: H.264 · AV1 · Vulkan

Read ARCHITECTURE.md

Browser

Layer 1

WebGPU / WebGL2 / canvas2d WASM diff engine Glyph atlas

Applies LZ4-compressed binary diffs; reports render metrics back for pacing.

diffs ↓ · keys ↑

Connection layer

Layer 2

WS · WebTransport WebRTC · Unix · SSH blit gateway · proxy-daemon

Stateless. Restartable. PTYs survive gateway and proxy restarts.

Unix socket

blit server

Layer 3

alacritty parser FrameState diff Wayland compositor (exp.)

Owns PTYs, scrollback, parsed state, per-client frame pacing, GPU encode.

Why blit

Not a web wrapper around one PTY.

Most browser terminals stop at “put this shell on a WebSocket.” blit is a multi-terminal workspace, remote protocol, agent API, and Linux GUI compositor built as one system.

Feature	blit	ttyd	gotty	Eternal Terminal	Mosh	xterm.js + node-pty
Architecture	Single binary	Single binary	Single binary	Client + daemon	Client + server	Library
Multiple PTYs	✓	—	—	—	—	~
Browser access	✓	✓	✓	—	—	✓
Delta updates	✓	—	—	—	✓	—
LZ4 compression	✓	—	—	—	—	—
Per-client backpressure	✓	—	—	~	—	—
GPU rendering (WebGPU/WebGL2)	✓	—	—	—	—	~
Embeddable (React/Solid)	✓	—	—	—	—	✓
Wayland compositor	✓	—	—	—	—	—
GUI app streaming	✓	—	—	—	—	—
Agent / CLI subcommands	✓	—	—	—	—	—
SSH tunneling built-in	✓	—	—	✓	✓	—

✓ first-class ~ partial / addon — not supported

Honest edges

Know where the line is.

The terminal and remote-workspace core is the foundation. GUI streaming and parts of the browser IDE are newer, so the page names those tradeoffs instead of hiding them.

Wayland compositor

Headless compositor and surface streaming are experimental. Some apps will draw fine; others won't. Linux only.

macOS / Windows GUI

Both platforms multiplex PTYs and stream them to browsers. The GUI compositor is Linux-only and not on the roadmap for either.

Hardware encoding

Vulkan Video is tried first and encodes on the compositor's own GPU, but drivers vary in what they will accept — 4:4:4 in particular. NVENC needs the proprietary NVIDIA driver, VA-API needs Intel/AMD with libva, and either can take over. Falls back to software at any time.

IDE scope

Edit, navigate, search, diff, commit — no debugger, no test runner, and rename is the only refactoring. Indentation is inferred from the file; there is no .editorconfig reader yet.

The shortest path to the product

Put this machine in a tab.

Install one binary, run blit open, and keep working. No account, config file, daemon setup, or required dependency.