With GDC 2014 having drawn to a close, we have finally seen what is easily the most exciting piece of news for PC gamers. As previously teased by Microsoft, Microsoft took to the stage last week to announce the next iteration of DirectX: DirectX 12. And as hinted at by the session description, Microsoft’s session was all about bringing low level graphics programming to Direct3D.

As is often the case for these early announcements Microsoft has been careful on releasing too many technical details at once. But from their presentation and the smaller press releases put together by their GPU partners, we’ve been given our first glimpse at Microsoft’s plans for low level programming in Direct3D.

Preface: Why Low Level Programming?

The subject of low level graphics programming has become a very hot topic very quickly in the PC graphics industry. In the last 6 months we’ve gone from low level programming being a backburner subject, to being a major public initiative for AMD, to now being a major initiative for the PC gaming industry as a whole through Direct3D 12. The sudden surge in interest and development isn’t a mistake – this is a subject that has been brewing for years – but it’s within the last couple of years that all of the pieces have finally come together.

But why are we seeing so much interest in low level graphics programming on the PC? The short answer is performance, and more specifically what can be gained from returning to it.

Something worth pointing out right away is that low level programming is not new or even all that uncommon. Most high performance console games are written in such a manner, thanks to the fact that consoles are fixed platforms and therefore easily allow this style of programming to be used. By working with hardware at such a low level programmers are able to tease out a great deal of performance of this hardware, which is why console games look and perform as well as they do given the consoles’ underpowered specifications relative to the PC hardware from which they’re derived.

However with PCs the same cannot be said. PCs, being a flexible platform, have long worked off of high level APIs such as Direct3D and OpenGL. Through the powerful abstraction provided by these high level APIs, PCs have been able to support a wide variety of hardware and over a much longer span of time. With low level PC graphics programming having essentially died with DOS and vendor specific APIs, PCs have traded some performance for the convenience and flexibility that abstraction offers.

The nature of that performance tradeoff has shifted over the years though, requiring that it be reevaluated. As we’ve covered in great detail in our look at AMD’s Mantle, these tradeoffs were established at a time when CPUs and GPUs were growing in performance by leaps and bounds year after year. But in the last decade or so that has changed – CPUs are no longer rapidly increasing in performance, especially in the case of single-threaded performance. CPU clockspeeds have reached a point where higher clockspeeds are increasingly power-expensive, and the “low hanging fruit” for improving CPU IPC has long been exhausted. Meanwhile GPUs have roughly continued their incredible pace of growth, owing to the embarrassingly parallel nature of graphics rendering.

The result is that when looking at single threaded CPU performance, GPUs have greatly outstripped CPU performance growth. This in and of itself isn’t necessarily a problem, but it does present a problem when coupled with the high level APIs used for PC graphics. The bulk of the work these APIs do in preparing data for GPUs is single threaded by its very nature, causing the slowdown in CPU performance increases to create a bottleneck. As a result of this gap and its ever-increasing nature, the potential for bottlenecking has similarly increased; the price of abstraction is the CPU performance required to provide it.

Low level programming in contrast is more resistant against this type of bottlenecking. There is still the need for a “master” thread and hence the possibility of bottlenecking on that master, but low level programming styles have no need for a CPU-intensive API and runtime to prepare data for GPUs. This makes it much easier to farm out work to multiple CPU cores, protecting against this bottlenecking. To use consoles as an example once again, this is why they are capable of so much with such a (relatively) weak CPU, as they’re better able to utilize their multiple CPU cores than a high level programmed PC can.

The end result of this situation is that it has become time to seriously reevaluate the place of low level graphics programming in the PC space. Game developers and GPU vendors alike want better performance. Meanwhile, though it’s a bit cynical, there’s a very real threat posed by the latest crop of consoles, putting PC gaming in a tight spot where it needs to adapt to keep pace with the consoles. PCs still hold a massive lead in single-threaded CPU performance, but given the limits we’ve discussed earlier, too much bottlenecking can lead to the PC being the slower platform despite the significant hardware advantage. A PC platform that can process fewer draw calls than a $400 game console is a poor outcome for the industry as a whole.

Direct3D 12 In Depth


View All Comments

  • B3an - Monday, March 24, 2014 - link

    For anyone interested.. new DX12 graphics features are coming and yet to be announced:


    As i suspected, current hardware will benefit from the DX12 performance gains, but you will need new hardware for the new graphics features. Same as previous DX releases.
  • Tristor - Monday, March 24, 2014 - link

    I should also point out that OpenGL is already more performant in draw calls than Mantle, and is fully multi-threaded. It has been for a LONG time. More importantly, it's cross-platforms. If more game devs start using OpenGL+OpenSDL we will end up with more games available on other platforms (Mac/Linux). I'm hoping the huge push Valve is doing with SteamOS will encourage this and we'll see the benefits across the board in PC gaming.

    Here's an nVidia dev talking at Steam Dev Days about the performance increases gained from simply porting to OpenGL over DirectX (these surpass the gains from moving to Mantle):


    http://www.neogaf.com/forum/showthread.php?t=69345... - AMD already has promised (and started releasing) OpenGL extensions that fully expose the capabilities of GCN hardware which has made OpenGL more performant on AMD than Mantle.

    http://www.dsogaming.com/news/john-carmack-nvidias... - Here's John Carmack himself (one of the few devs who actually embraces OpenGL fully) talking about how nVidia's OpenGL extensions make Mantle irrelevant because OpenGL is faster.

    So basically, OpenGL > Mantle > DirectX and OpenGL is also cross-platform and has been around for ages. But, nobody wants to use it because it's "too hard" or "takes too long". Companies like EA, Activision, and Ubisoft don't want to make well-optimized games, they want to make games quickly while milking profitable franchises so they can take their billions to the bank. For the rest of the games out there that are trying to do something cool (Project CARS, Star Swarm, et al) they should really start investing heavily in OpenGL. End of story.
  • inighthawki - Monday, March 24, 2014 - link

    "I should also point out that OpenGL is already more performant in draw calls than Mantle, and is fully multi-threaded. It has been for a LONG time"
    Being multithreaded doesn't mean anything. In OpenGLs case it just means it's thread safe, so you can go queue up some render commands on thread 2 while you do app work on thread 1. No different than what DX has had for even longer than OpenGL. DX12 is introducing a better multithreading model which OpenGL doesn't have. One where you can actually split rendering work equally across cores.

    "More importantly, it's cross-platforms. If more game devs start using OpenGL+OpenSDL we will end up with more games available on other platforms (Mac/Linux)"
    I'm sure a lot of people will hate me for this, but who cares? OSX+Linux marketshare combined is a tiny fraction of what Windows is, and there's not a lot of money in it.

    OpenGL is a horrible API comprised of a horrible interface trying to retain backwards compatibility with older version that should never even be used, coupled with a bunch of vendor specific extensions that khronos decided to make official because someone did the work for them of figuring it out.

    "AMD already has promised (and started releasing) OpenGL extensions that fully expose the capabilities of GCN hardware which has made OpenGL more performant on AMD than Mantle."
    Why would you ever want extensions that are vendor specific? Half the point of your post is "don't use mantle because tis vendor specific" then you praise OpenGL for gaining the ability to have vendor specific enhancements?

    "Here's John Carmack himself (one of the few devs who actually embraces OpenGL fully) talking about how nVidia's OpenGL extensions make Mantle irrelevant because OpenGL is faster."
    That's not what he said at all, I suggest you re-read it.
  • Lerianis - Monday, March 31, 2014 - link

    Well, that is kinda becoming the new 'normal'..... in order to use the new graphics stuff, you need a new graphics card.
    I'm getting kinda angry in that newer graphics cards sold on Newegg all need a minimum of a 400 Watt power supply. My nearly brand new computer has? 300 watts. So either these companies need to start putting at least a 400 Watt power supply in these machines or the graphics card companies need to make a selection of cards that regular home users can find that they can plug into their old computers that only need 300 Watts.
  • Tristor - Monday, March 24, 2014 - link

    If devs have been asking for lower level access on the PC "forever" why does nobody use OpenGL? OpenGL provides unimpeded lower level access that DirectX does not, it's cross-platform, it's well-optimized for in hardware and drivers on both AMD and nVidia, and with the numerous OpenGL extensions available there's no features available in DirectX which are missing in OpenGL.

    I'll tell you why, because OpenGL is harder to write for. "Low-level access" implies low-level programming, which is more difficult to do, especially to do properly, and it requires higher quality programmers to pull it off. The reason DirectX is popular is because its ridiculously easy to write for, not because it's well-optimized or good. This has always been the case. If game developers were truly interested in low-level access and optimizations they would have been using OpenGL this entire time.

  • Mr Perfect - Monday, March 24, 2014 - link

    OpenGL is probably also a victim of DirectX's popularity. IE; no one uses OpenGL because no one uses OpenGL. Middleware engines all seem to focus on DirectX, hardware vendors only advertise support for new DirectX features, competing games all use DirectX... It reminds me of Windows Phone and how it doesn't receive support because everyone's all busy doing Android and IOS work. Reply
  • DarkXale - Tuesday, March 25, 2014 - link

    It generally doesn't help that (PC) titles haven't really made a good impression.

    RAGE is not exactly a good demonstrator for graphical stability and reliability, and it was supposed to the a showcase for the ID Tech engine and OGL. Needless to say, it failed at that.
    Another game, Brink, was filled with graphical problems; the game was unplayable on AMD systems.

    OGL2 software tends to be more reliable - but the problem you have then is that you're using OGL2. Which isn't exactly modern, and was written in the more... problematic... days of OGL.
  • lmcd - Monday, March 24, 2014 - link

    Tristor, you're off-base. OpenGL isn't lower-level than Mantle and that has been long-acknowledged. OpenGL isn't even significantly lower-level than DirectX. DirectX is popular because it's standardized, not because it's easy to write for, and strong standards are better than weak standards. OpenGL regularly plays catch-up with DirectX feature sets and relies extensively on extensions which are not standardized.

    Different failings.
  • bluevaping - Friday, April 04, 2014 - link

    Big gaming houses use plenty of different API's not just Direct X or Open Gl. Microsoft likes keep things were they are, until the floor drops out. Oh snap gaming PC sales are declining. It's sad that AMD is trying to get more performance from hardware and wrote their own API. Gamers with different priorities are moving away from PC's to Console(simple and less expensive hardware) to Mobile Tablets(great screens with cheaper games). There are Open GL games, some are ports and some are released on multiple platforms at the same time . I have played dozens and dozens of them. We won't see record level of PC Gamers like the past. But developers will try to reach out to other platforms to make up for it. Microsoft little to late. They should be making better tools for Open GL. Just embrace it, Microsoft. Reply
  • ericore - Monday, March 24, 2014 - link

    There are no console advantages.
    I think I abandoned consoles 2 months after purchase, never looked back.

    The games are pricier.
    The load times are significantly greater.
    No modding ability.
    Same price of a PC which can do so much more.
    The AI on consoles is dumbed down.

    Consoles are for kids.
    PCs are for adults.

Log in

Don't have an account? Sign up now