Building

Publish and share

Put your app on the web at an address of its own, keep some apps private, and let other people continue from what you made.

Every project can become an app on the web. Graspable builds it, hosts it and gives it an address of its own. People open it in a browser or in a headset; nothing needs to be installed.

Publish an app

Open the project and choose Publish in the header. Give the app a title and, if you like, a line about it, then choose Publish. Graspable builds the project, uploads it and shows the address.

Every app has a name, and the name is its address: an app named quiet-otter-482 is at https://quiet-otter-482.graspable.cloud. A new app gets a random name that is easy to say. To choose your own, open Settings → Published apps and choose Rename: 3 to 40 lowercase letters, digits and dashes, and not a name another app already has. Renaming changes the address; the old one stops working.

Publishing again from the same project updates the app at the same address. From a terminal, grasp publish <project> does the same, and --name asks for a name (see CLI).

If a file upload loses its connection or the hosting service has a temporary error, Graspable retries that file up to twice. If publishing still fails, your previous published version stays available. Permission and size errors stop the upload immediately.

Each app runs at its own address, apart from every other app and from graspable.dev, so it can use the headset but cannot reach your account or anyone else's app.

Your published apps are listed under Settings → Published apps, each as a card with its picture, its views and likes and its address. Under Manage on a card you can rename the app, make it private or public, allow or stop people continuing from it, or take it down.

Your handle

A handle is optional. Choose one under Settings → Graspable account: 3 to 30 characters, lowercase letters, digits, _ and -. With a handle, your public apps are listed on your page, graspable.dev/@you, and each app's page says who made it.

Community: views, likes, follows and collections

A public app can be found by other people. Community in the app (the button beside Settings on the Projects page) lists public apps: the most viewed, the most liked, the newest, and those of the people you follow. On a card you can:

  • Open the app, or its page on graspable.dev.
  • Like it. One like per account; click again to take it back.
  • Follow the person who made it. What they publish next is under "People you follow".
  • Save it to a collection. A collection is a named list of apps with a page of its own (graspable.dev/c/…) that you can share; it also appears on your handle's page.
  • Continue from it, when its maker allows that.

Liking, following and saving need your Graspable account. Looking needs nothing.

Being found: category and tags

Under Settings → Published apps, a public app has a line "In the gallery as": choose one category (Games, Education, Training, Product, Architecture, Art, Tools, Social, Science or Other) and up to five tags, separated by commas. Tags are lower case, two to twenty-four characters, letters, digits and dashes.

The gallery on graspable.dev/made lists every public app. People search it by name, tag or maker, filter it by category or by clicking a tag, and order it by trending, most viewed, most liked or newest. Trending is this week's views and likes, a like counting as five views. The home page shows the four apps most opened and liked this week, and the rest of the week's trending ones in a row beside them.

Your app's page

Every public app has a page on graspable.dev, at graspable.dev/a/<its id>. The address never changes, whatever you rename the app to. The page shows the app's pictures and films, what it is about, who made it, where it runs, its views and likes, and buttons to open it, like it, save it to a collection, share it and, when you allow it, continue from it.

You fill the page in on the website: sign in, open Account → Published apps, and choose Edit its page on an app.

  • Pictures: up to 8, PNG, JPEG or WebP, up to 5 MB each. A 16:9 picture fits best. Move them into the order you want; the first is shown large.
  • Films: up to 2, by the address of their page at YouTube or Vimeo. A film is loaded from that service only when a visitor starts it.
  • The picture in lists: choose Use in lists on one of your pictures, and the gallery and shared links show that one. Without a choice, it is the picture taken when you published.
  • About this app: up to 4,000 characters. Leave an empty line between paragraphs.
  • Where people send feedback: an https address, such as a form, a forum or your Discord. Without one, the page points people to your profile and its links.

The title, the one line under it, the category and the tags are in the app's settings, under Published apps. With no pictures of your own, the page shows the picture taken when you published.

Sharing a public app’s graspable.cloud address or its page on graspable.dev shows a large preview with its saved picture, title and public author name. Change Use in lists to choose the picture, or publish again to use a new project capture. Apps without a picture show a title card. Social networks may keep an older preview until they refresh their copy; existing posts do not always update. Private apps do not have public preview images.

The gallery serves smaller copies of published project captures to fit your screen. Publishing a new capture gives it a new image address, so it can replace the previous cached picture.

Nothing checks a picture beyond that it is a picture. The rules for apps cover their pages too, and every page has Report this app.

On graspable.dev

The same works on the website. Sign in at the top of graspable.dev with the account you use in the app (GitHub, Google, or a link by email), and every app's page has Like and Save, and every person's page has Follow.

Your page (graspable.dev/@yourhandle) shows who you are, your apps with their pictures, how often they were viewed and liked, your followers, your public collections, and the month you joined. Under Account → Profile on the site (graspable.dev/account/profile) you set:

  • your handle and name;
  • a few words about you, up to 280 characters;
  • where you are, up to 60 characters;
  • up to five links, which must be https addresses. Each is shown with the name you have on that service (GitHub, X, YouTube, LinkedIn, Bluesky, Mastodon, Instagram and others) or by its host, and they are how people reach you: your email address is never shown;
  • what you build with, up to eight from a list of headsets and tools;
  • up to three of your public apps to show first on your page;
  • whether your page says you are open to work;
  • whether to show the picture of the GitHub or Google account you sign in with. It is off until you switch it on, and no other picture can be set.

Under Account → Collections you choose which collections anyone can see, and remove a collection.

  • Views are counted per app, each time it is opened at its address, and shown on its page.
  • The picture on a card is the project's picture: the one you chose with Capture in the preview, or else the built app as a browser shows it when you publish. An app published before 0.12 gets its picture the next time you publish it.
  • The home page of graspable.dev shows the eight most viewed community apps. Nothing is placed there by hand.

A private app is in none of these lists and cannot be liked or collected.

Private apps

On Builder and higher, an app can be private: it opens only with a link that holds a key. The key is shown once when you publish; make a new one under Settings → Published apps if a link got out. Private apps do not appear on your page and are not indexed.

Continue from an app

A public app shows a small Made with Graspable badge in the corner. It leads to the app's page on graspable.dev, where Continue from this app opens the app as a new project on the computer of whoever clicks it, with its editable source, ready for their next request. If you have not installed Graspable yet, download it.

Every public app allows this unless you switch it off under Settings → Published apps (Builder and higher); the badge goes away with it. The copy records which app it continued from.

Native projects

A Unity project or an Apple Vision Pro project runs on the device, not in a browser, so there is nothing to open at its address. Publishing one runs its check first, and what goes live is a page with the picture that check took (play mode in Unity, the visionOS Simulator for Vision Pro) and the project's source. People continue from it like from any app; to build it they need the same engine you do. See Native XR. The native examples under Made in Graspable are published this way.

The headset app, as a download

On Pro and higher, a Unity or Unreal Engine project can offer its headset app with the page. Choose Build for headset in the preview pane first, then Publish with Offer the headset app as a download ticked. The app's address, its page on graspable.dev and its example page then show a download button with the file's size and its SHA-256, so anyone can check that what they got is what you published.

  • The file is the Android app (.apk) from your last build. It is a test build signed with your computer's development key, not a store release, and the page says so.
  • A Meta Quest installs it only with developer mode on, from a computer: with Graspable, Meta Quest Developer Hub or adb install. For other Android headsets and glasses, follow their maker's instructions for installing an app file.
  • Publishing again without a new build does not send the file again. Settings → Published apps removes it.
  • One headset app per published app: up to 500 MB on Pro and 1 GB on Studio. A download counts as one visit.
  • An Apple Vision Pro app cannot be handed out as a file. Use TestFlight or the App Store and add the link, as below.

Store pages

When your app is in a store, add the address of its page there under Settings → Published apps → Store pages: the Meta Horizon Store, Google Play, the App Store, or a TestFlight invitation. The app's pages then show a button for each. This works on every plan and for every kind of app. Only addresses of those stores are accepted.

Connectors in your app

On Builder and higher, a published app can use one of the services you connected under Account → Connectors while it runs: read rows from your spreadsheet, add a line to it, post to your channel. The people who open the app sign in to nothing. The app calls a tool, and Graspable makes the call as you, with the values you pinned in place of whatever the app sent, so the app can only ever reach what you chose.

  1. Publish the app, then open Account → Published apps → Edit its page on graspable.dev and go to Connectors.
  2. Choose Grant a tool: a service you connected, one of its tools, and the values the app may not change: the spreadsheet, the folder, the channel.
  3. In the project, the app calls the tool with the helper every template has:
import { connector } from './lib/connector.js'
const rows = await connector('google_sheets', 'google_sheets-get-values', { range: 'A1:C20' })

The call goes to the app's own address, _connect/<service>/<tool>, so the app holds no key and no sign-in. In the preview on your computer the same grants work, through the Graspable app, once the project is published. Ask the agent for what the app should do with your data; it uses the helper and tells you which tool to grant.

  • Every tool that takes arguments is granted with at least one pinned value, because anyone who can reach the app can call the grant with any argument you did not pin. Tools that update, delete, share or change settings are not offered to apps.
  • Each call costs you 0.2 Credits, whether the service answers with a result or with an error. Each grant has its own limit of calls a day, 200 unless you change it, up to 2,000; the app also cannot make more than 30 calls a minute from one visitor or 600 a minute in all.
  • Switching a grant off stops the app's calls at once. Disconnecting the service stops them all. An app that rests for the month makes no calls.
  • An app's visitors can only ever call the tools you granted, with your pinned values. They cannot see your account, your other services or your connection. Pin everything a stranger should not choose.

AI in your app

On Builder and higher, a published app can ask an AI model while it runs: answer a visitor's question, say what is in front of them from a picture of the scene or a camera frame, or hold a spoken conversation. The people who open the app need no key and no account, and no key is ever in the app. You pay for it from your Credits.

  1. Publish the app, then open Account → Published apps → Edit its page on graspable.dev and go to AI in this app.
  2. Switch it on and choose the model. You can add a short instruction that is sent before everything the app sends ("You are the guide of this museum. Answer in two sentences."); the app cannot change it or leave it out.
  3. In the project, the app asks with the helper every template has:
import { ask, snapshot, listen, speak } from './lib/ai.js'
const answer = await ask('What am I looking at?', { image: snapshot(gl, scene, camera) })
speak(answer)

The request goes to the app's own address, _ai/chat, and Graspable asks the model for you. listen() and speak() use the browser's own speech recognition and voice, so a spoken conversation needs no other service; not every browser has them (some send the speech to their maker's service to recognise it), and the helper says when one is missing. In the preview on your computer the same AI answers, through the Graspable app, once the project is published. Ask the agent for what the app should do; it uses the helper and reminds you to switch AI on.

  • You pay by what each request costs, at the same rate as the Graspable agent on Credits: one Credit for every $0.10 the model provider charges. Each model's price, in Credits per million tokens (a token is about three quarters of a word), is shown where you choose it. Small requests add up over the day and are charged in tenths of a Credit.
  • Each app has a daily limit in Credits: 20 unless you change it, up to 500. When it is reached, or your Credits run out, the app gets a plain message instead of an answer until the next day. Answers are kept short: about 750 words unless the app asks for more, and about 1,500 at most. A request can carry up to four pictures.
  • One visitor can make up to 10 requests a minute, and the app 120 a minute in all.
  • Graspable keeps only counts of your app's requests (how many, how many pictures, tokens in and out, what they cost), never what was asked, a picture or an answer. The model provider receives the request to answer it.
  • Switching AI off stops the app's requests at once. An app that rests for the month makes none.
  • Anyone who can reach the app can ask through it. Choose the instruction and the daily limit with that in mind.

How many, and how much

Each plan comes with a number of published apps, private apps, visits per month, a size per app and, for native projects, a size for the headset app:

Plan Apps Private Visits a month Size per app Headset app
Explorer 2 — 2,000 60 MB —
Builder 10 3 25,000 150 MB —
Pro 30 10 100,000 250 MB 500 MB
Studio 100 50 500,000 500 MB 1 GB

An app that reaches its month's visits rests until the next month: its page says so instead of showing the app. Nothing is deleted. Enterprise plans have no limits; use the Contact sales button on the pricing page.

Rules, and reporting an app

You are responsible for what you publish. Apps that deceive people, harm their devices, break the law or copy someone else's work are taken down. Anyone can report an app at graspable.dev/report; a person on the team reads every report.

What is sent

Publishing sends the built app and the project's source for people who continue from it. The source archive leaves out Git metadata, project memory, dependencies and generated build folders. Generated engine and film folders are omitted only at their project paths; source folders with matching names elsewhere are kept.

It also leaves out files named .env, .env.* (including examples), .npmrc, .netrc, .pypirc and .yarnrc.yml, at every folder depth, regardless of letter case. These are filename exclusions, not a scan for secrets: credentials embedded in code, assets or other files can still be published. Keep private credentials out of the code and assets you share.

The exclusions apply to new publishes. Previously uploaded source archives are not rewritten.