cargo install termcrew

The terminal is
your social layer.

IRC-style channels. Live tmux session sharing. File locks for co-programming. Built in Rust. Runs entirely in your terminal — no browser, no Electron, no bullshit.

INSTALL TERMCREW JOIN WAITLIST
termcrew — taylorw@OFC — #cardinal-roofing
termcrew · #cardinal-roofing · 4 online ● ● ○ ○
SERVERS
▼ OFC
  # general
  # cardinal
  # random
FRIENDS
taylorw
🔒 routes.ts
devmike
sarah
idle 12m
thegian7
[10:31] taylorw alright webhook is done, pushing now
[10:32] taylorw deployed to staging
★ taylorw locked src/routes.ts
[10:34] devmike nice, testing the webhook now
[10:35] devmike /join taylorw
★ devmike joined taylorw's session [2 watching]
[10:36] devmike i see it — line 42, missing await
[10:36] taylorw oh damn, good catch
★ taylorw unlocked src/routes.ts
[10:38] taylorw fixed. re-deploying
★ session ended — taylorw's session
[10:40] devmike ✓ webhooks working
► /lock src/auth.ts

THE PROBLEM

Developers live in the terminal.
Their tools don't.

You're already in the terminal writing code. Then you alt-tab to a bloated chat app, share your screen over a laggy video call, and paste code into a browser window. Every switch costs focus. There had to be a better way.

Discord

  • Electron app — 300MB+ RAM just to say "hi"
  • No terminal integration whatsoever
  • Screen share is laggy and requires video
  • Code formatting is an afterthought
  • Your devs aren't on gaming platforms

Slack

  • $8–15/user/month for dev teams
  • Browser-first, terminal-never
  • Pair programming requires a plugin
  • No concept of file locks or presence
  • Thread model that nobody actually uses

IRC

  • No session sharing of any kind
  • No file locking or co-programming
  • No presence or idle detection
  • Setup requires an IRC client + server
  • It's 1988 and nobody is judging you

sshx.io

  • Session sharing only — no chat, no social
  • No channels, servers, or teams
  • No file locking or conflict prevention
  • No persistent history or friends
  • Single session, no coordination layer

FEATURES

Everything your team needs.
Nothing it doesn't.

termcrew is IRC done right for 2026. Chat, presence, DMs, session sharing, and file locks — all in one ratatui TUI with mouse support. No context switching. No browser. No video.

#

CHANNELS & SERVERS

Organize your team around projects with IRC-style servers and channels. Create with /server and invite teammates via a short invite code. Channels have two modes: collab (file locks enabled) and hangout (pure chat).

@

FRIENDS & DMs

Add teammates with /friend @handle. See who's online, idle, or offline in the sidebar — with idle time shown when they've gone quiet. Slip into a DM without leaving your terminal.

🔒

FILE LOCKING

Before editing a file, run /lock src/auth.ts. The channel sees it instantly. Advisory-only — no filesystem changes — but highly visible. Auto-expires after 30 minutes. Someone holding a lock you need? /steal prompts them.

CO-PROGRAMMING
▶

LIVE SESSION SHARING

Run /session to broadcast your tmux session. Teammates join with /join @you — they see exactly what you see, keystroke by keystroke, relayed through your server. Spectate with /watch @you for read-only view.

KILLER FEATURE
📋

SNIPPETS

Share code blocks with /share and specify a language. Displayed inline in chat with syntax highlighting rendered in your terminal. No pastebin, no link, no round trip.

⚫

PRESENCE & IDLE

Online/idle/offline is automatic — based on your WebSocket connection and keystroke activity. No manual status updates. Idle kicks in after 5 minutes of quiet. Your teammates know if you're actually there.

↺

RECONNECTION

Miss messages while your laptop sleeps? On reconnect, send your last-seen sequence number and the server replays everything you missed. Sessions survive your disconnect for 60 seconds — reconnect and pick up where you left off.

⚙

SLASH COMMANDS

Every action is a command. /session /join /watch /lock /unlock /steal /share /dm /friend /invite. Keyboard-first. Mouse supported too.

LIVE SESSION SHARING

Pair program without
a video call.

No screen share. No lag. No video. Just shared terminal.

HOST taylorw
● SESSION ACTIVE — 2 watching — Ctrl-\ to end
$ vim src/routes.ts
 
1 import { Router } from 'express'
2 import { handleWebhook } from './webhook'
3  
4 export async function initRoutes(app: Router) {
5   app.post('/webhook', async (req, res) => {
6     const result = handleWebhook(req.body)
7     // ← missing await!
8     res.json({ ok: true })

-- INSERT --
[chat] devmike: line 6 — missing await on handleWebhook
RELAY
WS
↕
VIEWER devmike
● WATCHING taylorw's session — Ctrl-\ to exit
$ vim src/routes.ts
 
1 import { Router } from 'express'
2 import { handleWebhook } from './webhook'
3  
4 export async function initRoutes(app: Router) {
5   app.post('/webhook', async (req, res) => {
6     const result = handleWebhook(req.body)
7     // ← missing await!
8     res.json({ ok: true })

-- INSERT --
[chat] you: line 6 — missing await on handleWebhook

HOW IT WORKS

01

HOST STARTS A SESSION

You run /session in any channel. termcrew tells your local tmux to pipe output to a relay socket. The server creates a session room and announces it in channel.

session
02

TEAMMATES JOIN OR WATCH

Anyone in the channel runs /join @you to join your session interactively, or /watch @you to spectate read-only. The server bridges raw PTY bytes between all participants. No SSH, no port forwarding.

join @taylorw
03

CHAT STAYS ALIVE ALONGSIDE

The session view takes over the main pane but a chat strip stays docked at the bottom. Comment on what you're seeing without breaking the stream. Inline, zero context switch.

check line 42 — missing await
04

SESSIONS SURVIVE DISCONNECTS

Your laptop sleeps. The relay buffers for 60 seconds. When you reconnect, the session is still alive. Viewers never know you dropped — they see a brief pause, nothing more.

Ctrl-\  (exit session, chat survives)

BUILT IN RUST

Fast. Safe. A single binary.

termcrew is written entirely in Rust — client, server, shared protocol library. tokio for async I/O, axum for the WebSocket server, ratatui for the TUI. No runtime, no GC pauses, no dependency hell.

<10ms
MESSAGE LATENCY
~8MB
BINARY SIZE
<20MB
RAM AT IDLE
1
BINARY TO DEPLOY
tokio async runtime — no blocking, no threads-per-connection
axum WebSocket server — typed, zero-copy message routing
ratatui TUI with crossterm mouse capture
SQLite persistence via rusqlite — no external DB required
serde JSON protocol — shared types across client and server
Compile-time guaranteed message exhaustiveness
Zero GC pauses — deterministic latency under load
MIT licensed — own your deployment
// Cargo.toml — one workspace, three crates, zero bloat [workspace] members = [ "crates/termcrew-common", # shared protocol types "crates/termcrew-server", # tokio + axum relay server "crates/termcrew-client", # ratatui TUI client ]
// Strongly-typed WebSocket protocol — compiler catches everything enum ClientMessage { SessionStart { channel_id: Uuid }, SessionJoin { session_id: Uuid }, LockAcquire { channel_id: Uuid, file_path: String }, ChatSend { channel_id: Uuid, content: String }, // ... 20 more variants, all exhaustively matched }

COMPARISON

How termcrew stacks up.

FEATURE TERMCREW DISCORD SLACK IRC SSHX.IO
Terminal-native TUI ✓ ratatui ✗ ✗ ~ client dependent ✗
Live session sharing ✓ tmux relay ~ screenshare (video) ~ plugin required ✗ ✓ link-based
File locking ✓ advisory ✗ ✗ ✗ ✗
Channels & servers ✓ ✓ ✓ ✓ ✗
Presence & idle ✓ keystroke-based ✓ ✓ ✗ ✗
Self-hostable ✓ single binary ✗ ✗ ✓ ~ server required
Direct messages ✓ ✓ ✓ ~ varies ✗
Open source ✓ MIT ✗ ✗ ✓ ~ partial
Cost ✓ free / self-host ✓ free tier $8–15/mo/user ✓ free ✓ free tier
RAM usage <20MB 300MB+ 200MB+ <5MB browser-based

DEPLOYMENT

Your server. Your data.

termcrew is open source under the MIT license. Run it on your own box — the server is a single Rust binary with no external dependencies beyond SQLite. Or use our hosted relay if you don't want to bother.

SELF-HOSTED

$0 forever
  • Single binary — drop it on any Linux box
  • SQLite storage — no separate DB process
  • Configurable via environment variables
  • WebSocket on any port you choose
  • Your team's data never leaves your server
  • MIT licensed — fork it, extend it, own it
$ cargo install termcrew
$ termcrew server --port 7700 --db /var/lib/termcrew/tc.db

HOSTED RELAY

coming soon
  • Zero-config — connect and go
  • Managed upgrades and backups
  • Private relay nodes for low latency
  • Same open-source server under the hood
  • Team billing, invite management
  • Sign up for early access below
$ termcrew connect tc.termcrew.io
> enter your invite code: ________
# Docker — if you're into that kind of thing $ docker run -d \ -p 7700:7700 \ -v termcrew-data:/data \ ghcr.io/termcrew/termcrew-server:latest

GET STARTED

Your team is waiting
in the terminal.

Install in 30 seconds. Invite your team. Start a session. Never alt-tab to a chat app again.

cargo install termcrew
JOIN WAITLIST SELF-HOST

MIT License  ·  Written in Rust  ·  Self-hostable  ·  No telemetry