The Decentralized, Secure, Peer-to-Peer Terminal Communicator for Developers
A terminal-native ecosystem for encrypted pair programming, WASM plugin execution, and decentralized communication without the cloud.
- Overview
- Features
- Version Evolution
- Architecture
- Installation
- Quick Start
- Command Reference
- Project Structure
- Plugins
- Security
- Performance
- Testing
- Contributing
- FAQ
- Roadmap
- License
What is QuickChat?
QuickChat is a 100% free and open-source, terminal-native communication layer. It is built natively in Rust, offering developers a secure environment to collaborate, share terminal sessions, ingest CI/CD alerts, and run offline AI tools—all without ever leaving their keyboard.
Why was it built?
Traditional messaging platforms rely on centralized cloud servers that harvest data, suffer from outages, and force developers into bloated electron apps. QuickChat was engineered to bring communication back to the terminal, secured by military-grade cryptography, and completely decoupled from corporate infrastructure.
Who is it for?
Developers, DevOps engineers, privacy advocates, and distributed teams who demand extreme performance and absolute ownership over their data.
What problems does it solve?
- Context Switching: Stay in your terminal while managing PRs, chatting, or reviewing logs.
- Privacy: No servers, no accounts, no telemetry. Pure Peer-to-Peer (P2P).
- Network Boundaries: Securely tunnel through restrictive networks via DHT routing and Federation.
| Feature | Description | Available Since | Status |
|---|---|---|---|
| Encrypted Messaging | P2P Noise/OpenMLS authenticated encryption | V1 | Stable |
| QUIC Networking | Multiplexed UDP streams via quinn |
V1 | Stable |
| Terminal UI | Stunning ratatui multi-pane interface |
V1 | Stable |
| WASM Plugin SDK | Run GitHub/Docker plugins safely in WASM | V2 | Stable |
| Live Code Pointers | Click a code:// link to open your local $EDITOR |
V2 | Stable |
| SQLite History | Persistent, locally-owned chat history | V3 | Stable |
| Persistent Groups | Multi-party rooms via /group join |
V3 | Stable |
| Pair Programming | Real-time synchronized file buffers | V4 | Stable |
| CI/CD Webhooks | Pipe build failures to your terminal natively | V4 | Stable |
| OS Clipboard Sync | Instantly sync clipboards across networks | V5 | Stable |
| Cross-Network Federation | Matrix and ActivityPub protocol bridges | V5 | Stable |
What it is: The foundational transport layer. How it works: QuickChat uses the Noise Protocol Framework for 1-on-1 handshakes and OpenMLS for Continuous Group Key Agreement (CGKA), transmitted over multiplexed QUIC streams. Benefits: Extreme low-latency, zero head-of-line blocking, and Perfect Forward Secrecy.
What it is: An isolated execution environment for community extensions.
How it works: Plugins are compiled to WebAssembly (.wasm) using our SDK and executed inside the wasmtime engine. They cannot access your OS natively.
Benefits: Infinite extensibility (e.g., Jira, GitHub, Docker integrations) without risking the host application's security.
What it is: Real-time synchronized terminal editing.
How it works: Using the /pair <file> command, a local file buffer is securely broadcasted as a BufferSync payload to your peer.
Benefits: Rapid collaborative debugging without heavy screen-sharing applications.
What it is: A bridge to other decentralized networks.
How it works: The quickchat_net::federation module structurally translates external Matrix and ActivityPub JSON payloads into our native Protobuf Envelope system.
Benefits: Allows isolated, self-hosted QuickChat nodes to interoperate with the broader open-source ecosystem.
| Version | Release Focus | Major Features | Architecture Changes | Networking | Status |
|---|---|---|---|---|---|
| V1 | The Foundation | P2P Chat, Terminal UI, Zstd Compression | Monolithic CLI | LAN (mDNS) only | Delivered |
| V2 | Extensibility | WASM Plugins, Live Code Pointers | plugin_host crate |
Global Internet (DHT) | Delivered |
| V3 | Teams | Persistent Groups, SQLite History | Local Storage Engine | Open Community Relay | Delivered |
| V4 | Workflows | Pair Programming, Offline AI, Webhooks | Async Event Bus | TCP Webhook Listeners | Delivered |
| V5 | The Comm Layer | Federation, Clipboard Sync, Voice Notes | federation module |
Matrix / ActivityPub | Delivered |
QuickChat matured from a simple LAN messenger (V1) into a fully decentralized, plugin-driven terminal operating system for communication (V5). Every feature was iteratively designed to keep developers in the flow state.
QuickChat utilizes an event-driven, highly concurrent architecture built on Rust's tokio runtime.
┌─────────────────────────────────────────────────────────┐
│ quickchat_cli │
│ (Event Bus, Webhook Listeners, Terminal Streamer) │
└──────┬─────────────────────────┬─────────────────┬──────┘
│ │ │
┌──────▼──────┐ ┌──────▼──────┐ ┌──────▼──────────┐
│quickchat_tui│ │quickchat_net│ │quickchat_plugin │
│ (Ratatui) │ │(QUIC/Noise) │ │ _host │
└──────┬──────┘ └──────┬──────┘ └──────┬──────────┘
│ │ │
┌──────▼─────────────────────────▼─────────────────▼──────┐
│ quickchat_core │
│ (SQLite, OpenMLS, File Manager, AI) │
└─────────────────────────────────────────────────────────┘
- Operating Systems: Windows, macOS, Linux
- Rust Toolchain: Version 1.80.0 or higher
- Cargo: Included with Rust (
rustup default stable) - Git: For fetching the repository
This method ensures you have the absolute latest, locally optimized binary.
# Clone the repository
git clone https://github.com/aaryanrwt/QuickChat.git
cd QuickChat
# Build the release binary
cargo build --release
# Run the executable directly
./target/release/quickchat_cliInstalls the binary globally to your ~/.cargo/bin directory.
cargo install --path .
quickchat_cliWelcome to QuickChat! Here is how to go from zero to chatting in under 60 seconds:
- Launch: Run
quickchat_cliin your terminal. You will be greeted by the stunning TUI. - Discover: The DHT automatically maps peers. Your Public Key is displayed at the top.
- Connect: Type
/connect <peer_public_key>to initiate a secure handshake. - Chat: Type your message and hit Enter. Markdown and syntax highlighting work out-of-the-box.
- Collaborate: Type
/pair src/main.rsto open a live, synchronized editing session. - Exit: Type
/quitto safely flush the SQLite database and exit.
| Command | Purpose | Syntax | Example | Expected Result |
|---|---|---|---|---|
/help |
View help menu | /help |
/help |
Displays command cheat sheet |
/connect |
Secure P2P handshake | /connect <key> |
/connect 8a2f...3c |
Establishes QUIC stream |
/group join |
Join persistent room | /group join <id> |
/group join rust_devs |
Sets routing tag to group ID |
/pair |
Live buffer sync | /pair <file> |
/pair src/lib.rs |
Broadcasts file contents |
/clip push |
Send OS clipboard | /clip push |
/clip push |
Sends clipboard payload |
/voice |
Send 10s audio note | /voice |
/voice |
Captures OS mic & transfers |
/quit |
Safely exit | /quit |
/quit |
Flushes DB and closes app |
Our monorepo is meticulously split into logical, highly cohesive crates:
quickchat_cli: The executable. Wires the event bus and parses arguments.quickchat_core: The brain. Manages SQLite history, cryptography (OpenMLS), and core state.quickchat_net: The transport. Manages QUIC streams, Federation, and Protobuf encoding.quickchat_dht: The router. Kademlia global peer discovery.quickchat_relay: Headless daemon for store-and-forward message delivery.quickchat_tui: The view. Stunning terminal interface usingratatui.quickchat_plugin_host: The WASM engine protecting you from malicious plugins.quickchat_plugin_sdk: FFI bindings for community developers.quickchat_types: Shared Protobuf definitions (message.proto).
QuickChat is infinitely extensible via WebAssembly.
The Sandbox: All plugins run inside wasmtime with WebAssembly System Interface (WASI) restrictions. They cannot read your local files or make arbitrary network requests unless explicitly granted capability-based permissions via our IPC channels.
Creating Plugins: You can write plugins in any language that compiles to wasm32-unknown-unknown (Rust recommended). Use the quickchat_plugin_sdk to interface with the host.
cargo build -p github --target wasm32-unknown-unknown --releaseDrop the resulting .wasm file into your plugins/ directory, and it will automatically intercept chat commands!
Privacy is our absolute highest priority.
- No Central Servers: There is no "QuickChat Inc." server logging your metadata.
- Perfect Forward Secrecy: OpenMLS ensures that even if a long-term key is compromised, past and future messages remain cryptographically secure.
- Zero Telemetry: QuickChat contains zero tracking, zero analytics, and zero telemetry.
- Local-First: Your chat history is encrypted and persisted locally via SQLite. You own your data.
QuickChat is unapologetically fast.
- Asynchronous I/O: Powered by
tokio, the event loop can handle thousands of concurrent DHT queries without ever dropping the 60 FPS UI render thread. - Zero-Copy Protobufs: Message payloads are framed and encoded directly into bytes without expensive memory allocations.
- QUIC vs TCP: By utilizing UDP-based QUIC multiplexing, QuickChat completely bypasses TCP Head-of-Line blocking, resulting in lightning-fast file transfers (compressed via Zstd).
We enforce a strict, zero-warning quality standard. Contributors must ensure their code passes the complete CI pipeline locally:
- Format: Ensures uniform code style.
cargo fmt --all --check - Lint: Enforces strict Rust idiomatic patterns (warnings are treated as errors).
cargo clippy --workspace --all-targets --all-features -- -D warnings - Compile: Verifies the AST compiles flawlessly.
cargo check --workspace - Test: Runs all Unit, Integration, and Cryptography tests.
cargo test --workspace - Audit: Checks for vulnerable dependency trees.
cargo audit
We love open-source contributors!
- Fork the repository.
- Create a branch for your feature (
git checkout -b feature/amazing-idea). - Write code following our strict
cargo clippystandards. - Commit your changes (
git commit -m 'feat: added amazing idea'). - Open a Pull Request. All PRs must pass the GitHub Actions CI pipeline to be merged.
Does QuickChat require servers? No. QuickChat is purely peer-to-peer. The DHT helps you find peers, but messages route directly between clients.
Is it really 100% free and open source? Yes. QuickChat is MIT Licensed and contains zero paid features, enterprise locks, or commercial limitations.
Does it work offline? Yes! If you are on an air-gapped Local Area Network (LAN), QuickChat uses mDNS to dynamically discover colleagues on the same network without needing internet access.
Which operating systems are supported? Windows, macOS, and Linux are treated as first-class citizens.
The open-source community drives QuickChat forward. Upcoming goals include:
- Asynchronous Group Joins: Enhancing community relays to hold encrypted MLS KeyPackages.
- Plugin Registry CLI: A decentralized Git-based registry to
cargo installWASM plugins directly. - Encrypted SQLite: Integrating SQLCipher for at-rest database encryption.
- Terminal Splitting: Native tmux-like pane splitting within the QuickChat UI.
If you encounter a bug or need help:
- Open a GitHub Issue.
- Join the community in GitHub Discussions.
- Submit a Pull Request.
QuickChat is released under the MIT License. Open Source Forever.