The guts of the terminal,
without the hand-waving.
Chau7 is powered by Rust for parsing, Metal for GPU rendering, and Swift + AppKit for native macOS UI.
100% local. Your data never leaves your Mac. Rust where bytes turn into decisions, Metal where pixels need to move now, and rich telemetry that belongs to you alone.
Does Chau7 send data to the cloud? No.
Chau7 does not send any data to the cloud. Chau7 tracks everything about your AI usage. Tokens, costs, sessions, latency, tool calls. But all of it is yours. None of it leaves your Mac.
Rich telemetry. Zero exfiltration.
Chau7 gives you detailed telemetry: token counts per call, cost per session, latency trends, AI tool call history, session recordings with millisecond timestamps. That data is genuinely useful. It's also genuinely local.
The Chau7 API cost proxy intercepts LLM traffic on your machine to count tokens and estimate costs. It does not forward, store, or report that data anywhere except your local filesystem.
The Chau7 MCP server runs over a Unix socket. Session recordings are local files. Settings are local files. Every byte of telemetry Chau7 collects is written to your disk and nowhere else.
There is no account to create because there is no server to talk to. We could not see your data even if we wanted to. We designed it that way on purpose.
Core technical choices
What technology powers Chau7 terminal?
Not a buzzword tour. The actual decisions that make Chau7 responsive, inspectable, and hard to trick.
Why does Chau7 use Rust instead of pure Swift?
Because terminals are mostly bytes, timing, and state transitions. That is exactly where “we'll be careful” stops being a strategy.
Rust is not there for branding
Chau7 uses Rust instead of pure Swift for the performance-critical parsing layer. Swift handles macOS UI, windowing, and tab management beautifully. But the hot path, where raw PTY data becomes terminal state, where ANSI escape sequences need to be parsed quickly, and where command streams need to be inspected without introducing UI jank, needs stronger memory safety guarantees than Swift alone provides.
Rust gives Chau7 compile-time guarantees against data races, use-after-free, and buffer overflows in the parsing layer. Swift's ARC model handles UI lifecycle well, but terminal byte parsing requires the kind of zero-cost abstraction and fearless concurrency that Rust was designed for.
That matters for AI-heavy workflows because AI CLIs are not polite terminal citizens. They dump huge logs, redraw frequently, stream output in bursts, and sometimes paste command text you really want to inspect before it runs. Rust gives Chau7 a safer place to do that work while still staying close to the metal.
Where Swift ends, where Rust begins, where Metal takes over
The Chau7 technology split is deliberate. Native macOS UI where platform fit matters. Rust where parsing and safety matter. Metal where drawing speed matters.
How does Chau7 detect dangerous commands before execution?
Chau7 detects dangerous commands before execution by inspecting the command stream at the terminal input layer, before the shell runs anything. If you want to flag rm -rf, suspicious dd, hidden Unicode junk, or pasted multi-line nonsense, you need to inspect the command stream before the shell gets clever.
Keyboard / Paste
│
▼
Input Intercept Layer ─────── shell-agnostic
│
▼
Rust Command Analyzer ─────── tokenize, normalize, inspect
│
├── safe command ───────────────▶ pass through
│
└── dangerous pattern ─────────▶ warn, confirm, or blockThe Chau7 command analyzer is where Chau7 terminal can reason about things shells normally leave to aliases, wrappers, or hope. Chau7 normalizes whitespace, spots recursive-destructive flags, detects hidden control characters, catches suspicious line breaks, and treats “this command looks dangerous” as a terminal concern instead of an afterthought in dotfiles.
This is also why the Chau7 dangerous-command guard belongs on a page about the core tech stack. It is not merely a UX feature. It exists because Chau7 is architected to parse and understand terminal input at the right layer.
- Destructive recursion: patterns like
rm -rf, recursive ownership changes, and commands aimed at the wrong root. - Device-level footguns: suspicious
dd, disk formatting tools, and commands that can trash volumes faster than the prompt can apologize. - Pasted trickery: hidden Unicode, zero-width characters, line continuations, and multi-line payloads designed to look safer than they are.
- Shell-agnostic normalization: inspect the submitted command stream before aliases, prompt themes, or shell-specific cleverness can hide intent.
Why does Chau7 use Metal instead of OpenGL for rendering?
Chau7 uses Metal instead of OpenGL because Chau7 is macOS-only and Metal is Apple's native, actively maintained GPU framework. OpenGL is deprecated on macOS. Terminals fail in very boring ways when their internals are generic.
Native GPU path, not deprecated OpenGL
Metal is the macOS-native rendering stack. Apple deprecated OpenGL on macOS in 2018. Chau7 does not need cross-platform abstraction points here. Chau7 terminal needs fast glyph compositing and predictable redraw behavior on Apple hardware, and Metal delivers that without the overhead of a compatibility layer.
No lock traffic in the handoff
The Chau7 PTY reader and parser have one job each. The SPSC queue lets them do that without negotiating every packet like coworkers scheduling a meeting.
Atomic state swaps
Triple buffering keeps rendering from reading half-written terminal state. No torn frames, no partial updates, no “close enough” approach to terminal correctness.
Why this matters when you're running multiple agents
AI tools stress every weak layer
Claude Code, Codex, Aider, and friends generate long bursts of output, redraw continuously, paste commands, and trigger edge cases that ordinary shell use only hits once a month. A terminal that is “fine most of the time” feels terrible under that load.
Chau7 terminal is engineered around that reality. Chau7 Rust parsing is fast enough to keep up. Chau7 lock-free buffers are simple enough not to deadlock under pressure. Chau7 Metal rendering is native enough not to wobble. And Chau7 command inspection happens early enough to catch destructive mistakes before they turn into stories you tell in a postmortem.
Frequently asked questions
Does Chau7 send any data to the cloud?
No. Chau7 tracks tokens, costs, sessions, and AI telemetry in detail, but all of that data stays on your Mac as local files. There are zero network requests to any Chau7 server. No crash reporting, no analytics callbacks, no update checks. The only network traffic is whatever your shell and AI tools generate themselves.
Why does Chau7 use Rust instead of pure Swift?
Chau7 uses Rust instead of pure Swift for the parsing hot path because Rust provides compile-time guarantees against data races, use-after-free, and buffer overflows. Swift handles Chau7 macOS UI, windowing, and tab management. Rust handles PTY byte parsing, terminal state, and command stream evaluation, where predictable performance and memory safety under heavy AI workloads matter most.
How can Chau7 flag dangerous commands before execution?
Chau7 inspects command text at the terminal input layer before the shell executes it. That lets it match destructive patterns such as rm -rf, suspicious pasted payloads, hidden Unicode characters, and multi-line trick commands regardless of shell aliases or prompt themes.
Why does Chau7 use Metal instead of OpenGL?
Chau7 uses Metal instead of OpenGL because Chau7 is macOS-only and Apple deprecated OpenGL on macOS in 2018. Metal is the native, actively maintained graphics stack with the best long-term path for glyph rendering, dirty-region updates, and low-latency compositing on Apple hardware. There is no reason for Chau7 to use a deprecated cross-platform API when the native option is faster and better supported.