spatial-swiftui-developer

Original：🇺🇸 English

Translated

Design and implement visionOS SwiftUI scenes that integrate RealityKit content. Use when building spatial UI with RealityView, Model3D, attachments, volumetric windows, ImmersiveSpace, or spatial gestures, or when choosing SwiftUI vs RealityKit APIs for 3D presentation.

1installs

Sourcetomkrikorian/visionosagents

Added on2026-02-07

NPX Install

npx skill4agent add tomkrikorian/visionosagents spatial-swiftui-developer

SKILL.md Content

View Translation Comparison →

Spatial SwiftUI Developer

Description and Goals

This skill provides guidance for designing and implementing visionOS SwiftUI scenes that integrate RealityKit content. It helps you choose between SwiftUI and RealityKit APIs for 3D presentation and shows how to bridge between the two frameworks effectively.

Goals

Enable developers to build spatial UI experiences on visionOS
Guide selection between SwiftUI and RealityKit APIs for 3D content
Show how to integrate RealityKit content into SwiftUI scenes
Demonstrate spatial interaction patterns with gestures
Support proper windowing and immersion patterns

What This Skill Should Do

When building spatial UI with SwiftUI on visionOS, this skill should:

Guide presentation surface selection - Help you choose between WindowGroup, volumetric windows, and ImmersiveSpace
Select 3D APIs - Show when to use Model3D vs RealityView for different use cases
Integrate RealityKit - Demonstrate how to load and embed RealityKit content in SwiftUI
Handle spatial interaction - Provide patterns for spatial gestures and entity-targeted interactions
Manage lifecycle - Ensure proper async loading and state management

Load the appropriate reference file from the tables below for detailed usage, code examples, and best practices.

Quick Start Workflow

Identify the presentation surface:
```
WindowGroup
```
, volumetric window, or
```
ImmersiveSpace
```
.
Choose a 3D API:
```
Model3D
```
for simple models,
```
RealityView
```
for full RealityKit scenes.
Load RealityKit content asynchronously and add entities in the
```
RealityView
```
make closure.
Use RealityView attachments to place SwiftUI UI in 3D space when needed.
Add spatial interaction with
```
SpatialTapGesture
```
or entity-targeted gestures.
Update RealityKit content in the
```
RealityView
```
update closure, not in SwiftUI body.
Validate scale using
```
defaultSize
```
for volumes and
```
immersionStyle
```
for immersive spaces.

Information About the Skill

Core Concepts

Scene and Spatial Presentation

Use

WindowGroup

with

windowStyle(.volumetric)

and

defaultSize

for volumes.

Use
```
ImmersiveSpace
```
for unbounded spatial scenes and
```
immersionStyle
```
selection.
Use
```
openImmersiveSpace
```
and
```
dismissImmersiveSpace
```
for transitions.

RealityKit Embedding in SwiftUI

Use
```
RealityView
```
for full RealityKit scenes and per-frame updates.
Use
```
Attachment
```
and RealityView attachments to embed SwiftUI views in 3D.

Use

ViewAttachmentEntity

and

ViewAttachmentComponent

for attachment entities.

3D Model Presentation

Use
```
Model3D
```
for async model loading with SwiftUI layout.
Use
```
Model3DPhase
```
and
```
Model3DAsset
```
for loading phases and animation choices.

Spatial Input

Use
```
SpatialTapGesture
```
for spatial tap locations in 2D/3D coordinate spaces.

Reference Files

Reference	When to Use
`REFERENCE.md`	When looking for feature-focused code patterns and general guidance.
`model3d.md`	When using Model3D for async model loading, assets, animation, and manipulation.
`realityview.md`	When setting up RealityView, attachments, and RealityKit integration patterns.
`interaction.md`	When implementing gestures and manipulation patterns for spatial input.
`windowing-immersion.md`	When managing windows and immersive space patterns.
`spatial-layout.md`	When using SwiftUI spatial layout APIs and debug tools.
`charts-3d.md`	When implementing Chart3D and surface plot patterns.

Implementation Patterns

Use
```
Model3D
```
when you only need display and layout; use
```
RealityView
```
for custom entity graphs and systems.
Keep RealityKit mutations inside
```
RealityView
```
make/update closures.
Prefer attachments for UI that should remain SwiftUI-driven but positioned in 3D.
Treat
```
ImmersiveSpace
```
as a separate scene with its own lifecycle and environment actions.

Pitfalls and Checks

Do not block the main actor with synchronous model or entity loading.
Do not update RealityKit entities inside SwiftUI body computation.
Do not use volumetric window style with
```
Window
```
instead of
```
WindowGroup
```
.
Do not omit
```
defaultSize
```
for volumes; physical scale will be inconsistent.
Prefer
```
.glassBackgroundEffect()
```
for backgrounds instead of custom blur/material backgrounds.