# SceneView: a Compose-native 3D and AR SDK that replaces Sceneform

> SceneView wraps Filament and ARCore for Android, RealityKit for Apple, and a Filament.js build for the web, and adds an MCP server so an assistant can scaffold the app. Here is how it installs, what it will and will not open, and where the documentation stops.

**sceneview/sceneview** — AI-first 3D & AR SDK for Android (Jetpack Compose + Filament), Apple (SwiftUI + RealityKit) and the web. Opens glTF/GLB, 3MF, STL, OBJ and PLY on Android and USDZ on Apple, at real size in AR. An assistant reads llms.txt and writes code that compiles first try; also an MCP server and a ChatGPT/Codex plugin.

- Repository: https://github.com/sceneview/sceneview
- Website: https://sceneview.github.io
- Stars: 1,328 · Forks: 246
- Language: Kotlin
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/sceneview-sceneview

## The gap SceneView fills on Android

Google archived Sceneform in 2021 and ships no first-party declarative AR renderer. The README is blunt about what that leaves behind: current ARCore samples hand-roll a throwaway OpenGL framework. SceneView descends from the maintained Sceneform community fork and keeps the declarative surface, but rebuilds it on Jetpack Compose instead of the old View and Fragment API.

The split of responsibilities is the part worth understanding. ARCore does perception: plane detection, anchors, depth, geospatial. Filament does rendering, the same engine Google uses elsewhere for real-time graphics. SceneView is the layer that binds the two to Compose state, so a model is a composable and not a lifecycle callback you have to unregister.

The target reader is an Android developer who already writes Compose and now needs a 3D viewer or an AR placement screen. The second audience is less obvious and comes from the file-format table: people who receive a 3MF, STL, OBJ or PLY file and want it on screen at real size without a desktop tool. The Android demo app registers as an "Open with" target for those files, so a tap anywhere on the phone lands in the viewer and then in AR.

## How the renderer, the file loaders and the assistant fit together

On Android the runtime is Filament. glTF and GLB go through Filament's own loader. The other four formats do not: the README describes 3MF, STL (binary and ASCII), OBJ with MTL, and PLY (binary and ASCII) as converted by pure Kotlin into GLB in memory. That is a meaningful design choice. It means no native dependency per format, and it means a 3MF in millimetres keeps its units through the conversion, but it also means a large mesh is parsed on the app's heap before Filament ever sees it.

Format detection happens on the bytes, not the extension. The README states that a `.3mf` arriving as `application/octet-stream` with no file name still opens. For an app that receives files from chat clients and download managers, that is the difference between working and showing an error.

Apple takes a different route entirely. iOS, macOS and visionOS use RealityKit through SwiftUI, and the format list is narrower: USDZ and Reality files only. Web runs Filament.js compiled to WASM, wrapped by a small `sceneview.js` DSL that exposes a `SceneView.modelViewer` call.

The AI layer is separate from the renderer. An `llms.txt` file sits at the repository root, and the README claims an assistant reading it writes code that compiles first try. An MCP server published as `sceneview-mcp` and a ChatGPT/Codex plugin directory (`.codex-plugin/`, `gpt/`) exist alongside it. Treat the compile-first-try claim as a vendor statement, not a measured result.

## Installing SceneView on Android and rendering a first model

The README's quick look is a Compose snippet, not an install guide. It gives the artifact names through its Maven Central badges, `io.github.sceneview:sceneview` for 3D and `io.github.sceneview:arsceneview` for AR, and the release badge shows v4.34.0. Add the one you need to your module's dependency block.

The first real use is a full-screen viewer with one model. This is the README's own Android example, with the model path pointing at an asset you ship in `src/main/assets/models/`.

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

What you should see is the helmet filling the view, scaled to one unit and rotating on its own because `autoAnimate` is true. The `?.let` matters: `rememberModelInstance` returns null until the load finishes, so the node simply does not exist for the first frames.

If you would rather have the assistant scaffold the project, the README gives one command and one prompt.

```bash
claude mcp add sceneview -- npx sceneview-mcp
# Then ask: "Build me an AR app with tap-to-place furniture"
```

There is also a one-tap path to the demos without any setup. Every demo opens through `https://sceneview.github.io/open?demo=<id>`, and the README gives `…/open?demo=ar-rerun` as the example, which lands on the AR Rerun debug screen.

## Where SceneView stops being the right tool

The format table is the first boundary and it is asymmetric. 3MF, STL, OBJ and PLY are Android-only. USDZ and Reality are Apple-only. Web covers glTF and GLB. If your product ingests 3MF on both Android and iOS, SceneView does not solve the iOS half, and nothing in the README suggests a converter is planned.

The second boundary is platform maturity. Only Android 3D, Android AR and the MCP server are marked Stable. Android TV, iOS/macOS/visionOS, Web, Desktop, Flutter, React Native and Compose Multiplatform are all marked Alpha. Compose Multiplatform is narrower still: the README calls it a viewer subset covering Android and iOS. Building a shipped product on an Alpha target means accepting that the API can move under you.

The third is the in-memory conversion path. Four of the five Android formats are parsed in Kotlin and materialised as GLB before rendering. The README does not document a streaming path, a size ceiling or a background-thread guarantee for that conversion, so a large STL or PLY is a case you should measure on a real device before you promise it. The README also does not document rollback or a downgrade path between versions, which matters because the release cadence is roughly every two weeks.

## SceneView against Sceneform, and against a game engine

The comparison people search for is Sceneform versus SceneView, and the difference is structural rather than cosmetic. Sceneform was a View-based library whose Android SDK Google archived in 2021. SceneView descends from the community fork that kept it alive, but its Android surface is Jetpack Compose, so scene content is declared inside your composable tree and recomposes with the rest of the UI. Porting a Sceneform screen is therefore not a version bump; it is a rewrite of the view layer, which is why the repository carries a MIGRATION.md.

The other alternative is a game engine such as Unity, which people also search for alongside SceneView. The approaches diverge on where the UI lives. A game engine owns the whole rendering surface and you bridge to native UI at the edges. SceneView does the opposite: it renders inside a Compose or SwiftUI hierarchy, so the AR view is one element among buttons, sheets and navigation. That is better when AR is a feature of an app. It is worse when the app is the 3D experience, because you inherit the host framework's layout and lifecycle constraints instead of controlling the loop yourself.

## Licence, releases and what an upgrade actually costs

SceneView is Apache-2.0, and the repository carries a NOTICE file alongside the LICENSE, which is the usual arrangement for a project that vendors third-party components. Filament and ARCore are separate dependencies with their own terms, so the Apache-2.0 grant covers SceneView's own code and not necessarily everything in the dependency graph. That is a question for whoever handles compliance on your team, not something the README settles.

The release cadence is the practical cost. The listed releases run v4.32.0 on 2026-08-26, v4.33.0 on 2026-08-26, and v4.34.0 on 2026-09-09, and the last push to the default branch was on 2026-09-09, so the project is being worked on continuously. Rapid minor releases with a Compose API surface mean the upgrade cost is not the version number; it is re-checking your scene code against the changelog. The repository has a CHANGELOG.md and a `changelog.d/` directory, and both a MIGRATION.md and a `parity-manifest.yml` sit at the root, which tells you the maintainers expect cross-platform drift to be tracked rather than assumed away. Pin an exact version and read the changelog entry before moving.

## What the documentation does not answer

Several things a team would want before committing are simply absent. There is no documented rollback procedure, so a bad minor version has no described exit. There is no stated performance envelope for the Kotlin conversion of 3MF, STL, OBJ or PLY, and no guidance on mesh size. The `llms.txt` compile-first-try claim has no published methodology behind it.

The MCP server is the part most likely to be adopted on faith, because the install is one command and the payoff is immediate. That is exactly why the claim deserves a test on your own codebase before it shapes your process. The rest of the project is more conventional: a Compose library over Filament and ARCore, with a format table you can check in ten seconds against the files your users actually send.

## Conclusion

Adopt SceneView if you are building an Android 3D or AR screen in Jetpack Compose and want ARCore plus Filament without writing a renderer, or if you need 3MF, STL, OBJ or PLY opened on a phone. Do not adopt it for a production iOS or web build: the README marks Apple, Web, Desktop, Flutter and React Native as Alpha, and the Compose Multiplatform target as a viewer subset covering Android and iOS only. Before committing, verify the Maven coordinates io.github.sceneview:sceneview and io.github.sceneview:arsceneview resolve at the version you intend to pin, and confirm the format you actually receive is in the support table, because 3MF, STL, OBJ and PLY are Android-only and USDZ is Apple-only.

## FAQ

### What is SceneView?

SceneView is a 3D and AR SDK that uses the UI frameworks you already know: Jetpack Compose on Android with Filament and ARCore, SwiftUI on Apple with RealityKit, and a Filament.js build for the web. It opens glTF, GLB, 3MF, STL, OBJ and PLY on Android and USDZ on Apple, and shows models at real size in AR.

### What is the difference between Sceneform and SceneView?

Google archived the Sceneform Android SDK in 2021. SceneView descends from the maintained Sceneform community fork but is Jetpack-Compose-native, so scene content is declared inside your composable tree rather than in a View-based surface, and the repository includes a MIGRATION.md for moving across.

### Which platforms does SceneView support?

Android 3D and Android AR are marked Stable, as is the MCP server. Android TV, iOS/macOS/visionOS, Web, Desktop, Flutter, React Native and Compose Multiplatform are all marked Alpha, and Compose Multiplatform is described as a viewer subset covering Android and iOS only.

### Which 3D file formats can SceneView open?

On Android: glTF, GLB, 3MF, STL, OBJ with MTL, and PLY. On Apple: USDZ and Reality files. On the web: glTF and GLB. The README states that the format is decided by the bytes rather than the file extension, so a 3MF arriving as application/octet-stream with no file name still opens.

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

Add the Maven Central artifact io.github.sceneview:sceneview for 3D, and io.github.sceneview:arsceneview for AR screens, to your module's dependencies. The README's quick look then shows a SceneView composable containing a ModelNode built from rememberModelInstance.

### Can an AI assistant write SceneView code?

The repository ships an llms.txt file plus an MCP server published as sceneview-mcp, installed with the command claude mcp add sceneview -- npx sceneview-mcp, and a ChatGPT/Codex plugin directory. The README states that an assistant reading llms.txt writes code that compiles first try, but it publishes no methodology for that claim.

## Sources

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

---

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