These examples demonstrate how to use Bevy's features in a minimal, easy to understand way. Click an example below to run it in your browser (using WASM + WebGPU) and view the source code. You can also view these examples (and others) in the Bevy repo.

Support Warning

WebGPU is currently only supported on Chrome starting with version 113, and only on desktop. If they don't work on your configuration, you can check the WebGL2 examples here.

2D Rendering#

Renders simple 2D primitive shapes like circles and polygons

Demonstrates how to use the `Camera::viewport_to_world_2d` method

Illustrates bloom post-processing in 2d

Showcases bounding volumes and intersection tests

Manually read/write the pixels of a texture

Renders a glTF mesh in 2D with a custom vertex attribute

Used to test alpha modes with mesh2d

Demonstrates UV-mapping of the circular segment and sector primitives

Renders a custom mesh 'manually' with 'mid-level' renderer apis

Renders a 2d mesh with vertex color attributes

Renders a 2d mesh

Changes the transform of a sprite

Shows how to create graphics that snap to the pixel grid by rendering to a texture in 2D

Demonstrates rotating entities in 2D with quaternions

Animates a sprite in response to an event

Renders a sprite flipped along an axis

Renders an animated sprite

Showcases slicing sprites into sections that can be scaled independently via the 9-patch technique

Renders a sprite tiled in a grid

Renders a sprite

Generates text in 2D

Demonstrates transparency in 2d

3D Rendering#

Simple 3D scene with basic shapes and lighting

A scene showcasing the built-in 3D shapes

Demonstrates how to use the `Camera::viewport_to_world` method

Shows how to animate material properties

A scene showcasing the atmospheric fog effect

Showcases different blend modes

Illustrates bloom configuration using HDR and emissive materials

Demonstrates using different sub view effects on a camera

Demonstrates color grading

Renders meshes with both forward and deferred pipelines

A scene showcasing the distance fog effect

Simple showcase of how to generate a custom mesh with a custom texture

Illustrates various lighting options in a simple scene

Loads and renders a glTF file as a scene, including the gltf extras

Loads and renders a glTF file as a scene

Demonstrates ray casting with the `MeshRayCast` system parameter

Shows how to create a 3D orthographic view (for isometric-look in games or CAD applications)

Demonstrates use of a normal map and depth map for parallax mapping

Demonstrates parent->child relationships and relative transformations

Demonstrates use of Physically Based Rendering (PBR) properties

Demonstrates the built-in postprocessing features

Query primitives in a glTF scene

Shows how to render to a texture, useful for mirrors, UI, or exporting images

Demonstrates how shadow biases affect shadows in a 3d scene

Demonstrates how to prevent meshes from casting/receiving shadows in a 3d scene

Demonstrates how point light radius values affect light behavior

Demonstrates how to render two cameras to the same window to accomplish 'split screen'

Illustrates spot lights

Shows configuration of texture materials

Compares tonemapping options

Showcases light transmission in the PBR material

Demonstrates transparency in 3d

Renders two 3d passes to the same window from different perspectives

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

Shows the use of vertex colors

Demonstrates visibility ranges

Demonstrates volumetric fog and lighting

Animation#

Plays an animation from a skinned glTF

Create and play an animation defined by code that operates on the `Transform` component

Shows how to use animation clips to animate UI properties

Demonstrate how to use animation events

Blends multiple animations together with a graph

Demonstrates animation masks

Demonstrates how to animate colors using mixing and splines in different color spaces

Skinned mesh example with mesh and joints data defined in code

Demonstrates the application of easing curves to animate an object

Showcases the built-in easing functions

Skinned mesh example with mesh and joints data loaded from a glTF file

Plays an animation from a glTF file with meshes with morph targets

Application#

An empty application with default plugins

Illustrate how to use generate log output

Demonstrates the creation and registration of a custom plugin group

Demonstrates the creation and registration of a custom plugin

Assets#

Implements a custom asset loader

Embed an asset in the application binary and load it

Demonstrates how to wait for multiple assets to be loaded.

How to configure the texture to repeat instead of the default clamp to edges

Audio#

Shows how to load and play an audio file, and control how it's played

Shows how to load and play an audio file

Shows how to create and register a custom audio source by implementing the `Decodable` type.

Shows how to directly play a simple pitch

Shows how to play different soundtracks based on game state

Shows how to play spatial audio, and moving the emitter in 2D

Shows how to play spatial audio, and moving the emitter in 3D

Diagnostics#

Shows how to create a custom diagnostic

Shows how to disable/re-enable a Diagnostic during runtime

Add a plugin that logs diagnostics, like frames per second (FPS), to the console

ECS (Entity Component System)#

Shows how to iterate over combinations of query results

Demonstrates event propagation with observers

Demonstrates observers that react to events (both built-in life-cycle events and custom events)

Games#

Eat the cakes. Eat them all. An example 3D game

An implementation of the classic game 'Breakout'.

Displays each contributor as a bouncy bevy-ball!

Demonstrates how to create a loading screen that waits for all assets to be loaded and render pipelines to be compiled.

Shaders#

A shader that uses dynamic data like the time since startup

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.

Shows that multiple instances of a cube are automatically instanced in one draw call

Demonstrates how to enqueue custom draw commands in a render phase

A custom post processing effect, using a custom render pass that runs after the main pass

A shader that renders a mesh multiple times in one draw call using low level rendering api

A shader that reads a mesh's custom vertex attribute

A custom shader that builds on the standard material

A shader that uses 'shaders defs' (a bevy tool to selectively toggle parts of a shader)

A shader and a material that uses it on a 2d mesh

A shader that uses the GLSL shading language

A shader that samples a texture with view-independent UV coordinates

A shader and a material that uses it

Demonstrates how to write a specialized mesh pipeline

A shader that shows how to bind a storage buffer using a custom material.

Stress Tests#

A heavy sprite rendering workload to benchmark your system with Bevy

Displays many animated sprites in a grid arrangement with slight offsets to their animation timers. Used for performance testing.

Test rendering of many UI elements

Test rendering of many cameras and lights

Simple benchmark to test per-entity draw overhead. Run with the `sphere` argument to test frustum culling

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

Test rendering of many gizmos

Simple benchmark to test text rendering.

Simple benchmark to test rendering many point lights. Run with `WGPU_SETTINGS_PRIO=webgl2` to restrict to uniform buffers and max 256 lights

Displays many sprites in a grid arrangement! Used for performance testing. Use `--colored` to enable color tinted sprites.

Tools#

Shows a visualization of gamepad buttons, sticks, and triggers

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#

Illustrates how to (constantly) rotate an object around an axis

A demonstration of Transform's axis-alignment feature

Illustrates how to scale an object in each direction

Shows multiple transformations of objects

Illustrates how to move an object along an axis

UI (User Interface)#

Demonstrates how to create a node with a border

Demonstrates how to create a node with a shadow

Illustrates creating and updating a button

Demonstrates how Display and Visibility work in the UI.

Demonstrates how the AlignItems and JustifyContent properties can be composed to layout nodes and position text

Illustrates how FontAtlases are populated (used to optimize text rendering internally)

Demonstrates the use of Ghost Nodes to skip entities in the UI layout hierarchy

An example for CSS Grid layout

Simple example demonstrating the OverflowClipMargin style property

An example to debug overflow and clipping behavior

Simple example demonstrating overflow behavior

Showcases the RelativeCursorPosition component

An example of rendering UI as a part of a 3D world

Demonstrates scrolling UI containers

Demonstrates how the to use the size constraints to control the size of a UI node.

An example for debugging text layout

Demonstrates text wrapping

Illustrates creating and updating text

Demonstrates transparency for UI

Demonstrates creating and using custom Ui materials

Illustrates how to scale the UI

Illustrates how to use 9 Slicing for TextureAtlases in UI

Illustrates how to use TextureAtlases in UI

Illustrates how to flip and tile images with 9 Slicing in UI

Illustrates how to use 9 Slicing in UI

Illustrates various features of Bevy UI

An example for debugging viewport coordinates

Demonstrates how to control the relative depth (z-position) of UI elements

Window#

Creates a solid color window

Handles custom user events within the event loop

Demonstrates settings to reduce power use for bevy applications

Illustrates how to customize the default window settings

Shows how to save screenshots to disk

Demonstrates resizing and responding to resizing a window

Demonstrates customizing default window settings

Math#

Exhibits different modes of constructing cubic curves using splines

Demonstrates how to add custom primitives and useful traits for them.

Demonstrates how to sample random points from mathematical primitives

Shows off rendering for all math primitives as both Meshes and Gizmos

Demonstrates all the primitives which can be sampled.

Demonstrates how to make an entity smoothly follow another using interpolation

Gizmos#

A scene showcasing 2D gizmos

A scene showcasing 3D gizmos

Demonstrates the function of axes gizmos

A scene showcasing light gizmos

Dev tools#

Demonstrates FPS overlay

Camera#

A simple 2D screen shake effect

A 2D top-down camera smoothly following player movements

Shows how to orbit a static scene using pitch, yaw, and roll.

A first-person camera that uses a world model and a view model with different field of views (FOV)

Shows how to zoom orthographic and perspective projection cameras.

Movement#

Handles input, physics, and rendering in an industry-standard way by using a fixed timestep

Picking#

Demonstrates picking meshes

Demonstrates how to use picking events to spawn simple objects

Demonstrates picking sprites and sprite atlases