agentleFS
mirzaaghazadehmirzaaghazadeh/unity-meta-quest-skills/skills/custom/horizon-store-publish-unity/SKILL.md

horizon-store-publish-unity

Skill1 starsChanged 31 days agoMITView on GitHub

Ship a Unity Meta Quest game build to the Meta Horizon Store: one-time Developer Dashboard setup (org verification, app record, App ID and credentials, Developer Distribution Agreement), Unity release-APK settings (IL2CPP, ARM64, target API 34, keystore signing, Bundle Version Code bump), a headless build with the Unity CLI, local APK verification, and upload with ovr-platform-util upload-quest-build (OBB, asset files/DLC, debug symbols) to ALPHA/BETA/RC/production, device targeting (Future devices for Meta VR Glasses, quest3+ channel suffix), promotion between channels, and CI. Use when the user says "upload my Quest build", "push to alpha/beta/RC", "release build for the Horizon Store", "bump the version code", "sign the APK", "ovr-platform-util", "upload-quest-build", "ship to Meta VR Glasses", "target Quest 3 only", or "set up CI for Quest uploads". Complements hz-store-submit (submission, review) and unity-quest-android-build (build routes, build failures).

  • Reads credentials

The file

We split this skill into the rules it gives an agent

10 rules. About 0 are common, 2 are distinctive, and 8 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 8

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  • could be automatic: a setting could enforce it
  1. Distinctive:

    Never invent App IDs, org IDs, secrets or tokens.

    line 46
  2. Very specific:

    Keep one keystore forever: Every update must be signed with the same key.

    line 48
  3. Very specific:

    Before you build, read the latest uploaded codes: ovr-platform-util get-release-channel-data --app-id "$META_APP_ID" --token …

    line 115
  4. Very specific:

    keep the keystore and a password.txt (mode 600) in a folder outside the repo, plus a README telling the user to back the folder up twice.

    line 146
  5. Very specific:

    Option B: Unity 6 Build Profile, no custom code: Use this when the project keeps its Quest settings in a Meta Quest build profile.

    line 181
  6. Very specific:

    Run scripts/verify-quest-apk.sh <apk>.

    line 205
  7. Distinctive:

    After an upload, the build's Test results tab shows a Basic malware test and a Security Vulnerability Review, which passed within minutes …

    line 293
  8. Very specific:

    Before targeting VR Glasses, check the build: 64-bit, every required flow works with hands (a controller-required immersive app installs …

    line 339
  9. Very specific:

    Run horizon-vrc-checklist, then horizon-store-listing-assets.

    line 362
  10. Very specific:

    Every developers.meta.com/horizon/...

    line 402

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Unity build to Meta Horizon Store release channel

Made by Navid Mirzaaghazadeh · part of unity-meta-quest-skills · MIT

This skill covers the path from a Unity project to a build sitting in a Horizon Store release channel. It stops at Submit for Review, which happens only in the Developer Dashboard. Hand off to hz-store-submit for that step, and audit with horizon-vrc-checklist and horizon-store-listing-assets first.

Related skills:

  • hz-quest-verify-first (Meta). Re-verify any Quest claim with metavr docs search before acting.
  • unity-cli (Unity). Installs Editors, activates licenses, runs unity build.
  • unity-quest-android-build (this library). Quest APK build routes, toolchain checks, build troubleshooting.
  • unity-quest-dev-setup (this library). Editor and Android module setup on a new machine.
  • quest-unity-project-settings. Covers the non-release Player, XR and URP settings.
  • hz-unity-platform-sdk (Meta). Entitlement check code.
  • metavr-cli (Meta). Device install, launch and logs.

Ground rules

  1. Never invent App IDs, org IDs, secrets or tokens. Ask the user for them. Keep them in environment variables or a CI secret store, and never commit or echo them.
  2. Keep one keystore forever. Every update must be signed with the same key. Back it up outside the repo. Meta's hz-store-submit says a lost key means creating a new app entry.
  3. Version codes only go up. Each upload needs a versionCode higher than any build ever uploaded for the app, drafts and alpha builds included.
  4. Uploading to store/production, passing --publish to metavr store dist upload, and moving a build into production are outward-facing. Confirm with the user every time.
  5. Horizon Store builds are APKs, optionally with an OBB and asset files. Do not build an AAB.

Step 0: One-time Dashboard setup (user does this)

ItemWhereNotes
Org verificationDashboard > Org VerificationRequired before publishing or updating apps and before DUC recertification. Admin verification uses a government ID and "typically" takes minutes.
App recordhttps://developers.meta.com/horizon/manage/ > create appNote the App ID.
App credentialsApp > Development > APIApp ID and App Credentials (app secret). Viewing the secret needs an admin.
User token (alternative)Account > Account settings > Get Oculus platform utility token > Generate tokenTreat it like a password.
Developer Distribution Agreementhttps://developers.meta.com/horizon/manage/organizations/<ORG_ID>/legal-documents/Typical first-upload failure: "must first agree to our Developer Distribution Agreement". Only an org admin can sign it. Pause and ask the user.
Release-channel testersApp > Distribution > Release ChannelsALPHA/BETA/RC are invite-only and start empty. The default cap is 200 users; you can request up to 2,500.
Age group self-certificationApp submission > Build tab > "Age group self-certification" > Start (Dashboard, 2026-10-24; older docs: My Apps > app > Production build > App Product Detail Page)Values: Teens and Adults (13+), Mixed Ages, Children (10-12). Same values as --age-group. The last step is a legal self-certification: the user confirms it.

Sources: publish-organization-verification, publish-reference-platform-command-line-utility, publish-release-channels, age-groups (URLs at the end). The DDA URL pattern comes from Meta's hz-store-pwa skill and is unverified on the docs site. If the link fails, look under Organization > Legal Documents in the Dashboard. The agreement text itself is public: https://developers.meta.com/vr/policy/developer-distribution-agreement/ (updated 2025-04-09).

Step 1: Release settings in Unity

Set these in the project, or let scripts/QuestReleaseBuild.cs enforce them at build time.

SettingValueWhy / source
Package namecom.company.game, unique, never changesMust be unique in the Meta Quest ecosystem (unity-prepare-for-publish, publish-mobile-manifest)
Version (versionName)Human-readable, for example 1.4.0Displayed version
Bundle Version CodeInteger, strictly increasingThe system uses it to decide which build is newer. Unity's top "Version" field is not the version code (unity-prepare-for-publish)
Minimum API Level32 recommended (29-34 allowed)publish-mobile-manifest
Target API Level34, set explicitlyApps created since 2026-03-01 must target 34, and immersive apps allow only 32-34. Unity's "Automatic (highest installed)" can resolve above 34, so don't use it
Scripting BackendIL2CPPunity-prepare-for-publish
Target ArchitecturesARM64 only (clear ARMv7)The Store accepts only 64-bit apps (VRC.Quest.Packaging.6). Meta VR Glasses can't run a binary with only 32-bit native libraries at all (app-compatibility)
Target Devices (Meta XR settings)Every Quest you supportWrites com.oculus.supportedDevices. Store delivery to Meta VR Glasses is set by Future devices in the Dashboard, not by this list (Step 5a)
Install LocationAutomaticinstallLocation must be auto (publish-mobile-manifest)
Development BuildOffandroid:debuggable must be false or unset
Build App Bundle (AAB)OffStore takes an APK under 1 GB plus OBB files under 4 GB (VRC.Quest.Packaging.5)
Split Application BinaryOn only if the APK would exceed 1 GBProduces main.obb. Upload it with --obb
KeystoreCustom release keystoreVRC.Quest.Packaging.2 requires APK Signature Scheme v2. Debug-signed builds are not release builds
Assets/Resources/DevAgentSettings.assetNot in the buildMeta's Immersive Debugger keeps its AI assistant's accessToken and LAN server address there, and Unity packs everything in Resources/, git-ignored or not (observed 2026-10-25, Core 207.0.1). Move it out of Assets/ for the release build and back afterwards; unity-quest-android-build path B has the pattern
Eye Tracking SupportNone unless the app reads gazeIt adds com.oculus.permission.EYE_TRACKING; unused, it's a Security.2 risk (quest-unity-project-settings)

The Meta XR Core SDK writes the Quest manifest entries: com.oculus.intent.category.VR (required for OpenXR apps), android.hardware.vr.headtracking (required="true" for immersive apps), com.oculus.supportedDevices, and excludeFromRecents=true. Regenerate the manifest from Meta XR settings rather than hand-editing it (see hz-unity-meta-core-sdk), then check the merged manifest in the built APK in Step 4. Uploads are rejected automatically for prohibited permissions. To strip permissions that packages add, use tools:node="remove" in Assets/Plugins/Android/AndroidManifest.xml (permissions-remove).

The merged manifest also tells the system which input the app supports (app-compatibility, 2026-10-13): no hand-tracking entries means controllers only; oculus.software.handtracking required="false" plus com.oculus.permission.HAND_TRACKING means controllers and hands; required="true" means hands only. Meta VR Glasses ship without controllers, and the Store shows hand-capable titles first to people without controllers. Declare hands only once every required flow works with hands (VRC.Quest.Tracking.2).

Step 2: Choose the version code

  • Pick one scheme and keep it: the CI build number (simplest, always increases) or major*10000 + minor*100 + patch (readable, but hotfix branches can collide).
  • Before you build, read the latest uploaded codes: ovr-platform-util get-release-channel-data --app-id "$META_APP_ID" --token "$META_UPLOAD_TOKEN" (or metavr store dist channels --app-id <id>). Set the new code above all of them.
  • Pass it to the build script as QUEST_VERSION_CODE, or as --android-version-code with unity build.

Step 3: Build a signed release APK headlessly

If unity-quest-android-build is installed, use it for this step. It owns the build mechanics: the Meta Quest profile route with --android-* flags, the --execute-method route, building inside the open Editor (unity command build / build_status), dev builds, toolchain and module checks, and build-failure troubleshooting. What follows is the minimal release path. Keep one build script per project: either its templates/QuestBuild.cs or this skill's scripts/QuestReleaseBuild.cs. Both read the same QUEST_* environment variables. Watch out for one default: per that skill, Unity's Meta Quest build profile defaults to target API 32. Override it to 34.

Copy scripts/QuestReleaseBuild.cs into the project under Assets/Editor/. It sets the store-critical options from Step 1, signs with the keystore named by environment variables, builds the enabled scenes in Build Settings, and exits non-zero on failure. It was compile-checked against Unity 6000.6.6f1's managed assemblies. It doesn't apply Build Profile overrides, so if your Quest settings live in a profile, use Option B.

Secrets go in the environment (CI secret store, or a local untracked .env): QUEST_KEYSTORE_PATH, QUEST_KEYSTORE_PASS, QUEST_KEY_ALIAS, QUEST_KEY_ALIAS_PASS. Non-secret inputs: QUEST_VERSION_CODE, QUEST_VERSION_NAME (optional), and QUEST_SPLIT_OBB=1 (optional).

Creating the key and wiring it in (ask the user first; observed 2026-10-25, Unity 6000.6.6f1):

  • Unity bundles a JDK, so no install is needed: <Editor>/PlaybackEngines/AndroidPlayer/OpenJDK/bin/keytool -genkeypair -storetype PKCS12 -keyalg RSA -keysize 4096 -validity 10950 ....
  • A pattern that keeps the password off command lines:
    • keep the keystore and a password.txt (mode 600) in a folder outside the repo, plus a README telling the user to back the folder up twice;
    • have the build method read the password from that file;
    • set PlayerSettings.Android.useCustomKeystore, keystoreName, keystorePass, keyaliasName and keyaliasPass only for the build, and clear them in a finally.
  • Clearing keystoreName to "" still leaves AndroidKeystoreName: '{inproject}: ' in ProjectSettings.asset. Restore that file from git after the build.
  • verify-quest-apk.sh then reports the release certificate's subject (PASS) instead of the debug key.

The App ID for the entitlement check, set headlessly once the Dashboard app exists: unity command script eval with Oculus.Platform.PlatformSettings.MobileAppID = "<id>"; UnityEditor.EditorUtility.SetDirty( UnityEngine.Resources.Load<Oculus.Platform.PlatformSettings>("OculusPlatformSettings")); UnityEditor.AssetDatabase.SaveAssets();. It's the ovrMobileAppID field of Assets/Resources/OculusPlatformSettings.asset. Builds made before it skip any check that is gated on an App ID, so rebuild the release APK after setting it.

Option A: Unity CLI with the execute method (recommended). The flags come from the unity-cli skill, references/build-run-test.md.

unity build /path/to/Project \
  --target Android \
  --execute-method QuestReleaseBuild.Build \
  --output-path ./Builds/Quest/mygame-release.apk \
  --timeout 3600

--output-path reaches the method as -buildOutput. For an --execute-method build, the CLI takes the result from the Editor's exit code. QuestReleaseBuild.Build calls EditorApplication.Exit(1) on any failure, so a non-zero exit means a real failure. Per Unity CLI release notes, Meta Quest builds without a custom method work only through --profile: --target Android with no --execute-method fails for non-desktop targets.

Option B: Unity 6 Build Profile, no custom code. Use this when the project keeps its Quest settings in a Meta Quest build profile. unity build --list-profiles shows profile names.

unity build /path/to/Project --profile "Meta Quest Release" \
  --output-path ./Builds/Quest/mygame-release.apk \
  --android-export-type apk \
  --android-keystore-base64 "$KEYSTORE_B64" --android-keystore-password "$QUEST_KEYSTORE_PASS" \
  --android-key-alias "$QUEST_KEY_ALIAS" --android-key-alias-password "$QUEST_KEY_ALIAS_PASS" \
  --android-version-code "$QUEST_VERSION_CODE" --android-target-sdk-version 34

The unity-cli skill warns that flag values appear in the process list, so mask them in CI logs.

Option C: Raw Editor binary (no Unity CLI).

"$UNITY_EDITOR" -batchmode -nographics -quit -projectPath /path/to/Project \
  -buildTarget Android -executeMethod QuestReleaseBuild.Build \
  -buildOutput ./Builds/Quest/mygame-release.apk -logFile -

Step 4: Verify the APK before uploading

Run scripts/verify-quest-apk.sh <apk>. It uses aapt2 and apksigner from Android build-tools; set ANDROID_BUILD_TOOLS if the script can't find them. It checks: package/versionCode/versionName, minSdk and targetSdk ranges, compileSdk >= targetSdk, arm64-v8a-only native code, debuggable flag, v2 signature and a non-debug certificate, VR category, headtracking, supportedDevices, installLocation, excludeFromRecents, the declared input (controllers, hands or both), com.meta.store.defaultDeviceTargets if set, the 1 GB APK limit, prohibited permissions (FAIL) and review-required permissions (WARN). It reads minSdk from either minSdkVersion: (aapt2) or sdkVersion: (the old aapt); before 2026-10-25 it read only the second, so aapt2 runs reported a false minSdkVersion '' FAIL.

Then smoke-test on a headset with the Meta CLI (see metavr-cli):

metavr device list
metavr app install --replace ./Builds/Quest/mygame-release.apk
metavr app launch com.company.game --cold-start --wait-for-idle --measure-launch-time --verify
metavr log --tag Unity --level W

--verify scans logcat for FATAL EXCEPTION, ANR and native crashes. For the full pre-submission audit, run horizon-vrc-checklist.

Step 5: Upload to a release channel

Install the uploader with metavr tools install platform-utils, or download it from the Platform Utils CLI page (see references). Upload with scripts/upload-quest-build.sh, which refuses the production channel unless CONFIRM_STORE_UPLOAD=yes, or call it directly:

ovr-platform-util upload-quest-build \
  --app-id "$META_APP_ID" --token "$META_UPLOAD_TOKEN" \
  --apk ./Builds/Quest/mygame-release.apk \
  --channel alpha \
  --age-group TEENS_AND_ADULTS \
  --notes "Build $QUEST_VERSION_CODE: fixes X\nAdds Y" \
  --debug-symbols-dir ./Builds/Quest/symbols --debug-symbols-pattern "*.sym.so" \
  --disable-progress-bar
  • Required flags: --app-id, one of --app-secret/--token, --apk, --channel, --age-group.
  • Channels are case-insensitive. Use store for production.
  • Device targets ride on the channel: --channel "alpha:quest3+". The wrapper script adds the suffix from QUEST_DEVICE_TARGETS (see Step 5a).
  • Optional: --obb <file>, --assets-dir <dir>, --asset-files-config <json>, --draft, --language-packs-dir, --inherit-asset-files, --exclude-addons, --config <json>.
  • A successful upload prints a Build ID. Record it, since set-release-channel-build and symbol uploads use it.
  • The doc says an upload with no age group goes into draft status, yet also lists --age-group as required. Always pass it.

Full flag reference, the asset-file JSON format, DLC upload and gotchas are in references/ovr-platform-util.md.

Alternatives:

  • metavr store dist upload --app-id <id> --channel ALPHA --apk <apk> [--obb <obb>] [--notes ..] uploads a draft unless --publish is passed. It has no age-group, device-target, asset-file or symbol options (metavr 1.8.0.17.10), so prefer ovr-platform-util for release builds. Meta's hz-store-submit says to fall back to the Dashboard if it errors.
    • It needs a signed-in Meta account. Without one it stops with "not signed in — run metavr auth login first". The login is a device code, or --browser for browser SSO, and metavr init offers it too. It's the user's account, so let them run it (! metavr auth login).
    • Observed 2026-10-25: --channel LIVE sent a 97 MB Unity APK as a LIVE draft in about 3.5 minutes. It printed a Build ID and a test-results URL, plus a warning that age group self-certification is required before publishing. That draft attached to the first submission normally.
    • metavr store dist channels --app-id <id> lists the four channels and their latest builds.
  • Browser upload of a Unity APK doesn't work with Claude in Chrome: its file_upload takes at most 10 MB per call, and a Unity APK is usually around 100 MB. Use metavr or ovr-platform-util. Small TWA APKs from Bubblewrap fit.
  • Unity Editor: Window > Meta > Tools > Oculus Platform Tool uploads an existing APK and does not build it.
  • Meta Quest Developer Hub, or the Dashboard upload page.

The Dashboard upload (Distribution > Builds, observed 2026-10-24):

  • The dialog defaults to the LIVE (Production) channel as a Draft. That's the build a review needs: the submission's Build tab says "Only draft builds in the Production Channel may be attached to Submissions". A LIVE draft reaches no players until review passes and the user releases it. Testers still need the build on ALPHA/BETA, which is a separate upload or a promotion.
  • The steps are:

    1. APK, validated in the dialog ("APK validation passed");
    2. optional files;
    3. Supported devices (Quest 2, Pro, the Quest 3 family and Future devices were preselected);
    4. Review, then Start upload.

    The dialog warns "Age group self-certification is required before publishing a binary"; the upload itself works without it.

  • After an upload, the build's Test results tab shows a Basic malware test and a Security Vulnerability Review, which passed within minutes (2026-10-25). Its VRC tab stays empty until the build is submitted and reviewed.
  • On the submission's Build tab (first submission):
    • "Use Live binary" is disabled, with the tooltip "You cannot use a live binary on your first app submission";
    • for a paid app the ads question is locked ("This app cannot contain ads based on our Advertising Policy").
  • Browser automation: the APK file input is created only when the button is clicked, which opens a native dialog an agent can't use. Patching HTMLInputElement.prototype.click keeps the input on the page so a file can be attached. Files attached by automation can arrive as application/octet-stream, and the page checks the type on the input event, before change. A capture-phase input listener that relabels the file as application/vnd.android.package-archive gets it accepted. Add both again after each page reload.

Step 5a: Device targeting and Meta VR Glasses

Meta VR Glasses (spring 2027) use the same Store, entitlements and add-ons as Quest. Which builds reach which device is set per build (target-builds-by-device, 2026-09-04; app-compatibility, 2026-10-13):

WhereHow
DashboardBuild > Supported Devices: Quest 2, Pro, 3, 3S and Future devices. Select Future devices plus every Quest that should get the build. That marks it forward-compatible, and after VR Glasses ship an approved Production build reaches them with no new APK
UploadQUEST_DEVICE_TARGETS="quest3+" scripts/upload-quest-build.sh app.apk alpha sends --channel "alpha:quest3+". Specifiers: quest2only, questproonly, quest3only, quest2+, questpro+, quest3+, questpro-, joined with |. quest3+ covers the Quest 3 family, VR Glasses and future devices. CLI values override the manifest
ManifestOptional <meta-data android:name="com.meta.store.defaultDeviceTargets" android:value="quest3+"/> presets Supported Devices at upload. Use it only to restrict a build on purpose

The manifest's device list doesn't set Store targeting (observed 2026-10-25):

  • A build whose com.oculus.supportedDevices was quest3|quest3s came in through metavr store dist upload with Supported devices: Quest 2, Quest Pro, Quest 3 family, Future devices.
  • Narrow it on Builds > the build > Details > Supported devices (Quest 3 family + Future devices), then Save. It saves on a draft.
  • Also set Purchase-blocked devices in the listing's Specs, or Quest 2 and Pro owners can buy a game that won't run for them.
  • The same page lists the merged permissions and "Blocked Quest devices: Oculus Quest".
  • Unverified: it showed ACCESS_LOCAL_NETWORK and USE_LOOPBACK_INTERFACE on a build where verify-quest-apk.sh printed only three permissions. Check the Dashboard's list as well when auditing Security.2.

Rules: a build must support at least one device; LIVE must always keep one build with Future devices; every build in an app submission must be forward-compatible; a build with no targeting ("All Devices") already includes VR Glasses. Removing a device from a live build rolls that device back to the previous build, so confirm with the user first. To stop selling on a device, set Purchase-Blocked Devices in a new app submission.

Before targeting VR Glasses, check the build: 64-bit, every required flow works with hands (a controller-required immersive app installs but a Switch to Controllers dialog blocks it), key UI fits a 70° × 66° view (metavr device fov-sim enable on a Quest 3/3S/Pro), and the VRC audit passes (no VRC is specific to VR Glasses). Conflict, unverified: the release-manifest page (2026-10-15) lists vrglasses as a com.oculus.supportedDevices value, while the compatibility mode page (2026-09-04) says it is not a supported public value yet. Rely on Future devices. Details: docs/meta-reference/store-2026.md in this repo.

Step 6: Promote a build between channels

ovr-platform-util set-release-channel-build --app-id "$META_APP_ID" --token "$META_UPLOAD_TOKEN" \
  --age-group TEENS_AND_ADULTS --source-channel beta --destination-channel rc
  • Promote the build you tested. Don't rebuild for RC or production.
  • First time in production: nothing goes public until Submission Info is complete and someone clicks Submit for Review in the Dashboard. After the app is live, a build copied to production updates entitled users. Confirm with the user before you copy anything to production.
  • Release channels show up in users' Library and under "My Preview Apps".

Step 7: Before Submit for Review

  1. Run horizon-vrc-checklist, then horizon-store-listing-assets.
  2. Data Use Checkup: required if the app uses Platform SDK features such as User ID, Profile, Followers, IAP, Subscriptions or User Age Group. Auto-approval ends at first submission, so finish feature testing first (hz-store-submit covers the one-way doors). Add-ons can't be published until the DUC includes in-app purchases. The form, step by step: horizon-store-listing-assets §4.
  3. On the submission (Dashboard, 2026-10-24):
    • attach a LIVE draft build on the Build tab;
    • finish the age group self-certification there;
    • confirm the app sharing preferences (the Submission tab asks before submitting);
    • fill the Submission tab: a name only you see, the contact email, notes for the reviewer and test credentials.
  4. Submit at least 2 weeks before the target launch date. Review is technical first, then content.
  5. Hand off to hz-store-submit for the Dashboard Submission tab. Submit for Review is the user's click.

CI

See references/ci.md for a pipeline outline, secret handling, and a GitHub Actions skeleton. The order is: license activation (per unity-cli), version code from the CI run number, Option A build, verify-quest-apk.sh, upload to alpha with --draft or straight to a test channel, and archived artifacts (APK, symbols, provenance manifest). For a CI check of Meta project settings, run -executeMethod OVRProjectSetupCLI.GenerateProjectSetupReport (see quest-unity-project-settings).

Troubleshooting

SymptomLikely cause / fix
"must first agree to our Developer Distribution Agreement"An org admin signs it under Legal Documents, then retry (Step 0).
Version code rejected as too lowBump Bundle Version Code, not Version. Check get-release-channel-data.
Upload fails the manifest/SDK testManifest is checked right after each upload (VRC.Quest.Packaging.1/4). Run verify-quest-apk.sh. Usual causes: targetSdk not 32-34, debuggable, missing VR category.
Upload fails for permissionsA prohibited permission is in the merged manifest. Remove it with tools:node="remove".
Build runs on device but entitlement failsWrong App ID in Meta > Platform > Edit Settings, or a non-entitled test account. See hz-unity-platform-sdk.
APK over 1 GBTurn on Split Application Binary (OBB under 4 GB), or move content to asset files/DLC.
metavr store dist GraphQL / "Invalid parameter"Don't retry with guessed IDs. Use ovr-platform-util or the Dashboard.
Can't remove a device from the live buildLIVE must keep a forward-compatible build and every launched device must stay covered. Hide the app from a device with Purchase-Blocked Devices instead (Step 5a).

Sources

Every developers.meta.com/horizon/... page now redirects to /vr/; the links below are the final URLs.

Last verified: 2026-10-25

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.