BerryCode - The IDE Built for Bevy

English | 日本語

---

English

The first IDE purpose-built for the Bevy game engine.

BerryCode is not a general-purpose editor with Bevy plugins bolted on — it's an IDE designed from the ground up for Bevy development. Built entirely in Rust with Bevy + bevy_egui + WGPU, it understands Bevy's ECS architecture, scene format, and development workflow natively.

Why not just use VS Code? VS Code treats Bevy as "just another Rust project." BerryCode treats Bevy as a first-class game engine — with a built-in Scene Editor, ECS Inspector, System Graph, and more. No extensions needed.

Demo

Screenshots

Scene Editor	Game Runtime

ECS Inspector	Git Integration

Code Editor + AI Chat

What Makes BerryCode Different

Feature	VS Code + Extensions	BerryCode
Scene editing	Text-only .scn.ron	Visual 3D viewport with gizmos
ECS inspection	None	Live entity/component/resource browser
System ordering	None	Visual system dependency graph
Bevy events	println! debugging	Real-time event monitor
Play in editor	Switch to terminal	Run with integrated console output
Bevy templates	Manually type boilerplate	One-click Component/System/Plugin generation
Plugin discovery	Search crates.io manually	Built-in Bevy plugin browser
Built with	Electron (web tech)	Bevy + WGPU (same stack as your game)

Bevy-Native Tools

These tools understand Bevy's architecture — they're not generic wrappers.

Scene Editor (Unity-class)

• 3D viewport with translate/rotate/scale gizmos (W/E/R)
• VS Code-style panel headers and compact toolbar layout
• Entity hierarchy with file-tree-style rendering (Codicon icons, full-row selection, indent guides)
• Inspector with type-aware component editors (Vec3, Color, Handle, etc.)
• Prefab system — create, instantiate, override
• Multi-scene tabs with independent undo/redo
• Export to .scn.ron (Bevy native) or .bscene (binary)

ECS Inspector

• Connect to a running Bevy app via BRP (Bevy Remote Protocol)
• Browse entities, components, and resources in real-time
• Filter and search by component type
• Auto-refresh with connection status indicator

System Graph

• Visualize system execution order and dependencies
• Identify bottlenecks and ordering issues
• Understand schedule topology at a glance

Event Monitor

• Real-time log of all Bevy events
• Filter by event type
• Inspect event payloads

Query Visualizer

• See which entities match a given query
• Performance metrics per query
• Optimization hints

State Editor

• View and manage Bevy States enum variants
• Manually trigger state transitions for testing

Bevy Templates

• Generate Component, Resource, System, Plugin, Event, State boilerplate
• Dynamic field/parameter input
• Insert directly at cursor position

Plugin Browser

• Search crates.io for Bevy-compatible plugins
• View metadata (version, downloads, description)
• One-click add to Cargo.toml

Animation System

• Timeline editor with keyframe scrubbing
• Dopesheet for per-property keyframe editing
• Animator editor with clip selection and blend controls

Additional Scene Tools

• Visual Scripting (node-based, Blueprint-style)
• Shader Graph editor with live preview
• Material preview with PBR properties
• Terrain editor, Skeleton/Rig editor, Navmesh generator
• Physics simulator, Particle preview

Also a Full-Featured Code Editor

BerryCode isn't just Bevy tools — it's a complete Rust IDE.

• LSP — completions, hover, go-to-definition, references, diagnostics, format, rename, code actions, inlay hints, macro expansion
• Syntax highlighting — Rust, Python, JavaScript, C/C++, TOML, Markdown (Tree-sitter + Syntect)
• Vim mode — full modal editing (Normal, Insert, Visual, Command, Replace) with operators, text objects, registers, marks, dot repeat
• Terminal — iTerm2-class PTY emulator (VT100/xterm, ANSI 256 colors, 10K scrollback, multi-tab)
• Git — 6-tab panel (Status, History, Branches, Remotes, Tags, Stash) with commit graph and diff viewer
• Search — project-wide regex search with parallel execution (Rayon)
• Debugger — variables, call stack, watch expressions, breakpoints (DAP)
• AI Chat — integrated LLM assistant via gRPC
• Minimap, code folding, snippets, image/3D model preview, test runner

Local-first AI with Llama 3 (60 seconds)

BerryCode runs end-to-end on a local Llama 3 with no API keys, no rate limits, and no code leaving your machine. Useful for offline work, privacy-sensitive projects, and teaching kids to code without cloud dependencies.

# 1. Install Ollama and pull Llama 3.3
brew install ollama
ollama pull llama3.3

# 2. Run the Ollama server (background)
ollama serve

1. Open BerryCode → Settings → AI Providers → Ollama (local) → click Use Llama 3 (local).

That's it. Chat sidebar, inline completions, and Autonomous (🤖 Agent) mode all run against the local model. BerryCode auto-injects a Llama-tuned Bevy 0.18 cheatsheet into the system prompt to compensate for the spots Llama gets wrong (Rust-vs-Python syntax slips, EventReader → MessageReader rename, tool-call envelope shape).

If you have a smaller machine, swap llama3.3 for llama3.1:8b in the Settings model field — same flow, lower memory.

Install

Pre-built binaries (recommended)

Grab the latest release artifact for your platform from the Releases page:

Platform	Artifact
macOS (Apple Silicon + Intel)	BerryCode-<version>-macOS-universal.dmg
Linux (x86_64)	berrycode-<version>-linux-x86_64.tar.gz
Windows (x86_64)	berrycode-<version>-windows-x86_64.zip

Releases are signed with Sigstore (.sig + .pem files alongside each archive). Windows ZIPs are additionally code-signed via SignPath so SmartScreen doesn't flag the binary.

Package managers

# macOS / Linux — Homebrew
brew install berrycode

# Windows — winget
winget install KyosukeIshizu1008.BerryCode

# Linux — Snap
sudo snap install berrycode

# Linux — Flatpak
flatpak install flathub dev.berrycode.BerryCode

# Cargo (any platform with Rust 1.75+)
cargo install berrycode

Build from source

git clone https://github.com/KyosukeIshizu1008/berryscode
cd berryscode
cargo run --bin berrycode               # debug
cargo build --release --bin berrycode   # release

AI features (chat, Native agent, Codex CLI / Claude Code fallbacks) are built into the binary — bring your own API key in Settings (Cmd+,) under the AI section.

Prerequisites: Rust 1.75+ | Linux: libx11-dev libasound2-dev libudev-dev libpipewire-0.3-dev

After cloning, enable the rustfmt pre-push hook so the Linux CI fmt check can't reject your push:

git config core.hooksPath .githooks

Roadmap

BerryCode ships in monthly releases. The big picture:

Phase	Versions	What we're building
Editor	v0.4 – v0.7	A solid Bevy IDE foundation (✅ shipped)
Runtime	v0.8 – v0.9	Ship to mobile, then connect players online
Publishing	v0.10 – v0.12	Game data, testing, store integration, i18n
Team scale	v1.0	Multi-developer collaboration

✅ Shipped (v0.4 → v0.7)

Highlights of what's already in the latest release:

• Editor core (v0.4): Rust LSP with completion details + signature help, IME preedit in the source editor, settings UI for keybindings & themes
• AI integration (v0.4.5): BYOK chat for Anthropic / OpenAI / Ollama, in-process Native agent (Responses-API tool-calling — read_file / write_file / list_files / run_bash), Codex CLI / Claude Code as fallback, Cmd+L chat sidebar, Approve / Reject diff cards, @file attachments, 3-way merge guard, Bevy 0.18 cheatsheet injection
• Bevy depth (v0.5): System Graph, animation blend tree, shader graph live-recompile preview, asset import (FBX / OBJ / glTF), plugin browser, hot reload for .bscene and shaders
• Audio pipeline (v0.6): in-IDE waveform with scrubbing, event-driven editor (one-shots / loops / ducking / parameter layers), spatial audio with attenuation curves, music graph with stinger / vertical re-mix, SFX randomiser, hot reload
• Architecture → game (v0.7): DXF importer (LINE / LWPOLYLINE / 3DFACE / arcs), IFC MVP importer, layer-name → PBR colour with EN + JA vocabulary, Walkable Architecture template (FPS controller + AABB collider + day / dusk / night cycle)

See GitHub Releases for the full per-version breakdown.

🚧 Current focus: v0.8 — Ship to mobile

Bevy mobile development without the toolchain hell. Replace the cargo-mobile + Xcode + Android Studio + SDK juggling with a single integrated workflow.

Already in main:

• ✅ One-click iOS Simulator run via cargo-mobile2 — no Xcode juggling
• ✅ Toolchain detection — Xcode / Android SDK / NDK / adb / rustup targets / codesign identities, persisted to disk so cold starts skip the probe
• ✅ Mobile run dispatch — simctl boot/install/launch (iOS Sim), devicectl (iOS Device), adb install + am start + logcat (Android), all chained as one tracked subprocess that gets cleaned up on IDE quit
• ✅ Unified log console — severity classifier handles adb logcat priorities, Apple unified-log markers, tracing keywords, and Bevy / Rust panic detection as a dedicated severity

v0.8.x roadmap:

• [ ] WiFi hot reload — mDNS-discovered TCP socket; asset edits flow to the running device build without rebuild
• [ ] iOS device probing — xcrun devicectl list devices so attached hardware shows up in the target dropdown (dispatch path is already wired)
• [ ] Signing UI — pick certs from security find-identity, attach provisioning profiles, manage Android keystores
• [ ] One-click rustup target add from the toolchain panel
• [ ] Mobile-aware editor — touch input editor, safe-area / notch / orientation layouts, ASTC / ETC2 texture compression, mobile LOD presets
• [ ] Performance tooling — Metal frame capture / RenderDoc Android, frame-budget visualiser, battery-cost estimator, lifecycle test harness
• [ ] IPA / AAB build & sign inside the IDE, App Store Connect / Play Console upload helper, TestFlight QR generator
• [ ] VR/AR — Vision Pro / Quest builds reusing the v0.7 walkable scenes; pipeline becomes "CAD → walkthrough → headset" in one tool

🌉 Migration & interop (v0.8.x → v0.9, parallel track)

Bring your existing projects with you. BerryCode aims to be a bridge, not a wall.

• [ ] Godot project read-only viewer — open project.godot, browse .tscn scene trees, syntax-highlight .gd / .cs files. No automatic conversion — just side-by-side reading while you migrate at your own pace
• [ ] Migration assistant — AI-suggested ECS scaffolding from Godot scene structure, side-by-side Godot ↔ Bevy code hints
• [ ] Unity project read (TBD) — .unity YAML scenes, .cs syntax-highlighted, similar non-converting viewer
• [ ] Jackdaw scene format interop — read scenes authored in the Bevy-native Jackdaw editor; edit code-side in BerryCode, scene-side in Jackdaw

Positioning: the editor that speaks your existing engine's files, even while you write new code in Bevy.

🔮 Future (v0.9 onwards)

Version	Theme	Headline
v0.9	Networking & multiplayer	First-class lightyear / bevy_replicon integration, N-client local launcher, server packaging (Fly.io / Railway / k8s)
v0.10	Game data	DB inspector for SQLite / Postgres / Redis with ECS bridge, live save-file editing, schema diagrams
v0.10.5	AI completion	Inline / Tab ghost-text, real 3-way merge, embedded Bevy doc RAG, ECS-aware completion (carryo