Crate bevy

source ·
Expand description

Bevy Logo

Bevy is an open-source modular game engine built in Rust, with a focus on developer productivity and performance.

Check out the Bevy website for more information, read the Quick Start Guide for a step-by-step introduction, and engage with our community if you have any questions or ideas!


Here is a simple “Hello World” Bevy app:

use bevy::prelude::*;

fn main() {
       .add_systems(Update, hello_world_system)

fn hello_world_system() {
   println!("hello world");

Don’t let the simplicity of the example above fool you. Bevy is a fully featured game engine and it gets more powerful every day!

§This Crate

The bevy crate is just a container crate that makes it easier to consume Bevy subcrates. The defaults provide a “full” engine experience, but you can easily enable / disable features in your project’s Cargo.toml to meet your specific needs. See Bevy’s Cargo.toml for a full list of features available.

If you prefer, you can also consume the individual bevy crates directly. Each module in the root of this crate, except for the prelude, can be found on with bevy_ appended to the front, e.g. app -> bevy_app.

§Cargo Features

Bevy exposes many features to customise the engine. Enabling them add functionalities but often come at the cost of longer compilation times and extra dependencies.

§Default Features

The default feature set enables most of the expected features of a game engine, like rendering in both 2D and 3D, asset loading, audio and UI. To help reduce compilation time, consider disabling default features and enabling only those you need.

feature namedescription
android_shared_stdcxxEnable using a shared stdlib for cxx on Android
animationEnable animation support, and glTF animation loading
bevy_animationProvides animation functionality
bevy_assetProvides asset functionality
bevy_audioProvides audio functionality
bevy_colorProvides shared color types and operations
bevy_core_pipelineProvides cameras and other basic render pipeline features
bevy_gilrsAdds gamepad support
bevy_gizmosAdds support for rendering gizmos
bevy_gltfglTF support
bevy_pbrAdds PBR rendering
bevy_renderProvides rendering functionality
bevy_sceneProvides scene functionality
bevy_spriteProvides sprite functionality
bevy_stateEnable built in global state machines
bevy_textProvides text functionality
bevy_uiA custom ECS-driven UI framework
bevy_winitwinit window and input backend
default_fontInclude a default font, containing only ASCII characters, at the cost of a 20kB binary size increase
hdrHDR image format support
ktx2KTX2 compressed texture support
multi_threadedEnables multithreaded parallelism in the engine. Disabling it forces all engine tasks to run on a single thread.
pngPNG image format support
smaa_lutsInclude SMAA Look Up Tables KTX2 Files
sysinfo_pluginEnables system information diagnostic plugin
tonemapping_lutsInclude tonemapping Look Up Tables KTX2 files. If everything is pink, you need to enable this feature or change the Tonemapping method on your Camera2dBundle or Camera3dBundle.
vorbisOGG/VORBIS audio format support
webgl2Enable some limitations to be able to use WebGL2. Please refer to the WebGL2 and WebGPU section of the examples README for more information on how to run Wasm builds with WebGPU.
x11X11 display server support
zstdFor KTX2 supercompression

§Optional Features

feature namedescription
accesskit_unixEnable AccessKit on Unix backends (currently only works with experimental screen readers and forks.)
asset_processorEnables the built-in asset processor for processed assets.
async-ioUse async-io’s implementation of block_on instead of futures-lite’s implementation. This is preferred if your application uses async-io.
basis-universalBasis Universal compressed texture support
bevy_ci_testingEnable systems that allow for automated testing on CI
bevy_debug_steppingEnable stepping-based debugging of Bevy systems
bevy_dev_toolsProvides a collection of developer tools
bevy_dynamic_pluginPlugin for dynamic loading (using libloading)
bmpBMP image format support
ddsDDS compressed texture support
debug_glam_assertEnable assertions in debug builds to check the validity of parameters passed to glam
detailed_traceEnable detailed trace event logging. These trace events are expensive even when off, thus they require compile time opt-in
dynamic_linkingForce dynamic linking, which improves iterative compile times
embedded_watcherEnables watching in memory asset providers for Bevy Asset hot-reloading
exrEXR image format support
file_watcherEnables watching the filesystem for Bevy Asset hot-reloading
flacFLAC audio format support
glam_assertEnable assertions to check the validity of parameters passed to glam
ios_simulatorEnable support for the ios_simulator by downgrading some rendering capabilities
jpegJPEG image format support
meshletEnables the meshlet renderer for dense high-poly scenes (experimental)
meshlet_processorEnables processing meshes into meshlet meshes for bevy_pbr
minimp3MP3 audio format support (through minimp3)
mp3MP3 audio format support
pbr_multi_layer_material_texturesEnable support for multi-layer material textures in the StandardMaterial, at the risk of blowing past the global, per-shader texture limit on older/lower-end GPUs
pbr_transmission_texturesEnable support for transmission-related textures in the StandardMaterial, at the risk of blowing past the global, per-shader texture limit on older/lower-end GPUs
pnmPNM image format support, includes pam, pbm, pgm and ppm
serializeEnable serialization support through serde
shader_format_glslEnable support for shaders in GLSL
shader_format_spirvEnable support for shaders in SPIR-V
subpixel_glyph_atlasEnable rendering of font glyphs using subpixel accuracy
symphonia-aacAAC audio format support (through symphonia)
symphonia-allAAC, FLAC, MP3, MP4, OGG/VORBIS, and WAV audio formats support (through symphonia)
symphonia-flacFLAC audio format support (through symphonia)
symphonia-isomp4MP4 audio format support (through symphonia)
symphonia-vorbisOGG/VORBIS audio format support (through symphonia)
symphonia-wavWAV audio format support (through symphonia)
tgaTGA image format support
traceTracing support
trace_chromeTracing support, saving a file in Chrome Tracing format
trace_tracyTracing support, exposing a port for Tracy
trace_tracy_memoryTracing support, with memory profiling, exposing a port for Tracy
wavWAV audio format support
waylandWayland display server support
webgpuEnable support for WebGPU in Wasm. When enabled, this feature will override the webgl2 feature and you won’t be able to run Wasm builds with WebGL2, only with WebGPU.
webpWebP image format support
wgpu_traceSave a trace of all wgpu calls
zlibFor KTX2 supercompression


  • Accessibility for Bevy
  • Animation for the game engine Bevy
  • This crate is about everything concerning the highest-level, application layer of a Bevy app.
  • Audio support for the game engine Bevy
  • Representations of colors in various color spaces.
  • This crate provides core functionality for Bevy Engine.
  • This crate provides additional utilities for the Bevy game engine, focused on improving developer experience.
  • This crate provides a straightforward solution for integrating diagnostics in the Bevy game engine. It allows users to easily add diagnostic functionality to their Bevy applications, enhancing their ability to monitor and optimize their game’s.
  • Bevy’s dynamic plugin loading functionality.
  • Bevy ECS
  • Systems and type definitions for gamepad handling in Bevy.
  • This crate adds an immediate mode drawing api to Bevy for visual debugging.
  • Plugin providing an AssetLoader and type definitions for loading glTF 2.0 (a standard 3D scene definition format) files in Bevy.
  • Parent-child relationships for Bevy entities.
  • Input functionality for the Bevy game engine.
  • This crate provides logging functions and configuration for Bevy apps, and automatically configures platform specific log handlers (i.e. WASM or Android).
  • Provides math types and functionality for the Bevy game engine.
  • use bevy::prelude::*; to import common components, bundles, and plugins.
  • Reflection in Rust.
  • Provides scene definition, instantiation and serialization/deserialization.
  • Provides 2D sprite rendering functionality.
  • In Bevy, states are app-wide interdependent, finite state machines that are generally used to model the large scale structure of your program: whether a game is paused, if the player is in combat, if assets are loaded and so on.
  • Bevy Tasks
  • Bevy Time
  • Bevy Transform
  • This crate contains Bevy’s UI system, which can be used to create UI for both 2D and 3D games
  • General utilities for first-party Bevy engine crates.
  • bevy_window provides a platform-agnostic interface for windowing in Bevy.
  • bevy_winit provides utilities to handle window creation and the eventloop through winit


  • This plugin group will add all the default plugins for a Bevy application:
  • This plugin group will add the minimal plugins for a Bevy application: