This Week in Bevy

What happened this week in the Bevy Engine ecosystem

Links

Avian Character Controllers, DespawnOnExitState, and SystemParams

2025-05-12

0.16 is out and honestly I'm already seeing features land that make me want 0.17 :D

The Avian Character Control Working Group (discord invite) is an ad-hoc group of people with a shared interest in building kinematic character controllers with Avian. If that sounds like you, move and slide your way over into the dedicated Discord to find links to the prototype GitHub repo.

fn filter_spawned_after(
    entities: impl IntoIterator<Item = Entity>,
    world: &World,
    tick: Tick,
) -> impl Iterator<Item = Entity> {
    let now = world.last_change_tick();
    entities.into_iter().filter(move |entity| world
        .entity(*entity)
        .spawned_at()
        .is_newer_than(tick, now)
    )
}

SystemParam for Option and Result

A SystemParam is a type like Query, Res, Local, Commands, EventWriter/EventReader that is used as an argument to a system.

Previously there were explicit SystemParam implementations for types like Option<Res<T>> for optional Resources. As of #18766, there are generic implementations for Option<T> and Result<T, SystemParamValidationError>.

This opens up using Option with third party SystemParam implementations and more immediately enables approaches like Option<EventReader>.

When

Contrary to the aforementioned Option SystemParam, the new When

SystemParamintroduced in [#18765](https://github.com/bevyengine/bevy/pull/18765) will silently skip a system if parameter validation fails. This means you can configure a system to only run if aResource` is available by writing

fn my_system(res: When<Res<MyResource>>) {}

clone_behavior in derive Component

#18811 introduces the ability to specify the clone behavior when deriving Component, which impacts usage when taking advantage of Entity Cloning.

StateScoped renamed to DespawnOnExitState

If you've used States before, you might be familiar with StateScoped, the Component that will despawn Entities when exiting a state. In #18818 StateScoped has been renamed to DespawnOnExitState and a new DespawnOnEnterState has also been added.

It seems like there may be more forms of this coming in the future as well.

Infinite children!

In 0.16, the children! macro supports up to twelve children at once. #18865 expands the children! macro to remove that limit. You are now bound by Rust's recursion limits instead, which seem to be 1400-ish children! but spawning 1400 children is probably not the best approach so you'll likely be using this with 10s of children, not thousands.

FooSystems

A new convention for naming SystemSets has arisen in #18900. Sets of systems are now generally expected to be named with a *Systems postfix. Examples include:

  • AnimationSystems
  • TransformSystems
  • TimeSystems

Allows bypass for DefaultQueryFilters

0.16 introduced DefaultQueryFilters which means that Querys can have, well, Default filters... #18192 introduces the ability to bypass these filters, since sometimes it can be useful to ignore the filters.

Customizing Default Log Formatting

#17722 enables changing the default log formatting Bevy uses. This can be useful for reducing the amount of noise by removing timestamps, or making other adjustments.

2025-05-10T19:33:16.753152Z  INFO kinematic_character_controller::kcc: current_velocity_magnitude=0.46875

Here's how it works

fn fmt_layer(_app: &mut App) -> Option<bevy::log::BoxedFmtLayer> {
    Some(Box::new(
        bevy::log::tracing_subscriber::fmt::Layer::default()
            .without_time()
            .with_writer(std::io::stderr),
    ))
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(bevy::log::LogPlugin {
            fmt_layer,
            ..default()
        }))
        .run();
}

Viewport UI Widget

viewport

A new examples/ui/viewport_node.rs introduced in #17253 shows off a new ViewportNode, which can turn a UI Node into a viewport.

This viewport uses a camera to determine what to show and can even handle picking (including dragging in and out of the viewport).

Text Background Colors

background colors

#18892 introduces background colors for text using a new TextBackgroundColor Component! Note that this effect works best on monospace fonts. If you use a proportional font the backgrounds might not line up with each letter in the same exact way.

Showcase

Bevy work from the #showcase channel in Discord and around the internet. Use hashtag #bevyengine.

bug bounty

Bug Bounty

showcase

Bug Bounty is a bug-collecting game made for the Fireside 2025 Jam

world-space ui

World space gizmo

showcase

An attempt to make a gizmo where you drag the colored circles to modify the spaceship’s trajectory

2d visibility

2d Visibility

showcase

A 2d visibility algorithm ported to Rust and Bevy. The idea is that this can be reused for various 2d games in the future as it has several uses beyond visibility for example AI or light / shadow radius, and it can be combined with shaders for postprocessing as well.

opportunity

My battery is low and it's getting dark

showcase

A game about a moon rover, who has to complete his tasks before his final battery runs out. It includes a postprocessing shader to implement bayer dithering for the visual style.

bevy inspection

Bevy Inspection

showcase

An alternative VSCode inspector that prioritizes tight coupling with VSCode’s UI capabilities for real-time interaction. It focuses on answering two questions:

  1. Can we make component editing in Bevy feel as seamless as debugging in Unity/Unreal?,
  2. How far can we push VSCode’s extension API for game dev tooling?
Visit
abysm

Abysm: The Pale Queen

showcase

The first episode/demo of Abysm: a retro arcade puzzle game. The first episodes features 18 levels, and based on play tests, around 1-2 hours of gameplay. It has most of the features expected from a full game

car sandbox

Car physics Sandbox

showcase

A neon car physics sandbox updated to Bevy 0.16

Visit
rain

deki-world: Custom Rain

showcase

Rain VFX and more for deki-world

foxtrot

Foxtrot: TheDarkMod

showcase

Progress on a port of TheDarkMod fan mission "Volta I: The Stone". The intended use is as a Foxtrot template demo.

card game

Slavic Castles

showcase

Slavic Castles is an old card game prototype that was recently updated to Bevy 0.16.

GitHub
star strategy

Space Strategy

showcase

An in-progress space strategy game that just reworked its stars.

a melon game on game boy advance

mel0n-2

showcase

Physics on the game boy advance with Bevy! One library, two platforms.

GitHub
big buck bunny tv

Big Buck Bunny on TV

showcase

A demo streaming webp video (Big Buck Bunny) into a TV in a Bevy scene.

physics based midi sequencer

Tombola: Physics-based MIDI sequencer

showcase

Tombola is a physics-based midi sequencer built on Avian for physics, bevy_egui for menus and midir for midi handling.

GitHub
simulo

Simulo Trailer

showcase

Simulo is a 2D physics sandbox game where you can build and share creations. Play with electricity, fluid simulation, and mod support. A built-in story campaign with physics challenges is included.

Simulo can be wishlisted on Steam

Visit
gnome village

Gnome Village

showcase

Gnome Village is an open source cozy colony sim. Implemented features include world generation, settlers taking on jobs, chopping stuff down, building stuff up, and watering plants.

GitHub
bevy tanks

Bevy Tanks

showcase

Bevy Tanks is a simple 3d tank game with projectiles, particles, and of course: tanks, on an open plane. Its the authors first published Bevy project and makes use of bevy_rapier, bevy_tnua, bevy_enhanced_input, and bevy_rand.

Source is available on GitHub

Crates

New releases to crates.io and substantial updates to existing projects

Lightyear 0.20

crate_release

Lightyear is a full-featured server-client networking library for bevy.

0.20 brings no-std support, batch replication, and a hierarchy replication refactor.

GitHub

seldom_state

crate_release

seldom_state is a plugin that adds a StateMachine component that you can add to your entities. The state machine will change the entity's components based on states, triggers, and transitions that you define.

This update also adds StateMachine::on_exit_from, StateMachine::on_enter_to, etc so you can detect when the state machine transitions from and to given states. The former runs before the transition occurs and the latter runs after.

GitHub

bevy_rand v0.11

crate_release

bevy_rand is a plugin to integrate rand for ECS optimized RNG for the Bevy game engine.

This is a small but breaking change release, as bevy_rand now has optional bevy_reflect dependency, allowing for bevy_rand to be even leaner for no_std. For most people using bevy_rand with default features, this changes nothing. Those who are in no_std land and need bevy_reflect now need to specify it explicitly in features

crates.io

bevy_fix_cursor_unlock_web

crate_release

bevy_fix_cursor_unlock_web

A tiny plugin that fixes Bevy not reporting when the cursor is unlocked on web To use it, just add FixPointerUnlockPlugin, done. Now, Window::cursor_options::grab_mode is automatically set to CursorGrabMode::None for you when unlocking the cursor on web.

This fixes https://github.com/bevyengine/bevy/issues/8949

GitHub

bevy_play_card 0.2

crate_release

bevy_play_card is a card crate with support for observer and Component based APIs.

GitHub

bevy_aseprite_ultra v0.6

crate_release

Hot reload animations and slices directly from an aseprite binary file.

0.6 brings new default render targets (Sprite, Ui and 3D), support for custom material targets, and a new simpler to use API.

GitHub

Avian Physics 0.3 🪶

crate_release

Avian is an ECS-driven physics engine for Bevy.

v0.3 is another huge release, with several new features, quality-of-life improvements, and important bug fixes. Highlights include:

  • Opt-in contact reporting: Collision events are now only sent for entities that have the CollisionEventsEnabled component, reducing unwanted overhead and iteration.
  • Observable collision events: Observers finally support collision events, making it easy to define per-entity collision handlers.
  • Collision hooks: Users can "hook into" the collision pipeline, making it possible to efficiently filter and modify contacts.
  • Per-manifold material properties: Friction, restitution, and tangent velocity can be modified for contact manifolds, allowing the simulation of non-uniform materials and conveyor belts.
  • Collider context: Custom colliders that implement AnyCollider have a Context for ECS access.
  • Physics diagnostics: Avian has built-in diagnostics and a debug UI for runtime physics profiling.
  • Reworked contact pair management: Contacts have been massively reworked to reduce allocations and unnecessary work while increasing parallelism.
  • Faster collisions and spatial queries: Collisions and spatial queries have much less overhead.
  • Bevy 0.16 support: Avian has been updated to the latest version of Bevy, and is taking advantage of relationships for attaching colliders to rigid bodies.

Check out the announcement blog post for a more in-depth overview of what has changed and why. A changelog and migration guide can be found on GitHub.

Visit

bevy-mesh-text-3d

crate_release

bevy-mesh-text-3d is a small crate to create extruded 3d text via cosmic text

GitHub

schminput 0.3.0

crate_release

an input manager for bevy, using actions and action sets, built with bevy_mod_openxr in mind.

crates.io
No devlogs this week
No Educational this week
Pull Requests Merged This Week
Contributing

Want to contribute to Bevy?

Here you can find two types of potential contribution: Pull Requests that might need review and Issues that might need to be worked on.

How do I contribute?

Pull Requests Opened this week

Issues Opened this week