Alera

The native, performance-first agentic development environment.
Run Claude Code, Codex, Amp, Antigravity, OpenCode, Copilot, Cursor or any other CLI agent side-by-side, each in its own Git worktree, all tracked in one place.
Built with Flutter + Rust + Ghostty. No Electron. No bundled Chromium. Available for macOS, Windows, and Linux.

Get Alera →  ·  alera.dev  ·  Roadmap

Why Alera

Agentic coding is the new bottleneck of developer tooling. Most "AI IDEs" today wrap a single chat backend inside an Electron shell: slow to start, heavy on RAM, locked to one provider, and limited to one task at a time.

Alera takes the opposite bet:

• Bring your own agent. Alera is terminal-first. Every CLI coding agent runs in its own real PTY, the way it was meant to. No proprietary chat layer, no vendor lock-in
• Run many agents at once. Each task gets its own Git worktree, its own tabs, and its own terminals, so Claude, Codex, Amp, and friends can work in parallel without stepping on each other
• Native performance. Flutter for a fast, consistent desktop UI. Rust for the PTY and process layer (portable_pty). Ghostty's VTE engine for terminal parsing. No Electron, no embedded browser, no JS event loop in the hot path
• See what your agents are doing. Lifecycle hooks for the most popular CLI agents stream their activity into Alera so you can tell, at a glance, which terminals are idle, working, or waiting on you
• Never lose a terminal again. Terminal sessions persist across restarts. Close the app, reboot the machine, come back, and your scrollback, processes, and layout are still there

Supported CLI agents

Alera works with any CLI agent. The agents below ship with first-class integration today (icons, managed lifecycle hooks, and live activity tracking):

Claude Code   Codex   Amp   Antigravity (Agy)   OpenCode   Cursor   GitHub Copilot   Pi

Anything else that runs in a terminal (Gemini CLI, Grok, Goose, Kimi, Crush, Continue, Aider, your own scripts) works out of the box. Activity tracking is incrementally rolling out per agent.

What you get today

Alera is in active development. These are the features shipping right now:

🗂️ Project & workspace registry

Register existing local folders or clone Git repositories from one place. Git-backed projects can spin up multiple workspaces backed by real Git worktrees: one branch, one task, one experiment per workspace, fully isolated.

🌳 Worktree-native workflow

Every workspace is a worktree. No stashing, no branch juggling, no "wait, what was I working on?". Switching contexts is instant, and your agents never collide on the same files.

🤖 Multi-agent terminals

Open multiple terminals per workspace, organised in tabs. Run Claude Code in one, Codex in another, Amp in a third, all in parallel and all visible at the same time. Each terminal is a full PTY backed by Rust (portable_pty) and parsed by Ghostty's VTE.

📡 Live agent activity tracking

Managed lifecycle hooks for Claude, Codex, Amp, OpenCode, Antigravity, Cursor, Copilot and Pi stream agent events into Alera. You can see which agents are idle, working, or waiting on input without staring at every terminal.

💾 Persistent terminal sessions

Close Alera. Reboot. Reopen. Your terminals, their scrollback, their layouts, and the processes you launched are still there. Long-running agent runs survive restarts instead of vanishing with the window.

🎨 Terminal customization

Per-terminal configuration: font, size, theme, behaviour. Built on top of the same engine that powers Ghostty for predictable, high-fidelity rendering.

🖥️ Truly native, truly cross-platform

One codebase, three real desktops. Native window chrome, native keyboard shortcuts (⌘ on macOS, Ctrl elsewhere), dark-mode-first UI built on the Alera design system. No Electron, no embedded browser, no 400 MB install.

🔄 Built-in update channel

Stable and release-candidate update channels with a manual download flow today, signed automatic installs as platform trust requirements land.

What's next

Alera is shipping fast. A non-exhaustive list of what's on the roadmap:

• SSH worktrees: run agents on remote machines as if they were local
• Mobile companion app: monitor and nudge your agents from your phone
• File explorer, search, and diff panels: review and edit AI-generated changes without leaving Alera
• Git operations UI: stage, commit, push, resolve conflicts visually
• Embedded browser & browser use: give agents a real browser to drive
• GitHub / GitLab / Linear / CI integrations: PRs, issues and checks linked per worktree
• Orchestration between agents: inter-agent messaging, task dispatch, coordinator loops
• Voice, automations, MCP management, skills, and more

See the full roadmap for the complete picture, including difficulty/utility scoring per feature.

Install

Public release artifacts and download links are being finalized. Track releases on GitHub or visit alera.dev for the latest.

Run from source

Alera is a Flutter desktop app. You'll need a recent Flutter SDK and a working Rust toolchain (rustup). The Rust workspace under rust/ provides both the native terminal-host sidecar (alera-cli) and the git layer (alera_native, compiled into the app through flutter_rust_bridge).

git clone https://github.com/leynier/alera.git
cd alera
git submodule update --init third_party/xterm third_party/dart_terminal
flutter pub get

# Pick your platform:
flutter run -d macos
flutter run -d windows
flutter run -d linux

By default a local build runs as Alera Dev (dev.leynier.alera.dev) so it can coexist with an installed release without sharing user data. Set ALERA_FLAVOR=release to opt back into the release identifier.

Regenerate the flutter_rust_bridge bindings after changing the Rust API (rust/src/api) with make frb-generate.

Performance & architecture

Alera is built around three deliberate engineering choices:

╭──────────────────────────╮      ╭──────────────────────────╮      ╭──────────────────────────╮
│         Flutter          │      │           Rust           │      │      Ghostty VTE         │
│    Native desktop UI,    │ ───> │   PTY + process layer    │ ───> │    Terminal parser &     │
│   shell, design system   │      │    via portable_pty      │      │  renderer (no Electron)  │
╰──────────────────────────╯      ╰──────────────────────────╯      ╰──────────────────────────╯

• Flutter for the desktop shell, design system, and UI: fast startup, consistent look across macOS / Windows / Linux, fully native rendering
• Rust for the PTY and process boundary through portable_pty, so spawning, signalling, and resizing real terminals stays predictable on every OS
• Ghostty's VTE through ghostty_vte_flutter for terminal parsing: the same engine that powers the Ghostty terminal emulator
• Drift / SQLite for local persistence of projects, workspaces, tabs, layouts, settings, and terminal state
• No Electron, no Chromium, no Node runtime in the app, and no plan to add them

For more, see docs/architecture.md.

Inspired by great open source projects

Alera stands on the shoulders of brilliant work in the agentic dev and terminal space. Special thanks to:

• Orca: the primary inspiration for worktree-oriented, multi-agent product thinking
• Ghostty: the bar for fast, high-quality terminal experiences
• xterm.js: ecosystem reference for terminal compatibility
• Flutter: the foundation that makes Alera's cross-platform desktop UI possible
• Drift and desktop_updater: used for local persistence and desktop update plumbing

Developing

Want to contribute or hack on Alera locally? Start with:

• AGENTS.md: contributor and agent governance rules
• docs/architecture.md: architecture glossary and naming rules
• docs/testing.md: unit, widget, golden, E2E, and coverage workflow
• docs/ui-styleguide.md: design tokens and UI rules

Project layout

• lib/src/app: bootstrap, dependency providers, theme setup
• lib/src/shared: shared infrastructure (process, storage, helpers)
• lib/src/features/projects: project registry and project sidebar UI
• lib/src/features/workbench: workspaces, tabs, split layouts, terminal runtime
• lib/src/features/agent_status: agent lifecycle hooks and activity tracking
• lib/src/features/updater: update archive parsing and desktop updater integration
• lib/src/features/shell: top-level application shell
• lib/src/design_system: shared Alera UI components

Checks

flutter analyze
flutter test --coverage --exclude-tags golden
dart run tool/quality/coverage_report.dart --input coverage/lcov.info --min-lines 65 --worst 25

Use flutter test --tags golden for visual regression tests and flutter test integration_test -d macos for local desktop E2E smoke coverage. See docs/testing.md.

Desktop flavors

Alera builds in two flavors selected by ALERA_FLAVOR:

See lib/src/core/build_flavor.dart for the canonical strings.

Releases and updates

Public release cuts are maintainer-managed through GitHub Actions. Stable builds can detect new releases and open the manual download page; automatic stable installation stays disabled until release builds are signed and trusted for the target platform. Release-candidate builds may opt into automatic installation through explicit build flags.

• Stable manifest: https://updates.alera.build/app-archive.json
• Release-candidate manifest: https://updates.alera.build/app-archive-rc.json
• Updater payloads are hosted in Cloudflare R2 under updates/stable/ and updates/rc/
• GitHub Releases remain the manual download surface

Community & support

• ⭐ Star this repo to follow along. Alera ships often
• 🐛 Found a bug or want a feature? Open an issue
• 🌐 Website: alera.dev
• 📜 License: see LICENSE
• 🛡️ Security: see SECURITY.md
• 🤝 Code of conduct: see CODE_OF_CONDUCT.md

Reference projects

Reference projects live under reference_projects/ and are non-runtime references for agentic development and orchestration patterns. Alera remains terminal-first and does not depend on any reference project at runtime.