Skip to content
CAI
Software that uses CAICheck a score

bevyengine/bevy

54.2

Adequate · 14 November 2026

536k

lines of production code

Rust

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

2D primitive mesh builders and extrusion support

Users can now generate meshes for 2D shapes (such as Circle, Ellipse, CircularSector, and others) via dedicated builders that allow configuration of vertex resolution and UV mapping modes. Additionally, 2D primitives can be extruded into 3D geometry using the new ExtrusionBuilder, which supports customizing depth and segment count while preserving smooth or flat shading on the perimeter.

_crates/bevy\mesh/src/primitives · high confidence

Add 3D primitive mesh builders for capsule, cone, cylinder, and other shapes

Users can now generate meshes for a variety of 3D primitives directly from the \bevy\_mesh\ crate. This change introduces \MeshBuilder\ implementations for \Capsule3d\, \Cone\, \ConicalFrustum\, \Cuboid\, \Cylinder\, \Plane3d\, \Polyline3d\, \Segment3d\, \Sphere\, \Tetrahedron\, and \Torus\. These builders allow for runtime construction of meshes with customizable parameters such as resolution, subdivisions, anchor points, and UV profiles, enabling more flexible geometry creation without relying on external asset files.

_crates/bevy\mesh/src/primitives/dim3 · high confidence

Add Bevy error code documentation and definitions

The \errors\ crate now includes structured documentation and Rust definitions for runtime error codes B0001 through B0009. This adds detailed explanations, erroneous code examples, and fix solutions for issues such as conflicting query access (B0001, B0007), resource access conflicts (B0002), entity despawn timing (B0003), missing hierarchy components (B0004), font atlas limits (B0005), software renderer warnings (B0006), and placeholders for exclusive parameter conflicts (B0008, B0009). Users can now reference these codes in panic messages and consult the official documentation at bevy.org/learn/errors for guidance.

errors · high confidence

Add Contrast Adaptive Sharpening (CAS) post-processing filter

Users can now apply Contrast Adaptive Sharpening to cameras by adding the \ContrastAdaptiveSharpening\ component. This filter sharpens images based on local contrast to recover detail lost by anti-aliasing methods like FXAA or TAA, with configurable \sharpening\_strength\ (0.0–1.0) and a \denoise\ option to reduce sharpening on noisy areas. The feature is implemented via a new \CasPlugin\ that integrates the RCAS shader into the post-processing pipeline.

_crates/bevy\_anti\_alias/src/contrast\_adaptive\sharpening · high confidence

Add GizmoConfigGroup derive macro

The \bevy\_gizmos\ crate now provides a \GizmoConfigGroup\ derive macro that automatically implements the \GizmoConfigGroup\ trait for user-defined types. This macro enforces that the derived type implements \Reflect\, \TypePath\, and \Default\, and uses the Bevy manifest to resolve the correct crate paths for \bevy\_gizmos\ and \bevy\_reflect\.

_crates/bevy\gizmos/macros/src · high confidence

Add MIT license files and derive macros for render bindings

The \bevy\_render\ crate now includes MIT license files for itself and its \macros\ sub-crate, and introduces new derive macros (\AsBindGroup\, \RenderLabel\, \Specializer\, \SpecializerKey\) to simplify generating render resource bindings and pipeline specializations for user-defined types.

_crates/bevy\render · high confidence

Add Mixed Lighting Example Model

Added a new glTF example model (MixedLightingExample.gltf) that demonstrates mixed lighting scenarios. The asset includes a scene with a directional light (Sun) and various meshes, including a chair with fabric materials utilizing the KHR\_materials\_sheen extension and multiple material variants (Mango Velvet, Peacock Velvet). This model serves as a reference for how lights and materials interact in mixed lighting setups.

assets/models/MixedLightingExample · high confidence

Add Screen Space Ambient Occlusion (SSAO) to Bevy PBR

This change introduces a new Screen Space Ambient Occlusion (SSAO) plugin to the \bevy\_pbr\ crate, enabling contact shadows and local occlusion effects to make 3D scenes appear more grounded. Users can enable the effect by adding the \ScreenSpaceAmbientOcclusion\ component to a 3D camera, which automatically requires the necessary depth and normal prepasses. The implementation includes a configurable quality level (Low, Medium, High, Ultra, or Custom) and exposes a \radius\ parameter to control the maximum sample distance. The feature relies on new WESL shader libraries for depth preprocessing, visibility calculation, and spatial denoising, and it requires a GPU with support for at least 5 storage textures per shader stage.

_crates/bevy\pbr/src/ssao · high confidence

Add bevy\_gizmos\_render crate with license and documentation

The bevy\_gizmos\_render crate is now included in the repository, providing the rendering implementation for Bevy gizmos. This addition includes the Apache-2.0 and MIT license files and a README, establishing the crate's legal and documentation foundation for users integrating gizmo rendering into their Bevy applications.

_crates/bevy\_gizmos\render · high confidence

Add bevy\_input\_focus crate

The \bevy\_input\_focus\ crate has been added to the Bevy repository. This entry documents the initial inclusion of the crate, which provides the Apache 2.0 and MIT license files and a README.md for the new module.

_crates/bevy\_input\focus · high confidence

Add bevy\_material crate with macro support

The new bevy\_material crate provides procedural macros for generating shader and draw function labels. It includes derive macros for ShaderLabel and DrawFunctionLabel, which automatically implement the corresponding traits by leveraging the Bevy manifest to locate the correct paths. The crate also includes standard Apache-2.0 and MIT license files and a README.

_crates/bevy\material/macros · high confidence

Add bevy\_reflect benchmarks for functions, lists, maps, paths, and structs

New benchmark suites have been added to the \benches/benches/bevy\_reflect\ directory to measure the performance of core reflection types. The \function.rs\ file benchmarks function info retrieval, conversion to reflected functions, invocation via \ArgList\, cloning, and function overloading. The \list.rs\ and \map.rs\ files benchmark operations on concrete and dynamic collections, including applying patches, converting to dynamic types, and inserting or pushing elements across various sizes. The \struct.rs\ file benchmarks field access, applying patches, retrieving type info, and converting to dynamic structs for structs with varying field counts. Additionally, \path.rs\ benchmarks the parsing of reflect paths, and \main.rs\ wires these groups together using Criterion.

_benches/benches/bevy\reflect · high confidence

Add example world serialization file

An example serialized world file (load\_scene\_example.scn.ron) has been added to the assets directory, demonstrating the structure of a serialized world including resources, entities with components like Name and Transform, and asset roots.

_assets/serialized\worlds · high confidence

Add font license files for Fira Mono, Fira Sans, KeySymbols, and Noto Sans Symbols 2

The Bevy Feathers toolkit now includes the required license texts for its bundled fonts (Fira Mono, Fira Sans, KeySymbols, and Noto Sans Symbols 2) under the SIL Open Font License and Bitstream Vera licenses, ensuring proper attribution and legal compliance for these assets.

_crates/bevy\feathers/src/assets/fonts · high confidence

Add gizmo rendering for 2D and 3D shape primitives

Users can now visualize geometric shapes from the \bevy\_shape\ crate directly in the gizmo overlay. This change introduces \GizmoPrimitive2d\ and \GizmoPrimitive3d\ traits and their implementations for types such as \Circle\, \Arc2d\, \Capsule2d\, \Sphere\, \Cone\, \Torus\, and \Plane3d\. The \Plane3d\ gizmo specifically renders a configurable grid aligned with the plane's normal. This allows developers to debug and inspect shape positions, rotations, and scales using the standard gizmo system.

_crates/bevy\gizmos/src/primitives · high confidence

Add integer rectangle types IRect and URect to bevy\_math

The \bevy\_math\ crate now exposes \IRect\ (signed 32-bit) and \URect\ (unsigned 32-bit) alongside the existing \Rect\ (floating-point). These new types provide axis-aligned rectangle operations using integer coordinates, including constructors like \new\, \from\_corners\, and \from\_center\_size\, as well as properties like \width\, \height\, and \size\. They support serialization and reflection when the respective features are enabled, allowing users to work with pixel-perfect or grid-based geometry without floating-point conversion.

_crates/bevy\math/src/rects · high confidence

Add opt-in screen-space reflections for the deferred renderer

Users can now enable screen-space reflections (SSR) on cameras by adding the \ScreenSpaceReflections\ component, which is available only with the deferred rendering pipeline. This feature implements an opt-in, high-quality raymarching algorithm that reflects visible scene geometry, with configurable parameters for roughness fading, raymarch steps, and edge fadeout. The implementation includes a new \ScreenSpaceReflectionsPlugin\, GPU uniform buffers for per-view settings, and a WGSL shader (\raymarch.wesl\) that handles depth buffer sampling and root-finding logic, while noting that WebGL 2 is currently unsupported due to depth buffer sampling limitations.

_crates/bevy\pbr/src/ssr · high confidence

Add remote inspection capability to the Bevy Inspector

The inspector now supports inspecting a separate, running Bevy application over the Bevy Remote Protocol. This change introduces a new \remote\ module containing a \RemoteSource\ for configuring the connection (host and port), a \RemoteConnection\ resource that manages the polling lifecycle and connection state, and a \RemoteWorld\ that mirrors remote entities into a local mirror world. The inspector's entity tree and details panel are updated to read from this mirrored world, allowing users to view and interact with remote entities without affecting the local application state. Also in this area: 4 commits (1 fix) modifying crates/bevy\_inspector.

_crates/bevy\inspector/src/remote · medium confidence · unverified

Add screen-space transmission rendering for transmissive materials

A new \ScreenSpaceTransmissionPlugin\ introduces screen-space transmission effects, allowing users to render objects that refract and blur the background (such as glass or water). By attaching the \ScreenSpaceTransmission\ component to a camera, users can control the visual fidelity via a \quality\ setting (Low, Medium, High, Ultra) and the number of rendering \steps\ to handle multiple layers of transparency. The feature is opt-in and requires the camera to have active opaque, alpha-mask, and transparent passes to function correctly.

_crates/bevy\pbr/src/transmission · high confidence

Add static display widgets for icons and text labels

The \bevy\_feathers\ crate now includes a new \display\ module providing static, non-interactive UI components. This adds \icon\ and \icon\_untinted\ helpers to render images as \ImageNode\s, with the themed variant automatically tinting to match the current text color. It also introduces \label\, \label\_dim\, \label\_small\, and \caption\ functions to render text with consistent font sizing, weights, and theme-aware colors.

_crates/bevy\feathers/src/display · high confidence

Add support for baked lightmaps with bindless texture optimization

Users can now apply baked indirect diffuse global illumination to meshes by adding a \Lightmap\ component, which references a texture and a UV rectangle for atlas support. The rendering system extracts these lightmaps into the render world, allowing multiple meshes to share lightmap data efficiently. On platforms that support bindless textures, the implementation groups up to four lightmaps into a single binding array (slab) to reduce draw calls, while falling back to single-binding mode otherwise. The feature also includes an option for higher-quality bicubic sampling on lightmap textures.

_crates/bevy\pbr/src/lightmap · high confidence

Add tool to generate Bevy documentation pages for examples and features

A new CLI tool in \tools/build-templated-pages\ has been added to automatically generate and update documentation pages for the Bevy website. The tool parses \Cargo.toml\ to extract example metadata and feature definitions (including profiles and collections), validates that required metadata and \doc-scrape-examples\ flags are present, and renders the data into Markdown files using Tera templates. Users can run the tool with \check-missing\ to validate metadata completeness or \update\ to regenerate the \examples/README.md\ and \docs/cargo\_features.md\ files.

tools/build-templated-pages · high confidence

Add volumetric fog and light shafts (god rays) post-processing effect

This change introduces a new physically-based volumetric fog and lighting system, allowing directional lights to cast visible light shafts (god rays) through fog volumes. Users can enable this by adding \VolumetricFog\ to cameras and \VolumetricLight\ to directional lights. The effect uses screen-space raymarching combined with shadow map sampling and the Henyey-Greenstein phase function to model light scattering and absorption. It supports optional 3D voxel density textures for localized fog regions and integrates with the existing PBR pipeline as a post-processing step.

_crates/bevy\_pbr/src/volumetric\fog · high confidence

Added AnisotropyBarnLamp model with PBR anisotropy support

A new 3D model asset, AnisotropyBarnLamp, has been added to the assets/models directory. This glTF file includes the KHR\_materials\_anisotropy extension, enabling realistic directional specular highlights on the lamp's metal components when rendered in compatible viewers.

assets/models/AnisotropyBarnLamp · high confidence

Added Flight Helmet 3D model asset

A new Flight Helmet model has been added to the application's assets, provided as a glTF 2.0 file. This asset includes multiple mesh components (such as Hose, RubberWood, GlassPlastic, MetalParts, LeatherParts, and Lenses) with associated geometry and material definitions, enabling the rendering of the helmet in the scene.

assets/models/FlightHelmet · high confidence

Added Order-Independent Transparency (OIT) resolve pass

The core pipeline now includes a new OIT resolve plugin that composites per-pixel linked lists of transparent fragments into the final screen color. This feature requires GPU support for fragment-writable storage buffers and a minimum of three storage buffers per shader stage. The resolve pass handles depth testing (optionally using a depth prepass) and blends transparent fragments using a sorted linked-list algorithm to achieve correct transparency ordering without sorting overhead.

_crates/bevy\_core\pipeline/src/oit/resolve · high confidence

Added PalmTree 3D model asset

A new PalmTree model (PalmTree.gltf) has been added to the assets/models directory. This glTF 2.0 file, exported from Blender, defines a scene containing multiple nodes including meshes and bezier curves, making the palm tree asset available for use in the application's 3D environment.

assets/models/PalmTree · high confidence

Added Ryfjallet cubemap asset and documentation

A new Ryfjallet cubemap texture asset has been added to the assets/textures directory, accompanied by a readme file detailing the modifications made to the original work by Emil Persson (Humus) using ImageMagick and its Creative Commons Attribution 3.0 license.

assets/textures · high confidence

Added SimpleSkin glTF model with mesh skinning support

A new glTF asset (SimpleSkin.gltf) has been added to the assets/models/SimpleSkin directory. This model demonstrates mesh skinning capabilities, including joint definitions, inverse bind matrices, and vertex attributes for joints and weights, along with a basic animation channel targeting node rotation.

assets/models/SimpleSkin · high confidence

Added Speeder D ship model

A new 3D model for the 'craft\_speederD' ship has been added to the assets/models/ship directory. This glTF asset includes geometry, materials (metal, metalDark, dark, metalRed), and buffer data, enabling the use of this specific ship model in the application, such as in the Transform::align example.

assets/models/ship · high confidence

Added cube and sphere 3D model assets

The application now includes standard geometric 3D models for a cube and a sphere. These assets are provided as glTF 2.0 files (with associated binary buffers) generated via the Khronos glTF Blender I/O plugin, enabling their use in rendering scenes.

assets/models/cube, assets/models/sphere · high confidence

Added developer tool to generate color conversion test data

A new \gen\_tests\ utility has been added to the \bevy\_color\ crate to generate pre-computed test data for validating color conversion functions across multiple color spaces (including Srgba, Hsla, Oklch, and Okhsl). This tool is intended for developer use only to produce the \test\_colors.rs\ file and is not part of the public Bevy library.

_crates/bevy\_color/crates/gen\tests · high confidence

Added easing function visualizations and MIT license

The \bevy\_curve\ crate now includes SVG visualizations for various easing functions (such as Back, Bounce, Circular, Cubic, and Elastic) to help users understand their behavior, and an MIT license file has been added to the crate.

_crates/bevy\curve · high confidence

Added low-poly flight helmet model asset

A new low-poly flight helmet model (FlightHelmetLowPoly.gltf) has been added to the assets directory. This asset includes multiple mesh components representing parts such as glass, plastic, leather, lenses, rubber, wood, and metal, along with associated PBR materials and textures.

assets/models/FlightHelmetLowPoly · high confidence

Added mesh shader intro example

A new shader example demonstrating mesh shader pipelines has been added to the assets. This includes the task, mesh, and fragment shader stages along with their shared bindings, allowing users to explore mesh shader capabilities within the engine.

_assets/shaders/mesh\_shader\intro · high confidence

Added morph target stress test model

A new glTF asset, MorphStressTest.gltf, has been added to the animated models directory. This file defines a mesh with eight morph targets (named Key 1 through Key 8) and includes three distinct animations ('Individuals', 'Pulse', and 'TheWave') that drive the morph weights, providing a test case for rendering complex morph target animations.

assets/models/animated · high confidence

Added mountain terrain model asset

A new glTF model file (Mountains.gltf) and its associated binary data (Mountains.bin) have been added to the assets/models/terrain directory. This asset defines a grid-based mesh with PBR materials, including specular and index-of-refraction extensions, intended for use in terrain rendering.

assets/models/terrain · high confidence

Added tool to generate EaseFunction SVG graphs for documentation

A new utility tool located at \tools/build-easefunction-graphs\ has been added to automatically generate SVG visualizations for all \EaseFunction\ variants (including linear, sine, quadratic, cubic, quartic, quintic, circular, exponential, elastic, back, bounce, and step functions) defined in the \bevy\_curve\ crate. This tool iterates through the available easing functions, computes their curve samples, and saves individual SVG files into the \crates/bevy\_curve/images/easefunction\ directory, providing visual references for the documentation.

tools/build-easefunction-graphs · high confidence

Android logging support via Android NDK

The \bevy\_log\ crate now includes a dedicated tracing layer for Android that routes log events directly to the Android NDK log system (\android\_log\_sys\). This ensures that Bevy's internal tracing and logging output is visible in Android's native logcat, providing better visibility for debugging applications on that platform.

_crates/bevy\log/src · high confidence

Automatic background motion vectors for temporal effects

Cameras with the MotionVectorPrepass now automatically generate motion vectors for background pixels (sky, solid color, etc.) based on camera rotation. This ensures that temporal effects like TAA and motion blur work correctly on areas without geometry. Users can opt out of this automatic behavior by adding the NoBackgroundMotionVectors component to a camera, which is useful if they are providing custom background motion vectors for their own effects.

_crates/bevy\_core\pipeline/src/prepass · high confidence

Bevy ECS v2: foundational architecture and core primitives

This change introduces the core \bevy\_ecs\ crate, establishing the foundational architecture for the engine's Entity Component System. It provides the primary data structures for managing entities and components, including \Archetype\ and \Table\ for efficient storage layout, and \World\ for the global state. The implementation includes the \ChildOf\ and \Children\ components to manage entity hierarchies, a \Disabled\ component with default query filters to hide entities from queries without despawning them, and a lifecycle system with hooks (\on\_add\, \on\_remove\, etc.) and change detection (\Added\, \Changed\) to react to state modifications. It also introduces the \define\_label!\ macro and \Interned\ types for efficient, deduplicated identification of system sets and labels, alongside a new \BatchingStrategy\ to control parallel iteration performance.

_crates/bevy\ecs/src · high confidence

Deferred rendering pipeline implementation with lighting ID tracking and occlusion culling

The deferred rendering pipeline in the core pipeline crate is now fully implemented, introducing a dedicated deferred prepass that renders opaque and alpha-masked 3D geometry into G-buffers (normals, motion vectors, and deferred data). This change adds a new \CopyDeferredLightingId\ pipeline and plugin to extract and store lighting pass IDs into a depth texture, enabling subsequent lighting passes to identify which lights affect which pixels. The implementation includes early and late prepass stages, with the late stage supporting GPU-based occlusion culling when enabled. Phase items for deferred rendering are sorted by pipeline and mesh to improve batching, and the system handles resolution overrides and WebGL2-specific texture clearing workarounds.

_crates/bevy\_core\pipeline/src/deferred · high confidence

Derive macros for Asset and VisitAssetDependencies traits

The \bevy\_asset\ crate now provides procedural macros to automatically implement the \Asset\ and \VisitAssetDependencies\ traits. Users can derive these traits on structs and enums, optionally marking specific fields with the \\#\[dependency\]\ attribute to enable automatic dependency tracking. The implementation supports generic types and handles both struct and enum variants, while explicitly rejecting unions.

_crates/bevy\asset/macros/src · high confidence

Docs.rs extension adds trait tags to Bevy documentation

Adds a docs.rs extension that injects visual tags into generated documentation pages to indicate which core Bevy traits (such as Component, Resource, Plugin, and Event) a type implements. The extension includes a README with instructions for third-party crates to integrate the styling and a JavaScript/CSS snippet that detects trait implementations and displays them as colored badges, improving the readability of Bevy API docs.

docs-rs · high confidence

Experimental hierarchical Z-buffer generation for occlusion culling

The \bevy\_core\_pipeline\ crate now includes an experimental module for generating hierarchical Z-buffers (depth pyramids) to support occlusion culling. This change introduces Rust systems (\early\_downsample\_depth\ and \late\_downsample\_depth\) and a WGSL shader (\downsample\_depth.wesl\) that implement single-pass downsampling to create mipmaps from depth textures. These components allow the renderer to build the depth hierarchy required for efficient occlusion queries, with support for both main view depth buffers and shadow map depth textures.

_crates/bevy\_core\_pipeline/src/mip\generation/experimental · high confidence

FXAA anti-aliasing support added to Bevy

Users can now enable Fast Approximate Anti-Aliasing (FXAA) on cameras via the new \Fxaa\ component. This feature allows tuning the algorithm's sensitivity through \edge\_threshold\ and \edge\_threshold\_min\ settings (Low, Medium, High, Ultra, Extreme) to balance sharpness and smoothness. The implementation integrates FXAA as a post-processing step in the render pipeline, running after tonemapping for both 2D and 3D views.

_crates/bevy\_anti\alias/src/fxaa · high confidence

Feathers UI toolkit restructured with new container widgets and comprehensive control implementations

The \bevy\_feathers\ crate has been significantly reorganized and expanded. New container widgets—\flex\_spacer\, \group\, \pane\, and \subpane\—have been added to support structured UI layouts. The controls module now includes fully implemented widgets for buttons, checkboxes, color inputs, color planes, color sliders, color swatches, color swatch grids, and color wheels, all utilizing the new \bsn!\ scene syntax and \bevy\_ui\_widgets\ primitives. This change introduces a more opinionated, theme-aware widget set for building Bevy tooling interfaces.

_crates/bevy\feathers/src/controls · high confidence

Frame time graph visualization added to FPS overlay

The FPS overlay now includes a visual frame time graph that renders historical frame duration data as a bar chart. This feature uses a new WESL shader to draw bars with heights proportional to frame time (on a logarithmic scale) and configurable widths, with colors interpolating from green to red based on performance. The graph is driven by the FrameTimeDiagnosticsPlugin and can be enabled or disabled via the FpsOverlayConfig.

_crates/bevy\_dev\_tools/src/frame\_time\graph · high confidence

GPU-accelerated clustering for lights, light probes, and decals

The clustering logic for lights, light probes, and decals has moved from the CPU to the GPU to improve performance. This change introduces a new \GpuClusteringPlugin\ and a suite of WESL shaders (\cluster\_z\_slice\, \cluster\_raster\, \cluster\_allocate\) that handle the entire clustering pipeline on the GPU: slicing objects into Z-layers, rasterizing them to count cluster intersections, and allocating object IDs in tightly packed buffers. The system automatically falls back to CPU clustering on devices that do not support the required storage buffers or compute shaders, and is currently disabled on Android and iOS simulators due to hardware/driver limitations.

_crates/bevy\pbr/src/cluster · high confidence

Gamepad input now exposes raw events alongside filtered ones

The \bevy\_gilrs\ plugin has been refactored to send both filtered \GamepadEvent\ instances (for standard input handling) and new \RawGamepadEvent\ variants (\RawGamepadButtonChangedEvent\, \RawGamepadAxisChangedEvent\, \GamepadConnectionEvent\). This allows users to access unprocessed input data directly from the Gilrs backend, enabling custom input mapping or advanced features like raw rumble control, while maintaining backward compatibility with existing filtered event consumers.

_crates/bevy\gilrs/src · high confidence

Hot-reloading support for embedded assets

Users can now enable the \embedded\_watcher\ feature to automatically reload embedded assets when their source files change on disk. This adds an \EmbeddedWatcher\ that monitors the original source files, reads updates from the filesystem, and overwrites the static bytes embedded in the binary, allowing for live development workflows with assets that are normally baked into the executable.

_crates/bevy\asset/src/io/embedded · high confidence

Initial release of the Bevy Remote Protocol (BRP)

The \bevy\_remote\ crate is introduced, providing the Bevy Remote Protocol to allow remote inspection and modification of a Bevy application's ECS world. This includes a JSON-RPC 2.0 over HTTP server implementation (\RemoteHttpPlugin\) listening on port 15702 by default, and an asynchronous HTTP client (\BrpClient\) for external tooling. The protocol exposes built-in methods for querying and mutating entities, resources, and components, as well as inspecting the application state, schedules, and diagnostics.

_crates/bevy\remote · high confidence

Initial release of the bevy\_winit crate

The \bevy\_winit\ crate is introduced as a new component of the Bevy engine, providing the \WinitPlugin\ to handle window creation, input event processing, and the application event loop via the \winit\ library. This release includes core infrastructure for accessibility integration through AccessKit, support for custom cursors (including image and texture atlas assets), and platform-specific features such as Feral Interactive's GameMode on Linux. It also establishes the foundational event conversion logic between \winit\ types and Bevy's input and window systems.

_crates/bevy\_sprite, crates/bevy\winit · high confidence

Introduce BSN (Bevy Scene Notation) macros for declarative scene definition

The \bevy\_scene\ crate now includes the \bsn!\ and \bsn\_list!\ procedural macros, which allow users to define scenes using a concise, declarative syntax. This new notation supports inserting components, patching values, including other scenes, and managing entity relationships directly within the macro, providing a more ergonomic alternative to programmatic scene construction.

_crates/bevy\scene · high confidence

Introduce BSN file format lexing, parsing, and AST

The \bevy\_bsn\ crate now provides the foundational infrastructure for the BSN file format, including a lexer (\lex.rs\) that tokenizes source text, a parser (\parse.rs\) that constructs an Abstract Syntax Tree (AST) defined in \types.rs\, and supporting utilities for token streams and source spans. This change adds the core parsing logic and data structures required to interpret BSN documents, enabling downstream components to consume structured scene definitions.

_crates/bevy\bsn · high confidence

Introduce Bevy Audio crate with playback, spatial audio, and volume controls

This change adds the \bevy\_audio\ crate, providing a complete audio system for Bevy applications. Users can now play audio sources via the \AudioPlayer\ component, with playback behavior (once, loop, despawn, remove) and initial settings (volume, speed, muted, paused, spatial) configured through \PlaybackSettings\. The system supports spatial audio using \SpatialListener\ and \GlobalVolume\ resources, allowing for 3D panning based on entity transforms. It exposes \AudioSink\ and \SpatialAudioSink\ components for runtime control of playback (play, pause, stop, seek, mute, volume adjustment) and includes built-in support for common audio formats (WAV, OGG, MP3, FLAC) via the \AudioLoader\. The \Volume\ type supports both linear and decibel scales, and the \Pitch\ asset allows for generating sine wave tones.

_crates/bevy\audio/src · high confidence

Introduce Bevy Feathers, an opinionated widget toolkit for Bevy tooling

This change adds the \bevy\_feathers\ crate, providing a cohesive set of styled and themed UI widgets (such as buttons, sliders, checkboxes, and text inputs) designed for building Bevy editors and inspectors. It introduces a comprehensive theming system using semantic tokens and surface levels, a default dark theme, and a standard color palette. The toolkit includes infrastructure for focus outlines, inheritable font styles, and rounded corner configurations, along with embedded assets like the Fira Sans/Mono fonts and specific icons to ensure a consistent look and feel out of the box.

_crates/bevy\feathers/src · high confidence

Introduce Bevy Material crate with alpha modes and pipeline descriptors

The new \bevy\_material\ crate provides the core abstractions for defining and rendering materials. It introduces \AlphaMode\ to control transparency behavior (Opaque, Mask, Blend, Premultiplied, AlphaToCoverage, Add, Multiply) and \OpaqueRendererMethod\ to select between Forward and Deferred rendering paths. The crate also defines \MaterialProperties\ to hold per-instance configuration (such as depth bias, shadow/OIT flags, and shader/draw-function handles) and low-level \RenderPipelineDescriptor\ structures to describe vertex, fragment, and mesh pipeline states, including bind group layouts and pipeline-overridable constants.

_crates/bevy\material/src · high confidence

Introduce FullscreenMaterial trait for custom post-processing effects

The \bevy\_core\_pipeline\ crate now includes a \FullscreenMaterial\ trait and associated plugin infrastructure, allowing users to define custom post-processing effects that run on a fullscreen triangle. This new capability provides a standardized way to inject custom rendering passes into the core 3D and 2D pipelines by implementing the trait, which handles pipeline initialization, bind group preparation, and scheduling within the \Core3dSystems::PostProcess\ set. The implementation includes a dedicated fullscreen vertex shader and integrates with the existing render graph systems to ensure these custom effects are executed in the correct order relative to other post-processing steps like tonemapping.

_crates/bevy\_core\pipeline/src · high confidence

Introduce MeshletMesh asset format and GPU-driven culling pipeline

Adds support for the \MeshletMesh\ asset type, allowing static meshes to be pre-processed into clusters (meshlets) with BVH-based culling and LOD selection. This includes a new asset loader/saver for \.meshlet\_mesh\ files, a Rust-side mesh builder (\from\_mesh\) that generates the meshlet data structures, and a suite of WESL compute shaders (\cull\_instances\, \cull\_bvh\, \cull\_clusters\) that perform visibility, frustum, and occlusion culling on the GPU to optimize rendering of large scenes.

_crates/bevy\pbr/src/meshlet · high confidence

Introduce \`bevy\_transform\` as a standalone, \`no\_std\`-compatible crate

The \bevy\_transform\ crate is now available as a standalone dependency, allowing users to utilize \Transform\ and \GlobalTransform\ components without pulling in the full Bevy engine. This release adds \no\_std\ support (with \std\ and \alloc\ feature gates), includes Apache-2.0 and MIT license files, and provides a \README\. The crate exposes core components, a \TransformPlugin\ for system registration, and extension traits like \BuildChildrenTransformExt\ for managing hierarchy changes while preserving global transforms.

_crates/bevy\transform · high confidence

Introduce bevy\_encase\_derive proc-macro crate

A new \bevy\_encase\_derive\ crate has been added to provide procedural macro support for the Encase serialization format. This crate implements the \implement\ macro, which constructs the necessary path to the \bevy::encase\ module by leveraging the \BevyManifest\ utility to resolve dependencies dynamically. The implementation is secured with \\#!\[forbid(unsafe\_code)\]\ and includes standard documentation configuration such as logo and favicon URLs.

_crates/bevy\_encase\derive/src · high confidence

Introduce bevy\_extract crate for main-to-sub-world data extraction

The new \bevy\_extract\ crate provides the infrastructure to copy main world state into sub-app worlds. It introduces \ExtractComponent\ and \ExtractResource\ derive macros to automatically implement the necessary traits, along with \ExtractComponentPlugin\ and \ExtractResourcePlugin\ to register the extraction logic. The crate also includes \ExtractInstances\ for high-performance extraction that bypasses ECS overhead, and the \Extract\ system parameter to allow systems running during the \ExtractSchedule\ to read from the main world.

_crates/bevy\extract · high confidence

Introduce bevy\_math crate with foundational math types and traits

The \bevy\_math\ crate is established as a standalone, \no\_std\-compatible library providing core mathematical types and functionality for the Bevy engine. This release introduces new types including \AspectRatio\ for screen calculations, \CompassQuadrant\ and \CompassOctant\ for directional logic, \Isometry2d\ and \Isometry3d\ for rigid body transformations, and \Rot2\ for 2D rotations. It also adds \FloatOrd\ for consistent float ordering and hashing, and exposes \VectorSpace\ and \ScalarField\ traits for generic mathematical operations. Additionally, utility functions such as \Affine3Ext\ for matrix transposition and \reflection\_matrix\ for Householder transformations are provided to support rendering and geometry tasks.

_crates/bevy\math/src · high confidence

Introduce bevy\_platform crate with platform-agnostic utilities

The new \bevy\_platform\ crate provides a set of utilities designed to replace or extend the Rust standard library for better compatibility across different platforms, including \no\_std\ environments. It includes \SyncCell\ and \SyncUnsafeCell\ for thread-safe cell operations, a \cfg\ module with macros for conditional compilation based on features or platform capabilities, and collections like \HashMap\ and \HashSet\ that default to a deterministic \FixedHasher\ for reproducible behavior. Additionally, it offers an \AlignedVec\ for memory-aligned storage and a \dirs\ module that abstracts platform-specific user directory paths (with support for overriding the settings directory via the \BEVY\_SETTINGS\_DIR\ environment variable).

_crates/bevy\platform · high confidence

Introduce bevy\_settings crate for persistent user configuration

The new \bevy\_settings\ crate provides a framework for saving and loading user settings as TOML files. On desktop platforms, settings are stored in OS-specific preference directories (e.g., \\~/.config/\ on Linux), while on WebAssembly targets, they are persisted in browser \localStorage\. The \SettingsPlugin\ loads these settings into Bevy resources implementing the \SettingsGroup\ trait and supports deferred or synchronous saving to ensure crash-resistant writes.

_crates/bevy\settings · high confidence

Introduce bevy\_sprite\_render crate for 2D sprite rendering

The new bevy\_sprite\_render crate provides the core infrastructure for 2D sprite rendering, including the SpriteRenderPlugin, Mesh2d support, and the ColorMaterial system. It introduces the ExtendedMaterial2d trait for shader extensions, implements bindless material support for 2D meshes, and adds the SpriteMesh and TilemapChunk rendering pipelines. This change also includes the necessary WESL shader modules and license files to support these rendering capabilities.

_crates/bevy\_sprite\render · high confidence

Introduce bevy\_state crate with state machine and scoped entity management

The \bevy\_state\ crate is introduced, providing a state machine system for managing app-wide states (Standard, Sub, and Computed states) via derive macros (\States\, \SubStates\) and traits. It adds \AppExtStates\ for initializing and inserting states, \CommandsStatesExt\ for setting states, and run conditions like \in\_state\ and \state\_changed\. The crate also includes \state\_scoped\ components (\DespawnOnEnter\, \DespawnOnExit\, etc.) to manage entity lifetimes based on state transitions, and \state\_scoped\_events\ for state-scoped event handling. Reflection support is provided via \ReflectState\ and \ReflectFreelyMutableState\.

_crates/bevy\state · high confidence

Introduce bevy\_time crate with timekeeping, delayed commands, and run conditions

The \bevy\_time\ crate is introduced as the built-in timekeeping plugin for the Bevy engine, providing \Time\<Real\>\, \Time\<Virtual\>\, and \Time\<Fixed\>\ resources for wall-clock, virtual, and fixed-timestep logic respectively. It adds a \DelayedCommands\ helper to queue ECS commands for execution after a specified duration, and exposes common run conditions like \on\_timer\ and \once\_after\_delay\ for system scheduling. The crate also includes a \Stopwatch\ for manual time tracking, a \Moment\ type for capturing points in time, and a \TimeUpdateStrategy\ resource to support manual time control for testing or custom clocks.

_crates/bevy\time · high confidence

Introduce bevy\_ui\_render crate for UI rendering

The \bevy\_ui\_render\ crate has been added to provide the rendering infrastructure for \bevy\_ui\. This new crate encapsulates the logic for rendering UI elements, including box shadows, gradients, images, text, and debug overlays, effectively separating UI rendering concerns from the broader \bevy\_render\ crate. It includes specific plugins for handling box shadows, gradients, and image nodes, along with utilities for clipping and debug overlays, enabling more modular and maintainable UI rendering within the Bevy engine.

_crates/bevy\_ui\render · high confidence

Introduce bevy\_world\_serialization for dynamic world definition and serialization

A new \bevy\_world\_serialization\ crate is added, providing the ability to define, instantiate, and serialize/deserialize dynamic worlds. It introduces \DynamicWorld\ and \WorldAsset\ types to store collections of entities and resources, along with \DynamicWorldBuilder\ for extracting world state. Users can spawn these worlds via \WorldAssetRoot\ and \DynamicWorldRoot\ components or the \WorldInstanceSpawner\, and save/load world state to \.scn\ and \.scn.ron\ files using the \WorldAssetLoader\ and \DynamicWorldSerializer\.

_crates/bevy\_world\serialization · high confidence

Introduce compile\_fail\_utils for standardized compile-fail test execution

A new \compile\_fail\_utils\ library has been added to provide shared helpers for running \ui\_test\-based compile-fail tests. This utility standardizes test configuration by automatically handling dependency building, filtering out contributor-specific filesystem paths (such as \$BEVY\_ROOT\, \$RUSTUP\_HOME\, and \$HOME\) from stderr output to ensure cross-platform consistency, and verifying that test root directories exist before execution. It also integrates with CI environments to group test results in GitHub Actions summaries.

_tools/compile\_fail\utils · high confidence

Introduce dedicated gizmo rendering crate with shader-based line and mesh-based transform gizmos

This change introduces the \bevy\_gizmos\_render\ crate, which provides the rendering infrastructure for Bevy's gizmo system. It adds immediate-mode line gizmos for 2D and 3D scenes using custom WGSL shaders (\lines.wesl\, \line\_joints.wesl\) that support solid, dotted, and dashed styles, as well as a new mesh-based rendering implementation for the transform gizmo (using standard unlit materials and a dedicated overlay camera layer). The crate handles the extraction of gizmo data from the main world to the render world, manages the associated render pipelines, and integrates with the existing \bevy\_gizmos\ API.

_crates/bevy\_gizmos\render/src · high confidence

Introduce deferred PBR lighting pass and G-buffer serialization

Adds a new deferred lighting pipeline to the PBR renderer, allowing users to render scenes using a deferred shading approach. This change introduces the \DeferredPbrLightingPlugin\ which registers the necessary ECS systems and GPU resources, including a new \PbrDeferredLightingDepthId\ component to manage lighting pass IDs. The implementation includes WESL shader modules (\deferred\_lighting.wesl\, \functions.wesl\, \types.wesl\) that handle the serialization of material properties into a G-buffer (packing reflectance, metallic, roughness, clearcoat, and normals) and the subsequent lighting calculation, with specific optimizations for WebGL2 compatibility.

_crates/bevy\pbr/src/deferred · high confidence

Introduce experimental raytraced lighting via bevy\_solari

Adds the \bevy\_solari\ crate, providing an experimental set of plugins for raytraced lighting. The \SolariPlugins\ group enables real-time raytraced direct and indirect lighting via the \SolariLighting\ component, which replaces traditional shadow mapping and requires HDR cameras with specific texture usages. It also includes a non-realtime \PathtracingPlugin\ for validation purposes. The feature relies on specific WGPU features (such as \EXPERIMENTAL\_RAY\_QUERY\) and includes configurable settings for ReSTIR, sample counts, and world caching to balance quality and performance.

_crates/bevy\solari · high confidence

Introduce generic Relationship and RelationshipTarget traits for entity linking

This change introduces a new, generic relationship system in \bevy\_ecs\ that allows any component to define a link between entities via the \Relationship\ and \RelationshipTarget\ traits. Users can now derive these traits to create custom one-to-many or one-to-one relationships (such as a new \ViewOf\/\View\ pair) with automatic synchronization via component hooks. The system provides new API methods on \EntityWorldMut\ and \EntityCommands\ (like \with\_related\, \add\_related\, \remove\_related\, and \replace\_related\) to manage these links, and adds query helpers to traverse the relationship graph (e.g., \root\_ancestor\, \iter\_descendants\). This replaces or generalizes the previous hardcoded parent-child hierarchy logic, allowing for more flexible entity compositions while maintaining the automatic update of target collections when source relationships change.

_crates/bevy\ecs/src/relationship · high confidence

Introduce the \`bevy\_color\` crate with comprehensive color space support

The \bevy\_color\ crate is introduced, providing a unified \Color\ enum and distinct types for 13 color spaces (including sRGB, linear RGBA, HSL, HSV, HWB, LAB, LCH, Oklab, Oklch, Okhsl, Okhsv, Okhwb, and XYZ). This change adds extensive color operations via traits such as \Mix\, \Hue\, \Luminance\, and \Saturation\, along with utilities for color gradients (\ColorCurve\), ranges, and difference calculations. The crate is designed to be \no\_std\ compatible and supports serialization and reflection when optional features are enabled.

_crates/bevy\color/src · high confidence

Introduces the Message system for buffered, pull-based event handling

The \crates/bevy\_ecs/src/message\ module now provides a new \Message\ system as an alternative to the existing \Event\ system. This system uses a double-buffered queue (\Messages\<M\>\) to store messages, which are polled by systems using the \MessageReader\ and \MessageWriter\ system parameters. \MessageReader\ tracks consumption per-system to ensure each system sees every message once, while \MessageMutator\ allows systems to both read and modify messages. The system supports parallel iteration via \par\_read\ and includes a \PopulatedMessageReader\ variant to skip systems when no messages are present. A \MessageRegistry\ resource manages the lifecycle and update scheduling of these message buffers, ensuring they are processed at fixed points in the schedule rather than immediately upon sending.

_crates/bevy\ecs/src/message · high confidence

Introduction of bevy\_dylib crate for dynamic linking

A new \bevy\_dylib\ crate has been added to the Bevy repository. This crate forces the dynamic linking of the main Bevy library, which significantly speeds up incremental builds during development. Users can enable this behavior by adding \bevy\_dylib\ as a dependency in debug mode, though they are warned that release builds require shipping additional shared libraries (\libstd.so\ and \libbevy\_dylib.so\). The crate includes documentation explaining the recommended \--features bevy/dynamic\_linking\ approach versus manual dependency configuration.

_crates/bevy\dylib/src · high confidence

Introduction of bevy\_utils crate with core utility types

The \bevy\_utils\ crate has been introduced to provide a collection of general utilities for first-party Bevy engine crates. This includes a \DebugName\ type that conditionally stores type names based on a \debug\ feature flag, a \BufferedChannel\ for efficient parallel message passing with memory pooling, a \BloomFilter\ for probabilistic set membership, and a \Parallel\ type for thread-local storage. The crate also provides \TypeIdHashMap\ and \TypeIdIndexMap\ with ergonomic extension traits, a \MemorySize\ type for human-readable memory reporting, and macros like \define\_atomic\_id\ and \once\ for unique ID generation and one-time execution.

_crates/bevy\utils · high confidence

Introduction of headless Bevy UI widgets crate

The new \bevy\_ui\_widgets\ crate provides a set of unstyled, headless UI components for Bevy, including buttons, checkboxes, dialogs, drag proxies, list boxes, menus, modals, numeric inputs, radio groups, scroll areas, sliders, split panes, tabs, text inputs, and trees. These widgets manage interaction logic (pointer, keyboard, and focus events) and emit state-change events (such as \Activate\ and \ValueChange\) rather than handling styling themselves, allowing developers to apply custom visuals while maintaining consistent behavior. The crate also includes licensing files (Apache-2.0 and MIT) and registers a comprehensive \UiWidgetsPlugins\ group to enable all widget functionalities.

_crates/bevy\_ui\widgets · high confidence

Introduction of the Command and EntityCommand traits with closure support

The \bevy\_ecs\ system commands module now exposes the \Command\ and \EntityCommand\ traits, allowing users to define custom deferred world mutations. These traits are automatically implemented for closures (\FnOnce\), enabling anonymous commands to be queued directly via \Commands::queue\ or \EntityCommands::queue\. The module also provides built-in command constructors for common operations such as \spawn\_batch\, \insert\_batch\, \init\_resource\, \insert\_resource\, \remove\_resource\, and \run\_system\, along with a \ParallelCommands\ system parameter for executing commands in parallel query contexts.

_crates/bevy\ecs/src/system/commands · high confidence

Introduction of the bevy\_anti\_alias crate with anti-aliasing plugins

The new bevy\_anti\_alias crate provides a unified AntiAliasPlugin that registers multiple anti-aliasing and sharpening solutions, including FXAA, SMAA, Temporal Anti-Aliasing (TAA), and Contrast Adaptive Sharpening (CAS). It also conditionally includes DLSS support when the 'dlss' feature is enabled and 'force\_disable\_dlss' is not set, allowing users to easily integrate these visual improvements into their Bevy applications.

_crates/bevy\_anti\alias/src · high confidence

Introduction of the bevy\_light crate

The \bevy\_light\ crate has been introduced to centralize lighting, shadow, and atmospheric rendering logic. This new module provides core components such as \DirectionalLight\, \PointLight\, \SpotLight\, and \RectLight\, alongside support for cascaded shadow maps and GPU-accelerated spatial clustering to optimize rendering performance. It also includes advanced features like \Atmosphere\ for planetary sky rendering, \SunDisk\ for realistic sun visualization, and \EnvironmentMapLight\ for global illumination. By consolidating these systems, the crate simplifies the API for scene lighting and enables more complex visual effects like contact shadows and volumetric light scattering.

_crates/bevy\_light, crates/bevy\_picking, crates/bevy\ptr · high confidence

Introduction of the bevy\_shader crate with WESL support

The new bevy\_shader crate provides the core Shader asset type and a shader cache system for Bevy. It introduces support for the WESL shader language, allowing shaders to include other modules via imports. The crate includes a \load\_shader\_library\ macro to embed and load shaders, and defines \ShaderDefVal\ for compile-time shader configuration. Runtime validation of shaders can be enabled or disabled via the \ValidateShader\ enum to balance safety and performance.

_crates/bevy\shader · high confidence

Introduction of the bevy\_text crate with Parley-based text rendering and EditableText widget

The \bevy\_text\ crate is introduced, providing a new text rendering pipeline powered by the Parley library. This change adds support for rich text features including strikethrough and underline colors, font smoothing controls, and generic font families. A new \EditableText\ component is added, offering a headless, plain-text input widget with features such as cursor movement, selection, clipboard operations, IME support, and configurable styling via \TextCursorStyle\ and \TextBounds\. The crate also includes new components like \InlineBox\ for inline layout and \TextBounds\ for wrapping, along with a \Font\ asset type and \FontLoader\ for managing font resources.

_crates/bevy\text · high confidence

New 2D and 3D bounding volume and raycast infrastructure

The \bevy\_shape\ crate now includes a comprehensive bounding volume system, introducing \Aabb2d\, \Aabb3d\, \BoundingCircle\, and \BoundingSphere\ types alongside the \BoundingVolume\, \Bounded2d\, and \Bounded3d\ traits. This update provides implementations for calculating bounding volumes for 2D primitives (such as \Circle\, \Ellipse\, \Arc2d\, and \Capsule2d\) and 3D primitives (including \Sphere\, \Cuboid\, \Cylinder\, and \Capsule3d\), as well as support for extruding 2D shapes into 3D bounding volumes. Additionally, it adds 2D raycast intersection capabilities via \RayCast2d\, \AabbCast2d\, and \BoundingCircleCast\ to enable efficient overlap and raycasting tests against these new bounding shapes.

_crates/bevy\shape · high confidence

New Bevy Inspector crate for interactive entity inspection

The new \bevy\_inspector\ crate provides an interactive UI for inspecting and editing Bevy entities. It features an expandable entity tree panel for navigating the world hierarchy and a details panel that displays and allows local editing of component fields (booleans, numbers, text, colors, and enums) for the selected entity. The inspector supports both local inspection of the current world and remote inspection of a separate running application via the Bevy Remote Protocol, with a draggable column splitter to adjust the layout between the tree and details views. Also in this area: Inspector gains connection panel and enhanced color/enum editing. Also in this area: 4 commits (1 fix) modifying crates/bevy\_inspector.

_crates/bevy\inspector/src · medium confidence · unverified

New CI testing plugin for automated screenshot and camera control

A new \CiTestingPlugin\ has been added to \bevy\_dev\_tools\ to automate visual regression and integration tests in CI environments. When the \bevy\_ci\_testing\ feature is enabled, the plugin reads a RON configuration file (via the \CI\_TESTING\_CONFIG\ environment variable) to execute frame-specific actions. Users can configure the test to take screenshots, move the camera to specific positions, start/stop screen recordings, or exit the application after a set number of frames. The plugin automatically handles system ordering to ensure events are processed before screenshots are captured and the window is closed, and it conditionally adds the \EasyCameraMovementPlugin\ and \EasyScreenRecordPlugin\ as needed.

_crates/bevy\_dev\_tools/src/ci\testing · high confidence

New CLI tool to build and test Bevy examples for WebAssembly

A new command-line utility (\tools/build-wasm-example\) has been added to streamline building Bevy examples for WebAssembly targets. This tool allows users to specify which examples to build, choose between WebGL2 and WebGPU APIs, and select build profiles including a size-optimized \wasm-release\ mode. It also supports running Playwright-based browser tests against the built examples, with options to target specific browsers and limit execution frames for CI efficiency.

tools/build-wasm-example · high confidence

New CompressedImageSaver with ctt and basis-universal backends

The \crates/bevy\_image/src/compressed\_image\_saver\ module now provides a new \CompressedImageSaver\ asset saver that compresses textures into GPU-friendly formats. It supports two mutually exclusive backends: the \compressed\_image\_saver\ feature uses the \ctt\ library to output KTX2 files with BCn (desktop) or ASTC (mobile) compression, while the \compressed\_image\_saver\_universal\ feature uses \basis-universal\ to output UASTC files for cross-platform/WebGPU support. The saver automatically selects output formats based on input texture properties (e.g., BC7 for 4-channel LDR, BC6H for HDR), handles sRGB/linear color space conversion, supports normal map compression, and generates mipmaps by default.

_crates/bevy\_image/src/compressed\_image\saver · high confidence

New ECS derive macros for Events, Bundles, Queries, and Templates

The \bevy\_ecs/macros\ crate now provides a comprehensive set of procedural macros to derive ECS traits, replacing previous manual or fragmented implementations. Users can now use \\#\[derive(Event)\]\ and \\#\[derive(EntityEvent)\]\ to handle event propagation and triggers, \\#\[derive(Bundle)\]\ (with \\#\[bundle(ignore)\]\ support) for component grouping, and \\#\[derive(QueryData)\]\ / \\#\[derive(QueryFilter)\]\ for defining flexible query types with contiguous iteration support. Additionally, \\#\[derive(Resource)\]\ simplifies resource registration, and \\#\[derive(FromTemplate)\]\ enables scene templating capabilities.

_crates/bevy\ecs/macros/src · high confidence

New ECS examples demonstrating change detection, messaging, and resources

Added three new examples to \crates/bevy\_ecs/examples\ that showcase core ECS patterns using the modern API. The \change\_detection\ example illustrates how to track component mutations and resource changes using \Changed\ and \is\_changed()\. The \events\ example demonstrates the new message-passing system, utilizing \MessageRegistry\, \MessageWriter\, and \MessageReader\ with explicit schedule ordering. The \resources\ example shows basic resource management and system chaining. All examples use the current \Schedule\-based system registration (\add\_systems\) and derive macros.

_crates/bevy\ecs/examples · high confidence

New PBR rendering infrastructure and features

This change introduces the core infrastructure for the new PBR renderer in bevy\_pbr. It adds support for GPU-based light clustering (cluster.wesl), contact shadows (contact\_shadows.rs), and distance fog (fog.rs). It also implements the ExtendedMaterial system (extended\_material.rs) allowing users to create custom material extensions, and adds a GLTF extension handler (gltf.rs) to automatically convert glTF materials to StandardMaterial. Diagnostic plugins (diagnostic.rs) are included to track material allocator performance.

_crates/bevy\pbr/src · high confidence

New WESL-based shaders for color selection widgets

The Bevy Feathers UI library now includes new shader assets written in WESL to render its color selection components. The \color\_plane.wesl\ shader supports multiple color spaces (sRGB, HSL, and OKHSL) for displaying color gradients, while \color\_wheel.wesl\ renders a hue ring with an inner whiteness/blackness triangle. Additionally, \alpha\_pattern.wesl\ provides a checkerboard pattern for visualizing transparency. These changes migrate the visual rendering of these widgets to the new WESL format.

_crates/bevy\feathers/src/assets/shaders · high confidence

New \`AnimationEvent\` derive macro for custom event types

The \bevy\_animation\ crate now provides a \\#\[derive(AnimationEvent)\]\ macro. Users can apply this derive to their own structs to automatically implement the \bevy\_animation::AnimationEvent\ trait and the \bevy\_ecs::event::Event\ trait (with \AnimationEventTrigger\ as the associated trigger type), simplifying the creation of custom animation events.

_crates/bevy\animation/macros · high confidence

New \`bench!\` macro for automatic benchmark naming

A new \bench!\ macro has been added to the \benches\ crate to automatically generate qualified benchmark names based on the current module path and the provided function name. This simplifies the process of naming benchmarks when using \Criterion::bench\_function\, \Criterion::bench\_with\_input\, or \Criterion::benchmark\_group\, ensuring consistent and unique identifiers without manual string concatenation.

benches/src · high confidence

New asset I/O backends for Android, Web, and in-memory storage

The \bevy\_asset\ I/O module now includes dedicated readers for Android (\AndroidAssetReader\ using the native \AssetManager\), Web/WASM (\HttpWasmAssetReader\ for HTTP fetching), and in-memory storage (\Dir\ and \MemoryAssetReader\). It also introduces \ProcessorGatedReader\ to synchronize asset loading with the asset processor and \GatedReader\ for test synchronization. These changes enable Bevy to load assets from native Android archives, remote web URLs, and virtual memory structures, while ensuring processed assets are ready before being read.

_crates/bevy\asset/src/io · high confidence

New auto exposure post-processing effect

The \bevy\_post\_process\ crate now includes an auto exposure effect that automatically adjusts camera exposure to simulate the human eye's adaptation to different lighting conditions. This feature requires HDR-enabled cameras and compute shaders (it is not compatible with WebGL2). It works by building a 64-bin histogram of the scene's luminance and adjusting the exposure so that the average brightness of the final render is middle gray. Users can configure the exposure range, filtering percentages, adaptation speeds, and a metering mask to weight specific screen areas. Additionally, a correction range limits the automatic adjustment, and a customizable compensation curve allows for fine-tuned artistic control over the final exposure.

_crates/bevy\_post\process · high confidence

New bevy\_camera crate with camera, visibility, and projection systems

The camera subsystem has been extracted into a dedicated \bevy\_camera\ crate, providing core components like \Camera\, \Camera2d\, and \Camera3d\, along with visibility management (\Visibility\, \InheritedVisibility\, \ViewVisibility\), projection logic (\PerspectiveProjection\, \OrthographicProjection\), and rendering configuration (\ClearColor\, \MsaaWriteback\, \CompositingSpace\). This modularization separates camera-specific logic from the broader render pipeline, introducing features such as hierarchical level-of-detail (HLOD) visibility ranges, custom projection support, and improved frustum culling optimizations.

_crates/bevy\camera · high confidence

New bevy\_camera\_controller crate with Free, Pan, and PanOrbit camera controllers

A new \bevy\_camera\_controller\ crate has been introduced to centralize first-party camera controllers, providing \FreeCamera\, \PanCamera\, and \PanOrbitCamera\ implementations. The \FreeCamera\ plugin enables free-roaming navigation with configurable movement speeds, exponential scroll-based speed adjustment, and axis-snapping features. The \PanCamera\ controller adds 2D panning, zooming (including zoom-to-cursor), and rotation capabilities. The \PanOrbitCamera\ controller offers advanced orbiting, panning, and zooming with momentum, input smoothing, and support for both perspective and orthographic projections. Each controller is gated behind its own feature flag (e.g., \free\_camera\, \pan\_camera\, \pan\_orbit\_camera\) to allow users to include only the functionality they need.

_crates/bevy\_camera\controller · high confidence

New bevy\_city example with procedural generation and performance optimizations

This location introduces the \bevy\_city\ example, a procedurally generated city scene designed as a stress test for Bevy's large-scene capabilities. It features a grid-based city generation system with randomized building densities, trees, and animated cars. The example demonstrates several performance and rendering features: it uses \merge\_all\_mesh\_3d\ to combine car meshes, implements Level of Detail (LOD) for buildings and trees via \PendingLod\, and supports toggling \NoCpuCulling\ at runtime to bypass CPU-side visibility checks. It also includes a UI settings panel (built with Feathers) to control simulation parameters like car density, shadow maps, contact shadows, and wireframe mode, as well as a loading screen and atmosphere settings.

_examples/large\_scenes/bevy\city · high confidence

New bevy\_clipboard crate for platform-agnostic clipboard access

The new \bevy\_clipboard\ crate provides a consistent, platform-agnostic API for reading and writing to the system clipboard, abstracting away platform-specific details via the \arboard\ library. It introduces a \Clipboard\ resource and \ClipboardPlugin\ for integration, supporting both synchronous (desktop) and asynchronous (Web) read operations. By default, clipboard operations use an in-process buffer for security and compatibility on unsupported platforms (Android, iOS, or when the \system\_clipboard\ feature is disabled); enabling the \system\_clipboard\ feature allows access to the actual OS clipboard, with optional image support on Windows and Unix when the \image\ feature is also enabled.

_crates/bevy\clipboard · high confidence

New bevy\_macro\_utils crate provides shared procedural macro utilities

The \bevy\_macro\_utils\ crate has been introduced to centralize helper code previously scattered across \bevy\_reflect\_derive\ and other crates. It provides a \BevyManifest\ struct that caches and shares \Cargo.toml\ parsing results across macro invocations to improve performance, and a \fq\_std\ module that generates fully qualified paths (e.g., \::core::option::Option\) to ensure macro hygiene. Additionally, it includes utilities for parsing attribute literals, deriving label traits, handling struct members, and sifting macro errors, which standardizes how Bevy's derive macros interact with the build system and Rust's standard library.

_crates/bevy\_macro\utils/src · high confidence

New color palettes added to bevy\_color

The \bevy\_color\ crate now exposes three new color palettes via the \palettes\ module: \basic\ (CSS1/VGA named colors), \css\ (CSS4/X11 extended colors, which re-exports the basic palette), and \tailwind\ (colors from Tailwind CSS 3.4.1). These provide ready-to-use, standardized color constants for application theming and UI design.

_crates/bevy\color/src/palettes · high confidence

New compile-fail test infrastructure and example-showcase patches for CI

Developers can now use the new \compile\_fail\_utils\ crate to write and run compile-fail tests for Bevy crates, with documentation and example test cases included in \tools/compile\_fail\_utils\. Additionally, a set of patch files in \tools/example-showcase\ modifies core Bevy crates (such as \bevy\_asset\, \bevy\_audio\, \bevy\_winit\, \bevy\_window\, and \bevy\_pbr\) to adjust default behaviors for the example showcase environment, including disabling audio, fixing window positioning, reducing light cluster configuration, and adapting window settings for WASM.

tools · high confidence

New debug visualization gizmos for AABBs and camera frustums

The gizmos module now includes dedicated plugins and drawing utilities for Axis-Aligned Bounding Boxes (AABBs) and camera frustums. Users can enable AABB visualization by adding the \ShowAabbGizmo\ component to entities or by setting \draw\_all\ in the \AabbGizmoConfigGroup\, with optional per-entity color overrides. Similarly, camera frustums can be visualized by adding the \ShowFrustumGizmo\ component or enabling \draw\_all\ in the \FrustumGizmoConfigGroup\. These additions provide immediate visual feedback for debugging collision bounds and camera visibility culling.

_crates/bevy\gizmos/src · high confidence

New decal rendering capabilities: forward decals and clustered decals

The \bevy\_pbr\ crate now includes two new decal rendering systems. Forward decals allow users to place 1x1 quad meshes that smoothly alpha-blend with underlying geometry, supporting custom materials and a configurable depth-fade factor to control blending distance. Clustered decals provide a higher-quality rendering technique using bindless textures to project up to four textures (base color, normal, metallic-roughness, and emissive) onto surfaces within a bounding box, supporting GPU clustering for performance. Both systems are integrated into the PBR pipeline via new plugins and shader libraries.

_crates/bevy\pbr/src/decal · high confidence

New derive macros and Android main attribute

The \bevy\_derive\ crate now provides \\#\[derive(Deref)\]\ and \\#\[derive(DerefMut)\]\ macros to automatically implement \std::ops::Deref\ and \std::ops::DerefMut\ for structs, supporting both single-field structs and multi-field structs via the \\#\[deref\]\ attribute. Additionally, a new \\#\[bevy\_main\]\ attribute macro is available to generate the necessary Android \android\_main\ boilerplate, simplifying cross-platform entry point setup.

_crates/bevy\derive/src · high confidence

New developer tools crate with FPS, diagnostics, and render debug overlays

The new \bevy\_dev\_tools\ crate introduces a suite of visual debugging utilities for Bevy applications. It includes an FPS overlay with a configurable frame-time graph, a draggable diagnostics overlay for monitoring engine statistics, and a render debug overlay that visualizes internal buffers like depth, normals, and motion vectors. Additional tools provide an infinite grid for spatial reference, easy screenshot and screen recording capabilities, and picking debug overlays to visualize pointer interactions.

_crates/bevy\_dev\tools/src · high confidence

New entity and world inspection tools for debugging

The \bevy\_dev\_tools\ crate now includes a new inspection module that allows developers to inspect the state of the ECS world, entities, components, and resources. This feature provides structured data about entities (including labels, memory size, and spawn details), components (including type metadata and reflected values), and resources. It also includes utilities for grouping and sorting entities by hierarchy, archetype, or name, as well as fuzzy name matching for components, resources, and entity labels to aid in debugging and tooling.

_crates/bevy\_dev\tools/src/inspection · high confidence

New entity collection types and cloning infrastructure

The \bevy\_ecs\ entity module now includes specialized collection types (\EntityHashMap\, \EntityHashSet\, \EntityIndexMap\, \EntityIndexSet\) optimized with a fast \EntityHash\ hasher, alongside new traits (\EntityEquivalent\, \ContainsEntity\) and iterator types (\EntitySetIterator\) to support unique entity iteration. Additionally, a new \clone\_entities\ module introduces \EntityCloner\ and \ComponentCloneCtx\ to enable advanced entity cloning with custom component clone handlers, while \map\_entities.rs\ provides the \MapEntities\ trait and implementations for mapping entity references across collections like \Vec\, \HashMap\, and \BTreeMap\.

_crates/bevy\ecs/src/entity · high confidence

New example showcase tool for running and publishing Bevy examples

A new CLI tool has been added to the Bevy repository to automate the execution of examples and generate the markdown content for the Bevy website's example showcase. The tool supports running examples locally or in CI with configurable parameters such as stopping at a specific frame, taking screenshots, and filtering by feature requirements. It also builds WebAssembly versions of the examples for WebGL2 and WebGPU, allowing the website to display interactive or static previews of the examples with pagination support.

tools/example-showcase · high confidence

New image format loaders and cubemap conversion utilities

The \bevy\_image\ crate now includes dedicated loaders for Basis Universal, DDS, EXR, and Radiance HDR formats, along with a new \Image::equirectangular\_to\_cubemap\ method that converts lat-long panoramas into cube maps. These additions expand the range of supported texture assets and provide built-in tools for handling high-dynamic-range and compressed image data.

_crates/bevy\image/src · high confidence

New input focus system with tab and directional navigation

This change introduces the \bevy\_input\_focus\ crate, providing a comprehensive system for managing input focus in Bevy applications. It adds core components like \Focusable\ and \InputFocus\, along with events \FocusGained\ and \FocusLost\ to track focus changes. The crate includes two navigation frameworks: \tab\_navigation\ for keyboard-based sequential navigation (following HTML spec rules with \TabGroup\ and \TabIndex\) and \directional\_navigation\ for gamepad or arrow-key based movement between UI elements using spatial proximity. It also supports automatic focus assignment via the \AutoFocus\ component and pointer-driven focus via \PointerFocusPlugin\ (gated by \bevy\_picking\).

_crates/bevy\_input\focus/src · high confidence

New large-scene rendering stress test example

Added the Bistro example, a large glTF scene designed to stress-test rendering performance with high draw calls, many textures, and numerous light sources. The example includes command-line options to toggle features such as deferred shading, various culling methods (frustum, CPU, GPU occlusion), automatic batching, indirect drawing, and mipmap generation, allowing users to benchmark and analyze specific rendering bottlenecks.

_examples/large\scenes/bistro · high confidence

New mipmap generator example for large scenes

Added a new \mipmap\_generator\ example within the \large\_scenes\ directory that demonstrates how to generate mipmaps for large textures. The example includes a plugin (\MipmapGeneratorPlugin\) that registers resources for generator settings and progress tracking, supports configurable anisotropic filtering and compression speeds, and provides an optional debug text overlay to visualize generation progress.

_examples/large\_scenes/mipmap\generator · high confidence

New mobile example with touch controls and UI

A new mobile example has been added that demonstrates a 3D scene with interactive UI and audio. The app features touch-based camera movement and rotation gestures (iOS), a styled button using the new \ui\_widgets::Button\ component, and audio playback that pauses on app lifecycle events. It is configured for mobile-specific behaviors like borderless fullscreen, hidden status bars, and reduced CPU usage via \WinitSettings::mobile()\.

examples/mobile · high confidence

New schedule data serialization tools for visualization

Added a new \schedule\_data\ module to \bevy\_dev\_tools\ that provides types and utilities for extracting and serializing ECS schedule information (including systems, dependencies, and component accesses) into RON format. This enables users to automatically dump app schedule metadata to a file (defaulting to \app\_data.ron\) via the \SerializeSchedulesPlugin\, facilitating integration with external visualization or debugging tools.

_crates/bevy\_dev\_tools/src/schedule\data · high confidence

New templated documentation for examples and Cargo features

The documentation build system now uses Jinja2 templates to generate the Examples README and the Cargo Features reference page. The new \EXAMPLE\_README.md.tpl\ provides a structured guide for running examples, including platform-specific setup instructions for Android, iOS, and Wasm, and clarifies versioning for crates.io releases. The \features.md.tpl\ introduces a new documentation structure that categorizes Bevy's Cargo features into 'Profiles' (high-level domains like 2D/3D), 'Collections' (mid-level groups for custom configurations), and a complete feature list, helping users optimize compilation times and binary size by enabling only the necessary features.

docs-template · high confidence

New terminal-based release content export tool

A new interactive CLI tool has been added at \tools/export-content\ that allows users to manage and export release notes and migration guides. The tool reads content from the \\_release-content\ directory and provides a terminal UI (powered by \ratatui\) for reviewing, reordering, adding, and deleting content sections before generating the final export file. It supports two modes—Release Notes and Migration Guides—and can be run via \cargo run -p export-content\ or used in a validation mode with the \--check\ flag.

tools/export-content · high confidence

New windowing capabilities: custom cursors, HDR/color-space control, and Android support

This update introduces several new capabilities to the windowing system. Users can now set custom cursors using images or URLs via the new \CustomCursor\ and \CursorIcon::Custom\ types. Display output is now configurable through the \DisplayTarget\ component, allowing requests for HDR output and explicit color space selection (e.g., sRGB, scRGB, PQ) to better match display hardware. Additionally, the crate now includes \bevy\_android\ support, exposing the \ANDROID\_APP\ static for querying Android application state and lifecycle events.

_crates/bevy\window · high confidence

Order Independent Transparency (OIT) support for 3D rendering

Added Order Independent Transparency (OIT) to the core 3D pipeline, allowing correct rendering of transparent meshes that previously suffered from alpha blending artifacts. Users can enable this feature by adding the \OrderIndependentTransparencySettings\ component to their camera and setting \Material::enable\_oit\ to true. The implementation uses a two-pass approach: a forward pass that constructs a linked list of fragment depth and color data, and a resolve pass that sorts and blends these fragments. Configuration options include \sorted\_fragment\_max\_count\ to control accuracy versus performance, \fragments\_per\_pixel\_average\ to manage memory usage, and \alpha\_threshold\ to optimize quality. Note that MSAA is not supported when OIT is enabled.

_crates/bevy\_core\pipeline/src/oit · high confidence

Procedural atmospheric scattering with real-time LUT generation

The atmosphere module now implements a full procedural sky using Hillaire's 2020 real-time atmospheric scattering algorithm. This introduces a suite of WESL compute shaders (transmittance, multiscattering, sky view, and aerial view LUTs) that precompute scattering data on the GPU, alongside a fullscreen render pass that composites the final sky using dual-source blending. The system supports dynamic time-of-day, multiple directional lights, and integrates with the existing skybox, while also handling scattering in front of terrain similar to distance fog.

_crates/bevy\pbr/src/atmosphere · high confidence

Project initialization and repository configuration

The repository has been initialized with standard project governance and development tooling. This includes the addition of a dual MIT/Apache-2.0 license, a Code of Conduct, a Security Policy, and a Contributor's Guide. Development workflows are configured via \.gitattributes\ (enforcing LF line endings for code), \rustfmt.toml\, \clippy.toml\ (disallowing non-deterministic math methods and enforcing \children!\ brace syntax), \deny.toml\ (managing license compliance and dependency bans), and \typos.toml\ (spell checking). The \.gitignore\ has been updated to exclude build artifacts, IDE files, and generated assets.

(repo-wide) · high confidence

Random sampling support for Bevy math types

Users can now generate random instances of Bevy math types such as \Dir2\, \Dir3\, \Dir3A\, \Rot2\, and \Quat\ using the \rand\ crate. This change introduces the \sampling\ module (enabled via the \rand\ feature) which implements the \Distribution\ trait for these types, allowing them to be created via standard \rand\ APIs like \random()\ or \rng.random()\. It also provides a \FromRng\ trait for ergonomic, type-inferred random generation directly on the types.

_crates/bevy\math/src/sampling · high confidence

Real-time environment map generation and GPU-based light probe filtering

Users can now generate environment maps at runtime from a source cubemap using a new \GeneratedEnvironmentMapLight\ component, which triggers a GPU pipeline to copy, downsample, and filter the map into diffuse and specular components. This includes new WESL compute shaders for single-pass downsampling, GGX radiance filtering, and Lambertian irradiance convolution. The light probe system has been updated to support these generated maps alongside static ones, with the PBR shader now handling view rotation for environment maps and supporting parallax-corrected reflection probes for more accurate local reflections.

_crates/bevy\_pbr/src/light\probe · high confidence

Runtime reflection support for ECS components, bundles, events, and resources

The \bevy\_ecs\ reflect module now exposes a comprehensive set of types—\ReflectComponent\, \ReflectBundle\, \ReflectEvent\, \ReflectResource\, \ReflectMessage\, \ReflectFromWorld\, and \ReflectMapEntities\—that allow you to insert, update, remove, and trigger ECS entities and world events using data whose types are only known at runtime. This is powered by the \ReflectCommandExt\ trait on \EntityCommands\, which adds methods like \insert\_reflect\ and \remove\_reflect\ so you can apply reflected data to entities without compile-time type knowledge, and by \AppTypeRegistry\ which stores the global type registry used to look up these reflection implementations.

_crates/bevy\ecs/src/reflect · high confidence

SMAA anti-aliasing implementation added

Subpixel Morphological Antialiasing (SMAA) is now available as a post-processing effect. Users can enable it by adding the \Smaa\ component to a camera, which runs a three-pass pipeline (edge detection, blending weight calculation, and neighborhood blending) to smooth jagged edges. The implementation supports four quality presets (Low, Medium, High, Ultra) and uses embedded KTX2 lookup textures for performance. Note that advanced features like temporal accumulation and depth/chroma-based edge detection are not yet supported.

_crates/bevy\_anti\alias/src/smaa · high confidence

Single-pass downsampling shader for mip generation

The mip generation module now uses a new single-pass downsampling shader (ported from AMD FidelityFX SPD) to create texture mipmaps. This shader supports a wide range of texture formats (including RGBA8, RG8, R32F, etc.) and handles both 2D and array textures via specialized compute pipelines, replacing the previous multi-pass approach.

_crates/bevy\_core\_pipeline/src/mip\generation · high confidence

Support for KHR\_materials\_anisotropy, clearcoat, and specular glTF extensions

The glTF loader now parses three Khronos material extensions—\KHR\_materials\_anisotropy\, \KHR\_materials\_clearcoat\, and \KHR\_materials\_specular\—allowing Bevy to correctly interpret advanced material properties like anisotropic reflections, clearcoat layers, and specular color/factor data from glTF files. These new parsers are integrated into the \GltfExtensionHandler\ system, enabling third-party extensions to hook into the loading process and ensuring that complex PBR materials are preserved when loading glTF assets.

_crates/bevy\gltf/src/loader/extensions · high confidence

Temporal Anti-Aliasing (TAA) implementation

Adds a new Temporal Anti-Aliasing (TAA) plugin to Bevy, providing a post-processing pass that blends current frames with historical data to smooth out aliasing artifacts. This feature requires MSAA to be disabled and relies on motion vectors and depth prepasses for reprojection. The implementation includes a WESL shader that handles tonemapping, history blending, and confidence-based filtering to reduce ghosting and flickering.

_crates/bevy\_anti\alias/src/taa · high confidence

bevy\_math adds no\_std support and enforces libm determinism

The bevy\_math crate now supports no\_std environments by providing alternative implementations for standard f32 methods (such as abs, sqrt, ceil, and trigonometric functions) via the ops module, and ensures deterministic floating-point results across platforms by routing unspecified-precision methods through the libm library when the libm feature is enabled. These changes are enforced via new clippy rules that disallow direct usage of standard library methods in favor of the crate's portable equivalents.

_crates/bevy\math · high confidence

bevy\_tasks crate initialization with new task execution infrastructure

The \bevy\_tasks\ crate has been initialized with a new task execution system, including a \ParallelIterator\ trait for parallel data processing, \ParallelSlice\ traits for concurrent slice operations, and a \TaskPool\ API for managing asynchronous work. The implementation supports both multi-threaded and single-threaded (Wasm) execution backends, with a new \edge\_executor\ vendored as an alternative to \async-executor\ for \no\_std\ environments. The crate also includes examples demonstrating busy and idle thread pool behaviors, and provides global task pool accessors for integration with the broader Bevy engine.

_crates/bevy\tasks · high confidence

Removals

Removed unused torus model asset

The unused torus model file (torus.gltf) has been removed from the assets directory. This cleanup reduces the application's asset footprint by eliminating a file that was no longer referenced or needed.

assets/models/torus · high confidence · unverified

Architecture

Bevy internal crate restructured into a modular re-export facade

The \bevy\_internal\ crate has been refactored from a monolithic library into a module-based re-export facade. It now exposes individual sub-crates (such as \bevy\_render\, \bevy\_ui\, \bevy\_pbr\, and \bevy\_state\) as optional modules gated by Cargo features, and consolidates the \DefaultPlugins\ and \MinimalPlugins\ definitions in a new \default\_plugins\ module. This change allows users to dynamically link Bevy and selectively enable only the engine components they need, while the prelude continues to aggregate the most common types for convenient imports.

_crates/bevy\internal/src · high confidence

Bundle logic refactored into dedicated module files

The bundle implementation in \bevy\_ecs\ has been reorganized from a single monolithic file into a structured module with dedicated files for specific responsibilities: \impls.rs\ for trait implementations (including tuples), \info.rs\ for bundle metadata and registration, \insert.rs\ for insertion logic, \remove.rs\ for removal logic, \spawner.rs\ for entity spawning, and \writer.rs\ for dynamic bundle writing. This structural change improves code maintainability and separation of concerns without altering the external API or behavior of bundles.

_crates/bevy\ecs/src/bundle · high confidence

Extracted reusable ECS macro logic into a dedicated crate

The procedural macro implementation details for \bevy\_ecs\ have been extracted into a new \crates/bevy\_ecs/macro\_logic\ crate. This change introduces reusable logic for deriving ECS traits, specifically providing the \DeriveComponent\ interface for parsing and generating \Component\ implementations (including support for attributes like \immutable\, \summary\_tick\, and hooks) and the \map\_entities\ module for handling entity mapping in structs and enums. This refactoring centralizes the macro code generation, making it available for other parts of the ECS system to reuse.

_crates/bevy\_ecs/macro\logic · high confidence

Mesh system extracted into standalone bevy\_mesh crate

The mesh functionality has been split out from bevy\_render into a new, independent crate (bevy\_mesh). This introduces dedicated ECS components for 2D (Mesh2d) and 3D (Mesh3d) meshes, along with systems to automatically mark them as changed when their underlying assets are modified. The crate also provides the core Mesh asset type, vertex/index handling, and optional support for morph targets and skinning, reducing dependencies for users who only need mesh data without the full render pipeline.

_crates/bevy\mesh/src · high confidence

Refactor AssetServer internals into modular info and loader components

The \AssetServer\ implementation in \crates/bevy\_asset/src/server\ has been restructured to improve maintainability and separation of concerns. The internal state tracking for assets (paths, load states, dependencies, and change-watching data) has been extracted into a dedicated \info.rs\ module, while the logic for registering, reserving, and resolving \AssetLoader\ instances has been moved to \loaders.rs\. This change consolidates the server's core logic, making the \AssetServer\ struct itself cleaner and easier to navigate, while preserving all existing functionality for loading assets, managing dependencies, and handling hot-reloading.

_crates/bevy\asset/src/server · high confidence

Refactored ECS schedule system into modular components

The \bevy\_ecs\ schedule module has been reorganized into distinct source files to improve code structure and maintainability. The scheduling logic is now split across \auto\_insert\_apply\_deferred.rs\ (handling automatic sync point insertion), \condition.rs\ (defining the \SystemCondition\ trait and combinators like \and\_then\ and \and\_eager\), \config.rs\ (managing \ScheduleConfig\ and \ScheduleConfigs\ for system/set registration), \error.rs\ (providing \ScheduleBuildError\ and \ScheduleBuildWarning\ types with detailed cycle/ambiguity reporting), \node.rs\ (storing \SystemWithAccess\ and \ConditionWithAccess\ in the graph), \pass.rs\ (defining the \ScheduleBuildPass\ trait for graph modification), \schedule.rs\ (the main \Schedule\ and \Schedules\ resource implementations), and \set.rs\ (defining \SystemSet\ and \ScheduleLabel\ traits). This change affects how the schedule subsystem is structured internally, though the public API surface remains consistent.

_crates/bevy\ecs/src/schedule · high confidence

Refactored entity access types into a dedicated module

The entity access types (\EntityRef\, \EntityMut\, \EntityWorldMut\, \FilteredEntityRef\, \FilteredEntityMut\, \EntityRefExcept\, and \ComponentEntry\) have been reorganized into a new \entity\_access\ module within \bevy\_ecs\. This change splits the previously monolithic implementation files into separate, focused source files, improving code organization and maintainability without altering the public API or behavior of these core ECS types.

_crates/bevy\_ecs/src/world/entity\access · high confidence

World module refactored into dedicated submodules

The \bevy\_ecs::world\ module has been reorganized into dedicated submodules (\command\_queue\, \deferred\_world\, \entity\_fetch\, \identifier\, \error\, \reflect\, \spawn\_batch\, \unsafe\_world\_cell\) to improve code structure and maintainability. This change introduces a new \CommandQueue\ implementation for efficiently storing and applying heterogeneous commands, a \DeferredWorld\ type for safe non-structural world access, and an \EntityFetcher\ for unified entity fetching. It also adds specific error types for world operations (e.g., \TryRunScheduleError\, \EntityMutableFetchError\) and exposes \WorldId\ as a unique system parameter. These structural changes support safer disjoint access patterns and more robust error handling within the ECS world.

_crates/bevy\ecs/src/world · high confidence

Behavioural changes

1 commit (0 fixes) modifying assets/blend\_graphs

A change to existing behaviour in assets/blend\_graphs — 1 commit, 1 file: “Adopt: Rename AnimationGraph to BlendGraph (\#26367)” (refs \#26367).

_assets/blend\graphs · low confidence · unverified

1 commit (0 fixes) modifying assets/irradiance\_volumes, assets/models/IrradianceVolumeExample

A change to existing behaviour in assets/irradiance\_volumes, assets/models/IrradianceVolumeExample — 1 commit, 2 files: “Implement irradiance volumes. (\#10268)” (refs \#10268).

_assets/irradiance\volumes, assets/models/IrradianceVolumeExample · low confidence · unverified

1 commit (0 fixes) modifying assets/models

A change to existing behaviour in assets/models — 1 commit, 1 file: “organize examples and add ecs guide”.

assets/models · low confidence · unverified

1 commit (0 fixes) modifying assets/models/AlienCake

A change to existing behaviour in assets/models/AlienCake — 1 commit, 3 files: “3d game example (\#1252)” (refs \#1252).

assets/models/AlienCake · medium confidence · unverified

1 commit (0 fixes) modifying assets/models/CornellBox

A change to existing behaviour in assets/models/CornellBox — 1 commit, 1 file: “Implement lightmaps. (\#10231)” (refs \#10231).

assets/models/CornellBox · low confidence · unverified

1 commit (0 fixes) modifying assets/models/Faces

A change to existing behaviour in assets/models/Faces — 1 commit, 1 file: “Light Textures (\#18031)” (refs \#18031).

assets/models/Faces · low confidence · unverified

1 commit (0 fixes) modifying assets/models/GolfBall

A change to existing behaviour in assets/models/GolfBall — 1 commit, 1 file: “Implement clearcoat per the Filament and the \KHR\_materials\_clearcoat\ specifications. (\#13031)” (refs \#13031).

assets/models/GolfBall · low confidence · unverified

1 commit (0 fixes) modifying assets/models/VolumetricFogExample

A change to existing behaviour in assets/models/VolumetricFogExample — 1 commit, 1 file: “Implement volumetric fog and volumetric lighting, also known as light shafts or god rays. (\#13057)” (refs \#13057).

assets/models/VolumetricFogExample · low confidence · unverified

1 commit (0 fixes) modifying assets/models/extras

A change to existing behaviour in assets/models/extras — 1 commit, 1 file: “add handling of all missing gltf extras: scene, mesh & materials (\#13453)” (refs \#13453).

assets/models/extras · low confidence · unverified

1 commit (0 fixes) modifying crates/bevy\_annotations, examples/reflection

A change to existing behaviour in crates/bevy\_annotations, examples/reflection — 1 commit, 2 files: “Implement Reflect for annotation types in bevy\_reflect (\#26470)” (refs \#26470). Also in this area: Introduces standard reflection annotations for tooling.

_crates/bevy\annotations · low confidence · unverified

1 commit (0 fixes) modifying crates/bevy\_fuzzy, crates/bevy\_internal

A change to existing behaviour in crates/bevy\_fuzzy, crates/bevy\_internal — 1 commit, 5 files: “Add bevy\_fuzzy, a fuzzy matcher for tools (\#26410)” (refs \#26410).

_crates/bevy\fuzzy · low confidence · unverified

1 commit (0 fixes) modifying crates/bevy\_reflect2

A change to existing behaviour in crates/bevy\_reflect2 — 1 commit, 48 files: “Bevy Reflect2: MVP (\#26356)” (refs \#26356).

_crates/bevy\reflect2 · medium confidence · unverified

2 commits (0 fixes) modifying assets/models/GltfPrimitives

A change to existing behaviour in assets/models/GltfPrimitives — 2 commits, 1 file: “Cosmetic tweaks to \query\_gltf\_primitives\ (\#16102)”; “feat(gltf): add name component to gltf mesh primitive (\#13912)” (refs \#16102, \#13912).

assets/models/GltfPrimitives · medium confidence · unverified

2 commits (0 fixes) modifying assets/volumes

A change to existing behaviour in assets/volumes — 2 commits, 2 files: “Allow volumetric fog to be localized to specific, optionally voxelized, regions. (\#14099)”; “Allow fog density texture to be scrolled over time with an offset (\#14868)” (refs \#14099, \#14868).

assets/volumes · medium confidence · unverified

2 commits (1 fix) modifying assets/models/DepthOfFieldExample

A change to existing behaviour in assets/models/DepthOfFieldExample — 2 commits (1 fix), 2 files: “fix lava emissive strength in depth of field example (\#13449)”; “Implement fast depth of field as a postprocessing effect. (\#13009)” (refs \#13449, \#13009).

assets/models/DepthOfFieldExample · medium confidence · unverified

2430 commits (279 fixes) modifying examples

A change to existing behaviour in examples — 2430 commits (279 fixs), 500 files: “Add docs & example for SystemParam (\#1435)”; “Instanced line rendering for gizmos based on \bevy\_polyline\ (\#8427)”; “fix whitespaces in comment (\#7853)”; and 2417 more (refs \#1435, \#8427, \#7853, \#25294, \#16589, …).

examples · medium confidence · unverified

3 commits (0 fixes) modifying assets/sounds

A change to existing behaviour in assets/sounds — 3 commits, 4 files: “Add simple collision sound to breakout (\#4331)”; “use ogg by default instead of mp3 (\#3421)”; “Programmed soundtrack example (\#12774)” (refs \#4331, \#3421, \#12774).

assets/sounds · medium confidence · unverified

4 commits (0 fixes) modifying assets/lightmaps

A change to existing behaviour in assets/lightmaps — 4 commits, 9 files: “Update ktx2 to v0.5.0 (\#23900)”; “Light Textures (\#18031)”; “Introduce support for mixed lighting by allowing lights to opt out of contributing diffuse light to lightmapped objects. (\#16761)”; and 1 more (refs \#23900, \#18031, \#16761, \#10231).

assets/lightmaps · medium confidence · unverified

5 commits (0 fixes) modifying examples/large\_scenes/zero\_day

A change to existing behaviour in examples/large\_scenes/zero\_day — 5 commits, 1 file: “Add more Zero Day benchmarking (\#26232)”; “Adopt: Rename AnimationGraph to BlendGraph (\#26367)”; “Use \bool::toggle\ (\#26528)”; and 2 more (refs \#26232, \#26367, \#26528, \#26157, \#25371).

_examples/large\_scenes/zero\day · medium confidence · unverified

55 commits (0 fixes) modifying \_release-content/release-notes

A change to existing behaviour in \_release-content/release-notes — 55 commits, 27 files: “Snap annotated inspector fields to their step (\#26395)”; “Password-style character masking for editable text inputs (\#25117)”; “Feathers now uses font-families everywhere; modifier key glyphs (\#26242)”; and 52 more (refs \#26395, \#25117, \#26242, \#26172, \#26462, …).

_\release-content/release-notes · medium confidence · unverified

Added WESL package for shader constant static analysis

A new WESL package has been added to the constants directory to support static analysis tools. This package defines dummy constant values (such as SORTED\_FRAGMENT\_MAX\_COUNT and MAX\_DIRECTIONAL\_LIGHTS) and includes a wesl.toml manifest, allowing the shader cache's virtual 'constants' namespace to be resolved during design-time without errors.

constants · medium confidence

Animation system restructured with curve-based evaluation and additive blending

The animation engine has been rebuilt to use a curve-based evaluation model, introducing the \Animatable\ trait for value interpolation and blending, and the \AnimationCurve\ trait to drive property updates from time-based curves. This enables additive blending for animations (allowing animations to layer on top of each other) and supports fine-grained control via animation graphs with masks. The system now uses \bevy\_curve\ for curve definitions (including stepped, cubic, and rotation-specific curves) and replaces the previous evaluator architecture with a new \AnimatableCurve\ and \AnimatableProperty\ system for applying curves to entity components.

_crates/bevy\animation/src · high confidence

Asset processor now uses write-ahead transaction logging for crash resilience

The asset processing system in \crates/bevy\_asset/src/processor\ now implements a write-ahead transaction log to ensure asset importing is crash and failure resistant. If the processor crashes or stops unexpectedly during an asset's processing, the system will detect the incomplete transaction on the next run and automatically reprocess the affected asset. This change introduces new internal traits (\ProcessorTransactionLog\, \ProcessorTransactionLogFactory\) and a file-based implementation that tracks processing start and end states, preventing data corruption and ensuring deterministic asset builds.

_crates/bevy\asset/src/processor · high confidence

Bevy Input restructured into a modular, feature-gated crate

The \bevy\_input\ crate has been completely rewritten to support \no\_std\ and modularize input handling behind feature flags (keyboard, mouse, gamepad, touch, gestures). The generic \Input\<T\>\ resource has been renamed to \ButtonInput\<T\>\, and the \ElementState\ enum has been renamed to \ButtonState\. A new generic \Axis\<T\>\ resource has been added to handle continuous input values (such as gamepad axes) with clamping and unclamped retrieval methods. Input events (e.g., \KeyboardInput\, \MouseButtonInput\, \GamepadEvent\) are now processed via ECS \Message\ types in \PreUpdate\ systems, and common run conditions like \input\_toggle\_active\ are provided in a dedicated \common\_conditions\ module. Touch input now includes a \Touches\ resource for tracking multi-touch state, and new gesture events (pinch, rotation, pan, double-tap) are available on supported platforms.

_crates/bevy\input/src · high confidence

Bevy UI 0.20: Major API overhaul and layout engine upgrade

This release introduces breaking changes to the Bevy UI API, including the deprecation of the legacy \Interaction\ component in favor of the new \Pressed\ and \Hovered\ components, and the removal of the \Button\ widget. The layout engine has been upgraded to Taffy 14, and the \Val\ type now supports \em\ and \rem\ units. Additionally, the crate has been reorganized into a new modular structure with dedicated files for accessibility, focus, and geometry.

_crates/bevy\ui · high confidence

Bevy app crate restructured with new core modules and hotpatching support

The \bevy\_app\ crate has been reorganized into distinct modules (\app\, \hierarchy\, \hotpatch\, \main\_schedule\, \panic\_handler\, \plugin\, \plugin\_group\, \propagate\, \schedule\_runner\, \sub\_app\) to improve separation of concerns. This change introduces a \HotPatchPlugin\ that integrates with Dioxus CLI for subsecond hot patching, adds a \ValidateParentHasComponentPlugin\ to enforce component hierarchy consistency, and refactors the \Plugin\ and \PluginGroup\ traits to support function-based plugin definitions and improved group building. The \Main\ schedule lifecycle is now explicitly documented and structured with dedicated labels for startup, update, and fixed update phases, while \SubApp\ extraction logic is separated into its own module for clearer data flow between main and sub-applications.

_crates/bevy\app/src · high confidence

Bevy engine restructured into modular crates with modern API and documentation

The \src\ directory has been completely refactored to reflect Bevy's transition from a monolithic prototype to a modular, crate-based engine. The previous \Application\ trait and hardcoded GLSL shaders (\shader.vert\, \shader.frag\) have been removed, replaced by a \bevy\_internal\ re-export that exposes the new modular subsystems. The public API has shifted from manual window and render-pipeline setup to a high-level \App\ builder pattern using \add\_systems\, as demonstrated in the new root-level documentation. Additionally, the engine now supports \no\_std\ environments, includes comprehensive crate documentation with a 'Hello World' example, and conditionally links \bevy\_dylib\ for dynamic linking on non-WASM targets.

src · high confidence

CI tool refactored to use \`argh\` for command-line argument parsing

The \ci\ tool in \tools/ci\ has been restructured to use the \argh\ library for parsing command-line arguments, replacing the previous implementation. This change introduces a new \Args\ struct that exposes \keep\_going\, \test\_threads\, and \build\_jobs\ options, which are now consistently passed to all subcommands (such as \clippy\, \test\, \compile-check\, and \doc-check\) via the \Prepare\ trait. The refactoring ensures that parallelism and failure-handling flags are correctly propagated to underlying \cargo\ commands, improving consistency and reliability when running CI checks locally or in CI environments.

tools/ci · high confidence

Complete rewrite of the ECS query system

The query subsystem in \crates/bevy\_ecs/src/query\ has been entirely replaced with a new implementation. This change introduces a new \QueryBuilder\ API for constructing queries at runtime, replaces the previous access tracking with a new \InvertibleComponentIdSet\ and \FilteredAccess\ model, and adds a bloom-filter-based conflict detection mechanism in \access\_iter.rs\ to optimize safety checks for queries with many components. The new system also includes updated error types (\QueryEntityError\, \QuerySingleError\) and a comprehensive \QueryData\/\QueryFilter\ derive macro infrastructure, fundamentally altering how queries are defined, validated, and iterated over.

_crates/bevy\ecs/src/query · high confidence

Component cloning and lifecycle constants are now modularized

The component module has been split into dedicated sub-modules to improve organization and clarity. A new \clone.rs\ module introduces \ComponentCloneBehavior\ and \ComponentCloneFn\, allowing users to define custom logic for cloning or ignoring components during entity cloning operations (e.g., via \EntityCloner\). A new \constants.rs\ module exposes specific \ComponentId\ constants for lifecycle events such as \Add\, \Insert\, \Discard\, \Remove\, and \Despawn\, making them directly accessible for observers and internal logic. The existing \info.rs\, \register.rs\, and \required.rs\ modules remain but are now part of this structured layout, maintaining their roles in metadata storage, registration, and required component handling.

_crates/bevy\ecs/src/component · high confidence

DLSS support refactored to use Bevy's new ECS systems instead of RenderGraph

The DLSS anti-aliasing implementation in \crates/bevy\_anti\_alias/src/dlss\ has been rewritten to replace the legacy \RenderGraph\ with Bevy's modern ECS systems. This change introduces new extraction, preparation, and execution nodes (\extract.rs\, \prepare.rs\, \node.rs\) that handle DLSS Super Resolution and Ray Reconstruction via the updated \dlss\_wgpu\ SDK. Users benefit from a more robust integration that correctly manages Vulkan instance/device extensions, aligns with the \bevy\_camera\ and \bevy\_core\_pipeline\ prepasses, and ensures proper synchronization of temporal jitter and resolution overrides through the standard render pipeline.

_crates/bevy\_anti\alias/src/dlss · high confidence

Diagnostics now use milliseconds and support configurable smoothing and history length

The \FrameTimeDiagnosticsPlugin\ now reports frame time in milliseconds (previously seconds) and exposes \max\_history\_length\ and \smoothing\_factor\ configuration options, allowing users to tune the exponential moving average and the number of historical measurements kept. The underlying \Diagnostic\ struct supports these settings, and the \EntityCountDiagnosticsPlugin\ also exposes a configurable \max\_history\_length\. Additionally, a new \FrameCountPlugin\ and \FrameCount\ resource track the total number of frames rendered since application start, which is exposed via the diagnostics system.

_crates/bevy\diagnostic/src · high confidence

File asset I/O now limits open file handles on non-Windows platforms

The file-based asset reader and writer in \crates/bevy\_asset/src/io/file\ now enforce a limit on the number of concurrently open files to prevent resource exhaustion. On macOS and iOS, the limit is set to 128 (half of the OS default of 256), and on Linux and Android, it is set to 512 (half of the OS default of 1024). This is implemented via a semaphore that guards file access in the multi-threaded file asset implementation, ensuring that the application does not exceed system file descriptor limits during asset loading.

_crates/bevy\asset/src/io/file · high confidence

Fullscreen shader now provided as a typed resource

The fullscreen vertex shader is now exposed as a \FullscreenShader\ resource that automatically loads the \fullscreen\_vertex\_shader.wesl\ asset. This resource provides a \to\_vertex\_state\ method to generate the necessary \VertexState\ for rendering a full-screen triangle, simplifying the setup for post-processing and other full-screen effects.

_crates/bevy\_core\_pipeline/src/fullscreen\_vertex\shader · high confidence

GPU-driven mesh preprocessing and indirect drawing infrastructure

The renderer now offloads mesh uniform allocation and indirect draw parameter generation to the GPU via new compute shaders (\allocate\_uniforms.wesl\, \build\_indirect\_params.wesl\). This enables multi-draw indirect operations by default, allowing the GPU to batch and sort mesh instances more efficiently. The change introduces a new \GpuMeshPreprocessPlugin\ and associated Rust systems to manage these compute passes, supporting both indexed and non-indexed meshes while optimizing memory usage and reducing CPU overhead during the render queue preparation phase.

_crates/bevy\pbr/src/render · high confidence

Introduce SystemAccess enum for explicit system world access tracking

The system module now uses a new \SystemAccess\ enum to explicitly track whether a system requires no access, shared access, or exclusive access to the world. This replaces previous implicit or less structured access tracking, providing clearer semantics for parallel execution and conflict detection. The enum includes methods like \is\_none\, \is\_shared\, and \is\_exclusive\ to query access levels, and \try\_extend\ to combine accesses while checking for compatibility. This change improves the clarity and safety of system scheduling by making access requirements explicit and verifiable at the system level.

_crates/bevy\ecs/src/system · high confidence

Introduce configurable skybox with rotation and exposure support

The skybox rendering system has been updated to support user-defined rotation and dynamic brightness adjustment based on camera exposure. The skybox now applies a rotation transform to the skybox texture, allowing users to orient the skybox independently of the camera's view direction. Additionally, the skybox's brightness is now multiplied by the current camera's exposure value, ensuring the skybox integrates correctly with the scene's lighting and exposure settings. This change also includes a new embedded shader (skybox.wesl) that calculates ray directions from the main pass viewport to sample the skybox texture, ensuring correct rendering even at large camera translations.

_crates/bevy\_core\pipeline/src/skybox · high confidence

Introduce configurable system executors with unified error handling

The ECS schedule executor has been refactored to support custom system execution strategies via a new \SystemExecutor\ trait, replacing the previous hardcoded \SimpleExecutor\. This change introduces a \default\_executor()\ function that automatically selects \MultiThreadedExecutor\ (when the \std\ and \multi\_threaded\ features are enabled) or falls back to \SingleThreadedExecutor\ (on \wasm32\ or when \std\ is disabled). The executor now accepts an \ErrorHandler\ function, allowing applications to configure how system panics and errors are handled rather than relying on default panic behavior. Additionally, the \ApplyDeferred\ system is now a dedicated system type that the executor explicitly handles to manage deferred command buffers.

_crates/bevy\ecs/src/schedule/executor · high confidence

Major refactoring of the GLTF loader with new configuration and extension handling

The GLTF loader has been significantly restructured to improve modularity and performance. The \GltfLoader\ now exposes configurable settings for default image samplers, coordinate conversion strategies, skinned mesh bounds policies, and mesh compression arguments. A new \GltfExtensionHandler\ interface allows third-party or custom processing of glTF extension data during the load process. Additionally, the loader now supports loading GLTF animations conditionally via the \bevy\_animation\ feature, and image loading failures will now correctly propagate as GLTF load failures rather than silent errors.

_crates/bevy\gltf/src/loader · high confidence

Migrate shader assets to WESL format

The shader assets in \assets/shaders\ have been converted to the new WESL (Wgpu Experimental Shader Language) format. This migration introduces support for WESL-specific features such as conditional compilation (e.g., \@if(BINDLESS)\, \@if(TONEMAP\_IN\_SHADER)\), module imports (e.g., \import bevy\_pbr::render::...\), and doc comments (\///\). The diff shows the addition of numerous new \.wesl\ files (e.g., \animate\_shader.wesl\, \custom\_material.wesl\, \deferred\_raymarch.wesl\) that replace or supplement previous shader implementations, enabling better integration with Bevy's rendering pipeline and improved developer tooling support.

assets/shaders · high confidence

New 2D opaque and transparent render pass nodes

The 2D core pipeline now uses dedicated render pass nodes (\main\_opaque\_pass\_2d\ and \main\_transparent\_pass\_2d\) to handle 2D rendering. The opaque pass renders both opaque and alpha-masked phases in a single pass, while the transparent pass loads the depth buffer to allow proper occlusion by opaque objects. A WebGL2-specific workaround is included to reset the viewport after the transparent pass.

_crates/bevy\_core\_pipeline/src/core\2d · high confidence

New 3D core pipeline render nodes and plugin structure

The 3D core pipeline now uses dedicated render node files (\main\_opaque\_pass\_3d\_node.rs\, \main\_transparent\_pass\_3d\_node.rs\) and a consolidated \mod.rs\ to manage the main pass execution. This change introduces explicit handling for resolution overrides via \MainPassResolutionOverride\ in both opaque and transparent passes, adds error logging for phase rendering failures, and implements a WebGL2-specific viewport reset workaround in the transparent pass to prevent rendering artifacts. The \Core3dPlugin\ now explicitly chains the opaque and transparent passes within the \Core3dSystems::MainPass\ set, replacing the previous graph-based node registration with a direct system schedule.

_crates/bevy\_core\_pipeline/src/core\3d · high confidence

New asset change detection and generic asset indexing

The asset system now includes an \AssetChanged\ query filter that allows systems to efficiently detect when specific asset types have been modified or added, eliminating the need to manually track changes via events. Additionally, asset identification has shifted from simple ascending integers to a generational \AssetIndex\ (combining an index and a generation counter) to safely handle asset recycling and prevent use-after-free bugs, while \Handle\ types now support both strong references and stable UUID-based references.

_crates/bevy\asset/src · high confidence

New dedicated upscaling pass with improved blend state and platform stability

The upscaling logic has been extracted into a new, dedicated render pass (UpscalingPlugin) that runs after other rendering systems. This change introduces a new \ViewUpscalingPipeline\ component to manage pipeline state per view, ensuring the upscaling blend state is correctly auto-detected based on camera render order (using alpha blending for subsequent cameras to prevent overwriting). It also adds a fix for uninitialized-drawable pink screen artifacts on iOS/Metal by ensuring a render pass is begun even when the pipeline is not yet ready, and applies the camera viewport scissor rect to the upscale pass to match the camera's output area.

_crates/bevy\_core\pipeline/src/upscaling · high confidence

New glTF asset structure and coordinate conversion controls

The \bevy\_gltf\ crate now exposes a structured \Gltf\ asset containing named and indexed handles to scenes, meshes, nodes, materials, skins, and animations, enabling users to load and access specific parts of a glTF file via \GltfAssetLabel\. Additionally, a new \GltfConvertCoordinates\ configuration allows users to explicitly control how glTF's +Z-forward coordinate system is converted to Bevy's -Z-forward system, with separate toggles for rotating scene entities and mesh assets to prevent visual misalignment.

_crates/bevy\gltf/src · high confidence

New low-level storage primitives: BlobArray, Column, and ThinArrayPtr

The ECS storage module now includes new internal data structures to back component and resource storage. BlobArray provides a flat, type-erased contiguous memory block for dense homogeneous data, while Column serves as the underlying storage for ComponentSparseSet. ThinArrayPtr offers a lightweight, capacity-tracked pointer to allocated memory without length management, and SparseArray/ImmutableSparseArray provide efficient sparse mappings. These types replace previous implementations to improve memory layout and iteration performance for tables and sparse sets.

_crates/bevy\ecs/src/storage · high confidence

New migration guides for Bevy 0.21 API and behavior changes

This release adds a comprehensive set of migration guides to the \\_release-content/migration-guides\ directory, documenting breaking changes and API updates for users upgrading to Bevy 0.21. The guides cover a wide range of subsystems: UI changes including the \GhostNode\ reimplementation, the split of \ui\_layout\_system\, the removal of \UiSurface\, and the migration of numeric input types to \bevy\_ui\_widgets\; reflection updates such as \Reflect\ no longer being a super trait of \FromReflect\, new \swap\ methods for \List\ and \Array\, and support for map/set keys in reflection paths; rendering and asset changes like the new \correction\_range\ for \AutoExposure\, HDR cubemap loading support, and merged mesh view samplers; and system/asset API shifts including \ProcessContext::load\_source\_asset\ returning typed assets, \Trigger\ trait safety improvements, and \Entity\ serialization format changes. Users should review these guides to update their code for struct literals, trait implementations, and resource usage.

_\release-content/migration-guides · high confidence

Non-linear color space conversion during blit operations

The blit pipeline now supports automatic color space conversion when copying textures. If the source texture uses an SRGB or OKLAB compositing space, the blit process automatically converts the color data to linear RGB before writing to the target, ensuring correct color handling in rendering pipelines.

_crates/bevy\_core\pipeline/src/blit · high confidence

Observers now support run conditions and centralized storage

Observers can now be configured with run conditions using \.run\_if()\, allowing them to execute only when specific world-state checks pass. The observer system has been restructured to use a centralized storage model (\Observers\ and \CachedObservers\) for efficient lookup of observers by event key, component, or entity, replacing the previous distributed approach. This change also introduces dedicated modules for observer conditions, entity cloning support for observers, and refined system parameters for handling triggered events.

_crates/bevy\ecs/src/observer · high confidence

Prepass shader pipeline migrated to WESL

The prepass rendering logic in \crates/bevy\_pbr/src/prepass\ has been rewritten using the WESL shader language, replacing the previous implementation. This migration introduces new shader modules (\bindings.wesl\, \io.wesl\, \prepass.wesl\, \utils.wesl\) that handle vertex decompression, morph target and skinning transformations, and motion vector calculation for temporal anti-aliasing. The Rust side (\mod.rs\, \prepass\_bindings.rs\) now loads these embedded WESL libraries and configures bind group layouts for depth, normal, motion vector, and deferred prepass textures, ensuring the prepass pipeline correctly interfaces with the updated rendering infrastructure.

_crates/bevy\pbr/src/prepass · high confidence

Refactor ECS storage to use a new Column type and TableId/TableRow identifiers

The internal storage implementation for \bevy\_ecs\ has been restructured to use a new \Column\ type (extracted from \thin\_array\_ptr\/\BlobArray\ usage) and explicit \TableId\ and \TableRow\ identifiers. This change replaces previous implicit or less structured access patterns with a more explicit, type-safe API for locating and manipulating component data within tables, improving clarity and safety for internal storage operations.

_crates/bevy\ecs/src/storage/table · medium confidence

Refactor glTF loader into modular extension helpers

The glTF loader's internal logic has been reorganized into a new \gltf\_ext\ module containing dedicated helper files for materials, meshes, scenes, and textures. This change introduces specific behaviors such as using Beer's law for light attenuation, allowing users to fix glTF coordinate system imports, and ensuring that texture sampler filters are no longer ignored. It also adds support for parsing glTF specular extensions and fixes issues where GLTF files loaded from custom asset sources were previously broken.

_crates/bevy\_gltf/src/loader/gltf\ext · medium confidence

Refactored change detection into a modular module with per-column tracking support

The change detection subsystem has been reorganized into a dedicated \change\_detection\ module, splitting the logic into \maybe\_location\, \params\, \tick\, and \traits\ files. This refactor introduces \ContiguousComponentTicksRef\ and \ContiguousComponentTicksMut\, enabling per-column change tracking that allows clients performing contiguous iteration to efficiently skip entire tables. The module also exports \MaybeLocation\ for optional compile-time location tracking, \Tick\ and \AtomicTick\ for managing change timestamps, and the \DetectChanges\/\DetectChangesMut\ traits that power \is\_changed\, \is\_added\, and \is\_changed\_after\ checks on resources and components.

_crates/bevy\_ecs/src/change\detection · high confidence

Removal of accesskit re-export from bevy\_a11y

The \bevy\_a11y\ crate no longer re-exports the \accesskit\ crate. Users who need to use \AccessKit\ types directly must now add it as a separate dependency in their project's \Cargo.toml\, ensuring they use the same version as Bevy to avoid conflicts.

_crates/bevy\a11y/src · high confidence

Reworked event system with new \`Event\` and \`Trigger\` traits

The event handling mechanism in \bevy\_ecs\ has been restructured to use a new \Event\ trait and a \Trigger\ trait that defines how observers are executed. This change introduces \GlobalTrigger\ for standard events and \EntityTrigger\ for entity-specific events, allowing for more flexible observer matching and execution order. Users will now derive \Event\ or \EntityEvent\ to define their event types, and the system ensures that observers are triggered immediately upon calling \World::trigger\ or \Commands::trigger\.

_crates/bevy\ecs/src/event · high confidence

Support for extension-less assets and new RON data formats

The asset system now supports loading assets without file extensions, demonstrated by the addition of \asset\_no\_extension\. Additionally, new RON-based data files (\simple\_data.ron\, \asset.custom\) have been added, indicating support for generic RON format saving and loading for both reflected and strongly-typed data.

assets/data · high confidence

Tonemapping pass now supports 3D LUTs and warns on incompatible settings

The tonemapping post-processing step now uses 3D LUT textures (Blender Filmic, AGX, Tony McMapface) for color grading, with a new \TonemappingLuts\ resource managing these assets. The system now warns users if they enable \Tonemapping::None\ while also using \DebandDither::Enabled\ or non-default \ColorGrading\, as these features have no effect without active tonemapping. Additionally, the tonemapping bind group is now recreated whenever the view uniforms buffer changes, ensuring correct rendering when view parameters are updated.

_crates/bevy\_core\pipeline/src/tonemapping · high confidence

Unified ECS error handling with severity-based fallback

Bevy now uses a centralized \BevyError\ type for systems, commands, and observers, allowing errors to carry a \Severity\ level (Trace through Panic) and optional context. The default \FallbackErrorHandler\ routes errors based on this severity—logging at the corresponding level or panicking for \Panic\ severity—while remaining configurable via the \FallbackErrorHandler\ resource. This replaces previous ad-hoc error handling with a consistent, extensible mechanism that improves debugging context and crash control.

_crates/bevy\ecs/src/error · high confidence

Fixes

1 commit (1 fix) fixing crates/bevy\_pbr/src/bluenoise

A fix in crates/bevy\_pbr/src/bluenoise — 1 commit (1 fix), 1 file: “Fix webgl2 (\#20286)” (refs \#20286).

_crates/bevy\pbr/src/bluenoise · low confidence · unverified

3 commits (2 fixes) fixing assets/models/cubes

A fix in assets/models/cubes — 3 commits (2 fixs), 1 file: “Revert "Implement minimal reflection probes. (\#10057)" (\#11307)”; “Implement minimal reflection probes. (\#10057)”; “Implement minimal reflection probes (fixed macOS, iOS, and Android). (\#11366)” (refs \#10057, \#11307, \#11366).

assets/models/cubes · medium confidence · unverified

Test coverage

Add ECS benchmarks for bundles, change detection, and entity cloning; Add ECS scheduling benchmarks; Add ECS world performance benchmarks; Add benchmarks for Bezier curves and bounding volumes; Add benchmarks for the new Bevy Scene system; Add compile-fail tests for bevy\_reflect; Add component storage benchmarks for table and sparse set variants; Add event write and iteration benchmarks; Add integration test for Bevy ECS component and resource access; Add observer benchmarks for custom, lifecycle, and propagation scenarios; Add parallel iterator benchmarks for bevy\_tasks; Added barycentric coordinate test asset; Added benchmarks for AlignedVec performance; Added benchmarks for Bevy transform propagation; Added benchmarks for ECS param systems; Added camera primitive intersection benchmarks; Added compile-fail test harness for ECS APIs; Added compile-fail test infrastructure for bevy\_ecs; Added compile-fail tests for Deref and DerefMut derives; Added compile-fail tests for bevy\_ecs safety invariants; Added fuzz testing harness for bevy\_ecs; Added integration tests for 3D rendering, ECS, and window management; Added ray-mesh intersection benchmark for picking performance; Added render subsystem benchmarks; Added test assets for tonemapping validation; Added text layout benchmarks; New ECS iteration benchmarks for performance validation.

Dependencies

2104 commits updating dependencies (113 manifests)

A dependency / build maintenance change in (dependencies) — 2104 commits (150 fixs), 113 files: “Add docs & example for SystemParam (\#1435)”; “Instanced line rendering for gizmos based on \bevy\_polyline\ (\#8427)”; “Move EntityCursor out of bevy\_feathers to bevy\_picking (\#25294)”; and 2099 more (refs \#1435, \#8427, \#25294, \#16589, \#21971, …).

(dependencies) · medium confidence · unverified

Replace petgraph with a custom graph implementation in bevy\_ecs

The \bevy\_ecs\ schedule graph module no longer depends on the external \petgraph\ crate. Instead, it uses a new internal implementation consisting of \DiGraph\ and \UnGraph\ structures (in \graph\_map.rs\), a \Dag\ wrapper with topological sorting (in \dag.rs\), and a custom Tarjan's Strongly Connected Components algorithm (in \tarjan\_scc.rs\). This change removes the \petgraph\ dependency, reducing the crate's external footprint and allowing for better control over graph operations within the ECS schedule system.

_crates/bevy\ecs/src/schedule/graph · high confidence

Housekeeping

Add Bevy ECS and Bevy App crate documentation and licenses; Add license and README files to bevy\_anti\_alias crate; Added documentation and license files to bevy\_audio crate; Added documentation for environment map asset generation; Added documentation for tonemapping LUT generation; Added font license files for EBGaramond, FiraMono, and Mona Sans; Added license and README files to Bevy crates; Added license files to Bevy macro and core crates.

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 54 → 54 (-0.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 60 → 59 (-1.0)
  • Architecture 96 → 96 (-0.1)
  • Maturity 81 → 81 (+0.5)
  • Readiness 72 → 70 (-2.4)
  • Security 34 → 35 (+1.0)
  • Event Sourcing 100 → 100 (+0.0)
  • Performance 91 → 91 (+0.0)

Resolved (182)

  • App::run (cognitive 37) (tools/export-content/src/app.rs)
  • App::run (cyclomatic 24) (tools/export-content/src/app.rs)
  • Change coupling: main_opaque_pass_3d_node.rs ↔ node.rs (crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs)
  • Change coupling: mod.rs ↔ picking_backend.rs (crates/bevy_picking/src/mesh_picking/mod.rs)
  • Change-coupling hub: mod.rs → mod.rs, copy_lighting_id.rs, mod.rs, mod.rs (crates/bevy_anti_alias/src/taa/mod.rs)
  • Change-coupling hub: node.rs → main_opaque_pass_3d_node.rs, node.rs, light.rs, node.rs (crates/bevy_core_pipeline/src/deferred/node.rs)
  • Cross-context type ArchetypeId (bevy_ecs → bevy_asset) (crates/bevy_asset/src/asset_changed.rs)
  • Cross-context type Context (bevy_ecs → bevy_asset) (crates/bevy_asset/src/io/memory.rs)
  • Cross-context type Context (bevy_ecs → bevy_asset) (crates/bevy_asset/src/io/mod.rs)
  • Cross-context type Context (bevy_ecs → bevy_asset) (crates/bevy_asset/src/io/mod.rs)
  • Cross-context type Context (bevy_ecs → bevy_asset) (crates/bevy_asset/src/io/mod.rs)
  • Cross-context type Context (bevy_ecs → bevy_asset) (crates/bevy_asset/src/io/mod.rs)
  • Cross-context type Context (bevy_ecs → bevy_asset) (crates/bevy_asset/src/io/processor_gated.rs)
  • Cross-context type Entity (bevy_ecs → bevy_asset) (crates/bevy_asset/src/asset_changed.rs)
  • Cross-context type Entity (bevy_ecs → bevy_winit) (crates/bevy_winit/src/converters.rs)
  • Cross-context type Entity (bevy_ecs → bevy_winit) (crates/bevy_winit/src/converters.rs)
  • Cross-context type Entity (bevy_ecs → bevy_winit) (crates/bevy_winit/src/winit_monitors.rs)
  • Cross-context type Entity (bevy_ecs → bevy_winit) (crates/bevy_winit/src/winit_windows.rs)
  • Cross-context type Entity (bevy_ecs → bevy_winit) (crates/bevy_winit/src/winit_windows.rs)
  • Cross-context type Entity (bevy_ecs → bevy_winit) (crates/bevy_winit/src/winit_windows.rs)
  • …and 162 more

New (658)

  • Change coupling: main_opaque_pass_3d_node.rs ↔ node.rs (crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs)
  • Change coupling: retained.rs ↔ pipeline_2d.rs (crates/bevy_gizmos/src/retained.rs)
  • Change coupling: retained.rs ↔ pipeline_3d.rs (crates/bevy_gizmos/src/retained.rs)
  • Change-coupling hub: mod.rs → mod.rs, copy_lighting_id.rs, mod.rs (crates/bevy_anti_alias/src/taa/mod.rs)
  • Change-coupling hub: node.rs → node.rs, light.rs, node.rs (crates/bevy_core_pipeline/src/deferred/node.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_core_pipeline/src/core_3d/main_transparent_pass_3d_node.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_core_pipeline/src/oit/resolve/node.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_ecs/src/schedule/schedule.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_pbr/src/render/mesh.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_reflect/derive/src/impls/enums.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_reflect/derive/src/registration.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_reflect/src/type_registry.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_remote/src/builtin_methods.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_render/src/render_resource/pipeline_cache.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_render/src/render_resource/storage_buffer.rs)
  • Duplicated block (10 lines × 2) (crates/bevy_ui_render/src/lib.rs)
  • Duplicated block (10–13 lines × 2) (crates/bevy_ecs/src/storage/sparse_set.rs)
  • Duplicated block (11 lines × 2) (crates/bevy_asset/src/io/processor_gated.rs)
  • Duplicated block (11 lines × 2) (crates/bevy_curve/src/lib.rs)
  • Duplicated block (11 lines × 2) (crates/bevy_ecs/src/world/deferred_world.rs)
  • …and 638 more

Changes since last survey

  • 127 commits — 101 feature/other, 26 fixes

By area

  • crates/bevy_ui — 14 commits
  • .github/workflows — 12 commits
  • crates/bevy_pbr — 12 commits
  • crates/bevy_ecs — 7 commits
  • crates/bevy_feathers — 7 commits
  • crates/bevy_remote — 6 commits
  • crates/bevy_render — 6 commits
  • crates/bevy_solari — 6 commits
  • _release-content/release-notes — 3 commits
  • crates/bevy_core_pipeline — 3 commits
  • crates/bevy_inspector — 3 commits
  • crates/bevy_light — 3 commits
  • crates/bevy_reflect — 3 commits
  • crates/bevy_text — 3 commits
  • crates/bevy_ui_widgets — 3 commits
  • .github/actions — 2 commits
  • _release-content/migration-guides — 2 commits
  • crates/bevy_scene — 2 commits
  • crates/bevy_sprite_render — 2 commits
  • (root) — 1 commit

Notable commits

  • fix: Another UI layout regression test (#26293)
  • fix: Fix AutoExposure buffers never being removed (#26400)
  • fix: Fix Earth atmosphere scale heights and Mie coefficients (#26143)
  • fix: Fix Popover misplacing scaled or rotated descendants (#26276)
  • fix: Fix Solari indirect dispatch argument layout on Metal (#26100)
  • fix: Fix broken FontSource behavior in bsn! {} (#26274)
  • fix: Fix cascade shadow assertion typo (#26412)
  • fix: Fix clustered lights disappearing (#26185)
  • fix: Fix fog volumes disappearing when the camera is within near-plane distance of the volume (#25336)
  • fix: Fix meshlet simplification normal buffer bounds (#26317)
  • fix: Fix panic caused by reloading a world instance whose parent was despawned (#26459)
  • fix: Fix position reconstruction with main-pass resolution overrides (#26233)
  • fix: Fix resolved call sites in nested BSN macros (#26314)
  • fix: Fix scene_viewer setup retry when mesh AABBs are missing (#25667)
  • fix: Fix shadows to midtones blend in sectional color grading (#26477)
  • fix: Fix text wrapping when use_rounding is false (#26352)
  • fix: Fix tilemap chunk colors (#26426)
  • fix: Fix tonemapping and compositing space not applied to tilemap chunks (#26425)
  • fix: Fix transmission with main-pass resolution overrides (#26235)
  • fix: Fix unused imports in bevy_ecs tests for default features. (#26485)
  • …and 107 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

bevyengine/bevy was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 7ea4827e16d5d50d48e22d9a249c554ad073f38a — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.