flutter3d and Flutter Scene
Flutter Scene is the other engine built on Flutter GPU. It is maintained by the author of Flutter GPU itself, a former core Flutter engine team member who spent four years on Flutter, most of it building Impeller. That gives it a relationship with the underlying API that no third-party package can have: Scene's render tests are where Flutter GPU regressions get caught, because the author of Flutter GPU also writes the engine. flutter3d uses flutter_gpu the way any other package does, through the public surface.
The two projects are not after the same thing. Scene is a complete 3D game engine and toolkit for anyone building on Flutter, pre-1.0 and moving quickly. flutter3d started from a narrower question: whether a HAL, a scene graph and a game layer of this shape can be built by someone with no inside access to Impeller, tested against four games of different genres that needed no engine-level code changes between them. For 1.0.0 I took Scene's 0.24 as the bar to reach, and most of this page's old "Scene has, flutter3d doesn't" list moved as a result. This version of the page is as of 2026-10-12. The flutter3d half was read against the source tree of the 1.0.0-rc.1 release candidate, and its lines that had gone stale were corrected against the 1.0.0-rc.2 tree on 2026-10-20. The Scene half was read against flutter_scene 0.24.3, published on pub.dev on 2026-10-09: its README, its CHANGELOG, and the published package's source, which was searched for every capability the README does not name. Commits on Scene's main branch after 0.24.3 are not counted until they are released. Every "no" in the tables below carries that date, because each one is a claim about a project that moves every week.
Quick facts #
| flutter3d | Flutter Scene | |
|---|---|---|
| First commit | 2026-08-08 | 2024-02-01 |
| Core package version | 1.0.0-rc.2 | 0.24.3 (2026-10-09) |
| Maintainer | An independent developer, unaffiliated with the Flutter team | The author of Flutter GPU, formerly on the core Flutter engine team |
| Licence | MIT | MIT |
| Web backend | WebGPU by default, WebGL2 where WebGPU does not start | Built-in WebGL2 |
| Windows and Linux | Windows: games and editor built in CI, nobody has played them there yet. Linux: every test suite runs there, and since 1.0.0-rc.1 the conformance suite runs through Impeller under Xvfb on every CI run; until that run is green and a game has been played there, a Linux game draws through the CPU backend unless its runner turns Flutter GPU on | Both listed as platforms; shipping a release build needs Flutter 3.47.1 |
| Physics | Its own core in C (flutter3d_physics_native, through dart:ffi natively and WebAssembly in the browser), compiled from source by a build hook, with the pure-Dart flutter3d_physics as its reference and fallback |
Native: flutter_scene_rapier (prebuilt binaries + wasm) or flutter_scene_box3d |
| Audio | flutter_soloud, an FFI binding to the SoLoud engine, behind a pluggable backend interface |
flutter_scene_soloud, the same SoLoud engine, or flutter_scene_fmod (commercial middleware) |
| Input | pad_input for gamepads, flutter3d_pointer_lock for mouse look, and rebindable controls with a settings screen in flutter3d_game |
flutter_scene_input 0.1.0, new with 0.24: rebindable actions for keyboard, mouse, gamepads and pointer lock, with contexts and saved profiles |
| CPU / GPU-less test backend | Yes: flutter3d_cpu, a software rasteriser used in CI |
No backend of its own; CI renders its smoke scenes through Impeller on Mesa's software rasterisers (Linux), SwiftShader (Android emulator), headless Chrome and Windows, and Metal on Codemagic, compared in Argos |
| Multiplayer | Rollback for two to thirty-two peers, spectators fed from the settled tape, an authoritative server with predicting clients, and a relay that holds parties (flutter3d_net, flame_multiplayer; WebSocket, WebRTC or dashwire underneath) |
flutter_scene_net, over dashwire: replicated state, client-side prediction, and physics rollback for the entity a client owns |
| Editor with an MCP server | Yes: the level editor and the model editor are MCP servers in flutter3d_mcp on pub.dev; the level editor app builds for the desktop and, new in 1.0, for the browser, where it is offered by URL (download); native downloads not yet |
Yes: the Flutter Scene Editor 0.24.0, a desktop app with macOS, Windows and Linux downloads on its GitHub releases, not on pub.dev, and still "in active development" |
| Community, on 2026-10-12 | 32 stars on GitHub, 2 contributors; flutter3d downloaded 592 times on pub.dev in the last 30 days |
914 stars on GitHub, 25 contributors; flutter_scene downloaded 22,989 times on pub.dev in the last 30 days |
Feature by feature #
A green dot is a capability the engine has; a red one is a capability it does not. For flutter3d that is read from its source. For Flutter Scene it is read from its README and its CHANGELOG up to 0.24.3, and then checked against its source: a red dot there means none of the three names it in the engine's packages. Where Scene has something close in another form, the row is worded to the difference, and here is the form: god rays rather than volumetric fog, splats sorted on the CPU rather than on the GPU, a pure-Dart physics backend for queries and triggers with no dynamics, physics rollback for the one entity a client owns rather than every player's input, occlusion culling through planes an application supplies rather than a depth pyramid, and a selection outline rather than a high-contrast look. A row marked rc.3 is one flutter3d does not have in rc.2 and has scheduled for its third release candidate. Each row is one capability, so where both engines have something in different depths (physics, global illumination, the editor) the sections below say how they differ.
| Capability | flutter3d | Flutter Scene |
|---|---|---|
| Rendering | ||
| Physically based materials with clearcoat, sheen, anisotropy and transmission | yes | yes |
| User materials compiled for every backend, with lighting hooks | yes | yes |
| Rectangle area lights | yes | yes |
| Clustered lights, so a scene can hold many | yes | yes |
| Cascaded sun shadows with soft penumbrae and contact shadows | yes | yes |
| Exponential variance shadow maps (EVSM) for the sun | yes | no as of 2026-10-12 |
| Caustics under glass and water | yes | no as of 2026-10-12 |
| Irradiance probe field with a visibility test per probe | yes | yes |
| Horizon-based ambient occlusion and screen-space bounced light | yes | yes |
| Screen-space reflections, depth of field, bloom, automatic exposure | yes | yes |
| Planar reflections, and a camera that renders into a texture | yes | yes |
| A physical sky, and fog that thins with height | yes | yes |
| Volumetric fog | yes | no as of 2026-10-12 |
| Order-independent transparency | yes | no as of 2026-10-12 |
| Motion blur | yes | no as of 2026-10-12 |
| Local exposure, and HDR output (WebGPU only) | yes | no as of 2026-10-12 |
| Temporal anti-aliasing, FXAA and SMAA | yes | yes |
Lens flares, radial lens distortion and .cube LUTs | yes | yes |
| A light with a physical size, so glossy reflections widen to the emitter (a point light's radius) | no as of 2026-10-12 | yes |
| A shadow-catcher material: a surface that shows only the shadows cast on it, for a model over a photo or a camera feed | no as of 2026-10-12 | yes |
| External textures (video, a camera preview) as material inputs | rc.3 | yes |
| Billboards and sprites that face the camera | rc.3 | yes |
| Projected decals | yes | yes |
| Orthographic cameras through every effect | yes | yes |
| Gaussian splats | yes | yes |
| Splats sorted on the GPU (WebGPU compute) | yes | no as of 2026-10-12 |
| Octahedral impostors for distant models | yes | no as of 2026-10-12 |
| Automatic occlusion culling (Hi-Z) | yes | no as of 2026-10-12 |
| Reversed depth, a near plane fitted to what is drawn, and depth layers for coplanar surfaces | yes | yes |
| A probe that names the nodes fighting over depth in a running scene | no as of 2026-10-12 | yes |
| Quality that adapts to measured frame times | yes | yes |
| Debug views of material channels, and render stats per pass | yes | yes |
| Assets and animation | ||
| Skinning, morph targets and blended animation | yes | yes |
| An animation graph: state machines, blend spaces, layers, IK after the pose | yes | no as of 2026-10-12 |
| glTF material variants | yes | yes |
| glTF animation pointers (a clip moves a material or a light) | yes | no as of 2026-10-12 |
| Retargeting a clip onto another skeleton | yes | no as of 2026-10-12 |
| An ETC1S (Basis Universal) encoder, so a build cooks textures to small KTX2 files | no as of 2026-10-12 | yes |
| Models converted at build time by a build hook | yes | yes |
| Hot reload for shaders, models, textures, environments and levels | yes | yes |
| Backends | ||
| Impeller through Flutter GPU | yes | yes |
| WebGL2 in the browser | yes | yes |
| WebGPU in the browser | yes | no as of 2026-10-12 |
| Shader variants for tvOS and visionOS (Apple's embedded platforms take the iOS Metal variant) | no as of 2026-10-12 | yes |
| A software rasteriser in Dart, so rendering tests run without a GPU | yes | no as of 2026-10-12 |
| Games | ||
| Native rigid bodies that rotate, with joints and continuous collision | yes | yes |
| Physics through an established third-party engine (Rapier, box3d) | no as of 2026-10-12 | yes |
| The same games on pure-Dart dynamics when the native core is not there | yes | no as of 2026-10-12 |
| Ragdolls | yes | no as of 2026-10-12 |
| Cloth in the engine's packages | yes | no as of 2026-10-12 |
| Liquids, floating bodies, heat and fire in the physics | yes | no as of 2026-10-12 |
| Particles | yes | yes |
| Audio through SoLoud | yes | yes |
| Rebindable input with gamepads and pointer lock | yes | yes |
| Multiplayer with a server and client-side prediction | yes | yes |
| Rollback of every player's input, for parties of more than two | yes | no as of 2026-10-12 |
| Navigation meshes and behaviour trees | yes | no as of 2026-10-12 |
| A run recorded and replayed to the bit, with a time-travel debugger | yes | no as of 2026-10-12 |
| Levels generated from a seed (wave function collapse, erosion) | yes | no as of 2026-10-12 |
| Voxel worlds | yes | no as of 2026-10-12 |
| Genre packages: shooter, platformer, racing, strategy | yes | no as of 2026-10-12 |
| A bridge to the Flame 2D engine | yes | no as of 2026-10-12 |
| Tools and app integration | ||
| A scene editor with an MCP server for coding agents | yes | yes |
| Editor downloads for macOS, Windows and Linux | no as of 2026-10-12 | yes |
| Render stats and the frame's draws, read by an agent over MCP | yes | yes |
| Agent skills shipped with the packages | yes | yes |
| A declarative widget API for the scene | yes | yes |
| The scene described to a screen reader | partly; Scene3D(semantics:) in rc.3 | yes |
| A high-contrast look with outlines, and colour-vision correction | yes | no as of 2026-10-12 |
What Scene has that flutter3d doesn't #
Reading its README and CHANGELOG against flutter3d's own feature table:
- Physics on an engine other people have already shipped games with. Rapier and box3d, pluggable behind one contract, with Rapier's binaries built in CI and downloaded prebuilt. flutter3d's physics core in C covers a lot of the same ground now (turning bodies, convex hulls and triangle meshes, joints with motors and limits, continuous collision, a character controller, ragdolls, threads, the browser through WebAssembly), but it was started on 2026-10-04, and nobody outside this repository has run it yet. The games pass their suites on it and on the Dart reference both. That tells me it works for these games; it tells you much less about yours. It is compiled from source by a build hook, with the compiler the target already uses, so there is nothing prebuilt to download, but the build machine needs that compiler.
- FMOD. Both engines wrap the same SoLoud engine for audio, so that is not a difference; Scene also offers FMOD, commercial middleware, as a second backend.
- An editor you can download today. The Flutter Scene Editor 0.24.0 is on GitHub releases for macOS, Windows and Linux. flutter3d's level editor builds for the desktop and, since 1.0, for the browser, where it is offered by URL (documents kept in the page, Play attached to a game already running); there is no native download of it yet, and the download page says what there is.
- Windows and Linux through Impeller. Scene lists both as platforms, and its editor ships for them. On Windows, flutter3d's CI builds the games and the editor and runs the native physics core's tests under MSVC, and nobody has played a game there yet. On Linux every flutter3d test suite runs and the CPU backend draws the golden scenes. Impeller's OpenGL ES backend used to refuse the shaders that read
gl_VertexID; since 1.0.0-rc.1 no stage reads it on that target, and CI runs the conformance suite through Impeller under Xvfb on every Linux run. Until that run is green and a game has been played on a Linux desktop, a flutter3d game there draws through the software backend unless its runner turns Flutter GPU on. - Tools that find z-fighting. Both engines now store reversed float depth where the device allows it, move the near plane out to what is drawn each frame, and let a material put one coplanar surface over another with a depth layer; Scene shipped it in 0.24.0, flutter3d in 1.0.0-rc.1. Scene also has tools that look for it.
Scene.probeDepthConflictsnames each pair of nodes that trade pixels as the camera moves,Scene.findCoplanarOverlapslists faces that overlap in one plane, and a debug view shows the gap two surfaces need at each pixel. flutter3d's nearest thing is the level validator, which warns when two solid brushes of a level share volume, since their coincident faces are where z-fighting shows. It knows nothing about models or a running scene. - A light with a size, a shadow catcher, an ETC1S encoder, and the Apple embedded platforms. As of 0.24.3, Scene's point and spot lights take a
radius, so a glossy reflection widens to the emitter;ShadowCatcherMaterialshows only the shadows on a surface, for a model over a photo;buildTexturescooks ETC1S KTX2 with a pure-Dart encoder; and tvOS, visionOS and watchOS take the iOS Metal variant. flutter3d has none of the four on 2026-10-12: it reads ETC1S and UASTC but does not write them, its light radius is a shadow-softening setting rather than a size the specular sees, and it builds for no Apple platform but iOS and macOS. - External textures and billboards. Scene takes a platform texture (video, a camera preview) as a material input and draws sprites that face the camera. Both are in flutter3d's rc.3.
- A bigger community. On 2026-10-12 Scene had 914 stars, 25 contributors and 22,989 downloads in thirty days, against flutter3d's 32, 2 and 592.
- Two projects built on it, the Dashsurfers endless runner and the Dashmap live world map, plus 43 runnable feature examples in the example app.
- More than two and a half years in its own repository, and an earlier life inside the Flutter engine, against flutter3d's two months.
Most of what this list held in 0.8 is now on both sides of the table. Reversed depth and depth layers, SMAA, lens flares, radial distortion and .cube LUTs; hot reload of models, textures, environments and levels as well as shaders; a declarative widget API (Scene3D with Node3D, Mesh3D, Model3D and the rest, which mounts nodes of an ordinary scene); rotating bodies with joints. Global illumination and temporal anti-aliasing had already moved off in 0.8. In each case Scene had it first, and in some it still goes further: its SMAA tunes its search at runtime where flutter3d has the 1x mode only, and its hot reload patches a changed scene document into the live graph in place.
What flutter3d has that Scene doesn't #
- Physics that still runs with no native code at all. The C core is the default, and
flutter3d_physics, in plain Dart, is its reference and its fallback: when the core will not start, the run says why and goes on in Dart, and the games' suites pass under both. A recording says which one it ran on, and a replay refuses the other. Scene's pure-Dart backend answers queries and triggers but has no dynamics. Beyond rigid bodies, the physics also carries cloth, liquids in vessels and pipes, floating bodies, and heat and fire with wind; Scene's README names none of those. - A CPU software backend.
flutter3d_cpurasterises entirely in Dart, gives the renderer a second, independent implementation to check the GPU backends against, and runs the golden-image suite in CI with no GPU at all. Scene has no software backend of its own; its CI renders through Impeller on Mesa and SwiftShader software rasterisers, in headless Chrome, and on Codemagic's Apple hardware, and checks the frames in Argos. - WebGPU in the browser, by default. flutter3d tries WebGPU first and falls back to WebGL2, and on WebGPU it sorts splats on compute. Scene ships WebGL2 only on the web.
- Four games of different genres on one engine, with no genre-specific code shared between them. A shooter, a platformer, a racing game and a strategy map played to a finish, each built without editing the engine packages the others depend on, with the boundary held by structural scans in
tool/structure.dart. A voxel sandbox joined them in 1.0:flutter3d_voxeland a demo that digs, builds and saves. - Simulation tooling a game is built from. An animation graph with state machines, blend spaces, layers, markers and IK; navigation meshes rebaked where a wall breaks; behaviour trees written in the editor or by an agent over MCP; cutscenes played in the fixed step; saves with migrations; a time-travel debugger; and replay tests that hold a recorded run to its digests in
flutter test. Every one of these runs in the deterministic step, which is why a run replays to the bit. And levels generated from a seed and a set of rules, by wave function collapse over a kit's tiles and erosion of a heightfield, refused when no route reaches the exit. - Parties with rollback.
flame_multiplayerrolls back every player's input for two to thirty-two machines (the tests and the racing game run four), feeds spectators from the settled tape, and also has an authoritative server with predicting clients. Scene's networking is the authoritative kind, with rollback for the entity a client owns. - A bridge to Flame, the established Flutter 2D game engine.
flame_flutter3dcomposites a Flame layer and a flutter3d layer in one widget, each drawing itself, with transform, ECS (throughflutter3d_sim's own actor system), physics, input and camera reconciled between the two, so neither engine drives the other's renderer. Since 0.8.5 a plain Flame game can also hold one 3D model as aModel3dComponent, ordered by Flame's priority like a sprite. A demo, Meteor Yard, uses the bridge end to end and plays in a browser. Scene's README does not describe an equivalent. - Colour accessibility. A high-contrast look that flattens texture detail and rings what the game marks as important in its role colour, colour-vision simulation and correction, and a lint for cues told apart by hue alone. On screen readers flutter3d is partway:
SceneSemanticsinflutter3d_appgives named parts and announcements to an application that lists them (the modeller does),flutter3d_game_uispeaks a game's events, and the declarativeScene3D(semantics:), which announces a scene's widgets with nothing listed by hand, comes in rc.3. - Rendering features Scene does not list. Order-independent transparency, motion blur, volumetric fog, caustics under see-through casters, local exposure, and HDR output on the WebGPU backend; octahedral impostors and occlusion culling. Scene has god rays, which are a near relative of the volumetric fog, and it may have more than its README and CHANGELOG say.
I read these as different bets on where a young engine spends its first months. Scene put more than two and a half years into rendering depth, physics and audio on established engines, an editor people can download, and the platforms it runs on, with a maintainer who wrote Flutter GPU. flutter3d spent the months before its 1.0 catching up on the renderer and the API, and put the rest into the simulation: deterministic runs, tools for building games on top of them, and a software rendering backend in Dart, so rendering tests need no GPU and no graphics driver. Scene is pre-1.0 and flutter3d is at its second 1.0 release candidate; both are MIT, both sit on the same `flutter_gpu` foundation.
Picking one #
If a project needs physics that other people have already shipped, FMOD, an editor to download today, Windows and Linux through Impeller, or tools that find z-fighting for you, Scene already has it, and I would pick Scene. If a project's constraints run the other way (physics that has to work with no native code when it must, rendering tests that run with no GPU or graphics driver inside flutter test, WebGPU, replays and rollback that hold to the bit, or an interest in how the genre-package split holds up across four real games), flutter3d is built to show exactly that.