bevyengine/bevy

Lore

This page is the narrative history of Bevy: where it came from, what changed and when, what got rewritten or thrown away. The hard data lives in by-the-numbers; this page tells the story.

Every era and milestone below is anchored to a date taken from git log or release tags.

Eras

The legion era (Nov 2019 – Mar 2020)

Bevy's first commit landed on 2019-11-12. The initial commits (new legion version, use wgpu example as base) reveal the original technology choices: the legion ECS as the data model and wgpu as the renderer.

This era was a one-person project. Cart (the founder, Carter Anderson) prototyped a renderer, asset loader, and entity hierarchy on top of legion. The commits read like an afternoon-by-afternoon engineering journal.

By late 2019 the project already had:

wgpu-based rendering (the choice that has stayed throughout Bevy's life).
Legion entities and components.
nalgebra for math (later replaced by glam).
Asset loading.

The custom-ECS era (Apr–Aug 2020)

In early-to-mid 2020 the legion ECS was replaced with a hand-rolled archetypal ECS that became bevy_ecs. This was driven by the need for finer control over scheduling and component storage. The custom ECS is what makes Bevy's parallel scheduler possible: every system declares its access pattern in its parameter types, and the scheduler computes a conflict graph at register time.

nalgebra was replaced by glam around the same period for performance reasons. glam produced smaller, faster SIMD-aware vector types and has been Bevy's math foundation ever since.

The 0.1 release and the open community (Aug 2020 – Mar 2021)

Bevy 0.1 was announced on Cart's blog on 2020-08-10. It was the first version available on crates.io. The reception was rapid: contributor count grew from ~5 to ~70 in the first six months. The bevyengine GitHub org was formed; the Discord, RFCs repo, and assets repo all date from this period.

The train release schedule — a new minor version every three months — emerged in this era and has held ever since.

Version	Date	Headline change
0.2	Sep 2020	Render graph; basic textures
0.3	Nov 2020	Custom ECS; new `Plugin` system
0.4	Dec 2020	Wasm support; bundles
0.5	Apr 2021	Asset hot reloading; gltf loader; UI

The "Pipelined Rendering" era (Apr 2021 – Apr 2022)

A multi-release effort split the renderer from the rest of the engine and put it in its own SubApp. The result was a pipelined frame loop: the main world for frame N+1 starts running while the GPU is still rendering frame N.

This era introduced:

SubApp in bevy_app, with separate Worlds for game logic and rendering.
ExtractSchedule, the only synchronization point between worlds each frame.
Render graph nodes as the unit of GPU work.
PBR materials (bevy_pbr) — Bevy's first real lighting model.

Version	Date	Headline change
0.6	Jan 2022	Pipelined rendering, PBR, deferred shading prep
0.7	Apr 2022	New scheduling primitives

The "Stageless" era (Apr 2022 – Jul 2023)

The next big architectural pivot was the move from "stages" (a linear list of named phases) to a schedule graph with run conditions, system sets, and explicit ordering constraints. RFC 45 (the "stageless" RFC) defined the new model. The migration spanned 0.10 and 0.11.

Version	Date	Headline change
0.8	Jul 2022	Plugin groups; new gltf path
0.9	Nov 2022	New scene format; pipelined rendering matures
0.10	Mar 2023	Stageless scheduling lands; ECS schedule graph
0.11	Jul 2023	Morph targets; WebGPU; better UI; deferred renderer

The stageless changes ripple through the API to this day — the schedule labels (Update, PostUpdate, FixedUpdate) replaced the old CoreStage enum.

The asset rewrite (Nov 2023 – Feb 2024)

The asset system was replaced in 0.12. The new design (under crates/bevy_asset/src/) added:

Asset processor for offline asset transformation.
Pluggable asset sources (filesystem, embedded, network).
Strict handle types with proper lifetime tracking.
AssetMode to choose between loading or processing pipelines.

Version	Date	Headline change
0.12	Nov 2023	New asset system; tonemapping LUTs; environment maps
0.13	Feb 2024	Lightmaps; one-shot systems; `Mesh` improvements

The ECS-as-API era (Jul 2024 – Apr 2025)

A series of releases reworked the ECS API to make it more ergonomic for both library authors and game developers. Highlights:

Observers (crates/bevy_ecs/src/observer/) — event handlers that run in response to component lifecycle events.
Hooks — per-component callbacks attached at registration time.
Required components — declarative dependencies between component types.
Relationships — first-class entity-to-entity links, replacing the old Parent/Children adhoc setup.

Version	Date	Headline change
0.14	Jul 2024	Computed states; reflection upgrades; rounded corners
0.15	Nov 2024	Required components; observers; better picking
0.16	Apr 2025	GPU-driven rendering prep; one-shot systems mature

The split-renderer era (Sep 2025 – present)

In 0.17–0.19 the rendering crates were broken apart. What used to live in a single bevy_render crate is now spread across bevy_camera, bevy_mesh, bevy_image, bevy_material, bevy_light, bevy_shader, bevy_anti_alias, bevy_post_process, bevy_sprite_render, bevy_gizmos_render, bevy_ui_render, and others. The point is to let users pick a custom renderer without dragging in unrelated code.

In parallel, bevy_solari (experimental ray-traced lighting) and bevy_feathers (the new built-in widget set) were added as independent crates.

Version	Date	Headline change
0.17	Sep 2025	Renderer split begins; new UI widgets crate (`bevy_feathers`)
0.18	Jan 2026	More renderer crate splits; `bevy_world_serialization`; BSN scene format
0.19-dev	(in progress)	Ongoing renderer modularization, BSN polish, observer improvements

Longest-standing features

bevy_app::App — the public top-level entry point. The App::new().add_plugins(...).run() pattern has been there since 0.2 (Sep 2020) and survives essentially unchanged.
Component and Resource traits — the public ECS surface has been stable since the custom-ECS era; the implementation underneath has been rewritten three times.
Plugin trait — added in 0.3 (Nov 2020) and unchanged since. Every other API in Bevy is built on it.
wgpu as the rendering backend — chosen in commit two of the project. Has not been seriously challenged.

Deprecated features

CoreStage — the original schedule labels. Replaced by the schedule graph in 0.10 (Mar 2023).
The legion ECS — replaced by Bevy's custom ECS in mid-2020.
Parent / Children components — superseded by the relationship system in 0.15 (Nov 2024). The new types are ChildOf and Children (still using the same name but implemented over the relationship trait).
The pre-0.12 asset system — replaced wholesale in Nov 2023.
bevy_dynamic_plugin — a plugin-loading dylib system was tried then dropped because of platform reliability issues. Some scaffolding still lives in bevy_dylib (a different crate, used for fast compiles via dynamic linking).

Major rewrites

What	When	Why
ECS: legion → bevy_ecs	Mid-2020	Need control over scheduling and storage
Math: nalgebra → glam	Mid-2020	Smaller, faster, simpler
Schedule: stages → graph	0.10 (Mar 2023)	Run conditions, ordering, sets
Assets: legacy → new	0.12 (Nov 2023)	Hot reloading, asset processor
Hierarchy: Parent/Children → relationships	0.15 (Nov 2024)	First-class entity links
Renderer: monolithic → many crates	0.17–0.19 (2025–)	Modular, swappable renderers

Growth trajectory

Bevy started as a one-person project in late 2019. By the 0.5 release (Apr 2021) it had ~50 contributors. By 0.10 (Mar 2023) it had crossed 500. The current count of unique commit author emails is ~1,570.

Crate count grew accordingly:

2020: ~5 crates.
2022: ~25 crates.
2025: ~50 crates.
2026 (HEAD): ~60 crates.

Most of the recent crate growth comes from splitting bevy_render apart so that custom renderers don't have to take all of it.