Build beyond
the flat screen.

Install Glint

Glint ships on pub.dev as glint_engine and tracks Flutter 3.44.1 with the opt-in flutter_gpu API.

flutter pub add glint_engine

Or add it to pubspec.yaml directly:

dependencies:
  glint_engine: ^0.1.0

Render your first scene

A Scene3D is a Flutter widget. Give it model nodes, lights, and a camera, then compose any ordinary Flutter UI over the result.

import 'package:flutter/material.dart';
import 'package:glint_engine/glint_engine.dart';

class Showroom extends StatelessWidget {
  const Showroom({super.key});

  @override
  Widget build(BuildContext context) {
    return Stack(children: [
      Scene3D(
        children: [
          Node3D(
            name: 'product',
            model: Model.asset('assets/product.glb'),
          ),
        ],
        lights: const [
          EnvironmentLight(asset: 'assets/studio.hdr'),
          DirectionalLight(),
        ],
        autoRotate: true,
      ),
      const ProductControls(),
    ]);
  }
}

Enable Flutter GPU once per app

Flutter GPU ships behind a flag. You can pass it on every run — or set it once in your platform manifests and never think about it again. Do the one-time setup: after this, plain flutter run, IDE run buttons, and release builds all work with no flags.

iOS — add one key inside the main <dict> (Impeller is already the default renderer on iOS):

<key>FLTEnableFlutterGPU</key>
<true/>

macOS — same key, plus Impeller, which is still opt-in on desktop:

<key>FLTEnableImpeller</key>
<true/>
<key>FLTEnableFlutterGPU</key>
<true/>

Android — add one meta-data entry inside the <application> tag:

<application ...>
  <meta-data
      android:name="io.flutter.embedding.android.EnableFlutterGPU"
      android:value="true" />
</application>

Skipping this? For a quick trial you can run with flags instead — but any device or teammate without them sees Glint's fallback widget, so the manifest route is the one to ship:

flutter run --enable-impeller --enable-flutter-gpu

Compose a world

Build scenes from Node3D objects with transforms, models, procedural meshes, material overrides, and child hierarchies. Glint resolves world transforms, bounds, culling, cameras, and lighting through one declarative scene graph.

final world = [
  Node3D(
    name: 'vehicle',
    model: Model.asset('assets/vehicle.glb'),
    transform: Transform3D(
      position: Vector3(0, 0, -4),
      scale: Vector3(1.2, 1.2, 1.2),
    ),
    children: [
      Node3D(name: 'marker', mesh: Mesh3D.cube(size: .2)),
    ],
  ),
];

Drive a real-time game

GlintGameView owns the ticker-driven render loop. Your simulation advances with delta time and returns a camera plus model instances for every frame. Flutter remains responsible for HUD, menus, navigation, and touch surfaces.

GlintGameView(
  models: {
    'player': Model.asset('assets/player.glb'),
    'coin': Model.asset('assets/coin.glb'),
  },
  onFrame: (dt) {
    simulation.step(dt);
    return GlintGameFrame(
      camera: GlintGameCamera(
        position: Vector3(0, 3.6, 8.4),
        target: Vector3(0, 1, -6),
      ),
      instances: simulation.instances,
    );
  },
)

Load 3D assets safely

Use Model.asset for packaged GLB files or Model.network for bounded, timeout-aware remote models. The loader handles meshes, normals, node hierarchies, embedded images, material factors, and typed failures instead of leaving a silent blank viewport.

final local = Model.asset('assets/level.glb');

final remote = Model.network(
  'https://cdn.example.com/world.glb',
);

Make the world respond

Glint includes ray construction, mesh intersection, tap picking, orbit, pan, zoom, Flutter-scroll gesture routing, node-to-screen projection, and anchored labels. Use the engine for spatial input while Flutter keeps accessible interface controls.

Platform support

Glint follows the flutter_gpu and Impeller path. The first release focuses on native mobile and macOS.

The direction

The goal is a complete, Flutter-native 3D engine. The current core covers rendering, scene graphs, per-material batches, PBR with HDRI lighting and fog, glTF node-animation playback, assets, cameras, picking, labels, diagnostics, instancing, and real-time frame loops.

Skeletal skinning, shadows, physics, particles, audio, richer lights, editor tooling, and broader platforms come after the foundation is stable and real projects prove the right priorities.