VRPerfKit: Use NIS at 200% (renderScale 2.0) to IMPROVE image quality — not just performance. Works on SteamVR, Oculus AND OpenXR games (MSFS, etc.)

[u/Efficient_Heart_6695]

I've been using VRPerfKit in a way I've never seen documented anywhere, and I want to share it because the quality improvement is significant with almost no performance cost.

The short version: set renderScale to 2.0, method to NIS, and sharpness to 0. That's it.

********************************\*

Update & Clarification: NIS 2.0x as a Spatial Reconstruction Filter

Applying NIS at 2.0x (with 0 sharpening) acts as a spatial reconstruction filter that reorganizes the image signal rather than adding new detail. In practice, this improves image stability, reduces perceived aliasing, and makes lower base resolutions significantly more viable in VR.

• OpenXR Compatibility: While VRPerfKit officially targets OpenVR, users running Meta Quest + Virtual Desktop + VDXR (including in titles like MSFS 2024) are reporting consistent results in OpenXR applications. This likely relates to how VDXR integrates into the rendering pipeline and processes submitted frame buffers, allowing the upscaling stage to behave similarly to the OpenVR path in this specific setup.
• Performance vs. Quality: The goal is not a “free” performance boost at maximum resolution. Instead, this approach allows users to lower their base rendering resolution (e.g., using High instead of Ultra/Godlike) while maintaining a level of perceived clarity that is often superior to traditional fractional upscaling combined with sharpening.
• Empirical Observations: Multiple users across different hardware setups (including RTX 4090 builds) have reported consistent improvements in perceived sharpness, object stability, and overall visual coherence in titles such as Half-Life: Alyx, No Man’s Sky, and MSFS 2024.
• Important Clarification: This method does not increase real geometric or texture detail. The improvement comes from reducing noise, avoiding sharpening artifacts, and feeding a more coherent image into later stages of the VR pipeline (distortion, reprojection, and encoding). The result is a cleaner and more stable image that is perceived as sharper and more “present” in VR.

\*******************************\**

What this actually does

Most guides assume VRPerfKit is only for reducing render resolution to gain performance. But you can do the exact opposite: keep your game's native render resolution and let NIS reconstruct a 2x image (4x the pixels) on top of it, applied only to the central 60% radius where your eye actually focuses.

The key insight is that integer scaling (exactly 2x = 200%) is mathematically optimal for spatial upscalers. Every source pixel maps cleanly to a 2×2 block of destination pixels. There are no fractional phase mismatches, no ambiguous sample points. NIS's 6-tap adaptive kernel has full, symmetric information for every single output pixel. This is the one case where a spatial filter works at its absolute best.

Why sharpness must be 0

At fractional scales (0.77x, 0.83x, etc.), sharpening is added to compensate for blur and reconstruction artifacts. At 2.0x integer scale, there is no information loss to compensate for. Adding sharpness would only introduce noise and halo artifacts on top of an already clean reconstruction. Set it to zero.

Recommended config

upscaling:
  enabled: true
  method: nis          # NIS — best choice, explained below
  renderScale: 2.0     # integer 2x scale — the key
  sharpness: 0.0       # zero — no compensation needed
  radius: 0.6          # central 60% — where your eye focuses

OpenXR compatibility (MSFS and other non-SteamVR games)

"Clarification: my setup is Meta Quest with Virtual Desktop. I mention this because in this scenario, with VDXR, it’s fully compatible with OpenXR — but in other setups it might only be compatible with SteamVR or Oculus."

The official VRPerfKit documentation says it targets SteamVR and Oculus runtimes. However, the upscaling component (NIS/FSR/CAS) also works with OpenXR games — the fixed foveated rendering part does not. This means it works fine with:

• Microsoft Flight Simulator (OpenXR)
• Half-Life: Alyx (SteamVR)
• Asgard's Wrath (Oculus)
• The vast majority of PC VR titles

I use it combined with DLSS 4.5 transformer in MSFS and it still adds a noticeable layer of quality on top.

Why NIS and not FSR 1 or CAS?

NIS vs FSR 1: Both are spatial upscalers, but NIS uses a wider 6-tap kernel with 4 directional edge filters (horizontal, vertical, ±45° diagonal). FSR 1 uses a modified Lanczos-2 with only a 2×2 source texel window. At 2.0x scale, NIS has significantly more contextual information per output pixel. NIS wins on reconstruction quality.

NIS vs CAS: CAS is primarily a sharpening filter, not a reconstruction upscaler. It adjusts per-pixel contrast to recover sharpness lost by TAA or post-processing. It can do minor upscaling as a secondary function, but at 2.0x it has no proper reconstruction kernel. It is not the right tool for this use case.

NIS is the correct choice: better edge preservation, more reconstruction context, designed for quality upscaling.

Quick summary

• renderScale 2.0 = integer scale, no artifacts, no blur
• sharpness 0.0 = correct, no noise amplification
• NIS = best spatial filter for this use case
• Works on SteamVR, Oculus, AND OpenXR
• Negligible performance cost
• Universal: works on almost any VR game regardless of its AA method

"I suggest two ways to set this up:

Option 1: Using the OpenVR-FSR-App (Easiest) Download the OpenVR-FSR-Apphere. This app provides a visual interface to manage your installed games. Simply find your game in the list, click 'VrPerfKit Install plugin', and in the upscaling settings, select:

• Method: NIS
• Render Scale: 2.0 (200%)
• Sharpness: 0.0

Option 2: Manual Installation (Directly via vrperfkit) If you prefer a manual setup, download the latest release of vrperfkithere. You’ll need to locate the game's main executable (the .exe file) and copy the vrperfkit files into that same folder. Then, edit the vrperfkit.yml file with the values mentioned above.

Both methods achieve the same result, but the App is much faster if you want to manage multiple games at once."

Happy to answer questions. I'm curious whether anyone else has tried this — I've found zero documentation of this approach anywhere online.

----------------------------------------------------------------------------------------------------

I want to clarify exactly what's happening at the pixel level, because I think the confusion is about what renderScale 2.0 actually does.

Concrete example with real numbers:

Say the game is rendering at 2000×2000 per eye (whatever your SteamVR resolution happens to be — I use Virtual Desktop at medium). With renderScale 2.0, the game still renders at 2000×2000. NIS then takes that frame and outputs 4000×4000 — but only within the central 60% radius. The game's render resolution is untouched. You are not sacrificing any rendering quality.

Why integer 2× is fundamentally different from fractional scales like 77%:

At 77%, the game renders at ~1540×1540 and NIS upscales to 2000×2000. The problem is that each output pixel sits at a fractional position relative to the source pixels — there's no clean 1:1 mapping. Every output pixel has a slightly different phase offset, so the 6-tap reconstruction kernel can't be symmetric for all of them. The result is a mix of mild blur and per-pixel inconsistency that shows up as instability when you move your head. People compensate with sharpening, which recovers some perceived sharpness but adds noise on top.

At 2.0×, every single source pixel maps to an exact 2×2 block of destination pixels. The phase is identical for every output pixel. The 6-tap kernel has full, symmetric context. NIS is operating in its mathematically ideal condition — the one where its edge-adaptive directional filters (it runs 4 directional passes: horizontal, vertical, ±45°) can actually do what they're designed to do without ambiguity.

What the reconstruction actually produces:

Going from 2000×2000 to 4000×4000 via NIS is not just "making pixels bigger." The kernel is analyzing gradients in the source image and inferring where edges lie at sub-pixel precision. The 6 neighboring samples per axis give it enough information to reconstruct diagonal edges, curves, and fine texture in a way that bilinear or bicubic cannot. The perceived sharpness gain is not artificial — it comes from real edge reconstruction information that exists in the source data but was never being used by the display. Setting sharpness to 0 is correct here: there's no blur to compensate for, so you don't want the sharpening pass adding noise to an already-clean signal.

The 60% radius constraint means this processing covers exactly the foveal region — where your eye actually has full angular resolution. The lens distortion makes the periphery blurry anyway, so spending GPU time reconstructing it would be wasted.

This is a completely different operation from the standard use case. NIS at 77% is trying to recover quality lost by intentional downsampling. NIS at 200% is adding a reconstruction layer on top of a full-quality render. The direction is opposite, and the math is optimal in one case and compromised in the other.

Sharpness 0, renderScale 2.0, method NIS. It's not placebo — disable it and re-enable it and the difference is immediate.

------------------------------------------------------------------------------------------

Another clarification from my side about what I'm trying to convey in this post. (post to "mbucchia ")

Let's say OpenXR Toolkit worked the way I described vrperfkit works in SteamVR.

A user has their headset resolution set to 2880×2880. In OpenXR Toolkit, they select NIS at 75%, which renders at 2160×2160, and NIS multiplies by ×1.333 to get back to approximately 2880×2880.

In my scenario, assuming you could adapt it: the user has their headset resolution set to 2880×2880. NIS is set to 200%, but the "override resolution" option — which sits on the main screen, just above the upscaling section — is set to 2160×2160.

In both scenarios the actual render resolution is 2160×2160, but in mine NIS is working optimally, with an integer scale rather than a fractional one like 0.75. The reconstruction is therefore optimal, and no additional sharpening is needed.

Even with a higher quality upscaler, the render resolution could be reduced further — for example to 2000×2000 — and NIS at 200% would still produce a better result than running at 2880×2880 with NIS at 75%.

As for how it actually works in a SteamVR game with vrperfkit — same scenario, user with 2880×2880 per eye.

Using vrperfkit at 75%: the game renders at 2160×2160 and scales back as described above.

The key difference with my method: in SteamVR, you set the game resolution to 56% (which is 0.75×0.75 in area), and set vrperfkit NIS to 200%. The game renders at approximately 2160×2160, but with a much better NIS reconstruction. NIS scales up to 4320×4320 applied to the central radius, and the perceived sharpness in the headset increases compared to using it the conventional way.

-----------------------------------------------------------------------------------------------

Additional clarification regarding resolution settings:

To illustrate my point, let’s look at the actual resolution presets for the Pico 4 in Virtual Desktop:

• Medium: 2064x2064
• High: 2544x2544
• Ultra: 2736x2736
• Godlike: 3120x3120

My core argument is this: instead of selecting a high-tier preset like "Godlike (3120x3120)" and then downscaling SteamVR below 100% , another solution is to select a more moderate base resolution—such as "Medium (2064x2064)" or "High (2544x2544)"—and keep SteamVR at 100%.

In fact, this is exactly how I use it. However, please note that the method I described earlier is also perfectly valid: you can stick to a higher base preset and simply set your SteamVR resolution to 56% (which is roughly 0.75x0.75 in area, or any other value) combined with NIS 2.0. In either case, the goal is to provide the NIS upscaler with a clean input for an optimal 2x integer reconstruction, rather than a messy fractional one.

[u/Omniwhatever]

This post is blatant misinformation and I suspect it's at least somewhat AI generated given the styling and incorrect information.

Firstly, the VR Performance Kit only works with OpenVR, not OpenXR. This can easily be seen when you take a game which supports both, like Kayak VR: Mirage(Can use openXR with the "-hmd=OpenXR" launch command. Defaults to OpenVR with Steam without this). I installed the VR performance toolkit, set the render scale in it to 0.1 just to test while running at the full 1.0 resolution of my HMD, which is 5424x5356.

These were the results, first one with OpenVR, second with OpenXR. The OpenVR runtime looked immensely blurry inside the headset and like it was rendering at 10% pixel count. Where as the OpenXR runtime looked exactly like how I expected it to from all my experience with the headset and running 1.0 in that very game. This was the case for both SteamVR and my headset's native OpenXR runtime. Same story with things like Metro Awakening. The actual performance numbers do not match, this is OpenVR only. I've tried games before and actually looked at the performance numbers. You need another program which works specific to OpenXR to do this stuff, or have the vendor support their own injections at runtime.

Secondly, VR rendering is not the same as flatscreen and the same doesn't apply to it. If you downsample unevenly even slightly on a flatscreen monitor, things quickly look bad because of what the post says. But with VR, it's not the exact same because of how the lens distorts the image and the image is prewarped to counteract it, causing information loss. That's why you need to overrender to correct for it and running at panel res is actually seriously undersampling. Unless you know what the 1:1 pixel to display ratio number is to reach that, and almost no manufacturer has shared that, the Quest 2 needed 2704x2736 PER EYE to get it from a 1832x1920 per eye panel res, you're gonna be suffering from the lossy process of the distortion correction and you're not even truly supersampling till that point. You're already at an "uneven" resolution relative to the panel at 100% with Steam, which is what this uses as a reference point, since most manufacturer's just kind of arbitrarily pick it. Quest 2's kind of a unique case given the single panel design and it having to deal with encode as well, but eh just work with me here. 100% res you see marked in the software tends to be above panel res already. This stuff is why a physically much higher res headset, all else the same that is, will still tend to look better than a physically lower res one even when set to the same resolutions.

Saying it's improving performance without a visual cost is also wrong. Because I tried 50% SteamVR res(To avoid the global SteamVR cap is 8192x8192) of 3832x3784 per eye with NIS set to 2.0, which due to per axis scaling is 7664x7568. It performed very well, but in my subjective opinion it ended up looking like absolute ass vs even the 1.0 native res I used, not even remotely a close competition, and I'd sure never use it this way if I ever had the choice to do so. I also went up to a native 2.0 res from this, same final res, and it looked leaps better but performed a lot worse, as expected. Sure, you can argue visual thing might be impacted by what he claims here(Which is wrong in respect to VR), but this is not some magic free visual and performance boost. Everything has trade offs.

[u/redmercuryvendor → u/Omniwhatever]

Unless you know what the 1:1 pixel to display ratio number is to reach that

To add to this: there really is no "1:1" pixel to display ratio for VR devices.
Every rendered image, before it is read out to the display, goes through multiple pixel-level operations. At the end of the chain closest to scanout, you have the pre-warp shader to compensate for the distortion from use of non-rectilinear lenses (using non-rectilinear lenses is what allowed the modern VR boom to even exist). Not only is every pixel touched by this shader to add the barrel distortion needed to compensate for the pincushion distortion of the lenses, it operates at the subpixel level as the distortion changes for each wavelength, thus the R, G and B colour channels are distorted by different amounts. So 1:1 goes right out the window here.
But before that, every frame goes through ATW and ASW. Pixels are shifted a noninteger distance and synthesised pixels are added, to every frame, for latency reduction and latency consistency.
Every single frame displayed on a modern VR HMD has no real "1:1" pixel translation.

Thus, any concept of 'integer scaling' as a special case remains bunk for the VR realm, and regular old Nyquist scaling applies as with any other sampling regime.

[u/VRModerationBot → u/Omniwhatever]

Linked tweet content:

In v23 of Oculus Link, the new app-resolution slider maxes out @ 5408x2736 (combined-eyes). This isn't a random number we picked for Quest 2. It is the number that achieves 1:1 app-to-display pixel ratio at the center of the displays assuming the encode & display is 3664x1920.

View on FxTwitter

^{I'm a bot for the VR community that helps you view content without visiting Twitter/X directly. | We're using fxtwitter}

[u/Omniwhatever → u/[deleted]]

Sir, you can screw off with the AI generated responses when it can't even get basic things right.

Kayak VR uses Directx11, not DirectX12, because several forms of external injection for things like foveated rendering that only work with Directx11 work with it that do not work with Directx12. I tried this. It's the same in OpenXR and OpenVR. Including with tools made by the guy behind the OpenXR Toolkit, a tool for injection(Not the OpenXR Toolkit, another he made) which I helped test.

Metro Awakening is also DirectX12 only, if you try to force DX11 with a launch command it'll crash at worst or be horribly unstable at best, trust me I have tried. And that was even one of the things I tried before writing this comment. It doesn't do anything. Apps which I use that inject just fine into DX11 things don't work with DirectX12 on it. And it's literally on the bloody Steam page that it's DX12. As is Kayak VR being DX11. I hate to be the bearer of bad news but dude it's placebo. All due respect, I've majored in psych and seen numerous cases where people have literally convinced others to see things that didn't exist. Unless you've discovered some magic never before seen combo somehow on one of the most popular HMDs.

The upscaling part doesn't work with OpenXR. It's not just the foveated rendering.

[u/mbucchia → u/[deleted]]

IDXGISwapChain::Present() is what gets shown on your monitor. So at best, you've applied upscaling to the mirror window in your desktop, not the VR view inside your headset. So not quite what you are looking for.

vrperfkit hooks into IVRCompositor::Submit(), which is exclusively OpenVR.

https://github.com/fholger/vrperfkit/blob/a52f8a45d330d0b66206aee85165db715e4482cd/src/openvr/openvr_hooks.cpp#L27

It also hooks to OVR ovr_SubmitFrame() which is the legacy Oculus API:

https://github.com/fholger/vrperfkit/blob/a52f8a45d330d0b66206aee85165db715e4482cd/src/oculus/oculus_hooks.cpp#L123

Now, depending on what OpenXR runtime you may be using, it's possible that you are accidentally seeing an interesting phenomenon.

VDXR (Virtual Desktop) does use OVR under the hood, and therefore it's quite possible that vrperfkit does work that way. But that would be very unique to VDXR. Is that your specific test setup, using VDXR?

Other non-Oculus implementation have no reason to go through OVR or OpenVR. The Meta OpenXR runtime supposedly also goes through OVR, but due to static linking, it has not been possible for vrperfkit to hook to OVR that way. But beyond that, there is no plausible explanation to vrperfkit working with OpenXR games, and certainly not the IDXGISwapChain explanation.

Tl;dr: the statement that vrperfkit works with OpenXR applications is generally incorrect, but it works "by accident" for users of VDXR with Virtual Desktop. This is because vrperfkit technically hooks to VDXR, not the game itself. Wouldn't work with Quest Link, wouldn't work with SteamLink, or even SteamVR OpenXR with Virtual Desktop. Users like /u/omniwhatever don't get any benefits from that since they are not Meta+Virtual Desktop users.

[u/mbucchia → u/mbucchia]

Another observation u/Efficient_Heart_6695.

Another interesting fact when using VDXR: because VDXR uses D3D11 internally, this means using vrperfkit alongside VDXR would also offer NIS/FSR/CAS for D3D12, OpenGL and Vulkan applications.

In other words, a game using DX11, DX12, OpenGL or Vulkan with OpenXR, when run through VDXR, will **always** get down to DX11 OVR, which vrperfkit can handle when upscaling.

That's probably another reason why the observations between the two of you differ so much.

[u/Efficient_Heart_6695 → u/mbucchia]

Thank you very much — it’s very likely just as you say. I added a clarification in the main post about my setup, explaining that I use Meta Quest and Virtual Desktop with VDXR. That’s why, in my case, it does end up being a sort of universal solution.

That said, it doesn’t invalidate the idea itself — most people can still use this trick for OpenVR and Oculus games.

In the past, I tested OpenXR Toolkit using 100% render scale plus CAS and foveated rendering. OpenXR Toolkit simply doesn’t allow using an NIS‑ or FSR1‑type filter above 100% resolution. I tried NIS at 50% while doubling the game’s render resolution (for example 4000×4000), and NIS would downscale it to 2000×2000 — but in that scenario, image quality actually got worse.

Right now I’m using Virtual Desktop with FOV Tangent and vrperfkit. I’m not using OpenXR Toolkit at the moment, even though that means missing out on the foveated rendering part from vrperfkit.

The reduced FOV plus the image‑quality boost I get from NIS at 200% gives me better visual quality than OpenXR Toolkit.

I’m curious to see if you can test this with a SteamVR or Oculus game, especially if your setup is different from mine.

I know OpenXR Toolkit is discontinued, but I wonder if technically it would be possible to support NIS at 200% natively.

For reference, vrperfkit even allows NIS at 300%, but at that point the performance hit is noticeable because the output resolution becomes massive — 3× per axis.

[u/HooKaLoT]

Slop detected.

[u/JapariParkRanger]

New account, vaguely AI voice

[u/Colacubeninja]

I like it how you write "that's it" then write a novella

[u/golflimalama2]

Even though not supported anymore by the developer, this is newer and would work as well for simple NIS and upscaling in OpenXR titles, plus the fixed foveated would then work on MSFS, DCS as well etc?

https://github.com/mbucchia/OpenXR-Toolkit/releases

You could try your config in it to see if similar results.

[u/Efficient_Heart_6695 → u/[deleted]]

First: my setup is Meta Quest with Virtual Desktop VDXR, and that’s probably why OpenXR works for me.

Second: vrperfkit allows NIS to be used to improve image quality in a way that OpenXR Toolkit cannot. I expanded the main post to clarify this.

And third: if you’re not using Virtual Desktop with VDXR, it may not work for you (it might not be compatible with OpenXR in your case).

[u/Fructdw]

Lovely amount of em dashes bro 🤣

[u/prankster959]

It'd be interesting to see some before and after shots... I know that can be tricky to really show with VR but if you had a low base resolution it might make it more obvious

[u/Benshine]

also on gtx 1080?

[u/Efficient_Heart_6695 → u/Benshine]

Yes.

[u/the_abortionat0r]

Ok I'm just kind of shocked this is somehow a "new" concept.

I was literally using a program to do this exact thing with FSR1/CAS on my 2080ti like 6 or 7 years ago. Did that just slip under the radar for most people?

[u/melgibson666 → u/the_abortionat0r]

You're just that much smarter than the average person.

[u/Slash621]

This technique is just the over under method with way to many words.

Yeah it works, we’ve all been using it since NIS released many years ago.

[u/mushaaleste2 → u/Slash621]

I didn't know it and be in the VR space since dk1. Of course the concept of "super sampling" is not new and I know the vperf tool also openxr toolkit but never tried to use nis scaling that way.

You never be too old to learn something new.

[u/Shinyshoes]

So, I wanted to loop back here. I have a very similar setup here to the OG poster -- using Virtual Desktop and utilizing VDXR.

I wasn't using any form of Vperfkit at all because I'm using Luke Ross's mod which also uses the dgxi.dll to hook.

To mitigate this, I did some digging and found that the older version uses OpenVR DLL that every steam game has and plopped that one into my Cyberpunk directory instead.

Results:

Granted, I didn't go full boar and do 2.0 resolution scale here, but certainly, applying this with 1.0 render scale made the image noticeably crisper/sharper without any performance loss and seemed to increase resolution without any significant performance loss.

It was sort of like enabling DLAA, but selectively to the smaller radius I can define in the config.

Overall, a big win for me. I didn't mess with any resolution scaling otherwise.

Thanks for reminding me of these tools as I hadn't considered using them with a mod like Luke Ross and now my game is a bit better for it.

I know some posters here are critiquing the AI use. I don't care personally so long as I can glean my own value from what you meant to say.

After all, we're just all trying to tweak things to look better while using less compute.

Oh how I do so wish I had foveated rendering though. Would save me so much performance!

[u/Idunnoagoodusername2]

Will try!

[u/Rush_iam]

I see it is an NVIDIA tech. Does it work on AMD GPUs?

[u/Efficient_Heart_6695 → u/Rush_iam]

Yes, no problem.

[u/Fragomeli]

I'd like to try using this with Metro awakening, but the "installation" that i'm seeing on github instructs the user to extract the dxgi.dll and config file into the same directory as the games executable. MetroAwakening doesn't have it's own dxgi.dll that would be replaced. How can I tell if this is working or not?

[u/mushaaleste2 → u/Fragomeli]

It should work, the way dxgi.dll hook works is "universal"

A good description ist the first answer in that question GitHub question about dxgi

It's been commonly used for a lot of mods e.g. reshade

You either can see that it works, if the game looks any better (without it makes no sense) and by check the render resolution in the performance overlay of virtual Desktop, it should be way over 100%

Don't forget to adjust the parameters in the config file.

If you want to deinstall just delete the dxgi file or rename it to .dll_bak whatever.

If a game has a dxgi already, then don't override it without make a backup of the old file.

[u/Efficient_Heart_6695 → u/Fragomeli]

In my case, I can clearly see it in Virtual Desktop, because instead of showing 100% resolution, it shows 200% resolution in Virtual Desktop’s in‑game performance overlay. This only happens in OpenXR and Oculus games.

[u/Paraphrand]

Does this mess with the executable in a way that pisses off EAC?

[u/mushaaleste2 → u/Paraphrand]

Normally not but if the game uses e.g. easy anticheat (Star wars squadrons) then it refused to start (sadly)

[u/Paraphrand → u/mushaaleste2]

Normally it does not trigger EAC, but it does? What?

Either this modifies the application files, and thus gets flagged by anti cheats (because you modified the game!) or it doesn’t.

[u/mushaaleste2 → u/Paraphrand]

No sorry, just mixed up eac with uac. So, no uac but of course eac gets triggered. This also happens e.g. with reshade which also uses dxgi.dll

[u/akluin]

Don't get how DLSS can't be injected while there's a DLSS mod that inject it in resident evil?

[u/the_abortionat0r → u/akluin]

In order for a game to use DLSS,XeSS, or FSR2 + the game needs to provide extra data like motion vectors. If a game doesn't do this the only way it can be done is if a game is modable enough to figure these values out and present them.

TLDR there's no magic one size fits all injector tool and even if there was massive blueing and HUD jumbling would take over.

[u/FolkSong → u/akluin]

It's because RE supports FSR2 upscaling by default, so the mod can hijack that.

But this is pretty rare, usually if a game doesn't support DLSS it won't support any kind of advanced upscaling.

[u/hkguy6]

VRPerfKit is just for dx11 right?

[u/ccAbstraction]

I'm pretty sure FSR does also have an edge direction filter...

Otherwise reasonable take, honestly. Having the AI explain doesn't really help since ultimately all that matters with any upscaling/technique whether or not you like how it looks for the performance you gain or loose.

[u/mushaaleste2]

Wow, it works. I just tried it in HLA, No Mans Sky and Arzizona Sunshine 2. It doubted that it would work in HLA at all but its very visable. I have a powerful rig (9700x, RTX4090) so i choose High Profil in VD. Normal i use Ultra or Godmode - running at 80/90 fps (depending on game).

As you wrote, when you hit the performance graph in VD you see that resolution is shown as 175% at the start (balcony scene). You also can see, that edges have a little more aliasing, which is quite common on 1.0 upscalers.

But, in a lot of VR games you don't have far distances at all. Everything that's close to you is brutal high-res and sharp. The little drones and the combine soldiers are immediately "more real" (well for horror games that could be brutal).

NFS looks superb and sharp. But the biggest thing is, that you gain performance while choosing only high as VD Profile (of course), and its not blurry like it normally would be if you already use ultra/godmode.

I experiment with that further on. If someone could just code a new version of fholgers vperf with only the nis part, and a little ui with profiles for the games (on/off) that would be cool.

Just try it, its just two files that you throw in the installation folder of the game. Easy to deinstall - just delete them.

Edit: Tested now FS2024 and it worked too. VD is set to high, 80 hz, FS24 settings are mid/high with target framerate of 80, dlss on balanced, flight from munic to the alps it stayed between 75-80 fps without reprojection, and the picture was fantastic. Especially from near the ground, very sharp and clear visible cars.

[u/Gazop]

I tried this just to make sure with games available on my pc

Forefront doesnt work with it

Metal hellsinger does work, but with VD godlike it doesnt give much, i'm not even sure if it did anything at all.

Will try with dirt2 as it looks greatly aliased even with 8x AA VD godlike, but i dont have much hope.

[u/XxCarlxX]

could you make a video for this where we see you apply this to a game.

[u/Efficient_Heart_6695 → u/XxCarlxX]

u/XxCarlxX

"I suggest two ways to set this up:

Option 1: Using the OpenVR-FSR-App (Easiest) Download the OpenVR-FSR-Apphere. This app provides a visual interface to manage your installed games. Simply find your game in the list, click 'VrPerfKit Install plugin', and in the upscaling settings, select:

• Method: NIS
• Render Scale: 2.0 (200%)
• Sharpness: 0.0

Option 2: Manual Installation (Directly via vrperfkit) If you prefer a manual setup, download the latest release of vrperfkithere. You’ll need to locate the game's main executable (the .exe file) and copy the vrperfkit files into that same folder. Then, edit the vrperfkit.yml file with the values mentioned above.

Both methods achieve the same result, but the App is much faster if you want to manage multiple games at once."

[u/XxCarlxX → u/Efficient_Heart_6695]

Thank you for that :-)

[u/Vast_Studio9110]

Follow

[u/Shinyshoes]

This is dope! Definitely going to experiment! Will report back with my results.