Async IDE

An open-source AI IDE Shell — Cursor alternative: Agent, Editor, Git, Terminal, all in one place.
Bring the Cursor workflow to your own machine with a fully open-source tech stack.

English | 简体中文

---

Cursor Alternative, Open Source

The goal is simple: match Cursor in features and experience — the AI-native IDE shell with Agent, Monaco editor, workspace tools, diff review, and terminal all integrated — but delivered as open source: Apache 2.0 license, BYOK model access, and local-first conversations and configuration.

You can think of it as an AI-native desktop workspace: Agent, Monaco editor, Git, diff/review flow, and terminal are all in one place, but the stack underneath is transparent and hackable. The project uses Apache 2.0 license, BYOK for model access, and keeps threads, settings, and plans local-first by default.

Aspect	undefinedCursorundefined	undefinedAsync IDEundefined
undefinedLicense / deliveryundefined	Proprietary product	undefinedOpen source codebase you can inspect and fork
undefinedModel accessundefined	Product billing / built-in integrations	undefinedBYOK for OpenAI, Anthropic, Gemini, and compatible APIs
undefinedStorage modelundefined	Product-managed workflow	undefinedLocal-first threads, settings, and plans
undefinedFocusundefined	Full IDE product	Desktop shell centered on agent workflow, editor, Git, and terminal

---

What is Async IDE?

Async IDE is an open-source AI-native desktop application designed as your command center for working with coding agents. Rather than being a chat plugin bolted onto the side of an editor, it starts from the Agent Loop and brings multi-model conversations, autonomous tool execution, and review workflows into a single workspace.

Why use Async?

• undefinedAgent-first — The agent can directly access your workspace, tools, and terminal through a clear Think → Plan → Execute → Observe loop.
• undefinedTransparent process — Streaming tool parameters (JSON rendered as it generates) + tool trajectory cards (Read, Write, Edit, Glob, Grep, Shell, etc.), so every step is visible.
• undefinedFull control — Use your own API keys, keep conversation history and repo state entirely local, with no dependency on cloud services.
• undefinedGit-native — Status, diffs, and agent-driven changes stay in sync with your actual repository.
• undefinedFour Composer modes — Agent (autonomous execution), Plan (review first, then run), Ask (read-only Q&A), and Debug (systematic troubleshooting), covering various development scenarios.
• undefinedIM bot bridge — Wire Telegram, Slack, Discord, and Feishu (Lark) into the same Agent / Team toolchain as the desktop app, with per-integration model, workspace roots, allowlists, optional HTTP proxy, and streaming replies where the platform supports it.
• undefinedLean shell — Electron + React with Agent / Editor dual layout, Monaco + embedded terminal, following the same philosophy as Cursor but with a more focused codebase.

---

Screenshots (partial)

Agent Layout

Model Settings

Appearance Color Palette

Cursor Theme

Browser tool invocation (with customizable request headers)

Multi-Agent Collaborative Expert Group

Control the entire application through external robots in a conversational manner.

All-rounder Terminal (Internal commands can be directly invoked by Agents and robots)

---

Core Features

Autonomous Agent Loop

• Streaming tool parameters with trajectory cards for clear execution visibility.
• undefinedPlan and Agent dual modes: review the plan first, or let the agent run directly.
• Approval gates for shell commands and file writes.
• Editor context sync so agent edits can focus on the relevant file and line range.
• Support for nested sub-agents, background execution, and timeline-style activity rendering.

Multi-Model Support

• Built-in adapters for Anthropic, OpenAI, and Gemini.
• Support for OpenAI-compatible endpoints like Ollama, vLLM, aggregators, or self-hosted services.
• Streaming thinking blocks on supported models.
• undefinedAuto mode to automatically pick the best available model.

Developer Experience

• undefinedMonaco editor with multi-tab support, syntax highlighting, and diff review flows.
• undefinedGit integration: status, diff, staging, commit, and push all available from the UI.
• undefinedxterm.js terminal: for both user commands and observing agent shell operations.
• undefinedComposer with @ file mentions, rich segments, and persistent threads.
• undefinedQuick Open palette (Ctrl/Cmd+P) and keyboard-first navigation.
• Built-in i18n support for English and Simplified Chinese.
• Support for local disk skills, workspace config merge, and tool approval controls.

IM / Bot integrations

Async can act as the host for coding agents on external chat surfaces, not only inside the Electron UI.

• undefinedPlatforms — Telegram, Slack, Discord, and Feishu (Lark) via dedicated adapters under main-src/bots/platforms/.
• undefinedSame runtime — Inbound messages run through botRuntime: normal threads use agentLoop, while Team mode uses the same teamOrchestrator path as the desktop Composer, including worker streaming and tool status where applicable.
• undefinedPer integration — Enable/disable, display name, default model, default Composer mode (agent / ask / plan / team), workspace root(s), optional allowlists for chats and users, and an extra system prompt on top of project rules.
• undefinedConnectivity — Optional HTTP proxy URL per platform (shared pattern for token calls and webhooks) when vendor APIs must go through a corporate proxy.
• undefinedFeishu — App credentials, optional encryption, streaming interactive cards for long-running replies, and session hygiene when integration settings change.
• undefinedConfiguration UI — Managed from Settings → Bots (SettingsBotsPanel.tsx).

For a deeper module-level walkthrough, see the maintainer-oriented notes under docs/llm-wiki/.

---

Technical Architecture

┌─────────────────────────────────────────────────────────┐
│                    Renderer Process                    │
│  React + Vite  │  Monaco Editor  │  xterm.js Terminal  │
│  Composer / Chat / Plan / Agent UI                     │
└──────────────────────────┬──────────────────────────────┘
                           │  contextBridge (IPC)
┌──────────────────────────▼──────────────────────────────┐
│                      Main Process                      │
│  agentLoop.ts  │  toolExecutor.ts  │  LLM Adapters     │
│  gitService    │  threadStore      │  settingsStore    │
│  workspace     │  LSP session      │  PTY terminal     │
└─────────────────────────────────────────────────────────┘

Tech Stack

Technology	Version	Purpose
undefinedReactundefined	^19.2.4	UI framework
undefinedElectronundefined	41.1.0	Desktop app shell
undefinedViteundefined	^6.0.3	Build tool & dev server
undefinedTypeScriptundefined	^5.9.3	Type-safe development
undefinedMonaco Editorundefined	^0.52.0	Code editor component
undefinedxterm.jsundefined	^5.5.0	Terminal emulator
undefinedOpenAI SDKundefined	^4.96.0	OpenAI API client
undefinedAnthropic SDKundefined	^0.39.0	Claude API client
undefinedGoogle Generative AIundefined	^0.21.0	Gemini API client
undefinedMCP SDKundefined	^1.29.0	Model Context Protocol
undefinednode-ptyundefined	^1.1.0	PTY terminal support

• undefinedMain / renderer IPC via Electron contextBridge and ipcMain.
• **agentLoop.ts** handles multi-round tool calls, partial JSON streaming, tool repair, and aborts.
• undefinedStructured assistant messages are persisted locally and expanded to provider-native tool formats when needed.
• undefinedLocal persistence stores threads, settings, and plans as JSON / Markdown under user data.
• **gitService** provides the Git layer used by the UI for status, diff, staging, commit, and push.
• undefinedLSP integration uses TypeScript Language Server for in-editor intelligence.

Project Structure

Async/
├── main-src/                  # Bundled -> electron/main.bundle.cjs (Node / Electron main)
│   ├── index.ts               # App entry: windows, userData, IPC registration
│   ├── agent/                 # agentLoop.ts, toolExecutor.ts, agentTools.ts, toolApprovalGate.ts
│   ├── llm/                   # OpenAI / Anthropic / Gemini adapters & streaming
│   ├── lsp/                   # TypeScript LSP session
│   ├── mcp/                   # Model Context Protocol integration
│   ├── memdir/                # Memory directory management
│   ├── bots/                  # IM bot controller, runtime, connectivity, platform adapters
│   ├── ipc/register.ts        # ipcMain handlers (chat, threads, git, fs, agent, ...)
│   ├── shell/                 # Shell command execution
│   ├── threadStore.ts         # Persistent threads + messages (JSON)
│   ├── settingsStore.ts       # settings.json
│   ├── gitService.ts          # Porcelain status, diff previews, commit/push
│   ├── workspace.ts           # Open-folder root & safe path resolution
│   ├── workspaceFileIndex.ts  # File indexing for workspace
│   ├── workspaceSemanticIndex.ts  # Semantic search indexing
│   ├── workspaceSymbolIndex.ts    # Symbol indexing
│   └── workspaceUsageStats.ts     # Workspace usage statistics
├── src/                       # Vite + React renderer
│   ├── App.tsx                # Shell layout, chat, composer modes, Git / explorer
│   ├── AgentChatPanel.tsx     # Agent chat interface
│   ├── AgentLeftSidebar.tsx   # Agent activity sidebar
│   ├── AgentRightSidebar.tsx  # Agent tools and results
│   ├── ChatComposer.tsx       # Message composer component
│   ├── EditorMainPanel.tsx    # Monaco editor panel
│   ├── SettingsPage.tsx       # Settings UI
│   ├── SettingsBotsPanel.tsx  # IM bot integrations (Telegram / Slack / Discord / Feishu)
│   ├── WorkspaceExplorer.tsx  # File explorer
│   ├── hooks/                 # Custom React hooks (19 files)
│   ├── i18n/                  # Locale messages (en / zh-CN)
│   └── ...                    # Agent UI, Plan review, Monaco, terminal, ...
├── electron/
│   ├── main.bundle.cjs        # esbuild output (do not edit by hand)
│   └── preload.cjs            # contextBridge -> window.asyncShell
├── docs/assets/               # Logo, screenshots
├── scripts/
│   └── export-app-icon.mjs    # Rasterize SVG -> resources/icons/icon.png
├── esbuild.main.mjs           # Builds main process
├── vite.config.ts             # Renderer build
└── package.json

Data Storage

Default location under Electron’s userData directory:

• undefinedasync/threads.json: threads and chat messages.
• undefinedasync/settings.json: model configuration, API keys, layout, agent options, and bots.integrations (Telegram / Slack / Discord / Feishu tokens, proxy URLs, allowlists, defaults).
• undefined.async/plans/: Markdown plan documents generated in Plan mode.

The renderer may use localStorage for lightweight UI state, but the authoritative data source for conversations is threads.json.

---

Getting Started

Prerequisites

• undefinedNode.js >= 18
• undefinednpm >= 9
• undefinedGit (recommended)

Install and Run

1. undefinedClone the repository:

   git clone https://github.com/ZYKJShadow/Async.git
   cd Async
   

   If you prefer Gitee, you can also use:

   git clone https://gitee.com/shadowsocks_z/Async.git
   cd Async
   

2. undefinedInstall dependencies:

   npm install
   

3. undefinedBuild and launch the desktop app:

   npm run desktop
   

   This will build both the main and renderer processes, then open the app with Electron.

Development

npm run dev

To open DevTools during development:

npm run dev:debug

Generate App Icon

npm run icons

This will rasterize docs/assets/async-logo.svg into resources/icons/icon.png and public/favicon.png.

---

Acknowledgements

We genuinely need to thank Claude Code for its “open-source moment” — Async IDE as an open-source alternative is, in a way, an indirect beneficiary of that.

---

Community

Have questions, ideas, or just want to chat with a community of developers?

• undefinedForum: linux.do — Join the discussion, share your setup, report issues, and stick around.

---

License

This project is open-sourced under the Apache License 2.0.