Supersampling

Supersampling (also called supersample anti-aliasing, or SSAA) is a rendering technique in which a scene is drawn at a higher resolution than the display it will be shown on, and the result is then filtered down to the display's resolution. Every output pixel is computed from several samples instead of one, which reduces aliasing artifacts such as jagged edges and shimmering. Writing on the RasterGrid blog, Daniel Rákos describes the method as rendering "at a higher resolution than the final target (e.g. twice the width and height to achieve 4x supersampling) and then downsampling the produced image", and notes that its performance and memory cost rise by the same ratio as the resolution.^[1]

In virtual reality the word is used in a looser, user-facing sense: it usually means raising a headset's render resolution above the default that the VR runtime recommends. Road to VR's June 2016 guide described it as rendering "at a higher resolution than the Vive's native 2160 x 1200 before finally downsampling and displayed in the VR headset".^[2] The setting has gone by several names: "render target multiplier" in early SteamVR, "pixel density" or "pixels per display pixel" in the Oculus SDK, "render resolution" in the Oculus PC app,^[3] and a percentage slider in later SteamVR versions.^[4] VR is sensitive to aliasing because each display pixel covers a large part of the visual field. In a 2024 user study on the HP Reverb G2, participants preferred supersampling over multisample, temporal and fast approximate anti-aliasing, although its lead over temporal anti-aliasing was not statistically significant.^[5]

Reviewed 27 September 2026. Checked every new claim, figure and quotation against the cited Valve GDC 2015/2016 slides, Meta PC and OpenXR developer docs, Road to VR, UploadVR, ComputerBase and NVIDIA articles, the PBR textbook and the 2024 Waldow et al. paper. About review dates.

How it works

A rendered image is a set of point samples of a continuous scene. In their textbook Physically Based Rendering, Matt Pharr, Wenzel Jakob and Greg Humphreys explain that the sampling and reconstruction process "introduces error known as aliasing, which can manifest itself in many ways, including jagged edges or flickering in animations". By the sampling theorem, a signal can only be reconstructed exactly when it is sampled at more than twice its highest frequency (the Nyquist rate). The simplest remedy is to raise the sampling rate until the copies of the signal's spectrum no longer overlap, which is what supersampling does.^[6] Geometric edges are step functions with infinite frequency content, so no finite sampling rate removes aliasing completely; the authors conclude that "we can never remove all of its sources".^[6]

The book describes three related strategies. Nonuniform (stochastic) sampling "tends to turn the regular aliasing artifacts into noise, which is less distracting to the human visual system". Adaptive supersampling finds regions with high-frequency content and takes additional samples only there, "without needing to incur the computational expense of increasing the sampling frequency everywhere". Prefiltering blurs the signal before sampling so that no frequencies remain that the sample rate cannot capture.^[6] On the history of the problem, the same authors write that Franklin Crow "first identified aliasing as a major source of artifacts in computer-generated images" in 1977, and that Robert Cook introduced nonuniform sampling to turn aliasing into noise in 1986.^[7]

Supersampling and multisampling

In supersampling every sample is fully shaded, so a 4x supersample runs the pixel shader four times per output pixel. Multisample anti-aliasing (MSAA) is a cheaper variant: it stores depth and coverage for several samples per pixel but, in its basic form, runs "only a single fragment shader invocation for each pixel a primitive overlaps with, no matter how many samples within that pixel the primitive actually covers".^[1] In practice MSAA concentrates its extra samples on polygon edges and leaves the interior of surfaces at the normal rate, which is why it costs much less than supersampling.^[5]

Why VR render targets are larger than the display

A head-mounted display shows its panels through magnifying lenses, and Meta's PC SDK documentation states that if the original rendered images were shown on the Rift, "the user would observe them with pincushion distortion". The runtime cancels it by warping each rendered view with "an equal and opposite barrel distortion so that the two cancel each other out".^[8] The eye buffer is therefore not simply sized to the panel: according to the same documentation, "Render texture size is determined based on the FOV and the desired pixel density at the center of the eye".^[8] Valve's Alex Vlachos gave the numbers for the HTC Vive Developer Edition at GDC 2015: a 2160 x 1200 framebuffer (1080 x 1200 per eye), rendered off-screen at about 1.4x in each dimension, or 1512 x 1680 pixels per eye, which is 2,540,160 shaded pixels per eye.^[9] At 90 Hz for both eyes this came to 457 million shaded pixels per second, compared with 124 million for a 1080p monitor at 60 Hz. Vlachos also estimated that the headset delivered about 15.3 pixels per degree, against roughly 25 for a 30-inch 720p monitor with a 50 degree horizontal field of view, and concluded that "we must increase the quality of our pixels"; Valve used 4x MSAA as the minimum and 8x "if perf allows".^[9]

The 1.4x figure is therefore not supersampling in itself. It is the baseline; on an HTC Vive, SteamVR's 100 percent setting corresponds to 1,512 x 1,680 pixels per eye, and user-facing supersampling multiplies it further.^[4] Vlachos noted that "1.4x is just a recommendation for the HTC Vive (Each HMD design has a different recommended scalar based on optics and panels)", and advised developers to scale the render target down on slower GPUs and up on faster ones: "If you've got GPU cycles to burn, BURN THEM".^[9]

The Oculus SDK expresses the same idea as a ratio. Its pixelsPerDisplayPixel parameter "determines the relative size of render target pixels as they map to pixels at the center of the display surface", and the default of 1.0 sets the render target pixel density to the display 1:1 at that point.^[10] The SDK function ovr_GetFovTextureSize computes the eye texture size from the field of view and this pixel density.^[8] The developer documentation takes a cautious line on raising the value: "Although you can set the parameter to a value larger than 1.0 to produce a higher-resolution intermediate render target, we haven't observed any useful increase in quality and it has a high performance cost." It recommends lowering pixel density rather than the video output resolution to save GPU time, and offers a dynamic resolution option that adjusts pixel density automatically between 0 and 1.^[10]

Performance cost

Because the scale factor applies to each axis, the pixel count grows with its square. Road to VR's 2016 guide to the Oculus Debug Tool noted that a setting of 2 quadruples the pixels the PC has to render; on a GeForce GTX 980 Ti the writer reached a pixel density of 1.8 before the frame rate suffered, with visible judder and skipped frames once Asynchronous Time Warp could no longer compensate.^[11] The companion Vive guide warned that the setting needs enough GPU power to keep a VR game above 90 frames per second "and avoid judder and general discomfort".^[2]

Memory grows as well. In his GDC 2016 talk, Vlachos explained why Valve's Aperture Robot Repair demo stopped at a 1.4x resolution scalar (on top of the 1.4x baseline) with this table of render target sizes and GPU memory for colour, depth and resolve buffers:^[12]

Resolution scalar	MSAA	Render resolution per eye	GPU memory, one eye	GPU memory, two eyes
2.0	8x	3024 x 3360	698 MB	1,396 MB
2.0	4x	3024 x 3360	388 MB	776 MB
1.4	8x	2116 x 2352	342 MB	684 MB
1.2	8x	1814 x 2016	251 MB	502 MB

Adaptive quality

Valve's answer to the cost was to change the resolution at run time. Vlachos defined "Adaptive Quality" as a system that "dynamically changes rendering settings to maintain framerate while maximizing GPU utilization", with two goals: fewer dropped and reprojected frames, and higher quality when GPU cycles are idle. The settings it may change include the rendering resolution or viewport (dynamic resolution), the MSAA level, fixed foveated rendering and radial density masking. In Aperture Robot Repair the scale ran from level +6 (8x MSAA at 1.4x resolution, where a GeForce GTX 980 Ti rendered for 95 percent of the experience) down to level -4 (4x MSAA at 0.65x resolution with radial density masking, the floor for a GTX 680). Vlachos advised against going as low as 0.65 because in-game text becomes very difficult to read, and suggested a floor of about 0.8.^[12]

Runtime and driver implementations

Year	Software	Setting	What it does
2016	SteamVR	`renderTargetMultiplier` in `steamvr.vrsettings`	Hand-edited multiplier for the HTC Vive render target^[2]
2016	Oculus Debug Tool	Pixels Per Display Pixel Override	Overrides the Oculus SDK pixel density for the running game, 1.0 to 2.0^[11]
2017	SteamVR	Advanced Supersample Filtering	Downsampling filter that reduces aliasing at the cost of a slightly softer image^[13]
2018	SteamVR beta	Auto resolution	Benchmarks the GPU and picks one render resolution for all SteamVR applications^[14]^[4]
2020	NVIDIA driver	Variable Rate Supersampling (VRSS)	Supersamples a fixed region in the centre of the view using variable rate shading^[15]
2020	Oculus PC software v19	Quest and Touch, Graphics Preference, Render Resolution	Sets the render resolution for Oculus Link^[3]
2021	NVIDIA driver R465	VRSS 2	Moves the supersampled region with the user's gaze using eye tracking^[16]

SteamVR

Early SteamVR had no menu setting for render scale. Users edited the renderTargetMultiplier value under the "steamvr" section of steamvr.vrsettings in the Steam config folder, and Road to VR's June 2016 guide used a value of 2.5, suggesting users lower it in steps of 0.1 if frame rate suffered.^[2]

In March 2018 Valve added automatic resolution selection to the SteamVR beta. It measures the GPU and tells applications to render at a matching resolution, which amounts to supersampling on fast GPUs; it covered the Vive, Vive Pro, Oculus Rift and Windows Mixed Reality headsets, and manual overrides remained in the SteamVR video settings. Vlachos said: "We set the resolution based on how many 'VR megapixels per second' we believe your GPU is safely capable of", and compared the approach to "what most PC games have done for decades for different resolution monitors and TVs".^[14] ComputerBase reported that the benchmark runs at each start and applies one scale factor to every title. In its example, an HTC Vive with a GeForce GTX 1080 Ti was set to 236 percent (2,323 x 2,581 pixels per eye), while mid-range cards such as the GTX 1060 and RX 580 stayed at 100 percent (1,512 x 1,680). The automatic range was about 100 to 240 percent, against 100 to 500 percent for the manual slider.^[4]

SteamVR also has an "Advanced Supersample Filtering" option, which UploadVR describes as a downsampling method that "produces less aliasing at the cost of a slightly softer image". It has existed since 2017; according to Valve it was "accidentally disabled" for Meta headsets a few years earlier, and a December 2023 update turned it back on for Steam Link and Meta Quest Link. The changelog said it "improves video quality when using high supersampling rates".^[13]

Oculus and Meta

For the original Oculus Rift, which runs at 2160 x 1200 at 90 Hz across two displays,^[17] users raised pixel density with the Oculus Debug Tool, a troubleshooting utility from the Oculus SDK. Its "Pixels Per Display Pixel Override" field sets the resolution a running game renders at before it is downsampled for the headset.^[11] Meta's current documentation places the tool in the Support\oculus-diagnostics folder of the Meta Horizon PC software installation.^[18]

Version 19 of the Oculus PC software, which reached the Public Test Channel in July 2020, added a Render Resolution option for Oculus Link under Devices, Quest and Touch, Graphics Preference. Its presets were 1568 x 1728 per eye (Prioritize Performance), 2448 x 2688 (Balanced) and 2784 x 3056 (Prioritize Quality), and the automatic mode chose Performance on a GTX 970 and Balanced on an RTX 2070. A change required restarting the Oculus software. When an application enables the Oculus SDK's dynamic resolution feature, that system takes priority and the Link setting is ignored.^[3]

On standalone Quest headsets, Meta's OpenXR extension XR_FB_composition_layer_settings lets developers apply a supersampling filter to individual compositor layers, such as text panels or video, that the compositor would otherwise undersample to match the display. The "normal" variant is "an efficient two-tap filter which alters the sampling pattern every other frame to approximate a more computationally expensive four-tap filter", while the "quality" variant "performs conventional supersampling with no temporal component". The documentation warns that layer filtering needs more GPU resources and may cause dropped frames.^[19] Meta Quest Super Resolution, which Meta presented to developers in July 2023, works the other way round: it is "a single-pass spatial upscaling and sharpening technique" applied to content rendered below display resolution.^[20]

NVIDIA Variable Rate Supersampling

NVIDIA released Variable Rate Supersampling (VRSS) in a driver on 6 January 2020. It uses the variable rate shading capability of the Turing architecture in RTX GPUs to apply a "foveated" supersampling region at the centre of the image and leaves the periphery, which the lenses blur anyway, at normal quality. Games must be based on DirectX 11 or use forward renderers, and must support MSAA. When GPU headroom is available, VRSS supersamples up to 8x. NVIDIA recommends the "Adaptive" mode, because "Always On" can drop the frame rate below the headset's native rate. On an NVIDIA test system, the company claimed that VRSS reached 4x supersampling in Boneworks at a 120 FPS average, compared with roughly 75 FPS for a traditional 4x supersample. The feature was enabled for 26 games at launch.^[15]

VRSS 2, which arrived with driver R465 in 2021, adds gaze tracking so that the supersampled region follows the user's eyes instead of staying fixed in the centre. It uses Tobii Spotlight eye tracking and first launched on the HP Reverb G2 Omnicept Edition, with a shading rate of up to 8x, and developers do not need to add any code for it.^[16] NVIDIA presents VRSS 2 as a dynamic form of foveated rendering.^[16]

Research

Kristoffer Waldow and colleagues compared four anti-aliasing methods built into the Unity engine in a pairwise-comparison study presented at the 2024 GI VR/AR workshop. Their abstract notes that anti-aliasing "is essential for Virtual Reality (VR) applications, as the pixels of current VR displays subtend a large field of view". The study used an HP Reverb G2 (native resolution 2160 x 2160 pixels) with the per-eye render resolution set to 2700 x 2630 to account for lens distortion, driven by an RTX 3090. It compared 2x SSAA, 4x MSAA, temporal anti-aliasing (TAA) and FXAA across four scenes in static and moving variants, with 24 participants.^[5] SSAA gave the best image quality and FXAA the worst. SSAA differed significantly from MSAA, but the difference between SSAA and TAA was not significant. The authors argued for choosing SSAA in VR, while noting its large performance cost at 4x or 8x.^[5]

Manual configuration on early PC headsets

The instructions below were written in June 2016 for the first consumer versions of the HTC Vive and Oculus Rift. Later software replaced the hand edits with settings in the runtime (see above).

Supersampling on HTC Vive

Updated on June, 2016

Go to your steam install path, for me this is C:\Games\Steam, for many it will be C:\Program Files(x86)\Steam.
Enter the config directory
Open steamvr.vrsettings in notepad or your preferred text editor(sublime etc not word)
Under "steamvr" add "renderTargetMultiplier": 2.5 (with a multiplier of your choice)
- IMPORTANT: between each item there should be a , EXCEPT for the last one(so Python programmers beware)

MY code looks like this:

"steamvr" : { "allowReprojection" : true, "background" : "C:\Program Files (x86)\ViveSetup\Updater\viveNight.png", "renderTargetMultiplier": 2.5 },

Supersampling on Oculus Rift