The guts of the terminal,
without the hand-waving.
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.
Your terminal is yours.
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 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 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
The technical stack
Not a buzzword tour. The actual decisions that make Chau7 responsive, inspectable, and hard to trick.
Why Rust shows up in the hot path
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 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. Those are the places where correctness and throughput meet. It is also where memory mistakes, race conditions, and “this only breaks under heavy output” bugs become expensive.
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 split is deliberate. Native macOS UI where platform fit matters. Rust where parsing and safety matter. Metal where drawing speed matters.
Dangerous commands are a parsing problem before they become a disaster
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 block
That analyzer is where Chau7 can reason about things shells normally leave to aliases, wrappers, or hope. It can normalize whitespace, spot recursive-destructive flags, detect hidden control characters, catch suspicious line breaks, and treat “this command looks dangerous” as a terminal concern instead of an afterthought in dotfiles.
This is also why the 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 Metal, why lock-free buffers, why the rest of the weirdness
Because terminals fail in very boring ways when their internals are generic.
Native GPU path
Metal is the macOS-native rendering stack. Chau7 does not need cross-platform abstraction points here. It needs fast glyph compositing and predictable redraw behavior on Macs.
No lock traffic in the handoff
The 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 for AI terminals
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 is engineered around that reality. Parsing is fast enough to keep up, buffers are simple enough not to deadlock under pressure, rendering is native enough not to wobble, and 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 use Rust in a terminal?
Rust is used where Chau7 parses PTY bytes, maintains terminal state, and evaluates command streams. That gives predictable performance for hot-path parsing while making memory and concurrency bugs dramatically less likely.
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 use Metal instead of OpenGL?
Chau7 is macOS-only, so Metal is the native graphics stack with the best long-term path for glyph rendering, dirty-region updates, and low-latency compositing on Apple hardware.