(I did read the current forum rules and the references I am posting here do not violate them.)

I just noticed that this forum already has a topic about this in the "Archimedean Dynasty", but I decided to move my reply here since this stuff affects much more old games. Especially pixel-art games. So I think that many more retro-gamers might be interested in this. But it's also interesting for modern games in case you own a 4K monitor and your graphics card is to slow to properly handle it.

It's all about getting rid of the blur when playing games in low resolutions (for instance old/retro-games) on modern high-resolution-monitors. People requesting this solution ended up calling it "integer scaling". (I prefer "pixel perfect scaling".) It works by converting each pixel into a perfect square of 2x2 pixels, 3x3 pixels etc.

I attached a picture that shows the difference for a scaling ratio of 8x for comparison (which is realistic for a 4K monitor if you want to upscale an old game with a resolution close to 320x240). View the picture in it's full size. What we want is above and the current situation is below. (The name of the game in the screenshot is "KQ lives" and it's released under GPLv2-license (which means that I'm not violating any copyrights by posting a screenshot here). It's an unfinished game abandoned by it's developers, although there is currently an attempt to resurrect it. OK, back to our topic.)

As you can see it is very useful for pixel-art. However this is also interesting for modern games in case you are using a 4K monitor, because it lets you reduce the resolution to 1920x1080 (and thus increase the performance/frame-rate) without introducing any additional blur. So basically you can turn a 4K monitor into a Full-HD monitor whenever your graphics card is to slow to handle 4K.

The main discussion about integer scaling is currently taking place on the Nvidia's forums and has reached 749 comments on 50 pages(!!!) (People who are interested in this tend to be retro-gamers, retro-game-developers, 4K-monitor-owners and laptop-owners.):

forums.geforce.com/default/topic/844905/

A petition to ask the developers of the GPU-drivers to implement integer scaling has been started and so far reached over 1400 signatures:

change.org/p/nvidia-amd-nvidia-we-need-integer-scaling-via-graphics-driver

Also strong evidence that the current GPUs are technically capable to do this exists. (I can provide it if necessary.)

Also the developer of the "nGlide" 3Dfx-emulator is one of those people who agreed with us and plans to include it into the next release. But this is only a solution for a small subset of old games.

Only the integration of the solution into to the GPU-drivers will make it compatible with all the games and all the monitors.

Oh yeah, I much prefer integer scaling if available (most good emulators give the option). It would be great to have it as a GPU option as an alternative to the standard bilinear and 1:1 modes.

There's a solution against Bler? Is it a Gargamel solution?

The ability to switch to nearest-neighbour scaling is already available in nVidia driver for Linux, Solaris, and FreeBSD since version 384.47 (2017-06-29). It can be enabled via a Terminal command like this:

nvidia-settings -a CurrentMetaMode="DP-1: 3840x2160_60 {ViewPortIn=1920x1080, ViewPortOut=3840x2160, ResamplingMethod=Nearest }"

Unfortunately, the feature is UNUSABLE in many games:

devtalk.nvidia.com/default/topic/1019141

Those games are blurrily upscaled and then CROPPED instead of being properly upscaled using nearest-neighbour interpolation. Such problematic games are e.g. Limbo, Syder Arcade, Trine Enchanted Edition.

According to Aaron Plattner from nVidia, the reason of such cropping is that such games incorrectly interpret data received from RandR.

There is also a significant PERFORMANCE DROP at least in some games such as F1 2017 where 1280x720 scaled via Transform Filter is more jerky than 1920x1080 in regular full-screen mode. It is important that this happens REGARDLESS whether with Nearest or Bilinear scaling method, so this is apparently an issue of the entire Transform-Filter feature and not a result of that Nearest-neighbour scaling is implemented programmatically unlike hardware-accelerated Bilinear one.

Unfortunately the feature is NOT available in nVidia GeForce driver for Windows while Linux market share is just about 1%.

Some important resources related to the blurry-scaling issue:

* tanalin.com/en/articles/lossless-scaling/ — the “Nonblurry integer-ratio scaling” article — an attempt to explain the blur issue and collect and summarize all the important relevant info about the issue and nonblurry integer-ratio scaling by pixel duplication as a solution.

* tanalin.com/_experimentz/demos/non-blurry-scaling/ — demo (web-based) that shows how proper nonblurry scaling should work.

* www.change.org/p/nvidia-amd-nvidia-we-need-integer-scaling-via-graphics-driver — petition (Change.org) for adding proper upscaling to graphics drivers.

* forums.geforce.com/default/topic/844905 — a 50-pages thread about the issue on the official nVidia GeForce forum.

* community.amd.com/thread/209107 — a thread about the issue on the official AMD forum.

* www.zeus-software.com/forum/viewtopic.php?t=2065 — nGlide (Glide emulator/wrapper) feature request (accepted).

Also please see the attached image that clearly shows the crucial difference between blurry and proper integer-ratio scaling.

Solution against blur?
https://www.youtube.com/watch?v=SSbBvKaM6sk

Please avoid offtopic.

I don't think so.

That song got me into Blur; got me to start buying their records and listening to them, the very opposite of against.

HAHAHA! *THUD*

Very funny, I just laughed my head off.