Join Devoted Studios, a globally remote game development company, as a Senior Performance Engineer to drive core systems and optimize AAA titles across CPU, GPU, memory, and networking on all major platforms using Unreal Engine 5.
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:
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 ActorComponents 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 (SCOPE_CYCLE_COUNTER, CSV_SCOPED_TIMING_STAT, custom Unreal Insights channels) for ongoing regression detection
• Profiles rendering performance using RenderDoc, 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 NetStat, 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 — automated perf validation scripts, CI-integrated regression detection, custom Unreal Insights data channels
• Writes automated performance regression tests: baseline capture, threshold alerting, trend visualisation — so regressions are caught in the build, not in the client review
• Builds or improves developer-facing profiling UX: makes it easier for other engineers on the engagement to find their own bottlenecks without specialist involvement
• Documents profiling methodology and tool usage: other engineers can reproduce the analysis without a knowledge transfer session
Requirements
• 5+ years of professional game engineering experience with at least 3 years in a dedicated performance, engine, or low-level systems role
• At least 2 shipped commercial titles where performance was a named ownership area — not a general engineering role that included some profiling
• C++ at a deep level: understands memory layout, cache efficiency, branch prediction, SIMD, and how the compiler's optimisation decisions affect runtime behaviour
• Unreal Engine 5 profiling expertise: fluent in Unreal Insights, Stat commands, LLM, GPU Visualiser — not just aware of them, but has used them to find real problems on real projects
• Cross-platform experience: has shipped on at least two platform types (PC + console, or console + mobile) and understands the meaningfully different constraint profiles
• Python proficiency: writes automation scripts, CI integration, data processing for perf telemetry — not a Python developer, but not blocked by Python tasks
• Structural fix mindset: profiles, identifies root cause, writes the C++ fix. Does not stop at the recommendation.
• Can explain a performance problem to a gameplay engineer or producer without requiring them to understand the GPU pipeline
• Console certification performance submissions: has prepared and passed Sony/Microsoft performance gates
• Mobile performance work on Android (Adreno/Mali/Dimensity) and/or iOS (Apple Silicon GPU) — thermal throttling, tiling architecture, bandwidth constraints
• Custom allocator or memory pool implementation in C++
• Shader authoring knowledge: HLSL/GLSL fluency sufficient to read a shader and identify unnecessary ALU or texture sample cost
• Familiarity with Tracy, Optick, or custom in-house profiling frameworks beyond Unreal's built-in tooling
• Experience optimising Nanite, Lumen, or other UE5-specific rendering features at engine depth
Benefits
This is a full-time employment role with standard benefits in Quebec province.
• 5+ years of professional game engineering experience with at least 3 years in a dedicated performance, engine, or low-level systems role• At least 2 shipped commercial titles where performance was a named ownership area• Deep C++ expertise (memory layout, cache efficiency, branch prediction, SIMD)• Unreal Engine 5 profiling fluency (Unreal Insights, Stat commands, LLM, GPU Visualiser)• Cross-platform shipping experience (PC + console, or console + mobile)• Python proficiency for automation scripts, CI integration, and data processing• Structural fix mindset: profile, identify root cause, write the C++ fix• Ability to explain performance problems to gameplay engineers or producers without requiring GPU pipeline understanding
