# mcp
**Category:** π Browser Automation
**Repository:** https://github.com/SceneView/sceneview
**Views:** 0
**Installs:** 0
**Upvotes:** 0
**Directory Page:** https://allmcps.com/mcp/mcp-204
## Description
3D & AR SDK for Android, iOS, Web β API docs, samples, validation, and code generation.
## Claude Desktop Quick Installation
Heuristic fallback β verify the package name and runner against the repository README before running it. Uses `npx` (confidence: low):
```json
"mcpServers": {
"mcp": {
"command": "npx",
"args": ["-y","mcp-204"]
}
}
```
## Documentation & README
# 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.
[](https://central.sonatype.com/artifact/io.github.sceneview/sceneview)
[](https://central.sonatype.com/artifact/io.github.sceneview/arsceneview)
[](https://github.com/sceneview/sceneview)
[](https://www.npmjs.com/package/sceneview-web)
[](https://www.npmjs.com/package/sceneview-mcp)
[](https://github.com/sceneview/sceneview/tree/main/flutter)
[](https://github.com/sceneview/sceneview/tree/main/react-native)
[](https://github.com/sceneview/sceneview/actions/workflows/ci.yml)
[](https://github.com/sceneview/sceneview/blob/main/LICENSE)
[](https://github.com/sceneview/sceneview/stargazers)
[](https://github.com/sceneview/sceneview/releases/latest)
[](https://discord.gg/UbNDDBTNqb)
[](https://github.com/sponsors/sceneview)
## Try the demo apps
See SceneView capabilities in action β install the live demos in one tap:
Browse all sample sources in [`samples/`](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
```kotlin
// Android β Jetpack Compose
SceneView(modifier = Modifier.fillMaxSize()) {
rememberModelInstance(modelLoader, "models/helmet.glb")?.let {
ModelNode(modelInstance = it, scaleToUnits = 1.0f, autoAnimate = true)
}
}
```
```swift
// iOS β SwiftUI
SceneView(environment: .studio) {
ModelNode(named: "helmet.usdz")
.scaleToUnits(1.0)
}
```
```html
```
```bash
# 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
| Platform | Renderer | Framework | Status |
|---|---|---|---|
| **Android** | Filament | Jetpack Compose | Stable |
| **Android TV** | Filament | Compose TV | Alpha |
| **iOS / macOS / visionOS** | RealityKit | SwiftUI | Alpha |
| **Web** | Filament.js (WASM) | Kotlin/JS + sceneview.js | Alpha |
| **Desktop** | Software renderer | Compose Desktop | Alpha |
| **Flutter** | Native per platform | PlatformView | Alpha |
| **React Native** | Native per platform | Fabric | Alpha |
| **Compose Multiplatform** | Per platform (Filament / RealityKit) | `sceneview-compose` | Alpha β viewer subset, Android + iOS |
| **Claude / AI** | β | MCP Server | Stable |
---
## The Compose-native successor to Sceneform
Google [archived Sceneform](https://github.com/google-ar/sceneform-android-sdk) 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](https://sceneview.github.io/migration/) for a concept-by-concept mapping
(`ArFragment` β `ARScene { }`, `ModelRenderable` β `rememberModelInstance`, and so on).
---
## Install
**Android** (3D + AR):
```kotlin
dependencies {
implementation("io.github.sceneview:sceneview:4.28.0") // 3D
implementation("io.github.sceneview:arsceneview:4.28.0") // AR (includes 3D)
}
```
**iOS / macOS / visionOS** (Swift Package Manager):
```
https://github.com/sceneview/sceneview.git (from: 4.28.0)
```
**Web** (sceneview.js β friendly DSL, two `
```
**Web** (Kotlin/JS):
```kotlin
dependencies {
implementation("io.github.sceneview:sceneview-web:4.28.0")
}
```
**Claude Code / Claude Desktop:**
```bash
claude mcp add sceneview -- npx sceneview-mcp
```
```json
{ "mcpServers": { "sceneview": { "command": "npx", "args": ["-y", "sceneview-mcp"] } } }
```
**Desktop** / **Flutter** / **React Native**: see [samples/](samples/)
---
## 3D scene
`SceneView` is a Composable that renders a Filament 3D viewport. Nodes are composables inside it.
```kotlin
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
| Category | Nodes | What they do |
|---|---|---|
| **Models** | `ModelNode` | glTF/GLB with skeletal/morph animations. `isEditable = true` for gestures. |
| **Primitives** | `CubeNode` Β· `SphereNode` Β· `CylinderNode` Β· `ConeNode` Β· `TorusNode` Β· `CapsuleNode` Β· `PlaneNode` | Procedural geometry, parametric size/segments |
| **Curves & shapes** | `LineNode` Β· `PathNode` Β· `ShapeNode` | Single segments, polylines, extruded 2D polygons |
| **Custom geometry** | `GeometryNode` Β· `MeshNode` | Direct Filament `IndexBuffer` / `VertexBuffer` |
| **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** β labels, cards, lists, animations (rendered, not touch-interactive) |
| **Lighting** | `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.
```kotlin
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
| Node | What it does |
|---|---|
| `AnchorNode` | Pin a node to a real-world ARCore `Anchor` |
| `HitResultNode` | Live surface cursor β pose comes from each frame's hit-test |
| `PoseNode` | Position a node at any ARCore `Pose` |
| `TrackableNode` | Generic wrapper for any `Trackable` |
| `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 |
### AR features
Every ARCore feature surfaced as a Compose-friendly API:
| Feature | API surface |
|---|---|
| **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(cameraConfig = β¦)`, `ARSceneScope.exposureCompensation` |
| **Record & Replay** | `rememberARRecorder()` to capture, `ARSceneView(playbackDataset = file)` to replay 1:1 β debug AR without a phone |
| **Rerun.io live debug** | `rememberRerunBridge()` streams poses/planes/clouds to the Rerun viewer + a hosted [`/rerun/?url=β¦`](https://sceneview.github.io/rerun/) replay |
| **Permission flow** | `ARPermissionHandler` β auto-detected from `ComponentActivity` |
See [`docs/docs/ar-recording.md`](docs/docs/ar-recording.md), [`RECORDING_PLAYBACK.md`](samples/android-demo/RECORDING_PLAYBACK.md), and the *AR Debug β Rerun.io* section in [`llms.txt`](./llms.txt).
---
## Capabilities
What you can do across all 3D and AR scenes β beyond placing nodes.
| 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-KMP simulation (no JNI). | `PhysicsNode`, `sceneview-core` |
| **Collision & raycasting** | Ray vs Box / Sphere intersections, hit-testing, frustum culling. | `CollisionSystem`, `Ray`, `Box`, `Sphere` |
| **Procedural geometry** | Generators for cube/sphere/cylinder/cone/torus/capsule, plus 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** | Render any `@Composable` as a textured plane in world space β labels, cards, lists, animations. Rendered only: hit-test the node to react to taps ([#2845](https://github.com/sceneview/sceneview/issues/2845)). | `ViewNode` + `ViewNode.WindowManager` |
| **Multiple cameras** | Picture-in-picture, mini-map, security-camera views. | `SecondaryCamera` |
| **Reactive scene graph** | Compose-driven recomposition: change state β tree updates. No imperative `parent.addChild()`. | `SceneScope` / `ARSceneScope` DSL |
---
## Apple (iOS / macOS / visionOS)
Native Swift Package built on RealityKit. **19 node types** mirroring the Android API.
```swift
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:
```swift
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.28.0)
---
## SceneView Web (JavaScript + Kotlin/JS)
The lightest way to add 3D to any website. Two `
```
> **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
```js
const ar = await SceneView.startAR("canvas", { hitTest: true }) // immersive-ar
const vr = await SceneView.startVR("canvas") // immersive-vr
```
| Class | Mode | Use |
|---|---|---|
| `ARSceneView` | `immersive-ar` | Phone passthrough AR with hit-test, anchors, light estimation |
| `VRSceneView` | `immersive-vr` | Headset VR with controller input, reference spaces |
| `WebXRSession` | both | Low-level frame loop, `XRHitTestSource`, `XRReferenceSpace` |
### 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:
```kotlin
implementation("io.github.sceneview:sceneview-web:4.28.0")
```
**Install:** `npm install sceneview-web` or CDN β [Landing page](https://sceneview.github.io/) β [Playground](https://sceneview.github.io/playground.html) β [npm](https://www.npmjs.com/package/sceneview-web)
---
## 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](./mcp/) provides **28 tools**, **33 compilable samples**, a full API reference, and a code validator:
```bash
# 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](https://github.com/sceneview/claude-marketplace):
```bash
/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
| Domain | Install | Tools |
|---|---|---|
| **Automotive** β car configurators, HUD, dashboards | `npx automotive-3d-mcp` | 9 |
| **Healthcare** β anatomy, DICOM, surgical planning | `npx healthcare-3d-mcp` | 7 |
| **Gaming** β characters, physics, particles, levels | `npx gaming-3d-mcp` | 7 |
| **Interior Design** β room planning, AR furniture | `npx interior-design-3d-mcp` | 7 |
| **Rerun.io** β AR debug logging, visualization | `npx rerun-3d-mcp` | 5 |
### ChatGPT / GitHub Copilot / Other AI
- **llms.txt** β Machine-readable API reference at [`llms.txt`](./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`](.github/copilot-instructions.md)
- **Cursor** β Rules file at [`.cursorrules`](.cursorrules)
- **Windsurf** β Rules file at [`.windsurfrules`](.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](#the-compose-native-successor-to-sceneform)
- **~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](https://registry.modelcontextprotocol.io). See the [MCP README](./mcp/README.md) 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`](https://www.npmjs.com/package/@rerun-io/web-viewer) under SceneView branding.
See the [AR Debug β Rerun.io section in `llms.txt`](./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`](docs/docs/ar-recording.md) and the [`Record & Playback` demo](samples/android-demo/RECORDING_PLAYBACK.md).
---
## 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 (software wireframe placeholder)
```
---
## Samples
| Sample | Platform | Run |
|---|---|---|
| `samples/android-demo` | Android β 3D & AR Explorer | `./gradlew :samples:android-demo:assembleDebug` |
| `samples/android-tv-demo` | Android TV | `./gradlew :samples:android-tv-demo:assembleDebug` |
| `samples/ios-demo` | iOS β 3D & AR Explorer | Open in Xcode |
| `samples/web-demo` | Web | `./gradlew :samples:web-demo:jsBrowserRun` |
| `samples/desktop-demo` | Desktop | `./gradlew :samples:desktop-demo:run` |
| `samples/flutter-demo` | Flutter | `cd samples/flutter-demo && flutter run` |
| `samples/react-native-demo` | React Native | See README |
---
## Links
- [Website](https://sceneview.github.io/)
- [Playground](https://sceneview.github.io/playground.html)
- [Documentation](https://sceneview.github.io/docs/)
- [Discord](https://discord.gg/UbNDDBTNqb)
- [Contributing](CONTRIBUTING.md)
- [Changelog](CHANGELOG.md)
- [Migration v2 β v3](MIGRATION.md)
## Support
SceneView is free and open source. Sponsors help keep it maintained across 9 platforms.
| | Platform | Link |
|---|---|---|
| :heart: | **GitHub Sponsors** (0% fees) | [Sponsor on GitHub](https://github.com/sponsors/sceneview) |
See [SPONSORS.md](.github/SPONSORS.md) for tiers and current sponsors.