Why • Overview • Agents • Extensions • Studios • Devices • Narration • Run & Build • Download • Contributors

[!NOTE] YzPzCode is under active development. Features may be experimental or evolve between releases. Feedback, bug reports and pull requests are warmly welcomed.

⚡ Why YzPzCode?

AI-assisted development usually turns into a shuffle between terminal tabs, agents, browsers, IDEs and one-off CLIs. YzPzCode replaces the window juggling with one native command center.

🧭 Everything in one window

📸 See it in action

_{▶ Watch the full 45-second showreel with sound}

Terminal grid & workspace explorer	Multi-agent collaborative layout
Integrated multi-tab webview browser	Deep visual element & style inspector

Supported AI Coding CLIs

YzPzCode detects, launches and manages PTY sessions for 26 external AI coding agents. The core integrations:

                     ┌─── Claude (Anthropic)
                     ├─── Antigravity (Google)
                     ├─── Codex (OpenAI)
                     ├─── OpenCode
  YzPzCode Host ─────┼─── Cursor
                     ├─── Kilo
                     ├─── Hermes
                     ├─── Pi (earendil-works)
                     └─── Command Code

See the CLI integration reference for vendor install instructions, documentation and platform notes.

[!IMPORTANT] YzPzCode integrates with third-party CLIs via PTY bridges and is not affiliated with or endorsed by their respective vendors unless explicitly stated.

SaaS & Developer Tool CLIs

Installation status, executable paths and authentication state for popular cloud and developer CLIs are tracked for you:

See the Tool CLIs reference guide for workflows, common commands and authentication details.

Graphical Workspace Extensions

Run graphical coding assistants right next to your shells and agents, inside the workspace grid. Press Ctrl+Shift+X or click the Extensions icon in the header to open the catalog.

• 🎛️ Side-by-side grid layouts: panels mount inside the terminal grid with drag-and-drop reordering, interactive resizing, focus presets and split layouts.
• 📌 Editor side dock: dock a panel to the right of the editor (Ctrl+Alt+B) and move it between grid and dock without restarting it.
• 📨 Prompt handoff: send a browser-inspector selection or a UI reference straight into an assistant panel; the prompt is inserted and submitted, and the outcome shows on the panel header.
• 🌈 Activity glow: panels get the same working ring and finish effect as agent terminals.
• 📦 Zero-config managed runtime: a verified VSCodium reh-web runtime is provisioned with pinned SHA-256 digests and Open VSX packages. No VS Code or Node install needed.
• 🛡️ Hardened sandboxing: every assistant runs in an isolated child webview on its own panel-<uuid>.localhost:<port> origin with persistent storage, and cannot call Tauri host commands.
• 🔒 Workspace trust & persistence: trust approvals (workspace-trust.json) and IndexedDB workbench state (workbench-state.json) are kept per workspace.

See the graphical workspace extensions documentation for architecture, runtime specifications and validation details.

Writing, Presentation & Sheets Studios

Besides coding, the setup page's mode switch opens three document studios. They need no terminals or IDEs, run the AI through the CLIs you already have installed (Claude Code, Codex, Grok, Antigravity, OpenCode) in a headless runner, and save into one folder, Documents/YzPzCode, so reports, decks and workbooks are found again after a reinstall.

Arabic and right-to-left, first-class

Arabic, Hebrew, Persian and Urdu work in both studios: paragraph direction follows the text, printed labels (Chapter, Table, Figure, Contents…) follow the document language, Word and PowerPoint exports write real bidirectional paragraphs, and a catalog of about 150 fonts (Latin and Arabic, with bundled @fontsource faces) feeds every font picker.

Mobile Device Window

A device window slides in from the right edge of every workspace view (terminal, extensions, editor, browser) and pushes the view aside instead of floating over it, so native webviews are never covered.

• 🤖 Embedded Android emulator: create and start AVDs from the app; the screen streams into the window (gRPC frames through the shared frame-codec crate) with touch, multi-touch, keyboard, scroll, rotation, skins and screenshots.
• 🍎 iOS Simulator (macOS): discovery and lifecycle through simctl, screen and input through idb_companion. Off macOS it is reported as unavailable.
• 🐦 Flutter run bar: run the workspace's app on the chosen device with hot reload (also on .dart save), hot restart and a live log.
• 🛠️ Guided setup: Settings → Environment inspects the Flutter, Android (and Xcode on macOS) toolchain and offers one-click fixes for missing SDK parts and hardware acceleration.

Local Narration

Reports and slides can be read aloud without sending text to a cloud service. Narration runs in a managed local Python environment and downloads models on demand (Settings → Narration).

Language is detected from the text, speed is 0.75× / 1× / 1.25×, and synthesized audio is cached on disk (LRU, 500 MB cap). Narrate the selection or a section in the Writing Studio, and slides in the Presentation Studio and presenter mode.

Application Run & Build System

Launch, build and debug your applications with zero configuration. Project manifests and runnable entry points are discovered across 15+ ecosystems, right inside terminal headers.

• ▶️ One-click run & build from the terminal header with instant target switching.
• 💬 Interactive stdin console: send input to running programs (input(), scanf, Console.ReadLine()) from the terminal input bar.
• 🌐 Dev-server auto-discovery: localhost URLs in terminal output become a 1-click preview in the browser bar.
• ⚙️ Custom run configurations: commands, environment variables, arguments and working directories in Settings → Application runs, global or per workspace.

See the application runs guide for configuration schemas, multi-target switching and compiler details.

Core Features

Architecture

flowchart TB
    subgraph Frontend["React 19 + TypeScript Frontend (Vite 6)"]
        direction LR
        UI_Term["Terminal Grid\n(xterm.js 6)"]
        UI_Ext["Workspace\nExtensions"]
        UI_Editor["Code Editor\n(Monaco)"]
        UI_Browser["Browser &\nInspector"]
        UI_Image["Image Editor\n(Konva)"]
        UI_Studio["Writing &\nPresentation Studios"]
        UI_Device["Device Window\n(Android / iOS)"]
    end

    subgraph TauriHost["Tauri v2 + Rust Core Host"]
        IPC["Tauri IPC Command Router"]
        PTY["PTY & Run Engine\n(portable-pty)"]
        ExtHost["Extension Host\nManager"]
        FS["File & Git Watcher\n(notify)"]
        DevEnv["IDE / CLI Detector"]
        Writing["Headless AI Runner\n(writing)"]
        Device["Emulator / Simulator\nManagers + frame-codec"]
        TTS["TTS Manager\n(local models)"]
    end

    subgraph External["External Runtime"]
        ExtRuntime["VSCodium reh-web\n(Open VSX Host)"]
        CLIs["External AI & Tool CLIs\n(Claude, Antigravity, gh, etc.)"]
        IDEs["External IDEs\n(VS Code, Cursor, Zed)"]
        Mobile["Android Emulator\niOS Simulator"]
    end

    Frontend <==>|"Tauri IPC (Async Invokes + Events)"| IPC
    IPC --> PTY
    IPC --> ExtHost
    IPC --> FS
    IPC --> DevEnv
    IPC --> Writing
    IPC --> Device
    IPC --> TTS

    PTY <==>|"Raw PTY Stream"| CLIs
    ExtHost <==>|"Loopback HTTP / Child Webview"| ExtRuntime
    DevEnv -.->|"Process Launch"| IDEs
    Writing -->|"Headless runs"| CLIs
    Device <==>|"gRPC / simctl + idb"| Mobile

yzpzcode/
├── .github/workflows/          # CI/CD release workflows (multi-platform builds)
├── docs/                       # Guides, screenshots and README graphics (docs/readme)
└── app/
    ├── src-tauri/              # Rust backend
    │   ├── crates/
    │   │   └── frame-codec/    # Shared screen-frame codec for device streaming
    │   └── src/
    │       ├── agent/          # Autonomous agent task orchestration & retry logic
    │       ├── agent_cli/      # AI & tool CLI detection, installation & auth
    │       ├── android/        # Android SDK, embedded emulator, Flutter run & setup
    │       ├── ios/            # iOS Simulator (simctl) and idb_companion streaming
    │       ├── writing/        # Headless AI runner for the studios, PDF printing
    │       ├── tts/            # Local narration: managed env, model catalog, bridge, cache
    │       ├── browser/        # Webview management & visual inspector bridge
    │       ├── commands/       # Tauri IPC commands (~100+ endpoints)
    │       ├── extension_host/ # Embedded VSCodium web runtime manager, Open VSX & VSIX sandboxing
    │       ├── terminal/       # PTY sessions, run engine & managed commands
    │       ├── filesystem/     # Recursive watcher, transactional file sync, Git ops & diffs
    │       ├── ide/            # External IDE launcher (VS Code, Cursor, Zed, etc.)
    │       └── discord_presence/ # Discord Rich Presence integration
    │
    └── src/                    # React 19 frontend
        ├── components/
        │   ├── workspace/      # Terminal grid, extension panels, editor terminal, dock, browser, device window
        │   ├── writing/        # Writing Studio (composer, paged editor, assistant, design, references)
        │   ├── presentation/   # Presentation Studio (AI-designed decks, slide editor, presenter mode)
        │   ├── studio/         # Shared studio chrome (top bar, inspector parts, font options)
        │   ├── tts/            # Narration controls and model picker
        │   ├── editor/         # Editor tabs & rich file previews
        │   ├── explorer/       # Virtualized file tree & Git panels
        │   ├── designer/       # AI design generation studio
        │   ├── image/          # Layered canvas image editor
        │   ├── settings/       # Preferences panel
        │   └── setup/          # Interactive onboarding wizard
        ├── hooks/              # Custom React hooks (useTerminal, useBrowser, useFileWatcher, ...)
        ├── stores/             # Zustand stores (appStore, runConfigStore, extensionStore, deviceStore, ...)
        ├── utils/              # Pure, dependency-free modules (writing/, presentation/, tts/, ...) with node --test suites
        └── types/              # TypeScript mirrors of Rust structs

Download & Installation

Option 1: Pre-built binaries (recommended)

Grab the latest installer from the Releases page:

[!TIP] macOS: for an unsigned build, open with Right Click → Open, or allow it under System Settings → Privacy & Security → Open Anyway.

Option 2: Build from source

Prerequisites: Node.js 22.x or higher, the latest stable Rust toolchain (rustup update stable), and C++ build tools (Visual Studio Build Tools on Windows, Xcode CLI Tools on macOS, build-essential on Linux).

git clone https://github.com/wolfenazz/YzPzCode.git
cd YzPzCode/app

npm install            # frontend dependencies
npm run tauri dev      # development mode (port 8745)
npm run tauri build    # production installers

The compiled binaries land in app/src-tauri/target/release/bundle/.

Security & Privacy

YzPzCode is built local-first:

• 🛡️ Your code stays local: project files and source code are never uploaded to third-party servers by YzPzCode itself.
• 🔑 Locally stored secrets: API keys and tokens live only on your machine.
• 📡 Direct provider connections: requests go straight to the official endpoints of the providers you configure.
• 🔊 On-device narration: text-to-speech models run locally; nothing is sent to a speech service.

Contributing

Contributions make open source incredible. Bug reports, improvements and new features are all appreciated. Check open issues or start a discussion before proposing major architectural changes.

# Typecheck the frontend
cd app && npx tsc --noEmit

# Check Rust formatting & lints, then run Rust tests
cd src-tauri
cargo fmt --check
cargo clippy -- -D warnings
cargo test

# Frontend pure-module suites (from app/)
npm run test:writing
npm run test:presentation
npm run test:browser
npm run test:explorer
npm run test:custom-theme
npm run test:workspace-setup
npm run test:workspace-view
npm run test:device

Contributors

_{@wolfenazz · Creator & Lead Architect   |   @Noor-Al-Khelaifi · Core Contributor & Developer}

License

YzPzCode is open-source software licensed under the Apache License 2.0.