Terax: a 7 MB terminal-first AI workspace built on Tauri 2 and Rust

The gap Terax targets: a terminal that can hand work to an agent

Most AI coding tools assume the editor is the centre of the session. Terax inverts that. The README calls it a terminal-first AI-native development environment, and the feature list backs the claim: the terminal is the primary surface, with a code editor, file explorer, source control and web preview arranged around it. The intended user is someone who already drives a shell, keeps a dev server in a tab, and wants an agent to read and edit files without leaving that context.

The pitch rests on size and control. The README states the app is about 7-8 MB on disk, with no telemetry and no account. AI runs against your own keys or a local model. That combination is the actual differentiator: a desktop binary small enough to install casually, and an AI layer that never routes through a vendor-hosted account.

What the Tauri 2 and Rust architecture buys you

Terax is a Tauri 2 application. The frontend is React 19 plus TypeScript; the native layer is Rust under src-tauri. The terminal is not a web emulation of a shell: the README describes a native PTY backend via portable-pty, with xterm.js and a WebGL renderer on top. Shells listed are zsh, bash, pwsh, fish and cmd.

The AI layer is assembled from the Vercel AI SDK provider packages visible in package.json: @ai-sdk/openai, @ai-sdk/anthropic, @ai-sdk/google, @ai-sdk/groq, @ai-sdk/xai, @ai-sdk/cerebras and @ai-sdk/openai-compatible, with @ai-sdk/react on the UI side. That explains the BYOK provider list in the README. Local inference is reached through LM Studio, MLX or Ollama rather than a bundled runtime, so the model weights stay outside the app.

The editor is CodeMirror 6, not a custom text buffer. Language server support is opt-in, and the README notes it covers diagnostics, navigation, completion and formatting, including custom servers. Two design choices stand out. Spaces restore tabs, working directories and split layouts across launches, which is state persistence rather than session replay. On Windows, WSL is treated as a first-class workspace environment rather than a wrapped subprocess, and per-tab workspace environments can be Local or any installed WSL distro.

Installing Terax and running a first agent task

The README points to the Releases page for installers and states that Terax auto-updates from there. There is no package-manager command for macOS or Windows in the README; Linux users get three documented routes.

On Arch, the README gives the AUR package, which tracks the latest release:

yay -S terax-bin

On NixOS or plain Nix, the README points at the official flake. For a non-NixOS machine:

nix profile install github:crynta/terax-ai

For NixOS, the README says to import the flake and add inputs.terax.packages.${pkgs.system}.terax to environment.systemPackages, and notes that a nixosModules.terax output exists for a simpler setup. If you take the AppImage route instead, it needs FUSE; without it the README gives this fallback:

./Terax_*.AppImage --appimage-extract-and-run

The README also records two graphical caveats: on Wayland with rendering glitches, try WEBKIT_DISABLE_DMABUF_RENDERER=1, and the .deb and .rpm packages link against the system GTK stack, which the README says tend to be smoother than the AppImage.

With the app open, configure the AI: Settings -> AI, pick a provider, paste an API key. For local inference, point Terax at your LM Studio, MLX or Ollama endpoint. The README states keys are written to the OS keychain. Then open a terminal tab and start a task from the AI side-panel. The agent's toolset, as documented, is file read, write, edit, multi-edit, grep and glob, plus bash with approval gating and background processes. Plan mode generates a plan and confirms before acting, and edits surface as diffs in the editor that you accept or reject hunk by hunk. Project memory lives in TERAX.md.

Where Terax stops being the right tool

The AI panel is not an autonomous runner. Bash execution is approval-gated by design, and plan mode confirms before doing work. If your workflow depends on an agent that edits and runs unattended for long stretches, Terax adds a human checkpoint at each step, and that is a deliberate constraint rather than a missing toggle you can find in the README.

The editor is CodeMirror 6 with opt-in language servers, not a full IDE platform. There is no extension marketplace in the feature list, so tooling that depends on a rich plugin ecosystem has no equivalent here. The README documents Vim mode and a set of built-in themes, but nothing about plugin authoring.

Release cadence is another boundary. The recent releases are v0.8.6, v0.8.5 and v0.8.2, dated 2026-07-27, 2026-07-10 and 2026-06-23, while package.json reports version 0.9.0-beta. The README does not document a rollback path for a bad auto-update, and it does not document a stable-versus-beta channel split. If you need a signed, slow-moving channel, that gap is unresolved in the published documentation.

Finally, the AI surface is only as good as the endpoint behind it. Terax ships no model. With a local LM Studio or Ollama setup, quality and latency are yours to manage, and the README gives no guidance on which local models work well with the tool-calling agent loop.

Terax versus running an agent inside VS Code

The obvious alternative is a full editor with an agent extension, VS Code being the common case. The difference is architectural, not cosmetic. VS Code carries an extension host and a large install footprint; Terax is a Tauri binary of roughly 7-8 MB whose only bundled surfaces are the terminal, editor, explorer, source control and preview panes.

That cuts both ways. In VS Code, the terminal is one panel among many and the agent usually lives inside the editor. In Terax, the PTY is the anchor and the agent sits alongside it, which matters if your work is mostly commands, dev servers and git rather than long editing sessions. The cost is everything the extension ecosystem provides: debuggers, remote development, language tooling you install once and forget.

A second alternative is a terminal multiplexer plus a separate CLI agent. That keeps your existing shell configuration and costs nothing to try, but you assemble the pieces yourself. Terax's argument is integration: the same window holds the agent, the file explorer it reads from, and the git graph where its edits land.

Licence, maintenance and what upgrading costs

Terax is Apache-2.0, both in the repository metadata and in package.json. That is a permissive licence with an explicit patent grant, and it lets you fork and redistribute. It does not give legal advice, and if you plan to ship a modified build, read the LICENSE file in the repository rather than this summary.

The repository is not archived, and the last push was on 2026-09-14. The release history shows a cadence of roughly two to three weeks between v0.8.2 and v0.8.6, and package.json already reports 0.9.0-beta, so work is continuing on the main branch between tagged releases.

Upgrade cost is low on paper: the README states Terax auto-updates from the Releases page, and the AUR package tracks the latest release. The practical cost is behavioural drift in a pre-1.0 tool. Settings that live in the OS keychain, project memory in TERAX.md, and Spaces state are the things most likely to need attention across versions, and the README does not describe a migration path for any of them.

Building from source is a separate commitment. package.json declares pnpm@11.9.0 and requires Node >= 22, and the repository is a pnpm workspace with src-tauri and packages directories. The scripts include tauri, build, test and check-types, plus a size-limit check, so the project tracks its own bundle size as part of the build.

Editorial conclusion

Adopt Terax if you live in a terminal, already pay for an OpenAI, Anthropic or Google key, and want the agent panel to sit next to a real PTY instead of replacing it. Skip it if you need a mature extension ecosystem, a signed stable channel, or a codebase small enough to audit in an afternoon; the repository ships a pnpm workspace with src-tauri and packages, and package.json reports version 0.9.0-beta. Before you commit, verify three things yourself: that your target OS package (AppImage, .deb, .rpm, the AUR terax-bin package, or the Nix flake) starts on your machine, that Settings -> AI accepts your provider key and stores it in the OS keychain, and that your preferred shell appears in the default shell detection order.

Frequently asked questions

Official sources

1. crynta/terax-ai on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases