Technical Portfolio
I build modular gameplay systems, editor tools and maintainable technical foundations for Unreal Engine projects, backed by professional experience in cloud platforms, backend systems and technical leadership.
Featured Project
Despite Time is a long-term Unreal Engine action RPG project by Gunblade Games GmbH, focused on fast combat, modular systems and a world fractured between timelines.
Role
Founder · Lead Developer · Technical Direction
Engine
Unreal Engine 4/5
Modular gameplay systems
Editor tooling and workflow automation
C++ / Blueprint architecture
Technical direction and production planning
Selected Work
Many of these systems share the same core foundations: reusable modifiers, extensible requirements, centralized settings, and lightweight Data Assets that are mapped into runtime gameplay objects. This keeps features consistent while allowing abilities, story events, world interactions, and visual feedback to build on the same architecture.
Gameplay Architecture
Built a modular Unreal Engine ability framework where designers can define active skills, passive effects, and combat behavior through lightweight Data Assets. The system keeps editor authoring simple while runtime mapping, caching, and extensible execution logic handle the actual gameplay complexity.
Designer-friendly ability creation through lightweight Data Assets
Dynamic DataAsset-to-runtime-object mapping with caching
Uses modifier system for stats, status effects, feedback, and technical effects
More predictable content configuration
Extensible requirement checks for ability access and effect validation
Complex gameplay abilities can quickly become difficult to maintain when every feature needs custom actors, duplicated Blueprint logic, or one-off implementation paths. I wanted a system that kept the editor workflow simple while still supporting highly flexible combat behavior, progression, effects, and technical feedback.
I designed abilities around simple editor-facing Data Assets and mapped them dynamically into runtime gameplay objects when the game starts or when they are needed. A generic modifier system handles the actual effects, while an extensible requirement system decides whether an ability or effect is currently valid.
The result is a reusable foundation where new abilities and effects can be assembled from data instead of being rebuilt from scratch. The same architecture can support combat skills, passive bonuses, status effects, camera shakes, default character abilities, and other gameplay behaviors through shared systems.
The system separates authoring data from runtime behavior. Data Assets define what an ability is, while the runtime mapping layer creates or resolves the actual gameplay objects needed during play. This avoids placing heavy gameplay objects directly in the editor and keeps content configuration lightweight. Modifiers provide the effect layer of the system. Instead of implementing every ability outcome as a special case, abilities can apply reusable modifier objects that grant attributes, unlock abilities, trigger feedback, apply status effects, or interact with other gameplay systems. Requirements act as the validation layer and can be extended to check player state, unlocked features, equipment, level history, nearby objects, or other world conditions.
Ability Hit
OnHitActor(WeaponHand, Target, Instigator);
IAbilityUser::Execute_OnAbilityHitSomething(GetUserObject(), this, Target,
HitBox, WeaponHand, PotentialCalculationResult.Potential);
IAbilityDamageable::Execute_OnHitByAbility(Target, this, HitBox,
GetUserAsActor(), WeaponHand, PotentialCalculationResult.Potential);
HandleExtensionsByTriggerPoint(EAbilitySpecialTriggerPoint::Hit);
HandleParticleEffectsByTriggerPoint(EAbilitySpecialTriggerPoint::Hit);
OnHitActor_HandleModifiers(Target);
OnHitActor_HandleStagger(WeaponHand, Target,
PotentialCalculationResult.Potential, Target->ActorHasTag(
TAG_ReactiveMontage_NoAnim));
VisualizeHit(Instigator, WeaponHand, HitBox, ImpactPoint,
FVector::ZeroVector, TraceDirection, PhysicalSurfaceType, CurrentChainStep,
PotentialCalculationResult);
Data Mapping via Interface
void UBaseAbility::TryToMap_Implementation(FPrimaryAssetId NewId)
{
if(NewId.IsValid())
Id = NewId;
if(bInMappingProcess || bMapped)
return;
UDataMappingSubsystem* DataMappingSubsystem =
UGlobalGetterLibrary::GetDataMappingSubsystem();
DataMappingSubsystem->GenericMapPrimaryObject(Id, this);
}
Narrative Tooling
Extended a third-party plugin into a custom Unreal Engine story pipeline for dialogue, decisions, and gameplay consequences. Story content is authored visually, converted into structured Data Assets, and resolved at runtime through the same mapping approach used by gameplay systems.
Visual story authoring extended into a custom gameplay pipeline
Converts authored story content into reusable Data Assets
Branching dialogue and decisions driven by gameplay state
Consequences can grant rewards, alter character state, or unlock abilities
Narrative content often needs more than simple dialogue playback. Story fragments may depend on player progress, unlocked abilities, visited levels, nearby objects, character state, or previous choices. Story events also need to trigger consequences such as granting items, changing character state, unlocking abilities, or applying negative effects.
I extended the story workflow so authored content can become structured Data Assets and participate in the same runtime mapping system as gameplay features. Story fragments use requirements to decide whether they are available and modifiers to apply consequences when dialogue, decisions, or story events are reached.
The story system became part of the wider gameplay architecture instead of a separate isolated tool. Dialogue, decisions, consequences, character state, rewards, and progression checks can reuse the same foundations as abilities and world interactions.
The story system is built around StoryFragments: individual pieces of narrative content such as dialogue lines, decisions, or story events. These fragments are authored in a visual story flow, converted into custom Data Assets, and then resolved into runtime objects through the same Data Mapping layer used by other systems. Requirements determine whether a fragment is currently available. This allows story content to react to gameplay state, world progress, unlocked abilities, equipment, level history, or nearby objects. Modifiers handle the consequences of story events, such as granting items, changing SoulType, unlocking abilities, or applying other positive and negative effects.
Load From Database
for (FPrimaryAssetId StoryFragmentContainerId : StoryContainers){
UStoryFragmentContainer* Container =
NewObject<UStoryFragmentContainer>(this);
IMappableObject::Execute_TryToMap(
Container, StoryFragmentContainerId);
StoryFragmentContainers.Add(Container);
}StoryFragment - SetDone
ABaseCharacter* PlayerCharacter =
UGlobalGetterLibrary::GetPlayerAsBaseCharacter(WorldContext);
if(ExecuteImpacts){
for (const FPrimaryAssetId ModifierId : ModifiersOnCompletion){
PlayerCharacter->GetModifierComponent()->RegisterModifier(
ModifierId, nullptr, true, false,
EModifierRegistrationDemand::StoryEvent_Completion);
}
}
if (!EventOwner)
return;
ABaseCharacter* EventOwnerAsCharacter =
Cast<ABaseCharacter>(EventOwner.GetObject());
if (!EventOwnerAsCharacter)
return;
UNPCComponent* NPCComponent =
Cast<UNPCComponent>(EventOwnerAsCharacter->GetComponentByClass(
UNPCComponent::StaticClass()));
if(!NPCComponent)
return;
for (UMemory* Memory : GeneratedMemoriesOnCompletion) {
//Add Memories to event owner so he remembers
NPCComponent->AddMemory(Memory);
}
World Systems
Built a project-wide time and atmosphere system exposed through Unreal Project Settings. Time-of-day profiles can control the visual mood of the world, including atmosphere, exposure, and related presentation settings, while a connected color grading system allows different looks to be tested and applied consistently.
Centralized time-of-day profiles exposed through Project Settings
Atmosphere and exposure settings tied to global time definitions
Smooth transitions between different visual moods
Global color grading profiles for consistent look development
Editor-friendly testing of different world moods and presentation styles
World mood and visual presentation can become inconsistent when lighting, exposure, atmosphere, and color grading are adjusted manually per level or per situation. I wanted a centralized way to define how different times or moods should feel and make those profiles accessible to both code and editor workflows.
I created global time and atmosphere profiles exposed through Project Settings, allowing the game to define how different times of day should look and feel. A related global color grading system uses the same idea: profiles can be configured centrally, previewed in editor workflows, and applied later through gameplay code.
The system gives the project a consistent visual language and makes mood changes easier to manage. Time-of-day changes can transition toward defined atmosphere and exposure settings, while color grading profiles provide reusable looks for testing, gameplay, and level presentation.
The framework uses global project-facing configuration instead of scattering visual mood settings across individual levels or actors. Time profiles define how a specific time or mood should influence the world, and those values can be consumed by runtime systems to transition the active visual presentation. The color grading side follows the same philosophy. Profiles are defined centrally and can be applied through code or tested directly in editor workflows. This keeps look development flexible while making it easier to maintain consistency across levels, gameplay states, and story moments.
Leadership & Engineering Background
A cross-disciplinary background combining software architecture, cloud platforms, infrastructure, Unreal Engine development and studio leadership.
Cloud
Platform Architecture
UE4/5
Game Development
C++
Systems Programming
Studio
Technical Direction
Founder & Managing Director
Technical direction, project planning and production ownership for long-term independent game development.
Project planning and technical direction
Contributor and intern coordination
Production, business and engineering alignment
Tools and processes for long-term maintainability
Cloud & Platform Architecture
Professional engineering experience across backend systems, cloud infrastructure, delivery pipelines and maintainable platform architecture.
CI/CD pipelines with Azure DevOps and GitHub Actions
Kubernetes, Helm and Terraform
Azure and AWS cloud infrastructure
Security, monitoring and performance optimization
Technical Stack
A compact overview of the engineering areas I use across game development, tooling, architecture and cloud-backed platforms.
Contact
Contact
I’m open to technical collaborations, Unreal Engine work, architecture discussions and opportunities where solid engineering can move a project forward.