Blog
Guides to building for WebXR, how we build Graspable, and what you can build with it.

Product 3 min read
Lessons students can step into
Three lessons made in Graspable that students open from a link: a solar system they pick up, chime bars they play with their hands, and a guided tour through a generated greenhouse.

Product 4 min read
XR training for industry, by describing it
Five working examples of XR training and operations apps made in Graspable: a guided pump shutdown, a machine start-up console, a gearbox design review, a technician work-order panel and pick-by-vision for a warehouse.

Product 5 min read
Build inside XR by talking
Graspable now has voice. Speak a request instead of typing it, hold a conversation with the agent and hear its answers, and keep talking after you put the headset on.

Product 6 min read
Design: one editor for the panels in your 3D scene
Graspable 0.21 brings Design, an editor for the 2D interfaces inside a 3D scene. Every change is written into your code, the agent works on what you select, and one panel can be written for Apple Vision Pro, Unity headsets and Meta Ray-Ban Display.

Engineering 4 min read
A million Gaussian splats on WebGPU, now in the headset
The WebGPU Splats template draws splats with Radix, which sorts every splat on the graphics card each frame. Since 0.20.1 a headset browser that offers WebGPU for immersive sessions draws both eyes on WebGPU too.

Product 4 min read
Graspable 0.19.8: gestures, the real room, and AI inside your apps
Graspable 0.19.8 gives web projects hand and head gestures and physics that meets your real furniture, and lets a published app ask an AI model about what it sees, with no key anywhere in the app.

Product 5 min read
Graspable 0.19.7: model in Blender and build the scene at the same time
Graspable 0.19.7 lets the agent split a request between helpers that work side by side, so a model can take shape in Blender while its interactions are written. Tidal Observatory is now a room you walk into, built that way.

Product 6 min read
Graspable 0.19.6: a Blender model in a WebXR scene, and a faster USD viewer
How the Graspable agent used a local copy of Blender to model, texture, animate and export Tidal Observatory, how the result is checked in an emulated headset, and why USD scenes now open without conversion.

Engineering 10 min read
Build an editable WebXR exhibit with your coding agent
An assembly study in one React Three Fiber component: select parts, separate them and inspect them in 3D or WebXR. Its source is below, and your coding agent can apply it through Graspable’s MCP tools.

Product 4 min read
Build an XR experience with NVIDIA OpenUSD assets
Graspable 0.19 brings NVIDIA’s SimReady library to Pro. Import the editable source, inspect an object in VR, or turn a warehouse layout into a playable rehearsal.

Guides 7 min read
Choosing an AI builder for XR
What an AI builder for XR has to do, how Graspable does it, and the few cases where another tool fits better. Check device support, editable output and testing before you choose.

Product 3 min read
Graspable 0.18: films you can step into
Animate a scene with your agent, publish an immersive film, or put a rescue game on your table. Graspable 0.18 adds tabletop AR and Claude subscription sign-in.

Product 3 min read
Make a film inside your 3D scene
Graspable brings together an animation workspace for objects, camera shots and sound, with editable scenes and films you can share on the web.

Product 3 min read
Generate project images through confidential Routstr
Graspable can generate images through a confidential Routstr session, with a price you approve and checks before the image becomes a project asset. Two live tests cost 36.381 sats.

Product 4 min read
Speech and gaze you can edit frame by frame
Import timed mouth cues, key a character’s named bones, and let an agent make changes to the same saved take. What works today, and what our native character study taught us.

Engineering 7 min read
A router that cannot read your prompts
Graspable can now use a Routstr node in confidential mode, built on Juraj Bednar's protocol: the node relays an encrypted connection the agent holds with the model provider itself. What it protects, what we measured, and what it costs.

Product 3 min read
A chair configurator in a headset, from one request
A shell chair in a dark showroom: point at a swatch, pull the trigger, and the chair and its price change. It was built in one run, and the request is here word for word.

Product 4 min read
A furniture catalogue loaded from the internet, placed in your room
Pick a scanned piece of furniture from a live catalogue, see it at its true size, and place several in your own room. It was built in one run, and the request is here word for word.

Product 3 min read
A penthouse sales suite in Unreal Engine, built from a description
The living room of an apartment that is not built yet, for buyers to walk through in a headset. It was made as an Unreal Engine 5 project in two runs, and the first request is here word for word.

Product 4 min read
A shelving configurator for Apple Vision Pro, from one request
Choose width, height, finish and extras in a window, read the parts and the price, and see the shelf at real size in your room. A native app built in one run; the request is here word for word.

Product 27 min read
How the National Theatre in Prague became a place to walk through together
An open 3D model of the Národní divadlo by Lukáš Eršil was turned into a multi-user WebXR app in seven requests. Here is what it does, and every request word for word.

Guides 5 min read
Agents, wallets and cameras: staying in charge of your own
An AI agent that reads the web, a wallet it can spend from, and a headset with cameras on your face each widen what can go wrong. A practical list of what to check, for people who use such tools and for people who build apps for them.

Product 3 min read
Profiles, follows, likes and collections
Graspable has a community side now: a public page for what you have made, people to follow, apps to like and keep in collections, and a gallery of everything public. Here is what each part does.

Engineering 4 min read
An agent with a wallet and a budget
Some requests need something that costs money. Graspable can let the agent pay for an outside service from a wallet of its own, inside limits you set, with every purchase and every refusal written down on your computer.

Product 4 min read
Pay for Graspable with crypto: Credits, or a plan paid ahead
You can now pay for Credits or for a Builder, Pro or Studio plan from your own wallet, in Bitcoin, Ether, Solana or USDC on Base. No card and no identity check. Here is how it works and what is different from paying by card.

Product 3 min read
An address for every app, and the request behind every example
What changed in Graspable from 0.9.36 to 0.9.45: published apps live at their own address on graspable.cloud, connected apps are chosen per project, your Credits are always in view, and every example on the site now comes with the request that built it.

Guides 5 min read
Build for Meta VR Glasses on the web: eyes and hands first
Meta VR Glasses ship without controllers and use gaze to aim and a pinch to select, in a narrower view than Quest 3. What that means for a WebXR app, how to try it in an emulator today, and what to change in a scene built for controllers.

Engineering 4 min read
What Graspable sends home, and what it never does
How a desktop app that reads your prompts and your code can report its own errors and count its own use without any of that leaving your computer: the rules we set, where they live in the code, and how to switch it all off.

Engineering 8 min read
Performance of Gaussian splats in WebXR: what we measured and what we chose
Load time, memory and frame time of two 500,000-splat worlds in Spark, measured on a laptop and in an emulated headset, not on a real one, and the defaults we chose for our templates and why.

Guides 8 min read
Gaussian splats, explained for people who build things
What a Gaussian splat is and is not, how it is drawn, the file formats you will meet, what splats are good and bad at, and what that means for a WebXR experience built on one.

Product 4 min read
Graspable now generates worlds with World Labs
Ask for a place in plain words and the agent generates it with World Labs Marble and puts it in your project: what you get, what it costs in Credits, and the three templates that use it.

Engineering 9 min read
How our world templates work
The layer shared by Splat World, World Explorer and World Game: one World component, raw units to metres, the collider as a physics mesh, a flattened floor, light from the splat, walking, throwing, and how the agent switches worlds.

Engineering 7 min read
Spark: the renderer behind our splat templates
What Spark is, why a Gaussian splat renderer that lives inside a normal three.js scene matters for a project an agent builds, what moving from Spark 0.1 to 2 changed, and how our templates set it up.

Guides 6 min read
How to test a WebXR app without a headset
Emulate a headset in the browser with IWER: install it, move the headset and controllers from code, use a synthetic room for AR, record a session and replay it.

Guides 6 min read
Hand tracking or controllers in WebXR, and how to support both
How WebXR describes hands and controllers, what each can and cannot do, and how to write one React Three Fiber scene that works with either.

Guides 6 min read
WebXR hit testing: how to place objects on real surfaces
What a WebXR hit test is, how to request one, how to read its result, and a working reticle in React Three Fiber that places objects on floors and tables.

Guides 7 min read
A performance budget for WebXR on Quest 3
How much time a frame has in the Meta Quest Browser, how to find out whether the CPU or the GPU is the limit, and what to change in a React Three Fiber scene.

Product 2 min read
Describe a scene, step inside it
Graspable is now a desktop studio. You say what you want, an agent builds it as a real project on your computer, and you try it on a headset.

Engineering 2 min read
How Graspable checks its own work
A run is not finished until the scene builds, loads in a browser and still passes the headset sessions you recorded.