Pangea
A native iPhone action RPG with an original world and a custom Metal renderer.
Native iPhone prototype in development. No public download is available yet; the scenes and characters shown are provisional.
Overview.
Pangea is a native iPhone action RPG that connects my software work with the world behind my fiction. The current playable prototype brings exploration, combat, equipment, environmental conditions, companions and ruin puzzles into one short adventure.
I’m building the game around Swift runtime packages and a custom Metal renderer. The interesting engineering problem is keeping the world, controls, presentation and saved progress in agreement as those systems grow. Touch and controller input share the same gameplay rules, and the interface exposes inventory, journals, maps and accessibility settings through native screens.
The game is in development. The screenshots show an actual simulator build and native renderer captures with provisional geometry and art. Final assets, physical-device performance and broader playtesting are still part of the work ahead.
Screens & workflows.
Application screens and development prototypes. Select a capture for a closer look.
Explore the route
- Move through the forest with the virtual stick or a supported controller.
- Orbit, raise, lower or recenter the tactical camera to inspect the terrain.
- Approach a nearby point of interest and use its contextual Inspect, Gather or Use action.
- Open the journal or discovered map to review progress and route information.
Read an encounter
- Select a target and watch the visible attack preparation.
- Use sword or bow attacks while managing range, facing and stamina.
- Dodge, parry or guard in response to the attack.
- Return to an earned practice encounter to rehearse without advancing adventure rewards.
Prepare for the field
- Open inventory to inspect carried items and equipped gear.
- Compare equipment or prepare available food and clothing.
- Use fieldcraft and camp actions as weather and exposure change.
- Resume the route with the same authoritative inventory and equipment state.
Pause, adjust and return
- Pause before opening settings or managing a checkpoint.
- Adjust accessibility preferences and the Battery, Balanced or Quality graphics ceiling.
- Save at an accepted stable gameplay boundary.
- Load a validated checkpoint, with an explicit recovery option when the previous managed save is needed.
Inside the build.
Explore the components, their boundaries, and the decisions behind them.
A native SwiftUI shell hosts a deterministic Swift simulation and a MetalKit rendering surface. Domain packages own gameplay decisions; immutable snapshots carry the accepted state into rendering and interface code. Save recovery, input delivery and graphics diagnostics have separate ownership boundaries.
Native shell & semantic input
Present the HUD and native panels, translate gestures and controller events, and coordinate app lifecycle changes.
- GameShellView composes the Metal world with independent HUD, feedback and bottom-control overlays so larger text does not reposition movement controls.
- Touch gestures and physical-controller edges become shared semantic actions rather than separate combat implementations.
- Scene transitions stop held input and suspend active work; camera and accessibility actions use the same bounded camera policy.
Design decisions & tradeoffs.
Separate simulation authority from presentation
The gameplay packages decide outcomes, then publish snapshots. Metal and SwiftUI consume that state without owning a second set of collision, damage or reward rules.
The tradeoffThis makes rendering and interface changes easier to test, but requires explicit adapters and careful snapshot lifecycle management.
Use the native Apple stack
SwiftUI handles menus and accessible controls while MetalKit renders gameplay. Semantic input connects touch and Game Controller support to the same simulation.
The tradeoffThe design gives direct control over iPhone behavior and rendering, while also making engine tooling and any future non-Apple port my responsibility.
Treat saves as a versioned contract
Managed current/previous slots, checksums and full-route validation make recovery an explicit operation. Migrations preserve recorded progress and reject inconsistent state.
The tradeoffCompatibility needs fixtures and migration work for each schema change, but an old or damaged checkpoint cannot silently rewrite the adventure.
Scale the world without scaling the interface
Quality ceilings control the Metal drawable and frame budget while native HUD and settings stay sharp. Thermal state and Low Power Mode can lower effective quality.
The tradeoffVisual quality varies with device conditions, and sustained phone testing is still needed to qualify the final limits.
Technical stack.
Application & language
- Swift 6
- SwiftUI
- UIKit
- Swift Package Manager
Native iPhone shell, lifecycle coordination, accessible menus and independently testable domain packages.
Rendering
- Metal
- MetalKit
- Metal Shading Language
- simd
Custom gameplay rendering, PBR materials, resource budgeting, shadows and immutable render snapshots.
Input & feedback
- Game Controller
- AVFoundation
- Combine
- UIKit haptics
Controller delivery, touch action coordination, audio lifecycle and feedback from accepted gameplay events.
Content & persistence
- Codable
- CryptoKit
- Swift actors
- Versioned save schemas
Typed content packs, integrity checks, serialized save recovery and explicit migration of older checkpoints.
Verification
- XCTest
- Swift Testing
- Xcode Simulator
- Metal GPU readback
Deterministic domain tests, native integration journeys and actual rendered-frame evidence; physical-device qualification remains ongoing.