Nvidia “Dynamic Super Resolution”

It looks like Nvidia has been implementing real driver support for higher-quality downsampling:

They have a much nicer name for it – Dynamic Super Resolution – even though I still don’t see what exactly is dynamic about it. If you read their description, it does sound like it sets out to fix many of the issues I also tried to circumvent when I first started working on GeDoSaTo:

Enthusiasts with compatible monitors and technical knowledge refer to this process as Downsampling, and for some time they’ve been applying a basic version to improve fidelity in games. DSR improves upon this process by applying a high-quality Downsampling filter that significantly improves image quality, by making Downsampling compatible with all monitors, by removing the need for technical know-how, and by integrating DSR into GeForce Experience, enabling gamers to apply DSR Optimal Playable Settings with a single click.

Improving downsampling quality and making it independent from monitor hardware compatibility have always been two of the most essential goals of GeDoSaTo. Obviously, with driver integration you are also in a position to make things much easier for non-technical users, something which was never a real target for GeDoSaTo.

However, the largest advantages of a driver-based method are the following:

  • Compatibility - since you can act after the 3D API, and not on its level, you get compatibility with any API, including all versions of DirectX and OpenGL.
  • Input Independence – a lot of the hard parts both in writing GeDoSaTo and in configuring it come with making mouse input work, since the OS knows it’s actually running at resolution X while the game thinks it’s running at Y. When operating on the driver level, OS and applications will be on the same page again, removing a major source of issues and need for implementation work.

These are things which are far harder to achieve in GeDoSaTo, and will likely never be possible on the same level.

Nonetheless, GeDoSaTo has evolved a lot from its initial role as just a downsampling tool, with HuD-less screenshot taking, postprocessing, texture replacement and other features taking a major role. Also, it seems like, at least for now, it will remain the only option for larger than 2×2 downsampling. And of course, it will always be more highly configurable – and obviously less vendor dependent – than a driver tool.

In any case, I’m really happy that high-quality downsampling is finally acknowledged by a hardware vendor (and, if history is any indication, it won’t be too long before AMD catches up). And I’m even happier to think that perhaps the reason it happened now is at least partly because of GeDoSaTo.

GeDoSaTo shader development features, Dark Souls 2 SSAO improvements

I just pushed an update to GeDoSaTo which makes it significantly easier to work on shaders and effects (i.e. downsampling, SSAO, postprocessing). It’s now possible to bind a key for reloading shaders. The magic thing however, and what really saves time, is that if loading the new shader fails the old one will continue to be used instead, and the error will be reported:

screenshot_2014-08-23_14-58-34_0This really saves a lot of time restarting games. My workflow is now to have the game running in a window in the corner of the screen, and have Visual Studio take up the other half. This way, I can make changes to the shader and see the result in-game in about 3 seconds. It’s not a GUI, but it’s much more flexible and almost as fast in terms of iteration.

To prove the claim that this makes shader development much easier, I set out to improve GeDoSaTo’s SSAO. While better than the built-in monstrosity, this was never really high quality, particularly considering its performance impact. Well, it’s a whole lot better now:

_prev _curThat’s the old version on top and the new one in the bottom. Look in particular at the detail in the distance, the lack of pixelation on the grass, the much better definition on objects like the staircase and the lack of polygonal artifacts on the floor.

Now, you might ask “But Durante, the AO was already really heavy, can I really afford to run the new version performance-wise?”. The answer is yes, absolutely. For the result shown above, the previous version took around 9 ms of GPU time on my 770. The new one takes 4.8 ms.  If you’re keeping track, that’s almost twice as fast as previously. While also looking better, and sporting fewer artifacts.

You can get the new version right now with the updater.

Oh, one more thing. Since someone asked in a donation message: yes, I do read all the donation messages :P

GeDoSaTo User Setting Profiles

While automatic updating seems to work out fine now, it introduces an issue for everyone who is not me: you have to recreate/restore your settings and keybindings every time you update. This sucks.

Therefore, the latest version introduces user profiles for both settings and keybindings. What does this mean? User profiles allow you to store settings and/or keybindings in additional _user files, which do not get distributed with GeDoSaTo and therefore persist across updates.

The loading for settings files and keybindings now proceeds like this:

configSo global user configuration extends/overrides the default configuration, is in turn overridden by game-specific configuration if it is available, which is finally extended by user game-specific configuration. This should hopefully let everyone do exactly what they want.

And even though I hate writing UIs, I even made a nice UI for managing profiles and user profiles:

settings2The “U” button creates a user profile (or switches to it if it already exists), the “+” creates a new profile and the “-” deletes the current file (and cleans up the directory if it’s empty afterwards).

The filter allows you to filter profiles shown in the selection with substring matching, so e.g. “Risen” will only show you profiles for Risen. I think this will get more relevant now with more people contributing profiles.

If you enjoy this update and want to support me doing boring stuff like UI for your convenience, you can always donate here. And of course, you can get the most recent GeDoSaTo version either by using the built-in updater, or by installing it from here.

GeDoSaTo Distribution Changes Mark II

Sadly the new method didn’t really work out all that well for many people, so I made everything automatic and as foolproof/convenient as I can:

updaterPlease go to the new GeDoSaTo page to learn more.

GeDoSaTo should now be supremely easy to install and keep up to date for everyone!

In the future, I’ll do blog updates about GeDoSaTo whenever there is a new interesting feature, but without an accompanying release, as it should now be very easy for everyone to always get the latest version.

GeDoSaTo release/distribution changes

As you might have noticed, there was no GeDoSaTo release this last weekend, even though I kept up a biweekly release cycle previously.

The reason for this is that I switched to uploading binaries on GitHub.

What this means for you:

  • You can always get the very latest gedosato.dll and executable right here, as well as new config profiles etc.
  • If there is a regression (that is, something which was previously working stops to work), you can help with fixing it even if you cant compile GeDoSaTo, by determining exactly which commit broke it.
  • You need to take slightly more care to also e.g. get the updated configuration file when getting a new version which makes configuration changes.

What this means for me:

  • I have more time to work on GeDoSaTo, since packaging, uploading and documenting/posting about a release does take some time.
  • I get more immediate feedback on new features from people who follow development closely.
  • I get fewer donations, since I usually get one or two with every new release. Well, you can’t win them all.

The current version on Github as of this posting is 0.11.1162, and it has a plethora of new features and fixes over the last “regular” release:


  • Allow multiple downsampling resolutions to be available at the same time
  • Added support for multisampling while downsampling
  • Made the presentInterval setting work even when not downsampling
  • Can now bind Xinput buttons to actions
  • Added option to force presentation resolution regardless of request
  • Fixed Steam overlay rendering with alternative injection method
  • Fixed handling of GetDepthStencilSurface
  • Fixed crash bug with Steam Big Picture Mode
  • Hook d3d9 debug dll separately (restoring third party injector compatibility)


  • Unified injection methods (!)
  • Stop accumulating empty lines when sorting
  • Added event handling for unloading dll (related to Steam Big Picture Mode crash fix)

Mitsurugi Kamui Hikae Plugin:

  • Added plugin, has all functionality of the generic plugin
  • Plus can render game at arbitrary resolution (vanilla game is limited to 1080p)

I hope this works out, it seems like a much better solution.

By the way, as I said in the last post, if you do a bug report in the blog comments it will most likely be lost. Please report bugs/issues at GitHub where they can be centrally tracked and more conveniently discussed.

Edit: I realized that this won’t work out for everyone. Stay tuned for new information, hopefully tomorrow.

GeDoSaTo Beta 10 Release – “Poltergeist”

Two weeks have passed, time for another release. Lots of fixes and additions in this one, and also many new profiles. My article seems to have worked to at least some extent, it’s great to see pull requests popping up on GitHub (even if most are not code).


  • General:
    • Added feature to disable HUD (in games with a targeted injection profile)
    • Added keybinding to toggle through scaling methods
    • Added option to prevent Steam Overlay loading (thanks GoaLitiuM)
    • Added “loadD3DEarly” compatibility option
    • Now possible to list and query readable app name from whitelist
    • Fixed downsampling with more than 3 levels
    • Fixed stupid typo preventing games with backbuffer formats other than the default from working correctly (thanks Boulotaur2024)
    • Fixed crash when framedumping, store framedumps as TGA, create folders for each
    • Fixed crash with special characters in blacklist/whitelist entries
    • Fixed “interceptOnlySystemDlls” with nonstandard system paths
  • GeDoSaToTool:
    • Can now sort black/whitelists
    • Fixed working directory when launched at windows startup
  • Generic Plugin:
    • Show exe name and (if available) readable name in status display
    • Added option to target screenshots/postprocessing to specific renderstate changes (“injectRenderstate [state],[value]” — example of use in Ys Origin profile)
    • Added lots of profiles, thanks to all the contributors

Download GeDoSaTo 0.10 “Poltergeist” here. And if you just found out about GeDoSaTo or have been using it for a while and want to encourage further work on it donations are always welcome.

One more thing: if you want to report bugs or request features, please do so at github. It’s much easier to follow, manage and discuss such things there than in the blog comments!

GeDoSaTo Beta 9 Release – “Underground Network”

This is mostly a bug-fixing and compatibility release, while under the hood changes continue to get ready for broader API support (which, before you ask, is a lot of work and will still take a while).


  • General:
    • Added nearest neighbour scaling option (this is intended to be used for upscampling in retro games, not downsampling)
    • Added “interceptOnlySystemDlls” option to potentially increase compatibility with 3rd party injectors
    • Fixed enum ordering in the scaler (should *really* fix Mafia 2)
    • Fixed overlays/console not rendering in some games
    • Fixed normal resolution screenshot regression introduced in beta 8
    • Fixed initialization for games which use automatic depth/stencil generation (e.g. Witcher 1)
    • Fixed initial render state settings
  • GeDoSaToTool:
    • Added option to launch at windows startup
    • Added command line option for launching minimized
    • Check for and resolve leftover registry entries on startup
  • Generic Plugin:
    • Extended postprocessing/screenshot targeting functionality (can now delay to first draw after marked pixel shader is set)

Basically, this release further improves compatibility, fixes some bugs and increases the functionality of the generic plugin. It also adds some requested useability features to GeDoSaToTool.

Download GeDoSaTo 0.9 “Underground Network” here, and if you want to encourage further work on GeDoSaTo donations are welcome.

There are even more options which can be configured per-game now, so if you find some compatibility settings (or good postprocessing options) for a given game please contribute on github.

Edit: Oh, and yes, Chrome is probably still falsely flagging GeDoSaTo. Take it up with Google, their processes for trying to get this fixed are stupid.

GeDoSaTo Beta 8 Release – “Rapidity is a justice”

This release comes with a Smörgåsbord of feature additions to both GeDoSaTo itself and the tool. It also increases game compatibility greatly, adds a high-quality Lanczos downsampling option, and massively increases screenshot performance.


  • General:
    • Added ability to have per-game postprocessing shaders
    • Added the “forceAlwaysDownsamplingRes” option (can be used to make reluctant games – like Divinity:OS – show downsampling resolutions)
    • Added Lanczos downsampling filter option
    • Changed default screenshots to also capture GeDoSaTo overlays
    • Made screenshot-taking asynchronous (basically 0 performance hit for the first SS)
    • Restored neutral render state before downsampling [Boulotaur2024]
    • Refactored rendertarget management (to easier turn API agnostic later)
  • GeDoSaToTool:
    • Implemented alternative dll injection strategy (for games which build the
      D3D device before doing anything which would be caught by the default)
    • Prevented multiple instances of GeDoSaToTool being started
    • Added startup checks for path validity and admin rights
    • Added basic editors for postprocessing shaders

The combination of the new injection method and improvements in GeDoSaTo now allows games like Divinity: Original Sin (which is a fantastic game releasing tomorrow which you should buy, btw.), Witcher 2 and Mafia 2 to work with Downsampling.

Download GeDoSaTo 0.8 “Rapidity is a justice” here, and I always appreciate any donations made here.

There are a lot of options which can be configured per-game now, so if you find some compatibility settings (or good postprocessing options) for a given game please contribute on github. Of course, more in-depth code contributions are also very welcome!

Once again, GeDoSaTo is not a virus or whatever else your misguided browser/scanner heuristic wants to label it as. It just does a lot of pretty wild stuff. If you don’t believe me, compile your own from Github, all the source is up there :P

If the alternative injection method is not working for you, you might have to set the registry value “LoadAppInit_DLLs” in the key “HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows NT\CurrentVersion\Windows” to “1″. Beta 9 will do this automatically.

GeDoSaTo Beta 7 Release – “Seishoujo Sacrifice”

The first release after open-sourcing the project! There haven’t been any source contributions yet, but at least one person gave me some pointers to issues which need investigation.

I’m very happy with this release, particularly since I managed to fix the alt-tabbing crash bug which has been in GeDoSaTo since day 1 (read more here). But there are lots of other improvements as well, see below.


  • General:
    • Fixed Alt-tab crash when downsampling in fullscreen mode (!)
    • Added IDirect3DSwapChain9 interception (fixes compatibility with some games, e.g. Dragon Age Origins)
    • Screenshot fallback to full-size if hudless not available
    • Fixed Z/stencil buffer format detection (fixes e.g. GTA4)
    • Improved handling of automatically generated z/stencil buffers (don’t duplicate, we don’t need an original-res depth buffer when downsampling)
  • Generic Plugin:
    • Store screenshots after AA/postprocessing, not before
    • Only use float BB if required (should improve AA/post performance on most games)
    • Added ability to specify a “marker” pixel shader in the configuration, in order to apply AA/postprocessing before HUD rendering and capture hudless screenshots
  • GeDoSaToTool:
    • Added ability to edit game profiles using the built-in editor (still need to be created externally)

I guess I will need to create a guide for the new pixel shader marker functionality in the generic plugin. Its goal is to allow everyone to enable postprocessing without affecting the UI and hudless screenshots for every game, simply by editing the config file, without coding a plugin or compiling GeDoSaTo. Currently, I’ve added a config file for Blackguards which uses this feature.

Download GeDoSaTo 0.7 “Seishoujo Sacrifice” here, and I always appreciate any donations made here.

If you find a shader hash and create a config file for a given game, please post it on github, I will then include it in future releases.