This Week in Bevy

What happened this week in the Bevy Engine ecosystem

Links

New Working Groups: WESL, First-Party Tilemaps

2025-05-05

A number of new working groups have been created, alongside progress from existing groups!

The Bevy WESL-ification has begun! or rather, the working group to figure out what migrating would look like and do some testing has been created. Will WESL be enough for Bevy's needs? Tune into the working group to find out.

WESL (pronounced "weasel") is an extended version of WebGPU’s WGSL shading language that is fully compatible with WGSL. It also contains a number of features Bevy needs already, including imports, so is a potentially great choice to participate in the wider WebGPU ecosystem if it works out.

A new Tilemap Rendering working group has also started up, focusing on a rendering abstraction for 2d tilemaps. #18866 is the first work-in-progress PR to come out of the working group.

The bevy_cli: please clap working group has also produced bevy_lint 0.3.

The Bevy Linter is a custom linter, like Clippy, that checks for Bevy-specific idioms, optimizations, and footguns. 0.3 brings 2 new lints, Bevy 0.16 support, a Github Action for installing the linter in CI, documentation improvements, and more!

Showcase

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

Pop Mania!

Pop Mania!

showcase

Pop Mania! is a new casual, 2d physics-based iOS game. Shoot balls down to prevent enemies from reaching the end!

Apple
space station

Cosmos

showcase

Cosmos is a game where you can create your dream spaceship that you can pilot through space. This showcase demos in-progress space stations.

GitHub
shmupsiepoo

shmup progress

showcase

Progress on am asteroids-like shoot-em-up that has a nice particle effect when destroying asteroids.

truck on planet: planet scaletruck on planettruck on planet zoom out

Planet Level of Detail

showcase

This is a seamless progressive LOD in a fully procedurally generated planet. The video demonstrates this by first viewing a small truck in a ditch before zooming out to show the entire planet.

Visit
world generation

World Generation

showcase

A continuation on previous world generation, there are now mountains and ocean streams, and an improved triangulation that creates less artifacts. Stream currents are created by setting initial values faking the Coriolis effect and subsequent simulation.

shadow sneak

Shadow Sneak

showcase

Hide yourself in the shadows in order to avoid the knights in Shadow Sneak! Shadow Sneak is a game jam entry that makes use of the difference of gaussians crate also mentioned in this issue.

shadplayshadplay hexsphereshadplay disco

Shadplay

showcase

Shadplay is a wgsl environment you can run that functions a bit like shadertoy, but for Bevy and wgsl.

Its received a few more shader ports to explore and a number of bug fixes.

GitHub
10000+ units

10000+ units over UDP

showcase

This is a research project/proof of concept replicating thousands of units over UDP using bevy_replicon as the base replication framework and renet as the transport layer, all on an unreliable channel. Current goals of the project are:

  • Increase update rate on important (visible) units
  • In theory this should then allow for a more realistic & rigid crowd simulation
Big Buck Bunny

Streaming Video Assets: Big Buck Bunny

showcase

Playing Big Buck Bunny by only loading a few frames at a time, keeping the memory used under control and initial load instant. This is a demo of functionality in vleue_kinetoscope.

GitHub
dialogue

Data driven dialogue engine

showcase

An early look at a data-driven dialogue system for Bevy. It supports variables, conditionals (if/else/match), input, output and more. There is a completely custom working runtime, which can evaluate expressions, format fstrings, and more. All while supporting hot reloading. It is designed to also support animation instructions, which are planned. Meaning it is not just for dialogue, but you can actually script visual novel in this. (It also uses Bevy Lunex for positioning)

hatchingdifference of gaussians

Extended Difference of Gaussians

showcase

The difference of gaussians (that is, subtracting one blurred version of an image from another less blurred version of an image) can be used for edge detection and extensions to this approach can be used to create stylized images.

This showcase recreates an implementation from Acerola (Unity) for Bevy with a couple of effects.

GitHub
warhammer: dark omenwarhammer: dark omen

Warhammer: Dark Omen

showcase

A Warhammer: Dark Omen implementation in Bevy. This week brings a number of updates, including

  • Rank changes
  • animation variations for units
  • unit formations
  • scriptable lua-based campaign mode, including meeting points, travel map, battles, and debriefs
Visit
lumina in personlumina

Lumina on Itch!

showcase

Lumina, a top down, fast paced, objective based, PvP game, showcased at Malaysia's Indie Jam event.

You can check out the gameplay on YouTube and give it a play over on Itch.io

flockingflocking fish

Boidsy: Flocking Simulation

showcase

Boidsy is a real-time 2D and 3D boid (flocking) simulation. It showcases emergent behavior through local rules such as alignment, cohesion, and separation. It takes advantage of bevy_spatial.

GitHub

Crates

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

bevy_flair v0.2

crate_release

Bevy Flair enables developers to style Bevy UI interfaces using familiar CSS syntax.

crates.io
bevy color

Bevy Color VSCode extension

crate_release

Bevy Color is an extension for VS Code to preview colors declared in rust files using the Bevy game engine. It also allows adjusting them with the integrated color picker.

Visit

simple_bevy_template

crate_release

simple_bevy_template is a Bevy game template that automatically sets up fast-compiles, including Mold, Cranelift and parallel compiler frontend.

cargo generate laundmo/simple_bevy_template --allow-commands

If you don't have cargo-generate, you can get it here.

GitHub
bevy ratatui camera

bevy_ratatui_camera 0.13.0

crate_release

Render your bevy app to the terminal using ratatui.

Recent features include:

  • Subcameras and transparency support for compositing cameras together.
  • Edge detection now works for all text conversion strategies
  • Support for terminals with limited color support: 16-color, 256-color, and true-color options
GitHub

bevy_app_compute

crate_release

bevy_app_compute attempts to improve the experience of developing compute shaders for Bevy applications.

GitHub

bevy_rand v0.10

crate_release

Bevy Rand is a plugin to provide integration of rand ecosystem PRNGs in an ECS friendly way.

0.10 brings improved developer experience due to relations, observers, and a new commands-based API; resulting in less boilerplate. It also implements no_std support.

GitHub
bevy sun move

bevy_sun_move

crate_release

bevy_sun_move is a utility crate that supports the new Atmosphere functionality in 0.16.

  1. Calculate physically correct sun trajectory to achieve desired day lengths, night lengths, and maximum sun heights (noon altitude). This allows you to quickly specify game timings (like day/night cycle duration and peak sun height) while ensuring a physically plausible sun trajectory on the sky.
  2. Animate a directional light (the "sun") across the sky based on astronomical principles (latitude, year fraction, time of day). (For example sun does not always rise in the east:D)
let timed_sky_config = TimedSkyConfig {
        sun_entity: sun_id,
        day_duration_secs: 10.0, 
        night_duration_secs: 5.0,
        max_sun_height_deg: 60.0,
        planet_tilt_degrees: 23.5,
        ..default()
    };
commands.spawn((
  SkyCenter::from_timed_config(&timed_sky_config).unwrap(),
));
GitHub

bevy_lint 0.3.0

crate_release

The Bevy Linter, a project built as part of the ⁠bevy_cli: please clap working group! bevy_lint is a custom linter, like Clippy, that checks for Bevy-specific idioms, optimizations, and footguns. 0.3 brings 2 new lints, Bevy 0.16 support, a Github Action for installing the linter in CI, documentation improvements, and more!

View the release page for installation instructions

GitHub

bevy-butler 0.6.1

crate_release

bevy-butler is a set of procedural macros for reducing boilerplate and making Bevy plugins and systems more self-documenting.

0.6.1 changes up a LOT of the macro syntax, since custom parsing code has been replaced with deluxe to simplify implementations in the future.

GitHub

crowdsim 0.1.0

crate_release

A multiplayer crowd simulation binary crate that is barebones with minimal dependencies.

Documentation is in-progress

GitHub

immediate_stats

crate_release

Game stats that reset every frame, inspired by immediate mode rendering.

GitHub

bevy_fix_gltf_coordinate_system

crate_release

A tiny plugin to fix the fact that Bevy does not respect the GLTF coordinate system.

use bevy::prelude::*;
use bevy_fix_gltf_coordinate_system::prelude::*;

App::new()
  .add_plugins(DefaultPlugins)
  .add_plugins(FixGltfCoordinateSystemPlugin);

glTF uses +Z as forward, while Bevy uses -Z. However, the glTF importer ignores this fact and pretends that glTF and Bevy use the same coordinate system. The result is that all glTFs imported into Bevy are rotated by 180 degrees. This plugin fixes that.

This fix may be upstreamed in the future perhaps by you?

GitHub
bevy blockout

bevy_blockout

crate_release

bevy_blockout is a triplanar blockout texture made from a combination of The Best Darn Grid Shader Yet and some simple checkerboards.

The blockout material is a StandardMaterial extension, which means you can set whatever color, reflectance, etc variables you want. Its usable directly in bevy as well as in editors that use reflection data using a special component with hooks that consume a StandardMaterial and create the extension.

crates.io

wasvy

crate_release

wasvy is a bridge between Bevy and the WASM component model. You can create new components and register systems from a WASM component and doing it is as simple as adding another plugin to your game!

The crate is currently in alpha-status

GitHub
yarn spinner for rust

Yarn Spinner for Rust 0.5.0

crate_release

bevy_yarnspinner is the Bevy plugin for the Rust port of Yarn Spinner, the friendly tool for writing game dialogue.

In 0.5, Yarn functions can now be regular Bevy systems! This means that your functions can query the ECS directly.

Dialogue like this:

<<if get_player_money() < 3>>
Shopkeeper: Sorry, you don't have enough cash on hand
<<else>>
Shopkeeper: Pleasure doing business with you!
<<subtract_money 3>>
<<endif>>
===

Can be powered by a function like this:

fn get_player_money(
wallet: Single<Wallet, With<Player>>
) -> usize {
  wallet.available_money()
}
GitHub
No devlogs this week

Educational

Tutorials, deep dives, and other information on developing Bevy applications, games, and plugins

Intro to Relationships in Bevy 0.16

educational

A followup to How to spawn objects in Bevy 0.16, this is an introduction to the new Relationships by examining some of the ChildOf/Children behavior and then a custom Inventory example

Hooks and Observers in Bevy 0.16

educational

A video covering using Component Hooks and Observers. This is more beginner focused and covers using them rather than implementation details.

Visit
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