Quick Reference: Alphabetical Index / Glossary

This page lists many common terms and concepts that you may come across while working with Bevy. It is in alphabetical order. Every entry has a brief definition, and links to relevant places in this book, where it is explained, if any.

It contains both bevy-specific jargon (including advanced topics that might not yet be covered by this book), as well as general game development or computer graphics topics that are relevant to working with Bevy.

The list is not exhaustive. I try my best to expand it to include anything that may be useful. If you notice any omissions / want something added, file an issue on GitHub or send me a message on Discord (Ida Iyes#0981).

Bookmark this page in your browser, for a quick reference when working with Bevy!

(some of the links may be broken, as they refer to planned or unpublished content. This book is WIP/incomplete; thank you for understanding! <3 )


Bevy Programming Jargon

Terms and concepts related to Bevy-specific features and APIs.

TopicDefinition
App / App BuilderBevy entry point; setup all the things to run.
AssetsThe data used by your game. Typically loaded from external files, or generated procedurally using code.
Asset LoaderImplementation for loading a specific asset type from a specific file format.
AssetServerBevy API for accessing and loading assets from external data files.
BundlesA "template" for easily spawning entities with a common set of component types.
Change DetectionWrite logic that responds to data being changed.
CommandsSpawn/despawn entities, manage components and resources. Deferred until they can be safely applied.
ComponentsPer-entity data. Basic data primitive in Bevy.
EntitiesID for a set of component values. Often conceptually represents an "object".
EventsCommunicate between systems. Send/receive data.
Exclusive SystemsSystems that have full access to the whole ECS world and do not run in parallel with any other systems.
Fixed TimestepRun some logic at a fixed time interval. Important for physics and simulations.
HandlesID for referring to an Asset in your game code. Reference counted (Bevy automatically unloads assets when there are no more handles).
Hot ReloadingAutomatically reloading assets from files if they are changed while the game is running.
LabelsNames for systems, stages, and other things.
Local ResourcesPer-system data.
Non-SendData that cannot be used in a multithreaded context, must be confined to a single thread.
Parent/Child HierarchyEntities in a hierarchical relationship.
PluginsBuild the App in a modular way.
QueriesFind matching entities and access their component data.
Query FiltersCriteria for narrowing down the entities to be accessed by a query.
Query SetsResolve query conflicts.
Removal DetectionWrite logic that responds to data being removed from the ECS.
ResourcesGlobal data for the whole app.
Run CriteriaLow-level primitive for controlling if systems run.
ScenesCollection of preconfigured entities that you can spawn into the world. Similar to "prefabs" in other game engines.
Schedule (systems)All the systems that Bevy runs every frame update, optimized to run on the task pool with maximum parallelism and performance.
StagesHard synchronization points for runtime scheduling.
StatesControl which systems run, by defining different "modes" your app can be in.
SystemsThe functions that contain your game logic.
SystemParamsThe acceptable Rust types to be used as function parameters in Bevy systems.
System ChainingCombine multiple Rust functions into one big system.
System OrderControl the runtime order of execution of systems.
System SetsGroup multiple systems together to apply common properties (labels, ordering, states, run criteria).
TextureAsset type, typically an image (but more generally any data) that can be sampled by the GPU during rendering (in a shader).
TransformsPosition and orientation of an object. May be relative to a parent object.
Untyped HandlesAsset Handle that can refer to an asset regardless of the asset type.
Weak HandlesAsset Handles that are not reference-counted (do not prevent the asset from being unloaded).
WorldThe underlying data structure / storage of the ECS. Contains all component and resource data.

Ecosystem Jargon

Terms and concepts related to the community and ecosystem around bevy and the development of the project, such as libraries and technologies that bevy uses.

TopicDefinition
Assets; Bevy AssetsPage on the Bevy Website listing community-made plugins and content (not to be confused with Assets, as in your game's data).
Data-drivenProgramming style / paradigm, where functionality is thought of in terms of the data it works with. Bevy is based on this philosophy.
ECSThe data storage / programming paradigm Bevy uses. Conceptually like a database. Bevy is often compared to other ECS implementations.
Features (cargo)A way to configure what optional functionality is included in your build.
FlexboxThe layout model used in Bevy UI (originates from CSS in web browsers).
GILRSThe library that Bevy uses for controller/joystick support.
GLTFFile format for 3D assets; can contain meshes, textures, materials, scenes.
Kira3rd-party audio library often used with Bevy (bevy_kira_audio plugin), much more feature-rich than Bevy's own audio.
main (bevy main)Development version of Bevy; git branch containing the latest unreleased changes.
MetalLow-level system API for accessing GPU hardware on Apple systems (macOS/iOS).
OpenGLLegacy GPU API for systems that do not support Vulkan. Not yet supported by Bevy.
Plugins (3rd-party crates)Libraries made by the community that can be added to your Bevy App.
VulkanLow-level system API for accessing GPU hardware. The interface to the graphics driver. Available on most platforms except Apple.
WebAssembly (WASM)New technology that allows running software like Bevy inside of a web browser.
WebGPU (WGPU)The cross-platform GPU API that Bevy uses. Allows using modern GPU features safely across different platforms (desktop/mobile/web).
WinitThe library that Bevy uses for windowing (managing the OS windows to display in)

Game Development Jargon

General game development concepts that are applicable to working with Bevy.

TopicDefinition
AssetsThe data used by your game. Typically loaded from external files, or generated procedurally using code.
CameraEntity representing a "view" into the game world, to be rendered.
Coordinate SystemOrientation of the X/Y/Z axes, defining the 3D space.
Fixed TimestepRun some logic at a fixed time interval. Important for physics and simulations.
MaterialThe shading properties for a surface to be drawn by the GPU, such as its color/texture, how shiny it is, ...
Mesh3D geometry data, consists of vertices, typically arranged into many triangles. Required for the GPU to draw an object.
Parent/Child HierarchyEntities in a hierarchical relationship.
Procedural GenerationCreating game assets using code/math/algorithms (often done at runtime, instead of loading asset files).
RaycastCalculating a simulated "ray" in the game world. Used, for example, for checking what object is under the mouse cursor.
ScenesCollection of preconfigured entities that you can spawn into the world. Similar to "prefabs" in other game engines.
ShadersCode that runs on the GPU. Typically for rendering graphics, but also for general computations.
SpritesGame object that is a 2D rectangle displaying an image. Most 2D games are made from these.
TextureTypically an image (but more generally any data) that can be sampled by the GPU during rendering (in a shader).
TransformsPosition and orientation of an object. May be relative to a parent object.
UIUser Interfaces like menus and in-game HUDs, typically displayed as overlays on top.

Rendering Jargon

Concepts that come up when working with computer graphics and the GPU, as applicable to Bevy.

TopicDefinition
Anisotropic FilteringMethod of sampling a texture that accounts for the angle between the surface and the camera, resulting in better visual quality.
Anti-AliasingTechniques to reduce aliasing artifacts (shimmering or jagged edges, when there is too much detail for the display resolution).
BatchingCombining compatible data from many meshes/entities together, so that it can be drawn by the GPU all at once.
CameraEntity representing a "view" into the game world, to be rendered.
Compute Shaders / GPU ComputeA way to use the GPU for general data processing.
Coordinate SystemOrientation of the X/Y/Z axes, defining the 3D space.
CullingFiguring out which parts of the scene don't need to be drawn and skipping them to improve performance.
Directional LightGlobal light source that illuminates the whole world, at a specified angle/direction. Typically models the sun in outdoor scenes.
Draw CallTelling the GPU to render something. Expensive; for best performance, aim to draw everything you need with the fewest draw calls.
FrustumThe space/volume that is visible from a camera. Everything that the camera can see.
Indices / Index BufferA way to make mesh data more compact (to save memory) by deduplicating vertices.
InstancingA way to tell the GPU to draw many copies of the same mesh efficiently. Useful for things like vegetation (lots of grass / trees).
MaterialThe shading properties for a surface to be drawn by the GPU, such as its color/texture, how shiny it is, ...
Mesh3D geometry data, consists of vertices, typically arranged into many triangles. Required for the GPU to draw an object.
MipmapsTextures with data available in many sizes (like 64x64, 32x32, 16x16, 8x8, ...). The GPU automatically uses the most appropriate.
MSAAMulti-Sample Anti-Aliasing: hardware AA method: for pixels along edges of meshes, the GPU will render multiple samples.
Normals / Normal VectorsThe direction perpendicular to a surface. Useful for shading, to compute how light interacts with the surface.
Normal MapsA way to add extra detail to a 3D object, using a texture that changes the normals to affect how light interacts with it.
Physically-Based RenderingModern realistic 3D graphics technique that uses materials that model physical properties, like how rough or metallic a surface is.
Point LightA light source that radiates in all directions from a given position, like a lamp or candle.
Post-ProcessingAfter rendering (but before displaying), apply some visual effects to the whole image.
Render GraphBevy's abstraction for modular configurable rendering. Connects "nodes" together to enable various graphical features.
Render PipelineThe procedure to be executed by the GPU to draw something. Includes the shaders to run, as well as setting fixed hardware parameters.
Sampler / Sampling (textures)How the GPU picks a value (like a color) from a specific position on a texture.
ShadersCode that runs on the GPU. Typically for rendering graphics, but also for general computations.
TextureTypically an image (but more generally any data) that can be sampled by the GPU during rendering (in a shader).
TexelA pixel that is part of a texture.
TransformsPosition and orientation of an object. May be relative to a parent object.
UniformsShader input data that is "global" for the whole mesh (unlike Vertex Attributes, which are per-vertex).
UVs / UV coordinatesTexture coordinates, used to map a texture to a mesh. The position on the texture that each vertex corresponds to.
Vertex / VerticesBuilding block of Meshes, typically a point in 3D space, with associated vertex attributes.
Vertex AttributesData associated with each vertex in a mesh, such as its position, color, UVs, normals, etc.