RealmWalker
Lead Programmer · Gameplay Systems Engineer

PROJECT DETAILS

Development: February 2025 – Present
Role: Lead Programmer
Genre: Roguelite Action RPG

Team Size: 10–20

DESCRIPTION

RealmWalker is an ongoing roguelite action game that I have been developing for over two years. I joined the project as a gameplay programmer focused primarily on combat, but as the project grew, my responsibilities expanded into gameplay architecture, systems design, technical leadership, and mentoring other programmers.

I eventually became the project's Lead Programmer, taking ownership of much of the game's technical foundation while working alongside a multidisciplinary team of roughly 10–20 developers across programming, art, animation, VFX, audio, and design.

Over the course of development, I have extensively refactored the project's existing architecture and continuously evolved its systems as the scope of the game expanded.

RealmWalker combines ability-driven spell combat, deep meta progression, procedural dungeons, procedural encounters and loot, elemental interactions, dynamic enemy AI, boss encounters, quest and spell drafting, challenge Rifts, and repeatable high-difficulty runs through its Descension system.

The project is still actively in development.

TECHNOLOGIES

Unreal Engine
Gameplay Ability System (GAS)
Blueprint
CommonUI
Behavior Trees
Procedural Generation
Data-Driven Gameplay Systems
Save / Load Systems
Cinematic & Dialogue Systems

AREAS

Gameplay Architecture
Gameplay Programming
Combat Systems
Ability Systems
AI Programming
Procedural Generation
Procedural Content
Meta Progression
UI Programming
Combat Design
Systems Integration
Technical Leadership
Codebase Refactoring
Cross-Discipline Collaboration
Programmer Mentorship

My Contribution

I joined RealmWalker primarily to work on combat programming. The project was introducing Unreal Engine's Gameplay Ability System, giving me my first significant experience with GAS.

As my understanding of the system grew, so did my responsibilities. I eventually became responsible for much of the game's gameplay architecture and took on the role of Lead Programmer.

Over more than two years of development, I have extensively refactored and reworked the project's underlying systems, focusing on creating gameplay architecture that is modular, data-driven, extensible, and capable of supporting a constantly expanding feature set.

My work spans nearly every major gameplay layer of RealmWalker, including:

Ability and spell systems
Spell upgrades
Combat and damage
Elemental interactions and status effects
Enemy AI
Combat encounter management
Boss encounters
Procedural dungeon generation
Procedural enemy spawning
Procedural loot
Rift challenges
Quest drafting
Spell drafting
Temporary run progression
Permanent meta progression
Aura and Corruption systems
Descension difficulty
Save and load architecture
UI and menu systems
Cinematics, dialogue, and subtitles
Gameplay system integration

A major part of my work has been connecting these systems together without allowing them to become tightly coupled. Rather than treating every feature as an isolated mechanic, I have focused on building reusable foundations that allow new gameplay to interact with existing systems.

Technical Leadership & Team Collaboration

As RealmWalker grew, my role expanded beyond individual gameplay systems into technical leadership across a multidisciplinary team of roughly 10–20 developers.

I work closely with programmers, artists, animators, VFX artists, audio designers, and other members of the development team to ensure that their work can integrate cleanly with the game's underlying systems.

My responsibilities include:

Mentoring and overseeing other programmers working within the project's gameplay architecture.
Establishing development patterns and conventions for gameplay systems.
Reviewing implementations and identifying architectural problems before they become difficult to unwind.
Helping programmers understand and work within shared gameplay frameworks.
Working with artists and animators to integrate gameplay requirements with character, animation, and visual systems.
Coordinating with VFX and audio contributors so gameplay events can consistently drive presentation and feedback.
Translating design requirements into technically viable gameplay systems.
Integrating work produced by different disciplines into shared gameplay frameworks.
Troubleshooting problems that span gameplay code, animation, VFX, UI, and audio.
Making architectural and implementation decisions with the needs of the wider team in mind.

Working with a team of this size has changed how I approach engineering. A system isn't successful simply because it works—it also needs to be understandable, extensible, and usable by the other developers building on top of it.

As Lead Programmer, I have to consider not only how a system should be implemented, but how it affects the workflow of everyone interacting with it.

Technical Highlights

Gameplay Ability System

GAS became the foundation of RealmWalker's combat architecture.

I built and continuously evolved the game's ability framework around the idea that spells should be modular gameplay systems rather than hard-coded character behavior.

Each spell can have three unique upgrades, allowing the same base ability to evolve substantially throughout a run.

This requires the ability system to interact with:

Player attributes
Gameplay effects
Damage calculation
Elemental interactions
Status effects
Enemy states
Temporary run progression
Spell upgrades
Aura modifications
Persistent progression

As the project grew, I repeatedly refactored the underlying ability architecture to prevent individual spells from becoming collections of special cases.

The goal is to make new spells and gameplay interactions build upon reusable systems and data rather than constantly expanding character-specific logic.

Spell Upgrades

Each spell can receive three unique upgrades, creating a layered progression system within individual abilities.

The challenge is allowing upgrades to substantially alter existing gameplay behavior without requiring every spell to have a completely unique implementation.

I structured the ability system around reusable modification points so upgrades can modify how an ability behaves while preserving its underlying architecture.

This allows a single spell to evolve significantly depending on the player's choices while keeping the implementation scalable as the number of spells and upgrades continues to grow.

Elemental Combat & Status Effects

RealmWalker's combat system uses an elemental stacking model to create interactions beyond raw damage.

Elemental applications accumulate stacks on enemies, with the corresponding status effect triggering when an element reaches 100 stacks.

This creates a distinction between simply dealing elemental damage and deliberately building toward a status effect.

The system must track elemental accumulation, evaluate thresholds, apply resulting status behavior, and manage the interaction between those states and the rest of the combat framework.

Because elemental behavior is integrated into the broader ability and damage architecture, spells can participate in the system without each implementing their own independent elemental logic.

Aura & Corruption System

One of RealmWalker's more unique progression systems is its Aura system.

During a run, players can acquire Auras that provide unique gameplay benefits and modify the way their character performs.

Auras can also be Corrupted.

Corrupting an Aura significantly increases its power while introducing a corresponding drawback. The important part of the system is that the negative effects become increasingly severe as the player accumulates more Corruptions.

This creates a deliberate risk/reward decision:

How much power is worth how much self-imposed difficulty?

From an engineering perspective, this requires separating an Aura's base behavior, its empowered state, and the cumulative scaling of its drawbacks so that individual Auras can remain data-driven rather than requiring bespoke implementations for every possible combination.

The result is a progression mechanic that gives the player direct agency over how aggressively they want to push their own power—and how much additional difficulty they are willing to accept in return.

Procedural Content

Procedural Dungeon Generation

Each RealmWalker run is assembled using a custom procedural dungeon generation system that I have designed and continuously refined throughout development.

Rather than relying on a fixed collection of handcrafted levels, the generator constructs dungeon layouts dynamically while maintaining the structural requirements necessary for a playable run.

The generator has evolved alongside the game, with the system built in layers so individual stages of generation can be modified without rewriting the entire pipeline.

This approach allows new room types, encounters, challenges, and progression requirements to be incorporated as the game expands.

The procedural system has therefore become more than a level generator—it acts as a foundation upon which much of RealmWalker's run-based content is constructed.

Procedural Enemy Spawning

Enemy encounters are also generated dynamically.

I developed the systems responsible for procedurally spawning enemies throughout generated content, allowing encounter composition to vary while still respecting the requirements of the room and progression structure.

This separates enemy behavior from encounter construction.

Individual enemies are responsible for knowing how to behave, while the spawning system determines when, where, and in what combination they should appear.

This makes it possible to introduce new enemy types without requiring the procedural generation system itself to understand every implementation detail of their behavior.

Procedural Loot

Loot is another part of the game's procedural content pipeline.

Breakable objects and chests can be procedurally spawned throughout the dungeon, giving players additional opportunities to discover resources and rewards during their runs.

Chests also participate in persistent progression, providing opportunities to unlock new starter spell choices that remain available in future runs.

This creates an intersection between procedural content and long-term progression: a randomly generated encounter can contribute toward permanent player advancement.

Rift Challenges

Throughout each run, players can discover Rifts—portals that transport them to compact challenge arenas where the normal dungeon gameplay loop is temporarily replaced by a focused objective.

I developed the gameplay systems supporting multiple Rift archetypes, with each challenge sharing a common framework while implementing its own objective and completion conditions.

Some Rift Challenges include:

Parkour Rift - Navigate a traversal-focused environment and reach the goal at the top.

Survive Rift - Remain alive until the countdown reaches zero.

Kill Rift - Defeat every enemy within the arena.

Progression Systems

Meta Progression

RealmWalker uses a persistent progression system built around Karmic Leaves used to purchase skills at the skill tree.

When a player dies, the majority of their run-specific progression is lost. Karmic Leaves, however, persist between runs and can be spent in a deep skill tree to permanently unlock new abilities and improvements.

This creates two distinct progression layers:

Run Progression - Temporary power gained during an individual attempt.

Meta Progression - Permanent advancement that survives death and influences future runs.

Keeping these systems separated is critical to ensuring that restarting a run can cleanly reset temporary gameplay state without affecting persistent progression.

The meta progression system also connects to other permanent unlocks, including additional starter spell choices, requiring persistent data to remain consistent across runs and save/load operations.

Quest & Spell Drafting

RealmWalker uses drafting systems to introduce controlled randomness into progression.

Quest drafting determines which objectives become available during a run, while spell drafting controls the choices through which players acquire and develop their spell arsenal.

These systems provide meaningful decisions without requiring every run to follow the exact same progression path.

The drafting systems are intentionally separated from the gameplay mechanics they modify. This allows the selection and presentation layer to evolve independently from the underlying progression and ability systems.

Descension System - Beating the game

After completing the game, players can continue into Descension runs.

Each level of Descension introduces modifiers that make the game progressively more difficult.

Successfully completing a Descension level unlocks a unique reward as well as access to the next level.

This creates a repeatable endgame progression layer on top of the standard roguelite loop.

From a systems perspective, Descension is designed to modify existing gameplay rules rather than creating a separate version of the game. Difficulty modifiers can therefore interact with the existing combat, dungeon, encounter, and progression architecture.

This makes the system both an endgame feature and a demonstration of the flexibility of the underlying gameplay framework.

Enemy AI & Encounter Systems

Enemy AI

RealmWalker's enemies use distinct behaviors and combat roles, with AI systems built around the needs of individual enemy types.

My work in AI includes designing and programming enemy behaviors, integrating them with the broader combat framework, and ensuring they function correctly within procedurally generated encounters.

The AI architecture is designed to separate individual enemy behavior from the systems responsible for constructing encounters, allowing enemies to operate consistently regardless of where or how they are spawned.

Boss Encounters

Bosses are built as structured gameplay encounters rather than simply larger enemies.

I have developed and integrated boss-specific gameplay behavior and cinematic introductions, allowing major encounters to transition from presentation into gameplay as part of a unified experience.

This requires cinematic sequencing, encounter state, gameplay logic, and presentation systems to coordinate so the player can move naturally from an introduction into the actual encounter.

Combat Tokens

One of RealmWalker's more important encounter systems is the Combat Token system.

Rather than allowing every enemy in an encounter to attack simultaneously, enemies compete for a limited number of opportunities to engage the player.

This creates a controlled combat cadence where enemies take turns attacking rather than overwhelming the player through unrestricted simultaneous actions.

The system effectively separates:

What an enemy wants to do

from

When the encounter allows it to act.

This gives encounters greater control over pacing while allowing multiple enemies to remain active without turning every fight into an unreadable collection of simultaneous attacks.

It also provides a central point where encounter-level rules can influence enemy behavior without requiring every individual AI implementation to understand the entire combat system.

Cinematics, Dialogue & Presentation

RealmWalker includes a full introductory cinematic when starting a new game, as well as custom cinematics throughout the experience, including boss introductions.

I have worked on the systems connecting these sequences with voice lines and subtitles, allowing cinematic presentation, audio, dialogue, and gameplay state to function together.

The goal is to make these sequences feel integrated into the game rather than disconnected video segments, allowing gameplay to transition naturally into and out of cinematic events.

UI & CommonUI

I have designed and programmed a large portion of RealmWalker's UI systems.

The project uses Unreal's CommonUI framework to establish consistent workflows for menus and interactive widgets.

UI work spans progression screens, spell and upgrade selection, drafting interfaces, settings, gameplay information, and other systems that need to communicate complex gameplay state to the player.

Because much of the game's gameplay is data-driven, the UI needs to dynamically represent information coming from the underlying gameplay systems rather than relying on individually authored interfaces for every possible combination of abilities, upgrades, progression, and rewards.

Save & Load Architecture

RealmWalker's combination of temporary run progression and persistent meta progression makes save architecture particularly important.

The save system handles persistent progression and player settings while maintaining a clear separation between information that should survive death and information that belongs exclusively to the current run.

This includes managing distinctions between:

Persistent progression
Run-specific progression
Unlocks
Karmic Leaves
Starter spell unlocks
Player settings
Long-term player state

Maintaining this separation ensures that a run can be reset according to roguelite rules without accidentally affecting persistent progression.

Architecture & Refactoring

One of the largest contributions I have made to RealmWalker isn't a single gameplay feature.

It is the continuous architectural refactoring of the project itself.

After working with the systems over an extended period, I have repeatedly revisited earlier implementations as the game's requirements changed.

Systems that were initially built to solve a single gameplay problem have been generalized, separated, or replaced when their original architecture began limiting further development.

This has included reworking gameplay frameworks, reducing unnecessary coupling, establishing reusable patterns, and creating clearer boundaries between systems.

The goal has been to avoid the common problem of a long-running game project becoming increasingly difficult to modify as new features are layered on top of old implementations.

RealmWalker has therefore become as much an exercise in maintaining and evolving a large gameplay codebase as it has been in implementing individual mechanics.

Technical Philosophy

The most important lesson from developing RealmWalker over an extended period has been that architecture is not a one-time decision.

A system that is appropriate when a project contains five spells may not be appropriate when it contains dozens of abilities, extensive procedural content, persistent progression, and multiple layers of modifiers.

As the game has grown, I have continuously refactored the codebase around new requirements rather than allowing the original implementations to dictate the direction of the project.

I place a strong emphasis on modularity, data-driven design, clear system boundaries, and reusable gameplay logic.

This has allowed systems such as Auras, Corruptions, Descension modifiers, elemental interactions, Rifts, and additional spell upgrades to build upon existing foundations rather than requiring completely independent implementations.

Outcome

RealmWalker is still actively in development and has grown from a combat-focused project into a large-scale roguelite gameplay framework spanning combat, progression, procedural generation, AI, UI, cinematics, persistence, and content generation.

Over more than two years of development, I have progressed from learning GAS for the project's combat system to becoming the Lead Programmer responsible for much of its gameplay architecture.

The project has given me experience not only implementing complex gameplay systems, but also maintaining, refactoring, and evolving those systems over an extended development cycle while supporting a multidisciplinary team.

Working with programmers, artists, animators, VFX artists, audio designers, and designers has also taught me that gameplay engineering doesn't happen in isolation. A successful system needs to provide the technical foundation that allows the rest of the team to create their work effectively.

RealmWalker represents my strongest demonstration of long-term gameplay engineering and technical leadership: building complex systems, maintaining a large and evolving codebase, mentoring other programmers, and creating architecture flexible enough to support a game that continues to grow.

RealmWalker is currently in active development.