Console Economics 

Want to know where graphics is going? Watch the console market. Not because consoles are technically sophisticated or the pinnacle of what computer graphics can achieve; they're not. But they do represent the largest chunk of the gaming ecosystem's revenue - and game developers, driven by publishers, follow the money. 

They are also cleverly engineered for a price point.  A PlayStation or Xbox retailing at $500 cannot do native 4K rendering at high frame rates with complex materials, global illumination, and real-time ray tracing. The physics don't work. The cooling doesn't work. The economics really don't work.  

Consoles could be considered the gateway to constrained graphics processing. The need to keep costs down via controlled silicon area and limited cooling means that the hardware is developing advanced techniques to deliver next-generation effects efficiently. 

So, what are they doing? The latest generations aren’t adding new specialised graphics features, they’re investing in AI acceleration. More reconstruction and upscaling. More temporal tricks and learned approximation. Less investment in pure rasterization throughput. 

This isn't compromise, it's pragmatism. Native rendering at 4K requires roughly four times the compute of 1080p. But AI-driven upscaling from 1080p to 4K requires a fraction of that cost while delivering perceptually similar results. Same image quality, quarter of the compute budget. The economics are undeniable. 

When the console makers bet this heavily on reconstruction over native rendering, the entire ecosystem follows. Game engines optimize for these patterns. Artists learn to work with them. By the time these techniques mature, they become the expected baseline. This is where constrained real-time graphics is heading, not just in consoles but in smartphones, in televisions and in cars. 

How Did We Get Here? 

For decades, Dennard scaling gave silicon designers a gift: shrink the transistors, get more of them, and they run faster while consuming the same power. We could pack in more graphics cores, more compute units, more specialized blocks, and the economics just worked. Every generation brought free performance. 

That stopped working a while ago, but the semiconductor industry has been running on momentum, acting like the old rules still apply. They don't. Now when we shrink transistors, we get more of them at higher density, but the performance no longer doubles, the power doesn’t scale the way it used to and thermal management is a major challenge. The only way forward is architectural efficiency, not just throwing more transistors at the problem. 

This has triggered a change in how we think about processor design. We need to be smarter about what we build and how it’s used – and AI arrived at the right time to bring the next wave of graphics efficiency that we need. 

Graphics Becomes Compute 

In fact across all markets, modern rendering is starting to look less like traditional graphics and more like sophisticated signal processing. Denoising ray traced lighting is a compute problem. Temporal anti-aliasing is a compute problem. Upscaling is definitely a compute problem. Even rasterization increasingly relies on compute shaders for culling, visibility determination, and material evaluation. 

The distinction between "graphics workload" and "compute workload" is dissolving. What looks like graphics is often compute that happens to generate pixels – and GPUs have evolved to become very effective at handling these kinds of workloads. 

This competence is already being repurposed for other use cases.  At the edge, a GPU is often tasked with handling workloads central to computational photography, extended reality (XR), virtual and augmented reality (VR/AR), and complex sensor fusion. These operations involve processing camera feeds, integrating point clouds from LiDAR, performing FFTs on sensor data, and tracking objects in three-dimensional space. Such preprocessing steps are fundamental to enabling richer, more immersive experiences and accurate environmental understanding.  

The Convergence  

These tasks occupy a unique intersection, distinct from both conventional graphics and AI workloads. They represent a class of heterogeneous compute tasks that predate the recent surge in AI, yet remain essential for modern uses in mobile, interactive and perceptual computing. 

The result is a well-established compute software ecosystem that treats the GPU as a first-class citizen. APIs, standards, libraries, compilers and tooling are all at hand to ensure that developers can easily get their AI models running on a GPU’s general-purpose compute units.  

This is key, as the inconvenient truth is that the AI algorithms dominating our roadmaps today are probably not the algorithms we'll be running in five years. Not because they're bad, but because they're optimized for an era of abundant power and compute that simply doesn’t scale. 

Transformer based models running in data centres with massive power requirements may be driving short term economic growth, but even they are reaching the end of their scaling curve, and free unlimited energy is still science fiction.  The next generation of algorithms will emerge because they must; again: physics and economics demand it.   Some of these algorithms will make data centre computing more efficient; others will encourage AI out of the data centre and onto the other abundant source of efficient computing: edge devices. 

Sparse architectures, novel quantization schemes, hybrid approaches we haven't imagined yet – however the algorithms evolve, the hardware needs to be ready.  We've seen this movie before. Expert systems gave way to neural networks. Fully connected networks gave way to CNNs. CNNs gave way to transformers. Each shift left behind specialized hardware optimized for yesterday's approach.   

The difference for edge computing is deployment timescales. While a data centre can refresh every 2-3 years (economics and infrastructure allowing), automotive SoCs live for 10+ years. Edge hardware can't afford to over-optimize for algorithms that might be obsolete before the first chip ships. 

What This Means for GPUs 

But specialist accelerators aren’t the only answer to AI at the edge. The GPU has evolved to become an AI machine; the primary use case for its compute resources was graphics, yes; but the joy of the GPU is its programmability and flexibility. It can be applied to today’s AI algorithms – and it will be the de facto accelerator for the more efficient model varieties that will emerge as data centre constraints start to bite in earnest. 

Today’s GPUs aren’t just graphics processors any more.  Nor are they compute processors, or AI accelerators. They’re all three, often simultaneously. What does this mean for architecture design? 

Genuine heterogeneity: fixed-function blocks for rasterization, ray tracing, tensor operations, and compute are still needed. But the scheduling and resource allocation needs to be flexible enough that workload shifts don't create bubbles. When the frame is in its reconstruction phase, those ray tracing units should be available for compute or AI workloads, not sitting idle. 

Memory hierarchy matters more than peak throughput: Edge devices can't brute-force problems with massive memory pools. Caching, compression, and data movement strategies are architectural, not algorithmic. When a GPU is reconstructing frames rather than rendering them fully, memory access patterns change fundamentally. The architecture needs to anticipate that. 

Numerical flexibility over peak performance: Today's neural networks might use INT8, but tomorrows could use INT4, FP4, or ternary representations we haven't standardized yet. Today's graphics might use FP32 for precision, but reconstruction algorithms might need different bit-widths we haven't anticipated. Build for adaptability, not just efficiency in one narrow format. 

Programmability cannot be sacrificed: That automotive GPU designed today needs to run algorithms that don't exist yet. This requires a programming model that lets developers express novel algorithms without fighting the architecture. Fixed-function blocks buy efficiency, but only if they don't paint you into a corner when workloads evolve. 

The Pattern We Keep Missing 

The computing industry has hit this cycle repeatedly over the last forty years. Scaling gives free performance. We build infrastructure assuming it continues. Physics imposes limits. Algorithms shift to compensate. Previous optimizations become less relevant. 

We're in that transition now. The question isn't whether it's happening: the Dennard scaling wall is here, algorithmic shifts are inevitable, edge deployment is accelerating. The question is whether we're building architectures that can adapt or ones that will be stranded when the transition completes.  And the edge is where these tensions matter most. Building architectures that can adapt to what's next is harder than optimizing for what's current, but it's also the only approach that survives contact with a decade of deployment.