At Siggraph 2014, the Khronos Group has announced both OpenGL 4.5 and, more excitingly, the Next Generation OpenGL Initiative. OpenGL 4.5, except for some new Direct3D 11 emulation features for easier porting, is your fairly standard annual OpenGL update. Next Generation OpenGL (OpenGL NG), however, is a complete rebuild of the OpenGL API. The idea, much like AMD’s Mantle and DirectX 12, is to build an entirely new version of OpenGL that removes a lot of the abstraction, significantly reducing the overhead and inefficiencies when working at a low level with the bare metal GPU hardware. Khronos has an uphill struggle ahead, though: While AMD and Microsoft are focusing on their own specific implementations, OpenGL NG will be a cross-platform solution for all operating systems and hardware makers, just like the existing OpenGL specs.

With more than 22 years under its belt, OpenGL (originally released by SGI in 1992) is the oldest high-level 3D graphics API still in popular use. Much like DirectX (which is only a little younger), OpenGL has gained a lot of bulk and scar tissue over the years. More importantly, though, OpenGL — again, like DirectX and Direct3D — is a very high-level API that makes it hard to efficiently run code on the GPU directly. This didn’t matter so much in the olden days, when GPUs were nasty things that needed high-level abstraction to be programmed sensibly — but now, as GPUs become ever more mature and sane and documented, developers are asking for graphics APIs that allow them to get much closer to the bare metal, significantly improving performance and reducing overhead.

Enter OpenGL NG, which will be a ground-up redesign of OpenGL that isn’t backwards compatible. The Khronos Group, which develops the OpenGL spec (and other related specs), says it’s working hard with all of its consortium members to develop a spec that hardware and software companies will actually use. Khronos’s last attempt to create a new, non-backwards-compatible spec — Longs Peak — failed dismally, so it’ll be keen to not make the same mistakes twice. The landscape has changed a lot since Longs Peak, though — now, with a variety of low-level APIs emerging from AMD, Microsoft, and even Apple, it would appear that developers are keen to break away from the heavily abstracted days of yore. (Longs Peak never saw the light of day, incidentally — it was trashed in 2007 and replaced by the much more “normal”, backwards-compatible OpenGL 3.0 spec in 2008.)

Khronos readily admits that it has set a pretty daunting task for itself. Still, as you can see in the slide above, Khronos definitely has most of the right people on board (the only significant omission is Microsoft). It’s nice to see a lot of software vendors, such as Valve, Epic, Blizzard, and Unity. Game development is increasingly cross-platform; I’m sure developers would love to target OpenGL NG and have their games work across most platforms and form factors — but that only works if the hardware support is there, of course. This dovetails neatly into another salient point: Khronos also admits that, because OpenGL NG has to work across multiple GPUs, it cannot physically be as low-level as AMD-only Mantle. Khronos is confident it can still offer significant overhead reductions and performance increases while being cross-platform, however. Given their different approaches at reaching roughly the same goal, it will be interesting to benchmark Mantle, DirectX 12, and OpenGL NG.

There doesn’t seem to be a timeline for the release of Next Generation OpenGL, but I doubt it’ll be soon. DirectX 12 is due at the end of 2015, and I’m sure Khronos would like to land OpenGL NG at around the same time, but it might be a little later. I do wonder about the fate of Mantle now that both Microsoft and Khronos are wading into the fight.

If you’re interested in the changes in OpenGL 4.5, which was released today, hit up the OpenGL documentation. There really isn’t much to it though, other than some new features that aid porting (between mobile and desktop, and DirectX 11 to OpenGL 4.5), and some general API clean-ups to bring the various OpenGL specs (OpenGL, OpenGL ES, WebGL) into alignment.