# google/filament: a real-time PBR engine for Android, iOS and the web

> Filament is Google's C++ physically based renderer with Java, JavaScript and native APIs. It is built for teams shipping 3D on mobile and the web, and the release archives include the host tools you need to compile materials before the runtime can use them.

**google/filament** — Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS, and WebGL2

- Repository: https://github.com/google/filament
- Website: https://google.github.io/filament/
- Stars: 20,548 · Forks: 2,270
- Language: C++
- License: Apache-2.0
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/google-filament

## What Filament is for, and who actually needs it

Filament is a real-time physically based rendering engine. The README lists Android, iOS, Linux, macOS, Windows and WASM as targets, and the project describes itself as designed to be as small as possible and as efficient as possible on Android. That last clause is the real positioning. This is not a general-purpose engine aimed at desktop workstations first; the mobile footprint is a stated design constraint.

The audience follows from that. If you are writing an Android app that has to display a glTF model with credible lighting, you can add Filament as a Maven dependency and get a renderer without writing shader code. If you are building a product configurator, an AR viewer, or a viewer for scanned or authored 3D content, the same engine is available on iOS through CocoaPods and in browsers through WebGL 2.0. The JavaScript API means the web target is a first-class citizen rather than a port.

What Filament is not is a scene editor or an asset pipeline. The repository ships samples (hellotriangle, hellopbr, gltf_viewer, material_sandbox and others) and host-side tools, but the README points at the documentation for the rendering theory and the material system rather than at an authoring application. You bring the content and the application logic.

## The material compiler is the part that shapes your build

The mechanism worth understanding before you adopt Filament is that materials are compiled ahead of time, not assembled at runtime by default. The README states that release archives contain host-side tools required to generate assets, and that you must always use tools from the same release as the runtime library, calling this out specifically for matc, the material compiler. The Materials documentation covers the material models and how to use matc.

That constraint has teeth. A material compiled by one release of matc is not something you should feed to a different release of the runtime, so your asset build step and your runtime dependency have to move together. Teams that pin a Maven artifact but rebuild assets on a floating toolchain will eventually hit a mismatch. The safe pattern is to treat the release archive as part of your build inputs.

There is an escape hatch. The artifact list includes filamat-android, described as a runtime material builder and compiler. The README notes it is large but contains a full shader compiler, validator and optimizer supporting both OpenGL and Vulkan. So you can compile materials on device if you accept the size cost. That is a real trade-off, not a footnote: the reason to use matc offline is to keep the shipped binary small, and filamat-android gives that back in exchange for the compiler living in your APK.

## Backends, features and what the renderer actually implements

Filament's backend list is broad: OpenGL 4.1+ on Linux, macOS and Windows; OpenGL ES 3.0+ on Android and iOS; Metal on macOS and iOS; Vulkan 1.0 on Android, Linux, macOS and Windows; WebGPU on Android, Linux, macOS and Windows; and WebGL 2.0 in browsers that support it. A single codebase reaching that many APIs is the main reason to pick this over a vendor-specific renderer.

The rendering feature list is long and specific. Clustered forward rendering, a Cook-Torrance microfacet specular BRDF with a Lambertian diffuse term, image-based lighting, a metallic workflow, clear coat, anisotropic lighting, cloth and sheen shading, and approximated translucent materials. Shadows include cascaded shadows and a choice of EVSM, PCSS, DPCF or PCF filtering, plus contact shadows and transparent shadows. Post-processing covers HDR bloom, depth of field bokeh, several tone mappers (GT7, PBR Neutral, AgX, ACES, filmic and a generic customizable one), color grading, TAA, FXAA, MSAA and screen-space lens flares. Screen-space ambient occlusion, reflections and refraction are all listed.

Two entries deserve attention because they are easy to miss. Dynamic resolution with support for AMD FidelityFX FSR is present, which matters if you are chasing frame time on mid-range phones. And the glTF 2.0 support table is explicit about what is not done: Line Loop and Triangle Fan primitive types are unchecked, while points, lines, line strip, triangles and triangle strip are supported. If your content uses those two primitive modes, that is a gap in the loader, not a rendering limitation.

## Installing Filament on Android and getting a first frame

The README gives the Android path directly: declare the Maven Central repository and add the filament-android artifact at the release version. The group is com.google.android.filament, and the current release is 1.77.0.

```gradle
repositories {
    // ...
    mavenCentral()
}

dependencies {
    implementation 'com.google.android.filament:filament-android:1.77.0'
}
```

If you need to load glTF content rather than build geometry by hand, add gltfio-android, which the README describes as a glTF 2.0 loader for Filament that depends on filament-android. The filament-utils-android artifact adds KTX loading, Kotlin math and camera utilities, and depends on gltfio-android. Pulling all three is the common shape for a viewer app.

```gradle
dependencies {
    implementation 'com.google.android.filament:filament-android:1.77.0'
    implementation 'com.google.android.filament:gltfio-android:1.77.0'
    implementation 'com.google.android.filament:filament-utils-android:1.77.0'
}
```

The iOS equivalent is CocoaPods. The README shows a single pod line pinned to the same version, which keeps the runtime and the tooling in step:

```shell
pod 'Filament', '~> 1.77.0'
```

For anything else, the README points at the release archives for stable builds and at BUILDING.md if you would rather compile Filament yourself. The samples directory is the practical starting point: hellotriangle, hellopbr, helloskinning and gltf_viewer are all listed in the repository, and they are the closest thing to a worked first example. The README does not walk through running a sample end to end, so expect to read the sample sources and the build manual together.

## Where Filament is the wrong choice

The compiled-material model is the first place teams get stuck. If your product lets users author or modify materials at runtime, you are either shipping filamat-android and paying for a shader compiler in your binary, or you are running a server-side compile step and accepting its latency. Neither is free. A renderer that builds shaders at runtime from source strings avoids that, at the cost of startup time and validation.

The second limitation is scope. Filament is a renderer, and the README's documentation list is about PBR theory and the material system, not about scene graphs, physics, animation state machines or editor tooling. If you expected an engine in the Unity or Godot sense, this is not that, and the samples will not fill the gap.

Third, the glTF loader has documented holes. Line Loop and Triangle Fan primitives are unchecked in the README's support table. Sparse accessors are checked for morph animation, and Draco mesh compression, KHR_lights_punctual and KHR_materials_clearcoat are supported, but the table is a checklist and the unchecked boxes are the ones to test against your own assets.

Finally, platform reach is not the same as platform parity. WebGL 2.0 is listed for browsers that support it, and WebGPU for Android, Linux, macOS and Windows. Which features survive on the weakest backend is something the README does not enumerate, so a feature that works on Vulkan may need verification on OpenGL ES 3.0 hardware.

## How Filament differs from three.js and Babylon.js

The obvious web-side alternatives are three.js and Babylon.js. The difference is architectural rather than cosmetic. Those are JavaScript libraries that build their rendering around the browser's WebGL or WebGPU context and let you construct materials at runtime from shader chunks. Filament is a C++ engine with a Java/JNI binding on Android, a native API on desktop and mobile, and a JavaScript API for the web. The same renderer core runs on all of them.

That matters when one product ships an Android app, an iOS app and a browser build. With a JavaScript-only library you either accept a different renderer on native, or you embed a web view. With Filament you compile materials once with matc and the same compiled artifacts feed the native and web runtimes. The cost is that you take on a native build or a set of platform dependencies, and your web bundle is a WASM build rather than plain JavaScript.

Against a vendor engine such as Unity, the difference is the opposite direction. Unity gives you an editor, an asset pipeline and a much larger runtime. Filament gives you a renderer and host tools. If your team already has an app and wants 3D inside it, Filament fits. If your team wants to build the whole experience inside an editor, it does not.

## Release cadence, licence and the upgrade work you are signing up for

The repository is not archived, and the last push was on 2026-09-20. Recent releases are v1.77.0 on 2026-09-15, v1.76.1 on 2026-09-09 and v1.76.0 on 2026-08-28. That is a fast cadence, and the README's warning about matching tool and runtime versions turns that cadence into real work: every upgrade is a runtime bump plus a material recompile. RELEASE_NOTES.md and NEW_RELEASE_NOTES.md exist at the top level, so the changelog is in the repository rather than only in release pages.

The licence is Apache-2.0, which is a permissive licence with an explicit patent grant. That is a normal choice for a project intended to be embedded in commercial applications. It is not legal advice, and the usual caveats apply: third_party/ exists in the repository, so dependencies carry their own terms, and you should have counsel review the notices you ship. The practical point for an engineering decision is that Apache-2.0 does not force you to open your application code.

Upgrade cost is dominated by the material pipeline, not by API churn. Budget for a CI step that downloads the release archive for the version you are moving to, runs matc over your material sources, and fails the build if the runtime dependency and the tool version drift apart. That single check is what the README's warning is really asking for.

## Conclusion

Adopt Filament if you need one renderer covering Android, iOS, desktop and WebGL2 with a compiled material pipeline you control. Do not adopt it if you want a scene editor, a Unity-style authoring workflow, or a renderer you can drive without learning its material system. Before committing, download the release archive matching your chosen runtime version, run matc from that same archive on one real material, and confirm your target devices expose the backend you plan to ship (OpenGL ES 3.0+ on Android and iOS, or Vulkan 1.0).

## FAQ

### What is google/filament?

It is a real-time physically based rendering engine for Android, iOS, Linux, macOS, Windows and WASM, written in C++ and licensed under Apache-2.0. It exposes a native C++ API, a Java/JNI API for Android and a JavaScript API.

### How do I install Filament in an Android project?

Declare mavenCentral() in your repositories and add the artifact com.google.android.filament:filament-android at the release version, for example 1.77.0. Add gltfio-android if you need to load glTF content, and filament-utils-android for KTX loading and camera utilities.

### Why must matc come from the same release as the runtime library?

The README states that you should always use tools from the same release as the runtime library, and calls this out particularly for matc, the material compiler. Release archives contain the host-side tools required to generate assets, so the compiler and the runtime are meant to move together.

### Which graphics backends does Filament support?

OpenGL 4.1+ on Linux, macOS and Windows; OpenGL ES 3.0+ on Android and iOS; Metal on macOS and iOS; Vulkan 1.0 on Android, Linux, macOS and Windows; WebGPU on Android, Linux, macOS and Windows; and WebGL 2.0 in supporting browsers.

### Can I compile materials at runtime instead of using matc?

Yes, through the filamat-android artifact, which the README describes as a runtime material builder and compiler containing a full shader compiler, validator and optimizer for OpenGL and Vulkan. It notes that this library is large.

## Sources

- [google/filament on GitHub](https://github.com/google/filament)
- [License: Apache-2.0](https://github.com/google/filament/blob/main/LICENSE)
- [Project website](https://google.github.io/filament/)
- [README](https://github.com/google/filament/blob/main/README.md)
- [Releases](https://github.com/google/filament/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/google-filament