Crate bevy

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!

Example

Here is a simple “Hello World” Bevy app:

use bevy::prelude::*;

fn main() {
   App::new()
       .add_systems(Update, hello_world_system)
       .run();
}

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 crates.io with bevy_ appended to the front, e.g. app -> bevy_app.

Cargo Features

Bevy exposes many features to customize 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 name	description
android-game-activity	Android GameActivity support. Default, choose between this and android-native-activity.
android_shared_stdcxx	Enable using a shared stdlib for cxx on Android
animation	Enable animation support, and glTF animation loading
bevy_animation	Provides animation functionality
bevy_asset	Provides asset functionality
bevy_audio	Provides audio functionality
bevy_color	Provides shared color types and operations
bevy_core_pipeline	Provides cameras and other basic render pipeline features
bevy_gilrs	Adds gamepad support
bevy_gizmos	Adds support for rendering gizmos
bevy_gltf	glTF support
bevy_mesh_picking_backend	Provides an implementation for picking meshes
bevy_pbr	Adds PBR rendering
bevy_picking	Provides picking functionality
bevy_render	Provides rendering functionality
bevy_scene	Provides scene functionality
bevy_sprite	Provides sprite functionality
bevy_sprite_picking_backend	Provides an implementation for picking sprites
bevy_state	Enable built in global state machines
bevy_text	Provides text functionality
bevy_ui	A custom ECS-driven UI framework
bevy_ui_picking_backend	Provides an implementation for picking UI
bevy_window	Windowing layer
bevy_winit	winit window and input backend
custom_cursor	Enable winit custom cursor support
default_font	Include a default font, containing only ASCII characters, at the cost of a 20kB binary size increase
hdr	HDR image format support
ktx2	KTX2 compressed texture support
multi_threaded	Enables multithreaded parallelism in the engine. Disabling it forces all engine tasks to run on a single thread.
png	PNG image format support
smaa_luts	Include SMAA Look Up Tables KTX2 Files
sysinfo_plugin	Enables system information diagnostic plugin
tonemapping_luts	Include tonemapping Look Up Tables KTX2 files. If everything is pink, you need to enable this feature or change the Tonemapping method for your Camera2d or Camera3d.
vorbis	OGG/VORBIS audio format support
webgl2	Enable 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.
x11	X11 display server support
zstd	For KTX2 supercompression

Optional Features

feature name	description
accesskit_unix	Enable AccessKit on Unix backends (currently only works with experimental screen readers and forks.)
android-native-activity	Android NativeActivity support. Legacy, should be avoided for most new Android games.
asset_processor	Enables the built-in asset processor for processed assets.
async-io	Use async-io’s implementation of block_on instead of futures-lite’s implementation. This is preferred if your application uses async-io.
basis-universal	Basis Universal compressed texture support
bevy_ci_testing	Enable systems that allow for automated testing on CI
bevy_debug_stepping	Enable stepping-based debugging of Bevy systems
bevy_dev_tools	Provides a collection of developer tools
bevy_remote	Enable the Bevy Remote Protocol
bmp	BMP image format support
dds	DDS compressed texture support
debug_glam_assert	Enable assertions in debug builds to check the validity of parameters passed to glam
detailed_trace	Enable detailed trace event logging. These trace events are expensive even when off, thus they require compile time opt-in
dynamic_linking	Force dynamic linking, which improves iterative compile times
embedded_watcher	Enables watching in memory asset providers for Bevy Asset hot-reloading
experimental_pbr_pcss	Enable support for PCSS, at the risk of blowing past the global, per-shader sampler limit on older/lower-end GPUs
exr	EXR image format support
ff	Farbfeld image format support
file_watcher	Enables watching the filesystem for Bevy Asset hot-reloading
flac	FLAC audio format support
ghost_nodes	Experimental support for nodes that are ignored for UI layouting
gif	GIF image format support
glam_assert	Enable assertions to check the validity of parameters passed to glam
ico	ICO image format support
ios_simulator	Enable support for the ios_simulator by downgrading some rendering capabilities
jpeg	JPEG image format support
meshlet	Enables the meshlet renderer for dense high-poly scenes (experimental)
meshlet_processor	Enables processing meshes into meshlet meshes for bevy_pbr
minimp3	MP3 audio format support (through minimp3)
mp3	MP3 audio format support
pbr_anisotropy_texture	Enable support for anisotropy texture in the StandardMaterial, at the risk of blowing past the global, per-shader texture limit on older/lower-end GPUs
pbr_multi_layer_material_textures	Enable 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_textures	Enable 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
pnm	PNM image format support, includes pam, pbm, pgm and ppm
qoi	QOI image format support
reflect_functions	Enable function reflection
serialize	Enable serialization support through serde
shader_format_glsl	Enable support for shaders in GLSL
shader_format_spirv	Enable support for shaders in SPIR-V
spirv_shader_passthrough	Enable passthrough loading for SPIR-V shaders (Only supported on Vulkan, shader capabilities and extensions must agree with the platform implementation)
symphonia-aac	AAC audio format support (through symphonia)
symphonia-all	AAC, FLAC, MP3, MP4, OGG/VORBIS, and WAV audio formats support (through symphonia)
symphonia-flac	FLAC audio format support (through symphonia)
symphonia-isomp4	MP4 audio format support (through symphonia)
symphonia-vorbis	OGG/VORBIS audio format support (through symphonia)
symphonia-wav	WAV audio format support (through symphonia)
tga	TGA image format support
tiff	TIFF image format support
trace	Tracing support
trace_chrome	Tracing support, saving a file in Chrome Tracing format
trace_tracy	Tracing support, exposing a port for Tracy
trace_tracy_memory	Tracing support, with memory profiling, exposing a port for Tracy
track_change_detection	Enables source location tracking for change detection, which can assist with debugging
wav	WAV audio format support
wayland	Wayland display server support
webgpu	Enable 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.
webp	WebP image format support
zlib	For KTX2 supercompression

Modules

• a11y
  Accessibility for Bevy
• animation
  Animation for the game engine Bevy
• app
  This crate is about everything concerning the highest-level, application layer of a Bevy app.
• asset
  In the context of game development, an “asset” is a piece of content that is loaded from disk and displayed in the game. Typically, these are authored by artists and designers (in contrast to code), are relatively large in size, and include everything from textures and models to sounds and music to levels and scripts.
• audio
  Audio support for the game engine Bevy
• color
  Representations of colors in various color spaces.
• core
  This crate provides core functionality for Bevy Engine.
• core_pipeline
• dev_tools
  This crate provides additional utilities for the Bevy game engine, focused on improving developer experience.
• diagnostic
  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.
• ecs
  Bevy ECS
• gilrs
  Systems and type definitions for gamepad handling in Bevy.
• gizmos
  This crate adds an immediate mode drawing api to Bevy for visual debugging.
• gltf
  Plugin providing an AssetLoader and type definitions for loading glTF 2.0 (a standard 3D scene definition format) files in Bevy.
• hierarchy
  Parent-child relationships for Bevy entities.
• image
• input
  Input functionality for the Bevy game engine.
• log
  This crate provides logging functions and configuration for Bevy apps, and automatically configures platform specific log handlers (i.e. Wasm or Android).
• math
  Provides math types and functionality for the Bevy game engine.
• pbr
• picking
  This crate provides ‘picking’ capabilities for the Bevy game engine. That means, in simple terms, figuring out how to connect up a user’s clicks or taps to the entities they are trying to interact with.
• prelude
  use bevy::prelude::*; to import common components, bundles, and plugins.
• reflect
  Reflection in Rust.
• remote
  An implementation of the Bevy Remote Protocol, to allow for remote control of a Bevy app.
• render
• scene
  Provides scene definition, instantiation and serialization/deserialization.
• sprite
  Provides 2D sprite rendering functionality.
• state
  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.
• tasks
  Bevy Tasks
• text
  This crate provides the tools for positioning and rendering text in Bevy.
• time
  Bevy Time
• transform
  Bevy Transform
• ui
  This crate contains Bevy’s UI system, which can be used to create UI for both 2D and 3D games
• utils
  General utilities for first-party Bevy engine crates.
• window
  bevy_window provides a platform-agnostic interface for windowing in Bevy.
• winit
  bevy_winit provides utilities to handle window creation and the eventloop through winit

Structs

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