Performance Engineer

Devoted Studios is a globally remote game development company specializing in Co-development, Porting, and End-to-End Art Production for the global gaming industry. We collaborate across time zones to support projects on all major platforms, engines and styles - from AAA titles to emerging technologies.

Our team includes world-class talents who bring deep expertise in external development, pipeline optimization, and creative problem-solving. Whether it’s porting games to new systems, enhancing gameplay features, or crafting stunning visuals, Devoted Studios operates as a trusted, flexible extension of our partners’ internal teams.

We are proud to be the development partner of choice for industry leaders such as:

• Epic
• Xbox
• Meta
• Obsidian Entertainment
• Riot
• Gearbox Software

In this role, you will own and drive the development of core systems and performance initiatives from planning and design through implementation and optimization. Working closely with engineers and cross-disciplinary teams, you will provide technical leadership and feature ownership.

• Profile and optimise the game thread, render thread, and RHI thread in Unreal Engine — identifies cross-thread bottlenecks, tick overhead, and task graph inefficiency

• Diagnose and resolve hitching: garbage collection pauses, streaming stalls, async loading conflicts, physics simulation spikes

• Reduce tick overhead: identifies UObjects and Actor Components with unnecessary tick enabled, unnecessary work in hot paths, incorrect tick group assignments

• Optimise gameplay and engine code at the C++ level — not just profiling and handing recommendations to another engineer; writes and ships the fix

• Instruments custom profiling markers (_COUNTER, _TIMING_STAT, custom Unreal Insights channels) for ongoing regression detection

• Profiles rendering performance using Render Doc, PIX, NSight, Xcode GPU Frame Capture, and Unreal's GPU Visualiser — isolates draw call overhead, overdraw, shader complexity, and GPU memory bandwidth

• Works with the rendering team to optimise material pipelines: shader permutation reduction, LOD tuning, occlusion culling, distance field shadow optimisation

• Identifies and resolves GPU memory pressure: texture streaming configuration, render target pooling, VRAM budget management per platform

• Understands the rendering architecture deeply enough to distinguish CPU-bound vs GPU-bound vs bandwidth-bound frames and route the fix correctly

• Targets platform-specific GPU constraints: the PS5/Xbox Series GPU architecture differs meaningfully from PC; mobile (Adreno, Mali, Apple GPU) has its own thermal and bandwidth profile

• Owns memory budget compliance on client engagements: tracks resident set size, texture memory, audio memory, and engine overhead against platform limits

• Finds and eliminates memory leaks in C++ using both automated tooling (ASan, Valgrind on non-console platforms, custom allocator hooks) and Unreal's LLM (Low-Level Memory tracker)

• Manages memory fragmentation: understands pooled allocators, custom memory arenas, and when Unreal's default allocation strategy creates fragmentation under long session times

• Console memory work is the hardest version of this: fixed RAM ceilings with no swap. Has shipped inside those constraints.

• Builds memory regression tests that run in CI — not just point-in-time snapshots

• Profiles and optimises Unreal's replication system: identifies bandwidth-heavy actors and components, tunes replication frequency, prioritises replication correctly under load

• Diagnoses client-server latency: distinguishes network latency from server frame time from client simulation cost — does not conflate them

• Familiar with Net Stat, Unreal's network profiler, and packet-level capture when needed

• Scope: supports multiplayer engagements where networking is a performance constraint — not the primary discipline on pure-networking architecture

• Builds internal profiling tools in C++ (UE plugins) and Python —…