Just to clarify, the Witcher 3 DX12 update (released Dec, 2022) does seem like it is particularly bad compared to the original DX11. But, what does this mean for other recent releases? Lol also it’s “Application Programming Interface” :) Feeling like LTT with these corrections 🫠😳

With DX12, you can treat the GPU like a console, squeezing out every inch of performance. But barely anyone seems to be putting in that effort.

Game Developer / Graphics Programmer here. One of the main issues when switching from D3d11 to 12 is the level of control. In 11 a lot of menial tasks are done for you pre-optimized for the GPU, however in D3d12 you have a lot more control over the fine details of tasks, but the average programmer does not know how to use it efficiently to make the extra control worth while. In addition to that, 11 is also a lot easier to learn because of how much simpler it is.

The biggest problem is that the solution has always been "throw more hardware at the problem" rather than "let's code smarter". Hardware has far outpaced the software at this point and it's a shame. I am willing to bet that there is a ton of untapped potential with this hardware that's being held back by convenient development practices. This is why I love Nintendo's engineers. Look at what they have accomplished with limited hardware. I wish more developers worked in constrained environments just so they could learn what optimization *really* looks like.

Starting from scratch with DX12 is a great experience. But most games are not made with DX12 from scratch. They use the tooling and assets already developed for the company's earlier games. They use abstractions that were developed all the way back for DX9 (and OpenGL) that were themselves kind of poor because they were really made for DX7 and it goes on and on. They have intermediate layers to allow you to switch graphics APIs that mean you can't really do anything well - you still have to pick one as your "main" and hopefully wire things together decently enough to make the alternate APIs barely worth it. Grafting DX12 or Vulkan on top of a game built for DX10/OpenGL doesn't do much... much of the time. The main problem with DX has always been the fact that it's a Microsoft product, utterly dependent and controlled by them... and _mostly_ locked to Windows. Of course, that's still the _vast_ majority of PC gaming and you can pretty safely ignore the alternatives if you're not explicitly targeting niche audiences. I started with OpenGL. I made a few simple 3D games. But when I tried DirectX for the first time... I really never ever felt like OpenGL had anything on offer that DirectX didn't do better. I never felt like I'm missing out. Of course, Carmack always preferred OpenGL because of it's openness, portability and C-style API, and was a big supporter of Vulkan for all the same reasons (as well as the added ability for low-level coding) - but the vast majority of graphics engine developers aren't Carmack or Sweeney. Vulkan is a pain to use for very little benefit the vast majority of time. Mind, it would probably be worth it if the game environment was a bit more static, with more of a chance of that investment paying off (the way it was always on consoles, where you had a typical progression with early games that didn't really know how to use the hardware yet to the end games that squeezed stuff noone thought possible out of it). But PCs were never like that. And the thing is, while there are many similarities between the APIs... to really get their worth, you need to build your entire game around a particular API. Anything else is a waste of loads of effort, even with all the modern helper tools like cross-compiling shaders. Giving you the option to switch costs _so much_ in either performance or development time... and often both. This only got worse with time (though even the very first release of OpenGL already did some things differently from DX for no other reason than spite; people do those kinds of things to each other). In the end, unless you're Epic... you really want to make a choice. Pick the API that feels comfortable, fits your goals, has great tooling and support, and build your game/engine around it. If you care about performance or efficiency, there is no other way, really. The kind of abstractions you need to simultaneously target DX10, DX12, OpenGL and Vulkan mean you lose way too much. The tooling will suffer too, and you'll have to build a lot of stuff on your own for almost no reason. You'll be investigating absolutely infuriating performance problems that seemingly have no reason all the time. It's incredible how much abstraction in the GPU space can hurt... and how hard it is to find how, and to fix it. I've had cases where I literally traced everything instruction-by-instruction, slot-by-slot... and still couldn't figure out why it was suddenly impossible to push 100k polygons on the screen at 60 FPS with 100% GPU load. Rewriting the same code in raw DX12 was simpler, faster and suddenly, that same GPU could push 100M polygons easily. The worst thing with GPUs (even before 3D accelerators) was always how fickle they are, and how random the performance and other issues are. In my case, the vast majority of games run much better on DX12 than on DX11 or Vulkan on _my particular hardware_ . The switch from 2D to 3D is deceptively simple... until you start testing on various random PCs and find out that half of them can't even run your game for obscure reasons, while the other half has inexplicable performance issues. It's crazy, and always has been. And as always: make sure your drivers are fully up to date. But of course it can't be that simple, really - some updates break games and/or their performance :D PCs are complicated.

Video game optimization was something we took for granted, but that's no longer the case. The reason game optimization took place was that the video game was the product. Today the product is the monetization platform, and the video game elements added to that platform are seen as an expense to be minimized. When the product was a video game, optimizing that product was considered a valid expense. When the product is a monetization platform, clearly that's not the case.

The problem with The Last of Us is that it runs on D3D11On12 which internally converts directx11 calls to directx12 calls. That creates unneeded overhead and decreases performance

DX11 did the work for the developers, people like Id Tech chose Vulkan bc they wanted to squeaze even more performance out of the hardware by going with a really low level API, MS seeing that, chose to make DX12 more similar to Vulkan, but guess what, not that many developers used Vulkan to begin with and most of them don't bother to optimize that much, which makes DX11 perform so much better in some many games. Bring back DX11 for Devs with no API knowledge.

Low level APIs are not a problem, it is more difficult to get the same result but certainly have the potential to be much better although it needs to be in the right hands. We can see the potential with emulators that use Vulkan or even DXVK.

I think that DX12 have been out for 8 years now, Microsoft keeps improving them and giving devs ways to optimise and gather control via hardware scheduling. Nvidia keeps relying on CPUs for graphics scheduling and devs keep cutting corners under pressure of publishers...it's not a DX issue, it's an industry issue.

DX12 and Vulkan are lower-level APIs and will be faster than DX11 when used right. The problem is the level of expertise and effort needed to use these tools optimally.

0:59 minor correction here but API stands for Application Programming Interface. In the context of graphics, an API is basically a middle man between the game you're running and your GPU, it tells the GPU what the game wants to render.

The history of DX12 and Vulcan come either directly or indirectly from AMD's Mantle. Mantle was a proof of concept by AMD, which was also practical. Some games or benchmarks using Mantle, like Ashes of the Singularity, came out. Mantle eventually got folded directly into Vulcan, and it inspired DX12. The whole concept was to be able to take control over the fine-tuning of details. The idea being able to optimize at the lowest levels. Developers were apparently "crying out" for such feature. But DX11 had a lot of features that actually made developing games much easier, without going into the bare metal. So it seems that the amount of optimization available from DX12 was just too much, and this level of control wasn't always needed.

Bring back the original Dishonored graphics, they look amazing and every toaster can run it

Vulkan coper here, just wanted to point out the enormous gains in 1% lows vs. DX12. In several of the RDR2 examples, the frametime graphs show big spikes in DX12 but not VK. 20+% improvement in the lows is no joke. I think you're much more likely to notice a few big stutters than ~5% average fps, so I use Vulkan/DXVK pretty much wherever possible.

Gotta hand it to you man, I've come accross your videos before but... this topic, pacing and educational mixture has got me to finally subscribe. Awesome stuff man.

There's a reason most indie devs use D3D11 and OpenGL. It's just alot easier to use! Most developers just do not have the time to do more for a chance of more performance

What I hate about modern game development is that newer devs tend to use 4k textures for everything, even the smallest of assets that you'll never see.

graphics dev here. i'm gonna try and explain in less technical terms whats going on, so apologies if it seems a bit rough or i miss explain something. generally speaking it's all about how these api calls are utilized by the developers, in conjunction with how well documented these new features are with these new updates/version and how much was added to these documentations. DX11 vs DX12 is essentially opening a flood gate of freedom to the "bare metal" of the system which causes a lot of development overhead as this means more setup may need to be done to achieve the same result as you did before. devs then need to spend more time going through the documentation which takes away from development time, which causes them to rush etc. etc. compounded by trying to fit in all these new shiny features people want to see, it leads to shortcutting and not fully understanding the tools they are working with. you would see a lot of the same if these studios just simply switched to vulkan cause now these developers gotta learn a whole new api, which is just more development overhead. there's more at play here on this issue all together, but that would be outside the scope of just talking about the drivers themselves, but a summarization can be crunch and lack of senior developers(studio pending).

To put it simpler, is like windows 10 & 11. Windows 10 often seems more preforming, but people still update it.

I'll bring my “I'm a graphics developer” moment, but before this, I need to clarify two things: I'm actually a GPGPU developer, I don't do real-time graphics stuff in general, but I do a lot of computing, and second I do agree that games seems to be struggling way more on DX12 than DX11, but I'll get into that in a moment. First I need to bring up one thing: Cyberpunk 2077 and The Witcher 3 do not really use DX12, they use D3D11On12. D3D11On12 basically translates DX11 calls to DX12 at runtime, and gives you access to features that would otherwise not be accessible on DX11, like Ray Tracing and DLSS. The problem is that D3D11On12 IS NOT MEANT to be used in production, Microsoft themselves states this. It's not like DXVK and VKD3D which is being extensively optimized and developed. About games performing worse, besides CP2077 and TW3 that still uses DX11 behind the scenes and has a lot of overhead, it's because developers need to learn a lot of stuff that was all hidden from them on DX11, and this also means that they will make a lot of mistakes, they will mismanage memory, they will use suboptimal synchronization techniques, they will do a lot of wrong things because they still don't know how to do things properly, and that's expected, it's the same for Vulkan and Metal, which are low-level APIs. Developers cannot rely on the API Runtime and Drivers doing all the optimizations for them (drivers still can do, but not to the same extent), now that's their responsibility to do this and to use those APIs correctly, and this has a really steep learning curve, graphics programming and optimization in specific is a tough task. As for games like Doom running really well on Vulkan, it's not really about Vulkan (although I would love to see more games using it instead of DX12), but about the devs. id Software devs are damn good and love to test new tech and try new things, they were really into learning and implementing Vulkan, they were not rushing because they needed to implement in order to deliver those new fancy features like Ray Tracing, by the time id Software started working on their Vulkan renderer, Nvidia's 2000 series wasn't even a thing. So they were implementing this because they wanted, not because they were forced to, this also means that they had a lot of time and way less pressure than the others.

Well we remember the time when vulkan and dx12 brought in asynchronous compute that boosted performance in games to almost double compared to dx11 modes, especially on the amd Polaris gpus.

Let us face the truth, most developers can't optimize their games well, or at least do it on the time frame of releasing the games. So what we get is unfinished game that is more fitting for a beta release rather a full release, and the devs finish it in the following months/years. This phenomenon has become so common, that it seems like the norm and not outlier. DX12 is not inherently awful, but since it gives more control for the game developer, it also require them to do a lot of things by themselves.

This is a great channel. Subbed. Thank you.

It's tough to pin the blame on any specific API. I think the main issue is the time constraints studio managers and publishers put on the developers to meet launch date targets, and so instead of having the time to tweak and optimise games (textures is the most obvious recent example), they're busy trying to make objects they stuff in their microtransaction stores instead, and maintain their "live services." When devs are busy trying to a fix a game that's broken on release (probably due to unrealistic time constraints), they obviously will have zero bandwidth for making their code more elegant and efficient. DX12 just happens to co-exist with all of these industry trends developing simultaneously to the rise of DX12. On paper, at least, DX12 provides many more levers for devs to pull (vs DX11) for better performance and optimisation; I just don't think they're given enough time to do that.

Application Programming Interface = API. Not "Advanced". Just FYI

Its not DX11 thats faster, its all the optimisation that are done in the GPU driver for DX11 that is outdoing the dev optimisations in other API, having said that youll still see DX12 and Vulcan being faster in some scenes in these games due to some of the bottlenecks.

I think I discovered the problem, when you use DirectX12 Ultime or Vulkan (the newer versions) these brings the CPU access to the VRAM, and Its like "standby memory" in ram, but for vram

Good informal video bro keep em up :) ILY

Dx12 itself is actually incredibly optimized, faster than dx11 by default. My own game is on it, and easily hits a stable 120fps on an integrated gpu. Its more of a problem in the way modern games are using the extra overhead and features of dx12 to push both the cpu and gpu harder. And speaking of Vulkan, from my experience while dx12 generally has more stable fps, Vulkan is better in terms of raw speed. It generally has slightly higher max and min framerates

Issue is likely porting to DX12 vs. developing around it. Same issue with Vulkan and OpenGL. Vulkan released an article saying you should develop around Vulkan rather than developing around existing OpenGL if you actually want performance gains.

what ddo you use to show the stat thing at the top ? btw cool video !

Good info and all but damn ! Slappin with that music at the end ! Damn bro lets go

I have a friend. who is a programmer and many years ago he told me "you can't make games with two left hands" this was in 1997-1998 (then we played duke nukem 3d, doom, heretic, half-life...) ... then most computers had Pentium 75 to 100 processors and video cards with 1-4mb ram. a lot of optimizations were needed if you want to sell your game - the more machines it runs on - the better... now the programmers are lazy "I don't optimize the game, whoever wants to play should get a powerful computer...

The problem isn't the DX12 API, in fact when properly programmed it is faster than DX11 because 1. it multicore/multithreads better and 2. the Shader Pipeline is no longer essentially FIFO but can do parallel processing as well as take Out of Order instructions. Key words are PROPERLY PROGRAMMED Take Witcher 3 Next Gen, the reason it performs poorly in DX12 compared to DX11 is because the CPU threading isn't proper programmed in DX12 and with DX11 the API takes control of multithreading BUT is limited to 4 cores with the rest just coasting. In DX12 it's up to the game engine and programmers to properly set up multithreading but it can handle pretty much unlimited threads. If Witcher 3 multithreaded correctly in DX12 instead of trying to do everything on 1 or 2 threads/cores the game performance would shoot right up there.

I have an I5 6500, RX480 8gb and 16gb of 2133mhz ram. I find that in Rainbow 6 siege, DX is a slide show, while Vulkan runs the game at 144 fps(with stutters and other problems).

as for porting Direct X games to other platforms, there is a tool called DXVK that translates DX api calls into Vulkan calls on the fly, and I’ve heard it results in higher frame rates, but I haven’t done the testing to prove that.

The easiest way to think of it is like this: "Using DX12 \ Vulkan is like writing your own graphics drivers." Hardware manufacturers love it since they don't need to hire as many driver optimization experts but game studios are feeling the pain because the optimization task has been shifted to them.

when comparing dx12 to vulkan, its hard to say because games that do enable you to switch between dx and vulkan are usually the ones that dont have the apis implemented well. its even said in a couple of vulkan learning resources that in order to use vulkan well you need to structure your application around it and abstracting vulkan(like in the games that do switch between apis) does nothing more than having a more verbose version of opengl... which in the end is probably sometimes their goal, to have the simplicity of opengl/dx11 with new features like rtx and dlss

DX12 gives more control over hardware to developers, but some of them don’t yet know how to utilize it properly. The thing with real-time shader compilation stuttering is that all game shaders are compiled in-time. It’s possible to precompile all shaders before loading the game, they can be delivered through steam services, they can be compiled while loading levels, this is to developers to decide. I hope that with time more developers will be adequately qualified to work with DX12 API

As I watched this video, while the information was all the more worthwhile, I started to get distracted (or rather attracted) to the possible Pokemon Gym music in the background... or was it just me? Lol. Good use of it!

Long story short, developers suck, and i say this as one myself, bad practices are everywhere and the bigger the team the more inconsistencies in development, shortcuts, or just unoptimized programming. Some of this comes from the tight release schedules as well and it has been proved time and time again that every game has lots of potential to even double performance with time, like the guy here on youtube that made a modified mario64 version for the gamecube and improved performance to the mooon by himself. Now, the problem with dx12 and vulkan is that the more direct access you give to the hardware a developer, the more responsible they are to properly manage the resources, this happens with regular programming languages as well, low level programming always needs the developer to be very careful with how they handle resources while high level languages and api's kinda hold your hands in that regard

To be fair there's even plenty of DX11 features that devs didn't use/aren't using properly. Which is a shame. Any API could do a lot more if properly understood by devs.

Two other important things I think to mention is that dx11 was largely focused on leaving optimization to drivers and graphics vendors, so nvidia and amd performance improvements came with the wealth of driver optimizations, whereas dx12 is fully in control of developers, this does mean that when the time is put in a game can utilize resources more efficiently depending on what the game needs, but it has a double edged sword effect where if the time isn’t put in it can end up harming performance beyond the one size fits all approach of dx11, it’s a complicated api that requires dedicated work to optimize properly but the problem then comes in that with most studios the pc port is oftentimes the least prioritized version as it is the least populated but requires the most work. Second vrs is a good example of how dx12 requires actual work dedicated to it since it has to be carefully balanced with regards to game visuals or else it can improperly blur and not make back much performance, upscalers on the other hand are much less hands on with not much resources required to make it work properly seeing as most games are able to be modded easily with support for stuff like dlss regardless of their actual support for it just so long as the games run on dx12

I think the biggest problem is d3d11ondx12 conversion wrapper vs just straight dx12 vulkan is similar but tends to be the better api when it comes to conversion layer

I believe that a lot of the performance hits also has to do with DRM in the background. I tried a (safe) cracked version of Dead Island 2 which is a DX12 title and features FSR2 Upscaling and Variable Rate Shading which I haven't seen used before, however the pirated version used the most of my GPU and little of my CPU, while averaging 170-200 FPS. Once I brought the game through Epic I noticed a huge FPS drop now running at 100-150, now utilizing more of my CPU. It might be interesting delving into what the DRM is doing to cause such a performance hit. I know Dead Island 2 specifically uses Denuvo v18. And my Specs are a 12-600k OC P cores @5Ghz, E cores @4.2Ghz with 3600 DDR4 Quad channel and a 3070 Gaming X Trio flashed with a Suprim X Vbios for +50W which helps for a small 10-15% FPS increase in titles.

At some point, I'll be playing an older game with "last gen" graphics and I can't help but notice that it still looks as good or even better than newer games to a degree but with a lot less stress on the system. It makes me wonder why the need to push current hardware to the extreme just to have, in my opinon, a hardly noticible difference in graphics other than ray tracing and 4k + textures which may or may not be worth it.

I love this content and this discussion, I did want to bring up the difference vulkan makes in RDR2: the 1% and 0.1% lows are much higher than on DX12, meaning a smoother experience overall. The advantages of vulkan aren't always in the high framerates.

Are we talking about driver overhead or is it just devs optimization techniques specific for Dx11 while Dx12 is still inexperienced I want to see GamerNexus Cover this and see the actual cause and results

One thing I believe is worth mentioning and it shows on the Red Dead Redemption 2 footage is while there appears to be little difference between the DX12 and Vulcan overall FPS, the 1% lows are generally much better with Vulcan. Look at the frame time chart; Vulcan tends to have less "stuttering" and in my opinion, gives a better overall experience.

Armored Core 6 is going to be built on DX12. I really hope it's not as big of an issue. I hope it runs well

Sorry out of topic may i know the music used in the background that's starting at minute 9:47 sir😄 ?

It's definitely a per-game optimization thing. And you have to look not just at average FPS but also 1% lows (stutters). For example in Apex I get like 50% higher average FPS with DX12 when nothing is going on, but when the fighting starts I get way more noticeable stutters so I stick to DX11 despite the average FPS being lower. While on The Witcher 3 DX12 obviously allows for DLSS Quality + Frame Generation + Raytracing so it's the superior choice (for my 4070). It's unfortunate that we have to do this, but trying both (and Vulkan) on every single game is the way to go.

I will be always impressed by Black Mesa, an HL2 mod than became a standalone gorgeous game (the best next-gen HL1 experience so far). Made by a small indie studio, it uses *DirectX 9.0c,* looks like it has RT on but it's all PURE OPTIMIZED RASTER! Running smooth like DooM Eternal. _edit: the engine used it's the latest 2007 update of Source, an engine made in 2004. Apex Legends and Titanfall games runs on heavly modified dx11 version of Source too._

Vulkan/DX12 both originate in AMD's Mantle API. The idea was to give developers more hardware control, but in exchange, they had to plan for every GPUs out there. What we're seeing now is devs that programmed for one single GPU.

Some of the performance issues that DX/D3D12 has is due to a security feature that Windows has named "Control Flow Guard" which can cause stuttering and inconsistent frametimes. DX11 is also bound by single-thread speed, so depending on your CPU you can get much more fps with DX12 if your CPU has slower cores (e.g. Ryzen 7 2700X and older or old Intel CPUs), so games like can Fortnite can yield ~30% higher fps with DX12 when CPU bound as long Windows security features aren't killing your frames.

Yeah I noticed the DX11 vs DX12 yesterday while playing Path of Exile. On DX12 it struggled to hit 120FPS while on DX11 it was smooth sailing with 120FPS at like 60% GPU usage. To be fair it is clearly labeled that DX12 is Beta, still it's a massive difference.

I was thinking about this yesterday. Things have gotten so bad that frame generation "fixes" the cpu being hammered in TLOU and jedi survivor (jedi has a dlss3 mod and it also uses 16gb vram with all the settings maxxed out). With dx12 and dx12 ultimate, devs have bitten off more than they can chew.

I know for Unity games that will come out in the next few years (if they use the latest version or update the engine), dx12 will get a measurable performance boost and is as fast or faster in most cases. So that's good news

@vextakes control flow guard on or off when tested dx12 games ?

Vulkan, like DX12 is a close to metal API, that means that GPU vendor driver layer is just kept at the bare minimum, still that doesn't mean they can't optimise it or even (often in nvidia's case) like to derive from what MS or the Khronos group have standardised (RTX, later on integrated, VK_NV...) to keep headache on non-nVidia users and developpers. When you transfert the responsibility of optimising the draw calls, compute etc... by the CPU from GPU vendors to developpers in their engine (looking at you UE) you often get that unoptimised mess because they either don't fully control these API calls in the case they're using a third party engine like UE or Unity and it's up to Epic to support them for instance or figure it out themselves. Or they simply don't have the time for that. With DX11, quite often the GPU vendor came to the rescue and tweaked their drivers to optimise things further, it's still the case with DX12 but the results are quite minimal every time. In the end is DX12/Vulkan a bad thing? No, they appeared at a time when it was needed and developpers wanted more control. Now with the growth of UE games we simply see the limits of what a "generic" game engine can do even if the demos are incredible, there's no way they're covering all game use cases perfectly. While game dev carelessness is for sure a good reason for unoptimised games, the problem is in most case the lack of control and the separation of the game developpement and game engine developpement they have. Remnant II is a perfect example of this, and many more are.

VRS has a pretty minimal performance gain, while also having visible artifacting if you know what to look for. You're still basically reducing the resolution of parts of the screen (shader wise, anyway). To even get a decent improvement, you need it aggressive enough that blockiness starts to be visible.

ive done my own tests with dx11 vs dx12 on pc fortnite (and some side research) and it gives a significant boost to performance (60-80 fps for me), but when you first switch to it, it stutters a lot and needs time to adjust or something

the rate at which you and your channel is growing is incredible

To give you some context, DX12 on wither 3 was very poorly made bc it was mainly an experiment for cd project devs to learn how to use some tools and add RT.

At rdr 2,using direct x causes frame time graph to spike often, specially noticeable at low end gpus. Whereas vulkan has a smooth frame time graph even in your video. The 1% low is what matters more than fps

Many of the games I've played in recent years have the ability to swap between DX(insert version) and Vulkan. What ends up happening is you get a ton of people asking "Which is better?" And my answer is always "Try both and see."

Excellent video. I'm no expert, but I do know more than enough to know that you've really done a great job.

Early dx11 and tesselation was like this too.

In rdr2, vulkan has better performance with heavy cpu workloads like massive AI crowds in Towns/Citys. Dx12 has better image quality. A good example is the field of blue bonnets (flowers) near adlers ranch in the North west of strawberry.

The question is, how much time is really spent on code optimization? As you see in the speed increase on cpus with big caches the code and data localization is pretty low, probably caused by many indirections via pointers. The next question is, is all the control that these APIs offer really used by the developer or do they just use a high level game engine that shadow all of this? To my understandment Unreal Engine 5 is just doing this: Shadow the graphics APIs. I am no developer but sometimes I need to program myself at work. A fast provided solution is often preferred by the bosses to a speedy program.

i find this interesting because with my 1060 i run both fortnite and Kena better on DX12 rather than 11, both get about 20fps more on average, but the studders are heavily reduced

Devs doesn't really figured DX12. Additionally for it to work better you need to run around for time being for cache to load in and essentially DX12 would provide slightly lower FPS, but much more stable since it's way better at multi-threading than DX11. Also, we don't have an insight about how companies allocate their programming staff so it hard so say if there's one team that works with multiple API's or bunch of teams or some other way.

wait so should i not have installed dx12 ultimate when there was that driver to support it? or would i just not be able to play games using the dx12 ultimate api

7:07 - It's not a matter of "choosing" to use it. It still requires a tremendous effort to implement those features, on top of re-architecting your backend to work with DX12 / VK.

I'm not a programmer, but I got experience selling custom/prebuild PCs and benchmarking games. Vulkan runs better for the most part on most systems, but especially low and midrange PCs. In RDR2 for example Vulkan gives a smoother experience, higher 1% lows and all that, over DX12.

The main problem is inefficient/poorly optimized CPU side code - in particular developers are not putting in the leg work for efficient asset streaming/traversal systems and shader compilation stuttering has also been a big problem in recent years. GPU side scaling has usually been OK but it’s the stutter struggle that’s been really unacceptable in recent times. The amount of UE games especially that ship with streaming/traversal stutter and/or shader stutter that are quite literally never fixed is astonishing. The fact that devs and publishers think it’s acceptable to make your product with such glaring technical problems is a big issue. It’s gotten so bad I pretty much just don’t buy UE games anymore on PC. DX12 / Vulkan “can be” powerful tools but only if the developer’s engineering team are up to the task - most do not seem to be unfortunately. DOOM Eternal, Red Dead 2, and post patch Cyberpunk come to mind for titles that are actually great on PC now and use low level graphics APIs.

What is the piano song in the end called? Gives me mad nostalgia and I don’t know for what

Great video man!

Denuvo is the bane of any and all games.

Never went to college, so I don't really consider myself a true "developer" but what I have is 5 years of experience in the industry. What I can say right now is a lot of the newer devs only seem to be getting into the industry because of demand and pay. Work environment can vary company to company but it's also usually acceptable. I can count on one hand the juniors or 1-2 years experienced devs who are actually passionate about their jobs. I've had slack from managers for me being to critical in code reviews, but I can actually visibly see the decrease in quality of work over these past 3 years. My last code review I dealt with a dude (not a jr btw) who parsed an xml file into an array then proceeded to loop over it 5 times to get item names and descriptions all single threaded. It's no problem in the server, companies' rich they can afford some of that cpu time, but people shouldn't pull that shit client side makes the menu laggy.

Is there any particlar reason traversal stuttering and shader compilation stutter has been far worse for me in DX12 than DX11 or Vulkan (one reason I use Vulkan every time I see it is cause that stuter is lessened)? Is there anyhting that can be done to help it other than running the game through DXVK especially UE5 games or something like Dead Space Remake?

One thing with VRS is that only quite new cards seem to support it. I was not surprised that 1060 did not support it which I still rocked a year go, but that 5700xt also does not support VRS IS surprising to me. DLSS is also exclusive to somewhat fresher cards on NVIDIA but FSR is supported by much older cards which is why it makes sense to be there as performance enhancing option. The cards that are more likely to need a performance enhancing option do not support VRS.

As a hobbyist graphics engine developer, often it's very hard to choose what to use which graphics API to use, DX works on Windows, Vulkan runs on most (however OSX removed support in place of Metal however I'm not sure they added it back), OpenGL runs on virtually everything but is old and fairly slow. Some of these systems have moved to using GPU graphics/compute libraries to merge all of these such as wgpu (which I believe uses gfx-rs for graphics and compute abstrations) on the Rust programming language. These use different shader modules such as SPIR-V or WGSL (which are both great formats however SPIR-V can be a nightmare sometimes). So now lets say I want to make a game, I'm going to use a game engine so I can avoid the nightmare of coding with all these potential graphics APIs, I just wanna write some shaders, lots use an ActorMVC model (CryEngine), some use an Entity Component System (Bevy Engine), some use a Node based system (Godot Engine), these all have their uses and how fast they run. But how are they built? Bevy Engine for example is 100% async with easy multi-threading however is hard to use, so why don't people use that? Well simply look at the engine, it's a bit of a nightmare and doesn't have all of these "modern" features requiring you to code your own shaders for ray tracing or the likes. So what's the issue? Honestly I'm not 100% sure. We have the options, we have the technology, we have very talented low level programmers (such as the WGPU and GFX-RS team) to make it so we don't have to interact with these large amount of graphics APIs by hand at next to no cost, we have people creating massive projects and graphics renderings that can do volumetric clouds at 0 cost (@rust_gamedev on twitter shares some neat things, even the frostbite engine devs are working with Rust and are seeing wonderful results!). So the only thing I can think of is investors pushing releases before optimizations happen, gotta meet those deadlines and meet those dollar values.

DX12 and Vulkan are quite hard to work with since is closer to the hardware... Vulkan can push way more (doom anyone?) but guess what, there is more coding to do. Linux translates DX to vulkan so i prefer having games with vulkan, less performance losses for me

I just wish gaming companies would take extra time to release a well polished game. I don't care how long it takes, but make it flawless and people will buy it

Hey wait how do you get the performance overlay?

I feel like Vulkan will probably be used more often going forward if developers want to go through the effort of optimizing their games graphically since you have the Steam Deck which only supports Vulkan and OpenGL (Using a translation layer to translate DirectX into Vulkan) acting as an optimization benchmark. If your game runs well on the Steam Deck, then it will run well on most relatively modern PCs.

It was always like this. For example, almost every game that has a DX9 rendering path had a lot more fps than the DX10 or DX11 rendering path on the same game. It is sad, but it really was always like that. in 95% of the games, using the LOWER API version provides you with better fps. And often with a more stable game.

An Application Programming Interface (API) is as the name implies, some kind of interface to make it easier to do things. In this case, a Graphics API is an API that let's you more easily interact with the GPU and tell it how to render something. Another example of an API is a device driver. It's a piece of software that helps you interact with the computer hardware.

Hi, could someone please tell me the name the backgroud song for the 'We want better' part ?

I had worse performance with dx12 when playing Control. And another thing I'd like to add is that it's not just fps but thermals seem to go wonky. I hit 86°c with DX12 but only 72°c with DX11.

You blame the wrong thing mate. I haven't worked with DX12 yet but it theoretically give you more control there for you can optimize the graphics pipeline better, reduce overhead. So if done correctly, games with DX12 should be less overhead than game DX11 (in a fair comparison), same go for Vulkan vs OpenGL. These next-gen modern APIs allow developers juice more out of hardware, but sometime they just juice it too hard, they should care more about optimizing for the middle to recent low-end class hardware rather than try to chase the pretty graphics at high end. Maybe game engine devs get too much money and become lazy, who knows 🤣

Thanks for putting this together

If you watch the CPU usage in Witcher 3 DX11 vs DX12, in that case the CPU is underutilized and sometimes the performance very CPU limited in DX 12, in Dx11 not and it use more than 4 CPU cores. When I had a i5 6600k I saw that all of my 4 threads were at 100% though my GTX 1070 was at 99% all the time, a CPU upgrade to i7 7700k solved that problem. Witcher 3 was the first game that I thought we are in a good direction. But since then… not so much and I have now a Ryzen 7 5800 X3D and RTx 4080 PC.

the vulcan option in rdr2 is massively better bc you get a lot less stutter as you can see in your comparison video and look at the frame time - a lot more consistent and A LOT better feeling than dx12

Direct3D12 (D3D12) is far superior to Direct3D11 (D3D11). OpenGL and D3D11 essentially manage memory behind the scenes for the developer, D3D12 and Vulkan leave the implementation and lifetime of the memory down to the developer. In fact implemented correctly the performance from Vulkan is insane, however not many engines use the API's and are often an after thought, however more and more tech is adopting these newer API's as a GPU is basically a giant parallel computing machine, and D3D12 and Vulkan are designed to take advantage of parallel computing, the implementation is not the fault of the API, it's the developers aren't implementing it well.

The “Vram crisis” is the sole reason why I bought a 7900 xtx. If there’s a game that somehow manages to max the Vram on that, i will throw a actual riot.

What we need is a high level API like DX11 or OpenGL but with modern features like ray tracing with maybe an option to do the low level bare metal stuff, forcing developers to use a low level API will just result in them doing whatever is easiest which ends up beeing worse then whatever DX11 does behind the scenes at that low level.

Whatever happened to variable rate shading? It was supposed to improve gpu performance a ton lol