JNT: Just a normal terminal

An AI-first terminal for Windows. Split panes, a Git panel that follows every tab's directory, project-wide and in-terminal search, a live coding-agent panel, desktop notifications, and a scriptable CLI, with Windows sandboxing and encrypted history underneath.

(The name winks at its sibling, JNE, "Just a normal editor." Neither is remotely normal.)

---

Why JNT

Most terminals are a grid of text and nothing more. JNT keeps that grid fast and correct, then adds the things you normally leave the terminal to do: read git status, search your project, watch an agent work, get pinged when a long task finishes, so you stay in one window.

It's built in Rust on gpui (Zed's GPU UI framework), alacritty_terminal for VT parsing, and ConPTY for the shell.

Features

• Terminal: GPU-rendered, split panes and groups with draggable dividers, scrollback, drag-select, IME, and a clear accent frame on the focused pane.
• Git panel: branch, ahead/behind, staging with checkboxes, commit + amend, pull/push, stash, history, and a GitHub PR-status row. It follows the focused pane's directory, so cd into another repo and the panel switches with you.
• Search: Ctrl+Shift+F opens project-wide search (a Tantivy index with ripgrep live-grep); Ctrl+F finds inside the terminal scrollback with highlight and F3 navigation.
• AI agent panel: Ctrl+Shift+A runs a live ACP coding agent: streaming transcript, approve/reject permission prompts, a context-usage meter, and tool-call cards.
• Agent-aware sidebar: panes running a coding agent (Claude Code, Codex, Qwen, opencode, aider, and friends) are listed with their state. Detection reads the pane's process tree, so it works even for agents that never set a terminal title.
• Agent-native CLI: deterministic --json output, a jnt status introspection command, compound verbs, and a built-in MCP server so an agent can drive the terminal itself (see CLI).
• Notifications: pane rings, a sidebar dot, a jump-to-unread key, and native Windows toasts when a background pane needs attention. Agents ping via jnt notify.
• Crew board: Ctrl+Shift+B opens a 5-seat multi-agent kanban (Architect, Builder, QA, Security, Summarizer), persisted per project.
• Live settings: Ctrl+Shift+P edits font, theme, and ANSI colors with instant apply and save.
• Scriptable: a CLI that talks to the running window over a local socket (see CLI).
• Selectable UI: drag-select and copy text from any panel, not just the terminal; double-click for a word, triple for a line.
• Safe paste: large pastes are chunked so they can't overrun the console pipe, and a multi-line paste into a shell that would execute each line asks first — while a paste the app receives safely (bracketed paste) never interrupts you.
• Session restore: layout, dock widths, and each pane's working directory come back on relaunch.
• Secure by default: AppContainer agent sandbox, DPAPI-protected storage key, kill-on-close job objects, and XChaCha20-Poly1305 encrypted history.

Install

Download JNT-Setup-<version>.exe from the Releases page and run it. It installs per-user (no admin needed), adds JNT to your PATH, and creates a Start Menu shortcut. Re-running upgrades in place.

The installer is currently unsigned, so Windows SmartScreen will warn on first launch. Choose More info → Run anyway. Requires Windows 10 1809+ (x64).

Build from source

You need a recent Rust toolchain (see rust-toolchain.toml).

cargo run --release                 # build and launch
cargo build --release               # binary at target\release\jnt.exe

The portable library and its tests build on any host; the desktop window and the Windows security primitives are gated behind cfg(windows).

cargo test --lib                    # engine + pure UI logic

Usage

Keybindings

Key	Action
Ctrl+\ / Ctrl+Shift+\	split right / down
Ctrl+B	toggle sidebar
Ctrl+F	find in terminal (F3 / Shift+F3 next/prev)
Ctrl+Shift+F	project search
Ctrl+Shift+A	agent panel
Ctrl+Shift+B	crew board
Ctrl+Shift+P	settings
Ctrl+Shift+I / U / N	notifications / jump-unread / toggle-unread
Ctrl+Shift+K	clear scrollback
Ctrl+Shift+W	close pane
Ctrl+Alt+Arrows	move focus between panes
Ctrl+1..8 / Ctrl+Alt+[ ]	jump / cycle groups
Ctrl+= / Ctrl+- / Ctrl+0	font size up / down / reset

Right-click a terminal to copy the selection (or paste if there's none), Windows Terminal style. Double-click a tab in the sidebar to rename it.

CLI

The running app listens on a localhost port; any jnt command with a control verb talks to it:

jnt split --right [--cwd <dir>]     # split the active pane (also --down)
jnt new-group [--cwd <dir>]
jnt close-group
jnt focus --next | --prev | --group <n>
jnt send-keys "text"
jnt run <name>                      # run a [[commands]] entry in the focused pane
jnt notify "message"                # ping the focused pane (agents call this)
jnt hooks setup | show              # print agent-integration snippets
jnt status                          # JSON snapshot of the live layout
jnt mcp                             # stdio MCP server (see below)

Launch options:

jnt <dir>                           # open with <dir> as the working directory
jnt <dir> -- pwsh.exe -NoLogo       # run a program instead of your shell

For agents and scripts

The CLI is built to be driven by a coding agent, so every answer is machine-readable and one call does one job:

jnt --json split --right            # {"ok":true}  /  {"ok":false,"error":"..."}
jnt --version --json                # {"version":"0.3.1"}
jnt status                          # groups, panes, cwd, agent, panels — as JSON

jnt status reports each pane's cwd, whether it is on the alternate screen, its mouse-reporting mode, and which agent (if any) is running in it — detected from the pane's process tree, so agents that set no terminal title still show up.

Compound verbs save a round trip by doing the follow-up in the pane they just created:

jnt split --right --cwd C:\code --run build
jnt new-group --send-keys "npm test`r"

jnt mcp speaks MCP over stdin/stdout, exposing the control verbs as tools (jnt_split, jnt_new_group, jnt_close_group, jnt_focus, jnt_run, jnt_send_keys) so an agent can drive the terminal directly. Point your agent's MCP config at the jnt binary with the argument mcp.

Configuration

Config lives at %APPDATA%\JNT\config.toml (versioned TOML; invalid input never blocks startup). Sections: [theme], [theme.colors], [accessibility], [keybindings], [notifications], [opencode], and [[commands]] (custom commands you can run from the ⚡ menu or jnt run <name>, overridable per project via a jnt.json in the project root).

Defaults worth knowing: the terminal is Cascadia Mono on #0C0C0C, matching Windows Terminal's Campbell scheme.

agent_backend selects which agent transport the panel uses — "acp" (default, spawns agent_command and speaks ACP over its stdio) or "opencode" (drives a local opencode HTTP server, configured under [opencode]). Omitting both keys behaves exactly as before.

Status

JNT is a developer preview: capable enough to daily-drive on Windows, with rough edges. See Contributing to get involved.

License

Dual-licensed under either MIT or Apache-2.0, at your option.