简体中文
English
Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is Bevy Engine?
Bevy Engine is a free, open-source game engine written in Rust. Its defining idea is that everything—engine features and your own game logic—runs on Bevy ECS, a custom Entity Component System. In practice this means components are plain Rust structs and systems are Rust functions, organized through queries and resources rather than deep inheritance trees. The site emphasizes that this design is fast (massively parallel, cache-friendly) and simple to reason about, with capabilities like change detection and a lock-free parallel scheduler.
What it gives you out of the box
The engine covers the core pieces a game or interactive app needs:
- 2D and 3D rendering — sprites, sprite sheets, dynamic texture atlases, cameras, textures and materials in 2D; lights, shadows, meshes, materials and glTF loading in 3D.
- A render graph — custom pipelines are composed as graph nodes, rendered automatically in parallel, and are not tied to one graphics API.
- Animation — skeletal rig animation via an ECS-based joint API, blending multiple animations, blend shapes/morph targets, and glTF animation import.
- UI — an ECS-driven framework using a familiar flex-box layout model, built on the same renderer and scene systems.
- Scenes — save and load ECS worlds, instance linked duplicates, and preserve entity IDs when loading (handy for save games).
- Audio — load audio as assets and play it on demand through audio entities.
- Hot reloading — scene, texture and mesh changes apply to a running app; the site notes any asset type can be integrated.
Who it suits
Bevy is a natural fit if you already write Rust, want engine source you can read and modify, and prefer composing behavior from data and systems over fighting an editor-centric workflow. It is also appealing for non-game interactive apps that need real-time 2D or 3D graphics, since the renderer and UI are usable independently of a game loop. If your team relies on a visual editor, a large prebuilt asset store, or a mature third-party plugin ecosystem, that is the trade-off to weigh: Bevy's data-driven approach buys flexibility and performance but expects more code-level assembly.
Cross-platform reach
The site lists support for Windows, macOS, Linux, Web, iOS and Android, so a single Rust codebase can target desktop, browser and mobile.
A useful next step
Skim the official Bevy book and examples at Bevy Engine and try the "get started" path with one small goal—say, a sprite that moves and responds to input. If the ECS style clicks there, the same patterns scale to 3D, UI and animation. For Rust itself, The Rust Programming Language is the standard companion reference.
How do I set up a new Bevy project in Rust?
The official starting point is Bevy's own "Get Started" guide, which walks through installing the Rust toolchain, creating a Cargo project, and adding Bevy as a dependency. The engine is a Rust crate, so setup follows the normal Cargo workflow rather than a separate installer.
Bevy Engine
The basic steps
- Install Rust via rustup if you don't already have it.
- Create a new binary project:
cargo new my_gameand move into that folder. - Add Bevy to
Cargo.tomlunder[dependencies], either by editing the file or runningcargo add bevy. - Replace the default
main.rswith a minimal Bevy app: anApp::new(), a window plugin, and your own startup system. - Run it with
cargo run.
A minimal main.rs looks roughly like this:
use bevy::prelude::*;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_systems(Startup, setup)
.run();
}
fn setup(mut commands: Commands) {
commands.spawn(Camera2d);
}
Practical notes
- Bevy is a fast-moving project, so match the crate version in
Cargo.tomlto the documentation version you are reading. Mixing a tutorial written for an older release with a newer crate is the most common source of confusing compile errors. - The first build is slow because Cargo compiles the whole engine and its dependencies. Later builds are much faster, and the page itself flags compile times as something the project cares about. On Linux you may also need system libraries for audio and windowing; the setup guide lists them.
- For faster iteration, the guide recommends a dynamic linking feature during development, which shortens rebuild times at the cost of a slightly more complex run command.
Choosing your path
If you are new to Rust, work through a small Bevy example first — spawning a camera and a sprite — before adding physics, UI, or 3D. If you already know Rust, the ECS model is the main thing to learn: game logic is expressed as systems operating on components, not as class hierarchies. Reading the examples that ship with the engine is the quickest way to see that pattern in practice.
For broader Rust questions, the language's own book is the standard reference: The Rust Programming Language.
What are the main differences between Bevy's 2D and 3D renderers?
Bevy's 2D and 3D renderers are separate front-ends built on the same foundation: the Render Graph, which handles how rendering work is composed and executed. That shared core means both are extensible with custom shaders, materials, and render pipelines, and both are backend-agnostic rather than tied to one graphics API. The practical differences are in what each is designed to draw and how you work with it.
2D renderer: Aimed at real-time 2D graphics for games and apps. Its listed features are sprite sheets, dynamic texture atlases, cameras, textures, and materials. Dynamic atlases matter when sprites are created or swapped at runtime, since the engine can pack them without a manual pre-build step.
3D renderer: Aimed at modern, flexible 3D scenes. Its listed features are lights, shadows, cameras, meshes, textures, materials, and glTF loading. Lighting and shadows are the clearest dividing line: they are core 3D concerns, while 2D rendering in Bevy is oriented around flat sprites and textures.
| Aspect | 2D renderer | 3D renderer |
|---|---|---|
| Primary use | Sprites, atlases, 2D apps and games | Meshes, lights, shadows, 3D scenes |
| Notable features | Sprite sheets, dynamic texture atlases | Lights, shadows, glTF loading |
| Shared core | Render Graph, custom shaders/materials/pipelines | Render Graph, custom shaders/materials/pipelines |
Both sit on Bevy's ECS, so entities, components, and systems drive rendering the same way. Animation is not split by renderer: skeletal rig animation, blending multiple animations, blend shapes/morph targets, and glTF animation import are described at the engine level, and skeletal animation is typically a 3D concern in practice.
A concrete scenario: a 2D puzzle game with animated sprites and dynamically packed atlases fits the 2D renderer, while a third-person scene with directional lights, shadows, and glTF character models fits the 3D renderer. Neither choice locks you out of the other's infrastructure, because both use the Render Graph.
If you are deciding, start from the content you must draw. Use the 2D renderer when your world is sprites and textures; use the 3D renderer when you need meshes, lights, and shadows. For a mixed project, check how each renderer composes into the Render Graph, since that is where custom passes and shared logic live.
How does Bevy's Entity Component System (ECS) work?
Bevy's ECS is the engine's core architecture: all engine and game logic is expressed through it, rather than being a side feature you opt into. The model has three parts. Entities are lightweight identifiers. Components are plain Rust structs attached to entities — position, health, sprite, and so on. Systems are ordinary Rust functions that read and write those components. The engine decides when systems run and how they are scheduled.
The design goals stated on the page are speed through massive parallelism and cache-friendly memory layout, simplicity because components and systems are just Rust types and functions, and capability through queries, global and local resources, change detection, and a lock-free parallel scheduler. In practice this means you describe what data exists and what operations touch it, and Bevy figures out which systems can safely run at the same time.
What it looks like in practice
A typical loop is: query for entities that have a certain set of components, mutate them, and let the scheduler handle ordering. Because components are structs, adding a new behavior usually means adding a component and a system, not editing a class hierarchy. Queries and change detection also let a system act only on entities whose data actually changed — useful for expensive work like re-rendering or pathfinding.
Where the trade-offs show up
| Aspect | What you get | What to watch for |
|---|---|---|
| Data model | Composition over inheritance; components are reusable across entity types | You need to think in data, not objects — a shift for developers from OOP engines |
| Parallelism | Systems run in parallel automatically when their data access doesn't conflict | Conflicts still serialize; system ordering matters for correctness |
| Reusability | ECS worlds can be saved and loaded as scenes, preserving entity IDs for save games | Scene instancing creates new IDs, so identity handling differs between the two modes |
| UI | Bevy UI is itself ECS-driven, with a flex-box layout model | UI logic lives in the same ECS world as gameplay, which is powerful but couples the two |
A concrete scenario
Suppose you are building a 2D game with many enemies. You define components for position, velocity, and health, then write one system that applies velocity to position and another that removes entities whose health reaches zero. Bevy's scheduler can run those alongside animation and rendering systems without you manually threading them. If you later add a 3D mode, the same ECS patterns carry over, and the render graph composes custom pipelines in parallel and in a backend-agnostic way.
Next step
Skim the official Bevy documentation and examples at Bevy Engine, then build the smallest possible scene — one entity, one component, one system — before scaling up. If you prefer a broader comparison of Rust game engines first, look at Are We Game Yet to see how Bevy's ECS-first approach differs from more traditional scene-graph engines.
Can Bevy games be deployed to the web or mobile platforms?
Yes. Bevy lists Windows, macOS, Linux, Web, iOS, and Android under its cross-platform support, so web and mobile are both intended targets rather than side experiments. The same engine features apply across them: the ECS-based game logic, 2D and 3D renderers, animation, UI, scenes, and audio are all described as part of the engine rather than as desktop-only extras.
What that means in practice
- Web: a Bevy game compiles to WebAssembly and runs in the browser. This suits small-to-mid-scope games, prototypes, game jams, and demos you want people to try without installing anything. Expect the usual browser constraints: download size, load time, and the performance ceiling of the device and browser rather than your development machine.
- Mobile (iOS and Android): Bevy apps can be packaged as native mobile apps. This fits touch-driven games and apps where you want the same Rust codebase as your desktop build. Mobile brings platform-specific work that the engine can't remove for you: signing and store submission, touch input instead of mouse and keyboard, smaller screens, and tighter thermal and battery limits.
Trade-offs to weigh
| Target | Main appeal | Main friction |
|---|---|---|
| Web | Instant access, easy sharing, no install | Larger initial download, browser performance limits |
| iOS / Android | Native performance, store distribution, touch input | Store tooling, device testing, input and UI rework |
| Desktop | Fewest constraints, easiest debugging | Requires users to download and install |
A useful decision rule: if your goal is reach and quick feedback, start with the web build because it is the fastest way to get the game in front of people. If your game depends on sustained performance, precise touch controls, or store distribution, plan for mobile from the start so input and UI are designed for it rather than retrofitted.
For a concrete scenario: a two-person team building a small puzzle game can ship a web build first to gather feedback, then reuse the same Rust project for iOS and Android once the design settles. The ECS logic, scenes, and assets carry over; what changes is input handling, UI layout, and packaging.
As a next step, check the official Bevy documentation and examples for the platform you're targeting, and build a minimal test project for it early. Verifying a trivial app on your chosen platform takes an afternoon and surfaces toolchain problems long before they can derail a release. You can also compare approaches with Godot Engine or Unity, which target the same platforms with different language and workflow trade-offs.
How does hot reloading work in Bevy and what assets does it support?
Hot reloading in Bevy watches your asset files on disk and applies changes to a running app, so you can iterate on content without restarting or recompiling. Bevy's own documentation frames it as instant feedback: asset changes are reflected immediately in running apps. It is a runtime convenience for content iteration, not a replacement for the normal build step when you change Rust code.
What the engine documentation says it covers
Per the page evidence, Bevy currently hot-reloads:
- Scenes — changes to scene files are automatically applied to running apps.
- Textures — image edits show up live.
- Meshes — geometry edits show up live.
The same page adds that any asset type can be integrated, so the three above are the built-in cases rather than a hard ceiling.
How it fits into a real workflow
A practical example: you are tuning a level's layout in a scene file while the game runs in a window. You move a platform, save, and the running world updates. Same for swapping a texture or adjusting a mesh. For a solo developer or small team, this removes the stop-start cycle that makes level and art tuning slow.
Decide based on what you actually change most:
- Mostly scenes, textures, meshes — you get the documented benefit out of the box.
- Custom asset formats — expect to wire up reload support yourself; the engine allows it but does not ship it for you.
- Mostly Rust logic changes — hot reloading does not help here; compile times are the relevant lever instead.
Next step
Start by hot-reloading a scene file and a texture in a small test project to confirm your asset paths and watcher setup behave as expected, then check whether your own custom asset types need explicit reload integration. If animation content matters to you, note that Bevy imports animations from glTF files, so re-exporting an animation is the path to seeing changes live rather than editing animation data in place.
For engine-level detail beyond the overview, the project's own site is the place to look: Bevy Engine.
Cloudflare
Fastly
Google Workspace
User reviews (0)