< Return_To_Databank()
Rust Dev
Mar 19, 2026

Piggy Terminal — Development Log

Author: YAER_SYSID: xx2k5x7z5 MIN READ

From "I want a better terminal" to "Agent-powered Mission Control" in one session. Screenshot: https://pbs.twimg.com/media/HDxMunxXUAEJ4rQ?format=jpg&name=large

The Starting Point

It began with a simple question: Can I build a customizable terminal app on Windows that looks like a Linux desktop? I was tired of running Claude CLI in a bare PowerShell window — no file tree, no multi-tab, no theming, no way to manage multiple Claude sessions at once.

Phase 1: Foundation (Terminal App)

We chose Tauri v2 + React + TypeScript as the stack. Tauri was the right call — 10MB binary vs Electron's 150MB+, with a Rust backend for PTY management.

Within the first hour we had:

  • A working terminal (xterm.js) connected to PowerShell via Rust's portable-pty
  • Multi-tab support with shell selection (PowerShell, WSL, CMD, Git Bash)
  • A file explorer sidebar
  • 5 built-in themes (Gruvbox, Dracula, Tokyo Night, Catppuccin, Nord)

The pixel pig mascot was born here too — first as a CSS box-shadow pixel art, then redrawn as a crisp SVG. It became the soul of the project.

Phase 2: Claude Integration

The core differentiator. We added two ways to use Claude:

  • Quick panel — Bottom panel calling claude -p for fast questions
  • Interactive tab — Full Claude CLI session in a terminal tab

This is when we discovered the real pain point wasn't "a prettier terminal" — it was managing multiple Claude sessions simultaneously.

Phase 3: The Pivot — Mission Control

This was the turning point. Instead of building yet another terminal (Wave, Warp, Hyper already exist), we pivoted to building a Claude Code operations center.

Mission Control introduced:

  • Session management — Monitor multiple Claude sessions from one dashboard
  • Activity timeline — Real-time tracking of what Claude is reading, writing, running
  • Git integration — Visual diff viewer, commit, and push without leaving the app
  • Agent system — 8 specialized agents (Developer, Reviewer, Tester, Debugger, Documenter, Refactorer, Security Auditor, Architect)
  • Pipeline automation — Pre-configured multi-step workflows that chain agents together

Phase 4: Polish

  • Windows Acrylic — Native frosted glass effect via window-vibrancy
  • Custom folder picker — Built our own instant-open folder browser (the native Windows dialog was too slow)
  • File viewer — Click any file in the explorer to view it in a tab with line numbers
  • Workspace system — Switch between projects with isolated file trees and terminals
  • Welcome screen — First-run setup that checks for Claude CLI
  • Session limits — 5 Mission Control sessions, 8 terminal tabs max

Technical Architecture

Frontend (React + TypeScript)
├── Terminal View — xterm.js + multi-tab + file explorer
├── Mission Control — Agent dashboard + pipeline launcher
├── Components — 15+ components (TerminalPane, FileViewer, GitPanel, etc.)
└── State — Zustand stores (config, layout, sessions)

Backend (Rust)
├── PTY Manager — portable-pty for shell processes
├── File System — Directory listing, file reading
├── Git Commands — Status, diff, commit, push
├── Claude Bridge — CLI detection and subprocess calls
└── Config — TOML-based persistent settings

Key Decisions

Why Tauri over Electron? — 15x smaller binary, Rust backend for PTY management, native window effects. The trade-off (WebView2 instead of Chromium) was worth it.

Why pivot from terminal to Mission Control? — Market research showed Wave Terminal and Claude Terminal already doing the "pretty terminal" thing well. Our unique angle became agent orchestration.

Why agents and pipelines? — Running Claude CLI in a terminal is powerful but unstructured. Wrapping it with pre-configured expert prompts (security auditor, code reviewer, etc.) and chaining them into pipelines turns a chat tool into a development workflow platform.

What We Built (Final Feature List)

  • Multi-tab terminal (PowerShell, WSL, CMD, Git Bash, Claude)
  • File explorer with click-to-cd and click-to-view
  • Workspace/project system with native folder picker
  • 5 themes + custom theme support
  • Claude CLI integration (quick panel + interactive sessions)
  • Mission Control dashboard
  • 8 specialized AI agents with expert system prompts
  • 4 automated pipelines (Full Feature, Bug Fix, Deep Review, Refactor)
  • Git panel (status, diff, commit, push)
  • Windows Acrylic frosted glass effect
  • File viewer with line numbers
  • Session management with limits
  • Settings panel
  • Welcome/setup screen

Lessons Learned

  1. Start building, then research competitors. We built a working prototype first, discovered competitors later, and pivoted based on what they didn't do well.

  2. The pivot was the most valuable moment. "Agent-powered CLI management" emerged from actually using the tool and feeling the pain points — not from planning.

  3. Tauri v2 is production-ready. PTY management, native dialogs, window effects, file system access — everything worked. The ecosystem is mature.

  4. Naming matters. "Claude Terminal" risked confusion with Anthropic's products. "Piggy Terminal" is distinctive, memorable, and legally safe.

What's Next

  • Pipeline execution engine (actually chain agents sequentially)
  • CLAUDE.md visual editor
  • File editing in the viewer tab
  • macOS/Linux support
  • Community agent/pipeline marketplace
  • Plugin system for custom integrations

Built with Claude (Opus 4.6) in Cowork mode. From first line of code to releasable product in a single session.

END OF TRANSMISSION.[< />]