What rendering features does Bevy Engine offer for 2D and 3D games?

Updated

Bevy Engine ships with two separate renderers — a 2D renderer and a 3D renderer — that share the same foundation: the Bevy Render Graph. Both are extensible through custom shaders, materials, and render pipelines, and both are driven by Bevy ECS. If you need real-time 2D graphics, you use the 2D renderer; if you need lights, shadows, and glTF-loaded meshes, you use the 3D renderer. You can also compose your own pipelines on top of the Render Graph when the built-in features aren't enough.

2D renderer

The 2D renderer is built for real-time 2D graphics in games and apps. According to the Bevy Engine site, its features include:

  • Sprite sheets — for frame-based animation and tile-based art.
  • Dynamic texture atlases — atlases that can be built and updated at runtime.
  • Cameras — 2D camera setup for viewing your scene.
  • Textures and materials — the basic building blocks for drawing 2D content.

It is also extensible: you can write custom shaders, materials, and render pipelines. The 2D renderer is described as building on top of Bevy's common core, the Render Graph.

3D renderer

The 3D renderer is described as modern and flexible. Its listed features are:

  • Lights — lighting for 3D scenes.
  • Shadows — shadow rendering.
  • Cameras — 3D camera setup.
  • Meshes — 3D geometry.
  • Textures and materials — surface appearance.
  • glTF loading — importing 3D assets in the glTF format.

Like the 2D renderer, it supports custom shaders, materials, and render pipelines, and it is built on top of the Render Graph.

What the two renderers share

Dimension 2D renderer 3D renderer
Core features Sprite sheets, dynamic texture atlases, cameras, textures, materials Lights, shadows, cameras, meshes, textures, materials, glTF loading
Extensibility Custom shaders, materials, render pipelines Custom shaders, materials, render pipelines
Common foundation Bevy Render Graph Bevy Render Graph

Both renderers are part of the same engine and rely on the same Render Graph core, so custom render logic you build for one is composed from the same graph structure.

The Render Graph underneath

The Render Graph is the shared layer both renderers build on. The site describes it as a way to compose custom render pipelines using a graph structure, with three properties worth noting:

  • Parallel — Render Graphs are automatically rendered in parallel.
  • Modular — you build composable, reusable render logic using Render Graph nodes.
  • Backend agnostic — it is not tied to a specific graphics API.

This matters if you plan to go beyond the built-in 2D and 3D features: instead of patching the renderer, you add nodes to the graph.

Related systems that affect rendering

  • Animation — skeletal rig animation driven by an ECS-based joint API, blending multiple animations at once, blend shapes / morph targets for direct vertex animation, and animation import from glTF files.
  • Bevy UI — an ECS-driven UI framework built directly on top of Bevy's ECS, Renderer, and Scene plugins, using a flex box layout model.
  • Scenes — create, save, and load ECS worlds; loading preserves entity IDs (useful for save games), instancing creates linked duplicates with new entity IDs, and scene file changes hot-reload into running apps.
  • Hot reloading — asset changes are reflected in running apps without restarts or recompiles; scenes, textures, and meshes can currently be hot-reloaded, and any asset type can be integrated.
  • Cross-platform support — Windows, macOS, Linux, Web, iOS, and Android.

Choosing between them

Use the 2D renderer when your game or app draws sprites, sprite sheets, or dynamic texture atlases and does not need lights and shadows. Use the 3D renderer when you need meshes, lighting, shadows, and glTF asset loading. If neither covers your case, extend either one through custom shaders, materials, and render pipelines, or compose new logic directly on the Render Graph. Bevy Engine is described on its site as free and open source forever, built in Rust.