# Templates

> The project templates that ship with Graspable, what each starts you with, and how a project is laid out.

Source: https://graspable.dev/docs/templates

A template is the starting point of a project. You pick it once, when you create the project. Graspable copies it into your project folder and installs its packages. It also gives the agent instructions that fit the template, so a short request goes a long way.

On the Projects screen, choose **Browse templates**. Compare the pictures and descriptions, or search for what you want to make. Open **Details** to see requirements and requests to try, then choose **Use this template** (or **Select template** for a plan you do not have yet). Choosing a template does not create the project: give it a name and choose **Create**. If the online catalog is unavailable, the app still lists the templates included with it; pictures need a connection.

Twenty-two templates ship with the app; each has a page under [Templates](https://graspable.dev/templates), with requests to try and what people made from it. React XR is for everyone. The others are premium templates: the WebXR and Expo ones come with the Builder plan and higher, the native ones (Unity, Unreal Engine, Apple Vision Pro) with the Pro plan and higher; see [Plans and billing](https://graspable.dev/docs/plans-and-billing.md). To create a project from a premium template you must be signed in, so the app can check your plan. A project you already created keeps working whatever your plan.

| Template | Kind | Use it for |
|---|---|---|
| [Tabletop AR](https://graspable.dev/templates/web-ar.md) | Premium, WebAR | A rescue film and relay puzzle on a real table, with phone image tracking and WebXR surface placement |
| [Unity AR tabletop](https://graspable.dev/templates/unity-ar.md) | Premium, native (Unity 6) | The same miniature world in a native iOS, Android or Quest app |
| [React XR](https://graspable.dev/templates/react-xr.md) | Free, WebXR | Anything built from objects, starting from a small working scene |
| [Splat World](https://graspable.dev/templates/splat-world.md) | Premium, WebXR | Standing inside a generated place and adding things to it |
| [World Explorer](https://graspable.dev/templates/world-explorer.md) | Premium, WebXR | Walking through a generated place as if it were solid: tours, viewings, exhibitions |
| [World Game](https://graspable.dev/templates/world-game.md) | Premium, WebXR | A game inside a generated place, with physics |
| [WebGPU Splats](https://graspable.dev/templates/webgpu-splats.md) | Premium, WebXR | Millions of Gaussian splats on WebGPU: captured places and splats made by code |
| [Scanned Room](https://graspable.dev/templates/scanned-room.md) | Premium, WebXR | Measuring, planning and training inside a capture of a real room |
| [Product Studio](https://graspable.dev/templates/product-studio.md) | Premium, WebXR | Product viewers and configurators, placed at real size |
| [XR Game](https://graspable.dev/templates/xr-game.md) | Premium, WebXR | Games you play by grabbing, throwing and hitting |
| [Hands & Spatial UI](https://graspable.dev/templates/spatial-ui.md) | Premium, WebXR | Apps you use with your bare hands: panels, dashboards, instruments |
| [Multi-user](https://graspable.dev/templates/multiuser.md) | Premium, WebXR | A room several people are in at once: meetings, games, reviews |
| [Cross-platform XR](https://graspable.dev/templates/crossplatform.md) | Premium, WebXR | One app that adapts to every headset, pair of glasses, phone and computer, in your own room where the device shows it |
| [Panel app](https://graspable.dev/templates/expo-quest.md) | Premium, Expo | A flat app that opens as a window in a headset's home space, and as a web page everywhere else |
| [Meta glasses app](https://graspable.dev/templates/meta-glasses.md) | Premium, Expo | A phone app for Ray-Ban Meta, Oakley Meta and Meta Ray-Ban Display glasses: camera, display, inputs, motion, speech |
| [Glasses field notes](https://graspable.dev/templates/glasses-journal.md) | Premium, Expo | A hands-free photo journal for Ray-Ban Meta and Oakley Meta glasses: look, tap the temple, say a note |
| [Display glasses web app](https://graspable.dev/templates/display-glasses.md) | Premium | A web app that runs on Meta Ray-Ban Display glasses, installed from a link |
| [Unity for Quest](https://graspable.dev/templates/unity-quest.md) | Premium, native (Unity 6) | A native mixed-reality app for Meta Quest and Meta VR Glasses: passthrough, real surfaces, hands, controllers |
| [Unity for Android XR](https://graspable.dev/templates/unity-androidxr.md) | Premium, native (Unity 6) | The same kit for Android XR headsets and glasses |
| [Unity for XREAL](https://graspable.dev/templates/unity-xreal.md) | Premium, native (Unity 6) | The same kit for XREAL glasses |
| [Apple Vision Pro](https://graspable.dev/templates/visionos.md) | Premium, native (Swift) | A visionOS app: a window and an immersive space, built with Xcode |
| [Unreal Engine XR](https://graspable.dev/templates/unreal-xr.md) | Premium, native (Unreal Engine 5) | A scene for OpenXR headsets whose level is a Python script your Unreal Editor builds |

The native templates need an engine on your computer; see [Native XR](https://graspable.dev/docs/native-xr.md).

## React XR

![The React XR template as it first opens](https://graspable.dev/site/templates/react-xr.webp)

[See the React XR template](https://graspable.dev/templates/react-xr.md).

The project starts with a bench in front of you: a cube, a can and a ball to pick up and throw, a **New ball** and a **Tidy up** button, a sign, and a basket that counts what lands in it. It works with controllers, tracked hands and a mouse, and has an **Enter VR** and an **Enter AR** button; in AR the bench stands in your own room. Each part is a small file the agent reuses: things you can pick up, solid boxes, buttons, text, sound. It uses React Three Fiber for the 3D scene and `@react-three/xr` for headsets. The physics library `@react-three/rapier` and the helper library `@react-three/drei` are installed too.

With tracked hands, a thumbs-up adds a ball, like the **New ball** button. In AR, the floor, walls, tables and furniture your headset finds in the room become solid: a ball you throw bounces off your real table and rolls across your real floor. See [Gestures and the real room](#gestures-and-the-real-room).

## Tabletop AR and Unity AR tabletop

![Signal Garden's miniature outpost, caretaker robot and three relay controls](https://graspable.dev/site/templates/web-ar.webp)

[Tabletop AR](https://graspable.dev/templates/web-ar.md) starts with **Signal Garden**: a 90-second rescue film and a puzzle where you turn three relays to guide a courier home. It includes animated models, physically based materials, original Gaussian terrain and a musical score. Watch it from the film camera or move around the miniature yourself. Pause, seek, mute and hide the controls; the scene remains editable.

In a compatible WebXR browser, place the garden on a detected surface. Other phone browsers use the included mission mat: print it or show it on a second screen, then point the camera at it. The board disappears and playback pauses when the mat leaves view. This is image tracking, so it needs the mat throughout the experience.

![The native Signal Garden scene in Unity](https://graspable.dev/site/templates/unity-ar.webp)

[Unity AR tabletop](https://graspable.dev/templates/unity-ar.md) contains the same film, puzzle and assets. It has separate phone AR and Quest configurations. The phone version uses ARKit on iOS and ARCore on Android; the Quest version uses OpenXR passthrough. Choose the target in Unity before building. Graspable exports the Android build without automatically installing it on a connected device.

See [AR films and tabletop games](https://graspable.dev/docs/augmented-reality.md) for device requirements and the editing workflow.

## The three world templates

![The Splat World starting scene](https://graspable.dev/site/templates/splat-world.webp)

[Splat World](https://graspable.dev/templates/splat-world.md)

![The World Explorer starting scene](https://graspable.dev/site/templates/world-explorer.webp)

[World Explorer](https://graspable.dev/templates/world-explorer.md)

![The World Game starting scene](https://graspable.dev/site/templates/world-game.webp)

[World Game](https://graspable.dev/templates/world-game.md)

Splat World, World Explorer and World Game start inside a **world**: a place generated by World Labs and shown as Gaussian splats with the Spark renderer. To get a different place, ask for it, for example "make this a greenhouse at dusk". See [Generated worlds](https://graspable.dev/docs/worlds.md).

- **Splat World** starts in a sunlit loft. You look around, teleport and put things in it. They sit on the world's real floor and tables, at real size.
- **World Explorer** starts in the same loft, but solid: floors hold you, walls and furniture stop you. It comes with info points and a guided tour. On a flat screen you walk with W A S D; in the headset with the thumbstick or by teleporting.
- **World Game** starts in a tavern with a throwing game: knock the mugs off the bar, ring the targets, keep score. Balls bounce off the room itself.

A world is a folder in the project, `public/worlds/<name>/`. Switching to another world is one word in the code, and the agent does it for you after generating one.

## WebGPU Splats

![The WebGPU Splats starting scene: a spiral galaxy of splats](https://graspable.dev/site/templates/webgpu-splats.webp)

[WebGPU Splats](https://graspable.dev/templates/webgpu-splats.md)

Gaussian splats drawn with Radix, the WebGPU splat renderer from the makers of Spark. Every splat in the scene is projected, sorted and drawn together on the graphics card, so a recent computer shows one to two million of them smoothly. The project starts with a spiral galaxy of 600 000 splats that code makes on the graphics card every frame.

- **Splats from a file:** put a `.spz` or `.ply` capture in `public/splats/` and ask for it. Radix does not read `.splat`, `.ksplat` or `.sog` files.
- **Splats made by code:** a generator is a short shader that makes each splat from its number: galaxies, fractals, particle fountains, flowers that open as you come near. Ask for what you want to see; the agent writes the generator.
- **In a headset:** WebGPU draws on computers and phones, and in a headset whose browser can draw a headset session with WebGPU: on a Quest, switch on the WebGPU and WebXR experiments in the browser's `chrome://flags` and restart it. Otherwise, and in the preview's emulated headset, the same scene runs on Radix's WebGL2 path, which handles a few hundred thousand splats at a headset's frame rate. Add `?gpu=webgpu-gl` or `?gpu=webgpu` to the address to choose one.

This template has no physics engine. For physics, start from React XR or XR Game.

## Scanned Room

![The Scanned Room template as it first opens](https://graspable.dev/site/templates/scanned-room.webp)

[See the Scanned Room template](https://graspable.dev/templates/scanned-room.md).

The project starts inside a 3D capture of a real seating corner, at real scale in metres. A reticle lies on the real floor, walls and furniture where you point; you can move around the room and place objects that sit on those surfaces. Use it for measuring tools, furniture planning, guided tours and training on site.

You can replace the room with your own scan. The template says what the file needs: metres, y up, the floor at height 0.

The room that ships with the template is a capture from the Eyeful Tower dataset, copyright (c) Meta Platforms, Inc. and affiliates, under the MIT License. The licence text is in the project beside the file.

## Product Studio

![The Product Studio template as it first opens](https://graspable.dev/site/templates/product-studio.webp)

[See the Product Studio template](https://graspable.dev/templates/product-studio.md).

The project starts with a chair on a photo-studio stage: soft light, reflections and a contact shadow. A panel lets people choose colours and materials, see an exploded view, read callouts, and place the product at its real size in VR or in their own room. To show your own product, give the agent its 3D file and say what its parts are.

## XR Game

![The XR Game template as it first opens](https://graspable.dev/site/templates/xr-game.webp)

[See the XR Game template](https://graspable.dev/templates/xr-game.md).

The project starts in an arcade booth with a can-knockdown game: pick up a ball, throw it, score. Physics, grabbing and throwing, a scoreboard, a timer and sounds are ready, so a request like "turn it into basketball" is a small change.

With tracked hands, a thumbs-up after a game starts the next one, like the **START OVER** button.

## Hands & Spatial UI

![The Hands & Spatial UI template as it first opens](https://graspable.dev/site/templates/spatial-ui.webp)

[See the Hands & Spatial UI template](https://graspable.dev/templates/spatial-ui.md).

The project starts with a floating panel of sliders, buttons and a toggle that drive an object in front of you. Everything works by pinching and poking with your hands, with controllers, and with a mouse. Use it for dashboards, data in space, instruments and tools.

## Multi-user

![The Multi-user template as it first opens](https://graspable.dev/site/templates/multiuser.webp)

[See the Multi-user template](https://graspable.dev/templates/multiuser.md).

The project starts as a room that several people open at the same time. Everyone sees the others as avatars with a name plate, a head and two hands, can pick up the same objects on the table and press the same board on the wall, and all of it stays in step. It works in a headset and on a flat screen together.

In the preview, everyone who opens the same preview address is in the same room. Once you [publish](https://graspable.dev/docs/publishing.md) the app, everyone who opens it meets in the app's own room; add `?room=name` to the address for a separate one. Up to 16 people share a room, and what was changed stays for a day after the last person leaves.

The shared state travels through Graspable's relay; nothing else leaves the app. You can ask the agent to make any of your own objects shared: "make the score shared between everyone".

## Cross-platform XR

![The Cross-platform XR template as it first opens](https://graspable.dev/site/templates/crossplatform.webp)

[See the Cross-platform XR template](https://graspable.dev/templates/crossplatform.md).

One WebXR app for every device. Where the device has passthrough (Meta Quest, Android XR, phones) the app is seen in your own room, placed on real surfaces. Where it has not (Apple Vision Pro's browser, a computer) the same scene stands in a photographed room. The start scene is a lounge chair with a side table that you can place, turn and refinish, beside a panel with three tabs: the product, live data fetched from the internet, and what the app found out about the device it runs on.

It looks real: the furniture models and the room's light are photographed (Poly Haven, public domain), and every surface is a physically based material. The panel is built with uikit, so it is laid out like a web page and used with controllers, bare hands, look-and-pinch, or a mouse. On glasses with a narrow view the panel becomes a small card near the middle.

A published app from this template can be installed from the browser, and its one address serves every device.

## Panel app

![The Panel app template as it first opens](https://graspable.dev/site/templates/expo-quest.webp)

[See the Panel app template](https://graspable.dev/templates/expo-quest.md).

Not every headset app is a 3D scene. Meta Quest, Meta VR Glasses and Android XR run ordinary Android apps as floating panels in the home space, and a panel is often the right shape for a tool: a list, a dashboard, a reader. This template is an Expo project (React Native) that starts as a to-do list laid out for a panel, with big targets you point at from a distance. It runs as a web page in the preview and anywhere else, and builds as an Android app for the headsets with Expo's own tools. Because it is plain JavaScript, it works with a Cloud Agent too.

## Meta glasses app

![The Meta glasses app template as it first opens](https://graspable.dev/site/templates/meta-glasses.webp)

[See the Meta glasses app template](https://graspable.dev/templates/meta-glasses.md).

A phone app for Meta AI glasses: Ray-Ban Meta Gen 1 and Gen 2, Ray-Ban Meta Optics, Oakley Meta HSTN and Vanguard, and Meta Ray-Ban Display. It is an Expo project on the Meta Wearables Device Access Toolkit and shows everything the toolkit can do, one screen each: registering with the Meta AI app, the camera stream and photos, a screen on Display glasses, the glasses' inputs, motion and speech, launching by voice, and mock glasses for development without hardware. The preview runs it against the glasses emulator; your own glasses need the app on a phone. See [Meta glasses](https://graspable.dev/docs/meta-glasses.md).

## Glasses field notes

![The Glasses field notes template as it first opens](https://graspable.dev/site/templates/glasses-journal.webp)

[See the Glasses field notes template](https://graspable.dev/templates/glasses-journal.md).

A finished-looking app for glasses without a display: Ray-Ban Meta Gen 1 and Gen 2 and Oakley Meta. You look through the glasses on your phone in a lens-shaped viewfinder, save a moment with the shutter or a tap on the temple, say a note and it is written under the photo, and hear "saved" in the glasses' own speakers. A line across the view levels the horizon from the glasses' motion sensor. Moments stay on the phone. Start here when you want an app people would use; start from the Meta glasses app when you want to see every capability on its own. See [Meta glasses](https://graspable.dev/docs/meta-glasses.md).

## Display glasses web app

![The Display glasses web app template as it first opens](https://graspable.dev/site/templates/display-glasses.webp)

[See the Display glasses web app template](https://graspable.dev/templates/display-glasses.md).

A web app for Meta Ray-Ban Display glasses, built with Meta's UI Toolkit: 600 by 600 pixels, moved through with the Neural Band or the touchpad, no pointer. It starts with a timer, guided steps, the glasses' senses and a note by voice. Publish it and the glasses install it from a code. See [Meta glasses](https://graspable.dev/docs/meta-glasses.md).

## Unity for Quest, Android XR and XREAL

![The Unity for Quest starting scene](https://graspable.dev/site/templates/unity-quest.webp)

[Unity for Quest](https://graspable.dev/templates/unity-quest.md)

![The Unity for Android XR starting scene](https://graspable.dev/site/templates/unity-androidxr.webp)

[Unity for Android XR](https://graspable.dev/templates/unity-androidxr.md)

![The Unity for XREAL starting scene](https://graspable.dev/site/templates/unity-xreal.webp)

[Unity for XREAL](https://graspable.dev/templates/unity-xreal.md)

Three native Unity 6 projects with the same Graspable kit and a different headset target each. The start scene is mixed reality: the real room shows through, a small table holds a ball you can grab and a button you can press, and you place a marker on any real surface by pointing and pinching. The kit has scripts for labels at a readable size, buttons, grabbable things, placing on real surfaces, and a hint that follows you. See [Native XR](https://graspable.dev/docs/native-xr.md).

## Apple Vision Pro

![The Apple Vision Pro template as it first opens](https://graspable.dev/site/templates/visionos.webp)

[See the Apple Vision Pro template](https://graspable.dev/templates/visionos.md).

A native visionOS app in Swift: a window with controls and an immersive space around you, in which a shape spins and can be pinched and dragged. SwiftUI for the window, RealityKit for the space, built and run in the visionOS Simulator by your own Xcode. See [Native XR](https://graspable.dev/docs/native-xr.md).

## Unreal Engine XR

![The Unreal Engine XR template as it first opens](https://graspable.dev/site/templates/unreal-xr.webp)

[See the Unreal Engine XR template](https://graspable.dev/templates/unreal-xr.md).

An Unreal Engine 5 project whose level is written as a Python script and built by your own Unreal Editor, so the agent can change it and you can read what changed. It starts with a workbench on a concrete floor in photographed materials. See [Native XR](https://graspable.dev/docs/native-xr.md) for what it does and does not do yet.

## Gestures and the real room

The React XR and XR Game templates recognise gestures, so you can ask the agent for things like "a thumbs-up starts the next round" or "nod to confirm".

- **Hand gestures**, with tracked hands: pinch, point, fist, thumbs-up, open palm and spread fingers. Each one is reported when it starts, while it is held and when it ends, for the left and the right hand.
- **Head gestures**, in a headset: a nod and a shake of the head.

Controllers and flat screens make no gestures, so keep a button for anything a gesture does.

In the React XR template, AR also uses the room you are in. The surfaces your headset detects (floor, walls, table tops) and the room shapes it scans become solid, so things land on your real table and bounce off your real walls. On Quest 3 and Android XR headsets, real things can also hide virtual ones behind them, using the headset's depth sensing. That costs some performance, so it is off until you ask for it: ask the agent to "turn on occlusion". The preview in Graspable shows the scene without occlusion.

## How a web project is laid out

Every web template has the same layout. There is no `src` folder. The premium templates add ready-made parts under `components/` and `lib/`, and files such as worlds, a room or a product under `public/`.

| File | What it is |
|---|---|
| `App.jsx` | The root of your app. Most changes start here |
| `App.css` | Styles |
| `components/` | Where the agent puts additional parts of the scene |
| `index.jsx`, `index.html` | The entry point |
| `package.json`, `vite.config.js` | Packages and build settings |
| `tests/xr/` | Your XR recordings. See [XR tests](https://graspable.dev/docs/xr-tests.md) |

The Panel app template is an Expo project: `App.tsx` is the root, `app.json` the app's settings. The native templates are laid out as their engine expects; [Native XR](https://graspable.dev/docs/native-xr.md) has the table.
