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 + WebGL) and view the source code. You can also view these examples (and others) in the Bevy repo.

If you would like to try WASM + WebGPU, you can explore our live WebGPU examples page.

2D Rendering#

A scene showcasing 2D gizmos

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

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

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

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#

A scene showcasing 3D gizmos

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

Renders meshes with both forward and deferred pipelines

Stop flickering from z-fighting at a performance cost

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

Create a custom material to draw 3d lines

Loads and renders a glTF file as a scene

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

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

Animation#

Plays an animation from a skinned glTF

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

Bezier curve example showing a cube following a cubic curve

Skinned mesh example with mesh and joints data defined in code

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 AssetReader

Implements a custom asset loader

Embed an asset in the application binary and load it

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 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

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

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!

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.

A shader that reads a mesh's custom vertex attribute

A custom shader that builds on the standard material

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

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

A shader that renders a mesh multiple times in one draw call

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

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

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

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

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)

An example for CSS Grid layout

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 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 TextureAtlases 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

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#

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