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.

Android 3D Android AR MCP Server 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=<id>. For example, …/open?demo=ar-rerun lands straight on the AR Rerun debug screen with a single tap from any QR code or link.

Open any 3D file, at real size

SceneView reads the files people actually receive — from a download, a chat, a 3D-printing site or an AI assistant — and shows them at their real size, in 3D and in AR.

The format is decided by the bytes, not the extension: a .3mf that arrives as application/octet-stream with no file name still opens. The Android demo app is an "Open with" target for these files, so a file tapped anywhere on the phone lands in the viewer, then in AR.

Two apps built on SceneView are on Google Play:

• AR Model Viewer — open any 3D file (GLB, glTF, 3MF, STL, OBJ, PLY) or browse thousands of free models, and see them in your room at real size.
• Will It Fit — type a sofa's dimensions, or pick a stand-in, and see whether it fits before you buy.

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)
}

<!-- Web — friendly DSL (Filament.js engine + SceneView wrapper) -->
<script src="https://cdn.jsdelivr.net/gh/sceneview/sceneview@v4.37.0/website-static/js/filament/filament.js"></script>
<script src="https://cdn.jsdelivr.net/gh/sceneview/sceneview@v4.37.0/website-static/js/sceneview.js"></script>
<script> SceneView.modelViewer("canvas", "model.glb") </script>

# Any AI assistant — add the MCP server, then just ask
npx -y 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.37.0")     // 3D
    implementation("io.github.sceneview:arsceneview:4.37.0")   // AR (includes 3D)
}

iOS / macOS / visionOS (Swift Package Manager):

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

Web (sceneview.js — friendly DSL, two <script> tags):

<!-- 1. Filament.js engine (WASM) -->
<script src="https://cdn.jsdelivr.net/gh/sceneview/sceneview@v4.37.0/website-static/js/filament/filament.js"></script>
<!-- 2. SceneView wrapper (exposes SceneView.modelViewer / .create / .startAR) -->
<script src="https://cdn.jsdelivr.net/gh/sceneview/sceneview@v4.37.0/website-static/js/sceneview.js"></script>

Web (Kotlin/JS, for bundler-based projects):

npm install sceneview-web

AI assistants (MCP): one server, every client — see Use SceneView with your AI coding assistant for the exact snippet per tool.

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"] } } }

ChatGPT / Codex: this repository is a plugin — the manifest lives at .codex-plugin/plugin.json and points at the three skills under agents/. Install it into Codex from a checkout:

codex plugin marketplace add "$PWD"          # absolute path — a relative one does not resolve
codex plugin add sceneview@sceneview-local
codex plugin list                            # sceneview@sceneview-local  installed, enabled

Codex also discovers the skills on its own from .agents/skills/ inside a checkout. For ChatGPT, the same MCP server speaks Streamable HTTP — npx sceneview-mcp --http — and carries the inline view_3d_model viewer widget. Package, listing copy and submission notes: agents/OPENAI-PLUGIN.md.

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<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 { 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.

Model formats

3MF — the format AI print flows emit

Ask ChatGPT for a 3D print from a sketch and it hands back a .3mf: an OPC/ZIP package whose 3D/3dmodel.model part is XML, in millimetres and Z-up. Until now nothing on Android opened one in 3D, let alone in AR.

There is no new API. ModelLoader sniffs the payload by its ZIP magic and converts it to GLB in memory, so every existing entry point already accepts a 3MF and the whole glTF path — materials, gestures, AR placement — is reused:

// A .3mf shared into your app (ChatGPT, Files, a slicer). This is the whole of it.
rememberModelInstance(modelLoader, uri.toString())?.let {
    ModelNode(modelInstance = it, scaleToUnits = 1.0f)
}

Conversion scales the file's declared unit to metres (a 60 mm print is life-size in AR without a magic number), rotates the printer's Z-up to glTF's Y-up, gives every face its own normal — flat shading is what a printed part looks like — and turns <basematerials> and <colorgroup> into one glTF material per colour. For a custom pipeline, ThreeMfLoader.parse(), .toGlb() and .isThreeMf() are public in sceneview-core. Full section in llms.txt.

The Android demo registers as a handler for .3mf, .glb, .gltf, .stl, .obj and .ply, so a file opened from Downloads or sent through the share sheet lands in the viewer and then in AR at the size it would print (#3510). The format is decided by the bytes, not the file name — a shared .3mf arrives as application/octet-stream with no queryable display name at all.

Coming next

The 3MF parser is deliberately dependency-free Kotlin, and the same shape now carries STL, OBJ + MTL and PLY. Tracked, not yet shipped:

one ModelFormat entry point · every format on the web

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.37.0)

SceneView Web (JavaScript + Kotlin/JS)

The lightest way to add 3D to any website. Two <script> tags, one function call. Friendly DSL (~25 KB) powered by Filament.js WASM (~210 KB) — the same engine behind Android SceneView.

<!-- 1. Filament.js engine (WASM) -->
<script src="https://cdn.jsdelivr.net/gh/sceneview/sceneview@v4.37.0/website-static/js/filament/filament.js"></script>
<!-- 2. SceneView wrapper -->
<script src="https://cdn.jsdelivr.net/gh/sceneview/sceneview@v4.37.0/website-static/js/sceneview.js"></script>
<script> SceneView.modelViewer("canvas", "model.glb") </script>

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

OrbitCameraController, the geometry DSL and reactive node updates live in the sceneview-web module, which ships on npm only. It builds a webpack bundle (binaries.executable()) rather than a Kotlin/JS library, so it has no Maven coordinate:

npm install sceneview-web

A Kotlin Multiplatform project that wants the shared core as a Gradle dependency — collision, math, geometry, animation and physics, but not the renderer — uses the published Kotlin/JS artifact instead:

implementation("io.github.sceneview:sceneview-core-js:4.37.0")

Links: 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 Code, Cline, Codex, Cursor, GitHub Copilot, JetBrains AI, and any other MCP client)

The official MCP server provides 38 compilable samples, a full API reference, and a code validator — every tool is free, and there is no API key:

# Any MCP client — locally over stdio
npx -y sceneview-mcp

# Or remotely over Streamable HTTP, already hosted (required by Gemini in
# Android Studio, which does not support stdio)
https://mcp.sceneview.dev/mcp

The tools your assistant actually reaches for: validate_code (compile-check before sending), get_node_reference (the exact node API, not an invented one), list_samples / get_sample (start from code that builds), get_setup and get_ar_setup (wire up the project). Then, as you go: get_troubleshooting, get_gesture_guide, analyze_project (audit an existing app), and per-platform recipes for AR, physics, geometry, and Compose-in-3D.

Claude Code plugin (optional — 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

ChatGPT / Codex plugin

OpenAI's unit of distribution is the plugin — a manifest, skills, an optional MCP server — listed in one directory shared by ChatGPT and Codex. This repository is that plugin: .codex-plugin/plugin.json at the root points at the three skills under agents/ (sceneview, sceneview-ios, sceneview-web), each carrying the API contract, the recipes and the migration guide.

codex plugin marketplace add "$PWD"    # absolute path
codex plugin add sceneview@sceneview-local

For ChatGPT, npx sceneview-mcp --http serves the MCP Streamable HTTP transport at /mcp and the inline view_3d_model widget (MCP Apps) that renders a public GLB/glTF URL right in the conversation. Listing copy, starter prompts and test cases: agents/OPENAI-PLUGIN.md.

Rules files — whichever one your assistant reads

• llms.txt — Machine-readable API reference at llms.txt (complete API: composables, nodes, threading rules, recipes — its Kotlin snippets are compile-checked in CI). Use it when your tool has no MCP support.
• AGENTS.md — read by Codex, Cursor, GitHub Copilot, Gemini in Android Studio and a growing list of others
• CLAUDE.md — read by Claude Code
• .github/copilot-instructions.md — read by GitHub Copilot
• .cursorrules — legacy Cursor rules, kept for older versions

Domain-specific MCP servers

Separate npm packages, built on the same API contract, for teams working in one vertical. They ship and version independently of sceneview-mcp; the server above is the one to install for general Android, iOS or Web work.

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
• 48+ node types as declarative composables
• MCP server that compile-checks generated code, plus a ChatGPT / Codex plugin — no other 3D SDK has this
• Opens the .3mf an AI print flow emits — the file every model-generating chat hands back, and that nothing else on Android views in 3D or AR

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:

https://sceneview.github.io/rerun/?url=<encoded-public-url>

…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.