Accelerating ray tracing using Metal

At a glance

Project structure

Source bundle/
├── Application/
│   ├── main.m
│   ├── AppDelegate.m
│   ├── AppDelegate.h
│   ├── ViewController.h
│   ├── ViewController.mm
│   ├── WindowSceneDelegate.h
│   └── WindowSceneDelegate.m
└── Renderer/
    ├── Scene.h
    ├── Scene.mm
    ├── ShaderTypes.h
    ├── Shaders.metal
    └── Renderer.h

Structure observations

• Architecturally prominent files are ranked from entry points and role-named declarations; resource-only paths are omitted.
• Primary languages: C/Objective-C header, Metal, Objective-C, Objective-C++.
• The verified tree contains 7 project/configuration file(s) and 22 source declaration(s).

Overall architecture

flowchart LR
    N1["main"]
    N2["ViewController"]
    N3["Renderer"]
    N4["Metal APIs"]
    N1 --> N2
    N2 --> N3
    N3 --> N4

Reference code

Application/main.m:20 — architecture anchor

#if !TARGET_OS_IPHONE
int main(int argc, const char * argv[]) {
    return NSApplicationMain(argc, argv);
}
#endif

Interpretation

The arrows summarize the source-visible entry, role-named types or folders, and framework direction; when nodes come from structural folders, the sequence is a high-level interpretation rather than proof that every adjacent node calls the next. Ownership is claimed only where the next section cites a stored property or assignment. The diagram is intentionally limited to the dominant path into Metal.

Ownership and state

classDiagram
    BoundingBox o-- id : device
    BoundingBox o-- NSString : intersectionFunctionName
    BoundingBox o-- Geometry : geometry
    BoundingBox o-- matrix_float4x4 : transform

Ownership evidence

Renderer/Scene.h:40 — stored dependency or nearest verified ownership anchor

#ifndef Scene_h
@property (nonatomic, readonly) id <MTLDevice> device;
#endif

Composition arrows indicate a source-visible construction expression or locally owned value state; aggregation means the owner stores or receives a dependency without proving exclusive lifetime ownership.

Concurrency, scheduling, and thread safety

Evidence limit: actor isolation, async/await, or Task creation does not by itself prove background-thread execution; Sendable conformance alone does not prove thread-safe mutation.

No source-visible execution, scheduling, or synchronization boundary was found in the indexed source.

@MainActor/MainActor.run, DispatchQueue.main, and RunLoop.main are reported as distinct isolation, queue, and event-loop mechanisms. A plain Task is kept separate from Task.detached; neither is labeled as a background thread.

State propagation, frameworks, and dependencies

Evidence limit: an import proves a source-level compilation dependency at the cited line; it does not prove runtime use, architectural adoption, or whether a Swift package is a direct application dependency.

receive(on:) describes downstream delivery scheduling, while subscribe(on:) describes upstream subscription/request/cancel scheduling. An import Combine alone establishes neither behavior nor a Store, reducer, Redux, or other application architecture.

Class and protocol design

Renderer/Scene.h:110 — representative type boundary

#ifndef Scene_h
@interface Scene : NSObject
@end
#endif

No local protocol conformance is claimed as protocol-oriented design; external framework conformances are listed only as dependencies.

Access control

Reference code

Application/AppDelegate.h:21 — representative boundary

#if !TARGET_IOS
@property (strong, nonatomic) PlatformWindow *window;
#endif

Swift declarations without a modifier are internal; explicit private, fileprivate, private(set), public, or open entries above are interpreted by language semantics. Objective-C/C samples instead rely on header and implementation boundaries, which are not equivalent to Swift lexical privacy.

Logic ownership and placement

Design patterns

Main application flow

sequenceDiagram
    participant Renderer
    participant _device
    participant _queue
    participant commandBuffer
    participant commandEncoder
    Renderer->>_device: accelerationStructureSizesWithDescriptor()
    Renderer->>_device: newAccelerationStructureWithSize()
    Renderer->>_device: newBufferWithLength()
    Renderer->>_queue: commandBuffer()
    Renderer->>commandBuffer: accelerationStructureCommandEncoder()
    Renderer->>commandEncoder: buildAccelerationStructure()
    Renderer->>commandBuffer: commit()
    Renderer->>commandBuffer: commit()

Reference code

Renderer/Renderer.mm:424 — newAccelerationStructureWithDescriptor()

- (id <MTLAccelerationStructure>)newAccelerationStructureWithDescriptor:(MTLAccelerationStructureDescriptor *)descriptor
{
    // ...
    MTLAccelerationStructureSizes accelSizes = [_device accelerationStructureSizesWithDescriptor:descriptor];
    id <MTLAccelerationStructure> accelerationStructure = [_device newAccelerationStructureWithSize:accelSizes.accelerationStructureSize];
    id <MTLBuffer> scratchBuffer = [_device newBufferWithLength:accelSizes.buildScratchBufferSize options:MTLResourceStorageModePrivate];
    id <MTLCommandBuffer> commandBuffer = [_queue commandBuffer];
    id <MTLAccelerationStructureCommandEncoder> commandEncoder = [commandBuffer accelerationStructureCommandEncoder];
    id <MTLBuffer> compactedSizeBuffer = [_device newBufferWithLength:sizeof(uint32_t) options:MTLResourceStorageModeShared];
    [commandEncoder buildAccelerationStructure:accelerationStructure
                                    descriptor:descriptor
                                 scratchBuffer:scratchBuffer
                           scratchBufferOffset:0];
    [commandEncoder writeCompactedAccelerationStructureSize:accelerationStructure
                                                   toBuffer:compactedSizeBuffer
                                                     offset:0];
    [commandEncoder endEncoding];
    [commandBuffer commit];
    [commandBuffer waitUntilCompleted];
    uint32_t compactedSize = *(uint32_t *)compactedSizeBuffer.contents;
    id <MTLAccelerationStructure> compactedAccelerationStructure = [_device newAccelerationStructureWithSize:compactedSize];
    commandBuffer = [_queue commandBuffer];
    commandEncoder = [commandBuffer accelerationStructureCommandEncoder];
    [commandEncoder copyAndCompactAccelerationStructure:accelerationStructure
                                toAccelerationStructure:compactedAccelerationStructure];
    [commandEncoder endEncoding];
    [commandBuffer commit];
    return compactedAccelerationStructure;
}

Naming conventions

• Types: Controller: ViewController; Delegate: AAPLAppDelegate, AAPLWindowSceneDelegate, WindowSceneDelegate; Renderer: Renderer; Scene: Scene.
• Protocols: no local protocol declaration in the scanned source.
• Methods: initWithDevice, clear, uploadToBuffers, geometryDescriptor, resources, addCubeWithFaces, addSphereWithOrigin, initWithGeometry.
• Files: Renderer/Scene.h, Renderer/Scene.mm, Application/ViewController.h, Application/ViewController.mm, Application/WindowSceneDelegate.h, Application/WindowSceneDelegate.m.

Architecture takeaways

• main is the main source-visible entry or composition anchor for this sample.
• Framework work reaches simd, Metal, UIKit, Cocoa through a deliberately small high-level chain; the detailed API graph remains inside the cited implementation files.
• Stored-property evidence identifies lifecycle collaboration; it does not by itself prove exclusive object ownership.
• Access-control conclusions separate verified language visibility from the likely design rationale.
• The source does not justify labeling the design protocol-oriented.

Source map

• Official Apple documentation