This Week in Bevy

What happened this week in the Bevy Engine ecosystem

Links

WESL, Recursive run_system, and Transform Propagation Optimization

2025-03-17

This week in Bevy we see experimental WESL support land! This is an exciting, very early look into some community driven extensions to WGSL.

The transform propagation system gets a nice optimization for static scenes, run_system becomes recursively callable, and the Bevy Remote Protocol takes steps towards OpenRPC support.

We also see a visual history of the development of Settletopia, 3d g-force hud, and Curveball (a curve generating tool for Neverball level developers).

Experimental WESL support

WESL is a community-driven portable superset of WGSL and the pre-MVP 0.1.x has been released! It intends to add features like imports, conditional compilation, packaging, and more to WGSL, which aligns with how Bevy uses WGSL generally.

#17953 introduces Bevy support for WESL as a shader source, which enables loading .wesl shaders.

This is experimental support, so don't expect to mix shaders via naga-oil yet but use this as a chance to check out the new shader_material_wesl example and some of the new WESL language syntax for imports, etc.

children! in updated examples

A large number of the Bevy examples now take advantage of the new children! macro that came with the recent improved spawning apis.

tests for helpers

Bevy's examples contain some "helper" code, especially when the functionality isn't directly related to the example's purpose but it is still useful to have, like camera controllers in non-camera examples.

#18288 adds a new examples/helpers directory for "library" style examples. Currently this includes a camera_controller and ui widgets.

Bevy Remote Protocol: OpenRPC

A first step towards OpenRPC support for the Bevy Remote Protocol. #18068 introduces an rpc.discover endpoint that follows the spec.

SpawnableList for Vec

Spawning related entities is a recent addition to the Bevy spawn APIs. For example Children::spawn(...). #18259 introduces a more direct way to spawn a Vec of Bundles by implementing SpawnableList. Previously this was achievable through the use of SpawnIter which required iterating the Vec.

Children::spawn(vec![
    (
        Name::new("first element"),
        Transform::from_xyz(0., 10., 0.),
    ),
    (
        Name::new("second element"),
        Transform::from_xyz(10., 10., 0.),
    ),
]);

Recursive run_system

As of #18076, run_system will requeue the system's command queue enabling the ability to recursively call run_system.

#[derive(Resource)]
pub struct Test {
    id: SystemId,
    counter: u32,
}

let mut world = World::new();
let id = world.register_system(|mut commands: Commands, mut test: ResMut<Test>| {
    print!("{:?} ", test.counter);
    test.counter -= 1;
    if test.counter > 0 {
        commands.run_system(test.id);
    }
});
world.insert_resource(Test { id, counter: 5 });
world.run_system(id).unwrap();

Saturation trait for bevy_color

#18202 introduces a new set of saturation APIs encapsulated in a Saturation trait.

fn next_golden(&mut self) -> Color {
    self.current
        .rotate_hue((1.0 / GOLDEN_RATIO) * 360.0)
        .with_saturation(self.rand_saturation())
        .with_luminance(self.rand_luminance())
        .into()
}

Decoupled naga for wgpu testing

The ability to test upcoming wgpu features in Bevy is an important capability that is made easier this week through #18099, which decouples some of the rendering internals allowing the testing of newer wgpu versions.

Transform propagation optimization

Another speed boost in Transform propagation lands this week with #18093 optimizing the algorithm to mark static subtrees. This means scenes with largely static Transforms see a big speedup.

System Config Genericization

Following a great writeup, #17962 reduces duplication between IntoSystemConfigs and IntoSystemSetConfigs, potentially setting the groundwork for issue #14195: "Support .run_if() on observers"

Alice's Merge Train is a maintainer-level view into active PRs and how the Bevy sausage is made.

Showcase

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

rendering crowds

Rendering Crowds

showcase

Crowd rendering for an upcoming game. The crowds walk around the outer part of a square as well as the offshoot platform.

dlss sneak peak

DLSS sneak peak

showcase

A sneak peak at DLSS alongside the rest of the options in the Bevy anti-aliasing example. (This is not coming in 0.16)

ability system

Composable Ability System

showcase

A composable ability system. Items are entities with "affixes" which can be equipped by another entity. The item can then "pass on" effects to the equipping entity.

(
    affix_type: "Test",
    tags: [],
    level_requirement: 1,
    stats: {
        "MeditateLevels": 1.0,
    },
    grants: {
        "IncreasedLife": 25.0,
    },
    requires: ([]),
    weight: 0.0,
    children: [
        (
            stats: {
                "ExplosionEffect": {
                    "radius": "root.AddedLife / 10",
                    "damage": {
                        "min": 10.0,
                        "max": 50.0,
                    },
                },
                "MeditateIntervalCue": 1.0,
                "TargetThis": 1.0
            },
            requires: ([]),
        ),
    ],
)
esp32-c6

Conways Game of Life: esp32-c6

showcase

Conway's Game of Life Bare Metal demo using Bevy no_std + esp-hal 1.0.0. It runs on 1.47 inch ESP32-C6 Waveshare display, with decent framerate, including DMA and framebuffer

GitHub
mesh slicing

Mesh slicing

showcase

A demo of mesh-slicing a torus with an egui based debug ui to control the slicing.

3d hud

3D heads up display

showcase

A 3D heads up display and camera affected by g-forces. 3D text is from bevy_rich_text_3d

curveball

Curveball

showcase

Curveball is a curve generating tool for Neverball level developers. You can use it on the web and check out the git repo

Visit
computroniumcomputronium servers

Computronium

showcase

Computronium is an automation game like Factorio or Satisfactory with an emphasis on computer hardware and networks.

This week:

  • Walls can now be placed in the world and snap to foundations
  • Servers can now be added to and removed from rack slots
  • A new sprint ability was added
  • The first music track was composed
hybrid raytracing shader

Hybrid raytracing shader

showcase

Using shadybug for development, this hybrid raytracing shader is ready for GDC and working on an iPad.

image segmentation

vulkan-cuda interop

showcase

This demo is running as a node in the render graph using an image segmentation model running in pytorch via pyo3. the main render texture is exported from vulkan via wgpu-hal to cuda and then exposed as a cuda array to torch in a python script.

Visit
onward v2

Onward v2

showcase

A Code for a Cause jam entry, Onward v2 takes advantage of Blender's custom properties and Bevy's support for GltfExtras.

weiqi

Weiqi Dungeon

showcase

A game inspired by Go/Weiqi and made with a bevy ascii terminal crate for the 7Day Roguelike game jam!

hexroll

Hexroll dice rolls

showcase

Using Avian3D to roll infinite dice for HEXROLL3. Hexroll is essentially a procedural sandbox generator mixed together with a virtual table top.

to build a home shopping menu

To Build a Home: Shopping Menu

showcase

A weekend project for To Build a Home: a functioning shopping menu, built with Bevy UI.

grass and foliage

Foliage and Grass

showcase

Upgrades to a foliage shader that brings faked cloud-darkening noise, fog, and waves in the wind.

bevy_old_tv_shader

bevy_old_tv_shader 2d camera support

showcase

2d camera support for an old tv style shader that can optionally apply the bevy_old_tv_shader effect to UI and text as well

GitHub
learning shaders

Learning Shader Programming

showcase

Progress in learning vertex and fragment shaders with the goal of making audio reactive visualizers with bevy and WGSL

mevy

Mevy Macros

showcase

New macro additions to mevy, a collection of bevy macros

  • >> observes an event and queues a closure command
  • .. means a short syntax for 'on event' World mutation
  • using > will only provide EntityCommands and the Event
GitHub
moonshot mission

Moonshot Mission

showcase

This is the first third of the first level of Moonshot Mission. The game is inspired by Star Fox 64 and has about 12 levels planned out

Crates

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

bevy_mod_outline

bevy_mod_outline 0.9.1

crate_release

bevy_mod_outline is a mesh outlining crate that supports both the vertex extrusion and jump-flood methods

0.9.1 brings:

  • New double-sided outlining modes for non-manifold geometry.
  • Support for outlining shapes defined using the alpha channel of a texture
crates.io

Bevy Replicon 0.31.0

crate_release

bevy_replicon is a crate for server-authoritative networking.

0.31 brings

  • Connected clients are now represented as entities.
  • Switch from bincode to postcard

As a result of preparing for a talk on the crate at Bevy Meetup #9, the quickstart guide was rewritten as well. The quickstart guide now contains details on how to write a messaging backend or implement client-side prediction.

crates.io

bevy_save

crate_release

bevy_save enables you to easily save and load your entire application state, including resources.

crates.io

bevy_radix_sort

crate_release

bevy_radix_sort is a low-level GPU-based radix sort implementation that's optimized for sorting u32 key/value pairs.

If you're interested in sorting algorithms like this one, check out the state of the art in GPU sorting including a wgsl implementation of OneSweep

crates.io

bevy_ecs_tiled v0.6.0

crate_release

bevy_ecs_tiled is a Bevy plugin for working with 2D tilemaps created with the Tiled map editor. It relies upon the official Tiled Rust bindings to parse and load Tiled map files and the bevy_ecs_tilemap crate to perform rendering. bevy_ecs_tiled aims to provide a simple and ergonomic workflow by using Tiled as an editor when working on Bevy 2D games.

0.6 brings:

  • Support for Tiled world
  • Aggregate physics colliders from tiles to improve global performances
  • Better support for infinite maps
  • Rework loading events to use both entity-scoped observers and regular events
GitHub

Devlogs

vlog style updates from long-term projects

Programming isn't enough

devlog

A devlog look into a year-long development effort for a digital, competitive card game. The devlog topic is how focusing on programming isn't enough for a commercial game.

Visit

The Development History of Settletopia

devlog

A largely visual history of the development of Settletopia, which can now be wishlisted on Steam

Visit
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