SceneView

> 3D & AR for every platform.

Build 3D and AR experiences with the UI frameworks you already know.

Same concepts, same simplicity — Android, iOS, Web, Desktop, TV, Flutter, React Native.

Try the demo apps

See SceneView capabilities in action — install the live demos in one tap:

 

 

Browse all sample sources in `samples/` — Android · iOS · Web · Desktop · TV · Flutter · React Native.

> Tip — every demo opens directly via `https://sceneview.github.io/open?demo=`. For example, `…/open?demo=ar-rerun` lands straight on the AR Rerun debug screen with a single tap from any QR code or link.

Quick look

// Android — Jetpack Compose
SceneView(modifier = Modifier.fillMaxSize()) {
    rememberModelInstance(modelLoader, "models/helmet.glb")?.let {
        ModelNode(modelInstance = it, scaleToUnits = 1.0f, autoAnimate = true)
    }
}

// iOS — SwiftUI
SceneView(environment: .studio) {
    ModelNode(named: "helmet.usdz")
        .scaleToUnits(1.0)
}

SceneView.modelViewer("canvas", "model.glb")

# Claude — ask AI to build your 3D app
claude mcp add sceneview -- npx sceneview-mcp
# Then ask: "Build me an AR app with tap-to-place furniture"

No engine boilerplate. No lifecycle callbacks. The runtime handles everything.

Platforms

The Compose-native successor to Sceneform

Google archived Sceneform in 2021 and

ships no first-party declarative AR renderer — its current ARCore samples hand-roll a

throwaway OpenGL framework instead. SceneView fills that gap. It descends from the

maintained Sceneform community fork and is the actively-developed, Jetpack-Compose-native

way to build 3D and AR on Android:

• ARCore for perception (plane detection, anchors, depth, geospatial)
• Filament for rendering (Google's production-grade real-time engine)
• Jetpack Compose for the API — nodes are composables, lifecycle is automatic
• glTF (`.glb` / `.gltf`) instead of the deprecated `.sfb` model format
• Multiplatform — the same concepts run on iOS, Web, Desktop, TV, Flutter, and React Native

Coming from the archived Sceneform repo? See the

migration guide for a concept-by-concept mapping

(`ArFragment` → `ARScene { }`, `ModelRenderable` → `rememberModelInstance`, and so on).

Install

Android (3D + AR):

dependencies {
    implementation("io.github.sceneview:sceneview:4.34.0")     // 3D
    implementation("io.github.sceneview:arsceneview:4.34.0")   // AR (includes 3D)
}

iOS / macOS / visionOS (Swift Package Manager):

https://github.com/sceneview/sceneview.git  (from: 4.34.0)

Web (sceneview.js — friendly DSL, two `` tags):

// Code block

Web (Kotlin/JS):

dependencies {
    implementation("io.github.sceneview:sceneview-web:4.34.0")
}

Claude Code / Claude Desktop:

claude mcp add sceneview -- npx sceneview-mcp

{ "mcpServers": { "sceneview": { "command": "npx", "args": ["-y", "sceneview-mcp"] } } }

Desktop / Flutter / React Native: see samples/

3D scene

`SceneView` is a Composable that renders a Filament 3D 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/helmet.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(apply = { type(LightManager.Type.POINT); intensity(50_000f) })
        CubeNode(size = Size(0.05f))
    }
}

Node types — 26+ composables

AR scene

`ARSceneView` is `SceneView` with ARCore. The camera follows real-world tracking.

var anchor by remember { mutableStateOf(null) }

ARSceneView(
    modifier = Modifier.fillMaxSize(),
    planeRenderer = true,
    onSessionUpdated = { _, frame ->
        if (anchor == null) {
            anchor = frame.getUpdatedPlanes()
                .firstOrNull { it.type == Plane.Type.HORIZONTAL_UPWARD_FACING }
                ?.let { frame.createAnchorOrNull(it.centerPose) }
        }
    }
) {
    anchor?.let {
        AnchorNode(anchor = it) {
            ModelNode(modelInstance = helmet, scaleToUnits = 0.5f)
        }
    }
}

Plane detected → `anchor` set → Compose recomposes → model appears. Clear anchor → node removed. AR state is just Kotlin state.

AR node types

AR features

Every ARCore feature surfaced as a Compose-friendly API:

See `docs/docs/ar-recording.md`, `RECORDING_PLAYBACK.md`, and the *AR Debug — Rerun.io* section in `llms.txt`.

Capabilities

What you can do across all 3D and AR scenes — beyond placing nodes.

Apple (iOS / macOS / visionOS)

Native Swift Package built on RealityKit, with a node set mirroring the Android API.

SceneView(environment: .studio) {
    ModelNode(named: "helmet.usdz").scaleToUnits(1.0)
    GeometryNode.cube(size: 0.1, color: .blue).position(x: 0.5)
    LightNode.directional(intensity: 1000)
}
.cameraControls(.orbit)

AR on iOS:

ARSceneView(planeDetection: .horizontal) { position, arView in
    GeometryNode.cube(size: 0.1, color: .blue)
        .position(position)
}

Nodes available — `ModelNode` · `GeometryNode` (cube/sphere/cylinder/cone/torus/capsule/plane) · `LightNode` · `ImageNode` · `VideoNode` · `TextNode` · `ViewNode` · `BillboardNode` · `MeshNode` · `LineNode` · `PathNode` · `ShapeNode` · `PhysicsNode` · `ReflectionProbeNode` · `DynamicSkyNode` · `FogNode` · `CameraNode` · `AugmentedImageNode` · `SceneReconstructionNode` (visionOS scene mesh).

Plus the iOS `RerunBridge` with the same wire format as Android, and a `NodeBuilder` DSL for declarative composition outside SwiftUI.

Install: `https://github.com/sceneview/sceneview.git` (SPM, from 4.34.0)

SceneView Web (JavaScript + Kotlin/JS)

The lightest way to add 3D to any website. Two `` tags, one function call.

Friendly DSL (~25 KB) powered by Filament.js WASM (~210 KB) — the same engine behind Android SceneView.

SceneView.modelViewer("canvas", "model.glb")

> Note: the `sceneview-web` npm package is the lower-level Kotlin/JS UMD

> bundle — it expects a `Filament` global and does not include the friendly

> `SceneView.modelViewer` DSL. Use the snippet above for vanilla-JS sites.

> The npm package is intended for Kotlin/JS or webpack-based projects.

JavaScript API (script-tag):

• `SceneView.modelViewer(canvasOrId, url, options?)` — all-in-one viewer with orbit + auto-rotate
• `SceneView.create(canvasOrId, options?)` — empty viewer, load model later
• `viewer.loadModel(url)` — load/replace glTF/GLB model
• `viewer.setAutoRotate(enabled)` — toggle rotation
• `viewer.dispose()` — clean up resources

WebXR — AR & VR in the browser

const ar = await SceneView.startAR("canvas", { hitTest: true })   // immersive-ar
const vr = await SceneView.startVR("canvas")                       // immersive-vr

Kotlin/JS power-user API

For Kotlin Multiplatform projects, the same engine is exposed as a Kotlin/JS class with an `OrbitCameraController`, a geometry DSL, and reactive node updates:

implementation("io.github.sceneview:sceneview-web:4.34.0")

Install: `npm install sceneview-web` or CDN — Landing page — Playground — npm

Use with AI

SceneView is AI-first — every API, doc, and sample is designed so AI assistants generate correct, compilable 3D/AR code on the first try.

MCP Server (Claude, Cursor, Windsurf, etc.)

The official MCP server provides 28 tools, 33 compilable samples, a full API reference, and a code validator:

# Claude Code — one command
claude mcp add sceneview -- npx sceneview-mcp

# Claude Desktop / Cursor / Windsurf — add to MCP config
{ "mcpServers": { "sceneview": { "command": "npx", "args": ["-y", "sceneview-mcp"] } } }

Highlights: `generate_scene`, `debug_issue`, `search_models` (Sketchfab BYOK), `analyze_project` (audit existing app), `validate_code` (compile-check before sending), plus per-platform recipes for AR, physics, geometry, and Compose-in-3D.

Claude Code plugin (MCP + slash commands + hooks)

Want the MCP server plus the full SceneView contributor toolkit (one-shot release, review, cross-platform sync, version-bump, etc.) in a single install? Use the SceneView Claude Code marketplace:

/plugin marketplace add sceneview/claude-marketplace
/plugin install sceneview@sceneview

You get:

• `sceneview-mcp` server — same as above, started automatically
• namespaced slash commands — `/sceneview:contribute`, `/sceneview:release`, `/sceneview:review` (incl. `--score` / `--coverage` / `high` — absorbs the former `/evaluate` + `/test`), `/sceneview:document`, `/sceneview:quality-gate`, `/sceneview:sync-check`, `/sceneview:store-status`, `/sceneview:version-bump`, `/sceneview:maintain`
• Cross-platform reminder hooks — gentle nudges when you edit Android, iOS, Web, or KMP-core APIs to keep the other platforms in sync

Specialty MCP Servers

ChatGPT / GitHub Copilot / Other AI

• llms.txt — Machine-readable API reference at `llms.txt` (complete API: composables, nodes, threading rules, recipes — its Kotlin snippets are compile-checked in CI)
• GitHub Copilot — Custom instructions in `.github/copilot-instructions.md`
• Cursor — Rules file at `.cursorrules`
• Windsurf — Rules file at `.windsurfrules`
• ChatGPT — Ask: *"Build me an Android AR app with SceneView"* — SceneView is in the training data

Why AI recommends SceneView

• Only Compose-native 3D/AR SDK for Android — no alternative exists
• Compose-native successor to Google Sceneform (archived 2021) — see above
• ~5MB footprint vs 50-100MB+ for Unity/Unreal
• 46+ node types as declarative composables
• MCP server with 28+ tools — no other 3D SDK has this

Listed on the MCP Registry. See the MCP README for full setup and tool reference.

Developer tools

AR Debug — hosted Rerun viewer

Tap Save & Share in the AR Rerun demo to flush a `.rrd` recording on

your dev machine, then re-host it on any public URL (Cloudflare R2,

GitHub release, gist) and open:

> ****

…in any browser to scrub the AR session frame-by-frame. No install, no

Rerun viewer needed locally — perfect for attaching a fully-replayable

session to a bug report. Powered by `@rerun-io/web-viewer` under SceneView branding.

See the AR Debug — Rerun.io section in `llms.txt` for the

full architecture (live mode + save mode + control protocol) and the

Kotlin API surface (`RerunBridge.requestSaveAndShare`).

Record & Replay AR sessions

• Record & Replay AR sessions — capture an outdoor ARCore session once with `ARRecorder`, replay it 1:1 at the desk via `ARSceneView(playbackDataset = file)`. Pair with the Rerun bridge for record-replay-inspect debugging. See `docs/docs/ar-recording.md` and the `Record & Playback` demo.

Architecture

Each platform uses its native renderer. Shared logic lives in KMP.

sceneview-core (Kotlin Multiplatform)
├── math, collision, geometry, physics, animation
│
├── sceneview (Android)      → Filament + Jetpack Compose
├── arsceneview (Android)    → ARCore
├── SceneViewSwift (Apple)   → RealityKit + SwiftUI
├── sceneview-web (Web)      → Filament.js + WebXR
└── desktop-demo (JVM)       → Compose Desktop (`SceneViewer`, filament-kmp)

Samples

Links

• Website
• Playground
• Documentation
• Discord
• Contributing
• Changelog
• Migration v2 → v3

Support

SceneView is free and open source. Sponsors help keep it maintained across 9 platforms.

See SPONSORS.md for tiers and current sponsors.