When a flagship console game ships without a 60fps mode, the internet reacts with predictable heat. But for engineers who have shipped real-time interactive software at scale, the headline about Blood of the Dawnwalker isn't a morality play about laziness or greed. It is a data point about fixed hardware budgets, simulation complexity, and the engineering compromises that sit between a Target frame rate and a shippable product. The real story isn't that 60fps is missing; it's that the studio chose 40fps as the most defensible midpoint between visual fidelity and temporal stability on silicon that can't be upgraded.
As someone who has spent years profiling CPU-GPU workloads, tuning render budgets and explaining frame pacing to stakeholders, I want to unpack what "up to 40fps on all consoles" actually means under the hood. This article looks at the architecture, tooling. And platform constraints that produce a launch-day performance target. The analysis applies beyond gaming to anyone building latency-sensitive applications on constrained devices.
Frame Rate Targets as a Performance Engineering Contract
A frame rate target isn't a wish it's a service-level objective with hard mathematical consequences. At 60fps, the engine has roughly 16. 67 milliseconds to complete simulation, culling, rendering, and presentation. At 30fps, the budget doubles to 33, but 33 milliseconds. At 40fps, the target frame time is 25 milliseconds. That 25ms value is the contract every subsystem must honor, every frame, or the player sees stutter, tearing, or input lag.
In production environments, we found that 40fps is often chosen when the simulation is CPU-bound at 60fps but GPU-bound at 30fps. It gives the CPU a little more room without throwing away the temporal gains of higher refresh rates. The studio's confirmation that Dawnwalker targets "up to 40fps" tells me the team measured a workload that fits the 25ms envelope on PlayStation 5 and Xbox Series X|S more reliably than it fits the 16. 67ms envelope. This is a profiling-driven decision, not a marketing one,
The phrase "up to" also mattersIt signals variable performance, but the engine may use dynamic resolution scaling, variable rate shading. Or level-of-detail reduction to stay inside the budget during heavy combat or streaming sequences. Those techniques are standard mitigation patterns in real-time graphics engineering, and they show up in tools like Microsoft PIX, RenderDoc. And AMD Radeon GPU Profiler.
Why 40fps Is a Compromise Between Two Worlds
Forty frames per second sits in an awkward but technically useful spot. It isn't the cinematic 30fps default that console players tolerated last generation. And it's not the responsive 60fps target that competitive and action games chase. To display cleanly, 40fps typically requires a 120Hz output mode because 120 divides evenly by 40. That gives each frame exactly three display refreshes, which eliminates uneven frame pacing that would appear at 40fps on a 60Hz panel.
This matters because uneven pacing feels worse than a lower but stable frame rate. A game that averages 45fps on a 60Hz display can feel juddery because frames persist for unequal numbers of refreshes. By locking to 40fps on a 120Hz signal, the engine guarantees consistent frame delivery. In my experience tuning Unreal Engine 5 projects, enabling a 120Hz output path with a 40fps cap often produces a smoother perceived experience than an unlocked 45-55fps range.
The tradeoff is ecosystem compatibility. Not every display supports 120Hz. Players on standard 60Hz TVs may see repeated frames or the engine may fall back to 30fps. Studios therefore have to implement multiple presentation paths and validate each one through certification testing. That complexity is one reason smaller teams publish a single, well-tested performance mode rather than four optional modes at launch.
Console Architecture Bottlenecks and Optimization Tradeoffs
Current-generation consoles use AMD Zen 2 CPUs and RDNA 2 GPUs with unified memory. The PlayStation 5 and Xbox Series X are powerful. But they're also fixed targets. You can't add RAM, swap a GPU, or upgrade the SSD interface. Every feature in the game competes for the same power, thermal. And memory budgets. When a game like Dawnwalker targets high-fidelity open environments, character density,, and and real-time lighting, something has to give
Memory bandwidth is often the hidden constraint. Modern engines stream assets continuously from SSD into RAM and then into GPU memory. A 25ms frame budget leaves limited headroom for shader compilation hitches or texture streaming stalls. Techniques like PRT (Partially Resident Textures), mesh shaders, and Nanite virtualized geometry can reduce memory pressure. But they introduce their own CPU overhead and platform-specific support requirements.
Power and thermal budgets also shape sustained performance. A console can briefly exceed its average power draw. But it can't sustain that without throttling. Frame rate targets are therefore validated against worst-case thermal scenarios, not best-case benchmarks. This is why launch performance profiles sometimes look conservative: the team is guaranteeing stability across thousands of hardware units in varied ventilation conditions.
Engine Architecture and CPU-Bound Simulation Costs
Frame rate isn't purely a graphics problem. The CPU must run game simulation, AI, physics, animation, audio, networking, and input processing before the GPU ever sees a command list. In open-world action RPGs, AI update loops, crowd simulation, and physics interactions can dominate CPU time. If the simulation can't complete in under 16ms, 60fps is impossible regardless of how fast the GPU is.
This is where job systems and multithreading become critical. Engines like Unreal Engine 5 use task graphs to distribute work across CPU cores. But not all game logic parallelizes cleanly. Script-driven events, synchronous physics queries. And single-threaded gameplay systems can create serial bottlenecks. In my own optimization work, we used Intel VTune and Superluminal to identify long-tail frame spikes caused by gameplay code that looked innocent in average frame metrics.
Reaching 40fps instead of 60fps may indicate that the team prioritized simulation density over frame rate. More NPCs, richer physics, and deeper systemic interactions keep the CPU busy. Lowering the frame target is a valid engineering response when gameplay complexity is the primary product differentiator it's the same calculus backend engineers make when choosing consistency over raw throughput,
Display Technology, VRR,And Perceptual Stability
Variable Refresh Rate, supported by HDMI 2. 1 and technologies like AMD FreeSync, can make 40fps look smoother by eliminating screen tearing and reducing judder. VRR allows the display to adjust its refresh period to match the engine's delivery time within a supported range. For Dawnwalker, VRR on compatible TVs could make the 40fps mode feel closer to a VRR-unlocked experience. Though the studio hasn't yet confirmed VRR support.
Perceptual research shows that frame time variance matters more than average frame rate for comfort. A locked 40fps with low variance is preferable to an oscillating 50-60fps range. This is why frame limiters and refresh-sync options exist. If you're building any latency-sensitive application, from game clients to trading dashboards, the lesson is the same: stability is a feature, not a byproduct.
For players without VRR or 120Hz displays, the experience will depend on the engine's frame pacing implementation. A good frame limiter sleeps the CPU precisely to avoid early or late submission, and a poor one introduces micro-stutterThe technical details rarely make marketing slides. But they separate polished Release from rocky launches.
Telemetry, Profiling. And Launch-Day Observability
Modern game launches are observability problems. Studios collect telemetry on frame times, GPU memory usage - crash rates, and player display configurations. Tools like Unreal Engine's Profiler, Microsoft PIX, and platform-specific telemetry dashboards let engineers compare in-house test data against real-world telemetry. If a frame time spike appears in 0. 1% of sessions, it can still affect thousands of players on launch day.
In production environments, we found that distributed tracing concepts from backend engineering transfer surprisingly well to games. We instrumented subsystems with timers and exported histograms to Grafana and Prometheus. This let us see which levels, enemy combinations. And camera angles produced long-tail latency. That same data likely informed the Dawnwalker team's decision that 60fps wasn't achievable at launch with acceptable stability.
Observability also helps plan patches. Post-launch updates can target the worst offenders revealed by telemetry. Shader compilation hitches, streaming stalls, and CPU hotspots can be addressed once real-world data is available. Launch-day performance is therefore a snapshot, not a final verdict. Though first impressions are hard to reverse.
Platform Certification and Post-Launch Patch Cycles
Console certification is a gate. Platform holders enforce requirements around crash rates - loading times, achievements, network behavior. And presentation stability. A 60fps mode that fails certification due to frame time violations isn't a mode you can ship. Certification test suites run on reference hardware under controlled conditions. And they catch edge cases that internal QA misses.
This means the 40fps target was likely the highest mode that passed certification reliably across all required test scenarios. Shipping a 60fps mode as "optional" still exposes the studio to support costs and reputational risk if it performs poorly. Many teams choose to disable an optional mode rather than ship something that fails platform quality bars or generates refund requests.
Post-launch patches are common, but they're constrained by testing bandwidth and platform patch cycles. Each update must pass certification again. Major performance patches sometimes arrive weeks or months after launch, especially when they require engine-level changes. The community should expect optimization patches, but the launch configuration is what the studio could certify today.
What This Means for Cross-Platform Engine Teams
For software engineers outside gaming, the Dawnwalker situation is a useful case study in platform heterogeneity. You can't assume identical performance across devices with the same generation label. PlayStation 5 and Xbox Series X differ in memory architecture, I/O compression, and GPU clock profiles. Series S has fewer compute units and less RAM. A target that's comfortable on one console may be tight on another.
This is why cross-platform teams establish performance budgets early and validate them continuously. Budgets cover draw calls, texture memory, CPU time per subsystem. And streaming bandwidth. Violations are treated like failing CI tests. The discipline is identical to setting latency SLOs for microservices or page-weight budgets for web applications.
Teams also benefit from automated benchmarking. Nightly builds run deterministic scenes through capture tools. And regression alerts fire when frame time increases. This prevents "performance debt" from accumulating invisibly. While if Dawnwalker had a late-stage feature that blew the 60fps budget, automated benchmarks would have flagged it early enough to choose a lower target rather than rush an unstable mode.
Frequently Asked Questions
Why can't consoles run every game at 60fps?
Console hardware is fixed, and at 60fps, the engine has only 1667ms per frame for simulation, rendering. And presentation. Complex graphics, AI, physics, and world streaming can exceed that budget. Developers must choose between frame rate, visual fidelity, and simulation depth.
Is 40fps on a 120Hz display better than 30fps on a 60Hz display?
Generally yes, if the implementation is clean. Forty frames on a 120Hz signal gives each frame three refreshes, producing even pacing. Thirty frames on 60Hz gives two refreshes per frame, also even but with lower responsiveness. The 40fps mode usually feels smoother and more responsive than 30fps.
Will a 60fps mode be added later?
Possibly. Post-launch patches can improve hotspots, but major frame rate additions require substantial engineering and re-certification. Some games add performance modes months after launch. While others stay at their launch target there's no universal rule.
Does VRR make lower frame rates acceptable?
VRR reduces tearing and judder by matching the display refresh rate to the engine output. It can improve the feel of a 40fps mode on a compatible display. But it doesn't reduce input latency as much as a higher, locked frame rate it's a mitigation, not a replacement for performance optimization.
What tools do developers use to diagnose frame rate issues?
Common tools include Microsoft PIX, RenderDoc, AMD Radeon GPU Profiler - Intel VTune, Superluminal. And engine-specific profilers. These tools show CPU and GPU timelines, memory usage, draw call costs, and shader performance. Telemetry dashboards like Grafana and Prometheus help analyze real-world data at scale.
Conclusion and Next Steps
The decision to ship Blood of the Dawnwalker at up to 40fps on consoles isn't a failure of engineering ambition it's the visible output of invisible tradeoffs: CPU budgets, memory bandwidth, thermal limits, certification gates, and perceptual stability. For technical readers, the takeaway is that performance targets are contractual commitments, not marketing dials.
If you're building real-time software, treat your latency and frame-time targets like SLOs. Instrument your subsystems - benchmark continuously, and validate on real hardware. When the budget doesn't balance, make deliberate cuts rather than ship instability. The players, and your incident-response team, will thank you.
For more engineering perspectives on real-time systems, performance optimization, and platform architecture, explore our coverage of web performance fundamentals on MDN and our internal guides on rendering pipelines and observability. Read our deep get into game engine profiling tools Learn how telemetry shapes launch-day stability Explore cross-platform performance budgets
What do you think?
Should studios ship an unstable optional 60fps mode at launch,? Or is a locked 40fps target the more responsible engineering choice?
How much of the launch-day performance conversation is driven by real hardware limits,, and and how much by certification risk management
Could automated benchmarking and telemetry pipelines prevent late-stage frame-rate downgrades,? Or are some compromises inevitable in large-scale game development?
