Summary
Type: Professional Experience
Completed: Released
Acquirable: WatchOS
My Role: UI Programmer
Studio: Gameloft (Brisbane)
Time at the studio: November 2021 - March 2024
Overview
I worked on The Oregon Trail: StepTracker, a companion app for Apple Watch that tracked daily steps and synced player activity into the Apple Arcade version of The Oregon Trail. My responsibilities spanned both SwiftUI development on the watch app and Blueprint/UI integration inside the main game.
This project required bridging two completely different ecosystems — Apple HealthKit on watchOS and Unreal Engine UI systems on iOS — while keeping the interaction simple enough for casual mobile/watch users. I built the UI according to UI artist mockups, engineered a custom animation system for sprites (since SwiftUI does not support sprite sheets), and implemented the logic that pushed step data into the game.
This project showcased my ability to learn new technologies quickly, integrate across platforms, and support designers with reliable technical implementation.
Audience & Platform Context
The StepTracker was aimed at:
• Players already engaged with the Apple Arcade game
• Casual fitness-style users who check their watch frequently
• Players expecting immediate, low-friction interactions
• Users in short play sessions (seconds, not minutes)
This meant the UI needed to be:
• Extremely simple
• Readable on a small screen
• Consistent with the visual identity of the main game
• Stable and reliable even without opening the iOS app
These constraints informed every technical decision I made.
My Role
I did not design the UI layouts or art assets. My work focused on the technical realisation of the designer/artist’s vision, including:
• Implementing UI mockups using SwiftUI
• Connecting the Apple Watch app to Apple Health step data
• Pushing step counts to the main game through existing sync systems
• Creating a sprite animation pipeline SwiftUI does not natively support
• Ensuring consistent behaviour across the iOS app, Apple Watch app, and in-game UI
• Enabling designers to make spreadsheets populate game data for localisation and game design
• Supporting designers by clarifying interaction edge cases and ensuring the feature worked as intended
This required combining engineering, platform understanding, and design-supportive decision-making.
Key Contributions
SwiftUI UI Implementation
This was my first production work in SwiftUI, where I built:
• The full StepTracker UI based on artist mockups
• State-driven layouts that responded to step count changes
• Logic for updating visuals at various step thresholds
• Scalable layouts that worked across different Watch sizes
I adapted quickly to Apple’s declarative UI workflow and worked within platform constraints.
Custom Sprite Animation System for watchOS
SwiftUI does not support sprite sheets or frame-by-frame animation by default, so I engineered a small custom system to:
• Load sprite sequences
• Display them frame-by-frame
• Control timing of frames
• Avoid performance issues on watch hardware
This allowed the watch app to include charming, animated visuals that matched the feel of the main game.
UI Integration Inside The Oregon Trail (Main Game)
Inside Unreal Engine, I implemented the UI logic that:
• Received the synced step data
• Refreshed widgets using the updated activity values
• Handled edge cases where data failed or permissions weren’t granted
• Preserved a consistent experience between platforms
This helped unify the watch app and the main game into a single cohesive feature.
What I Delivered
• Full SwiftUI implementation of the StepTracker Apple Watch UI
• Custom sprite animation framework for watchOS
• HealthKit permissions and step-data integration
• Cross-platform syncing logic to Unreal Engine
• Blueprint/UI updates inside the main game to reflect step activity
• Reliable behaviour across watchOS + iOS + Unreal Engine systems
How This Shows My Technical Design Strengths
This project demonstrates my ability to take a designer’s vision and make it functional across entirely different systems. It required:
• Understanding player context and usage patterns
• Translating design intent into technical behaviour
• Integrating two platforms that don’t naturally communicate
• Designing a mini-system (sprite animation) where the engine lacked features
• Solving usability and clarity problems introduced by platform constraints
It reflects the strengths of a Technical Designer: bridging design goals with reliable implementation, adapting quickly to new tech, and ensuring the final feature supports the intended player experience.
What I’d Do Next Time
If I revisited this project, I’d implement far more on-device debugging features. Without them, testing step count updates required running through Xcode workflows and manually simulating data. A simple debug overlay or internal test mode would have saved time and allowed for faster iteration.
In future watchOS work, I would:
build dedicated debug screens to generate fake step data
log animation state transitions directly on device
allow designers/testers to verify behaviour without Xcode
These improvements would make iteration considerably smoother.
