List of Bevy Builtins

This page is a quick condensed listing of all the important things provided by Bevy.

• SystemParams
• Assets
• File Formats
• wgpu Backends
• Bundles
• Resources (Configuration)
• Resources (Engine User)
• Resources (Input)
• Events (Input)
• Events (System/Control)
• Components
• GLTF Asset Labels
• Stages

SystemParams

These are all the special types that can be used as system parameters.

(List in API Docs)

• Commands: Manipulate the ECS using commands
• Res<T>: Shared access to a resource
• ResMut<T>: Exclusive (mutable) access to a resource
• Option<Res<T>>: Shared access to a resource that may not exist
• Option<ResMut<T>>: Exclusive (mutable) access to a resource that may not exist
• Query<T, F = ()> (can contain tuples of up to 15 types): Access to entities and components
• ParamSet (with up to 8 params): Resolve conflicts between incompatible system parameters
• Local<T>: Data local to the system
• EventReader<T>: Receive events
• EventWriter<T>: Send events
• Extract<T>: Extract stage only! T is a system parameter type to access from the main World
• RemovedComponents<T>: Removal detection
• NonSend<T>: Shared access to Non-Send (main thread only) data
• NonSendMut<T>: Mut access to Non-Send (main thread only) data
• ParallelCommands: Abstraction to help use Commands when you will do your own parallelism
• &World: Read-only direct access to the ECS World
• Entities: Low-level ECS metadata: All entities
• Components: Low-level ECS metadata: All components
• Bundles: Low-level ECS metadata: All bundles
• Archetypes: Low-level ECS metadata: All archetypes
• SystemChangeTick: Low-level ECS metadata: Tick used for change detection
• tuples containing any of these types, with up to 16 members

Your function can have a maximum of 16 total parameters. If you need more, group them into tuples to work around the limit. Tuples can contain up to 16 members, but can be nested indefinitely.

Assets

These are the Asset types registered by Bevy by default.

• Image: Pixel data, used as a texture for 2D and 3D rendering; also contains the SamplerDescriptor for texture filtering settings
• TextureAtlas: 2D "Sprite Sheet" defining sub-images within a single larger image
• Mesh: 3D Mesh (geometry data), contains vertex attributes (like position, UVs, normals)
• Shader: GPU shader code, in one of the supported languages (WGSL/SPIR-V/GLSL)
• ColorMaterial: Basic "2D material": contains color, optionally an image
• StandardMaterial: "3D material" with support for Physically-Based Rendering
• AnimationClip: Data for a single animation sequence, can be used with AnimationPlayer
• Font: Font data used for text rendering
• Scene: Scene composed of literal ECS entities to instantiate
• DynamicScene: Scene composed with dynamic typing and reflection
• Gltf: GLTF Master Asset: index of the entire contents of a GLTF file
• GltfNode: Logical GLTF object in a scene
• GltfMesh: Logical GLTF 3D model, consisting of multiple GltfPrimitives
• GltfPrimitive: Single unit to be rendered, contains the Mesh and Material to use
• AudioSource: Raw audio data for bevy_audio
• AudioSink: Audio that is currently active, can be used to control playback
• FontAtlasSet: (internal use for text rendering)
• SkinnedMeshInverseBindposes: (internal use for skeletal animation)

File Formats

These are the asset file formats (asset loaders) supported by Bevy. Support for each one can be enabled/disabled using cargo features. Some are enabled by default, many are not.

Image formats (loaded as Image assets):

Audio formats (loaded as AudioSource assets):

3D asset (model or scene) formats:

Shader formats (loaded as Shader assets):

Font formats (loaded as Font assets):

There are unofficial plugins available for adding support for even more file formats.

wgpu Backends

wgpu (and hence Bevy) supports the following backends for each platform:

• Vulkan (Linux/Windows/Android)
• DirectX 12 (Windows)
• Metal (Apple)
• WebGL2 (Web)
• WebGPU (Web; experimental)
• GLES3 (Linux/Android; legacy)
• DirectX 11 (Windows; legacy; WIP (not yet ready for use))

Bundles

Bevy's built-in bundle types, for spawning different common kinds of entities.

(List in API Docs)

Any tuples of up to 15 Component types are valid bundles.

General:

• SpatialBundle: Contains the required transform and visibility components that must be included on all entities that need rendering or hierarchy
• TransformBundle: Contains only the transform types, subset of SpatialBundle
• VisibilityBundle: Contains only the visibility types, subset of SpatialBundle

Scenes:

• SceneBundle: Used for spawning scenes
• DynamicSceneBundle: Used for spawning dynamic scenes

Bevy 3D:

• Camera3dBundle: 3D camera, can use perspective (default) or orthographic projection
• MaterialMeshBundle: 3D Object/Primitive: a Mesh and the Material to draw it with
• PbrBundle: 3D object with the standard Physically-Based Material (MaterialMeshBundle<StandardMaterial>)
• DirectionalLightBundle: 3D directional light (like the sun)
• PointLightBundle: 3D point light (like a lamp or candle)
• SpotLightBundle: 3D spot light (like a projector or flashlight)

Bevy 2D:

• Camera2dBundle: 2D camera, uses orthographic projection + other special configuration for 2D
• SpriteBundle: 2D sprite, using a whole image (Image asset)
• SpriteSheetBundle: 2D sprite, using a sub-rectangle in a larger image (TextureAtlas asset)
• MaterialMesh2dBundle: 2D shape, with custom Mesh and Material (similar to 3D objects)
• Text2dBundle: Text to be drawn in the 2D world (not the UI)

Bevy UI:

• NodeBundle: Empty node element (like HTML <div>)
• ButtonBundle: Button element
• ImageBundle: Image element
• TextBundle: Text element

Resources

Configuration Resources

These resources allow you to change the settings for how various parts of Bevy work.

Some of them affect the low-level initialization of the engine, so must be present from the start to take effect. You need to insert these at the start of your app builder:

• [LogSettings][bevy::LogSettings]: Configure what messages get logged to the console
• WindowDescriptor: Settings for the primary application window
• WgpuSettings: Low-level settings for the GPU API and backends
• [AssetServerSettings][bevy::AssetServerSettings]: Configuration of the AssetServer
• [DefaultTaskPoolOptions][bevy::DefaultTaskPoolOptions]: Settings for the CPU task pools (multithreading)
• WinitSettings: Settings for the OS Windowing backend, including update loop / power-management settings

These may be inserted at the start, but should also be fine to change at runtime (from a system):

• ClearColor: Global renderer background color to clear the window at the start of each frame
• AmbientLight: Global renderer "fake lighting", so that shadows don't look too dark / black
• Msaa: Global renderer setting for Multi-Sample Anti-Aliasing (some platforms might only support the values 1 and 4)
• [ImageSettings][bevy::ImageSettings]:
• Configure the default sampler settings (incl. texture filtering mode) for Image assets
• ClusterConfig: Configuration of the light clustering algorithm, affects the performance of 3D scenes with many lights
• WireframeConfig: Global toggle to make everything be rendered as wireframe
• GamepadSettings: Gamepad input device settings, like joystick deadzones and button sensitivities

Engine Resources

These resources provide access to different features of the game engine at runtime.

Access them from your systems, if you need their state, or to control the respective parts of Bevy.

• FixedTimesteps: The state of all registered FixedTimestep drivers
• Time: Global time-related information (current frame delta time, time since startup, etc.)
• AssetServer: Control the asset system: Load assets, check load status, etc.
• Gamepads: List of IDs for all currently-detected (connected) gamepad devices
• Windows: All the open windows (the primary window + any additional windows in a multi-window gui app)
• WinitWindows (non-send): Raw state of the winit backend for each window
• Audio: Use this to play sounds via bevy_audio
• AsyncComputeTaskPool: Task pool for running background CPU tasks
• ComputeTaskPool: Task pool where the main app schedule (all the systems) runs
• IoTaskPool: Task pool where background i/o tasks run (like asset loading)
• Diagnostics: Diagnostic data collected by the engine (like frame times)
• SceneSpawner: Direct control over spawning Scenes into the main app World
• TypeRegistryArc: Access to the Reflection Type Registry
• RenderDevice: The GPU used for rendering; use this for direct lowlevel access to wgpu APIs from the main World
• AdapterInfo: Information about the GPU hardware that Bevy is running on

Input Handling Resources

These resources represent the current state of different input devices. Read them from your systems to [handle user input][cb::input].

• Input<KeyCode>: Keyboard key state, as a binary Input value
• Input<MouseButton>: Mouse button state, as a binary Input value
• Input<GamepadButton>: Gamepad buttons, as a binary Input value
• Axis<GamepadAxis>: Analog Axis gamepad inputs (joysticks and triggers)
• Axis<GamepadButton>: Gamepad buttons, represented as an analog Axis value
• Touches: The state of all fingers currently touching the touchscreen

Events

Input Events

These events fire on activity with input devices. Read them to [handle user input][cb::input].

• MouseButtonInput: Changes in the state of mouse buttons
• MouseWheel: Scrolling by a number of pixels or lines (MouseScrollUnit)
• MouseMotion: Relative movement of the mouse (pixels from previous frame), regardless of the OS pointer/cursor
• CursorMoved: New position of the OS mouse pointer/cursor
• KeyboardInput: Changes in the state of keyboard keys (keypresses, not text)
• ReceivedCharacter: Unicode text input from the OS (correct handling of the user's language and layout)
• TouchInput: Change in the state of a finger touching the touchscreen
• GamepadEvent: Changes in the state of a gamepad or any of its buttons or axes
• GamepadEventRaw: Gamepad events unaffected by GamepadSettings

System and Control Events

Events from the OS / windowing system, or to control Bevy.

• RequestRedraw: In an app that does not refresh continuously, request one more update before going to sleep
• AppExit: Tell Bevy to shut down
• CreateWindow: Tell Bevy to open a new window
• FileDragAndDrop: The user drag-and-dropped a file into our app
• CursorEntered: OS mouse pointer/cursor entered one of our windows
• CursorLeft: OS mouse pointer/cursor exited one of our windows
• WindowCloseRequested: OS wants to close one of our windows
• WindowCreated: New application window opened
• WindowFocused: One of our windows is now focused
• WindowMoved: OS/user moved one of our windows
• WindowResized: OS/user resized one of our windows
• WindowScaleFactorChanged: One of our windows has changed its DPI scaling factor
• WindowBackendScaleFactorChanged: OS reports change in DPI scaling factor for a window

Components

The complete list of individual component types is too specific to be useful to list here.

See: (List in API Docs)

Curated/opinionated list of the most important built-in component types:

• Transform: Local transform (relative to parent, if any)
• GlobalTransform: Global transform (in the world)
• Parent: Entity's parent, if in a hierarchy
• Children: Entity's children, if in a hierarchy
• Handle<T>: Reference to an asset of specific type
• Visibility: Manually control visibility, whether to display the entity (hide/show)
• ComputedVisibility: Check if an entity should be rendered (is it hidden? is it culled?)
• RenderLayers: Group entities into "layers" and control which "layers" a camera should display
• AnimationPlayer: Make the entity capable of playing animations; used to control animations
• Camera: Camera used for rendering
• UiCameraConfig: Can be used to disable or configure UI rendering for a specific camera
• Camera2d: Configuration parameters for 2D cameras
• Camera3d: Configuration parameters for 3D cameras
• OrthographicProjection: Orthographic projection for a camera
• PerspectiveProjection: Perspective projection for a camera
• Sprite: (2D) Properties of a sprite, using a whole image
• TextureAtlasSprite: (2D) Properties of a sprite, using a sprite sheet
• PointLight: (3D) Properties of a point light
• SpotLight: (3D) Properties of a spot light
• DirectionalLight: (3D) Properties of a directional light
• NoFrustumCulling: (3D) Cause this mesh to always be drawn, even when not visible by any camera
• NotShadowCaster: (3D) Disable entity from producing dynamic shadows
• NotShadowReceiver: (3D) Disable entity from having dynamic shadows of other entities
• Wireframe: (3D) Draw object in wireframe mode
• Node: (UI) Mark entity as being controlled by the UI layout system
• Style: (UI) Layout properties of the node
• Interaction: (UI) Track interaction/selection state: if the node is clicked or hovered over
• UiImage: (UI) Image to be displayed as part of a UI node
• [UiColor][bevy::UiColor]: (UI) Color to use for a UI node
• Button: (UI) Marker for a pressable button
• Text: Text to be displayed

GLTF Asset Labels

Asset path labels to refer to GLTF sub-assets.

The following asset labels are supported ({} is the numerical index):

• Scene{}: GLTF Scene as Bevy Scene
• Node{}: GLTF Node as GltfNode
• Mesh{}: GLTF Mesh as GltfMesh
• Mesh{}/Primitive{}: GLTF Primitive as Bevy Mesh
• Texture{}: GLTF Texture as Bevy Image
• Material{}: GLTF Material as Bevy StandardMaterial
• DefaultMaterial: as above, if the GLTF file contains a default material with no index
• Animation{}: GLTF Animation as Bevy AnimationClip
• Skin{}: GLTF mesh skin as Bevy SkinnedMeshInverseBindposes

Stages

Internally, Bevy has at least these built-in stages:

• In the main_app (StartupStage, run once at app startup): PreStartup, Startup, PostStartup
• In the main app (CoreStage, run every frame update): First, PreUpdate, Update, PostUpdate, Last
• In the render sub-app (RenderStage): Extract, Prepare, Queue, PhaseSort, Render, Cleanup