English 中文

BitFun is a desktop-grade Agent runtime (Local Agent Runtime) and a ready-to-use suite of desktop Agent applications.

• It is the foundation—a Rust core plus a Tauri shell, with sessions, tools, memory, MCP, LSP, and remote-control protocols built in, designed for long-running use;

• It is the product—install once and you get four official Agents out of the box: Code, Cowork, Computer Use, and Personal Assistant, covering almost every mainstream Agent capability shape in the industry today.

One install: use it as an Agent, or use it as a Runtime.

BitFun aims to pack the coding power of Code Agents, the office productivity of Cowork, the assistant experience of OpenClaw, the control surface of Computer Use, and more—the most popular Agent capabilities in the industry—into one desktop app, with the full protocol stack (Agentic runtime, tools, memory, MCP, Skills, context compression, remote control) ready by default. You can use it immediately, or define your own domain Agents on top of it.

• One app, almost every mainstream Agent capability in the industry: Code / Cowork / Computer Use / document collaboration / generative UI / Mini App / MCP / remote control … No juggling multiple tools or paying for separate subscriptions for each.
• Download and run—no DIY assembly: MCP / LSP / filesystem / terminal / Git / remote SSH are all built in; configure your model and go, without spending time wiring the protocol stack from scratch.
• Your data stays on your machine: Sessions, memory, and working directories live under .bitfun/sessions/, portable, exportable, and auditable; nothing is forced to the cloud—suitable for privacy and compliance scenarios.
• Deeply customizable, with no gap from a single Markdown file to a full-repo fork: ~90% of domain needs are covered with one .md; missing a tool? a UI? want to change the product? Have the Code Agent do it inside BitFun—the way you customize it is by using it.
• Control the desktop from your phone: Pair by QR code, or use Telegram, Feishu Bot, or WeChat Bot as remote entry points. The Agent works on the desktop; you check progress on the go.
• A desktop app you can actually live with: Rust core + Tauri shell—fast cold start, low idle footprint, fine to leave running in the background for a long time.
• Self-improving: 97%+ of the code was produced by BitFun’s built-in Code Agent via Vibe Coding, so it naturally fits AI-assisted development.

New paradigms appear almost weekly in the Agent space. BitFun’s pace is: when we see something great, we ship it on the desktop and make it work seamlessly with what you already have.

Below is BitFun’s official Agent and capability inventory, plus how we track the industry’s latest Agent patterns. Zero extra setup—download and use:

Different depths of customization map to different-effort paths. Pick from light to heavy as needed:

In BitFun, an Agent = a prompt (system role + behavior constraints) + the set of tools it may call. The official Code Agent and Cowork Agent differ only in those two dimensions:

So if you want a “legal review Agent,” a “research literature Agent,” or an “ops incident Agent”—L1 is enough:

1. Write a Markdown file defining role / guardrails / workflow
2. From the tool registry, enable what it should use (files, browser, specific MCP …)
3. If a specific tool is missing—use L3: open BitFun and have the Code Agent add it in source
4. If the Agent needs a dedicated UI—use L2: one sentence to spin up a Mini App
5. If you want a completely different product—use L4: fork the repo and have the Code Agent help you reshape it

Key point: For L3 and L4 you never leave BitFun—open BitFun, tell the Code Agent what to change, and it shows you the diff. The way you customize it is by using it.

From one Markdown file to a full fork, there is no discontinuity. That is what “a self-improving foundation” means.

Desktop is built on Tauri for Windows / macOS / Linux; remote control works from mobile browsers, Telegram, Feishu, and WeChat.

Download the latest desktop installer from Releases. After installation, configure your model and start using BitFun.

Prerequisites:

• Node.js (LTS recommended)
• pnpm
• Rust toolchain
• Tauri prerequisites (required for desktop development)

Commands:

# Install dependencies
pnpm install

# Run desktop in development mode
pnpm run desktop:dev

# Build desktop
pnpm run desktop:build

For more details, see the Contributing guide.

src/crates/core         # Product logic hub: agentic / service / infrastructure
src/crates/transport    # Tauri / WebSocket / CLI transport adapters
src/crates/api-layer    # Shared handlers and DTOs
src/apps/desktop        # Tauri desktop host
src/apps/server         # Web server runtime
src/apps/cli            # CLI runtime
src/web-ui              # Shared desktop / Web frontend

Design principle: keep product logic platform-agnostic and expose it through adapters. See AGENTS.md.

We welcome great ideas and code; we are maximally open to AI-generated code. Please submit PRs directly to the main branch; we review and merge there.

Contribution directions we care about most:

1. Runtime core: session model, tool registry, memory system, protocol adapters
2. Reference Agents: capabilities and experience for Code / Cowork / Personal Assistant
3. Ecosystem: Skills, MCP, LSP plugins, Mini App templates, and new vertical Agents
4. Ideas / creativity (features, interaction, visuals)—Issues welcome

1. This project is spare-time exploration and research into next-generation human–machine collaboration, not a commercial profit-making project.
2. More than 97% was built with Vibe Coding. Code feedback is welcome; refactoring and optimization via AI is encouraged.
3. This project depends on and references many open-source projects. Thanks to all open-source authors. If your rights are affected, please contact us for remediation.