Contact
Showcase

Ultra IDE

The AI-Powered Terminal Code Editor

All the power of VS Code, none of the bloat. Ultra is a blazingly fast terminal-native editor with AI built-in. Works anywhere—even over SSH.

<100ms Startup Time
~50MB Memory Usage
0 Human-Written Lines
Visit ultra.dev Work With Us
ultra ~/projects/api
$ ultra .
Ultra v0.5.0 — Opening project...
✓ 47 files indexed
✓ TypeScript LSP connected
✓ Session restored
Why Ultra

Everything You Need. Nothing You Don't.

Ultra combines the ergonomics of Sublime Text with the power of VS Code, wrapped in a blazingly fast terminal interface.

🖥️

Terminal Native

Works in any terminal, over SSH, in tmux. No GUI, no Electron—just pure terminal power with 24-bit true color support.

🤖

AI Built-In

Claude, Codex, and Gemini are integrated directly. Get intelligent code suggestions and assistance without leaving your editor.

Ctrl+Shift+A
⚙️

VS Code Compatible

Your settings, themes, and keybindings work immediately. Migrate in seconds with familiar JSONC configuration.

🔧

Full LSP Support

Autocomplete, go-to-definition, find references, hover info, and diagnostics for all your languages.

Ctrl+Space
📦

Git Integration

Stage, commit, and view diffs without leaving the editor. Inline markers show changes at a glance.

Ctrl+Shift+G
💾

Session Persistence

Ultra remembers everything. Open files, cursor positions, pane layouts, and even AI conversations.

Architecture

Built on the Editor Command Protocol

Ultra's modular architecture routes everything through ECP—a JSON-RPC 2.0 protocol that makes it infinitely extensible and automation-ready.

ECP Editor Command Protocol
📄 Document
📁 File System
🔧 LSP
📦 Git
💻 Terminal
🗄️ Database
🎨 Syntax
⚙️ Session

Unified API

Every operation flows through the same protocol. Build tools, scripts, or integrations with a single, consistent interface.

Service Isolation

Each service is independent and testable. Add new capabilities without touching existing code.

Automation Ready

Script any editor action programmatically. The same commands that power the UI are available for extension.

Deep Dive

Three-Layer Design

ECP separates the editor into distinct layers that communicate via JSON-RPC, enabling multiple UI implementations to interact with shared backend services.

1

Clients

TUI, future GUI clients, and headless testing—all using the same protocol

2

ECP Server

Central JSON-RPC router directing requests to appropriate service adapters

3

Services

Stateful backend components handling document editing, files, git, LSP, and more

Method Routing
document/*  → DocumentService
file/*      → FileService
git/*       → GitService
lsp/*       → LSPService
terminal/*  → TerminalService
database/*  → DatabaseService

Data Flow

  1. Terminal captures keystroke
  2. Client determines action from keybinding
  3. JSON-RPC request sent to service
  4. Service modifies state, emits events
  5. Render scheduler batches and displays
Performance

Piece Table Buffers

Ultra uses the same data structure as VS Code for text buffers. Instead of modifying text directly, a piece table maintains references to the original file and an append-only buffer of additions.

O(log n) Insert/Delete
O(1) Undo/Redo
Instant Large File Open
Original:
Hello World
After edit:
Hello Beautiful World
Undo:
Hello Beautiful World
Rendering

Terminal Rendering Pipeline

📋

Render Scheduler

Batches rapid state changes, deduplicates by ID, orders by priority

→
🎨

Component Render

Each component paints to ScreenBuffer, tracking changed cells

→
📤

Buffer Flush

Only dirty cells written out with optimized cursor movement

→
🖥️

Terminal Output

ANSI escape sequences sent to stdout with 24-bit color

Dirty Cell Tracking

Rather than redrawing everything, Ultra maintains a dirty boolean grid. When a cell changes, it's marked for output. During flush, only changed cells generate ANSI sequences—preventing the performance drain of full-screen rewrites.

Remote Development

Works Everywhere—Even Over SSH

Ultra runs entirely in your terminal, which means it works seamlessly over SSH. Edit files on remote servers with the same experience as local.

  • No port forwarding or tunneling required
  • Full feature set over any SSH connection
  • Works inside tmux, screen, and mosh
  • Sub-100ms latency even on slow connections
  • Session persistence across disconnects
💻 Terminal
local $ ssh dev@server.example.com
Welcome to Ubuntu 22.04
server $ ultra ~/projects/api
Ultra v0.5.0 — Opening project...
✓ 47 files indexed
✓ TypeScript LSP connected
Comparison

How Ultra Stacks Up

Feature Ultra VS Code
Terminal Native ✓ ✗
Works over SSH Native Extension
Built-in AI Claude, Codex, Gemini Extension
Startup Time <100ms 2-5s
Memory Usage ~50MB ~500MB
Runtime Bun Electron
The Methodology

Built with the CCA Framework

Ultra was built entirely using Claude through the CCA (Coder/Critic/Arbiter) Framework—zero lines of human-written code. This methodology is now available to help other teams build AI-powered applications.

C

Coder

AI generates code from natural language specifications

C

Critic

AI reviews and identifies issues in generated code

A

Arbiter

Human guides direction and makes final decisions

Conversational Development

Describing features in natural language and iterating through dialogue

Structured Prompting

Techniques for getting consistent, high-quality code output

Iterative Refinement

Building complex systems through progressive enhancement

Quality Assurance

Ensuring AI-generated code meets production standards

Experience Ultra

A terminal-native IDE that proves AI can be a true development partner.

Visit ultra.dev Discuss Your Project