Crate bevy

Expand description

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 a container crate that makes it easier to consume Bevy subcrates. The defaults provide a “full engine” experience, but you can easily enable or disable features in your project’s Cargo.toml to meet your specific needs. See Bevy’s Cargo.toml for a full list of available features.

If you prefer, you can also use 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 Cargo features to customize the engine. Enabling them adds functionality but may come at the cost of longer compilation times and extra dependencies.

§Profiles

“Profiles” are high-level groups of cargo features that provide the full Bevy experience, but scoped to a specific domain. These exist to be paired with default-features = false, enabling compiling only the subset of Bevy that you need. This can cut down compile times and shrink your final binary size.

For example, you can compile only the “2D” Bevy features (without the 3D features) like this:

bevy = { version = "0.17", default-features = false, features = ["2d"] }

Profile	Description
default	The full default Bevy experience. This is a combination of the following profiles: 2d, 3d, ui
2d	The default 2D Bevy experience. This includes the core Bevy framework, 2D functionality, Bevy UI, scenes, audio, and picking.
3d	The default 3D Bevy experience. This includes the core Bevy framework, 3D functionality, Bevy UI, scenes, audio, and picking.
ui	The default Bevy UI experience. This includes the core Bevy framework, Bevy UI, scenes, audio, and picking.

By default, the bevy crate enables the features.

§Collections

“Collections” are mid-level groups of cargo features. These are used to compose the high-level “profiles”. If the default profiles don’t suit your use case (ex: you want to use a custom renderer, you want to build a “headless” app, you want to target no_std, etc), then you can use these collections to build your own “profile” equivalent, without needing to manually manage every single feature.

Collection	Description
dev	Enable this feature during development to improve the development experience. This adds features like asset hot-reloading and debugging tools. This should not be enabled for published apps!
audio	Features used to build audio Bevy apps.
scene	Features used to compose Bevy scenes.
picking	Enables picking functionality
default_app	The core pieces that most apps need. This serves as a baseline feature set for other higher level feature collections (such as “2d” and “3d”). It is also useful as a baseline feature set for scenarios like headless apps that require no rendering (ex: command line tools, servers, etc).
default_platform	These are platform support features, such as OS support/features, windowing and input backends, etc.
common_api	Default scene definition features. Note that this does not include an actual renderer, such as bevy_render (Bevy’s default render backend).
2d_api	Features used to build 2D Bevy apps (does not include a render backend). You generally don’t need to worry about this unless you are using a custom renderer.
2d_bevy_render	Bevy’s built-in 2D renderer, built on top of `bevy_render`.
3d_api	Features used to build 3D Bevy apps (does not include a render backend). You generally don’t need to worry about this unless you are using a custom renderer.
3d_bevy_render	Bevy’s built-in 3D renderer, built on top of `bevy_render`.
ui_api	Features used to build UI Bevy apps (does not include a render backend). You generally don’t need to worry about this unless you are using a custom renderer.
ui_bevy_render	Bevy’s built-in UI renderer, built on top of `bevy_render`.
default_no_std	Recommended defaults for no_std applications

§Feature List

This is the complete bevy cargo feature list, without “profiles” or “collections” (sorted by name):

Feature	Description
accesskit_unix	Enable AccessKit on Unix backends (currently only works with experimental screen readers and forks.)
android-game-activity	Android GameActivity support. Default, choose between this and `android-native-activity`.
android-native-activity	Android NativeActivity support. Legacy, should be avoided for most new Android games.
android_shared_stdcxx	Enable using a shared stdlib for cxx on Android
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.
async_executor	Uses `async-executor` as a task execution backend.
basis-universal	Basis Universal compressed texture support
bevy_animation	Provides animation functionality
bevy_anti_alias	Provides various anti aliasing solutions
bevy_asset	Provides asset functionality
bevy_audio	Provides audio functionality
bevy_camera	Provides camera and visibility types, as well as culling primitives.
bevy_camera_controller	Provides a collection of prebuilt camera controllers
bevy_ci_testing	Enable systems that allow for automated testing on CI
bevy_color	Provides shared color types and operations
bevy_core_pipeline	Provides cameras and other basic render pipeline features
bevy_debug_stepping	Enable stepping-based debugging of Bevy systems
bevy_dev_tools	Provides a collection of developer tools
bevy_gilrs	Adds gamepad support
bevy_gizmos	Adds support for gizmos
bevy_gizmos_render	Adds support for rendering gizmos
bevy_gltf	glTF support
bevy_image	Load and access image data. Usually added by an image format
bevy_input_focus	Enable input focus subsystem
bevy_light	Provides light types such as point lights, directional lights, spotlights.
bevy_log	Enable integration with `tracing` and `log`
bevy_mesh	Provides a mesh format and some primitive meshing routines.
bevy_mikktspace	Provides vertex tangent generation for use with bevy_mesh.
bevy_pbr	Adds PBR rendering
bevy_picking	Provides picking functionality
bevy_post_process	Provides post process effects such as depth of field, bloom, chromatic aberration.
bevy_remote	Enable the Bevy Remote Protocol
bevy_render	Provides rendering functionality
bevy_scene	Provides scene functionality
bevy_shader	Provides shaders usable through asset handles.
bevy_solari	Provides raytraced lighting (experimental)
bevy_sprite	Provides sprite functionality
bevy_sprite_render	Provides sprite rendering functionality
bevy_state	Enable built in global state machines
bevy_text	Provides text functionality
bevy_ui	A custom ECS-driven UI framework
bevy_ui_debug	Provides a debug overlay for bevy UI
bevy_ui_render	Provides rendering functionality for bevy_ui
bevy_window	Windowing layer
bevy_winit	winit window and input backend
bluenoise_texture	Include spatio-temporal blue noise KTX2 file used by generated environment maps, Solari and atmosphere
bmp	BMP image format support
compressed_image_saver	Enables compressed KTX2 UASTC texture output on the asset processor
critical-section	`critical-section` provides the building blocks for synchronization primitives on all platforms, including `no_std`.
custom_cursor	Enable winit custom cursor support
dds	DDS compressed texture support
debug	Enable collecting debug information about systems and components to help with diagnostics
debug_glam_assert	Enable assertions in debug builds to check the validity of parameters passed to glam
default_font	Include a default font, containing only ASCII characters, at the cost of a 20kB binary size increase
detailed_trace	Enable detailed trace event logging. These trace events are expensive even when off, thus they require compile time opt-in
dlss	NVIDIA Deep Learning Super Sampling
dynamic_linking	Force dynamic linking, which improves iterative compile times
embedded_watcher	Enables watching in memory asset providers for Bevy Asset hot-reloading
experimental_bevy_feathers	Feathers widget collection.
experimental_bevy_ui_widgets	Experimental headless widget collection for Bevy UI.
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
force_disable_dlss	Forcibly disable DLSS so that cargo build –all-features works without the DLSS SDK being installed. Not meant for users.
free_camera	Enables the free cam from bevy_camera_controller
gamepad	Gamepad support. Automatically enabled by `bevy_gilrs`.
gestures	Gestures support. Automatically enabled by `bevy_window`.
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
gltf_animation	Enable glTF animation loading
hdr	HDR image format support
hotpatching	Enable hotpatching of Bevy systems
http	Enables downloading assets from HTTP sources. Warning: there are security implications. Read the docs on WebAssetPlugin.
https	Enables downloading assets from HTTPS sources. Warning: there are security implications. Read the docs on WebAssetPlugin.
ico	ICO image format support
jpeg	JPEG image format support
keyboard	Keyboard support. Automatically enabled by `bevy_window`.
ktx2	KTX2 compressed texture support
libm	Uses the `libm` maths library instead of the one provided in `std` and `core`.
mesh_picking	Provides an implementation for picking meshes
meshlet	Enables the meshlet renderer for dense high-poly scenes (experimental)
meshlet_processor	Enables processing meshes into meshlet meshes for bevy_pbr
morph	Enables support for morph target weights in bevy_mesh
morph_animation	Enables bevy_mesh and bevy_animation morph weight support
mouse	Mouse support. Automatically enabled by `bevy_window`.
mp3	MP3 audio format support
multi_threaded	Enables multithreaded parallelism in the engine. Disabling it forces all engine tasks to run on a single thread.
pan_camera	Enables the pan camera from bevy_camera_controller
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_clustered_decals	Enable support for Clustered Decals
pbr_light_textures	Enable support for Light Textures
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_specular_textures	Enable support for specular 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
png	PNG image format support
pnm	PNM image format support, includes pam, pbm, pgm and ppm
qoi	QOI image format support
raw_vulkan_init	Forces the wgpu instance to be initialized using the raw Vulkan HAL, enabling additional configuration
reflect_auto_register	Enable automatic reflect registration
reflect_auto_register_static	Enable automatic reflect registration without inventory. See `reflect::load_type_registrations` for more info.
reflect_documentation	Enables bevy_reflect to access documentation comments of rust code at runtime
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
shader_format_wesl	Enable support for shaders in WESL
smaa_luts	Include SMAA Look Up Tables KTX2 Files
spirv_shader_passthrough	Enable passthrough loading for SPIR-V shaders (Only supported on Vulkan, shader capabilities and extensions must agree with the platform implementation)
sprite_picking	Provides an implementation for picking sprites
statically-linked-dxc	Statically linked DXC shader compiler for DirectX 12
std	Allows access to the `std` crate.
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)
sysinfo_plugin	Enables system information diagnostic plugin
tga	TGA image format support
tiff	TIFF image format support
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`.
touch	Touch support. Automatically enabled by `bevy_window`.
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_location	Enables source location tracking for change detection and spawning/despawning, which can assist with debugging
ui_picking	Provides an implementation for picking UI
vorbis	OGG/VORBIS audio format support
wav	WAV audio format support
wayland	Wayland display server support
web	Enables use of browser APIs. Note this is currently only applicable on `wasm32` architectures.
web_asset_cache	Enable caching downloaded assets on the filesystem. NOTE: this cache currently never invalidates entries!
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.
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
x11	X11 display server support
zlib	For KTX2 supercompression
zstd_c	For KTX2 Zstandard decompression using zstd. This is a faster backend, but uses unsafe C bindings. For the safe option, stick to the default backend with “zstd_rust”.
zstd_rust	For KTX2 Zstandard decompression using pure rust ruzstd. This is the safe default. For maximum performance, use “zstd_c”.

Modules§

a11y: Reusable accessibility primitives
animation: Animation for the game engine Bevy
anti_alias
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
camera
camera_controller: A home for first-party camera controllers for Bevy, used for moving the camera around your scene.
color: Representations of colors in various color spaces.
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
feathers: bevy_feathers is a collection of styled and themed widgets for building editors and inspectors.
gilrs: Systems and type definitions for gamepad handling in Bevy.
gizmos: This crate adds an immediate mode drawing api to Bevy for visual debugging.
gizmos_render: This crate renders bevy_gizmos with bevy_render.
gltf: Plugin providing an AssetLoader and type definitions for loading glTF 2.0 (a standard 3D scene definition format) files in Bevy.
image
input: Input functionality for the Bevy game engine.
input_focus: A UI-centric focus system for Bevy.
light
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.
mesh
pbr
picking: This crate provides ‘picking’ capabilities for the Bevy game engine, allowing pointers to interact with entities using hover, click, and drag events.
platform: Platform compatibility support for first-party Bevy engine crates.
post_process
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: Useful Environment Variables
scene: Provides scene definition, instantiation and serialization/deserialization.
shader
solari: Provides raytraced lighting.
sprite: Provides 2D sprite functionality.
sprite_render: 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
ui_render: Provides rendering functionality for bevy_ui.
ui_widgets: This crate provides a set of standard widgets for Bevy UI, such as buttons, checkboxes, and sliders. These widgets have no inherent styling, it’s the responsibility of the user to add styling appropriate for their game or application.
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:

Crate bevy

Crate bevy Copy item path

§Example

§This Crate

§Cargo Features

§Profiles

§Collections

§Feature List

Modules§

Structs§

Crate bevy