satoshi0212/visionOS_30Days

This system is a collection of standalone iOS and visionOS sample applications designed to demonstrate specific capabilities within Apple's spatial computing and multimedia ecosystems. It covers a wide range of features including RealityKit-based 3D rendering, ARKit world tracking, immersive space management, and Metal graphics programming. Additionally, the codebase includes demos for integrating external services like Slack, handling live location data, and implementing audio-visual playback with spatial audio.

37 changes.

This period focused on building a comprehensive suite of visionOS and iOS sample applications demonstrating spatial computing capabilities. The work centered on integrating RealityKit, ARKit, and Metal to create immersive experiences, including 3D model viewers, interactive physics simulations, and spatial video playback. It also explored advanced features such as world tracking, plane detection, image tracking, and the integration of external services like Slack within spatial interfaces.

4 changes.

This period focused on developing a series of iOS and visionOS sample applications demonstrating advanced spatial computing features. The work included implementing peer-to-peer networking, world-anchored 3D objects, real-time mesh reconstruction, and spatial-audio interactions within immersive spaces.

Introduces a new Day 14 application that demonstrates opening and dismissing both Progressive and Full Immersive Spaces. The app features a main view with toggles to manage these spaces and an immersive view that loads a texture asynchronously using \TextureResource.loadAsync\ to render a textured sphere, addressing deprecation warnings associated with the synchronous \load\ method.

Day14 · high confidence

This change introduces the Day 16 application, a SwiftUI-based app featuring an immersive AR space powered by ARKit. The app includes a main interface (ContentView) that allows users to toggle the immersive space, and an ImmersiveView that initializes an ARKit session for world tracking. Users can interact with the scene using two-finger taps to place a 3D axis model (axis.usdz) at the current device pose, or long-press gestures to dismiss the immersive space. The implementation includes an ARKitSessionManager to handle session lifecycle and anchor updates, a ViewModel to manage the 3D content entity, and coordinate transformation extensions for pose extraction.

Day16 · high confidence

A new Day 17 application has been added, featuring a RealityKit scene that displays a 3D cube textured with the Slack icon. Users can interact with the cube using a bottom control panel that allows them to toggle transparency and adjust the object's scale through a picker menu.

Day17 · high confidence

This change introduces the Day 18 application, a new iOS/macOS app built with SwiftUI and RealityKit. The app features a main interface with a toggle to open and dismiss an immersive space. The immersive space displays 3D text content generated via RealityKit's text mesh resources, specifically rendering the string "Hello! 日本語！". The project structure includes standard Xcode project files, asset catalogs for app icons, and a ViewModel using the Observation framework to manage the 3D scene content.

Day18 · high confidence

A new Day 19 application has been added, featuring a SwiftUI interface with a toggle to start and stop audio recording. The app integrates the Speech framework to perform real-time speech-to-text transcription, handling microphone permissions and displaying the recognized text in the UI.

Day19 · high confidence

A new Day 21 application is introduced, featuring a SwiftUI interface that lists places (Shibuya, Akihabara, Kabuki-cho) and displays them on a Map. Users can select a location to open a full-immersion RealityKit space, where a sphere textured with a LookAround snapshot of the selected place is rendered. The app is configured for Xcode 15 and targets spatial computing with an ImmersiveSpace entry point.

Day21 · high confidence

Introduces a new Day 22 application that combines MapKit and RealityKit to display Tokyo locations (Shibuya, Akihabara, Kabuki-cho) in an immersive environment. The app features a list-based UI for selecting places, which updates a Map view and triggers an Immersive Space. Inside the immersive view, a spherical mesh is textured with a panoramic image fetched asynchronously from the Google Street View Tiles API, allowing users to visualize the selected location in a 360-degree spatial context.

Day22 · high confidence

The Day 26 location now includes a standalone iOS app that renders a Matrix-style digital rain animation using SwiftUI Canvas and Metal. Users see falling columns of Japanese characters with depth-based blur and scaling, and can toggle a pixelation effect by tapping the screen, which applies a custom Metal shader to the layer.

Day26 · high confidence

The Day 31 location now contains a complete iOS application that demonstrates video playback and trimming. The app integrates a \PlayerViewModel\ using the Observation framework to manage an \AVPlayer\ instance and an \AVPlayerViewController\. The UI, built with SwiftUI, presents the video via a \SystemPlayerView\ wrapper and provides controls to play, pause, and initiate system-level trimming. When trimming is started, the app exports the selected portion of the bundled 'BigBuckBunny' video to the device's documents directory.

Day31 · high confidence

This change introduces a new Day 32 application for visionOS, featuring an immersive space where users can interact with 3D cubes. The app includes a main view to toggle the immersive space and an immersive view containing two cubes (red and green) that respond to spatial taps. Tapping a cube triggers a jump animation and plays a sound effect, with the jump height varying based on which cube is tapped. The implementation uses SwiftUI and RealityKit for the 3D scene, along with custom logic for character movement and physics simulation.

Day32 · high confidence

This change introduces the Day 4 application, an iOS app configured for immersive space experiences. It adds a SwiftUI app entry point and a view model that initializes an ARKit session with WorldTrackingProvider. The app requests world sensing authorization and sets up a simple 3D box entity within an ImmersiveSpace scene, logging anchor update events to the console.

Day4 · high confidence

This change introduces the Day 5 application, a spatial computing demo built with SwiftUI and RealityKit. It features a main interface with a toggle to open an immersive space, where users can view a 3D cube textured with numbered images (1–6). The implementation includes the Xcode project configuration, the app entry point defining the immersive scene, a view model for managing the 3D content, and the immersive view itself which renders the cube and handles spatial tap gestures.

Day5 · high confidence

The Day 8 module now includes a new iOS app project featuring a SwiftUI interface that allows users to launch an immersive space. Inside this space, users can interact with two 3D cubes (red and blue) via spatial tap gestures, which trigger a vertical bounce animation. The cubes are labeled with floating text attachments, and the underlying view model handles entity creation, collision, and animation sequencing.

Day8 · high confidence

Introduces a new Day1 application target for visionOS, including the main app entry point (Day1App.swift), a root view displaying "Hello, visionOS!" (ContentView.swift), and the necessary asset catalogs for the app icon and previews. This establishes the initial project structure and build configuration for the Day1 module.

Day1 · high confidence

This change introduces the Day10 application, a SwiftUI and RealityKit-based immersive experience. The app features a main window with a toggle to launch an ImmersiveSpace, where users can view a 3D scene containing 25 'laputa' images arranged on three board planes. Users can tap the scene to toggle between a sorted grid layout and a randomized arrangement of the image planes, with smooth animations for position changes.

Day10 · high confidence

The Day13 project introduces a new SwiftUI application that supports immersive spaces. The main interface provides a toggle to open or dismiss an immersive environment, which renders a 3D scene using RealityKit. Users can interact with the scene by double-tapping to spawn a 3D axis model at the tap location, with the view model handling entity loading and spatial coordinate conversion.

Day13 · high confidence

The Day2 location now includes a complete iOS application project that displays a 3D teapot model using SwiftUI's Model3D component. The app loads a teapot.usdz file from Apple's developer documentation and presents it in a resizable view with a loading placeholder, accessible via a 'Show teapot' text label.

Day2 · high confidence

The Day20 location now contains a complete SwiftUI application that connects to the Slack API. The app uses a ViewModel to periodically fetch channel history every second and displays the message text in a list. It includes the necessary project configuration, assets for visionOS, and data models to parse Slack responses.

Day20 · high confidence

This change introduces the Day23 application, a SwiftUI-based iOS app that integrates with the Slack API to fetch channel history. The app features a standard 2D interface for displaying message text and a toggle to launch an Immersive Space (visionOS/RealityKit). In this spatial view, fetched Slack messages are rendered as 3D text entities that animate across the user's environment, with support for different visual styles such as 'danmaku' (scrolling) effects.

Day23 · high confidence

A new Day25 application has been added, featuring a SwiftUI interface with two synchronized windows (home and other) for managing lists of items. The app uses a shared ViewModel to track left and right list items, allowing users to drag and drop items between the two lists via drop destinations. The implementation includes a main app entry point, view models, and asset catalogs for the app icon.

Day25 · high confidence

A new Day27 application has been added, featuring a SwiftUI interface that integrates with RealityKit for an immersive space. The app allows users to toggle an immersive view where they can place 3D plane entities by double-tapping; these entities are textured using a live snapshot of the SwiftUI source view. The project is configured for Xcode 15.0 and includes a ViewModel that handles the 3D scene setup, input targeting, and texture generation from UI elements.

Day27 · high confidence

This change introduces the Day28 application, a VisionOS app that leverages the new ARKit session API to run a WorldTrackingProvider for device pose and orientation. The app features a 2D window with a toggle to launch an ImmersiveSpace, where users can place virtual timer entities via double-tap gestures. These timers are rendered as SwiftUI attachments within RealityKit, displaying a custom clock face with countdown logic. The implementation includes an ARKitSessionManager for session lifecycle and authorization, a ViewModel for entity management, and specific Info.plist keys for world sensing and hand tracking permissions.

Day28 · high confidence

This change introduces the Day29 application, an iOS app featuring an immersive space powered by ARKit. The app manages AR sessions via ARKitSessionManager, requesting world-sensing and hand-tracking authorizations, and utilizes WorldTrackingProvider to query device anchors for pose data. The user interface includes a ContentView to toggle the immersive space, an ImmersiveView that renders RealityKit entities (including red, blue, and green cubes) and attaches a LogView as an attachment, and a ViewModel that handles entity creation and message logging. Utility extensions for simd\_float4x4 and ModelEntity support coordinate transformations and material tinting.

Day29 · high confidence

The Day35 location now contains a complete, standalone iOS/visionOS application project. The app initializes a Metal rendering pipeline and displays a red triangle on screen using a custom CAMetalLayer and Metal shaders (vertex and fragment). The project is configured for visionOS (indicated by the 'vision' idiom in asset catalogs) and includes the necessary Xcode project files, Swift UI entry points, and Metal shader code to support this specific rendering capability.

Day35 · high confidence

The Day36 location now contains a complete iOS application that renders a 3D gear animation using Metal. The app integrates a SwiftUI interface (ContentView) with a custom Metal rendering pipeline (ViewModel and Shaders.metal) to display a rotating gear structure on screen. It includes the necessary Xcode project configuration, asset catalogs for the app icon and texture, and a ViewModel that manages the Metal device, command queue, and render loop.

Day36 · high confidence

The Day37 location now contains a complete iOS application demonstrating local peer-to-peer connectivity using Apple's MultipeerConnectivity framework. The app features a \PeerToPeerModel\ that handles service advertising, peer browsing, and session management, exposed via a SwiftUI \ContentView\ that allows users to discover nearby devices, send connection invitations, and manage paired sessions. The project is configured with the necessary \Info.plist\ Bonjour services and asset catalogs to support this functionality.

Day37 · high confidence

The Day6 project introduces a new iOS application featuring a main interface with a toggle to launch an immersive space. Inside the immersive environment, users can interact with a 3D cube: dragging it repositions it in space, while tapping it changes its color to a random value. The implementation uses SwiftUI for the UI layer and RealityKit for the 3D rendering and physics simulation.

Day6 · high confidence

This change introduces the Day7 application, a SwiftUI-based app that integrates with Apple's spatial computing platform. It features a main interface for managing an immersive space and an immersive view powered by RealityKit that renders a 3D cube. Tapping the cube triggers an asynchronous call to the Slack API to post a message, demonstrating a workflow that bridges 3D interaction with external service communication.

Day7 · high confidence

The Day9 application now includes a RealityKit-based demo that renders a 3D scene containing an Earth model and a portal entity. The app initializes a world with an 'Sunlight' skybox environment and places the Earth model within it. A portal plane is added to the scene, configured with a custom material and linked to the world entity via a PortalComponent, allowing users to view the Earth through the portal interface.

Day9, Day9/Packages/RealityKitContent · high confidence

This change adds the Day 30 application, a visionOS app that plays an HLS video stream and reacts to its metadata by toggling an immersive space. The app uses a PlayerModel to manage AVPlayer playback and spatial audio configuration, exposing a PlayerView that wraps AVPlayerViewController. When the video metadata signals a 'dark room' state, the app opens a full-immersion RealityKit scene featuring a starfield skybox and a fireworks particle effect; it closes the immersive space for 'light room' or 'reset' states. The project is configured for Xcode 15.0 and includes the necessary RealityKitContent package assets.

Day30 · high confidence

This change adds the Day 3 application, a new SwiftUI-based video player that features spatial audio (head-tracked sound stage) and synchronized group watching via the GroupActivities framework. The app includes a \PlayerModel\ backed by AVKit to manage playback state, a \VideoWatchingCoordinator\ to handle shared session logic, and a \VideoWatchingActivity\ to enable multi-device synchronization. Users can now load and play videos with Picture-in-Picture support, experience spatial audio, and participate in coordinated viewing sessions.

Day3 · high confidence

Added a new Day39 application target for visionOS that demonstrates immersive space management and real-time 3D mesh reconstruction using ARKit. The app provides a SwiftUI interface to launch immersive spaces in mixed, progressive, or full immersion styles, and utilizes the SceneReconstructionProvider to generate and render wireframe mesh models of the physical environment as the user moves.

Day39 · high confidence

Adds a new Day40 project for visionOS that launches a 2D SwiftUI window with a toggle to open an ImmersiveSpace. Inside the immersive space, a bird entity (Bird.usdz) loads with a spatial-audio component and plays bird-call sounds; a ChaserSystem tracks the device’s WorldTracking position and makes the bird chase or circle the user based on configurable distance thresholds, while a DeviceSystem anchors the scene to the real world.

Day40 · high confidence

The Day33 location now contains a complete visionOS application that demonstrates AR plane detection. The app features a main window with a toggle to open an immersive space, where a RealityKit view renders detected horizontal and vertical planes as colored overlays (e.g., blue for walls, red for floors) while skipping windows. The implementation includes the \PlaneDetectionModel\ for managing the ARKit session and plane updates, along with the necessary Xcode project structure, assets, and Info.plist configurations to support the immersive experience.

Day33 · high confidence

A new Day 11 application has been added, featuring a SwiftUI view that displays a title with a typewriter effect. The app includes a custom \TypeTextModifier\ that animates text character-by-character with a blinking cursor, controlled by a \ViewModel\ that tracks the current and final title states. The interface uses a \NavigationStack\ and applies a fade-in effect to supplementary text once the title animation completes.

Day11 · high confidence

This change introduces the Day 15 application, a SwiftUI project that showcases managing volumetric windows in augmented reality. The app features a home interface with a tabbed selection for 3D models (guitars, televisions, shoes) and uses a toggle to open a dedicated volumetric window displaying the selected model via RealityKit's Model3D. It includes the necessary Xcode project configuration, asset catalogs for the app icon, and the Swift source files for the app entry point, view models, and UI components.

Day15 · high confidence

A new standalone Day 24 application has been added, featuring a SwiftUI interface that allows users to toggle an immersive space. Inside this immersive environment, a large sphere renders a video texture sourced from the bundled 'ayutthaya.mp4' file using RealityKit and AVFoundation, providing a demonstration of immersive video playback capabilities.

Day24 · high confidence

This change introduces the Day 38 project, a standalone iOS/visionOS application that demonstrates placing and anchoring 3D cubes in a real-world environment using ARKit and RealityKit. The app manages world-sensing authorization, runs a WorldTracking session, and allows users to anchor virtual objects to physical surfaces so they remain stable in space. It includes the full Xcode project structure, SwiftUI views for entering and managing the immersive space, and utility extensions for matrix transformations.

Day38 · high confidence

A new standalone iOS application named Day12 has been added, featuring a SwiftUI interface that displays the user's current location on a hybrid map. The app utilizes CoreLocation's live updates API to track position changes in real-time, automatically panning the map to follow the user. It includes controls to start and stop location updates, persists the update state via UserDefaults, and supports background activity sessions to maintain tracking.

Day12 · high confidence

A new Day34 application has been added, introducing augmented reality image tracking capabilities on visionOS. The app features a main interface with a toggle to launch an immersive space, where a blue sphere is rendered and tracked in real-time over a physical reference image named 'marker1'. This functionality is implemented using ARKit's ImageTrackingProvider and is supported by the necessary asset catalog configurations for the image target and the app's immersive icon stack.

Day34 · high confidence

New Swift Package.swift manifests were added for the RealityKitContent package in both the Day9 and Day30 directories. These manifests define the package structure, specifying a minimum Swift version of 5.7 for Day9 and 5.9 for Day30, and configure a library product and target named RealityKitContent with no external dependencies.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 46 → 43 (-3.7)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 100 → 97 (-2.5)
• Architecture 100 → 99 (-0.6)
• Maturity 43 → 43 (+0.0)
• Readiness 15 → 11 (-4.3)
• Security 100 → 100 (+0.0)

• Concentrated knowledge decay
• Documentation: no usage examples (README.md)

• Dependency hygiene PARTLY measured — SwiftPM pinning read, dependency currency NOT established
• Documentation: no project overview (README.md)
• Dormant codebase
• Duplicated block (10 lines × 2) (Day27/Day27/Day27App.swift)
• Duplicated block (10 lines × 2) (Day33/Day33/Day33App.swift)
• Duplicated block (12 lines × 2) (Day13/Day13/ImmersiveView.swift)
• Duplicated block (14 lines × 2) (Day33/Day33/ImmersiveView.swift)
• Duplicated block (17 lines × 2) (Day21/Day21/ContentView.swift)
• Duplicated block (17 lines × 5) (Day10/Day10/ContentView.swift)
• Duplicated block (19–20 lines × 7) (Day27/Day27/ContentView.swift)
• Duplicated block (21 lines × 2) (Day38/Day38/ContentView.swift)
• Duplicated block (6 lines × 3) (Day14/Day14/ImmersiveView.swift)
• Duplicated block (8 lines × 2) (Day21/Day21/ImmersiveView.swift)
• Duplicated block (9 lines × 2) (Day21/Day21/Day21App.swift)
• Low cohesion: PeerToPeerModel (LCOM4 8) (Day37/Day37/PeerToPeerModel.swift)
• Low cohesion: ViewModel (LCOM4 4) (Day23/Day23/ViewModel.swift)
• Members sharing a duplicated core (5 members, 50+ identical tokens) (Day10/Day10/ContentView.swift)
• Members sharing a duplicated core (7 members, 50+ identical tokens) (Day27/Day27/ContentView.swift)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

satoshi0212/visionOS_30Days was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.