bevy/examples

Examples

These examples demonstrate the main features of Bevy and how to use them. To run an example, use the command cargo run --example <Example>, and add the option --features x11 or --features wayland to force the example to run on a specific window compositor, e.g.

cargo run --features wayland --example hello_world

⚠️ Note: for users of releases on crates.io!

There are often large differences and incompatible API changes between the latest crates.io release and the development version of Bevy in the git main branch!

If you are using a released version of bevy, you need to make sure you are viewing the correct version of the examples!

• Latest release: https://github.com/bevyengine/bevy/tree/latest/examples
• Specific version, such as 0.4: https://github.com/bevyengine/bevy/tree/v0.4.0/examples

When you clone the repo locally to run the examples, use git checkout to get the correct version:

# `latest` always points to the newest release
git checkout latest
# or use a specific version
git checkout v0.4.0

---

Table of Contents

• Examples

  • Table of Contents

• The Bare Minimum

  • Hello, World!

• Cross-Platform Examples

  • 2D Rendering
  • 3D Rendering
  • Animation
  • Application
  • Assets
  • Async Tasks
  • Audio
  • Diagnostics
  • ECS (Entity Component System)
  • Games
  • Input
  • Reflection
  • Scene
  • Shaders
  • Stress Tests
  • Tools
  • Transforms
  • UI (User Interface)
  • Window

• Tests

• Platform-Specific Examples

  • Android
    • Setup
    • Build & Run
    • Old phones
  • iOS
    • Setup
    • Build & Run
  • WASM
    • Setup
    • Build & Run
    • Loading Assets

The Bare Minimum

Hello, World!

Example	Description
hello_world.rs	Runs a minimal example that outputs "hello world"

Cross-Platform Examples

2D Rendering

Example	Description
2D Rotation	Demonstrates rotating entities in 2D with quaternions
2D Shapes	Renders a rectangle, circle, and hexagon
Manual Mesh 2D	Renders a custom mesh "manually" with "mid-level" renderer apis
Mesh 2D	Renders a 2d mesh
Mesh 2D With Vertex Colors	Renders a 2d mesh with vertex color attributes
Move Sprite	Changes the transform of a sprite
Sprite	Renders a sprite
Sprite Flipping	Renders a sprite flipped along an axis
Sprite Sheet	Renders an animated sprite
Text 2D	Generates text in 2D
Texture Atlas	Generates a texture atlas (sprite sheet) from individual sprites
Transparency in 2D	Demonstrates transparency in 2d

3D Rendering

Example	Description
3D Scene	Simple 3D scene with basic shapes and lighting
3D Shapes	A scene showcasing the built-in 3D shapes
Lighting	Illustrates various lighting options in a simple scene
Lines	Create a custom material to draw 3d lines
Load glTF	Loads and renders a glTF file as a scene
MSAA	Configures MSAA (Multi-Sample Anti-Aliasing) for smoother edges
Orthographic View	Shows how to create a 3D orthographic view (for isometric-look in games or CAD applications)
Parenting	Demonstrates parent->child relationships and relative transformations
Physically Based Rendering	Demonstrates use of Physically Based Rendering (PBR) properties
Render to Texture	Shows how to render to a texture, useful for mirrors, UI, or exporting images
Shadow Biases	Demonstrates how shadow biases affect shadows in a 3d scene
Shadow Caster and Receiver	Demonstrates how to prevent meshes from casting/receiving shadows in a 3d scene
Skybox	Load a cubemap texture onto a cube like a skybox and cycle through different compressed texture formats.
Spherical Area Lights	Demonstrates how point light radius values affect light behavior
Split Screen	Demonstrates how to render two cameras to the same window to accomplish "split screen"
Spotlight	Illustrates spot lights
Texture	Shows configuration of texture materials
Transparency in 3D	Demonstrates transparency in 3d
Two Passes	Renders two 3d passes to the same window from different perspectives
Update glTF Scene	Update a scene from a glTF file, either by spawning the scene as a child of another entity, or by accessing the entities of the scene
Vertex Colors	Shows the use of vertex colors
Wireframe	Showcases wireframe rendering

Animation

Example	Description
Animated Fox	Plays an animation from a skinned glTF
Animated Transform	Create and play an animation defined by code that operates on the Transform component
Custom Skinned Mesh	Skinned mesh example with mesh and joints data defined in code
glTF Skinned Mesh	Skinned mesh example with mesh and joints data loaded from a glTF file

Application

Example	Description
Custom Loop	Demonstrates how to create a custom runner (to update an app manually)
Drag and Drop	An example that shows how to handle drag and drop in an app
Empty	An empty application (does nothing)
Empty with Defaults	An empty application with default plugins
Headless	An application that runs without default plugins
Logs	Illustrate how to use generate log output
No Renderer	An application that runs with default plugins and displays an empty window, but without an actual renderer
Plugin	Demonstrates the creation and registration of a custom plugin
Plugin Group	Demonstrates the creation and registration of a custom plugin group
Return after Run	Show how to return to main after the Bevy app has exited
Thread Pool Resources	Creates and customizes the internal thread pool
Without Winit	Create an application without winit (runs single time, no event loop)

Assets

Example	Description
Asset Loading	Demonstrates various methods to load assets
Custom Asset	Implements a custom asset loader
Custom Asset IO	Implements a custom asset io loader
Hot Reloading of Assets	Demonstrates automatic reloading of assets when modified on disk

Async Tasks

Example	Description
Async Compute	How to use AsyncComputeTaskPool to complete longer running tasks
External Source of Data on an External Thread	How to use an external thread to run an infinite task and communicate with a channel

Audio

Example	Description
Audio	Shows how to load and play an audio file
Audio Control	Shows how to load and play an audio file, and control how it's played

Diagnostics

Example	Description
Custom Diagnostic	Shows how to create a custom diagnostic
Log Diagnostics	Add a plugin that logs diagnostics, like frames per second (FPS), to the console

ECS (Entity Component System)

Example	Description
Component Change Detection	Change detection on components
Custom Query Parameters	Groups commonly used compound queries and query filters into a single type
ECS Guide	Full guide to Bevy's ECS
Event	Illustrates event creation, activation, and reception
Fixed Timestep	Shows how to create systems that run every fixed timestep, rather than every tick
Generic System	Shows how to create systems that can be reused with different types
Hierarchy	Creates a hierarchy of parents and children entities
Iter Combinations	Shows how to iterate over combinations of query results
Parallel Query	Illustrates parallel queries with ParallelIterator
Removal Detection	Query for entities that had a specific component removed in a previous stage during the current frame
Startup System	Demonstrates a startup system (one that runs once when the app starts up)
State	Illustrates how to use States to control transitioning from a Menu state to an InGame state
System Closure	Show how to use closures as systems, and how to configure Local variables by capturing external state
System Parameter	Illustrates creating custom system parameters with SystemParam
System Piping	Pipe the output of one system into a second, allowing you to handle any errors gracefully
System Sets	Shows SystemSet use along with run criterion
Timers	Illustrates ticking Timer resources inside systems and handling their state

Games

Example	Description
Alien Cake Addict	Eat the cakes. Eat them all. An example 3D game
Breakout	An implementation of the classic game "Breakout"
Contributors	Displays each contributor as a bouncy bevy-ball!
Game Menu	A simple game menu

Input

Example	Description
Char Input Events	Prints out all chars as they are inputted
Gamepad Input	Shows handling of gamepad input, connections, and disconnections
Gamepad Input Events	Iterates and prints gamepad input and connection events
Keyboard Input	Demonstrates handling a key press/release
Keyboard Input Events	Prints out all keyboard events
Keyboard Modifiers	Demonstrates using key modifiers (ctrl, shift)
Mouse Grab	Demonstrates how to grab the mouse, locking the cursor to the app's screen
Mouse Input	Demonstrates handling a mouse button press/release
Mouse Input Events	Prints out all mouse events (buttons, movement, etc.)
Touch Input	Displays touch presses, releases, and cancels
Touch Input Events	Prints out all touch inputs

Reflection

Example	Description
Generic Reflection	Registers concrete instances of generic types that may be used with reflection
Reflection	Demonstrates how reflection in Bevy provides a way to dynamically interact with Rust types
Reflection Types	Illustrates the various reflection types available
Trait Reflection	Allows reflection with trait objects

Scene

Example	Description
Scene	Demonstrates loading from and saving scenes to files

Shaders

These examples demonstrate how to implement different shaders in user code.

A shader in its most common usage is a small program that is run by the GPU per-vertex in a mesh (a vertex shader) or per-affected-screen-fragment (a fragment shader.) The GPU executes these programs in a highly parallel way.

There are also compute shaders which are used for more general processing leveraging the GPU's parallelism.

Example	Description
Animated	A shader that uses dynamic data like the time since startup
Array Texture	A shader that shows how to reuse the core bevy PBR shading functionality in a custom material that obtains the base color from an array texture.
Compute - Game of Life	A compute shader that simulates Conway's Game of Life
Custom Vertex Attribute	A shader that reads a mesh's custom vertex attribute
Instancing	A shader that renders a mesh multiple times in one draw call
Material	A shader and a material that uses it
Material - GLSL	A shader that uses the GLSL shading language
Material - Screenspace Texture	A shader that samples a texture with view-independent UV coordinates
Post Processing	A custom post processing effect, using two cameras, with one reusing the render texture of the first one
Shader Defs	A shader that uses "shaders defs" (a bevy tool to selectively toggle parts of a shader)

Stress Tests

These examples are used to test the performance and stability of various parts of the engine in an isolated way.

Due to the focus on performance it's recommended to run the stress tests in release mode:

cargo run --release --example <example name>

Example	Description
Bevymark	A heavy sprite rendering workload to benchmark your system with Bevy
Many Animated Sprites	Displays many animated sprites in a grid arrangement with slight offsets to their animation timers. Used for performance testing.
Many Buttons	Test rendering of many UI elements
Many Cubes	Simple benchmark to test per-entity draw overhead. Run with the sphere argument to test frustum culling
Many Foxes	Loads an animated fox model and spawns lots of them. Good for testing skinned mesh performance. Takes an unsigned integer argument for the number of foxes to spawn. Defaults to 1000
Many Lights	Simple benchmark to test rendering many point lights. Run with WGPU_SETTINGS_PRIO=webgl2 to restrict to uniform buffers and max 256 lights
Many Sprites	Displays many sprites in a grid arrangement! Used for performance testing. Use --colored to enable color tinted sprites.
Transform Hierarchy	Various test cases for hierarchy and transform propagation performance

Tools

Example	Description
Gamepad Viewer	Shows a visualization of gamepad buttons, sticks, and triggers
Scene Viewer	A simple way to view glTF models with Bevy. Just run cargo run --release --example scene_viewer /path/to/model.gltf#Scene0, replacing the path as appropriate. With no arguments it will load the FieldHelmet glTF model from the repository assets subdirectory

Transforms

Example	Description
3D Rotation	Illustrates how to (constantly) rotate an object around an axis
Global / Local Translation	Illustrates the difference between direction of a translation in respect to local object or global object Transform
Scale	Illustrates how to scale an object in each direction
Transform	Shows multiple transformations of objects
Translation	Illustrates how to move an object along an axis

UI (User Interface)

Example	Description
Button	Illustrates creating and updating a button
Font Atlas Debug	Illustrates how FontAtlases are populated (used to optimize text rendering internally)
Text	Illustrates creating and updating text
Text Debug	An example for debugging text layout
Transparency UI	Demonstrates transparency for UI
UI	Illustrates various features of Bevy UI
UI Scaling	Illustrates how to scale the UI

Window

Example	Description
Clear Color	Creates a solid color window
Low Power	Demonstrates settings to reduce power use for bevy applications
Multiple Windows	Demonstrates creating multiple windows, and rendering to them
Scale Factor Override	Illustrates how to customize the default window settings
Transparent Window	Illustrates making the window transparent and hiding the window decoration
Window Resizing	Demonstrates resizing and responding to resizing a window
Window Settings	Demonstrates customizing default window settings

Tests

Example	Description
How to Test Systems	How to test systems with commands, queries or resources

Platform-Specific Examples

Android

Setup

rustup target add aarch64-linux-android armv7-linux-androideabi
cargo install cargo-apk

The Android SDK must be installed, and the environment variable ANDROID_SDK_ROOT set to the root Android sdk folder.

When using NDK (Side by side), the environment variable ANDROID_NDK_ROOT must also be set to one of the NDKs in sdk\ndk\[NDK number].

Build & Run

To run on a device setup for Android development, run:

cargo apk run --example android_example

When using Bevy as a library, the following fields must be added to Cargo.toml:

[package.metadata.android]
build_targets = ["aarch64-linux-android", "armv7-linux-androideabi"]

[package.metadata.android.sdk]
target_sdk_version = 31

Please reference cargo-apk README for other Android Manifest fields.

Debugging

You can view the logs with the following command:

adb logcat | grep 'RustStdoutStderr\|bevy\|wgpu'

In case of an error getting a GPU or setting it up, you can try settings logs of wgpu_hal to DEBUG to get more informations.

Sometimes, running the app complains about an unknown activity. This may be fixed by uninstalling the application:

adb uninstall org.bevyengine.example

Old phones

Bevy by default targets Android API level 31 in its examples which is the Play Store's minimum API to upload or update apps. Users of older phones may want to use an older API when testing.

To use a different API, the following fields must be updated in Cargo.toml:

[package.metadata.android.sdk]
target_sdk_version = >>API<<
min_sdk_version = >>API or less<<

Example	File	Description
android	android/android.rs	The 3d/3d_scene.rs example for Android

iOS

Setup

You need to install the correct rust targets:

• aarch64-apple-ios: iOS devices
• x86_64-apple-ios: iOS simulator on x86 processors
• aarch64-apple-ios-sim: iOS simulator on Apple processors

rustup target add aarch64-apple-ios x86_64-apple-ios aarch64-apple-ios-sim

Build & Run

Using bash:

cd examples/ios
make run

In an ideal world, this will boot up, install and run the app for the first iOS simulator in your xcrun simctl devices list. If this fails, you can specify the simulator device UUID via:

DEVICE_ID=${YOUR_DEVICE_ID} make run

If you'd like to see xcode do stuff, you can run

open bevy_ios_example.xcodeproj/

which will open xcode. You then must push the zoom zoom play button and wait for the magic.

Example	File	Description
ios	ios/src/lib.rs	The 3d/3d_scene.rs example for iOS

WASM

Setup

rustup target add wasm32-unknown-unknown
cargo install wasm-bindgen-cli

Build & Run

Following is an example for lighting. For other examples, change the lighting in the following commands.

cargo build --release --example lighting --target wasm32-unknown-unknown
wasm-bindgen --out-name wasm_example \
  --out-dir examples/wasm/target \
  --target web target/wasm32-unknown-unknown/release/examples/lighting.wasm

The first command will build the example for the wasm target, creating a binary. Then, wasm-bindgen-cli is used to create javascript bindings to this wasm file, which can be loaded using this example HTML file.

Then serve examples/wasm directory to browser. i.e.

# cargo install basic-http-server
basic-http-server examples/wasm

# with python
python3 -m http.server --directory examples/wasm

# with ruby
ruby -run -ehttpd examples/wasm

Optimizing

On the web, it's useful to reduce the size of the files that are distributed. With rust, there are many ways to improve your executable sizes. Here are some.

1. Tweak your Cargo.toml

Add a new profile to your Cargo.toml:

[profile.wasm-release]
# Use release profile as default values
inherits = "release"

# Optimize with size in mind, also try "s", sometimes it is better.
# This doesn't increase compilation times compared to -O3, great improvements
opt-level = "z"

# Do a second optimization pass removing duplicate or unused code from dependencies.
# Slows compile times, marginal improvements
lto = "fat"

# When building crates, optimize larger chunks at a time
# Slows compile times, marginal improvements
codegen-units = 1

Now, when building the final executable, use the wasm-release profile by replacing --release by --profile wasm-release in the cargo command.

cargo build --profile wasm-release --example lighting --target wasm32-unknown-unknown

Make sure your final executable size is smaller, some of those optimizations may not be worth keeping, due to compilation time increases.

2. Use wasm-opt from the binaryen package

Binaryen is a set of tools for working with wasm. It has a wasm-opt CLI tool.

First download the binaryen package, then locate the .wasm file generated by wasm-bindgen. It should be in the --out-dir you specified in the command line, the file name should end in _bg.wasm.

Then run wasm-opt with the -Oz flag. Note that wasm-opt is very slow.

Note that wasm-opt optimizations might not be as effective if you didn't apply the optimizations from the previous section.

wasm-opt -Oz --output optimized.wasm examples/wasm/target/lighting_bg.wasm
mv optimized.wasm examples/wasm/target/lighting_bg.wasm

For a small project with a basic 3d model and two lights, the generated file sizes are, as of Jully 2022 as following:

profile	wasm-opt	no wasm-opt
Default	8.5M	13.0M
opt-level = "z"	6.1M	12.7M
"z" + lto = "thin"	5.9M	12M
"z" + lto = "fat"	5.1M	9.4M
"z" + "thin" + codegen-units = 1	5.3M	11M
"z" + "fat" + codegen-units = 1	4.8M	8.5M

There are more advanced optimization options available, check the following pages for more info:

• https://rustwasm.github.io/book/reference/code-size.html
• https://rustwasm.github.io/docs/wasm-bindgen/reference/optimize-size.html
• https://rustwasm.github.io/book/game-of-life/code-size.html

Loading Assets

To load assets, they need to be available in the folder examples/wasm/assets. Cloning this repository will set it up as a symlink on Linux and macOS, but you will need to manually move the assets on Windows.