Solo 3D platformer built around a phase-shifting mechanic
Phase Run is a third-person platformer built around a reality-shifting mechanic that changes how the environment behaves. Players can switch between normal and “phase” states, causing platforms to appear or disappear, turning straightforward jumps into timing-based puzzles that require awareness, precision, and decision-making rather than speed alone.
The project was developed as a solo design-focused experience centered on exploring how a single mechanic can drive both challenge and player learning. The design emphasis was on clear feedback, readable systems, and structured difficulty progression, ensuring that complexity comes from mastering the mechanic rather than from added systems or unnecessary features.
Gameplay video coming soon
Role:
Solo Game | Level Designer
Tools:
• Unreal Engine 5 (Blueprints)
• Unreal Engine Level Design Tools
• Basic UI Systems (UMG)
• Post-Process & Audio Feedback Systems
Team Size: 1
Responsibilities:
• Core mechanic design and Blueprint implementation
• Platform state logic and interaction systems
• Level layout and difficulty progression
• Player feedback systems (visual + audio)
• UI implementation and gameplay flow
• Playtesting, debugging, and mechanic balancing
Mechanic-Driven Level Design
Phase Run was built around designing levels that teach, reinforce, and challenge a single mechanic. Early stages introduce the phase system in controlled scenarios, while later levels combine moving platforms, timing challenges, and tighter platforming to test player mastery.
Level layouts were structured to ensure players first understand what the mechanic does, then gradually learn when to use it under increasing pressure. The environment itself becomes a dynamic puzzle where pathing changes based on the player's state.
Player Feedback & Readability
A key design goal was ensuring the player always understands their current state and the consequences of their actions. Visual effects, UI indicators, material differences, and audio cues were used to clearly communicate when the player is in phase mode. Platform behaviors were designed to be consistent and rule-based, reinforcing player trust in the system.
This clarity ensured that difficulty came from execution and timing, not uncertainty or unclear mechanics.
Difficulty Progression
Each level was designed to add one new layer of complexity at a time — first static phase platforms, then combining movement with phasing, and finally introducing moving platforms and timing-based challenges. Spacing, jump distances, and platform speed were iterated on to create increasing tension without creating unfair failure states.
Early Mechanic Confusion
During early testing, players sometimes struggled to understand why certain platforms were solid at one moment and gone the next. While the underlying logic was correct, the feedback surrounding the mechanic was not strong enough to communicate the rule set clearly.
Iteration & Solution
To address this, I refined platform materials, introduced post-process state changes, and added UI and audio feedback when switching phase states. I also reworked some level layouts so players could observe the mechanic in action before being tested on it, reinforcing learning through level structure rather than tutorials.
Result
These changes made the mechanic feel readable and intentional, significantly reducing confusion and allowing later challenges to feel fair and skill-based rather than unpredictable.
Designing Around a Single Mechanic
Phase Run reinforced how much depth can come from one strong core idea. By focusing on variations of one mechanic instead of stacking systems, I was able to create clearer learning curves and more cohesive gameplay.
Clarity Over Complexity
I learned that even simple mechanics need strong technical feedback systems. Visual effects, UI, and sound design were essential in bridging the gap between system logic and player perception.
Gameplay Pacing & System Reliability
Balancing a platformer isn’t just about jump distance — it involves timing windows, readability, recovery opportunities, and consistent system behavior. Iterating on Blueprint logic and level layout helped smooth difficulty spikes and maintain gameplay flow.