# Set up PICO Space Pro — Unity track

Revision: 2026-10-08. This is the complete installer prompt. Read all of it before acting. Resolve current official releases when executing; the research snapshot at the end is not an installation pin.

## 1. Your mission and authorization

Set up this computer for Unity development for **PICO Space Pro (Project Swan), PICO OS 6**. Assume Codex Desktop or Claude Code Desktop is already installed. Install the toolchain, integrate the active agent host, create a fun hands-only passthrough smoke app, build its Android APK, and finish with that app visibly running in the **standalone PICO Emulator**. Keep the Emulator and app open at the end so I can play and continue prompting.

You may use shell, official downloads, browser and computer use for this setup. Carry out routine installation, project creation, configuration, building and troubleshooting yourself. Explain progress in plain language. Ask only for installation location, a meaningful mode choice, or unavoidable license/account, OS permission or restart actions. Preserve existing projects and installations. Do not uninstall anything or erase an emulator to obtain a clean start.

Required: **Unity 6.6 latest final patch (6000.6.*), latest public stable pico-cli, latest official Unity CLI, current compatible PICO Unity SDK for PICO OS 6, and latest stable standalone PICO Emulator**. Unity's Android Build Support, SDK, NDK and OpenJDK modules are necessary; **Android Studio is not**. Do not install Android Studio, its PICO IDE plugin, the PICO Spatial Editor, or the legacy **PICO Unity Integration SDK** for PICO 4/4 Ultra. Use Unity for scene authoring. Do not substitute Meta XR tooling, Unity Gaming Services CLI or a third-party package named unity-cli.

## 2. Retrieve this document reliably

Use the current canonical source URL: `https://picospaceprogram.com/setup/unity.md`. If you already have the complete contents, continue without fetching again. Save the source, URL, retrieval time, document revision (if stated), and SHA-256 checksum under the selected root once known.

If an in-app web tool fails, continue with a shell HTTP client with redirects (curl/PowerShell), then open the same canonical URL through browser/computer use. Do not fall back to the former GitHub Gist or a historical copy without explicit user approval. Do not stop because one retrieval method failed; do not reconstruct missing instructions. Only after all available retrieval methods fail ask for a paste or attachment. Verify the title, PICO OS 6 SDK exclusion, webcam hand-tracking section and completion criteria are present.

## 3. One small choice before downloading

Inspect the OS, CPU architecture, connected writable drives, and available space. Before large downloads ask once where to install tools and projects, offering a suitable internal or external `<drive>/SpaceProgram` folder and a custom folder. Reuse an existing choice in this session or verified saved state. Wait for the location choice.

In the same question, offer:

- **XR Mode — recommended:** a PICO-native standalone Android app with passthrough, tracked hands and a physical cup-toss game. This occupies the immersive app space; passthrough can still show the environment.
- **Spatial Mode:** a compact spatial experience. Verify the current SDK's Full/Shared Space hand, rendering and physics constraints before promising the same demo. The published SDK 6.0 capability table lists raw hand tracking only in Full Space and VST as unsupported for PICO Spatial. If current authoritative evidence cannot satisfy hands-only plus passthrough, explain that exact limitation and ask to use XR Mode. Do not silently change modes or claim they are equivalent.

Use XR Mode if I leave the optional mode choice blank. If I explicitly select Spatial Mode, preserve that selection until I approve a necessary switch. Only implement the selected mode; do not build both apps to complete onboarding. No controller-dependent interaction in either option.

Check current PICO Emulator and Unity host requirements, hardware acceleration, architecture and available space for downloads, extraction, Editor/modules, project Library/builds and virtual-device growth. Check system-volume space too. Do not assume Windows ARM, WSL or a VM is supported. Do not format a drive. On macOS use native Apple-silicon distributions when supported; on Windows use native supported downloads, PowerShell syntax and actual Windows paths. Do not change security settings or firmware speculatively.

Present applicable Unity, PICO and Android terms and obtain required explicit acceptance and Unity license eligibility/account sign-in. Record prior acceptance across restarts. Do not choose license eligibility or accept agreements on my behalf. Let me handle credentials and OS consent without logging secrets. A Mac mini has no built-in webcam: check for a connected usable camera early and tell me if one is needed. Installation can continue while a camera is pending, but the webcam milestone cannot pass without one.

## 4. Resolve and record current releases

Resolve once per run, record the source/channel/lookup time and exact version, then install that resolved version for reproducibility. On later runs resolve again; on resume reconcile at a safe checkpoint without discarding working downloads.

**pico-cli:** inspect official public npm metadata for `@picoxr/pico-cli`, including dist-tags, versions and engines, using the public registry. Choose the newest official stable public version, not a historical cap at 0.5/0.6. Install in a private tools directory under the chosen root; provision a compatible official Node LTS there if needed. Verify the actual executable's absolute path and reported version. Do not claim latest if release lookup failed.

**Unity CLI:** use Unity's official CLI distribution from `https://docs.unity.com/en-us/unity-cli/use-unity-cli`. Its executable is `unity`. Inspect/download the official installer and published integrity data; use its supported relocation (`UNITY_CLI_HOME`) and current supported update mechanism. Resolve the newest release on Unity's official public distribution channel. This product may still be experimental/beta; disclose that label, rather than inventing a stable release or replacing it with an unrelated CLI. Verify actual path and `unity --version`, and inspect current help before using commands. PICO setup may provision it too: avoid creating competing installations and ensure the agent uses the selected executable.

**Unity Editor:** query current official Unity release metadata, such as `https://services.api.unity.com/unity/editor/release/v1/releases?version=6000.6`, and/or the current CLI release-list command. Paginate if needed. Select the highest released final `6000.6.*f*` patch for the host architecture, excluding alpha/beta/RC and future releases. Do not use `lts`, which can resolve to a different series; do not upgrade to 6.7. Inspect PICO SDK/template compatibility against 6.6 and verify it by import/build. If unsupported, retain the requested version requirement and explain the blocker instead of silently downgrading.

**PICO Emulator:** resolve the latest stable standalone release for the host architecture/region from official PICO resources/feed. Default to Global outside mainland China. Record the feed, exact artifact/version and checksum where published. A previously installed image is usable only if it is the resolved matching release and healthy. Preserve older virtual devices and data.

**PICO Unity SDK and packages:** resolve the current official OS 6 SDK release compatible with the selected Editor and Emulator. Consult official PICO resources, SDK release notes, `Pico-Developer/PICO-Unity-SDK`, current Unity plugin guidance and templates. Prefer the newest compatible released SDK; if the official template requires a branch dependency, resolve and record its commit as well as package version and do not call it a stable release without evidence. Keep package versions compatible as a set; do not blindly upgrade every transitive package.

## 5. Put large components on the chosen drive

Create a documented layout for tools, Editor/modules, downloads, projects, builds, evidence and supported Emulator payload/data paths under the selected root. Use `UNITY_CLI_HOME` for CLI installation and the supported Editor install-path setting discovered through `unity install-path --help`. Verify the chosen Editor/modules really landed there. Put the Unity project there so its Library and builds stay there. Use supported Unity package-cache, npm/cache, Gradle and PICO storage settings when documented by the installed versions.

Inspect the actual CLI/Emulator storage behavior. Do not assume `PICO_HOME` relocates every AVD or `UNITY_CLI_HOME` relocates Editors/caches. Use supported relocation only, keep credentials/profile state where required, and report unavoidable system-drive paths and measured sizes. Never rewrite HOME, USERPROFILE or CODEX_HOME, mass-move profile folders, or make unverified symlinks. Save a quoted launcher/environment file for repeat runs, including paths with spaces. Remember that an already-running desktop app may retain an old PATH/environment.

Install Unity **Android Build Support including its SDK, NDK and OpenJDK child modules**. Current documented examples include `unity install <resolved-version> -m android` and `unity install-modules -e <resolved-version> -m android`; inspect current help and module inventory first. Verify child modules on disk and in Unity External Tools. Use these compatible bundled tools for building. Install only additional Android command-line components proven necessary for the standalone Emulator, through supported PICO provisioning. Never install Android Studio as a workaround.

## 6. Integrate the agent and verify live tools

Use the installed PICO environment preflight skill when available; inspect current CLI help and doctor commands before dependent execution. Repair concrete setup problems and rerun affected checks. A bootstrap environment missing an installable prerequisite should be repaired as part of this authorized setup, not treated as a reason to abandon the installer.

Discover the supported Unity setup route (current PICO docs describe `pico-cli setup --platform unity`). Install/enable the official PICO Unity agentic tooling for the **active host** only; do not configure Claude if I am using Codex, or vice versa. Check effective host configuration and plugin manifests, including inherited/global settings and disabled states. Use absolute known executable paths where supported, with the selected version, correct environment and SDK knowledge alignment. Preserve unrelated MCP servers and user settings.

Required checks are distinct:

1. **Registered and enabled:** PICO knowledge server plus the current supported Unity Editor bridge/agent tooling exist in the effective host configuration.
2. **CLI health:** actual CLI diagnostics and Editor connection checks succeed for this project.
3. **Live agent access:** this chat discovers and successfully calls PICO knowledge `query_graph` for PICO OS 6 Unity SDK capabilities, and performs a harmless read of the current Unity project's scene/Editor through the supported bridge. If current Unity tooling uses CLI/Pipeline instead of MCP, prove that live route works and record it explicitly; do not claim an absent unity-mcp server is loaded.

Inspect current official Unity integration help (`unity setup`, `unity mcp`, Pipeline tooling where available) and PICO Unity MCP Extensions instructions; these change over time. Install compatible official Unity Pipeline/AI Assistant dependencies and PICO MCP Extensions as required by the current toolchain. Current Unity documentation describes `unity pipeline install`, followed by `unity pipeline list` and command discovery. Do not leave the bridge exposed beyond the supported local setup or invent static tool schemas.

If host registration changed, save a checkpoint and request a specific host restart once: quit and reopen Codex/Claude, return to this chat and say “continue.” Afterward rediscover tools and repeat live checks. Registration and a green terminal doctor do not prove the chat loaded them. Continue independent build/download work while host activation is pending, but never mark integration complete prematurely. Unity can stay open during an agent-only restart when safe.

## 7. Create an OS 6 Unity project

Use a fresh, uniquely named project such as `SpaceProgramCupToss` under the selected root. Preserve existing projects. Inspect current official templates at `https://github.com/Pico-Developer/PICO-Unity-Project-Templates` and the installed Unity skills. Select `PICOXR` for XR Mode or `PICOSpatial` for verified Spatial Mode. Inspect actual CLI template/help names rather than copying historical flags. Template Editor versions may be older: set this fresh project's `ProjectVersion.txt` to the resolved 6.6 Editor/revision and open it with that Editor and Android target. Record import/upgrade changes. Use the scoped initialization workflow only if its invocation conditions are met; this prompt authorizes project setup but does not justify fabricating a slash-command invocation.

Before the first build inspect `Packages/manifest.json`, the resolved lockfile and imported Assets/plugins:

- Required OS 6 SDK source is **Pico-Developer/PICO-Unity-SDK**, with mode-appropriate packages. Current official plugin references identify `com.bytedance.pico.xr` (`XR`) and `com.bytedance.pico.spatialadapter` (`SpatialAdapter`), plus `com.bytedance.pico.mcp-extensions`. Resolve the current guidance before assuming every package is necessary in both modes.
- Prefer public HTTPS Git dependencies on port 443 so a fresh user needs no GitHub SSH key. Record exact resolved commits. Use official releases where supported.
- **Reject the legacy PICO Unity Integration SDK**, old `Unity.XR.PXR` imports, old SDK Assets/plugins and legacy `com.unity.xr.picoxr` dependencies. In this fresh project remove only newly introduced legacy dependencies and correct the template; never modify an unrelated user's project. Display names alone are not sufficient: verify source repository, version and API namespaces.
- For the OS 6 native XR path current guidance uses `ByteDance.PICO.XR`; Spatial uses `ByteDance.PICO.Spatial`. Inspect installed public APIs/samples. Do not copy old Integration SDK tutorials even when their hand/passthrough examples look convenient.
- Resolve compatible XR Interaction Toolkit, Input System and hand samples required by the selected SDK. Native PICO hand models alone do not provide interaction: verify actual interactor rigs and pinch/grasp Select bindings. Remove controller-dependent prefabs/actions from the smoke scene. If an SDK option mentions controllers and hands, document it and verify the app still functions entirely with hands.
- Keep one selected runtime/provider per Player build. Respect Spatial Camera, supported components/shaders, physics, export and lifecycle boundaries for Spatial Mode. Do not enable XR building blocks in a Spatial project by analogy.

Wait for package import/domain reload to finish, verify the Unity bridge connects to this project, and check compiler errors before scene work. Author the scene through the supported Unity live tools when available. Save scene/build settings so the first scene is included. Use only documented public APIs, current knowledge and installed samples. Do not invent class names, feature toggles, Android permissions or manifest entries.

## 8. Make the first app fun: Cup Toss

Build a lightweight, polished **Cup Toss** game using simple local primitives. No paid assets, network login or extra service. Use metre-scale geometry, a reachable table/tray, six brightly coloured cups arranged 3–2–1, and a soft ball. Leave a clear view of the passthrough environment. Show a short friendly instruction: “Pinch to grab. Toss to knock down cups. Push Reset to play again.”

Required gameplay:

- Hands only: tracked left/right hands; pinch/grasp grab the ball, move it naturally, and release to throw. Estimate release velocity over a small sample window, reject invalid tracking samples and clamp implausible webcam spikes. Add a gentle selectable assist if noisy monocular depth makes throwing difficult; explain the assist and keep the gesture hand-based.
- Cups have lightweight rigidbody/collider physics; detect a tipped cup once per round, show score 0–6, and celebrate a win briefly. The ball uses collision handling suitable for throws. Avoid excessive particles, complex assets or endless allocations.
- A reachable readable interactive panel provides **Reset**, **New Ball**, and optionally **Throw Assist**. Support finger poke/push and hand-ray pinch selection where the selected OS 6 mode supports them. Show hover/pressed feedback. No mouse/controller needed to play.
- Respawn lost/out-of-bounds balls and handle tracking loss safely without throwing on reacquisition. Keep Reset reliable and preserve state sensibly across app pause/resume. Clean up tracking/event listeners normally; do not shut down the Emulator.
- XR Mode: configure documented PICO OS 6 passthrough/VST and hands settings, camera/compositor setup, and mode-appropriate interaction rig. Verify the built APK, not only Editor Play Mode.
- Spatial Mode: implement a compact version using supported Spatial components/physics and hand/OS input. Verify the required environmental visibility and interaction semantics. A Shared Space system selection ray is not automatically raw tracked-hand physics. If the mandatory requirements cannot be fulfilled, report the capability conflict and obtain the mode switch before proceeding.

**Room mesh is an optional enhancement**, not a gate that prevents the first game. Query capability and permission at runtime. If real/simulated mesh data is available through documented APIs, use lightweight simplified colliders for ball bounces and label the data source. If absent, use an explicitly virtual table/floor. Never label a synthetic room as a scanned physical room, or suggest the Emulator validates real-device mesh/passthrough performance.

## 9. Enable and prove webcam hand tracking

This is a required milestone. After starting the **standalone PICO Emulator**, inspect its current official documentation, supported CLI controls and actual UI using computer use. Find the camera/webcam hand-tracking simulation control, select a connected camera and **enable webcam-driven hand simulation**. Use actual discovered names; do not invent a launch flag, assume generic Android `-camera-back webcam0` supplies tracked hands, or copy Meta XR Simulator settings. Save exact Emulator version and the control/settings used for repeat recording.

Handle OS camera permission and any Emulator-specific permission deliberately. Ask me to grant OS consent if automation cannot do so; do not bypass it. Check camera availability and conflicts with other camera apps. Keep the webcam preview/hand simulator visible briefly to confirm operation, then arrange the Emulator app window for play. A camera preview is not proof of tracked joints, and hand simulation is not necessarily webcam video passthrough. Record which background the Emulator actually uses.

Ask for one brief physical participation step when ready: hold hands in frame, move both hands and pinch/poke as instructed. The agent cannot move my hands. Verify tracked joints change with those movements **inside the running APK**, including loss/reacquisition. Identify pinch selection and poke separately. Do not count mouse drag or controller emulation as webcam hand verification.

If this release/host lacks the advertised mode, inspect another official documentation/help/UI route and check camera/platform compatibility. Report the precise limitation and evidence. Do not silently substitute keyboard/controller input or claim this milestone succeeded. Continue useful independent setup and keep the demo open if it runs; report webcam completion as blocked/pending until genuinely verified. Do not install a separate unrelated simulator as a workaround.

## 10. Build, launch, verify and recover

Start the Emulator from its installed local bundle through the host's supported execution channel. On macOS preserve the original QEMU signature and hypervisor entitlement. If `HV_DENIED`/`HYPERVISOR_RUNTIME_DENIED` occurs, diagnose execution context and use an already-authorized supported host launch channel; do not repeat the same failed context, re-sign binaries, strip quarantine speculatively, reinstall or delete virtual devices. If a host launch truly needs a user action, explain the exact action and checkpoint. On Windows verify supported acceleration and request only concretely necessary OS changes/reboots.

Use current help-discovered PICO Emulator provisioning/start/status and device commands. Create or reuse a dedicated matching OS 6 virtual device, select its serial explicitly for every deployment and verify boot/ADB readiness. Avoid targeting an attached physical headset by accident. Long downloads/extraction are normal: monitor actual output and stay communicative; elapsed time alone is not failure. Retain partial downloads when supported.

Build an **Android APK** with the selected Unity 6.6 Editor and its Android toolchain. Inspect supported Emulator ABI and SDK/native-plugin ABI before choosing Player architectures; do not assume host Apple silicon proves guest ARM64 support. Choose a documented compatible graphics/rendering path, manifest and Android API level. Treat incompatibility as a specific issue to resolve, not a reason to install Studio. Keep Player API compatibility aligned with the SDK/template.

Install and launch the APK using supported pico-cli operations on the selected serial; verify package, process/activity, first-scene readiness and logs. Watch for at least 60 seconds for startup crashes, repeated exceptions or broken rendering. Inspect the actual Emulator window with computer use; an ADB screenshot can miss composited spatial content and a black screenshot alone is inconclusive. Collect an appropriate host-window image/log evidence when possible.

Acceptance checklist (record pass/pending/fail with evidence):

1. Exact latest resolved tool versions and paths verified; Editor is 6000.6.*, Android modules present; no Android Studio/legacy Integration SDK installed by this workflow.
2. Knowledge `query_graph` callable in this chat and supported Unity bridge/CLI scene read works for the correct project.
3. Correct latest stable standalone Emulator and selected virtual device are running; built APK is installed and visibly open; 60-second crash check passes.
4. Environment remains visible through the supported passthrough/compositor path. State whether it is simulated; do not claim real-device passthrough validation.
5. Webcam simulation is enabled; both tracked hands respond inside the APK to actual camera-observed movements. Verify tracking loss/reacquisition.
6. Physically pinch-grab and toss the ball, knock at least one cup down and observe score. Verify Reset restacks cups and clears score, and New Ball works. Verify poke and pinch button paths where supported. Label automated checks and human observations separately; if I have not moved my hands, this interaction check is pending.
7. Emulator and app remain running, project and source are saved, and the user can continue with a follow-up prompt.

Fix compile/package errors before rebuilding, and input/compositor issues from logs and rig/config evidence rather than guesses. Prefer official help, knowledge and public samples; if MCP retrieval is unavailable use official docs and state the limit. For TLS failures inspect the failing runtime's certificate configuration, compare a trusted system HTTP client and use supported trusted-CA settings; never disable TLS verification. For Git SSH failures use official public HTTPS dependencies. Retry only with a meaningful correction; do not stop after one recoverable tooling failure.

## 11. Checkpoint, recording and handoff

After each stage save `<root>/setup-unity-state.json` and `SETUP-UNITY-RESUME.md`: chosen root, source revision/checksum, host/architecture, mode, exact versions and commits, paths, accepted agreements, verified milestones, project/package/device serial, pending host restart or camera consent, last error/evidence and next action. Store no credentials. Keep logs/evidence under the selected root. Resume the latest verified state without repeating completed installs or agreements.

For recording, arrange the Emulator/game prominently and leave it visible at the end. A macOS screen recording must be started/stopped by the user unless separately requested; it may not include camera/permission prompts. Do not publish recordings, upload to YouTube, or close the Emulator automatically. Build/verify first, then report honestly what passed and any pending camera or interaction check. This prompt's publication is not evidence that the installer was runtime-tested.

Once all acceptance criteria pass, finish warmly and briefly:

“Your first PICO Space Pro Unity app is running. The Emulator and Cup Toss are still open—try it with your hands! **Now you try creating something fun.** Paste one of these into this chat:”

- “Turn this into a dart game: pinch to pick up soft darts, throw them at a colourful target, and keep score.”
- “Build a mini basketball game with a hoop I can move by hand and a streak bonus for consecutive baskets.”
- “Make a marble playground where I can pinch to move ramps and watch the marbles bounce into a finish cup.”
- “Let me draw glowing 3D ribbons with my fingertips, with colour buttons and a push-to-clear panel.”
- “Build a musical garden: touching floating flowers plays different notes and makes them glow.”

Tell me the saved project location and that follow-up changes should reuse this OS 6 SDK, selected mode and hands-only input, then rebuild/redeploy to the open Emulator. Do not imply every example or physical-room feature has already been tested. If completion is partial, use an accurate partial-result message instead of the success text.

## Research snapshot and official sources

Checked 2026-10-08: official Unity release API returned **6000.6.4f1**, released 2026-10-01; public npm latest pico-cli was **0.6.0**; Unity CLI release notes list **1.0.0-beta.13**, dated 2026-10-07. These are observations, not future pins. PICO SDK `main` package manifests reported XR **6.1.1** and SpatialAdapter **6.1.0**; branch metadata alone does not establish the newest stable SDK release. Exact webcam controls were not independently confirmed in public documentation during authoring: discover and verify them in the installed standalone Emulator. This Unity installer and game have not yet been executed as an end-to-end run.

- [PICO OS 6 Unity SDK resources](https://developer.picoxr.com/resources/?platform=unity)
- [PICO Unity CLI quickstart](https://developer.picoxr.com/document/pico-cli/quickstart-unity/)
- [Official PICO Unity SDK](https://github.com/Pico-Developer/PICO-Unity-SDK)
- [Official PICO Unity project templates](https://github.com/Pico-Developer/PICO-Unity-Project-Templates)
- [PICO Unity agentic tooling](https://github.com/Pico-Developer/PICO-Intelligent-Plugins/tree/main/pico-unity-agentic-tools)
- [PICO mode capabilities and boundaries](https://github.com/Pico-Developer/PICO-Intelligent-Plugins/blob/main/pico-unity-agentic-tools/skills/develop-pico-unity-apps/references/mode-selection.md)
- [PICO Emulator guide](https://developer.picoxr.com/document/pico-cli/emulator-guide/)
- [Unity CLI install and usage](https://docs.unity.com/en-us/unity-cli/use-unity-cli)
- [Unity CLI reference](https://docs.unity.com/en-us/unity-cli/unity-cli-reference)
- [Unity CLI release notes](https://docs.unity.com/en-us/unity-cli/release-notes)
- [Unity Pipeline installation](https://docs.unity.com/en-us/unity-cli/unity-pipeline/unity-pipeline-package)
- [Unity official 6.6 release metadata](https://services.api.unity.com/unity/editor/release/v1/releases?version=6000.6)
