sceneview-android
The AI-first 3D & AR SDK for Jetpack Compose — and the web.
Declarative 3D and AR for app developers who want a model on screen, or in the room, without a game engine: Filament + ARCore on Android, Filament.js + WebXR in the browser, and a Compose Multiplatform viewer. It is the maintained successor to Google Sceneform. Open source, Apache 2.0.
| Building with | Add | Then write |
|---|---|---|
| Jetpack Compose — 3D | io.github.sceneview:sceneview:4.70.0 |
SceneView { } |
| Jetpack Compose — AR | io.github.sceneview:arsceneview:4.70.0 |
ARSceneView { } or PlacementScene |
| Android Views / XML | the same | SceneView { } inside a ComposeView |
| Kotlin / Compose Multiplatform (Android, desktop) | io.github.sceneview:sceneview-compose:4.70.0 |
SceneViewer(model = …) in commonMain |
| Web | npm install sceneview-web |
SceneView.modelViewer("canvas", "model.glb") |
Moving from Sceneform, or from SceneView 2.x code (Scene(childNodes = …), ARScene)?
The mapping. Which artifact fits your app:
3D and AR library, per platform.
Used in production. More than 1,300 stars on GitHub, and over 500 public repositories declare SceneView as a dependency. It ships on Google Play in the Volkswagen, Audi, Porsche and CUPRA apps, Philips Hue, Medal and IKEA, is declared by the open-source apps Bitkey (Block) and Vocable (WillowTree), and is a dependency of the GeneXus Augmented Reality module and the TruVideo camera SDK. The Niantic Spatial SDK samples use it for AR. Lenskart ships Sceneform Maintained, SceneView's predecessor, and Safie presented SceneView in a public talk.
AI-first means one thing here: an assistant that reads llms.txt or
the MCP server writes SceneView code that works on the first try. When it doesn't, the
API or the doc gets fixed.
Using SceneView? You can support it on Open Collective or through GitHub Sponsors.
Try it
The iOS and macOS demo has no new builds after 4.69.7 — see DEPRECATION.md.
The demo apps are built from samples/. Any demo opens straight from a link:
https://sceneview.github.io/open?demo=<id>. Start with
Cosmos, the galaxy the catalogue opens on, or
3D Scan, a space scanned with ARCore and rebuilt in 3D.
A living room scanned in 3D Scan on a Pixel 9, then rebuilt as a model (sped up).
Help test the demos
Install the Android demo, record your screen while you use a demo, and tell us what breaks or confuses you: open an issue with the recording attached, or send it from the app (any demo, Settings, then Send feedback).
Quick start
One minimal, working example per platform. The full reference for each is in
llms.txt.
Android
// build.gradle.kts
implementation("io.github.sceneview:sceneview:4.70.0")
The app module needs compileSdk = 37, minSdk 24 or higher, AGP 9.4.0+, Kotlin 2.3 or newer and JVM
target 21 for both Java and Kotlin: SceneView ships Java 21 bytecode with public inline
functions. The quickstart requirements give the Gradle
snippet and the reason for each.
Stuck on AGP 8 / compileSdk 36 / Kotlin 2.2? Use 4.18.0, the newest release that builds there.
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import io.github.sceneview.SceneView
import io.github.sceneview.rememberModelInstance
@Composable
fun ModelScreen() {
SceneView(modifier = Modifier.fillMaxSize()) { // orbit camera + default lighting
rememberModelInstance(modelLoader, "models/toy_car.glb")?.let { instance ->
ModelNode(modelInstance = instance, scaleToUnits = 1.0f, autoAnimate = true)
}
}
}
Download the Khronos glTF Sample Assets Toy Car (CC0):
ToyCar.glb.
Save it as app/src/main/assets/models/toy_car.glb, as in the
quickstart.
rememberModelInstance returns null until the model is loaded, then recomposes.
Never call modelLoader.createModel* from a background
coroutine: Filament calls must run on the main thread, and rememberModelInstance handles that.
Loading state and errors
rememberModelInstance returns null while loading or after a failure; use
rememberModelLoadState to tell them apart. Keep the scene visible and overlay its status.
Incrementing retry changes the composition key and starts a fresh load of the same path;
recomposition alone does not retry.
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import io.github.sceneview.ModelLoadState
import io.github.sceneview.SceneView
import io.github.sceneview.rememberEngine
import io.github.sceneview.rememberModelLoader
import io.github.sceneview.rememberModelLoadState
@Composable
fun ModelScreenWithLoading() {
val engine = rememberEngine()
val modelLoader = rememberModelLoader(engine)
var retry by remember { mutableIntStateOf(0) }
val state = key(retry) { rememberModelLoadState(modelLoader, "models/toy_car.glb") }
Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
SceneView(modifier = Modifier.fillMaxSize(), engine = engine, modelLoader = modelLoader) {
if (state is ModelLoadState.Ready) {
ModelNode(modelInstance = state.instance, scaleToUnits = 1f, autoAnimate = true)
}
}
when (state) {
is ModelLoadState.Loading -> CircularProgressIndicator()
is ModelLoadState.Failed -> Button(onClick = { retry++ }) { Text("Load failed. Retry") }
is ModelLoadState.Ready -> Unit
}
}
}
AR (Android)
// build.gradle.kts
implementation("io.github.sceneview:arsceneview:4.70.0") // includes the 3D module
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import com.google.ar.core.Anchor
import com.google.ar.core.Plane
import io.github.sceneview.ar.ARSceneView
import io.github.sceneview.ar.arcore.createAnchorOrNull
import io.github.sceneview.ar.arcore.getUpdatedPlanes
import io.github.sceneview.rememberModelInstance
@Composable
fun ARScreen() {
var anchor by remember { mutableStateOf<Anchor?>(null) }
ARSceneView(
modifier = Modifier.fillMaxSize(),
planeRenderer = true,
onSessionUpdated = { _, frame ->
if (anchor == null) {
anchor = frame.getUpdatedPlanes()
.firstOrNull { it.type == Plane.Type.HORIZONTAL_UPWARD_FACING }
?.let { it.createAnchorOrNull(it.centerPose) }
}
}
) {
val toyCar = rememberModelInstance(modelLoader, "models/toy_car.glb")
anchor?.let { a ->
AnchorNode(anchor = a) {
toyCar?.let { ModelNode(modelInstance = it, scaleToUnits = 0.5f) }
}
}
}
}
Plane detected → anchor set → Compose recomposes → the model appears. AR state is just Kotlin
state. For placement without a tap, grounded and gesture-ready, start from
AutoPlacementScene (see llms.txt).
arsceneview already declares the CAMERA permission and marks ARCore as optional. An AR
Optional app declares android.hardware.camera.ar and android.hardware.camera as
<uses-feature … android:required="false" />; an AR Required app overrides the ARCore value
with tools:replace="android:value". Both snippets are in the
AR manifest section.
Web
<canvas id="viewer" style="width: 100%; height: 480px"></canvas>
<script src="https://cdn.jsdelivr.net/gh/sceneview/sceneview@v4.70.0/website-static/js/filament/filament.js"></script>
<script src="https://cdn.jsdelivr.net/gh/sceneview/sceneview@v4.70.0/website-static/js/sceneview.js"></script>
<script> SceneView.modelViewer("viewer", "model.glb") </script>
Compose Multiplatform (Android · desktop)
// commonMain dependencies
implementation("io.github.sceneview:sceneview-compose:4.70.0")
SceneViewer(model = ModelSource.Asset("models/toy_car.glb"), modifier = Modifier.fillMaxSize())
A viewer by design — load, orbit, light, tap; no AR. Android and desktop are maintained.
The retained iOS host requires end-of-life SceneViewSwift 4.68.0. Scope and historical iOS setup:
sceneview-compose/.
iOS, Flutter and React Native
SceneView for SwiftUI (SceneViewSwift), Flutter (flutter_sceneview) and React Native
(@sceneview-sdk/react-native) is end of life: 4.68.0 (November 2026) is the last release. No new releases. Published versions stay
installable and the source stays in this repository — what that means and the timeline.
Your AI assistant
claude mcp add sceneview -- npx -y sceneview-mcp # Claude Code
codex mcp add sceneview -- npx -y sceneview-mcp # Codex
Then ask: "Add a 3D model viewer to my Compose screen." Every other client is in Use with AI.
Runs on
Each row is a published package plus an app or page you can open today, backed by a real capture of it.
| Platform | Status | Install | Open it | Capture |
|---|---|---|---|---|
| Android | Shipped · Stable | Maven Central | Google Play | ![]() |
| iOS | End of life — package 4.68.0, demo app 4.69.7 | Swift Package | App Store | ![]() |
| Web | Shipped · Alpha | npm sceneview-web |
Live web demo | ![]() |
Shipped means released and publicly reachable; the second word is the API maturity. The other platforms in the table below join this section once a capture backs them.
Platforms
| Platform | Renderer | Framework | Status |
|---|---|---|---|
| Android | Filament | Jetpack Compose | Stable |
| Android TV | Filament | Compose TV | Alpha |
| iOS / macOS / visionOS | RealityKit | SwiftUI | End of life — 4.68.0 is the last release |
| Web | Filament.js (WebGL2 / WASM) | JavaScript + Kotlin/JS | Alpha |
| Compose Multiplatform | Filament (Android, desktop); retained iOS host uses end-of-life SceneViewSwift | sceneview-compose |
Alpha — viewer subset |
| Desktop (JVM) | Filament, via filament-kmp | Compose Desktop (sceneview-compose) |
Alpha |
| Flutter | Native per platform | PlatformView | End of life — 4.68.0 is the last release |
| React Native | Native per platform | Fabric | End of life — 4.68.0 is the last release |
| AI assistants | — | llms.txt, MCP server, skills |
Stable |
Install
| Platform | Coordinate |
|---|---|
| Android 3D | io.github.sceneview:sceneview:4.70.0 |
| Android AR | io.github.sceneview:arsceneview:4.70.0 |
| Compose Multiplatform | io.github.sceneview:sceneview-compose:4.70.0 |
| KMP core only (math, collision, physics) | io.github.sceneview:sceneview-core:4.70.0 |
| Apple (SPM) — deprecated | https://github.com/sceneview/sceneview.git, exact: "4.68.0" |
| Web, script tag | the two <script> tags in Web |
| Web, bundler (Kotlin/JS) | npm install sceneview-web — see SceneView Web |
| Flutter — deprecated | flutter_sceneview on pub.dev |
| React Native — deprecated | @sceneview-sdk/react-native on npm |
| AI assistants | npx -y sceneview-mcp — see Use with AI |
Use with AI
Everything an assistant needs to write SceneView code ships with the SDK:
llms.txt— the complete API reference in one file: composables, every node type, threading rules, recipes. Its Kotlin snippets are compiled in CI. Served athttps://sceneview.github.io/llms.txtfor tools without MCP support.- Rules files —
AGENTS.md(Codex, Cursor, GitHub Copilot, Gemini in Android Studio and others),CLAUDE.md(Claude Code),.github/copilot-instructions.md, and.cursorrulesfor older Cursor versions. - The MCP server — free, no API key. The tools assistants reach for most:
validate_code(checks a snippet for known pitfalls and unknown symbols before you run it; it does not check argument names),get_node_reference(the exact node signature, not an invented one),list_samples/get_sample(38 samples to start from), andget_setup/get_ar_setup(project wiring).
MCP setup
claude mcp add sceneview -- npx -y sceneview-mcp # Claude Code
codex mcp add sceneview -- npx -y sceneview-mcp # Codex
copilot mcp add sceneview -- npx -y sceneview-mcp # GitHub Copilot CLI
// Cursor (.cursor/mcp.json), Cline, JetBrains AI Assistant
{ "mcpServers": { "sceneview": { "command": "npx", "args": ["-y", "sceneview-mcp"] } } }
// VS Code (.vscode/mcp.json) uses the "servers" key instead
{ "servers": { "sceneview": { "type": "stdio", "command": "npx", "args": ["-y", "sceneview-mcp"] } } }
Clients that only speak HTTP (Gemini in Android Studio, ChatGPT) use the hosted endpoint
https://mcp.sceneview.dev/mcp, or run their own with npx sceneview-mcp --http. Per-client
snippets: sceneview.github.io/#ai-setup. Listed on the
MCP Registry.
ChatGPT / Codex plugin
This repository is also an OpenAI plugin: .codex-plugin/plugin.json points at the three
skills under agents/ (sceneview, sceneview-ios, sceneview-web). From a
checkout:
codex plugin marketplace add "$PWD" # absolute path — a relative one does not resolve
codex plugin add sceneview@sceneview-local
Codex also discovers the skills from .agents/skills/ on its own. Over HTTP the MCP server
carries an inline view_3d_model widget that renders a public GLB/glTF URL in the
conversation. Listing copy and test prompts: agents/OPENAI-PLUGIN.md.
Claude Code plugin
/plugin marketplace add sceneview/claude-marketplace, then /plugin install sceneview@sceneview,
installs the same three skills as the Codex plugin together with the MCP server. The commands used
to work on this repository are a separate plugin, sceneview-contrib@sceneview — see
sceneview/claude-marketplace.
Vertical MCP servers (Rerun AR debugging and others) are listed in the MCP README.
Android in depth
3D scene
SceneView is a composable that renders a Filament viewport. Nodes are composables inside it.
val engine = rememberEngine()
val modelLoader = rememberModelLoader(engine)
val environmentLoader = rememberEnvironmentLoader(engine)
SceneView(
modifier = Modifier.fillMaxSize(),
engine = engine,
modelLoader = modelLoader,
environment = rememberEnvironment(environmentLoader) {
environmentLoader.createHDREnvironment("envs/studio.hdr")
?: createEnvironment(environmentLoader)
},
cameraManipulator = rememberCameraManipulator()
) {
// Model — async loaded, appears when ready
rememberModelInstance(modelLoader, "models/toy_car.glb")?.let {
ModelNode(modelInstance = it, scaleToUnits = 1.0f, autoAnimate = true)
}
// Geometry — procedural shapes
CubeNode(size = Size(0.2f))
SphereNode(radius = 0.1f, position = Position(x = 0.5f))
// Nesting — same as Column { Row { } }
Node(position = Position(y = 1.0f)) {
LightNode(type = LightManager.Type.POINT, apply = { intensity(50_000f) })
CubeNode(size = Size(0.05f))
}
}
Node composables — 27 in 3D, 15 more in AR
| Category | Nodes | What they do |
|---|---|---|
| Models | ModelNode |
glTF/GLB with skeletal/morph animations. isEditable = true for gestures. |
| Primitives | CubeNode · SphereNode · CylinderNode · ConeNode · TorusNode · CapsuleNode · TubeNode · PlaneNode |
Procedural geometry, parametric size/segments |
| Curves & shapes | LineNode · PathNode · ShapeNode |
Single segments, polylines, extruded 2D polygons |
| Custom geometry | MeshNode |
Your own Filament VertexBuffer / IndexBuffer |
| Surfaces | ImageNode · VideoNode · BillboardNode |
PNG/JPG plane, video plane (MediaPlayer), camera-facing sprite |
| 3D text | TextNode |
World-space text label that always faces the camera |
| Compose-in-3D | ViewNode |
Any Compose UI rendered as a 3D surface, fully touch-interactive |
| Gaussian splats | SplatNode |
Render a Gaussian-splat capture |
| Lighting & sky | LightNode · ReflectionProbeNode · DynamicSkyNode · FogNode |
Sun/dir/point/spot lights, local IBL, time-of-day sky, atmospheric fog |
| Physics | PhysicsNode |
Simple rigid-body simulation (gravity, collisions) |
| Cameras | CameraNode · SecondaryCamera |
Main and picture-in-picture cameras |
| Group | Node |
Empty pivot for nesting and transform inheritance |
AR scene
ARSceneView is SceneView with ARCore: the camera follows real-world tracking. See the
AR quick start above.
| Node | What it does |
|---|---|
AnchorNode |
Pin a node to a real-world ARCore Anchor |
HitResultNode · DepthHitResultNode |
Live surface cursor from each frame's hit-test (planes or depth) |
PoseNode |
Position a node at any ARCore Pose |
PlaneNode · ReticleNode |
Render a detected plane, or a placement reticle |
PointCloudNode · DepthMeshNode · SceneMeshNode |
Feature points, depth mesh, classified geospatial scene mesh |
AugmentedImageNode |
Image tracking — pose + 2D extent of a detected image |
AugmentedFaceNode |
Face mesh overlay (front camera) |
CloudAnchorNode |
Persistent cross-device anchor (host + resolve) |
StreetscapeGeometryNode |
Geospatial — semantic city mesh (buildings, terrain) |
TerrainAnchorNode |
Geospatial — anchor pinned to ground at a lat/lng |
RooftopAnchorNode |
Geospatial — anchor pinned to a building rooftop |
| Feature | API surface |
|---|---|
| Automatic placement | AutoPlacementScene + AutoPlacementModel — grounded, gesture-ready, no tap |
| Plane / depth / instant placement | ARSceneView(planeRenderer = …, depthMode = …, instantPlacementMode = …) |
| Geospatial (VPS) | Streetscape + Terrain + Rooftop anchors via Earth session |
| Cloud Anchors | CloudAnchorNode.host(ttlDays = N) + .resolve(id) |
| Augmented Faces & Images | AugmentedFaceNode, AugmentedImageDatabase, runtime image add |
| Image Stabilization (EIS) | ARSceneView(imageStabilizationMode = ImageStabilizationMode.EIS) |
| Camera exposure & focus | ARSceneView(sessionCameraConfig = …, focusMode = …, cameraExposure = …) |
| Record & Replay | rememberARRecorder() to capture, ARSceneView(playbackDataset = file) to replay 1:1 — see AR debugging |
| Rerun.io live debug | rememberRerunBridge() streams poses, planes and point clouds to the Rerun viewer |
| Permission flow | ARPermissionHandler — auto-detected from ComponentActivity |
Capabilities
| Capability | What it gives you | Where it lives |
|---|---|---|
| Gestures | Drag, pinch-to-scale, two-finger rotate, elevate, tap. Per-node opt-in via isEditable. |
NodeGestureDelegate, OnGestureListener |
| Animations | Skeletal/morph from glTF, plus per-node spring/property/smooth-transform. | ModelNode.playAnimation(), NodeAnimationDelegate |
| Physics | Rigid-body dynamics — gravity, collisions, impulses. Pure Kotlin Multiplatform, no JNI. | PhysicsNode, sceneview-core |
| Collision & raycasting | Ray vs box / sphere intersections, hit-testing, frustum culling. | CollisionSystem, Ray, Box, Sphere |
| Procedural geometry | Cube/sphere/cylinder/cone/torus/capsule generators, extrusion from 2D shapes (Earcut + Delaunator). | sceneview-core geometry + triangulation |
| HDR environment | IBL lighting + skybox from .hdr / .ktx. Async load + reactive swap. |
EnvironmentLoader, rememberEnvironment |
| Custom materials | Filament .filamat materials with parameters, plus built-in unlit / lit / overlay variants. |
MaterialLoader |
| Post-processing | Bloom, depth of field, SSAO, vignette, color grading, tone mapping. | View.bloomOptions, dynamicResolutionOptions, … |
| Compose UI in 3D | Any @Composable as a textured plane in world space. Touches are forwarded, so Button.onClick, ripples and inner scrolling work. |
ViewNode + ViewNode.WindowManager |
| Multiple cameras | Picture-in-picture, mini-map, security-camera views. | SecondaryCamera |
| Reactive scene graph | Change state → the tree updates. No imperative parent.addChild(). |
SceneScope / ARSceneScope DSL |
Model formats
| Format | Android | Apple | Web |
|---|---|---|---|
| glTF / GLB | ✅ | — convert to USDZ (tools/convert-usdz.sh) |
✅ |
| USDZ / Reality / USD | — | ✅ RealityKit | — |
| STL (binary + ASCII) | ✅ converted to GLB in memory | ✅ ModelIO, millimetres by default | — |
| OBJ + MTL | ✅ converted to GLB, material colours | ✅ ModelIO | — |
| PLY (binary + ASCII) | ✅ converted to GLB, vertex colours | ✅ ModelIO, vertex colours | — |
| 3MF | ✅ converted to GLB, declared units honoured | ✅ SceneViewSwift parser, declared units honoured | — |
There is no per-format API on Android: rememberModelInstance(modelLoader, path) accepts all of
them. On Apple, RealityKit reads no glTF, so .gltf / .glb are deliberately not in
ModelFormat; USD/Reality load through RealityKit and the mesh formats through MeshAsset. The format is decided by the file's bytes, not its extension, so a file shared into your
app as application/octet-stream with no name still opens. The converters are dependency-free
Kotlin in sceneview-core. Tracked next:
one ModelFormat entry point and
every format on the web. Details:
Model formats.
Apple (iOS / macOS / visionOS) — end of life at 4.68.0
End of life: SceneView for SwiftUI (SceneViewSwift), Flutter (flutter_sceneview) and React Native (@sceneview-sdk/react-native). 4.68.0 (November 2026) is the last release. No new releases. Published versions stay installable. See DEPRECATION.md.
Native Swift Package built on RealityKit, with a node set mirroring the Android API. Content you
can build synchronously uses the @NodeBuilder form:
SceneView {
GeometryNode.cube(size: 0.1, color: .blue)
.position(.init(x: 0.5, y: 0, z: 0))
LightNode.directional(intensity: 1000)
}
.environment(.studio)
.cameraControls(.orbit)
AR on iOS — tap a detected plane to place content:
ARSceneView(
planeDetection: .horizontal,
onTapOnPlane: { position, arView in
let anchor = AnchorNode.world(position: position)
anchor.add(GeometryNode.cube(size: 0.1, color: .blue).entity)
arView.scene.addAnchor(anchor.entity)
}
)
Nodes — ModelNode · GeometryNode (cube/sphere/cylinder/cone/torus/capsule/plane) ·
LightNode · ImageNode · VideoNode · TextNode · ViewNode · BillboardNode · MeshNode ·
LineNode · PathNode · ShapeNode · PhysicsNode · ReflectionProbeNode · DynamicSkyNode ·
FogNode · CameraNode · AnchorNode · AugmentedImageNode · SceneReconstructionNode
(visionOS scene mesh). Plus an iOS RerunBridge with the same wire format as Android.
Full guide: SceneViewSwift/README.md.
SceneView Web
Two <script> tags and one call (see Web above). The wrapper is 24 KB gzipped; the
engine it drives is Filament — the same renderer as Android SceneView — compiled to WebAssembly
(2.3 MB gzipped).
JavaScript API (script tag):
SceneView.modelViewer(canvasOrId, url, options?)— all-in-one viewer with orbit + auto-rotateSceneView.create(canvasOrId, options?)— empty viewer, load a model laterviewer.loadModel(url)— load or replace a glTF/GLB modelviewer.setAutoRotate(enabled)— toggle rotationviewer.dispose()— release resources
Kotlin/JS (sceneview-web, npm only) — the power-user API: OrbitCameraController, the
geometry DSL, reactive node updates, and WebXR through ARSceneView (immersive-ar,
hit-test, anchors, light estimation), VRSceneView (immersive-vr, controllers) and the
low-level WebXRSession. The module builds a webpack bundle, so it has no Maven coordinate:
npm install sceneview-web
The package expects a Filament global and does not include the SceneView.modelViewer script
helpers. A Kotlin Multiplatform project that only needs the shared core (collision, math,
geometry, animation, physics — no renderer) uses
implementation("io.github.sceneview:sceneview-core-js:4.70.0").
Landing page · Web demo · npm
The Compose-native successor to Sceneform
Google archived Sceneform in 2021 and ships
no first-party declarative AR renderer. SceneView descends from the maintained Sceneform
community fork: ARCore for perception, Filament for rendering, Jetpack Compose for the API, and
glTF (.glb / .gltf) instead of the deprecated .sfb format.
Coming from Sceneform? The migration guide maps it
concept by concept (ArFragment → ARSceneView { }, ModelRenderable →
rememberModelInstance, and so on).
AR debugging
- Record & Replay — capture an ARCore session once with
rememberARRecorder(), replay it 1:1 at your desk withARSceneView(playbackDataset = file). Seedocs/docs/ar-recording.mdand the Record & Playback demo. - Hosted Rerun viewer — export a scan's Rerun recording from the 3D Scan demo, host the
.rrdfile at an https address that ends in.rrd, and openhttps://sceneview.github.io/rerun/?url=<encoded-url>to scrub the session frame by frame in a browser, with no local install. The host has to allow cross-origin requests (CORS): a public GitHub repository'sraw.githubusercontent.comlink and GitHub Pages do, a GitHub release asset does not (checked 2026-10-13); an R2 or S3 bucket does with a CORS rule that allowshttps://sceneview.github.io. Architecture and the Kotlin API (RerunBridge.requestSaveAndShare) are in the AR Debug — Rerun.io section ofllms.txt.
Architecture
Each platform uses its native renderer. Shared logic lives in Kotlin Multiplatform.
sceneview-core (Kotlin Multiplatform)
├── math, collision, geometry, physics, animation, model-format converters
│
├── sceneview (Android) → Filament + Jetpack Compose
├── arsceneview (Android) → ARCore
├── sceneview-compose (KMP) → one SceneViewer for Android, iOS and desktop
├── SceneViewSwift (Apple) → RealityKit + SwiftUI
├── sceneview-web (Web) → Filament.js + WebXR
└── flutter/ · react-native/ → bridges to the native views
Samples
| Sample | Platform | Run |
|---|---|---|
samples/android-demo |
Android — 3D & AR | ./gradlew :samples:android-demo:assembleDebug |
samples/android-tv-demo |
Android TV | ./gradlew :samples:android-tv-demo:assembleDebug |
samples/ios-demo |
iOS — 3D & AR | Open in Xcode |
samples/web-demo |
Web | cd samples/web-demo && cp ../../website-static/js/sceneview.js site/js/sceneview.js && npx http-server site -p 8080 |
samples/desktop-demo |
Desktop (JDK 21+) | ./gradlew :samples:desktop-demo:run |
samples/flutter-demo |
Flutter | cd samples/flutter-demo && flutter run |
samples/react-native-demo |
React Native | See its README |
Used in
In Google Play apps (checked in their published builds: the Volkswagen Group and Philips Hue apps on November 17, 2026, Medal and IKEA on November 9, 2026):
- Volkswagen — Volkswagen.
- Audi — myAudi.
- Porsche — My Porsche.
- CUPRA — My CUPRA.
- Philips Hue — Philips Hue: ships SceneView's AR module (
ARSceneView). - Medal — Medal.
- IKEA — IKEA.
Declared in their public source code or published build files (checked November 17, 2026):
- Meshtastic: the Android app's 3D and AR device viewer (SceneView 4.69.5).
- Bitkey by Block: 3D rendering of the hardware wallet in the Android app (SceneView 2.3.0).
- Vocable AAC by WillowTree: head tracking for hands-free communication (ARSceneView 2.3.3).
- Niantic Spatial: the Kotlin samples of its spatial SDK (ARSceneView 2.3.1).
- GeneXus: its Android augmented reality module, in the Maven Central POM (SceneView 2.3.0).
- TruVideo: its camera SDK, in the Maven Central POM (ARSceneView 2.3.0).
Built with SceneView
- 3D AR Model Viewer — open a 3D file from any app or link (GLB, glTF, STL, OBJ, PLY, 3MF) and see it in your room at real size.
- Will It Fit — enter a piece of furniture's dimensions and see whether it fits before you buy.
Maintainer
Thomas Gorisse — Mobile SDKs and the AI agent pipeline behind them · Creator of SceneView, open-source 3D & AR
Links
Sponsors
If SceneView helps you build, consider supporting its maintenance.
Recurring contributions fund bug fixes, Filament updates, documentation and releases. Individuals and small teams are welcome; small contributions matter too. Teams that want public recognition can choose a sponsor tier with a logo and link.
Support SceneView on Open Collective · or through GitHub Sponsors
Sponsorship supports shared maintenance. It does not include a support contract or priority on issues. Thank you to everyone who contributes code, reports bugs, improves the docs or sponsors SceneView.
Questions about SceneView in your product: hello@sceneview.dev.




