Godot visionOS Plugins - Apple GitHub XR Playbook for Indies - 2026

visionOS 27 landed at WWDC26 with a surprise for Godot teams: Apple published first-party, open-source Godot plugins on GitHub instead of burying spatial tooling inside Xcode-only samples. The apple/plugins-for-godot repository ships GodotRealityKit (windows and volumes in shared space) and PHASE spatial audio, while Apple's platform docs document CompositorServices for fully immersive rendering and PSVR2 Sense controller support on visionOS.

That is not a vague "XR is the future" keynote line. It is still an August 2026 shipping surface for teams already publishing Godot titles on Steam and itch who want an honest answer to: Can we evaluate Vision Pro without rewriting the whole game in SwiftUI? Weeks after WWDC, milestone boards still schedule “Vision Pro week” without a lab branch — that is why this August refresh keeps the same spike and adds an explicit Monday ritual plus Discord paste.

This playbook gives you a beginner evening path, developer gates V1–V6, a renderer picker table, and godot_visionos_plugins_receipt_v1.json so Monday standup does not turn WWDC enthusiasm into an unowned Vision Pro promise.

Non-repetition: This is not the Godot Steam Frame XR playbook (Valve OpenXR / Steamworks). It is not the GodotCon Boston Android XR playbook (Quest/Android lab). It is not the Godot 4.8 dev snapshot (engine preview keep/hold). Same Godot family — Apple first-party visionOS plugins only.

Official anchors: What's New in visionOS — Game Engine updates, WWDC26 visionOS session, and apple/plugins-for-godot on GitHub.

Who this is for: indie developers, XR-curious creators, and small-studio leads deciding whether Apple spatial distribution belongs on the 2026 roadmap.

What you get: plain-language plugin map, RealityKit vs CompositorServices decision table, beginner setup steps, verification gates, and a receipt JSON.

Time: about 90–120 minutes for notes + picker + throwaway export smoke on a Mac with Xcode; add device lab time if you have Vision Pro hardware. Creators without hardware can still finish V1–V2 and simulator V3; device V3 stays Hold until lab time exists.

Pixel character illustration for the Godot visionOS Apple GitHub XR playbook

Why this matters now (August 2026)

Three signals make godot visionos plugins worth an evening this month:

First-party Godot plugins are public — Apple's plugins-for-godot repo (June 2026) documents GodotRealityKit and PHASE with MIT licensing and contributor guidelines. That is a different posture than community bridges that drift when Apple ships new spatial APIs. August search still hits README pages without a keep/hold ritual.
visionOS 27 expands engine parity — Apple's Game Engine updates page names CompositorServices for Godot immersive experiences, RealityKit rendering for windows and volumes, PHASE spatial audio, and PSVR2 Sense controller spatial accessories — the same accessory story Unity PolySpatial teams already track. Most SERP pages celebrate WWDC; few force a renderer picker sentence plus simulator/device honesty.
Godot shipping volume is real — Godot 4.7 release notes cite 700+ new Godot games on Steam in 2026 before mid-year. Spatial plugins lower the evaluation cost for teams that already ship 2D/3D Godot builds and hear "what about Vision Pro?" from partners — especially when producers treat “we cloned the Apple repo” as a store listing decision.

If you just finished GodotCon Boston Android XR playbook week, treat visionOS as a separate Apple diligence track — not a checkbox on the Quest matrix. Android XR lab time does not automatically transfer to Xcode signing, spatial personas, or App Store spatial review habits.

Pair platform risk framing with Apple Vision Pro year-one review for game developers before you model revenue. Pair export hygiene with Godot 4.7 upgrade lock so your stable Godot pin stays honest while you spike Vision Pro.

What Apple's Godot visionOS plugins actually include

Apple's repository documents two plugins today:

Plugin	Path	What it does
GodotRealityKit	`godotrealitykit/`	Renders Godot scenes with RealityKit on visionOS — supports windows, volumes, and immersive presentation modes per Apple's capability matrix
PHASE for Godot	`phasegodot/`	Brings Apple's PHASE spatial audio framework to Godot on macOS, iOS, tvOS, and visionOS

Apple's platform docs add a third path that is not the same plugin zip:

Path	Renderer	Best when
GodotRealityKit plugin	RealityKit	You want shared-space windows/volumes with deeper visionOS integration while game logic stays in Godot
CompositorServices	Godot's Metal driver	You need fully immersive experiences with Godot's renderer in an ImmersiveSpace
Monoscopic Metal view	Godot Metal	Quick flat preview — limited spatial input

The GodotRealityKit README compares capabilities across RealityKit, CompositorServices, and monoscopic Metal — use that table as your renderer picker, not marketing adjectives.

Plain-language summary: most of your game (scripts, animation, simulation) still runs in Godot. What changes is who renders pixels and how the app presents (window vs volume vs immersive).

Renderer picker — Keep / Hold / Rewrite

Decision	Keep	Hold	Rewrite
Production Godot version	Stay on pinned stable (for example 4.7.1) until a separate upgrade receipt passes	Do not jump to a WWDC demo export template as default	Rewrite upgrade plan only if Vision Pro spike proves a hard blocker on locked version
RealityKit plugin spike	Throwaway branch + one scene	Hold shipping SKU claims until V3 passes on device or simulator	Rewrite art budget only if volumes require asset changes you cannot afford
CompositorServices immersive	Lab project with explicit immersive scope	Hold public "full VR" marketing until immersive smoke passes	Rewrite camera/input only after flat Godot export is already green
PHASE audio	Enable on Mac/iOS builds if you already ship Apple platforms	Hold visionOS audio promises until PHASE smoke passes	Rewrite mix only if spatialization changes gameplay readability
PSVR2 Sense controllers	Document In/Out for 2026	Hold tactile accessory marketing	Rewrite input map only if a funded contract requires Sense
App Store / notarization lane	Reuse Mac signing discipline	Hold Vision Pro store listing until export + privacy rows exist	Rewrite CI only after desktop notarization receipt is green — see WWDC Game Porting Toolkit checklist

Company diligence note: Vision Pro evaluation is lab capability until a named owner, device calendar, and receipt exist. Model support hours separately — XR support cost forecasting applies to Apple spatial work too.

Plain-language glossary

Term	Plain meaning
GodotRealityKit	Apple’s Godot plugin that renders scenes with RealityKit (windows, volumes, some immersive modes)
PHASE	Apple’s spatial audio framework, exposed to Godot via `phasegodot`
CompositorServices	Apple path for fully immersive Godot Metal rendering in an ImmersiveSpace
Shared space	visionOS mode where apps sit as windows/volumes beside other apps
ImmersiveSpace	Full-surround presentation — different diligence than a volume
PSVR2 Sense	Spatial controllers Apple documents as accessories on visionOS — optional In/Out
Plugin commit pin	Exact Git commit of `apple/plugins-for-godot` recorded in the receipt
GodotVision (archive)	Older community bridge pattern — do not treat as the 2026 first-party path

Paste this table into Discord before anyone says “just add XR” after a WWDC clip.

When to run which gate (late-July / early-August cadence)

Window	Do this	Skip this
Week of WWDC interest	V1 presentation-mode sentence + clone plugins repo	Store listing date, partner Vision Pro SKU
First Mac evening (90–120 min)	V2 pin + plugin import on throwaway branch + simulator smoke	Production main merge; Quest matrix rewrite
Before partner pitch	V3–V6 + Discord checklist filled + receipt	Device-less “we’re shipping Vision Pro” claims
Same week as Steam Frame / Quest lab	Separate receipts — do not stack hardware nights	One vague “XR matrix” row for all headsets
Engine upgrade week	Keep visionOS spike on pinned Godot; pair version moves with 4.8 snapshot / 4.7 upgrade lock	Jumping Godot minor mid-visionOS smoke

Discord partner checklist (copy/paste)

Godot visionOS plugins - Aug 2026 Monday ritual
1) Presentation mode: volumes/windows (RealityKit) / fully immersive (CompositorServices) / HOLD
2) Godot pin: ____ | plugins-for-godot commit: ____
3) Spike branch: ________ (not shipping main)
4) Simulator smoke: PASS / FAIL | Device smoke: PASS / FAIL / HOLD (no hardware)
5) PHASE audio: PASS / N/A reason: ________
6) PSVR2 Sense: IN / OUT for 2026
7) Gates V1–V6: ____
8) External Vision Pro promises wait until V1–V6 receipt passes
9) Separate from Steam Frame / Quest matrices (different receipts)
10) Ship main: untouched

Monday ritual - August visionOS keep/hold (90–120 minutes)

Use this when the board says “Vision Pro this week” and nobody owns the Apple lab branch yet.

Block 90–120 minutes on a Mac with Xcode — not after a Quest / Steam Frame hardware night.
Throwaway Git branch only — never spike plugins on shipping main.
V1 — write one presentation-mode sentence (volumes/windows vs fully immersive).
V2 — pin Godot stable + exact apple/plugins-for-godot commit hash.
V3 — RealityKit or CompositorServices smoke on simulator (device HOLD if no hardware).
V4–V5 — input map note + PHASE audio honesty (Mac-only PHASE ≠ visionOS pass).
V6 + Discord — keep / hold / rewrite with owner + revisit date, then paste the checklist above.
Stop — do not merge to ship, do not stack Steam Frame / Quest matrices into this receipt, do not promise App Store spatial dates tonight.

Pass: receipt JSON saved, Discord checklist posted, ship main untouched.
Fail: “We cloned Apple’s repo” with no renderer picker sentence, or Vision Pro marketing from simulator-only smoke.

Paste this one-liner after the checklist:

Honesty: Apple Godot visionOS plugins ≠ Vision Pro SKU — lab spike only; separate from Steam Frame / Quest receipts (Aug 2026).

Beginner path — evaluate Godot visionOS plugins in one evening

Prerequisites

Godot project copy on a Git branch (never spike on main).
Mac with Xcode and Apple developer account access for signing smoke.
Clone or submodule apple/plugins-for-godot into a third_party/ or addons/ path your team documents.
About 90–120 minutes without device; add 60+ minutes if you have Vision Pro hardware.

If export presets are rusty, skim Godot export presets lesson and Godot scene management.

Step 1 — Pick your presentation mode (15 minutes)

Answer one sentence: Are we testing shared-space volumes, or fully immersive gameplay?

Volumes / windows → start with GodotRealityKit README Adding the Plugin.
Fully immersive → read Apple's CompositorServices notes on visionOS what's new before you assume RealityKit covers your scene.

Write the answer in your receipt — ambiguous scope is how teams promise Vision Pro at a festival and deliver a flat iPad build.

Step 2 — Add the plugin to a throwaway scene (30 minutes)

Follow Apple's AddingPlugin doc for GodotRealityKit.
Open a single-scene test (menu + one gameplay room — not your production overworld).
Confirm the project still opens on desktop Godot after plugin import.
Note Godot version + plugin commit hash in the receipt.

Step 3 — Run PHASE audio smoke (optional, 15 minutes)

If your game already ships Mac/iOS audio:

Open phasegodot README.
Play one known SFX through PHASE on Mac build.
Log pass/fail — do not block Vision Pro renderer spike on audio if flat platforms are already red.

Step 4 — Export and launch smoke (30–45 minutes)

Configure visionOS export in Xcode per Apple docs.
Launch on simulator minimum; device preferred.
Capture one screenshot or screen recording for the receipt.
Stop — do not merge to main until gates pass.

Step 5 — File the receipt (10 minutes)

Complete godot_visionos_plugins_receipt_v1.json below and assign an owner for revisit date.

Developer verification gates (V1–V6)

Gate	Pass when	Fail signal
V1 Scope	Written picker: RealityKit vs CompositorServices vs hold	"We'll figure out immersive later" on a marketing slide
V2 Version pin	Godot engine version + plugin commit recorded	Unknown plugin hash in production branch
V3 Renderer smoke	Target mode launches to interactive frame	Black screen, instant crash, or desktop-only fallback
V4 Input map	Documented In/Out for hand tracking, gamepad, Sense	Promising Sense support without device test
V5 Audio	PHASE smoke pass or explicit N/A with reason	Spatial audio claimed while flat mix is broken
V6 Receipt	`godot_visionos_plugins_receipt_v1.json` signed by human	Gates checked from memory in Discord only

Gate deep notes (V1–V6)

V1 — Scope. One sentence: volumes/windows vs immersive vs hold. Marketing slides without that sentence fail V1.

V2 — Version pin. Record Godot exact version and plugins-for-godot commit. “Latest main” is not a pin.

V3 — Renderer smoke. Target mode reaches an interactive frame on simulator or device. Desktop-only open after plugin import is not V3 for visionOS claims.

V4 — Input map. Hand tracking / gamepad / Sense each marked In or Out with a test note. Promising Sense without hardware fails V4.

V5 — Audio. PHASE smoke pass, or explicit N/A (flat platforms already broken, or audio out of scope). Claiming “spatial audio” without smoke fails V5.

V6 — Receipt. JSON below with human review and revisit date — not a Discord reaction emoji.

Set "result": "pass" only when V1–V6 are honestly true — a simulator screenshot alone does not justify a store listing date.

Receipt template — `godot_visionos_plugins_receipt_v1.json`

{
  "receipt": "godot_visionos_plugins_receipt_v1",
  "date": "2026-08-03",
  "godot_version": "4.7.1",
  "plugin_repo": "https://github.com/apple/plugins-for-godot",
  "plugin_commit": "abc1234",
  "presentation_mode": "realitykit_volume",
  "compositor_services": "hold",
  "phase_audio": "pass",
  "psvr2_sense": "out",
  "simulator_smoke": "pass",
  "device_smoke": "hold",
  "xr_matrix_note": "visionOS lab only; Quest matrix unchanged; Steam Frame separate",
  "gates": {
    "V1_scope": true,
    "V2_version_pin": true,
    "V3_renderer_smoke": true,
    "V4_input_map": true,
    "V5_audio": true,
    "V6_receipt": true
  },
  "monday_ritual": "picker sentence → pin → simulator smoke → Discord paste",
  "discord_paste_posted": true,
  "result": "pass",
  "operator": "session-owner-handle",
  "revisit_date": "2026-08-17"
}

How this differs from GodotVision and older bridges

Community project GodotVision documented a headless Godot + RealityKit frontend pattern and is moving to archive mode as native visionOS support lands in upstream Godot. Apple's 2026 plugins are first-party, versioned on GitHub, and aligned with WWDC26 platform docs.

Do not confuse this with "Godot natively owns every visionOS feature today." Apple's docs still position RealityKit and SwiftUI as the deepest integration path. The plugins are how Godot-first teams evaluate Vision Pro without rewriting the entire game loop in Swift.

Common mistakes

Skipping the renderer picker — RealityKit volumes and CompositorServices immersive solve different problems; mixing them mid-sprint creates orphan scenes.
Promising Vision Pro because WWDC slides looked easy — signing, privacy, and spatial review still cost calendar time.
Collapsing Quest lab work into visionOS — keep separate matrices; see GodotCon Boston XR playbook.
Spiking on production main — plugin import and export templates belong on throwaway branches.
Ignoring flat Godot export health — if desktop/macOS export is red, Vision Pro will not save you.
Marketing "spatial audio" without PHASE smoke — PHASE is powerful; unverified audio claims fail partner diligence.

Troubleshooting — Monday failure modes

“Plugin imports, desktop Godot opens, visionOS export is black.” V3 incomplete. Re-read RealityKit vs CompositorServices picker; confirm ImmersiveSpace vs volume matches your V1 sentence.

“Simulator pass, device crash.” Keep result as lab-only until device smoke is scheduled. Do not promote V3 to partner-facing pass on simulator alone if your claims name Vision Pro hardware.

“Partner asks if Steam Frame work covers Vision Pro.” No. Point to Steam Frame playbook and this receipt as separate diligence tracks.

“We upgraded Godot mid-spike and plugins broke.” Re-pin: restore the Godot version from V2, file a separate engine upgrade receipt (4.8 snapshot if you are evaluating previews).

“PHASE works on Mac, silent on visionOS.” Treat V5 as fail until platform-specific smoke passes; do not market spatial audio from Mac-only success.

Partner one-liner

Apple’s open-source Godot visionOS plugins (GodotRealityKit + PHASE) let us evaluate Vision Pro without a Swift rewrite. We pick RealityKit volumes vs CompositorServices immersive up front, pin Godot + plugin commit, run simulator/device smoke, and file godot_visionos_plugins_receipt_v1.json before any store or partner Vision Pro date.

Key takeaways

godot visionos plugins — Apple shipped open-source GodotRealityKit + PHASE on GitHub; still August Vision Pro diligence after WWDC26.
visionOS 27 documents CompositorServices immersive rendering and PSVR2 Sense accessories for Godot teams.
Pick RealityKit plugin for shared-space windows/volumes; use CompositorServices for fully immersive Godot rendering.
Run the Monday ritual on a branch — not production main.
Prove gates V1–V6 before external Vision Pro promises.
Keep Quest/Android XR, Steam Frame, and visionOS on separate diligence tracks with separate receipts.
File godot_visionos_plugins_receipt_v1.json with version pin, plugin commit, and revisit date.
Model lab cost honestly — Vision Pro evaluation is not free because the engine is MIT-licensed.
Use the cadence table so visionOS smoke does not collide with Steam Frame / Quest nights.
Paste the Discord partner checklist before external Vision Pro promises.
Simulator pass ≠ device pass — hold hardware claims until device smoke is scheduled.
Cite apple/plugins-for-godot and visionOS what’s new when APIs drift.

Frequently asked questions

What are the Godot visionOS plugins Apple released?

Apple's apple/plugins-for-godot repository includes GodotRealityKit (RealityKit rendering for windows, volumes, and immersive modes) and PHASE for Godot (spatial audio on Apple platforms including visionOS). Platform context: What's New in visionOS.

Should I use GodotRealityKit or CompositorServices?

Use GodotRealityKit when you want RealityKit to render shared-space windows or volumes while game logic stays in Godot. Use CompositorServices when you need fully immersive experiences with Godot's Metal renderer in an ImmersiveSpace. Apple's GodotRealityKit README includes a capability comparison table.

Do I need a Vision Pro to start?

No. Begin with README integration, desktop validation, and simulator smoke where possible. Device tests still matter before store claims — assign lab time explicitly.

How is this different from the GodotCon Boston XR article?

The GodotCon Boston playbook covers Android XR, headset editor, and GABE post-conference aftermath keep/hold. This article covers Apple's first-party Godot visionOS plugins and Vision Pro evaluation gates.

How is this different from Godot Steam Frame day-one support?

Steam Frame is Valve OpenXR / Steamworks diligence (Steam Frame playbook). visionOS is Apple plugins + Xcode/App Store habits. Keep separate receipts.

Does visionOS replace my Steam-first Godot roadmap?

Not automatically. Treat Vision Pro as an optional distribution spike until receipts, cost, and audience data justify a SKU. Many teams stay Steam-first while documenting an honest Hold on visionOS.

Should I combine this with a Godot 4.8 preview upgrade?

Prefer not on the same evening. Pin a stable Godot for the visionOS spike; evaluate 4.8 preview keep/hold separately (Godot 4.8 snapshot).

Where do I learn Godot export basics first?

Start with Godot export presets and the Godot guide hub before you add spatial plugins.

Conclusion

Godot visionOS plugins still matter in August 2026: WWDC26 did not magically make Vision Pro a mandatory SKU for every Godot studio. It did make evaluation more honest — first-party plugins on GitHub, a clear renderer picker, and platform docs that name CompositorServices, PHASE, and spatial accessories. Run the Monday ritual, pass gates V1–V6, paste Discord, file the receipt, and keep external promises aligned with what you actually launched on device — separate from Steam Frame and Quest matrices.