RTX Options

This file contains a complete reference of all configurable RTX Options in RTX Remix.

For detailed documentation on the RtxOption system architecture, including layers, priorities, and how values are resolved, see RemixConfig.md.

This file is auto-generated by RTX Remix. To regenerate it, run Remix with DXVK_DOCUMENTATION_WRITE_RTX_OPTIONS_MD=1 defined in the environment variables.

Simple Types

RTX Option	Type	Default Value	Min Value	Max Value	Description
rtx.accumulation.blendMode	int	0			The blend mode to use for accumulating debug view output. Supported modes are: 0 = Average, 1 = Min, 2 = Max. Average is the default mode and is the most common mode to use for accumulation. Min and Max are useful for visualizing the minimum or maximum value of a debug view output over time.
rtx.accumulation.numberOfFramesToAccumulate	int	1024	1		Number of frames to accumulate render output. This can be used for generating reference images smoothed over time. By default the accumulation stops once the limit is reached. When desired, continous accumulation can be enabled via enableContinuousAccumulation.
rtx.accumulation.resetOnCameraTransformChange	bool	True			Resets the accumulated debug view output when the camera transform changes.
rtx.adaptiveAccumulation	bool	True
rtx.adaptiveResolutionDenoising	bool	True
rtx.adaptiveResolutionReservedGPUMemoryGiB	int	2			The amount of GPU memory in gibibytes to reserve away from consideration for adaptive resolution replacement textures. This value should only be changed to reflect the estimated amount of memory Remix itself consumes on the GPU (aside from texture loading, mostly from rendering-related buffers) and should not be changed otherwise. Only relevant when force high resolution replacement textures is disabled and adaptive resolution replacement textures is enabled. See asset estimated size parameter for more information.
rtx.advanceTime	bool	True			A flag to enable or disable advancing time used by Remix subsystems (particle effects, animations, etc.).
rtx.aliasing.beginPass	int	0			The first render pass where the aliasing resource is bound in a frame.
rtx.aliasing.depth	int	1			The depth of the aliasing resource. Required for 3D textures.
rtx.aliasing.endPass	int	39			The last render pass where the aliasing resource is bound in a frame.
rtx.aliasing.extentType	int	0			Specifies the resolution type for the aliasing resource. If a 3D texture is used, depth must also be set.
rtx.aliasing.formatCategory	int	-1			Specifies the texture format compatibility category for the aliasing resource.
rtx.aliasing.height	int	720			The height of the aliasing resource in pixels.
rtx.aliasing.imageType	int	1			The image type of the aliasing resource (e.g., 1D, 2D, or 3D).
rtx.aliasing.imageViewType	int	1			The image view type of the aliasing resource (e.g., 1D, 2D, 3D, or cube).
rtx.aliasing.layer	int	1			The number of layers in the aliasing resource.
rtx.aliasing.width	int	1280			The width of the aliasing resource in pixels.
rtx.allowCubemaps	bool	False			When enabled, cubemaps from the game are processed through Remix, but they may not render correctly.
rtx.allowFSE	bool	False			A flag indicating if the application should be able to utilize exclusive full screen mode when set to true, otherwise force it to be disabled when set to false. Exclusive full screen may see performance benefits over other fullscreen modes at the cost of stability in some cases. Do note that on modern Windows full screen optimizations will likely be used regardless which in most cases results in performance similar to exclusive full screen even when it is not in use.
rtx.alwaysCopyDecalGeometries	bool	True			When set to True tells the geometry processor to always copy decals geometry. This is an optimization flag to experiment with when rtx.useBuffersDirectly is True.
rtx.alwaysWaitForAsyncTextures	bool	False			Force CPU to wait for the texture upload. Do not use an asynchronous thread for textures. If true, a frame stutter should be expected.
rtx.antiCulling.light.enable	bool	False			Enable Anti-Culling for lights.
rtx.antiCulling.light.fovScale	float	1			Scalar of the FOV of lights Anti-Culling Frustum.
rtx.antiCulling.light.numFramesToExtendLightLifetime	int	1000			Maximum number of frames to keep when Anti-Culling is enabled. Make sure not to set this too low (then the anti-culling won't work), nor too high (which will hurt the performance).
rtx.antiCulling.light.numLightsToKeep	int	1000			(DEPRECATED)
rtx.antiCulling.object.enable	bool	False			Extends lifetime of objects that go outside the camera frustum (anti-culling frustum).
rtx.antiCulling.object.enableHighPrecisionAntiCulling	bool	True			Use robust intersection check with Separate Axis Theorem. This method is slightly expensive but it effectively addresses object flickering issues that arise from corner cases in the fast intersection check method. Typically, it's advisable to enable this option unless it results in a notable performance drop; otherwise, the presence of flickering artifacts could significantly diminish the overall image quality.
rtx.antiCulling.object.enableInfinityFarFrustum	bool	False			Enable infinity far plane frustum for anti-culling.
rtx.antiCulling.object.farPlaneScale	float	10			Scale applied to the far plane for Anti-Culling Frustum for matching the culling frustum in the original game.
rtx.antiCulling.object.fovScale	float	1			Scale applied to the FOV of Anti-Culling Frustum for matching the culling frustum in the original game.
rtx.antiCulling.object.hashInstanceWithBoundingBoxHash	bool	True			Hash instances with bounding box hash for object duplication check. Disable this when the game using primitive culling which may cause flickering.
rtx.antiCulling.object.numObjectsToKeep	int	10000			The maximum number of RayTracing instances to keep when Anti-Culling is enabled.
rtx.applicationId	int	102100511			Used to uniquely identify the application to DLSS. Generally should not be changed without good reason.
rtx.autoExposure.autoExposureSpeed	float	5			Average exposure changing speed (in units per second) when the image changes.
rtx.autoExposure.centerMeteringSize	float	0.5			The importance of pixels around the screen center.
rtx.autoExposure.enabled	bool	True			Automatically adjusts exposure so that the image won't be too bright or too dark.
rtx.autoExposure.evMaxValue	float	5			Min/Max values tuned by moving from bright/dark locations in game, and adjusting until they look correct.
rtx.autoExposure.evMinValue	float	-2			Min/Max values tuned by moving from bright/dark locations in game, and adjusting until they look correct.
rtx.autoExposure.exposureAverageMode	int	1			Average mode. Valid values: <Mean=0, Median=1>. The mean mode averages exposures across pixels. The median mode is more stable for extreme pixel values.
rtx.autoExposure.exposureCenterMeteringEnabled	bool	False			Gives higher weight to pixels around the screen center.
rtx.autoExposure.exposureWeightCurve0	float	1			Curve control point 0.
rtx.autoExposure.exposureWeightCurve1	float	1			Curve control point 1.
rtx.autoExposure.exposureWeightCurve2	float	1			Curve control point 2.
rtx.autoExposure.exposureWeightCurve3	float	1			Curve control point 3.
rtx.autoExposure.exposureWeightCurve4	float	1			Curve control point 4.
rtx.autoExposure.useExposureCompensation	bool	False			Uses a curve to determine the importance of different exposure levels when calculating average exposure.
rtx.autoUnblockOptionEdits	bool	False			If true, editing an RtxOption in the Remix UI that is overridden by a stronger config layer clears the stronger value immediately instead of showing a confirmation dialog.
rtx.automation.disableBlockingDialogBoxes	bool	False			Disables various blocking blocking dialog boxes (such as popup windows) requiring user interaction when set to true, otherwise uses default behavior when set to false. This option is typically meant for automation-driven execution of Remix where such dialog boxes if present may cause the application to hang due to blocking waiting for user input.
rtx.automation.disableDisplayMemoryStatistics	bool	False			Disables display of memory statistics in the Remix window. This option is typically meant for automation of tests for which we don't want non-deterministic runtime memory statistics to be shown in GUI that is included as part of test image output.
rtx.automation.disableUpdateUpscaleFromDlssPreset	bool	False			Disables updating upscaler from DLSS preset. This option is typically meant for automation of tests for which we don't want upscaler to be updated based on a DLSS preset.
rtx.automation.enableTestTrace	bool	False			Enables opt-in frame trace artifacts for automation-driven image tests. When enabled, Remix records a bounded frame window around the configured screenshot frame, writes frame_trace.jsonl, and appends dxvk_trace_* summary fields to metrics.txt.
rtx.automation.suppressAssetLoadingErrors	bool	False			Suppresses asset loading errors by turning them into warnings. This option is typically meant for automation of tests for which acceptable asset loading issues are known.
rtx.blockInputToGameInUI	bool	True			If true, input will not be passed to the game when the UI is active. Can be toggled with Alt + Backspace
rtx.bloom.burnIntensity	float	1			Amount of bloom to add to the final image.
rtx.bloom.enable	bool	True			Enable bloom - glowing halos around intense, bright areas.
rtx.bloom.luminanceThreshold	float	0.25			Adjust the bloom threshold to suppress blooming of the dim areas. Pixels with luminance lower than the threshold are multiplied by the weight value that smoothly transitions from 1.0 (at luminance=threshold) to 0.0 (at luminance=0).
rtx.bloom.steps	int	5	1	8	Number of downsampling steps to perform [1..8]. A higher value produces a wider blooming radius.
rtx.calculateLightIntensityUsingLeastSquares	bool	True			Enable usage of least squares for approximating a light's falloff curve rather than a more basic single point approach. This will generally result in more accurate matching of the original application's custom light attenuation curves, especially with non physically based linear-style attenuation.
rtx.camera.correctProjectionYFlip	bool	False			Some games (typically Unity titles) use a projection matrix with a negative Y scale, causing the ray-traced scene to render upside down. Enable this to automatically detect and correct the Y-flip in the projection matrix at runtime.
rtx.camera.enableFreeCamera	bool	False			Enables free camera.
rtx.camera.freeCameraPitch	float	0			Free camera's pitch.
rtx.camera.freeCameraPosition	float3	0, 0, 0			Free camera's position.
rtx.camera.freeCameraViewRelative	bool	True			Free camera transform is relative to the view.
rtx.camera.freeCameraYaw	float	0			Free camera's position.
rtx.camera.lockFreeCamera	bool	False			Locks free camera.
rtx.camera.useFreeCameraForComponents	bool	True			Use free camera for graph components when free camera is enabled.
rtx.cameraAnimationAmplitude	float	2			Amplitude of the free camera's animation.
rtx.cameraAnimationMode	int	3			Free camera's animation mode.
rtx.cameraJitterSequenceLength	int	64			Sets a camera jitter sequence length [number of frames]. It will loop around once the length is reached.
rtx.cameraSequence.autoLoad	bool	False			Load camera sequence automatically.
rtx.cameraSequence.mode	int	0			Current mode.
rtx.cameraShakePeriod	int	20			Period of the free camera's animation.
rtx.capture.correctBakedTransforms	bool	False			Some games bake world transforms into mesh vertices. If individually captured meshes appear to be way off in the middle of nowhere OR instanced meshes appear to all have identity xform matrices, enabling will attempt to correct this and improve stage + mesh viewability in tools. Hashes are unaffected.
rtx.captureDebugImage	bool	False
rtx.captureEnableMultiframe	bool	False			Enables multi-frame capturing. THIS HAS NOT BEEN MAINTAINED AND SHOULD BE USED WITH EXTREME CAUTION.
rtx.captureFramesPerSecond	int	24			Playback rate marked in the USD stage. Will eventually determine frequency with which game state is captured and written. Currently every frame -- even those at higher frame rates -- are recorded.
rtx.captureInstances	bool	True			If true, an instanced snapshot of the game scene will be captured and exported to a USD stage, in addition to all meshes, textures, materials, etc. If false, only meshes, etc will be captured.
rtx.captureMaxFrames	int	1			Max frames capturable when running a multi-frame capture. The capture can be toggled to completion manually.
rtx.captureMeshBlendWeightDelta	float	0.01			Inter-frame blend weight min delta warrants new time sample.
rtx.captureMeshColorDelta	float	0.3			Inter-frame color min delta warrants new time sample.
rtx.captureMeshNormalDelta	float	0.3			Inter-frame normal min delta warrants new time sample.
rtx.captureMeshPositionDelta	float	0.3			Inter-frame position min delta warrants new time sample.
rtx.captureMeshTexcoordDelta	float	0.3			Inter-frame texcoord min delta warrants new time sample.
rtx.captureNoInstance	bool	False			Same as 'rtx.captureInstances' except inverse. This is the original/old variant, and will be deprecated, however is still functional.
rtx.captureOverwriteExistingCapture	bool	False			If true, a capture with the same filename will overwrite any existing capture file instead of appending a numeric suffix to avoid collisions.
rtx.captureShowMenuOnHotkey	bool	True			If true, then the capture menu will appear whenever one of the capture hotkeys are pressed. A capture MUST be started by using a button in the menu, in that case. If false, the hotkeys behave as expected. The user must manually open the menu in order to change any values.
rtx.compositePrimaryDirectDiffuse	bool	True			Enables direct lightning's diffuse signal for primary surfaces in the final composite.
rtx.compositePrimaryDirectSpecular	bool	True			Enables direct lightning's specular signal for primary surfaces in the final composite.
rtx.compositePrimaryIndirectDiffuse	bool	True			Enables indirect lightning's diffuse signal for primary surfaces in the final composite.
rtx.compositePrimaryIndirectSpecular	bool	True			Enables indirect lightning's specular signal for primary surfaces in the final composite.
rtx.compositeSecondaryCombinedDiffuse	bool	True			Enables combined direct and indirect lightning's diffuse signal for secondary surfaces in the final composite.
rtx.compositeSecondaryCombinedSpecular	bool	True			Enables combined direct and indirect lightning's specular signal for secondary surfaces in the final composite.
rtx.debugView.accumulation.blendMode	int	0			The blend mode to use for accumulating debug view output. Supported modes are: 0 = Average, 1 = Min, 2 = Max. Average is the default mode and is the most common mode to use for accumulation. Min and Max are useful for visualizing the minimum or maximum value of a debug view output over time.
rtx.debugView.accumulation.enable	bool	False			Enables accumulation of debug ouptput's result to emulate multiple samples per pixel or over time.
rtx.debugView.accumulation.numberOfFramesToAccumulate	int	1024	1		Number of frames to accumulate debug view's result over. This can be used for generating reference images smoothed over time. By default the accumulation stops once the limit is reached. When desired, continous accumulation can be enabled via enableContinuousAccumulation.
rtx.debugView.accumulation.resetOnCameraTransformChange	bool	True			Resets the accumulated debug view output when the camera transform changes.
rtx.debugView.composite.compositeViewIdx	int	0			Index of a composite view to show when Composite Debug View is enabled. The index must be a a valid value from CompositeDebugView enumeration. Value of 0 disables Composite Debug View.
rtx.debugView.composite.numColumnsInRuntimeValuesSets	int	4			Number of columns in the runtime values sets. This is used to determine how many values are displayed in the composite view.
rtx.debugView.debugViewIdx	int	0			Index of a debug view to show when Debug View is enabled. The index must be a valid value from DEBUG_VIEW_* macro defined indices. Value of 0 disables Debug View.
rtx.debugView.displayType	int	0		3	The display type to use for visualizing debug view input values. Supported display types are: 0 = Standard, 1 = BGR Exclusive Color, 2 = EV100, 3 = HDR Waveform Each mode may be useful for a different kind of visualization, though Standard is typically the most common mode to use. Standard mode works for a simple direct, scaled or color mapped visualization, BGR exclusive for another type of color mapped visualization, and EV100 or the HDR Waveform for understanding HDR value magnitudes in the input on a log scale.
rtx.debugView.enableGammaCorrection	bool	False			Enables gamma correction of a debug view value.
rtx.debugView.enableInputQuantization	bool	False			Enables uniform-step input quantization on debug view input buffers. This is mostly useful for when debugging artifacts relating to quantization that may not be visible in a buffer due to higher precision formats in use. For example, the final output from tonemapping is a floating point texture in the debug view but will be quantized to 8 bit on some monitors. Using this option the quantization which will be applied to the output can be visualized in advance.
rtx.debugView.evMaxValue	int	4			The maximum EV100 debug view input value to map to the top of the visualization range when EV100 debug display is in use. Values above this value in the input will be clamped to the top of the range.
rtx.debugView.evMinValue	int	-4			The minimum EV100 debug view input value to map to the bottom of the visualization range when EV100 debug display is in use. Values below this value in the input will be clamped to the bottom of the range.
rtx.debugView.gpuPrint.enable	bool	False			Enables writing into a GPU buffer that's read by CPU when CTRL is pressed. The value is printed to console.
rtx.debugView.gpuPrint.pixelIndex	int2	2147483647, 2147483647			Pixel position to GPU print for. Requires useMousePosition to be turned off.
rtx.debugView.gpuPrint.useMousePosition	bool	True			Uses mouse position to select a pixel to GPU print for.
rtx.debugView.inverseQuantizationStepSize	float	255			The inverse of the uniform step size to quantize the debug view input to when Input Quantization is enabled. A value of 255 indicates that the input will be quantized to steps of 1/255, the same as the step size used when quantizing the range 0-1 to an 8 bit representation.
rtx.debugView.maxValue	float	1			The maximum debug view input value to map to 1 in the output when the standard debug display is in use. Values above this value in the input will be clamped to 1 in the output.
rtx.debugView.minValue	float	0			The minimum debug view input value to map to 0 in the output when the standard debug display is in use. Values below this value in the input will be clamped to 0 in the output.
rtx.debugView.overlayOnTopOfRenderOutput	bool	False			Enables the debug view to be overlayed directly on top of the rendered output. Overlays all non zero RGB values from the debug view on top of the rendered output. Use rtx.debugView.overlayOpacity to control the transparency of the overlay.
rtx.debugView.overlayOpacity	float	1			Opacity of the debug view overlay when rtx.debugView.overlayOnTopOfRenderOutput is enabled. 0 == fully transparent, 1 == fully opaque.
rtx.debugView.pseudoColorMode	int	0			Selects a mode for mapping debug value inputs to a scalar to be visualized using a colormap spectrum. Only takes effect when rtx.debugView.displayType is set to "Standard". Supported modes are: 0 = Disabled, 1 = Luminance, 2 = Red, 3 = Green, 4 = Blue, 5 = Alpha. Useful for visualizing a value's range with greater precision than a simple monochromatic color spectrum (due to interpolating across an entire spectrum of color with a roughly uniform progression).
rtx.debugView.replaceCompositeOutput	bool	False			Replaces composite output with debug view output that is generated right after composition pass. Allows for debug view output to get the post composition pipeline applied to it, such as upscaling and postprocessing actions). Note any Debug Views having data set post Composite pass require this setting to be disabled to work. When disabled Debug View output is generated close to the end of RTX pipeline (after postprocessing and upscaling).
rtx.debugView.samplerType	int	2			Sampler type for debug views that sample from a texture (applies only to a subset of debug views). Supported types are: 0 = Nearest, 1 = Normalized Nearest, 2 = Normalized Linear
rtx.debugView.showFirstGBufferHit	bool	False			Show information of the first hit surface.
rtx.defaultToAdvancedUI	bool	False			Whether to default to the Advanced UI when opening the developer menu.
rtx.demodulate.demodulateRoughness	bool	True			Demodulate roughness to improve specular details.
rtx.demodulate.demodulateRoughnessOffset	float	0.1			Strength of roughness demodulation, lower values are stronger.
rtx.demodulate.directLightBoilingThreshold	float	5			Remove direct light sample when its luminance is higher than the average one multiplied by this threshold .
rtx.demodulate.enableDirectLightBoilingFilter	bool	True			Boiling filter removing direct light sample when its luminance is too high.
rtx.denoiseDirectAndIndirectLightingSeparately	bool	True			Denoising quality, high uses separate denoising of direct and indirect lighting for higher quality at the cost of performance.
rtx.denoiser.maxDirectHitTContribution	float	-1
rtx.denoiserIndirectMode	int	14
rtx.denoiserMode	int	14
rtx.di.confidenceGradientPower	float	8
rtx.di.confidenceGradientScale	float	6
rtx.di.confidenceHistoryLength	float	8
rtx.di.confidenceHitDistanceSensitivity	float	300
rtx.di.disocclusionFrames	int	8
rtx.di.disocclusionSamples	int	4			The number of spatial reuse samples in disocclusion areas.
rtx.di.enableBestLightSampling	bool	True			Whether to include a single best light from the previous frame's pixel neighborhood into initial sampling.
rtx.di.enableCrossPortalLight	bool	True
rtx.di.enableDenoiserConfidence	bool	True
rtx.di.enableDenoiserGradient	bool	True			Enable gradient calculation, which is used by confidence calculation and GI sample validation.
rtx.di.enableDiscardEnlargedPixels	bool	True
rtx.di.enableDiscardInvisibleSamples	bool	True			Whether to discard reservoirs that are determined to be invisible in final shading.
rtx.di.enableInitialVisibility	bool	True			Whether to trace a visibility ray for the light sample selected in the initial sampling pass.
rtx.di.enableRayTracedBiasCorrection	bool	True			Whether to use ray traced bias correction in the spatial reuse pass.
rtx.di.enableSampleStealing	bool	True			No visibile IQ gains, but exhibits considerable perf drop (8% in integrate pass).
rtx.di.enableSpatialReuse	bool	True			Whether to apply spatial reuse.
rtx.di.enableTemporalBiasCorrection	bool	True
rtx.di.enableTemporalReuse	bool	True			Whether to apply temporal reuse.
rtx.di.gradientFilterPasses	int	4
rtx.di.gradientHitDistanceSensitivity	float	10
rtx.di.initialSampleCount	int	4			The number of lights randomly selected from the global pool to consider when selecting a light with RTXDI.
rtx.di.maxHistoryLength	int	4			Maximum age of reservoirs for temporal reuse.
rtx.di.minimumConfidence	float	0.1
rtx.di.permutationSamplingNthFrame	int	0			Apply permutation sampling when (frameIdx % this == 0), 0 means off.
rtx.di.spatialSamples	int	2			The number of spatial reuse samples in converged areas.
rtx.di.stealBoundaryPixelSamplesWhenOutsideOfScreen	bool	True			Steal screen boundary samples when a hit point is outside the screen.
rtx.disableAMDSwitchableGraphics	bool	True			A flag indicating if Remix should attempt to disable AMD's switchable graphics Vulkan layer (VK_LAYER_AMD_swichable_graphics). Due to how some older AMD drivers filter devices exposed to Vulkan it is possible for Remix to see no valid GPUs on a machine when using an integerated AMD GPU with a dedicated Nvidia GPU (for instance a laptop). This is because on such machines both Nvidia Optimus and AMD switchable graphics attempt to filter the device list to promote their respective GPUs, but rather than leaving at least one device all end up filtered out. To work around this issue, Remix can attempt to disable the AMD switchable graphics layer which should eliminate this buggy filtering. As such, this option should generally remain enabled. If this causes an undesired GPU to be selected (e.g. if for some reason you want to force Remix to run on an integerated AMD GPU via the switchable graphics layer), then this option should be disabled.
rtx.displacement.displacementFactor	float	1			Scaling factor for all displacement maps
rtx.displacement.displacementInFactor	float	1			Scale factor for inwards displacement
rtx.displacement.displacementOutFactor	float	1			Scale factor for outwards displacement
rtx.displacement.enableDirectLighting	bool	True			Whether direct lighting accounts for displacement mapping
rtx.displacement.enableIndirectHit	bool	False			Whether indirect ray hits account for displacement mapping (Enabling this is expensive. Without it, non-perfect reflections of displaced objects will not show displacement.)
rtx.displacement.enableIndirectLighting	bool	True			Whether indirect lighting accounts for displacement mapping
rtx.displacement.enableNEECache	bool	True			Whether the NEE cache accounts for displacement mapping
rtx.displacement.enablePSR	bool	False			Enable PSR (perfect reflections) for materials with displacement. Rays that have been perfectly reflected off a POM surface will not collide correctly with other parts of that same surface.
rtx.displacement.enableReSTIRGI	bool	True			Whether ReSTIR GI accounts for displacement mapping
rtx.displacement.maxIterations	int	64			The max number of times the POM raymarch will iterate.
rtx.displacement.mode	int	2			What algorithm the displacement uses. RaymarchPOM: advances the ray in linear steps until the ray is below the heightfield. QuadtreePOM: Relies on special mipmaps with maximum values instead of average values. Uses the mipmap as a quadtree.
rtx.dlfg.enable	bool	True			Enables DLSS 3.0 frame generation which generates interpolated frames to increase framerate at the cost of slightly more latency.
rtx.dlfg.enablePresentMetering	bool	True			Use hardware present metering for DLSS 4.0 frame generation instead of CPU pacing.
rtx.dlfg.maxInterpolatedFrames	int	2	1	6	For DLSS 4.5 frame generation, controls the number of interpolated frames for each rendered frame. Ignored for DLSS 3.0.
rtx.dlssEnhancementDirectLightMaxValue	float	10			The maximum strength of direct lighting enhancement.
rtx.dlssEnhancementDirectLightPower	float	0.7			The overall strength of direct lighting enhancement.
rtx.dlssEnhancementIndirectLightMaxValue	float	1.5			The maximum strength of indirect lighting enhancement.
rtx.dlssEnhancementIndirectLightMinRoughness	float	0.3			The reference roughness in indirect lighting enhancement.
rtx.dlssEnhancementIndirectLightPower	float	1			The overall strength of indirect lighting enhancement.
rtx.dlssEnhancementMode	int	1			The enhancement filter type. Valid values: <Normal Difference=1, Laplacian=0>. Normal difference mode provides more normal detail at the cost of some noise. Laplacian mode is less aggressive.
rtx.dlssPreset	int	1			Combined DLSS Preset for quickly controlling Upscaling, Frame Interpolation and Latency Reduction.
rtx.drawCallRange	int2	0, 2147483647
rtx.dumpAllInstancesOnFrame	int	-1			If set, and running in a REMIX_DEVELOPMENT build, this will dump all active instances to the log on the specified frame.
rtx.dust.anisotropy	float	0.5			Anisotropy of the particles for lighting purposes.
rtx.dust.enable	bool	False			Enables dust particle simulation and rendering.
rtx.dust.gravityForce	float	-0.5			Net influence of gravity acting on each particle (meters per second squared).
rtx.dust.maxParticleLife	float	6			Maximum lifetime (in seconds) to give to a particle when spawned.
rtx.dust.maxParticleSize	float	3			Maximum size (in pixels at 1080p reference resolution) to give to a particle when spawned.
rtx.dust.maxSpawnDistance	float	400			Maximum distance in world space from camera to spawn particles.
rtx.dust.maxSpeed	float	3			Maximum speed of a particle in world space.
rtx.dust.minParticleLife	float	3			Minimum lifetime (in seconds) to give to a particle when spawned.
rtx.dust.minParticleSize	float	1			Minimum size (in pixels at 1080p reference resolution) to give to a particle when spawned.
rtx.dust.minSpawnDistance	float	20			Minimum distance in world space from camera to spawn particles.
rtx.dust.numberOfParticles	int	1000000			Maximum number of particles to simulate simultaneously.
rtx.dust.opacity	float	0.5			Opacity of the particles.
rtx.dust.rotationSpeed	float	5			How quickly the particle is rotating (this primarily only affects light interaction).
rtx.dust.timeScale	float	1			Time modifier, can be used to slow/speed up time.
rtx.dust.turbulenceAmplitude	float	5			How much turbulence influences the force of a particle.
rtx.dust.turbulenceFrequency	float	0.05			The rate of change of turbulence forces.
rtx.dust.useTurbulence	bool	True			Enable turbulence simulation.
rtx.effectLightColor	float3	1, 1, 1			Colour of the effect light, if not using plasma ball mode. Effect lights can be attached to materials from the remix runtime menu, using the `Add Light to Texture` texture tag in game setup.
rtx.effectLightIntensity	float	1			The intensity of the effect light. Effect lights can be attached to materials from the remix runtime menu, using the `Add Light to Texture` texture tag in game setup.
rtx.effectLightPlasmaBall	bool	False			Use plasma ball mode, in this mode the effect light color is ignored. Effect lights can be attached to materials from the remix runtime menu, using the `Add Light to Texture` texture tag in game setup.
rtx.effectLightRadius	float	5			The sphere radius of the effect light. Effect lights can be attached to materials from the remix runtime menu, using the `Add Light to Texture` texture tag in game setup.
rtx.emissiveBlendOverrideEmissiveIntensity	float	0.2	0	65504	The emissive intensity to use when the emissive blend override is enabled. Adjust this if particles for example look overly bright globally.
rtx.emissiveIntensity	float	1	0		A general scale factor on all emissive intensity values globally. Generally per-material emissive intensities should be used, but this option may be useful for debugging without needing to author materials.
rtx.enableAlphaBlend	bool	True			Enable rendering alpha blended geometry, used for partial opacity and other blending effects on various surfaces in many games.
rtx.enableAlphaTest	bool	True			Enable rendering alpha tested geometry, used for cutout style opacity in some games.
rtx.enableAlwaysCalculateAABB	bool	False			Calculate an Axis Aligned Bounding Box for every draw call. This may improve instance tracking across frames for skinned and vertex shaded calls.
rtx.enableBillboardOrientationCorrection	bool	True
rtx.enableBreakIntoDebuggerOnPressingB	bool	False			Enables a break into a debugger at the start of InjectRTX() on a press of key 'B'. If debugger is not attached at the time, it will wait until a debugger is attached and break into it then.
rtx.enableCrashHotkey	bool	False			Arms the crash hotkey feature. When enabled, pressing the crash hotkey combination (Ctrl+Shift+Alt+K by default) will trigger a deliberate crash. This option is only available in development builds and is intended for testing crash handling and crash dump generation. The armed state is indicated by a red warning overlay on screen. This setting is not saved to config files but can be set manually in rtx.conf.
rtx.enableCulling	bool	True			Enable front/backface culling for opaque objects. Objects with alpha blend or alpha test are not culled.
rtx.enableCullingInSecondaryRays	bool	False			Enable front/backface culling for opaque objects. Objects with alpha blend or alpha test are not culled. Only applies in secondary rays, defaults to off. Generally helps with light bleeding from objects that aren't watertight.
rtx.enableDLSSEnhancement	bool	True			Enhances lighting details when DLSS is on.
rtx.enableDecalMaterialBlending	bool	True			A flag to enable or disable material blending on decals. This should generally always be enabled when decals are in use as this allows decals to be blended down on to the surface they sit slightly above which results in more convincing decals rendering.
rtx.enableDirectAlphaBlendShadows	bool	True			Calculate shadows for semi-transparent materials (alpha blended) in direct lighting. In engineering terms: include OBJECT_MASK_ALPHA_BLEND into primary visibility rays.
rtx.enableDirectLighting	bool	True			Enables direct lighting (lighting directly from lights on to a surface) on surfaces when set to true, otherwise disables it.
rtx.enableDirectTranslucentShadows	bool	False			Calculate coloured shadows for translucent materials (i.e. glass, water) in direct lighting. In engineering terms: include OBJECT_MASK_TRANSLUCENT into primary visibility rays.
rtx.enableEmissiveBlendEmissiveOverride	bool	True			Override typical material emissive information on draw calls with any emissive blending modes to emulate their original look more accurately.
rtx.enableEmissiveBlendModeTranslation	bool	True			Treat incoming semi/additive D3D blend modes as emissive.
rtx.enableFallbackLightShaping	bool	False			Enables light shaping on the fallback light (only used for non-Distant light types).
rtx.enableFallbackLightViewPrimaryAxis	bool	False			Enables usage of the camera's view axis as the primary axis for the fallback light's shaping (only used for non - Distant light types). Typically the shaping primary axis may be specified directly, but if desired it may be set to the camera's view axis for a "flashlight" effect.
rtx.enableFirstBounceLobeProbabilityDithering	bool	True			A flag to enable or disable screen-space probability dithering on the first indirect lobe sampled. Generally sampling a diffuse, specular or other lobe relies on a random number generated against the probability of sampling each lobe, effectively focusing more rays/paths on lobes which matter more. This can cause issues however with denoisers which do not handle sparse stochastic signals (like those from path tracing) well as they may be expecting a more "complete" signal like those used in simpler branching ray tracing setups. To help solve this issue this option uses a temporal screenspace dithering based on the probability rather than a purely random choice to determine which lobe to sample from on the first indirect bounce. This as a result helps ensure there will always be a diffuse or specular sample within the dithering pattern's area and should help the denoising resolve a more stable result.
rtx.enableFog	bool	True
rtx.enableIndexBufferMemoization	bool	True			CPU performance optimization, should generally be enabled. Will reduce main thread time by caching processIndexBuffer operations and reusing when possible, this will come at the expense of some CPU RAM.
rtx.enableIndirectAlphaBlendShadows	bool	True			Calculate shadows for semi-transparent (alpha blended) objects in indirect lighting (i.e. reflections and GI). In engineering terms: include OBJECT_MASK_ALPHA_BLEND into secondary visibility rays.
rtx.enableIndirectTranslucentShadows	bool	False			Calculate coloured shadows for translucent materials (i.e. glass, water) in indirect lighting (i.e. reflections and GI). In engineering terms: include OBJECT_MASK_TRANSLUCENT into secondary visibility rays.
rtx.enableInstanceDebuggingTools	bool	False			NOTE: This will disable temporal correllation for instances, but allow the use of instance developer debug tools
rtx.enableLegacyRectLightConeShaping	bool	False			If true, restores the legacy cos(angle) * aspectRatio formula for RectLight cone shaping. Enable this only to preserve the look of existing scenes that were authored against the legacy behavior. Note this can silently kill the light at high aspect ratios.
rtx.enableMultiStageTextureFactorBlending	bool	True			Support texture factor blending in stage 1~7. Currently only support 1 additional blending stage, more than 1 additional blending stages will be ignored.
rtx.enableNearPlaneOverride	bool	False			A flag to enable or disable the Camera's near plane override feature. Since the camera is not used directly for ray tracing the near plane the application uses typically does not matter, but for certain matrix-based operations (such as temporal reprojection or voxel grid projection) it is still relevant. The issue arises when geometry is ray traced that is behind where the chosen Camera's near plane is located, typically common on viewmodels especially with how they are ray traced, causing graphical artifacts and other issues. This option helps correct this issue by overriding the near plane value to else (usually smaller) to sit behind the objects in question (such as the view model). As such this option should usually be enabled on games with viewmodels. Do note that when adjusting the near plane the larger the relative magnitude gap between the near and far plane the worse the precision of matrix operations will be, so the near plane should be set as high as possible even when overriding.
rtx.enablePSRR	bool	True			A flag to enable or disable reflection PSR (Primary Surface Replacement). When enabled this feature allows higher quality mirror-like reflections in special cases by replacing the G-Buffer's surface with the reflected surface. Should usually be enabled for the sake of quality as almost all applications will utilize it in the form of glass or mirrors.
rtx.enablePSTR	bool	True			A flag to enable or disable transmission PSR (Primary Surface Replacement). When enabled this feature allows higher quality glass-like refraction in special cases by replacing the G-Buffer's surface with the refracted surface. Should usually be enabled for the sake of quality as almost all applications will utilize it in the form of glass.
rtx.enablePSTROutgoingSplitApproximation	bool	True			Enable transmission PSR on outgoing transmission events such as leaving translucent materials (rather than respecting no-split path PSR rule). Typically this results in better looking glass when enabled (at the cost of accuracy due to ignoring non-TIR inter-reflections within the glass itself).
rtx.enablePSTRSecondaryIncidentSplitApproximation	bool	True			Enable transmission PSR on secondary incident transmission events such as entering a translucent material on an already-transmitted path (rather than respecting no-split path PSR rule). Typically this results in better looking glass when enabled (at the cost accuracy due to ignoring reflections off of glass seen through glass for example).
rtx.enablePortalFadeInEffect	bool	False
rtx.enablePresentThrottle	bool	False			A flag to enable or disable present throttling, when set to true a sleep for a time specified by the throttle delay will be inserted into the DXVK presentation thread. Useful to manually reduce the framerate if the application is running too fast or to reduce GPU power usage during development to keep temperatures down. Should not be enabled in anything other than development situations.
rtx.enablePreservePath	bool	True			When true, Remix attempts to identify draw calls whose state has not changed since last frame and re-use the previous frame's translation, rather than retranslating the draw call into raytrace-ready scene data. When false, every submit uses full dynamic geometry and instance processing (drawReplacements / processDrawCallState). Disable for debugging or compatibility when suspecting preserve-path regressions.
rtx.enableProbabilisticUnorderedResolveInIndirectRays	bool	True			A flag to enable or disable probabilistic unordered resolve approximations in indirect rays. This flag speeds up the unordered resolve for indirect rays by probabilistically deciding when to perform unordered resolve or not. Must have both unordered resolve and unordered resolve in indirect rays enabled for this to take effect. This option should be enabled by default as it can significantly improve performance on some hardware. In rare cases it may come at the cost of some quality for particles and decals in reflections. Note that even with this option enabled, unordered resolve approximations are only done on the first indirect bounce for the sake of performance overall.
rtx.enableRayReconstruction	bool	True			Enables DLSS ray reconstruction, an AI-based denoiser designed for real time ray tracing.
rtx.enableRaytracing	bool	True			Globally enables or disables ray tracing. When set to false the original game should render mostly as it would in DXVK typically. Some artifacts may still appear however compared to the original game either due to issues with the underlying DXVK translation or issues in Remix itself.
rtx.enableRectLightConeShapingRatioScaling	bool	False			If true, scales the RectLight cone half-angle by the light's aspect ratio in tangent space, producing a cone that matches the rect's proportions. When false (default), the cone is uniform and independent of the light's width/height. Ignored when enableLegacyRectLightConeShaping is true.
rtx.enableReplacementAssets	bool	True			Globally enables or disables all enhanced asset replacement (materials, meshes, lights) functionality.
rtx.enableReplacementInstancerMeshRendering	bool	True			Enables or disables rendering GeomPointInstancer meshes using an optimized path. Requires reloading replacement assets.
rtx.enableReplacementLights	bool	True			Enables or disables enhanced light replacements. Requires replacement assets in general to be enabled to have any effect.
rtx.enableReplacementMaterials	bool	True			Enables or disables enhanced material replacements. Requires replacement assets in general to be enabled to have any effect.
rtx.enableReplacementMeshes	bool	True			Enables or disables enhanced mesh replacements. Requires replacement assets in general to be enabled to have any effect.
rtx.enableRussianRoulette	bool	True			A flag to enable or disable Russian Roulette, a rendering technique to give paths a chance of terminating randomly with each bounce based on their importance. This is usually useful to have enabled as it will ensure useless paths are terminated earlier while more important paths are allowed to accumulate more bounces. Furthermore this allows for the renderer to remain unbiased whereas a hard clamp on the number of bounces will introduce bias (though this is also done in Remix for the sake of performance). On the other hand, randomly terminating paths too aggressively may leave threads in GPU warps without work which may hurt thread occupancy when not used with a thread-reordering technique like SER. Additionally, Russian Roulette will always for the most part increase variance and will reduce the average path depth from whatever the current maximum path length is set to. This increase in variance will slightly impact image quality especially on scenes relying heavily on many bounces of indirect lighting, but this is usually worth it for efficiency purposes, as Russian Roulette allows each ray to reduces variance more than it would otherwise.
rtx.enableSecondaryBounces	bool	True			Enables indirect lighting (lighting from diffuse/specular bounces to one or more other surfaces) on surfaces when set to true, otherwise disables it.
rtx.enableSeparateUnorderedApproximations	bool	True			Use a separate loop during resolving for surfaces which can have lighting evaluated in an approximate unordered way on each path segment (such as particles). This improves performance typically in how particles or decals are rendered and should usually always be enabled. Do note however the unordered nature of this resolving method may result in visual artifacts with large numbers of stacked particles due to difficulty in determining the intended order. Additionally, unordered approximations will only be done on the first indirect ray bounce (as particles matter less in higher bounces), and only if enabled by its corresponding setting.
rtx.enableShaderExecutionReorderingInPathtracerGbuffer	bool	False			(Note: Hard disabled in shader code) Enables Shader Execution Reordering (SER) in GBuffer Raytrace pass if SER is supported.
rtx.enableShaderExecutionReorderingInPathtracerIntegrateIndirect	bool	True			Enables Shader Execution Reordering (SER) in Integrate Indirect pass if SER is supported.
rtx.enableStochasticAlphaBlend	bool	True			Use stochastic alpha blend.
rtx.enableTransmissionApproximationInIndirectRays	bool	False			A flag to enable transmission approximations in indirect rays. Translucent objects hit by indirect rays will not alter ray direction, just change the ray throughput.
rtx.enableUnorderedEmissiveParticlesInIndirectRays	bool	False			A flag to enable or disable unordered resolve emissive particles specifically in indirect rays. Should be enabled in higher quality rendering modes as emissive particles are fairly important in reflections, but may be disabled to skip such interactions which can improve performance on lower end hardware. Note that rtx.enableUnorderedResolveInIndirectRays must first be enabled for this option to take any effect (as it will control if unordered resolve is used to begin with in indirect rays).
rtx.enableUnorderedResolveInIndirectRays	bool	True			A flag to enable or disable unordered resolve approximations in indirect rays. This allows for the presence of unordered approximations in resolving to be overridden in indirect rays and as such requires separate unordered approximations to be enabled to have any effect. This option should be enabled if objects which can be resolvered in an unordered way in indirect rays are expected for higher quality in reflections, but may come at a performance cost. Note that even with this option enabled, unordered resolve approximations are only done on the first indirect bounce for the sake of performance overall.
rtx.enableValidationLayerExtendedValidation	bool	False			A flag to enable extended validation to validation layers in Vulkan. Only takes effect if validation layers are enabled already. This flag enables GPU assisted and synchronization validation along with best practices within the Vulkan validation layers which allow for greater error-checking capability at the cost of significant performance impact. Much like the rtx.enableValidationLayers option, this option should only be enabled by developers during development and not be put into production builds of any project. Additionally, this setting must be set at startup and changing it will not take effect at runtime.
rtx.enableValidationLayers	bool	False			A flag to enable validation layers in Vulkan. Note that in Debug builds validation layers will always be enabled and this flag will have no effect. Enabling validation layers is useful for debugging and development to catch common issues in Vulkan, but will reduce overall performance. Should only be enabled by developers during development and not put into production builds of any project. Additionally, this setting must be set at startup and changing it will not take effect at runtime.
rtx.enableVsync	int	2			Controls the game's V-Sync setting. Native game's V-Sync settings are ignored.
rtx.eye.assumeViewTexgenModeAsEye	bool	True			Used to detect eyes and its vectors, by assuming that a draw call with D3DTSS_TCI_CAMERASPACEPOSITION and specific texture transform is an eye draw call.
rtx.eye.corneaSphereOffset	float	0.1			How much to offset a sphere origin when calculating the eye normals on Cornea. Positive values make the eye cornea appear more spherical. Negative values - more flat.
rtx.eye.enable	bool	False			Enable shader code for eye drawing (eyeball normals, iris blending).
rtx.eye.eyeWhitesAlbedoScale	float	0.5			Brightness multiplier for the eye whites.
rtx.eye.eyeballSphereOffset	float	0.18			How much to offset a sphere origin when calculating the eye normals on Whites. The larger the value, the more pronounced the ambient shadowing is on an eyeball, to better ground the eyes on a face.
rtx.eye.irisDepth	float	0.06			How deep should the iris (colored part of an eye) be placed behind the cornea (eye lens). The larger the value the more distortion there is, because of the lens.
rtx.eye.irisRadius	float	0.165			Size of an iris in the iris texture. If the iris texture is sampled outside of this radius, it's assumed that that area is a transition to the eye whites, so iris depth gradually goes to 0.
rtx.eye.showOptions	bool	False			Show eye options in the developer menu.
rtx.fallbackLightAngle	float	5	0		The angular size in degrees to use for the fallback light (used only for Distant light types). Should only be within the range [0, 180].
rtx.fallbackLightConeAngle	float	25	0		The cone angle in degrees to use for the fallback light shaping (used only for non-Distant light types with shaping enabled). Should only be within the range [0, 180].
rtx.fallbackLightConeSoftness	float	0.1	0		The cone softness to use for the fallback light shaping (used only for non-Distant light types with shaping enabled).
rtx.fallbackLightDirection	float3	-0.2, -1, 0.4			The direction to use for the fallback light (used only for Distant light types)
rtx.fallbackLightFocusExponent	float	2	0		The focus exponent to use for the fallback light shaping (used only for non-Distant light types with shaping enabled).
rtx.fallbackLightMode	int	1			The mode to determine when to create a fallback light. Never (0) never creates the light, NoLightsPresent (1) creates the fallback light only when no lights are provided to Remix, and Always (2) always creates the fallback light. Primarily a debugging feature, users should create their own lights via the Remix workflow rather than relying on this feature to provide lighting. As such, this option should be set to Never for "production" builds of Remix creations to avoid the fallback light from appearing in games unintentionally in cases where no lights exist (which is the default behavior when set to NoLightsPresent).
rtx.fallbackLightPositionOffset	float3	0, 0, 0			The position offset from the camera origin to use for the fallback light (used only for non-Distant light types).
rtx.fallbackLightPrimaryAxis	float3	0, 0, -1			The primary axis to use for the fallback light shaping (used only for non-Distant light types).
rtx.fallbackLightRadiance	float3	1.6, 1.8, 2	0, 0, 0		The radiance to use for the fallback light (used across all light types).
rtx.fallbackLightRadius	float	5	0		The radius to use for the fallback light (used only for Sphere light types).
rtx.fallbackLightType	int	0			The light type to use for the fallback light. Determines which other fallback light options are used.
rtx.fireflyFilteringLuminanceThreshold	float	1000	0		Maximum luminance threshold for the firefly filtering to clamp to.
rtx.fogColorScale	float	0.25
rtx.fogIgnoreSky	bool	False			If true, sky draw calls will be skipped when searching for the D3D9 fog values.
rtx.forceCameraJitter	bool	False			Force enables camera jitter frame to frame.
rtx.forceCutoutAlpha	float	0.5			When an object is added to the cutout textures list it will have a cutout alpha mode forced on it, using this value for the alpha test. This is meant to improve the look of some legacy mode materials using low-resolution textures and alpha blending instead of alpha cutout as this can cause blurry halos around edges due to the difficulty of handling this sort of blending in Remix. Such objects are generally better handled with actual replacement assets using fully opaque geometry replacements or alpha cutout with higher resolution textures, so this should only be relied on until proper replacements can be authored.
rtx.forceMergeAllMeshes	bool	False			Force merges all meshes into as few BLAS as possible. This is generally not desirable for performance, but can be a useful debugging tool.
rtx.freeCameraInvertY	bool	False			Invert free camera pitch direction.
rtx.freeCameraSpeed	float	200			Free camera speed [GameUnits/s].
rtx.freeCameraTurningSpeed	float	1			Free camera turning speed (applies to keyboard, not mouse) [radians/s].
rtx.fusedWorldViewMode	int	0			Set if game uses a fused World-View transform matrix.
rtx.graph.enable	bool	True			Enable graph loading. If disabled, all graphs will be unloaded, losing any state.
rtx.graph.pauseGraphUpdates	bool	False			Pause graph updating. If enabled, graphs logic will not be updated, but graph state will be retained.
rtx.graphicsPreset	int	5			Overall rendering preset, higher presets result in higher image quality, lower presets result in better performance.
rtx.gui.backgroundAlpha	float	1	0	1	A value controlling the alpha of the GUI background.
rtx.gui.compactGui	bool	False			A setting to toggle between compact and spacious GUI modes.
rtx.gui.enableExternalPresenter	bool	False			Enables GUI rendering for external presenters.
rtx.gui.hudMessageAnimatedDotDurationMilliseconds	int	1000			A duration in milliseconds between each dot in the animated dot sequence for HUD messages. Must be greater than 0. These dots help indicate progress is happening to the user with a bit of animation which can be configured to animate at whatever speed is desired.
rtx.gui.largeUiMode	bool	False			Toggles between Large and Regular GUI Scale Modes.
rtx.gui.legacyTextureGuiShowAssignedOnly	bool	False			A setting to show only the textures in a category that are assigned to it (Unassigned textures are found in the new "Uncategorized" list at the top). Requires: 'Split Texture Category List' option to be enabled.
rtx.gui.reflexStatRangeInterpolationRate	float	0.05	0	1	A value controlling the interpolation rate applied to the Reflex stat graph ranges for smoother visualization.
rtx.gui.reflexStatRangePaddingRatio	float	0.05	0		A value specifying the amount of padding applied to the Reflex stat graph ranges as a ratio to the calculated range.
rtx.gui.showLegacyTextureGui	bool	False			A setting to toggle the old texture selection GUI, where each texture category is represented as its own list.
rtx.gui.subRect	float4	0, 0, 0, 0			Used for toolkit.
rtx.gui.textureGridThumbnailScale	float	1			A float to set the scale of thumbnails while selecting textures. This will be scaled by the default value of 120 pixels. This value must always be greater than zero.
rtx.gui.themeGui	int	0			A setting controlling the active GUI theme.
rtx.hairCardMipBias	float	-32			The mip level bias applied to textures on materials tagged as hair cards. Large negative values preserve thin strand detail at a distance.
rtx.hairCardRoughnessScale	float	1			An additional roughness multiplier applied only to materials tagged as hair cards.
rtx.hashCollisionDetection.enable	bool	False			Enables hash collision detection.
rtx.hideSplashMessage	bool	False			A flag to disable the splash message indicating how to use Remix from appearing when the application starts. When set to true this message will be hidden, otherwise it will be displayed on every launch.
rtx.ignoreAllVertexColorBakedLighting	bool	False			If true, all baked lighting bound to all vertex colors will be ignored.
rtx.ignoreGameDirectionalLights	bool	False			Ignores any directional lights coming from the original game (lights added via toolkit still work).
rtx.ignoreGamePointLights	bool	False			Ignores any point lights coming from the original game (lights added via toolkit still work).
rtx.ignoreGameSpotLights	bool	False			Ignores any spot lights coming from the original game (lights added via toolkit still work).
rtx.ignoreLastTextureStage	bool	False			Removes the last texture bound to a draw call, when using fixed-function pipeline. Primary textures are untouched. Might be set to true, if a game applies a lightmap as last shading step, to omit the original lightmap data.
rtx.indirectRaySpreadAngleFactor	float	0.05			A tuning factor applied to the spread angle calculated from the sampled lobe solid angle PDF. Should be 0-1. This scaled spread angle is used to widen a ray's cone angle after indirect lighting BRDF samples to essentially prefilter the effects of the BRDF lobe's spread which potentially may reduce noise from indirect rays (e.g. reflections). Prefiltering will overblur detail however compared to the ground truth of casting multiple samples especially given this calculated spread angle is a basic approximation and ray cones to begin with are a simple approximation for ray pixel footprint. As such rather than using the spread angle fully this spread angle factor allows it to be scaled down to something more narrow so that overblurring can be minimized. Similarly, setting this factor to 0 disables this cone angle widening feature.
rtx.initializer.asyncAssetLoading	bool	True			If true, a separate thread is created to load USD assets asynchronously.
rtx.initializer.asyncShaderFinalizing	bool	True			When set to true, shader prewarming will be finalized asynchronously rather than Remix's initializer blocking synchronously until it is finished. Do note that this only controls if Remix waits for prewarming to finish or not on startup, if shaders are not finished prewarming by the time they are first used by Remix (e.g. once ray tracing starts) they will still block synchronously until finished even with this option set. See rtx.shader.enableAsyncCompilation for true async shader compilation. This option should usually be set to true and is usually combined with async shader compilation to faciliate a better user experience, but can be to set to false to ensure all shaders are loaded to allow for slightly more deterministic behavior when debugging, or if prewarming all shaders before rendering is desired behavior (at the cost of blocking on startup for a while). Finally, this option only takes effect for the most part when shader prewarming is enabled (rtx.initializer.asyncShaderPrewarming) as otherwise there will be no prewarmed shaders to worry about finalizing.
rtx.initializer.asyncShaderPrewarming	bool	True			When set to true, shader prewarming will be enabled, allowing for Remix to start compiling shaders before their first use. Typically shaders will only begin compilation on their first use, but this is generally undesirable from a user experience perspective as this often causes stalls or wait times while using the application until all shaders have been used at least once. By prewarming permutations of potentially required shaders in advance this can be avoided by ensuring all required shaders are compiled before they are used. Additionally, this prewarming work can often be overlapped with an application's existing startup sequence (e.g. the initial loading screen of a game), allowing Remix's shaders to be ready before they are actually used and avoiding any stalls or wait times. As such this should generally be set to true and is often used in conjunction with rtx.initializer.asyncShaderFinalizing to avoid Remix blocking on initialization for the prewarming to complete, and rtx.shader.enableAsyncCompilation to avoid shaders from blocking if the application starts using Remix shaders before prewarming is complete. Since prewarming uses shader permutation however a greater amount of shaders will need to be compiled when this option is enabled compared to the minimal required set (mainly to accomodate various runtime situations and user-facing options that may be altered). Setting this option to false may be useful in specific cases where minimizing this compilation cost is important over user experience (e.g. for automated testing).
rtx.instanceOverrideInstanceIdx	int	-1
rtx.instanceOverrideInstanceIdxRange	int	15
rtx.instanceOverrideSelectedInstancePrintMaterialHash	bool	False
rtx.instanceOverrideWorldOffset	float3	0, 0, 0
rtx.integrateIndirectMode	int	2			Indirect integration mode: 0: Importance Sampled. Importance sampled mode uses typical GI sampling and it is not recommended for general use as it provides the noisiest output. It serves as a reference integration mode for validation of other indirect integration modes. 1: ReSTIR GI. ReSTIR GI provides improved indirect path sampling over "Importance Sampled" mode with better indirect diffuse and specular GI quality at increased performance cost. 2: RTX Neural Radiance Cache (NRC). NRC is an AI based world space radiance cache. It is live trained by the path tracer and allows paths to terminate early by looking up the cached value and saving performance. NRC supports infinite bounces and often provides results closer to that of reference than ReSTIR GI while improving performance in scenarios where ray paths have 2 or more bounces on average.
rtx.io.enabled	bool	False			When this option is enabled the assets will be loaded (and optionally decompressed on GPU) using high performance RTX IO runtime. RTX IO must be enabled for loading compressed assets, but is not necessary for working with loose uncompressed assets.
rtx.io.forceCpuDecoding	bool	False			Force CPU decoding in RTX IO.
rtx.io.memoryBudgetMB	int	256
rtx.io.useAsyncQueue	bool	True
rtx.isReflexEnabled	bool	True			Enables or disables Reflex globally. Note that this option when set to false will prevent Reflex from even attempting to initialize, unlike setting the Reflex mode to "None" which simply tells an initialized Reflex not to take effect. Additionally, this setting must be set at startup and changing it will not take effect at runtime.
rtx.isShaderExecutionReorderingSupported	bool	True			Enables Shader Execution Reordering (SER) if it is supported by the target HW and SW.
rtx.keepTexturesForTagging	bool	False			A flag to keep all textures in video memory, which can drastically increase VRAM consumption. Intended to assist with tagging textures that are only used for a short period of time (such as loading screens). Use only when necessary!
rtx.leftHandedCoordinateSystem	bool	False			Indicates that the world space coordinate system is left-handed when true, otherwise right-handed when false.
rtx.legacyMaterial.albedoConstant	float3	1, 1, 1			The default albedo constant to use for non-replaced "legacy" materials. Should be a color in sRGB colorspace with gamma encoding.
rtx.legacyMaterial.alphaIsThinFilmThickness	bool	False			A flag to determine if the alpha channel from the albedo source should be treated as thin film thickness on non-replaced "legacy" materials.
rtx.legacyMaterial.anisotropy	float	0			The default roughness anisotropy to use for non-replaced "legacy" materials. Should be in the range -1 to 1, where 0 is isotropic.
rtx.legacyMaterial.emissiveColorConstant	float3	0, 0, 0			The default emissive color constant to use for non-replaced "legacy" materials. Should be a color in sRGB colorspace with gamma encoding.
rtx.legacyMaterial.emissiveIntensity	float	0			The default emissive intensity to use for non-replaced "legacy" materials.
rtx.legacyMaterial.enableEmissive	bool	False			A flag to determine if emission should be used on non-replaced "legacy" materials.
rtx.legacyMaterial.enableThinFilm	bool	False			A flag to determine if a thin-film layer should be used on non-replaced "legacy" materials.
rtx.legacyMaterial.ignoreAlphaChannel	bool	False			A flag to determine if the albedo alpha channel should be ignored on non-replaced "legacy" materials.
rtx.legacyMaterial.metallicConstant	float	0.1			The default metallic constant to use for non-replaced "legacy" materials. Should be in the range 0 to 1.
rtx.legacyMaterial.opacityConstant	float	1			The default opacity constant to use for non-replaced "legacy" materials. Should be in the range 0 to 1.
rtx.legacyMaterial.roughnessConstant	float	0.7			The default perceptual roughness constant to use for non-replaced "legacy" materials. Should be in the range 0 to 1.
rtx.legacyMaterial.thinFilmThicknessConstant	float	200			The thickness (in nanometers) of the thin-film layer assuming it is enabled on non-replaced "legacy" materials. Should be any value larger than 0, typically within the wavelength of light, but must be less than or equal to OPAQUE_SURFACE_MATERIAL_THIN_FILM_MAX_THICKNESS ((1500.0f) nm).
rtx.legacyMaterial.useAlbedoTextureIfPresent	bool	True			A flag to determine if an "albedo" texture (a qualifying color texture) from the original application should be used if present on non-replaced "legacy" materials.
rtx.lightConversionDistantLightFixedAngle	float	0.0349	0	3.14159	The angular size in radians of the distant light source for legacy lights converted to distant lights. Set to ~2 degrees in radians by default. Should only be within the range [0, pi].
rtx.lightConversionDistantLightFixedIntensity	float	1	0		The fixed intensity (in W/sr) to use for legacy lights converted to distant lights (currently directional lights will convert to distant lights).
rtx.lightConversionIntensityFactor	float	1			Scales the converted light intensities.
rtx.lightConversionMaxIntensity	float	3.40282e+38			The highest intensity value a converted light can have.
rtx.lightConversionSphereLightFixedRadius	float	4	0		The fixed radius in world units to use for legacy lights converted to sphere lights (currently point and spot lights will convert to sphere lights). Use caution with large light radii as many legacy lights will be placed close to geometry and intersect it, causing suboptimal light sampling performance or other visual artifacts (lights clipping through walls, etc).
rtx.lights.debugDrawLightHashes	bool	False			Draw light hashes of all visible ob screen lights, when enableDebugMode=true.
rtx.lights.enableDebugMode	bool	False			Enables light debug visualization.
rtx.limitedBonesPerVertex	int	4			Limit the number of bone influences per vertex for replacement geometry. D3D9 games were limited to 4, which is the default. In rare instances you may want to increase this based on your preference for replaced assets. This config only takes affect when set on startup via the rtx.conf.
rtx.localtonemap.boostLocalContrast	bool	False			Boosts contrast on local features.
rtx.localtonemap.displayMip	int	0			Bottom mip level of tone map pyramid.
rtx.localtonemap.exposure	float	0.75			Exposure factor applied on average exposure.
rtx.localtonemap.exposurePreferenceOffset	float	0			Offset to reference luminance when calculating the weights a pixel belongs to shadow/normal/highlight areas.
rtx.localtonemap.exposurePreferenceSigma	float	4			Transition sharpness between different areas of exposure. Smaller values result in sharper transitions.
rtx.localtonemap.finalizeWithACES	bool	True			Applies ACES tone mapping on final result.
rtx.localtonemap.highlights	float	4			Highlight area strength. Higher values cause darker highlight.
rtx.localtonemap.mip	int	3			Top mip level of tone map pyramid.
rtx.localtonemap.shadows	float	2			Shadow area strength. Higher values cause brighter shadows.
rtx.localtonemap.useGaussian	bool	True			Uses gaussian kernel to generate tone map pyramid.
rtx.logCallstacksOnValidationLayerErrors	bool	True			A flag to enable logging of callstacks when validation layer errors occur. This is useful for debugging and development to help track down the source of validation layer errors more easily. Requires pdb symbols to be present next to Remix's d3d9 dll and/or in the working directory to resolve symbols.
rtx.logLegacyHashReplacementMatches	bool	False
rtx.lowMemoryGpu	bool	False			Enables low memory mode, where we aggressively detune caches and streaming systems to accomodate the lower memory available.
rtx.maxAnisotropySamples	float	8			The maximum number of samples to use when anisotropic filtering is enabled. The actual max anisotropy used will be the minimum between this value and the hardware's maximum. Higher values increase quality but will likely reduce performance.
rtx.maxFogDistance	float	65504
rtx.maxPrimsInMergedBLAS	int	50000			The maximum number of triangles for a mesh that can be in the merged BLAS.
rtx.minOpaqueDiffuseLobeSamplingProbability	float	0.25			The minimum allowed non-zero value for opaque diffuse probability weights.
rtx.minOpaqueDiffuseTransmissionLobeSamplingProbability	float	0.25			The minimum allowed non-zero value for thin opaque diffuse transmission probability weights.
rtx.minOpaqueOpacityTransmissionLobeSamplingProbability	float	0.25			The minimum allowed non-zero value for opaque opacity probability weights.
rtx.minOpaqueSpecularLobeSamplingProbability	float	0.25			The minimum allowed non-zero value for opaque specular probability weights.
rtx.minPrimsInDynamicBLAS	int	1000			The minimum number of triangles required to promote a mesh to it's own BLAS, otherwise it lands in the merged BLAS with multiple other meshes.
rtx.minTranslucentSpecularLobeSamplingProbability	float	0.3			The minimum allowed non-zero value for translucent specular probability weights.
rtx.minTranslucentTransmissionLobeSamplingProbability	float	0.25			The minimum allowed non-zero value for translucent transmission probability weights.
rtx.minimizeBlasMerging	bool	False			Minimize BLAS merging to the minimum possible, this option tries to give all meshes their own BLAS. This is generally not desirable forperformance, but can be a useful debugging tool.
rtx.nativeMipBias	float	0			Specifies a mipmapping level bias to add to all material texture filtering. Stacks with the upscaling mip bias. Mipmaps are determined based on how far away a texture is, using this can bias the desired level in a lower quality direction (positive bias), or a higher quality direction with potentially more aliasing (negative bias). Note that mipmaps are also important for good spatial caching of textures, so too far negative of a mip bias may start to significantly affect performance, therefore changing this value is not recommended
rtx.nearPlaneOverride	float	0.1			The near plane value to use for the Camera when the near plane override is enabled. Only takes effect when rtx.enableNearPlaneOverride is enabled, see that option for more information about why this is useful.
rtx.neeCache.ageCullingSpeed	float	0.02			This threshold determines culling speed of an old triangle. A triangle that is not detected for several frames will be deemed less important and culled quicker.
rtx.neeCache.approximateParticleLighting	bool	True			Use particle albedo as emissive color.
rtx.neeCache.cullingThreshold	float	0.01			Culling threshold.
rtx.neeCache.emissiveTextureSampleFootprintScale	float	1			Emissive texture sample footprint scale.
rtx.neeCache.enable	bool	True			Enable NEE cache. The integrator will perform NEE on emissive triangles, which usually have significant light contributions, stored in the cache.
rtx.neeCache.enableAnalyticalLight	bool	True			Enable NEE Cache on analytical light.
rtx.neeCache.enableImportanceSampling	bool	True			Enable importance sampling.
rtx.neeCache.enableMIS	bool	True			Enable MIS.
rtx.neeCache.enableModeAfterFirstBounce	int	1			NEE Cache enable mode on a second and higher bounces. 0 means off, 1 means enabled for specular rays only, 2 means always enabled.
rtx.neeCache.enableOnFirstBounce	bool	True			Enable NEE Cache on a first bounce.
rtx.neeCache.enableReshuffleResilience	bool	True			Preserve cached light samples through BLAS primitive reshuffles. Reduces flicker when geometry is re-indexed but may show stale lighting for one extra frame when emissive surfaces are removed.
rtx.neeCache.enableSpatialReuse	bool	True			Enable NEE cell share statistics information with neighbors.
rtx.neeCache.enableTriangleExploration	bool	True			Explore emissive triangle candidates in the same object.
rtx.neeCache.enableUpdate	bool	True			Enable Update.
rtx.neeCache.learningRate	float	0.02			Learning rate. Higher values makes the cache adapt to lighting changes more quickly.
rtx.neeCache.minRange	float	400			The range for lowest level cells.
rtx.neeCache.reshuffleMaxAge	int	8	0	15	Maximum consecutive reshuffled frames before forcing a sample refresh. Prevents permanently stale samples from continuously animating emissive geometry (e.g. particle systems). 0 disables the limit.
rtx.neeCache.resolution	float	8			Cell resolution. Higher values mean smaller cells.
rtx.neeCache.specularFactor	float	1			Specular component factor.
rtx.neeCache.triangleExplorationAcceptRangeRatio	float	0.33			Accept index range to search range ratio, when triangle exploration is enabled.
rtx.neeCache.triangleExplorationMaxRange	int	20			Index range to explore, when triangle exploration is enabled.
rtx.neeCache.triangleExplorationProbability	float	0.05			The probability to explore new triangles.
rtx.neeCache.triangleExplorationRangeRatio	float	0.1			Index range to triangle count ratio, when triangle exploration is enabled.
rtx.neeCache.uniformSamplingProbability	float	0.1			Uniform sampling probability.
rtx.neuralRadianceCache.allowRussianRouletteOnUpdate	bool	False
rtx.neuralRadianceCache.averageTrainingBouncesPerPath	float	2.15			Average number of bounces per path used to calculate max training dimensions. Lower values result in higher max training dimensions and higher memory requirements by NRC. Lower values boost training dimensions to allows for more training records to get generated in scenes with very few / 1-2 bounces (i.e. most of the view being into the sky with small geometric footprint on-screen).
rtx.neuralRadianceCache.boostEmissives	bool	True			Preserves emissive lighting on indirect bounces where NRC would otherwise terminate the path before evaluating it. When Include Direct Lighting is enabled, NRC terminates paths immediately on cache hit, skipping emissive evaluation. The cache cannot accurately represent sharp emissive features, so this option defers termination until after MIS-weighted emissive accumulation. May cause minor double-counting in rare cases.
rtx.neuralRadianceCache.clearBuffersOnFrameStart	bool	False			Clears buffers for NRC before they are written to by the the Pathtracer.
rtx.neuralRadianceCache.debugResolveMode	int	0			Debug Visualization Mode.
rtx.neuralRadianceCache.enableAdaptiveTrainingDimensions	bool	True			Enables adaptive training dimensions that scale based off pathtracer's execution behavior on a given scene.
rtx.neuralRadianceCache.enableCalculateTrainingLoss	bool	False			Enables calculation of a training loss. Imposes a performance penalty.
rtx.neuralRadianceCache.enableCustomNetworkConfig	bool	False			Enables usage of a custom config "CustomNetworkConfig.json" for NRC. The file needs to be present in the application's working directory.
rtx.neuralRadianceCache.enableDebugResolveMode	bool	False
rtx.neuralRadianceCache.enableNrcResolver	bool	False			Enables NRC radiance resolve by NRC's resolver. Disable to use Remix's resolver.
rtx.neuralRadianceCache.includeDirectLighting	bool	True
rtx.neuralRadianceCache.jitterSequenceLength	int	128			Halton sequence length to use for jittering training path to pixel mapping every frame. The sequence length governs how often the jitter distribution repeats. Setting this to 0 disables jittering.Training paths are mapped to a subset of pixels every frame, generally there is 1 training path per 100 pixels. The value to use should be same or slightly higher than the number of pixels per training path so that all pixels get cycled through over a smaller time window.
rtx.neuralRadianceCache.learnIrradiance	bool	True
rtx.neuralRadianceCache.luminanceClampMultiplier	float	0			Luminance based clamp multiplier to use for clamping radiance passed to NRC during training. 0: disables clamping. The clamp value is calculated as "luminanceClampMultiplier" * "maxExpectedAverageRadianceValue".
rtx.neuralRadianceCache.maxExpectedAverageRadianceValue	float	2.5			NRC works better when the radiance values it sees internally are in a 'friendly' range for it. Applications often have quite different scales for their radiance units, so we need to be able to scale these units in order to get that nice NRC - friendly range. Set the value to an average radiance that you see in your bright scene (e.g.outdoors in daylight).
rtx.neuralRadianceCache.maxNumTrainingIterations	int	16			This controls the max number of training iterations to perform in a frame. When the pathtracer generates more training records than the ideal number of training records based on "targetNumTrainingIterations", this parameter allows NRC SDK to use those records to speed up the training at an increased cost instead of throwing the records away. Generally the pathtracer will try to reach the ideal number training records, but in cases when its calibrating the workload during "numFramesToSmoothOutTrainingDimensions" frames it can overshoot it. This can happen when the cache resets on a level load or camera cut. In such cases it is preferrable to speed the training up to make the indirect lighting inference more accurate faster.
rtx.neuralRadianceCache.numFramesToSmoothOutTrainingDimensions	int	16
rtx.neuralRadianceCache.proportionPrimarySegmentsToTrainOn	float	0.02
rtx.neuralRadianceCache.proportionTertiaryPlusSegmentsToTrainOn	float	1
rtx.neuralRadianceCache.proportionUnbiased	float	0.06
rtx.neuralRadianceCache.proportionUnbiasedToSelfTrain	float	1
rtx.neuralRadianceCache.qualityPreset	int	2			Quality Preset: Medium (0), High (1), Ultra (2). Adjusts quality of RTX Neural Radiance Cache (NRC): - How quickly path-tracer terminates paths into NRC cache. It terminates quicker on lower presets. - Granularity of the cache - i.e. the smallest resolvable feature size. The cache is less precise on lower presets. - Responsiveness of the cache. The cache is more responsive to dynamic lighting changes on higher presets. Lower quality presets result in faster path-tracing with fewer bounces that may result in lower quality indirect lighting. Higher quality presets result in more responsive and detailed indirect lighting.
rtx.neuralRadianceCache.resetHistory	bool	False
rtx.neuralRadianceCache.resetSceneBoundsOnCameraCut	bool	True			Resets scene bounds used by NRC Cache when a camera cut occurs. This is strongly recommended to leave enabled as otherwise the scene bounds would have to cover all geometry across all camera cuts (i.e. when loading into a new level), which can be prohibitively expensive requiring very large scene bounding box to cover geometry that can be loaded in from any level.
rtx.neuralRadianceCache.resolveAddNrcQueriedRadiance	bool	True
rtx.neuralRadianceCache.resolveAddPathTracedRadiance	bool	True
rtx.neuralRadianceCache.sceneBoundsWidthMeters	float	200			Minimum width of a 3D axis-aligned bounding box in meters that will cover any in-game scene. The width must be large enough to cover any scene and its geometry to ensure NRC cache coverage. The width must be large enough to contain any geometry that can be loaded during gameplay at any point. Note, "rtx.neuralRadianceCache.resetSceneBoundsOnCameraCut" controls whether the bounding box coverage resets on camera cuts. Note, larger values will result in increased memory and performance costs of NRC cache.
rtx.neuralRadianceCache.selfTrainingAttenuation	float	1
rtx.neuralRadianceCache.skipDeltaVertices	bool	True
rtx.neuralRadianceCache.smallestResolvableFeatureSizeMeters	float	0.01
rtx.neuralRadianceCache.targetNumTrainingIterations	int	4			This controls the target number of training iterations to perform each frame, which in turn determines the ideal number of training records that the training/update path tracing pass is expected to generate. Each training batch contains 16K training records derived from path segments in the the NRC update path tracing pass. For example, 4 training iterations results in 64K training records. Higher number results in more responsive NRC cache at the cost of increased workload.
rtx.neuralRadianceCache.terminationHeuristicThreshold	float	0.1
rtx.neuralRadianceCache.trainCache	bool	True
rtx.neuralRadianceCache.trainingMaxPathBounces	int	15			The maximum number of indirect bounces the path will be allowed to complete during NRC Update path tracing pass. Must be < 16. NRC requires this value to be fairly high (8+) for best lighting signal reconstruction. This value can be lower in games with darker surfaces and higher in games with albedos close to 1 and/or to reconstruct lighting phenomena requiring many bounces. Setting this parameter to a higher has no to minor performance and moderate memory requirements (~10MiB per bounce) impact.
rtx.neuralRadianceCache.trainingMaxPathBouncesBiasInQualityPresets	int	0			This is a value added to the default "trainingMaxPathBounces" set by NRC quality presets. Set to negative value to lower the max number of training bounces and to a higher value to increase it in each quality preset.
rtx.neuralRadianceCache.trainingTerminationHeuristicThreshold	float	0.25
rtx.nisPreset	int	1			Adjusts NIS scaling factor, trades quality for performance.
rtx.numFramesToKeepBLAS	int	1
rtx.numFramesToKeepInstances	int	1
rtx.numFramesToKeepLights	int	100
rtx.numGeometryProcessingThreads	int	2			The desired number of CPU threads to dedicate to geometry processing Will be limited by the number of CPU cores. There may be some advantage to lowering this number in games which are fairly simple and use a low number of draw calls per frame. The default was determined by looking at a game with around 2000 draw calls per frame, and with a reasonably high average triangle count per draw.
rtx.opacityMicromap.buildRequests.customFiltersForBillboards	bool	True			Applies custom filters for staged Billboard requests.
rtx.opacityMicromap.buildRequests.enableAnimatedInstances	bool	False			Enables Opacity Micromaps for animated instances.
rtx.opacityMicromap.buildRequests.enableParticles	bool	True			Enables Opacity Micromaps for particles.
rtx.opacityMicromap.buildRequests.filtering	bool	True			Enables filtering of Opacity Micromap requests. Filtering reduces and slows down acceptance of Opacity Micromap requests to maximize resources to requests that are more likely to be reused across instances and frames.
rtx.opacityMicromap.buildRequests.maxRequestFrameAge	int	300			Max request frame age to allow building Opacity Micromaps for. Any requests older than this are purged.
rtx.opacityMicromap.buildRequests.maxRequests	int	5000			Max number of staged unique Opacity Micromap build requests. Any further requests will simply be discarded until the number of staged requests decreases below this threshold. Once a staged request passes filters for building, it is removed from the staging list.
rtx.opacityMicromap.buildRequests.minInstanceFrameAge	int	1			Min instance's frame age which to allow building Opacity Micromaps for.
rtx.opacityMicromap.buildRequests.minNumFramesRequested	int	5			Min number of frames for a staged Opacity Micromap request before it is allowed to be built.
rtx.opacityMicromap.buildRequests.minNumRequests	int	10			Min number of Opacity Micromap usage requests for a staged Opacity Micromap request before it is allowed to be built.
rtx.opacityMicromap.building.allow2StateOpacityMicromaps	bool	True			Allows generation of two state Opacity Micromaps.
rtx.opacityMicromap.building.conservativeEstimation.enable	bool	True			Enables Conservative Estimation of micro triangle opacities.
rtx.opacityMicromap.building.conservativeEstimation.maxTexelTapsPerMicroTriangle	int	64			Max number of texel taps per micro triangle when Conservative Estimation is enabled. Set to 64 as a safer cap. 512 has been found to cause a timeout. Any micro triangles requiring more texel taps will be tagged as Opaque Unknown.
rtx.opacityMicromap.building.conservativeEstimation.maxTrianglesToCalculateTexelDensityForPerFrame	int	1536			Max number of triangles for which to calculate texel density in a frame. The higher the value, the lower latency in getting OMM data generated, but at the cost of increasing CPU load per frame on the draw call submission thread.
rtx.opacityMicromap.building.conservativeEstimation.minValidOMMTrianglesInMeshPercentage	float	0.75			Min percentage of triangles in a mesh for which valid OMM triangle arrays can be calculated. Valid OMM triangle arrays can be calculated for triangles for which the number of required texture taps is smaller or equal to "maxTexelTapsPerMicroTriangle". If the criteria is not met for a mesh, the OMMs will not be generated for the mesh.
rtx.opacityMicromap.building.costPerTexelTapPerMicroTriangleBudget	float	0.45			Approximate relative cost of doing an additional texel tap when baking micro triangles. This is used for estimating the overhead of baking micro triangles.This cost is a relative cost to doing only a single tap. With C being the cost and N number of taps, the total cost is T = 1 + (N - 1) * C.
rtx.opacityMicromap.building.decalsMinResolveTransparencyThreshold	float	0			Min resolve transparency threshold for decals.
rtx.opacityMicromap.building.enableUnlimitedBakingAndBuildingBudgets	bool	False			Enables unlimited baking and building budgets so that all available Opacity Micromaps are generated in a frame.
rtx.opacityMicromap.building.enableVertexAndTextureOperations	bool	True			Applies vertex and texture operations during baking.
rtx.opacityMicromap.building.force2StateOpacityMicromaps	bool	False			Forces generation of two state Opacity Micromaps.
rtx.opacityMicromap.building.highWorkloadMultiplier	int	20			High workload multiplier that is applied to number of Opacity Micromaps to bake and build per frame. This is used for testing to decrease frame latency for Opacity Micromaps being ready.
rtx.opacityMicromap.building.maxAllowedBillboardsPerInstanceToSplit	int	16			Max billboards per instance to consider for splitting (large value results in increased CPU costs on BLAS builds).
rtx.opacityMicromap.building.maxMicroTrianglesToBakeMillionPerSecond	int	300			Max Micro Triangles to bake [Million/Second]. The actual number of issued micro triangles also depends on "costPerTexelTapPerMicroTriangleBudget" option.
rtx.opacityMicromap.building.maxMicroTrianglesToBuildMillionPerSecond	int	300			Max Micro Triangles to build [Million/Second].
rtx.opacityMicromap.building.numFramesAtStartToBuildWithHighWorkload	int	0			Number of frames at start to to bake and build Opacity Micromaps with high workload multiplier. This is used for testing to decrease frame latency for Opacity Micromaps being ready.
rtx.opacityMicromap.building.splitBillboardGeometry	bool	True			Splits billboard geometry and corresponding Opacity Micromaps to quads for higher reuse. Games often batch instanced geometry that reuses same geometry and textures, such as for particles. Splitting such batches into unique subgeometries then allows higher reuse of build Opacity Micromaps.
rtx.opacityMicromap.building.subdivisionLevel	int	8			Opacity Micromap subdivision level per triangle.
rtx.opacityMicromap.cache.freeVidmemMBBudgetBuffer	int	384			A buffer of free memory on top of "minFreeVidmemMBToNotAllocate" to not budget OMMs for when calculating a new memory budget for OMMs. Note, "minFreeVidmemMBToNotAllocate" + "freeVidmemMBBudgetBuffer" is left untouched when calculating a new memory budget. However, once budget has been assigned to OMMs, the budget will not decrease until the free VidMem drops below "minFreeVidmemMBToNotAllocate". Having this soft budget buffer protects OMM budget against runtime memory usage swings at high memory pressure and keep it stable rather than the budget being continously bumped and decreased in oscilating manner, which is detrimental since OMM build workloads are spread across multiple frames.
rtx.opacityMicromap.cache.hashInstanceIndexOnly	bool	False			Uses instance index as an Opacity Micromap hash.
rtx.opacityMicromap.cache.maxBudgetSizeMB	int	1536			Budget: Max Allowed Size [MB].
rtx.opacityMicromap.cache.maxVidmemSizePercentage	float	0.15			Budget: Max Video Memory Size %.
rtx.opacityMicromap.cache.minBudgetSizeMB	int	128			Budget: Min Video Memory [MB] required. If the min amount is not available, then the budget will be set to 0.
rtx.opacityMicromap.cache.minFreeVidmemMBToNotAllocate	int	512			Min Video Memory [MB] to keep free before allocating any for Opacity Micromaps.
rtx.opacityMicromap.cache.minUsageFrameAgeBeforeEviction	int	900			Min Opacity Micromap usage frame age before eviction. Opacity Micromaps unused longer than this can be evicted when freeing up memory for new Opacity Micromaps.
rtx.opacityMicromap.enable	bool	True			Enables Opacity Micromaps for geometries with textures that have alpha cutouts. This is generally the case for geometries such as fences, foliage, particles, etc. . Opacity Micromaps greatly speed up raytracing of partially opaque triangles. Examples of scenes that benefit a lot: multiple trees with a lot of foliage, a ground densely covered with grass blades or steam consisting of many particles.
rtx.opacityMicromap.enableBakingArrays	bool	True			Enables baking of opacity textures into Opacity Micromap arrays per triangle.
rtx.opacityMicromap.enableBinding	bool	True			Enables binding of built Opacity Micromaps to bottom level acceleration structures.
rtx.opacityMicromap.enableBuilding	bool	True			Enables building of Opacity Micromap arrays.
rtx.opacityMicromap.enableResetEveryFrame	bool	False			Debug: resets Opacity Micromap runtime data every frame.
rtx.opacityMicromap.showAdvancedOptions	bool	False			Shows advanced options.
rtx.opaqueDiffuseLobeSamplingProbabilityZeroThreshold	float	0.01			The threshold for which to zero opaque diffuse probability weight values.
rtx.opaqueDiffuseTransmissionLobeSamplingProbabilityZeroThreshold	float	0.01			The threshold for which to zero thin opaque diffuse transmission probability weight values.
rtx.opaqueMaterial.albedoBias	float	0			A bias factor to add to all albedo values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.albedoScale	float	1			A scale factor to apply to all albedo values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.enableThinFilmOverride	bool	False			A flag to force the thin-film layer on the opaque material to be enabled. Should only be used for debugging or development.
rtx.opaqueMaterial.ignoreAlphaChannelOverride	bool	False			A flag to ignore the alpha channel of the colormap on the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.layeredWaterNormalEnable	bool	True			A flag indicating if layered water normal should be enabled or disabled. Note that objects must be properly classified as animated water to be rendered with this mode.
rtx.opaqueMaterial.layeredWaterNormalLodBias	float	5			The LoD bias to use when sampling from the normal map on layered water for the second layer of detail. This value typically should be greater than 0 to allow for a more blurry mip to be selected as this allows for a low frequency variation of normals to be applied to the higher frequency variation from the typical normal map. Only takes effect when layered water normals are enabled (and an object is properly classified as animated water).
rtx.opaqueMaterial.layeredWaterNormalMotion	float2	-0.25, -0.3			A vector describing the motion in the U and V axes across a texture to apply for layered water. Only takes effect when layered water normals are enabled (and an object is properly classified as animated water).
rtx.opaqueMaterial.layeredWaterNormalMotionScale	float	9			A scale factor applied to the layered water normal motion vector. Only takes effect when layered water normals are enabled (and an object is properly classified as animated water).
rtx.opaqueMaterial.metallicBias	float	0			A bias factor to add to all metallic values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.metallicScale	float	1			A scale factor to apply to all metallic values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.normalIntensity	float	1			An arbitrary strength scale factor to apply when decoding normals in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.roughnessBias	float	0			A bias factor to add to all roughness values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.roughnessScale	float	1			A scale factor to apply to all roughness values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.thinFilmThicknessOverride	float	0			The thin-film layer's thickness in nanometers for the opaque material when the thin-film override is enabled. Should be any value larger than 0, typically within the wavelength of light, but must be less than or equal to OPAQUE_SURFACE_MATERIAL_THIN_FILM_MAX_THICKNESS ((1500.0f) nm). Should only be used for debugging or development.
rtx.opaqueOpacityTransmissionLobeSamplingProbabilityZeroThreshold	float	0.01			The threshold for which to zero opaque opacity probability weight values.
rtx.opaqueSpecularLobeSamplingProbabilityZeroThreshold	float	0.01			The threshold for which to zero opaque specular probability weight values.
rtx.orthographicIsUI	bool	True			When enabled, draw calls that are orthographic will be considered as UI.
rtx.particleSoftnessFactor	float	0.05	0	1	Multiplier for the view distance that is used to calculate the particle blending range.
rtx.particles.discontinuityFactor	float	3	1		Multiplier on an emitter's recent velocity (plus the floor) above which a one-frame deviation is treated as a discontinuity (swap / teleport), collapsing the spawn context's prev transform to the current one. Higher = more tolerant before snapping. Only used when rtx.particles.enableDiscontinuityGuard is ON.
rtx.particles.discontinuityFloor	float	1	0		Minimum per-frame motion added to the emitter's recent speed when forming the discontinuity threshold. Suppresses false snaps from jitter on a near-stationary emitter. This value is multiplied by rtx.sceneScale (rendering units of 1cm per game unit, default 1). Only used when rtx.particles.enableDiscontinuityGuard is ON.
rtx.particles.enable	bool	True			Enables particle simulation and rendering.
rtx.particles.enableDiscontinuityGuard	bool	False			ON: when an emitter's one-frame motion deviates from a moving average of its recent velocity (swap / teleport / loop restart), collapse the spawn prev transform to the current one to kill the spawn ghost trail. This may fix bugs where particles seems to blur across large distances for one frame. Option may be removed when instance tracking becomes more reliable.
rtx.particles.enableSpawning	bool	True			Controls whether or not any particle system can currently spawn new particles.
rtx.particles.globalPreset.alignParticlesToVelocity	bool	False			Rotates the particles such that they are always aligned with their direction of travel, in this mode we ignore rotation speed.
rtx.particles.globalPreset.attractorForce	float	0			How strongly should the particles be attracted to the the attractor position. A value of 0 defines no attraction what soever, the unit is centimeters per second per second.
rtx.particles.globalPreset.attractorPosition	float3	0, 0, 0			The position in world space of the 'attractor' - which can be used to make particles be drawn to and even orbit a particular location.
rtx.particles.globalPreset.attractorRadius	float	0			Tunable falloff for the attractor - outside of this radius the attractor has no effect.
rtx.particles.globalPreset.billboardType	int	0			Billboard type to use for the global particle preset.
rtx.particles.globalPreset.collisionMode	int	0			Selects the collision mode for the particle - which controls behaviour on collision (if enabled). 0: Bounce on collision. 1: Stop all motion on collision. 2: Kill particle on collision.
rtx.particles.globalPreset.collisionRestitution	float	0.5			The fraction of velocity retained after a collision with scene geometry. 1.0 = perfectly elastic (no speed loss), 0.0 = completely inelastic (velocity zeroed). Values outside [0,1] will be clamped to this range.
rtx.particles.globalPreset.collisionThickness	float	5			The maximum penetration depth (in centimeters) at which a particle will still collide with geometry. Particles that penetrate deeper than this value are considered to have passed through thin objects and will not collide.
rtx.particles.globalPreset.dragCoefficient	float	0			Slows particles down over time, like air-resistance. This parameter must be greater than 0. 0 means particles wont slow down due to drag, for values larger than this particles will slow over time without any external force being applied.
rtx.particles.globalPreset.enableCollisionDetection	bool	False			Enables particle collisions with the world.
rtx.particles.globalPreset.enableMotionTrail	bool	False			Elongates the particle with respect to velocity, texture edges are preserved, with only the center being stretched which provides a motion blur like effect on the particles themselves. This will automatically align particles rotation with their individual velocity (similar to rtx.particles.globalPreset.alignParticlesToVelocity) and so rotation parameters are no longer taken into account when this setting is enabled.
rtx.particles.globalPreset.gravityForce	float	0			Net influence of gravity acting on each particle (centimeters per second squared).
rtx.particles.globalPreset.initialRotationDeviationDegrees	float	0			Range of degrees to rotate each particle by on spawn.
rtx.particles.globalPreset.initialVelocityConeAngleDegrees	float	0			Specifies the half angle, in degrees, of the random emission cone around the triangles surface normal when spawning a new particle. A value in the range of 0 to 180 degrees is expected.
rtx.particles.globalPreset.initialVelocityFromMotion	float	0			Multiplier for initial velocity applied at spawn time, based on the spawning objects current velocity.
rtx.particles.globalPreset.initialVelocityFromNormal	float	0			Initial speed to apply on spawn (centimeters per sec) along the normal vector of the spawning triangle.
rtx.particles.globalPreset.maxParticleLife	float	1			Maximum lifetime (in seconds) to give to a particle when spawned.
rtx.particles.globalPreset.maxSpawnColor	float4	1, 1, 1, 1			Minimum range of the color to tint a particle with when spawned.
rtx.particles.globalPreset.maxSpawnRotationSpeed	float	0			Maximum rotation speed (in revolutions per second) to give to a particle when spawned.
rtx.particles.globalPreset.maxSpawnSize	float2	10, 10			Maximum size (in centimeters) to give to a particle when spawned.
rtx.particles.globalPreset.maxSpawnVelocity	float3	-1, -1, -1			Maximum velocity of a particle in world space (in centimeters per second) to be used at spawn time. Negative values imply unlimited.
rtx.particles.globalPreset.maxSpeed	float	-1			*DEPRECATED* this setting has been removed in favor of maxSpawnVelocity and maxTargetVelocity.
rtx.particles.globalPreset.maxTargetColor	float4	1, 1, 1, 0			Maximum RGBA color picked from a range, to be used as the target animation state, at the end of the particles life.
rtx.particles.globalPreset.maxTargetRotationSpeed	float	0			Maximum rotation speed (in revolutions per second) picked from a range, to be used as the target animation state, at the end of the particles life. Only used if alignParticlesToVelocity is false.
rtx.particles.globalPreset.maxTargetSize	float2	0, 0			Maximum size (in centimeters) picked from a range, to be used as the target animation state, at the end of the particles life.
rtx.particles.globalPreset.maxTargetVelocity	float3	-1, -1, -1			Maximum velocity of a particle in world space (in centimeters per second) at a particles end of life. Negative values imply unlimited.
rtx.particles.globalPreset.minParticleLife	float	1			Minimum lifetime (in seconds) to give to a particle when spawned.
rtx.particles.globalPreset.minSpawnColor	float4	1, 1, 1, 1			Minimum range of the color to tint a particle with when spawned.
rtx.particles.globalPreset.minSpawnRotationSpeed	float	0			Minimum rotation speed (in revolutions per second) to give to a particle when spawned.
rtx.particles.globalPreset.minSpawnSize	float2	10, 10			Minimum size (in centimeters) to give to a particle when spawned.
rtx.particles.globalPreset.minTargetColor	float4	1, 1, 1, 0			Minimum RGBA color picked from a range, to be used as the target animation state, at the end of the particles life.
rtx.particles.globalPreset.minTargetRotationSpeed	float	0			Minimum rotation speed (in revolutions per second) picked from a range, to be used as the target animation state, at the end of the particles life. Only used if alignParticlesToVelocity is false.
rtx.particles.globalPreset.minTargetSize	float2	0, 0			Minimum size (in centimeters) picked from a range, to be used as the target animation state, at the end of the particles life.
rtx.particles.globalPreset.motionTrailMultiplier	float	1			When enableMotionTrail is set to enabled, this value can be used to increase (or decrease) the length of the tail artificially, which is determined by the velocity. A value of 1 (the default) will ensure each particle is the exact size of the motion over the previous frame. Values greater than 1 will increase that size linearly. Likewise for smaller than 1. 0 and below is an invalid value.
rtx.particles.globalPreset.numberOfParticlesPerMaterial	int	10000			Maximum number of particles to simulate per material simultaneously. There is a performance consideration, lower numbers are more performant. Ideal is to tune this number for your specific needs.
rtx.particles.globalPreset.randomFlipAxis	int	0			Allows the particle to be flipped randomly on spawn based on the selection here. Controlled per axis (or both). This feature helps hide repetition when reusing a single particle texture multiple times.
rtx.particles.globalPreset.restrictVelocityX	bool	False			Restricts particle velocity in the X axis.
rtx.particles.globalPreset.restrictVelocityY	bool	False			Restricts particle velocity in the Y axis.
rtx.particles.globalPreset.restrictVelocityZ	bool	False			Restricts particle velocity in the Z axis.
rtx.particles.globalPreset.spawnBurstDuration	float	0			Number of seconds between particle spawning bursts. For a value of 0, we assume continuous spawning, for all values greater than 0 we expect particles to be spawned in bursts. This value will still respect the spawn rate per second parameter and the max particle parameter.
rtx.particles.globalPreset.spawnRatePerSecond	int	100			Number of particles (per system) to spawn per second on average.
rtx.particles.globalPreset.spriteSheetMode	int	0			Sprite sheet mode to use for generating particle UVs. Options are, 0: Prefer material sprite sheet parameters - 1: Animate spritesheet with respect to the lifetime of the particle - 2: Pick a random sprite from the sheet per particle to use as the texture.
rtx.particles.globalPreset.turbulenceForce	float	5			How much turbulence influences the velocity of a particle as an external force (represented in centimeters per second squared).
rtx.particles.globalPreset.turbulenceFrequency	float	0.05			Frequency (rate of change) of the turbulence forces. Lower values change slowly; higher values change rapidly. This is specified in centimeters.
rtx.particles.globalPreset.useSpawnTexcoords	bool	False			Use the texture coordinates of the emitter mesh when spawning particles.
rtx.particles.globalPreset.useTurbulence	bool	False			Enable turbulence simulation.
rtx.particles.timeScale	float	1			Time modifier, can be used to slow/speed up time.
rtx.pathMaxBounces	int	4	0	15	The maximum number of indirect bounces the path will be allowed to complete. Must be < 16. Higher values result in better indirect lighting quality due to biasing the signal less, lower values result in better performance. Very high values are not recommended however as while long paths may be technically needed for unbiased rendering, in practice the contributions from higher bounces have diminishing returns.
rtx.pathMinBounces	int	1	0	15	The minimum number of indirect bounces the path must complete before Russian Roulette can be used. Must be < 16. This value is recommended to stay fairly low (1 for example) as forcing longer paths when they carry little contribution quickly becomes detrimental to performance.
rtx.pipeline.useDeferredOperations	bool	True
rtx.pixelHighlightReuseStrength	float	0.5			The specular portion when we reuse last frame's pixel value.
rtx.playerModel.backwardOffset	float	0
rtx.playerModel.enableInPrimarySpace	bool	False
rtx.playerModel.enablePrimaryShadows	bool	True
rtx.playerModel.enableVirtualInstances	bool	True
rtx.playerModel.eyeHeight	float	64
rtx.playerModel.horizontalDetectionDistance	float	34
rtx.playerModel.intersectionCapsuleHeight	float	68
rtx.playerModel.intersectionCapsuleRadius	float	24
rtx.playerModel.verticalDetectionDistance	float	64
rtx.pointInstancer.cullingRadius	float	5000	0		Maximum distance (in world units) from the camera beyond which PointInstancer instances are culled. Instances farther than this distance are not included in the TLAS.
rtx.pointInstancer.enable	bool	True			Enables radius-based culling for USD PointInstancer replacements. When disabled, all instances are submitted to the TLAS regardless of distance.
rtx.pointInstancer.fadeStartRadius	float	0	0		Distance (in world units) from the camera at which instances begin to be stochastically removed to create a smooth density falloff. Set to 0 to disable the fade region (hard culling boundary only). Must be less than cullingRadius.
rtx.postFilterThreshold	float	3			Clamps a pixel when its luminance exceeds x times of the average.
rtx.postfx.blurDiameterFraction	float	0.02			The diameter of the circle that motion blur samplings occur. Motion vectors beyond this circle will be clamped.
rtx.postfx.chromaticAberrationAmount	float	0.02			The strength of chromatic aberration.
rtx.postfx.chromaticCenterAttenuationAmount	float	0.975			Control the amount of chromatic aberration effect that attunuated when close to the center of screen.
rtx.postfx.desaturateOthersOnHighlight	bool	True			If true, desaturare all objects that are not highlighted.
rtx.postfx.enable	bool	True			Enables post-processing effects.
rtx.postfx.enableChromaticAberration	bool	True			Enables chromatic aberration post-processing effect.
rtx.postfx.enableMotionBlur	bool	True			Enables motion blur post-processing effect.
rtx.postfx.enableMotionBlurEmissive	bool	True			Enable Motion Blur for Emissive surfaces. Disable this when the motion blur on emissive surfaces cause severe artifacts.
rtx.postfx.enableMotionBlurNoiseSample	bool	True			Enable random distance sampling for every step along the motion vector. The random pattern is generated with interleaved gradient noise.
rtx.postfx.enableVignette	bool	True			Enables vignette post-processing effect.
rtx.postfx.exposureFraction	float	0.4			Simulate the camera exposure, the longer exposure will cause stronger motion blur.
rtx.postfx.motionBlurDynamicDeduction	float	1			The deduction of motion blur for dynamic objects.
rtx.postfx.motionBlurJitterStrength	float	0.6			The jitter strength of every sample along the motion vector.
rtx.postfx.motionBlurMinimumVelocityThresholdInPixel	float	1			The minimum motion vector distance that enable the motion blur. The unit is pixel size.
rtx.postfx.motionBlurSampleCount	int	4			The number of samples along the motion vector. More samples could help to reduce motion blur noise.
rtx.postfx.vignetteIntensity	float	0.6			The darkness of vignette effect.
rtx.postfx.vignetteRadius	float	0.8			The radius that vignette effect starts. The unit is normalized screen space, 0 represents the center, 1 means the edge of the short edge of the rendering window. So, this setting can larger than 1 until reach to the long edge of the rendering window.
rtx.postfx.vignetteSoftness	float	0.2			The gradient that the color drop to black from the vignetteRadius to the edge of rendering window.
rtx.preTransformedVerticesIsUI	bool	False			When enabled, draw calls using pre-transformed (screen-space) vertices will be considered as UI. This is typical for D3D8/D3D9 games that render UI with RHW vertices.
rtx.presentThrottleDelay	int	16			A time in milliseconds that the DXVK presentation thread should sleep for. Requires present throttling to be enabled to take effect. Note that the application may sleep for longer than the specified time as is expected with sleep functions in general.
rtx.primaryRayMaxInteractions	int	32	1	255	The maximum number of resolver interactions to use for primary (initial G-Buffer) rays. This affects how many Decals, Ray Portals and potentially particles (if unordered approximations are not enabled) may be interacted with along a ray at the cost of performance for higher amounts of interactions.
rtx.profiler.memory.enable	bool	False			Enables the memory profiler which allows users to inspect Remix resources using the profiler tool in the Dev Settings Remix window. This option is disabled by default, and must be enabled from application launch to work correctly.
rtx.profiler.memory.includeWholeFrame	bool	False			Profiles memory across the entire frame when enabled. When disabled we only see a snapshot of memory at the time of sampling. This has some additional CPU performance overhead so is disabled by default.
rtx.psrRayMaxInteractions	int	32	1	255	The maximum number of resolver interactions to use for PSR (primary surface replacement G-Buffer) rays. This affects how many Decals, Ray Portals and potentially particles (if unordered approximations are not enabled) may be interacted with along a ray at the cost of performance for higher amounts of interactions.
rtx.psrrMaxBounces	int	10	1	254	The maximum number of Reflection PSR bounces to traverse. Must be 15 or less due to payload encoding. Should be set higher when many mirror-like reflection bounces may be needed, though more bounces may come at a higher performance cost.
rtx.psrrNormalDetailThreshold	float	0			A threshold value to indicate that the denoiser's alternate disocclusion threshold should be used when normal map "detail" on a reflection PSR surface exceeds a desired amount. Normal detail is defined as 1-dot(tangent_normal, vec3(0, 0, 1)), or in other words it is 0 when no normal mapping is used, and 1 when the normal mapped normal is perpendicular to the underlying normal. This is typically used to reduce flickering artifacts resulting from reflection on surfaces like glass leveraging normal maps as often the denoiser is too aggressive with disocclusion checks frame to frame when DLSS or other camera jittering is in use.
rtx.pstrMaxBounces	int	10	1	254	The maximum number of Transmission PSR bounces to traverse. Must be 15 or less due to payload encoding. Should be set higher when refraction through many layers of glass may be needed, though more bounces may come at a higher performance cost.
rtx.pstrNormalDetailThreshold	float	0			A threshold value to indicate that the denoiser's alternate disocclusion threshold should be used when normal map "detail" on a transmission PSR surface exceeds a desired amount. Normal detail is defined as 1-dot(tangent_normal, vec3(0, 0, 1)), or in other words it is 0 when no normal mapping is used, and 1 when the normal mapped normal is perpendicular to the underlying normal. This is typically used to reduce flickering artifacts resulting from refraction on surfaces like glass leveraging normal maps as often the denoiser is too aggressive with disocclusion checks frame to frame when DLSS or other camera jittering is in use.
rtx.qualityDLSS	int	4			Adjusts internal DLSS scaling factor, trades quality for performance.
rtx.rayPortalCameraHistoryCorrection	bool	False			A flag to control if history correction on ray portal camera teleportation events is enabled or disabled. This allows for the previous camera matrix to be set to a virtual matrix to correct the large discontunity in position and view direction which happens when a camera teleports from moving through a ray portal (in games like Portal). As such this option should always be enabled in games utilizing ray portals the camera can pass through as it should fix artifacts from incorrectly calculated motion vectors or other deltas that rely on the current and previous camera matrix.
rtx.rayPortalCameraInBetweenPortalsCorrection	bool	False			A flag to contol correction when the camera is "in-between" a pair of ray portals. This is mostly relevant in applications which allow the camera to move through a ray portal (games like Portal) as often the ray portals are placed slightly off of a surface, allowing the camera to sometimes end up in this tiny gap for a frame. To correct this artifact (as it can mess up denoising and other temporal surface consistency checks due to the sudden frame of geometry in front of the camera) this option pushes the camera slightly backwards if this occurs when entering a ray portal. Similar to ray portal camera history correction this option should always be enabled in games utilizing ray portals the camera can pass through.
rtx.rayPortalCameraInBetweenPortalsCorrectionThreshold	float	0.1			The threshold to use for camera "in-between" ray portal detection in meters. When the camera is less than this distance behind the surface of a ray portal it will be pushed backwards to stay behind the ray portal. This value should stay small but be large enough to cover the gap between ray portals and the geometry behind them (if such a gap exists in the underlying application). Additionally, this setting must be set at startup and changing it will not take effect at runtime.
rtx.rayPortalEnabled	bool	False			Enables ray portal support. Note this requires portal texture hashes to be set for the ray portal geometries in rtx.rayPortalModelTextureHashes.
rtx.rayPortalModelHeightAxis	float3	0, 1, 0			The axis in object space to map the ray portal geometry's height axis to. Currently unused (as PCA is not implemented).
rtx.rayPortalModelNormalAxis	float3	0, 0, 1			The axis in object space to map the ray portal geometry's normal axis to. Currently unused (as PCA is not implemented).
rtx.rayPortalModelWidthAxis	float3	1, 0, 0			The axis in object space to map the ray portal geometry's width axis to. Currently unused (as PCA is not implemented).
rtx.rayPortalSamplingWeightMaxDistance	float	1000	0		The maximum distance from a portal which the interpolation of the probability of light sampling through portals will end (and is at its minimum value such that no portal light sampling will happen beyond this point). Currently unimplemented, kept here for future use.
rtx.rayPortalSamplingWeightMinDistance	float	10	0		The minimum distance from a portal which the interpolation of the probability of light sampling through portals will begin (and is at its maximum value). Currently unimplemented, kept here for future use.
rtx.rayreconstruction.combineSpecularAlbedo	bool	True			Combine primary and secondary specular albedo to improve DLSS-RR reflection quality.
rtx.rayreconstruction.compositeVolumetricLight	bool	True			Composite volumetric light and then input the result to DLSS-RR, otherwise volumetric light is in a separate layer. Disabling it may introduce flickering artifacts.
rtx.rayreconstruction.demodulateAttenuation	bool	True			Demodulate attenuation to reduce ghosting when an object is behind textured translucent objects.
rtx.rayreconstruction.demodulateRoughness	bool	True			Demodulate roughness to enhance roughness details.
rtx.rayreconstruction.disocclusionMaskBlurNormalizedGaussianWeightSigma	float	0.5			Normalized Gaussian weight sigma to use for blurring disocclusion mask. The sigma is applied to the normalized blur kernel radius extents (i.e. <0, 1>).
rtx.rayreconstruction.disocclusionMaskBlurRadius	int	32			Pixel radius to use for blurring disocclusion mask.
rtx.rayreconstruction.enableDetailEnhancement	bool	True			Enable detail enhancement filter to enhance normal map details.
rtx.rayreconstruction.enableDisocclusionMaskBlur	bool	False			Enables blurring of disocclusion mask to suppress instabilities due to abrupt mask value changes.
rtx.rayreconstruction.enableNRDForTraining	bool	False			Enable NRD. This option is only for training or debug purpose.
rtx.rayreconstruction.enableTransformerModelD	bool	False
rtx.rayreconstruction.invalidateHistoryForAnimatedWater	bool	False			Adds animated water surfaces to the disocclusion mask, making DLSS Ray Reconstruction discard their temporal history every frame. This suppresses ghosting from the water's per-frame normal variation, but can introduce shimmering on objects seen through or near the water, so it is disabled by default. Enable it for content whose animated water ghosts noticeably.
rtx.rayreconstruction.model	int	1			Ray reconstruction model to use. 0: CNN, 1: Transformer (higher quality).
rtx.rayreconstruction.particleBufferMode	int	1			Use a separate particle buffer to handle particles.
rtx.rayreconstruction.pathTracerPreset	int	1			Path tracer preset to use when Ray Reconstruction is enabled.
rtx.rayreconstruction.preprocessSecondarySignal	bool	True			Denoise secondary signal before passing to DLSS-RR. This option improves reflection on translucent objects.
rtx.rayreconstruction.preserveSettingsInNativeMode	bool	False			Preserve settings when switched to native mode, otherwise the default preset will be applied.
rtx.rayreconstruction.upscalerRoughnessDemodulationMultiplier	float	0.15			Multiplier of upscaler roughness demodulation to suppress noise. Only used by DLSS-RR.
rtx.rayreconstruction.upscalerRoughnessDemodulationOffset	float	1.5			Strength of upscaler roughness demodulation. Only used by DLSS-RR.
rtx.rayreconstruction.useSpecularHitDistance	bool	True			Use specular hit distance to reduce ghosting.
rtx.raytraceModePreset	int	1
rtx.raytracedRenderTarget.enable	bool	True			Enables or disables raytracing for render-to-texture effects. The render target to be raytraced must be specified in the texture selection menu.
rtx.recomputeTextureHashOnWrite	bool	False			When true, Remix computes the hash of a texture when the game writes to the resource. Some games manage their own pool of textures and shuffle data around those resources resulting in incorrect textures being displayed. Recomputing the hash when the game writes to the resource can resolve this issue, however this can have unintended side effects when replacing animated game textures.
rtx.reflexMode	int	1			Reflex mode selection, enabling it helps minimize input latency, boost mode may further reduce latency by boosting GPU clocks in CPU-bound cases. Supported enum values are 0 = None (Disabled), 1 = LowLatency (Enabled), 2 = LowLatencyBoost (Enabled + Boost). Note that even when using the "None" Reflex mode Reflex will attempt to be initialized. Use rtx.isReflexEnabled to fully disable to skip this initialization if needed.
rtx.reloadTextureWhenResolutionChanged	bool	False			Reload texture when resolution changed.
rtx.renderPassGBufferRaytraceMode	int	0		2	The ray tracing mode to use for the G-Buffer pass which resolves the initial primary and secondary surfaces to apply lighting to.
rtx.renderPassIntegrateDirectRaytraceMode	int	0		1	The ray tracing mode to use for the Direct Lighting pass which applies lighting to the primary/secondary surfaces.
rtx.renderPassIntegrateIndirectRaytraceMode	int	2		2	The ray tracing mode to use for the Indirect Lighting pass which applies lighting to the primary/secondary surfaces.
rtx.replaceDirectSpecularHitTWithIndirectSpecularHitT	bool	True
rtx.resetDenoiserHistoryOnSettingsChange	bool	False
rtx.resolutionScale	float	0.75
rtx.resolveOpaquenessThreshold	float	0.996078	0	1	A threshold for which any opacity value above is considered totally opaque.
rtx.resolvePreCombinedMatrices	bool	True
rtx.resolveTransparencyThreshold	float	0.00392157	0	1	A threshold for which any opacity value below is considered totally transparent and may be safely skipped without as significant of a performance cost.
rtx.restirGI.DLSSRRTemporalRandomizationRadius	int	80			In DLSS-RR compatibility mode temporal reprojection is randomized to reduce sample coherency. This option determines the randomization radius.
rtx.restirGI.biasCorrectionMode	int	4			Bias correction mode to combine central with its neighbors in spatial reuse.
rtx.restirGI.boilingFilterMaxThreshold	float	20			Boiling filter threshold when surface normal is parallel to view direction.
rtx.restirGI.boilingFilterMinThreshold	float	10			Boiling filter threshold when surface normal is perpendicular to view direction.
rtx.restirGI.boilingFilterRemoveReservoirThreshold	float	62			Removes a sample when a sample's weight exceeds this threshold.
rtx.restirGI.fireflyThreshold	float	50			Clamps specular input to suppress boiling.
rtx.restirGI.historyDiscardStrength	float	0			The sensitivity of discarding history. Higher values discard more history.
rtx.restirGI.lightingValidationThreshold	float	0.5			Invalidate a sample when pixel change ratio is above this value.
rtx.restirGI.misMode	int	2			MIS mode to mix specular output with input.
rtx.restirGI.misRoughness	float	0.3			Reference roughness when roughness MIS is used. Higher values give ReSTIR inputs higher weight.
rtx.restirGI.pairwiseMISCentralWeight	float	0.1			The importance of central sample in pairwise bias correction modes.
rtx.restirGI.parallaxAmount	float	0.02			Parallax strength when parallax MIS is used. Higher values give ReSTIR inputs higher weight.
rtx.restirGI.permutationSamplingSize	int	2			Permutation sampling strength.
rtx.restirGI.reflectionMinParallax	float	3			When the parallax between normal and reflection reprojection is greater than this threshold, randomly choose one reprojected position and reuse the sample on it. Otherwise, get a sample between the two positions.
rtx.restirGI.roughnessClamp	float	0.01			Clamps minimum roughness a sample's importance is evaluated.
rtx.restirGI.sampleStealingJitter	float	0			Jitter samples by k pixels to avoid aliasing.
rtx.restirGI.stealBoundaryPixelSamplesWhenOutsideOfScreen	bool	True			Steals ReSTIR GI samples even a hit point is outside the screen. This will further improve highly specular samples at the cost of some bias.
rtx.restirGI.temporalAdaptiveHistoryLengthMs	int	500			Temporal history time length, when adaptive temporal history is enabled.
rtx.restirGI.temporalFixedHistoryLength	int	30			Fixed temporal history length, when adaptive temporal history is disabled.
rtx.restirGI.useAdaptiveTemporalHistory	bool	True			Adjust temporal history length based on frame rate.
rtx.restirGI.useBoilingFilter	bool	True			Enables boiling filter to suppress boiling artifacts.
rtx.restirGI.useDLSSRRCompatibilityMode	bool	False			DLSS-RR compatibility mode. In this mode temporal reprojection is randomized to reduce sample coherency.
rtx.restirGI.useDemodulatedTargetFunction	bool	False			Demodulates target function. This will improve the result in non-pairwise modes.
rtx.restirGI.useDiscardEnlargedPixels	bool	True			Discards enlarged samples when the camera is moving towards an object.
rtx.restirGI.useFinalVisibility	bool	True			Tests visiblity in output.
rtx.restirGI.usePermutationSampling	bool	True			Uses permutation sample to perturb samples. This will improve results in DLSS.
rtx.restirGI.useReflectionReprojection	bool	True			Uses reflection reprojection for reflective objects to achieve stable result when the camera is moving.
rtx.restirGI.useSampleStealing	int	2			Steals ReSTIR GI samples in path tracer. This will improve highly specular results.
rtx.restirGI.useSpatialReuse	bool	True			Enables spatial reuse.
rtx.restirGI.useTemporalBiasCorrection	bool	True			Corrects bias caused by temporal reprojection.
rtx.restirGI.useTemporalJacobian	bool	True			Calculates Jacobian determinant in temporal reprojection.
rtx.restirGI.useTemporalReuse	bool	True			Enables temporal reuse.
rtx.restirGI.useVirtualSample	bool	True			Uses virtual position for samples from highly specular surfaces.
rtx.restirGI.validateLightingChange	bool	True			Remove samples when direct light has changed.
rtx.restirGI.validateVisibilityChange	bool	False			Remove samples when visibility has changed. This feature is automatically disabled when virtual sample is enabled.
rtx.restirGI.virtualSampleLuminanceThreshold	float	2			The last path vertex with luminance greater than 2 times of the previous accumulated radiance will get virtualized. Higher values tend to keep the first path vertex with non-zero contribution.
rtx.restirGI.virtualSampleMaxDistanceRatio	float	0			Clamp max virtual distance, measured by the proportion of distance to camera. 0 disables clamping.
rtx.restirGI.virtualSampleRoughnessThreshold	float	0.2			Surface with roughness under this threshold is considered to be highly specular, i.e. a "mirror".
rtx.restirGI.virtualSampleSpecularThreshold	float	0.5			If a highly specular path vertex's direct specular light portion is higher than this. Its distance to the light source will get accumulated.
rtx.restirGI.visibilityValidationRange	float	0.05			Check actual hit distance of a shadow ray, invalidate a sample if hit length is longer than one plus this portion, compared to the distance from the surface to the sample.
rtx.restoreCursorPosition	bool	False			If true, the game's mouse cursor position will be restored when the Remix UI is closed. This should fix the issue where the game camera suddenly turns when closing the UI.
rtx.risLightSampleCount	int	7	1	65535	The number of lights randomly selected from the global pool to consider when selecting a light with RIS. Higher values generally increases the quality of RIS light sampling, but also has diminishing returns and higher performance cost past a point. Note that RIS is only used when RTXDI is disabled for direct lighting, or for light sampling in indirect rays, so the impact of this effect will vary.
rtx.rngSeedWithFrameIndex	bool	True			Indicates that pseudo-random number generator should be seeded with the frame number of the application every frame, otherwise seed with 0. This should generally always be enabled as without the frame index each frame will typically be identical in the random values that are produced which will result in incorrect rendering. Only meant as a debugging tool.
rtx.russianRoulette1stBounceMaxContinueProbability	float	1			The maximum probability of continuing a path when Russian Roulette is being used on the first bounce. This is similar to the usual max continuation probability for Russian Roulette, but specifically only for the first bounce.
rtx.russianRoulette1stBounceMinContinueProbability	float	0.6			The minimum probability of continuing a path when Russian Roulette is being used on the first bounce. This ensures that on the first bounce rays are not terminated too aggressively as it may be useful for some denoisers to have a contribution even if it is a relatively unimportant one rather than a missing indirect sample.
rtx.russianRouletteDiffuseContinueProbability	float	0.1			The probability of continuing a diffuse path when Russian Roulette is being used. Only apply to specular based mode.
rtx.russianRouletteDistanceFactor	float	0.1			Path segments whose distance proportion are under this threshold are more likely to continue. Only apply to specular based mode.
rtx.russianRouletteMaxContinueProbability	float	0.9	0	1	The maximum probability of continuing a path when Russian Roulette is being used. This ensures all rays have a small probability of terminating each bounce, mostly to prevent infinite paths in perfectly reflective mirror rooms (though the maximum path bounce count will also ensure this).
rtx.russianRouletteMode	int	0			Russian Roulette Mode. Throughput Based: paths with higher throughput become longer; Specular Based: specular paths become longer.
rtx.russianRouletteSpecularContinueProbability	float	0.98			The probability of continuing a specular path when Russian Roulette is being used. Only apply to specular based mode.
rtx.sceneKeepAliveFrames	int	0			Number of consecutive frames without valid camera or raytracing before clearing the scene. Set to 0 to clear immediately (legacy behavior). Higher values prevent scene clearing during brief shader loading delays, camera cuts, etc.
rtx.sceneScale	float	1			Defines the ratio of rendering unit (1cm) to game unit, i.e. sceneScale = 1cm / GameUnit.
rtx.secondaryRayMaxInteractions	int	8	1	255	The maximum number of resolver interactions to use for secondary (indirect) rays. This affects how many Decals, Ray Portals and potentially particles (if unordered approximations are not enabled) may be interacted with along a ray at the cost of performance for higher amounts of interactions. This value is recommended to be set lower than the primary/PSR max ray interactions as secondary ray interactions are less visually relevant relative to the performance cost of resolving them.
rtx.secondarySpecularFireflyFilteringThreshold	float	1000			Firefly luminance clamping threshold for secondary specular signal.
rtx.shader.asyncCompilationThrottleMilliseconds	int	33			Specifies a time in milliseconds to throttle each application frame when async shader compilation is in progress. Set to 0 to disable, and only takes effect when rtx.shader.enableAsyncCompilation is true. This generally should be set to a value low enough to not impact the application framerate significantly (especially if non-ray traced visuals are capable of being displayed by the application while loading, e.g. an intro video), but also high enough to get the desired shader compilation performance (especially relevant if the application is fairly heavy on the CPU during async shader compilation, or on CPUs with few hardware threads).
rtx.shader.asyncSpirVRecompilation	bool	True			When set to true runtime shader recompilation will recompile shaders to SPIR-V asynchronously rather than blocking until complete. Do note that despite setting this option the actual compilation of the shader from SPIR-V to the ISA will still be blocking as only the prewarming process can handle this step asynchronously for now. Generally this option should remain enabled, though disabling it may be useful for CI where deterministic behavior is needed, and may be useful to maximize performance at the cost of blocking (by not having application running while compiling to SPIR-V). This option is mainly meant for development use and should not be set for user-facing operation.
rtx.shader.enableAsyncCompilation	bool	True			When set to true shader compilation (especially that of prewarming) will be done asynchronously rather than blocking. Typically shader prewarming with async finalization is done to attempt to compile all required shader variants before they are used, often by overlapping this work with a startup sequence (e.g. a game's loading screen). Often times however this prewarming takes longer than the time available, or an application may not have a startup sequence to begin with and immediately begin using Remix shaders. To accomodate this, async shader compilation allows for this work to be done asynchronously to avoid blocking the application at the cost of being unable to render anything until the process is complete. This is typically better choice than blocking however and is recommended to be enabled as on Windows Remix blocking will cause the application to stop responding, making it seem as if the application has crashed if shader compilation takes a long time. Additionally, when combined with rtx.shader.enableAsyncCompilationUI the progress of the compilation process can be shown to the user as a UI, improving user experience. The main downside to this approach is that when blocking shader compilation is allowed to take up more of the CPU, whereas async shader compilation will have to compete with the application which can make compilation take slightly longer than it would otherwise (especially true if the application's framerate is uncapped). To mitigate this, Remix can optionally throttle the application during async compilation via rtx.shader.asyncCompilationThrottleMilliseconds to ensure enough time is available for compilation. Finally, a more minor downside is that when async shader compilation is in use Remix currently has no way of keeping the application in a startup sequence (e.g. keeping a game on its loading screen) while it waits for shaders to compile. This will mean for instance a game's menu may be active but not be able to render until the compilation is complete, rather than blocking on the loading screen and transitioning to the menu only once all shaders are loaded. Not blocking the application is typically better for user experience regardless though as long as some sort of progress UI is displayed to indicate what is happening.
rtx.shader.enableAsyncCompilationUI	bool	True			Enables a UI message when async shader compilation is in progress to indicate the current compilation progress. Only takes effect when rtx.shader.enableAsyncCompilation is true. This should usually be enabled as providing information to the user about the current progress of compilation is useful. May be disabled however for automated testing purposes if the nondeterministic behavior of the UI's rendered text interferes with testing.
rtx.shader.prewarmAllVariants	bool	False			When set to true, all variants of shaders will be prewarmed at launch. Only takes effect when rtx.initializer.asyncShaderPrewarming is set to true. By default Remix only prewarms shaders which may actually be used at runtime or are accessible by user-facing graphics menus rather than all shader variants accessible by changing options in the developer menu. This has the benefit of minimizing shader compilation cost for typical users, but may cause shader compilation stalls when changing various options in the developer menu. As such, this option is useful to enable during development to minimize these stalls. Do note however that enabling this option will have a significant performance impact whenever shaders are uncached (e.g. on first load) due to requiring many more shaders to be compiled. As such using the enviornment variable to set this option locally on a developer's machine is recommended over a configuration file change to ensure it is not accidently enabled for users.
rtx.shader.recompileOnLaunch	bool	False			When set to true runtime shader recompilation will execute on the first frame after launch. This option is mainly meant for development use and should not be set for user-facing operation. Also see rtx.useLiveShaderEditMode for a similar option which auto-detects shader changes instead.
rtx.shader.useLiveEditMode	bool	False			When set to true shaders will be automatically recompiled when any shader file is updated (saved for instance) in addition to the usual manual recompilation trigger. This option is mainly meant for development use and should not be set for user-facing operation.
rtx.shadowTerminator.enableOffset	bool	True			Offset the shadow ray origin along the triangle vertex normals to avoid self-intersection. Helps to remove the triangular shadow artifacts on a terminator region. Note that it may introduce a noticeable light leaking if the geometry is low-poly.
rtx.shadowTerminator.maxArea	float	0.05			If a polygon area is larger than this value (in square meters), then a shadow terminator offset will not be applied.
rtx.shadowTerminator.maxLength	float	0.02			Clamp shadow terminator length by this value (in meters).
rtx.shadowTerminator.soften	bool	True			Fix the harsh transition on a shadow terminator by gradually smoothing, when the geometry normal is inconsistent with shading normal.Note that it doesn't modify the shadow ray, and only applies a falloff when calculating a direct illumination.
rtx.shakeCamera	bool	False			Enables animation of the free camera.
rtx.showLegacyACESOption	bool	False			Show 'rtx.useLegacyACES' in the developer menu. Default is OFF, as the non-legacy ACES is currently experimental and the implementation is a subject to change.
rtx.showRaytracingOption	bool	True			Enables or disables the option to toggle ray tracing in the UI. When set to false the ray tracing checkbox will not appear in the Remix UI.
rtx.showUI	int	0			0 = Don't Show, 1 = Show Simple, 2 = Show Advanced, 3 = First Use Guide.
rtx.showUICursor	bool	True			If true, the ImGUI mouse cursor will be shown when the UI is active. Can be toggled with Alt + Delete.
rtx.skipDrawCallsPostRTXInjection	bool	False			Ignores all draw calls recorded after RTX Injection, the location of which varies but is currently based on when tagged UI textures begin to draw.
rtx.skipObjectsWithUnknownCamera	bool	False
rtx.skyAutoDetect	int	0			Automatically tag sky draw calls using various heuristics. 0 = None 1 = CameraPosition - assume the first seen camera position is a sky camera. 2 = CameraPositionAndDepthFlags - assume the first seen camera position is a sky camera, if its draw call's depth test is disabled. If it's enabled, assume no sky camera. Note: if all draw calls are marked as sky, then assume that there's no sky camera at all.
rtx.skyAutoDetectUniqueCameraDistance	float	1			If multiple cameras are found, this threshold distance (in game units) is used to distinguish a sky camera from a main camera. Active if sky auto-detect is set to CameraPosition / CameraPositionAndDepthFlags.
rtx.skyBrightness	float	1
rtx.skyDrawcallIdThreshold	int	0			It's common in games to render the skybox first, and so, this value provides a simple mechanism to identify those early draw calls that are untextured (textured draw calls can still use the Sky Textures functionality.
rtx.skyForceAutoDetectedToReproject	bool	False			When enabled, draw calls classified as sky by auto-detect are always reprojected to main camera space instead of being rasterized to the sky cubemap. This fixes a class of bugs where auto-detect misclassifies world geometry as sky (due to shared camera positions), causing that geometry to become invisible. Only effective when Sky Auto-Detect and Reproject Sky to Main Camera are both enabled.
rtx.skyForceHDR	bool	False			By default sky will be rasterized in the color format used by the game. Set the checkbox to force sky to be rasterized in HDR intermediate format. This may be important when sky textures replaced with HDR textures.
rtx.skyMinZThreshold	float	1			If a draw call's viewport has min depth greater than or equal to this threshold, then assume that it's a sky.
rtx.skyProbeSide	int	1024			Resolution of the skybox for indirect illumination (rough reflections, global illumination etc).
rtx.skyReprojectScale	float	16			Scaling of the sky geometry on reprojection to main camera space.
rtx.skyReprojectToMainCameraSpace	bool	False			Move sky geometry to the main camera space. Useful, if a game has a skybox that contains geometry that can be a part of the main scene (e.g. buildings, mountains). So with this option enabled, that geometry would be promoted from sky rasterization to ray tracing.
rtx.skyUiDrawcallCount	int	0
rtx.sparseRendering.directLightingSamplingRate	float	1	0.0625	1	Per-pixel sampling rate for primary direct lighting (RTXDI + integrate_direct). Lower values boost performance at the cost of image detail and temporal stability. Range [0.0625, 1.0]. Rates below ~0.2 tend to look bad and yield diminishing perf returns.
rtx.sparseRendering.enableRtxdiReuseForInactivePixels	bool	False			Enables RTXDI reservoir reuse (temporal reprojection and spatial reuse) on inactive pixels. Disabling improves performance and, counterintuitively, has been observed to reduce ghosting.In theory it can increase direct lighting noise under animated lighting.
rtx.sparseRendering.enableSparsePrimaryRayMissComposition	bool	False			When enabled, primary miss pixels (sky) use sparse rendering. This improves performance at the cost of sky reconstruction artifacts.
rtx.sparseRendering.enableSparsePrimarySpecularAlbedo	bool	False			When enabled, the primary specular albedo guide for DLSS Ray Reconstruction is written sparsely: active pixels get the computed specular albedo, inactive primary-hit pixels are zeroed. When disabled (default), the guide is computed and written densely for every primary-hit pixel so RR sees a clean dense signal.
rtx.sparseRendering.enableSparseRendering	bool	False			Enables sparse rendering. When enabled, applies a constant per-pixel sampling rate across the screen. DLSS Ray Reconstruction is required.
rtx.sparseRendering.enableSparseSecondaryLighting	bool	False			When enabled, secondary surfaces (PSR glass reflections) use sparse rendering. This improves performance at the cost of potential sparse NRD denoising artifacts on glass. This option is in development and may not produce good denoised results.
rtx.sparseRendering.enableSparseVolumetricsPrimaryHit	bool	True			When enabled, volumetric NEE integration at primary-hit pixels uses sparse rendering.
rtx.sparseRendering.enableSparseVolumetricsPrimaryMiss	bool	False			When enabled, volumetric NEE integration at primary-miss (sky) pixels uses sparse rendering.
rtx.sparseRendering.forceNrcTrainingPixelsActive	bool	True			When enabled, pixels that correspond to NRC training paths are forced active in sparse rendering.
rtx.sparseRendering.indirectLightingSamplingRate	float	1	0.0625	1	Per-pixel sampling rate for primary indirect lighting (integrate_indirect, integrate_nee, NRC resolve). Lower values boost performance at the cost of image detail and temporal stability. Range [0.0625, 1.0]. Rates below ~0.2 tend to look bad and yield diminishing perf returns.
rtx.sparseRendering.perPixelRateNoiseSource	int	1			Selects the noise source used to threshold per-pixel sampling rates. WhiteNoise (0): wangHash ~ white-noise. BlueNoise128x128x64x8 (1): 8 bit 128x128 blue-noise 64 frame length.
rtx.splashMessageDisplayTimeSeconds	int	20			The amount of time in seconds to display the Remix splash message for.
rtx.srgbDither.ditherMode	int	2			Final output dither mode selection. Dithering allows for reduction of banding artifacts in the final rendered output from quantization using a small amount of monochromatic noise. Supported enum values are 0 = None (Disabled), 1 = Spatial (Enabled, Spatial dithering only), 2 = SpatialTemporal (Enabled, Spatial and temporal dithering).
rtx.stochasticAlphaBlendDepthDifference	float	0.1			Max depth difference for a valid neighbor.
rtx.stochasticAlphaBlendDiscardBlackPixel	bool	False			Discard black pixels.
rtx.stochasticAlphaBlendEnableFilter	bool	True			Filter samples to suppress noise.
rtx.stochasticAlphaBlendInitialSearchRadius	float	10			Initial search radius.
rtx.stochasticAlphaBlendNormalSimilarity	float	0.9			Min normal similarity for a valid neighbor.
rtx.stochasticAlphaBlendOpacityThreshold	float	0.95			Max opacity to use stochastic alpha blend.
rtx.stochasticAlphaBlendPlanarDifference	float	0.2			Max planar difference for a valid neighbor.
rtx.stochasticAlphaBlendRadianceVolumeMultiplier	float	1			Radiance volume multiplier.
rtx.stochasticAlphaBlendRadiusExpandFactor	float	1.6			Multiply radius by this factor if cannot find a good neighbor.
rtx.stochasticAlphaBlendSearchIteration	int	6			Search iterations.
rtx.stochasticAlphaBlendSearchTheSameObject	bool	True			Only use radiance samples from the same object.
rtx.stochasticAlphaBlendShareNeighbors	bool	True			Share result with other pixels to accelerate search.
rtx.stochasticAlphaBlendUseNeighborSearch	bool	True			Get radiance from neighbor opaque pixels.
rtx.stochasticAlphaBlendUseRadianceVolume	bool	True			Get radiance from radiance volume.
rtx.subsurface.diffusionProfileDebugPixelPosition	int2	2147483647, 2147483647			Pixel position where we show debugging sampling positions for diffusion profile. Requires set debug view to 'SSS Diffusion Profile Sampling'.
rtx.subsurface.diffusionProfileScale	float	1			Scalar of the diffusion profile scale.
rtx.subsurface.enableDiffusionProfile	bool	True			Enable subsurface material. Solve subsurface rendering equation with (burley/SOTO) diffusion profile.
rtx.subsurface.enableHeuristicSingleScatteringTransmission	bool	True			Heuristically checks the mean free path (MFP) of SSS materials to determine whether single scattering transmission should be enabled. Extremely large MFP values usually indicate thick volumes dominated by high-order scattering, which is already approximated by the diffusion profile and captures most of the SSS energy. In these cases, the single scattering contribution can be safely ignored.
rtx.subsurface.enableTextureMaps	bool	True			Enable texture maps such as thickness map or scattering albedo map. The corresponding subsurface properties will fallback to per-material constants if this is disabled.
rtx.subsurface.enableThinOpaque	bool	True			Enable thin opaque material. The materials withthin opaque properties will fallback to normal opaque material.
rtx.subsurface.enableTransmission	bool	True			Enable subsurface transmission. Implement single scattering transmission for thin or curved SSS surface.
rtx.subsurface.enableTransmissionDiffusionProfileCorrection	bool	False			Enable diffusion profile correction when enabling SSS Transmission. Both burley's diffusion profile and SSS Transmission includes the single scattering energy. The correction removes the single scattering part from diffusion profile to avoid double counting the single scattering energy.
rtx.subsurface.enableTransmissionSingleScattering	bool	True			Enable single scattering for subsurface transmission. If this option is disabled, then the refracted ray will not be scattered again inside of the volume.
rtx.subsurface.surfaceThicknessScale	float	1			Scalar of the subsurface thickness.
rtx.subsurface.transmissionBsdfSampleCount	int	1			The sample count for transmission BSDF.(1spp as default)
rtx.subsurface.transmissionSingleScatteringSampleCount	int	1			The sample count for every single scattering on BSDF transmission (refracted) ray.(1spp as default)
rtx.suppressLightKeeping	bool	False			If true, Remix doesn't keep game's original light sources for many frames. For example, if a game switches a point light off, then, in Remix, the light might still be rendered as if it's enabled: because the light would be cached (kept) for many consecutive frames. (So to solve this, set this option to True).
rtx.taauPreset	int	2			Adjusts TAA-U scaling factor, trades quality for performance.
rtx.temporalAA.colorClampingFactor	float	1	0		A scalar factor to apply to the standard deviation of the neighborhood of pixels in the color signal used for clamping. Should be in the range 0-infinity. This value essentially represents how many standard deviations of tolerance from the current frame's colors around each pixel pixel the temporally accumulated color signal may have. Higher values will cause more ghosting whereas lower values may reduce ghosting but will impact image quality (less ability to upscale effectively) and reduce stability (more jittering).
rtx.temporalAA.maximumRadiance	float	10000	0		The maximum value to use in TAA-U's perceptual quantizer color transformation, measured in cd/m^2. The typical value used for the PQ transformation is 10,000 and usually shouldn't be changed.
rtx.temporalAA.newFrameWeight	float	0.1	0	1	The maximum amount of the current frame to use as part of the temporal anti-aliasing process. Must be in the range 0-1. Values closer to 0 will result in better image stability (less jittering) and less aliasing, values closer to 1 will result in more responsive results (less ghosting).
rtx.terrain.terrainAsDecalsAllowOverModulate	bool	False			Set to true, if it's known that terrain layers with ModulateX2 / ModulateX4 flags do not contain a lighting info, but ModulateX2 / ModulateX4 are used only to blend layers.
rtx.terrain.terrainAsDecalsEnabledIfNoBaker	bool	False			If terrain baker is disabled, attempt to blend with the decals.
rtx.terrainBaker.cascadeMap.defaultHalfWidth	float	1000			Cascade map square's default half width around the camera [meters]. Used when the terrain's BBOX couldn't be estimated.
rtx.terrainBaker.cascadeMap.defaultHeight	float	1000			Cascade map baker's camera default height above the in-game camera [meters]. Used when the terrain's BBOX couldn't be estimated.
rtx.terrainBaker.cascadeMap.expandLastCascade	bool	True			Expands the last cascade's footprint to cover the whole cascade map. This ensures whole terrain surface has valid baked texture data to sample from even if there isn't enough cascades generated (due to the current settings or limitations).
rtx.terrainBaker.cascadeMap.levelHalfWidth	float	10			First cascade level square's half width around the camera [meters].
rtx.terrainBaker.cascadeMap.levelResolution	int	4096	1	32768	Texture resolution per cascade level.
rtx.terrainBaker.cascadeMap.maxLevels	int	8	1	16	Max number of cascade levels.
rtx.terrainBaker.cascadeMap.useTerrainBBOX	bool	True			Uses terrain's bounding box to calculate the cascade map's scene footprint.
rtx.terrainBaker.clearTerrainBeforeBaking	bool	False			Performs a clear on the terrain texture before it is baked to in a frame.
rtx.terrainBaker.debugDisableBaking	bool	False			Force disables rebaking every frame. Used for debugging only.
rtx.terrainBaker.debugDisableBinding	bool	False			Force disables binding of the baked terrain texture to the terrain meshes. Used for debugging only.
rtx.terrainBaker.disableBackFaceCulling	bool	False			Disables back-face culling for baked terrain instances. When enabled, all terrain will render as double-sided.
rtx.terrainBaker.enableBaking	bool	True			[Experimental] Enables runtime baking of blended terrains from top down (i.e. in an opposite direction of "rtx.zUp"). It bakes multiple blended albedo terrain textures into a single texture sampled during ray tracing. The system requires "Terrain Textures" to contain hashes of the terrain textures to apply. Only use this system if the game renders terrain surfaces with multiple blended surfaces on top of each other (i.e. sand mixed with dirt, grass, snow, etc.). Requirement: the baked terrain surfaces must not be placed vertically in the game world. Horizontal surfaces will have the best image quality. Requires "rtx.zUp" to be set properly.
rtx.terrainBaker.material.bakeReplacementMaterials	bool	True			Enables baking of replacement materials when they are present.
rtx.terrainBaker.material.bakeSecondaryPBRTextures	bool	True			Enables baking of secondary textures in replacement materials when they are present. Secondary textures are all PBR textures except for albedoOpacity. So that includes normal, roughness, etc.
rtx.terrainBaker.material.maxResolutionToUseForReplacementMaterials	int	8192			Max resolution to use for preprocessing and baking of input replacement material textures other than color opacity which is used as is. Applies only to a case when a preprocessing compute shader is used to support baking of secondary PBR materials. Replacement materials need to be preprocessed prior to baking them and limitting the max resolution allows to balance the quality vs performance cost.
rtx.terrainBaker.material.properties.displaceInFactor	float	1			The max depth and height the baked terrain can support will be larger than the max of any incoming draw call, which results in a loss of detail. When this is too low, the displacement will lack detail. When it is too high, the lowest and highest parts of the POM will flatten out. This affects both displaceIn and displaceOut, despite the name.
rtx.terrainBaker.material.properties.emissiveColorConstant	float3	0, 0, 0			Emissive color constant. Should be a color in sRGB colorspace with gamma encoding.
rtx.terrainBaker.material.properties.emissiveIntensity	float	0			Emissive intensity.
rtx.terrainBaker.material.properties.enableEmission	bool	False			A flag to determine if emission is enabled.
rtx.terrainBaker.material.properties.metallicConstant	float	0.1			Metallic constant. Valid range is <0, 1>.
rtx.terrainBaker.material.properties.roughnessAnisotropy	float	0			Roughness anisotropy. Valid range is <-1, 1>, where 0 is isotropic.
rtx.terrainBaker.material.properties.roughnessConstant	float	0.7			Perceptual roughness constant. Valid range is <0, 1>.
rtx.terrainBaker.material.replacementSupportInPS	bool	True			Enables reading of secondary PBR replacement textures in pixel shaders when supported. Current support is limitted to fixed function pipelines and programmable shaders with Shader Model 1.0. When set to false or unsupported, an extra compute shader is used to preproces the secondary textures to make them compatible at an expense of performance and quality instead. Requires "rtx.terrainBaker.material.replacementSupportInPS_fixedFunction = True" to apply for draw calls with fixed function graphics pipeline. Requires "rtx.terrainBaker.material.replacementSupportInPS_programmableShaders = True" to apply for draw calls with programmable graphics pipeline.
rtx.terrainBaker.material.replacementSupportInPS_fixedFunction	bool	True			Enables reading of secondary PBR replacement textures in pixel shaders for games with fixed function graphics pipelines. When set to false, an extra compute shader is used to preproces the secondary textures to make them compatible at an expense of performance and quality instead. This parameter must be set at launch to apply.
rtx.terrainBaker.material.replacementSupportInPS_programmableShaders	bool	True			[Experimental] Enables reading of secondary PBR replacement textures in pixel shaders for games with programmable graphics pipelines."When set to false, an extra compute shader is used to preproces the secondary textures to make them compatible at an expense of performance and quality instead. This parameter must be set at launch to apply. The current support for this is limitted to draw calls with programmable shaders with Shader Model 1.0 only. Draw calls with Shader Model 2.0+ will use the preprocessing compute pass.
rtx.texturemanager.budgetPercentageOfAvailableVram	int	50			The percentage of available VRAM we should use for material textures. If material textures are required beyond this budget, then those textures will be loaded at lower quality. Important note, it's impossible to perfectly match the budget while maintaining reasonable quality levels, so use this as more of a guideline. If the replacements assets are simply too large for the target GPUs available vid mem, we may end up going overbudget regularly. Defaults to 50% of the available VRAM.
rtx.texturemanager.fixedBudgetEnable	bool	False			If true, rtx.texturemanager.fixedBudgetMiB is used instead of rtx.texturemanager.budgetPercentageOfAvailableVram.
rtx.texturemanager.fixedBudgetMiB	int	2048	256	32768	Fixed-size VRAM budget for replacement textures. In mebibytes. To use, set rtx.texturemanager.fixedBudgetEnable to True.
rtx.texturemanager.hotReload	bool	False			While a game is running, if a texture file is modified on a disk, it will be automatically reuploaded to GPU.
rtx.texturemanager.hotReloadRateMs	int	100			Amount of time to wait between filesystem OS events, for texture hot-reloading. In milliseconds.
rtx.texturemanager.neverDowngradeTextures	bool	False			Debug option to forcibly prevent uploading lower resolution data, if the texture already has been promoted to a high resolution.
rtx.texturemanager.samplerFeedbackEnable	bool	True			Enable texture sampler feedback. If true, a texture prioritization logic considers the amount of mip-levels that was sampled by a GPU while rendering a scene.(For example, if a texture is in the distance, it will have a lower priority compared to a texture rendered just in front of the camera).
rtx.texturemanager.showProgress	bool	False			Show texture loading progress in the HUD.
rtx.texturemanager.stagingBufferSizeMiB	int	96			Size of a pre-allocated staging (intermediate) buffer to use when sending a texture from a RAM to GPU VRAM. If a texture size exceeds this limit, it will not be considered for the texture streaming. In mebibytes.
rtx.timeDeltaBetweenFrames	float	0			Frame time delta in milliseconds to use for rendering. Setting this to 0 will use actual frame time delta for a given frame. Non-zero value allows the actual time delta to be overridden and is primarily used for automation to ensure determinism run to run without variance due to frame time fluctuations.
rtx.tonemap.colorBalance	float3	1, 1, 1			The color tint to apply after tonemapping when color grading is enabled for the tonemapper (rtx.tonemap.colorGradingEnabled). Values should be in the range [0, 1].
rtx.tonemap.colorGradingEnabled	bool	False			A flag to enable or disable color grading after the global tonemapper's tonemapping pass, but before gamma correction and dithering (if enabled).
rtx.tonemap.contrast	float	1			The contrast adjustment to apply after tonemapping when color grading is enabled for the tonemapper (rtx.tonemap.colorGradingEnabled). Values should be in the range [0, 1].
rtx.tonemap.curveShift	float	0			Range [0, inf). Amount by which to shift the tone curve up or down. Nonzero values will cause additional clipping.
rtx.tonemap.dynamicRange	float	15			Range [0, inf). Without further adjustments, the tone curve will try to fit the entire luminance of the scene into the range [-dynamicRange, 0] in linear photographic stops. Higher values adjust for ambient monitor lighting; perfect conditions -> 17.587 stops.
rtx.tonemap.exposureBias	float	0			The exposure value to use for the global tonemapper when auto exposure is disabled, or a bias multiplier on top of the auto exposure's calculated exposure value.
rtx.tonemap.finalizeWithACES	bool	False			A flag to enable applying a final pass of ACES tonemapping to the tonemapped result.
rtx.tonemap.maxExposureIncrease	float	5			Range [0, inf). Forces the tone curve to not increase luminance values at any point more than this value.
rtx.tonemap.saturation	float	1			The saturation adjustment to apply after tonemapping when color grading is enabled for the tonemapper (rtx.tonemap.colorGradingEnabled). Values should be in the range [0, 1].
rtx.tonemap.shadowContrast	float	0			Range [0, inf). Additional gamma power to apply to the tone of the tone curve below shadowContrastEnd.
rtx.tonemap.shadowContrastEnd	float	0			Range (-inf, 0]. High endpoint for the shadow contrast effect in linear stops; values above this are unaffected.
rtx.tonemap.shadowMinSlope	float	0			Range [0, inf). Forces the tone curve below a linear value of 0.18 to have at least this slope, making the tone darker.
rtx.tonemap.toneCurveMaxStops	float	8			High endpoint of the tone curve (in log2(linear)).
rtx.tonemap.toneCurveMinStops	float	-24			Low endpoint of the tone curve (in log2(linear)).
rtx.tonemap.tonemappingEnabled	bool	True			A flag to enable or disable the local tonemapper. Note this flag will only take effect when the global tonemapper is set to be used (as opposed to another option such as the local tonemapper).
rtx.tonemap.tuningMode	bool	False			A flag to enable a debug visualization to tune the tonemapping exposure curve with, as well as exposing parameters for tuning the tonemapping in the UI.
rtx.tonemappingMode	int	1			The tonemapping type to use, 0 for Global, 1 for Local (Default). Global tonemapping tonemaps the image with respect to global parameters, usually based on statistics about the rendered image as a whole. Local tonemapping on the other hand uses more spatially-local parameters determined by regions of the rendered image rather than the whole image. Local tonemapping can result in better preservation of highlights and shadows in scenes with high amounts of dynamic range whereas global tonemapping may have to comprimise between over or underexposure.
rtx.trackParticleObjects	bool	True			Track last frame's corresponding particle object.
rtx.translucentDecalAlbedoFactor	float	10			A global scale factor applied to the albedo of decals that are applied to a translucent base material, to make the decals more visible. This is generally needed as albedo values for decals may be fairly low when dealing with opaque surfaces, but the translucent diffuse layer requires a fairly high albedo value to result in an expected look. The need for this option could be avoided by simply authoring decals applied to translucent materials with a higher albedo to begin with, but sometimes applications may share decals between different material types.
rtx.translucentMaterial.animatedWaterEnable	bool	True			If enabled, draw calls in the AnimatedWater category and a translucent material will have their primary texcoordinates animated, and will also take a second sample from the normal map. Note that objects must be properly categorized as animated water to be rendered with this mode.
rtx.translucentMaterial.animatedWaterPrimaryNormalMotion	float2	0.05, 0.05			Velocity in UV space for the primary texture coordinate. This relies on Remix animation time, which will not respect any time warping performed by the game (so pause, slow mo, etc will not change animation speed).
rtx.translucentMaterial.animatedWaterSecondaryNormalLodBias	float	1			LoD bias to use when taking the second normal map sample. Values greater than 0 will cause the secondary normal map to be blurred, resulting in lower frequency waves.
rtx.translucentMaterial.animatedWaterSecondaryNormalMotion	float2	-0.03, -0.06			Velocity in UV space for the secondary texture coordinate. This relies on Remix animation time, which will not respect any time warping performed by the game (so pause, slow mo, etc will not change animation speed).
rtx.translucentMaterial.enableDiffuseLayerOverride	bool	False			A flag to force the diffuse layer on the translucent material to be enabled. Should only be used for debugging or development.
rtx.translucentMaterial.normalIntensity	float	1			An arbitrary strength scale factor to apply when decoding normals in the translucent material. Should only be used for debugging or development.
rtx.translucentMaterial.refractiveIndexScale	float	1			A scale factor to apply to the index of refraction for all translucent materials. The scale is clamped to [0.0, 3.0]. Should only be used for look development.
rtx.translucentMaterial.transmittanceColorBias	float	0			A bias factor to add to all transmittance color values in the opaque material. Should only be used for debugging or development.
rtx.translucentMaterial.transmittanceColorScale	float	1			A scale factor to apply to all transmittance color values in the translucent material. Should only be used for debugging or development.
rtx.translucentSpecularLobeSamplingProbabilityZeroThreshold	float	0.01			The threshold for which to zero translucent specular probability weight values.
rtx.translucentTransmissionLobeSamplingProbabilityZeroThreshold	float	0.01			The threshold for which to zero translucent transmission probability weight values.
rtx.uniqueObjectDistance	float	300	0		The distance (in game units) that an object can move in a single frame before it is no longer considered the same object. If this is too low, fast moving objects may flicker and have bad lighting. If it's too high, repeated objects may flicker. This does not account for sceneScale.
rtx.upscalerType	int	1			Upscaling boosts performance with varying degrees of image quality tradeoff depending on the type of upscaler and the quality mode/preset.
rtx.upscalingMipBias	float	0			Specifies a mipmapping level bias to add to all material texture filtering when upscaling (such as DLSS) is used. Mipmaps are determined based on how far away a texture is, using this can bias the desired level in a lower quality direction (positive bias), or a higher quality direction with potentially more aliasing (negative bias). Note that mipmaps are also important for good spatial caching of textures, so too far negative of a mip bias may start to significantly affect performance, therefore changing this value is not recommended
rtx.useAnisotropicFiltering	bool	True			A flag to indicate if anisotropic filtering should be used on material textures, otherwise typical trilinear filtering will be used. This should generally be enabled as anisotropic filtering allows for less blurring on textures at grazing angles than typical trilinear filtering with only usually minor performance impact (depending on the max anisotropy samples).
rtx.useBuffersDirectly	bool	True			When enabled Remix will use the incoming vertex buffers directly where possible instead of copying data. Note: setting the d3d9.allowDiscard to False will disable this option.
rtx.useDenoiser	bool	True			Enables usage of denoiser(s) when set to true, otherwise disables denoising when set to false. Denoising is important for filtering the raw noisy ray traced signal into a smoother and more stable result at the cost of some potential spatial/temporal artifacts (ghosting, boiling, blurring, etc). Generally should remain enabled except when debugging behavior which requires investigating the output directly, or diagnosing denoising-related issues.
rtx.useDenoiserReferenceMode	bool	False			Enables reference "denoiser" (~ accumulation mode) when set to true, otherwise uses a standard denoiser. The reference denoiser accumulates frames over time to generate a reference multi-sample per pixel contribution which should converge slowly to the ideal result the renderer is working towards. It is useful for analyzing quality differences in various denoising methods, post-processing filters, or for more accurately comparing subtle effects of potentially biased rendering techniques which may be hard to see through noise and filtering. It is also useful for higher quality artistic renders of a scene beyond what is possible in real-time.
rtx.useHighlightLegacyMode	bool	False
rtx.useIntersectionBillboardsOnPrimaryRays	bool	False
rtx.useLegacyACES	bool	True			Use a luminance-only approximation of ACES that over-saturates the highlights. If false, use a refined ACES transform that converts between color spaces with more precision.
rtx.useNewGuiInputMethod	bool	True			Disables the previous method for getting mouse/keyboard input and enables a new method which should be more reliable. If successful the old method will be deprecated. This setting can't be changed at runtime, so it must be set in a .conf file.
rtx.useObsoleteHashOnTextureUpload	bool	False			Whether or not to use slower XXH64 hash on texture upload. New projects should not enable this option as this solely exists for compatibility with older hashing schemes.
rtx.usePartialDdsLoader	bool	True			A flag controlling if the partial DDS loader should be used, true to enable, false to disable and use GLI instead. Generally this should be always enabled as it allows for simple parsing of DDS header information without loading the entire texture into memory like GLI does to retrieve similar information. Should only be set to false for debugging purposes if the partial DDS loader's logic is suspected to be incorrect to compare against GLI's implementation.
rtx.usePostFilter	bool	True			Uses post filter to remove fireflies in the denoised result.
rtx.useRTXDI	bool	True			A flag indicating if RTXDI should be used, true enables RTXDI, false disables it and falls back on simpler light sampling methods. RTXDI provides improved direct light sampling quality over traditional methods and should generally be enabled for improved direct lighting quality at the cost of some performance.
rtx.useRayPortalVirtualInstanceMatching	bool	True
rtx.useVertexCapture	bool	True			When enabled, injects code into the original vertex shader to capture final shaded vertex positions. Is useful for games using simple vertex shaders, that still also set the fixed function transform matrices.
rtx.useVertexCapturedNormals	bool	True			When enabled, vertex normals are read from the input assembler and used in raytracing. This doesn't always work as normals can be in any coordinate space, but can help sometimes.
rtx.useVertexCapturedTexcoords	bool	False			When enabled, vertex shader output texcoords always override input texcoords from the vertex declaration. Enable for games where the vertex shader applies meaningful UV transformations that should be used for ray tracing (e.g. animated UVs via shader constants).
rtx.useVirtualShadingNormalsForDenoising	bool	True			A flag to enable or disable the usage of virtual shading normals for denoising passes. This is primairly important for anything that modifies the direction of a primary ray, so mainly PSR and ray portals as both of these will view a surface from an angle different from the "virtual" viewing direction perceived by the camera. This can cause some issues with denoising due to the normals not matching the expected perception of what the normals should be, for example normals facing away from the camera direction due to being viewed from a different angle via refraction or portal teleportation. To correct this, virtual normals are calculcated such that they always are oriented relative to the primary camera ray as if its direction was never altered, matching the virtual perception of the surface from the camera's point of view. As an aside, virtual normals themselves can cause issues with denoising due to the normals suddenly changing from virtual to "real" normals upon traveling through a portal, causing surface consistency failures in the denoiser, but this is accounted for via a special transform given to the denoiser on camera ray portal teleportation events. As such, this option should generally always be enabled when rendering with ray portals in the scene to have good denoising quality.
rtx.useWhiteMaterialMode	bool	False			Override all objects' materials by white material
rtx.useWorldMatricesForShaders	bool	True			When enabled, Remix will utilize the world matrices being passed from the game via D3D9 fixed function API, even when running with shaders. Sometimes games pass these matrices and they are useful, however for some games they are very unreliable, and should be filtered out. If you're seeing precision related issues with shader vertex capture, try disabling this setting.
rtx.userBrightness.userBrightness	int	50			How bright the final image should be. [0,100] range.
rtx.userBrightnessEVRange.userBrightnessEVRange	float	3			The exposure value (EV) range for 'rtx.userBrightness' slider, i.e. how much of EV there is between 0 and 100 slider values.
rtx.validateCPUIndexData	bool	False
rtx.vertexColorIsBakedLighting	bool	True			If true, brightness contribution will be removed from the vertex color by dividing each component by the largest component.
rtx.vertexColorStrength	float	0.6	0	1	A scalar to apply to how strong vertex color influence should be on materials. A value of 1 indicates that it should be fully considered (though do note the texture operation and relevant parameters still control how much it should be blended with the actual albedo color), a value of 0 indicates that it should be fully ignored.
rtx.viewDistance.distanceFadeMax	float	500	0		The view distance based on the result of the view distance function to end view distance noise fading at (and effectively draw nothing past this point), only used for the Coherent Noise view distance mode.
rtx.viewDistance.distanceFadeMin	float	400	0		The view distance based on the result of the view distance function to start view distance noise fading at, only used for the Coherent Noise view distance mode.
rtx.viewDistance.distanceFunction	int	0			The view distance function, Euclidean is a simple distance from the camera, whereas Planar Euclidean will ignore distance across the world's "up" direction.
rtx.viewDistance.distanceMode	int	0			The view distance mode, None disables view distance, Hard Cutoff will cut off geometry past a point, and Coherent Noise will feather geometry out using a stable worldspace noise pattern (experimental).
rtx.viewDistance.distanceThreshold	float	500	0		The view distance to draw out to based on the result of the view distance function, only used for the Hard Cutoff view distance mode.
rtx.viewDistance.noiseScale	float	3			The scale per meter value applied to ther world space position fed into the noise generation function for generating the fade in Coherent Noise view distance mode.
rtx.viewModel.enable	bool	False			If true, try to resolve view models (e.g. first-person weapons). World geometry doesn't have shadows / reflections / etc from the view models.
rtx.viewModel.enableVirtualInstances	bool	True			If true, virtual instances are created to render the view models behind a portal.
rtx.viewModel.maxZThreshold	float	0			If a draw call's viewport has max depth less than or equal to this threshold, then assume that it's a view model.
rtx.viewModel.perspectiveCorrection	bool	True			If true, apply correction to view models (e.g. different FOV is used for view models).
rtx.viewModel.rangeMeters	float	1			[meters] Max distance at which to find a portal for view model virtual instances. If rtx.viewModel.separateRays is true, this is also max length of view model rays.
rtx.viewModel.scale	float	1			Scale for view models. Minimize to prevent clipping.
rtx.volumetrics.anisotropy	float	0	-1	1	The anisotropy of the scattering phase function (-1 being backscattering, 0 being isotropic, 1 being forward scattering).
rtx.volumetrics.atmosphereHeightMeters	float	30			Height of the atmosphere in meters, respects scene scale.
rtx.volumetrics.atmosphereInverted	bool	False			A flag to invert the rendering of the volumetric atmosphere if rtx.volumetrics.enableAtmosphere is enabled. Some games render the world upside down and that cannot be detected automatically, this setting can be used to correct that inversion for the volumetric atmosphere.
rtx.volumetrics.atmospherePlanetRadiusMeters	float	10000			Radius of the planet in meters, respects scene scale.
rtx.volumetrics.debugDisableRadianceScaling	bool	False			Disables the volumetric radiance scaling feature, this effectively sets the per light radiance scaling to 1.f. Useful when debugging issues when this feature is suspected. Do not ship your mod with this in the rtx.conf.
rtx.volumetrics.depthOffset	float	0.5			Depth offset to avoid volumetric light leaking.
rtx.volumetrics.enable	bool	True			Enabling volumetric lighting provides higher quality ray traced physical volumetrics, disabling falls back to cheaper depth based fog. Note that disabling this option does not disable the froxel radiance cache as a whole as it is still needed for other non-volumetric lighting approximations.
rtx.volumetrics.enableAtmosphere	bool	False			Enables a finite atmosphere in the volumetrics system. When false, the volumetric volume is assumed to reach to infinity in every direction, when true the volumetric volume will be limited to that a finite atmosphere controlled by parameters describing atmosphere height and its curvature via a planetary radius. This option should generally be enabled if volumetrics are used in outdoor settings as without a finite atmosphere infinite light sources such as the skybox and distant lights will not function properly.
rtx.volumetrics.enableFogColorRemap	bool	False			A flag to enable or disable remapping fixed function fox's color. Only takes effect when fog remapping in general is enabled. Enables or disables remapping functionality relating to the color parameter of fixed function fog with the exception of the multiscattering scale (as this scale can be set to 0 to disable it). This allows dynamic changes to the game's fog color to be reflected somewhat in the volumetrics system. Overrides the specified volumetric transmittance color.
rtx.volumetrics.enableFogMaxDistanceRemap	bool	True			A flag to enable or disable remapping fixed function fox's max distance. Only takes effect when fog remapping in general is enabled. Enables or disables remapping functionality relating to the max distance parameter of fixed function fog. This allows dynamic changes to the game's fog max distance to be reflected somewhat in the volumetrics system. Overrides the specified volumetric transmittance measurement distance.
rtx.volumetrics.enableFogRemap	bool	False			A flag to enable or disable fixed function fog remapping. Only takes effect when volumetrics are enabled. Typically many old games used fixed function fog for various effects and while sometimes this fog can be replaced with proper volumetrics globally, other times require some amount of dynamic behavior controlled by the game. When enabled this option allows for remapping of fixed function fog parameters from the game to volumetric parameters to accomodate this dynamic need.
rtx.volumetrics.enableHeterogeneousFog	bool	False			Enables a noise-driven heterogeneous fog approximation.
rtx.volumetrics.enableInPortals	bool	False			Enables using extra frustum-aligned volumes for lighting in portals. Note that enabling this option will require 3x the memory of the typical froxel grid as well as degrade performance in some cases. This option should be enabled always in games using ray portals for proper looking volumetrics through them, but should be disabled on any game not using ray portals. Additionally, this setting must be set at startup and changing it will not take effect at runtime.
rtx.volumetrics.enableInitialVisibility	bool	True			Determines whether to trace a visibility ray for Reservoir samples. Results in slightly less noise with the volumetric froxel grid light samples at the cost of a ray per froxel cell each frame and should generally be enabled.
rtx.volumetrics.enableReferenceMode	bool	False			Enables reference mode for volumetrics. This is very expensive, but allows for rendering engineers to test how close sampling approximations are to the real thing. This will not save.
rtx.volumetrics.enableSpatialResampling	bool	True			Indicates if spatial resampling should be used for volume integration. Spatial resampling allows for reuse of spatial information when picking froxel grid light samples similar to how ReSTIR works, providing higher quality light samples.
rtx.volumetrics.enableTemporalResampling	bool	True			Indicates if temporal resampling should be used for volume integration. Temporal resampling allows for reuse of temporal information when picking froxel grid light samples similar to how ReSTIR works, providing higher quality light samples. This should generally be enabled but currently due to the lack of temporal bias correction this option will slightly bias the lighting result.
rtx.volumetrics.enableTranslucentShadows	bool	False			Calculate coloured shadows from translucent materials (i.e. glass, water) in volumetric lighting. In engineering terms: include OBJECT_MASK_TRANSLUCENT into volumetric visibility rays.
rtx.volumetrics.fogRemapColorMultiscatteringScale	float	0.1	0		A value representing the scale of the fixed function fog's color in the multiscattering approximation. This scaling factor is applied to the fixed function fog's color and becomes a multiscattering approximation in the volumetrics system. Sometimes useful but this multiscattering approximation is very basic (just a simple ambient term for now essentially) and may not look very good depending on various conditions.
rtx.volumetrics.fogRemapMaxDistanceMaxMeters	float	40	0		A value controlling the "max distance" fixed function fog parameter's maximum remapping bound. Note that fog remapping and fog max distance remapping must be enabled for this setting to have any effect. In meters.
rtx.volumetrics.fogRemapMaxDistanceMinMeters	float	1	0		A value controlling the "max distance" fixed function fog parameter's minimum remapping bound. Note that fog remapping and fog max distance remapping must be enabled for this setting to have any effect. In meters.
rtx.volumetrics.fogRemapTransmittanceMeasurementDistanceMaxMeters	float	100	0		A value representing the transmittance measurement distance's maximum remapping bound. When the fixed function fog's "max distance" parameter is at or above its specified maximum the volumetric system's transmittance measurement distance will be set to this value and interpolated upwards. Note that fog remapping and fog max distance remapping must be enabled for this setting to have any effect. In meters.
rtx.volumetrics.fogRemapTransmittanceMeasurementDistanceMinMeters	float	20	0		A value representing the transmittance measurement distance's minimum remapping bound. When the fixed function fog's "max distance" parameter is at or below its specified minimum the volumetric system's transmittance measurement distance will be set to this value and interpolated upwards. Note that fog remapping and fog max distance remapping must be enabled for this setting to have any effect. In meters.
rtx.volumetrics.froxelDepthSliceDistributionExponent	float	2	0.0001		The exponent to use on depth values to nonlinearly distribute froxels away from the camera. Higher values bias more froxels closer to the camera with 1 being linear.
rtx.volumetrics.froxelDepthSlices	int	64	1	65535	The z dimension of the froxel grid. Must be constant after initialization.
rtx.volumetrics.froxelFireflyFilteringLuminanceThreshold	float	1000	0		Sets the maximum luminance threshold for the volumetric firefly filtering to clamp to.
rtx.volumetrics.froxelGridResolutionScale	int	8	1		The scale factor to divide the x and y render resolution by to determine the x and y dimensions of the froxel grid.
rtx.volumetrics.froxelMaxDistanceMeters	float	20	0		The maximum distance in world units to allocate the froxel grid out to. Should be less than the distance between the camera's near and far plane, as the froxel grid will clip to the far plane otherwise. The unit of measurement is meters.
rtx.volumetrics.initialRISSampleCount	int	32	1		The number of RIS samples to select from the global pool of lights when constructing a Reservoir sample. Higher values generally increases the quality of the selected light sample, though similar to the general RIS light sample count has diminishing returns.
rtx.volumetrics.maxAccumulationFrames	int	128	1	255	The number of frames to accumulate volume lighting samples over, maximum of 254. Large values result in greater image stability at the cost of potentially more temporal lag.Should generally be set to as large a value as is viable as the froxel radiance cache is assumed to be fairly noise-free and stable which temporal accumulation helps with.
rtx.volumetrics.noiseFieldDensityExponent	float	2	0		A exponent factor to apply to the noise field when mapping noise values to heterogeneous fog volume density. A value of 1 will result in a linear mapping whereas higher exponents will make the noise field more contrastey by reducing the influence of lower noise values.
rtx.volumetrics.noiseFieldDensityScale	float	1	0		A scale factor to apply to the noise field when mapping noise values to heterogeneous fog volume density. Higher values will make the fog more dense on average, whereas lower values will make the fog thinner on average.
rtx.volumetrics.noiseFieldGain	float	0.5	0		Visual Parameter: A scale factor in the range (0, infinity) to apply to the noise amplitude with each noise octave. Larger values typically make the noise field more jagged whereas lower values make the noise field smoother.
rtx.volumetrics.noiseFieldInitialFrequencyPerMeter	float	8	0		Visual Parameter: The initial frequency at which to sample the heterogeneous fog noise volume in terms of noise coordinate units per meter, respecting scene scale.
rtx.volumetrics.noiseFieldLacunarity	float	2	0		Visual Parameter: A scale factor in the range (0, infinity) to apply to the noise frequency with each noise octave. Values above 1 increase the frequency with each octave and thus "narrow" the noise faster, whereas values below 1 reduce the frequency each octave.
rtx.volumetrics.noiseFieldOctaves	int	2	1	8	Visual Parameter: Controls how much detail is in the heterogeneous fog noise volume. Detail will be fundamentally limited by the resolution of the froxel grid. Values must be in the range [1, 8]. Higher values will become significantly costly and have diminishing returns in terms of visual fidelity.
rtx.volumetrics.noiseFieldSubStepSizeMeters	float	10	0		Maximum substep size in world space for sampling the heterogeneous fog noise volume. Units are meters, respects scene scale.
rtx.volumetrics.noiseFieldTimeScale	float	0.5	0		A scale factor to apply to the time parameter of the noise field to use for heterogenous fog. Higher values cause the field to modulate faster, whereas lower values cause the field to modulate slower. Setting this scale to 0 will stop temporal noise modulation entierly.
rtx.volumetrics.restirFroxelDepthSlices	int	128	1	65535	The z dimension of the ReSTIR froxel grid. Must be constant after initialization.
rtx.volumetrics.restirGridGuardBandFactor	float	1.1			The scale factor for the restir grid guard band, which is an extended part of the viewing frustum for which we should calculate lighting information for, even though they are technically offscreen. This helps reduce noise in cases where the camera is moving around.
rtx.volumetrics.restirGridScale	int	4			The scale factor to divide the x and y froxel grid resolution by to determine the x and y dimensions of the ReSTIR froxel grid. Note that unlike the rtx.volumetrics.froxelGridResolutionScale option this is not dividing the render resolution, but rather is a scalar on top of the resulting froxel grid resolution after it is divided by the resolution scale.
rtx.volumetrics.singleScatteringAlbedo	float3	0.999, 0.999, 0.999	0, 0, 0	1, 1, 1	The single scattering albedo (otherwise known as the particle albedo) representing the ratio of scattering to absorption. While color-like in many ways this value is assumed to be more of a mathematical albedo (unlike material albedo which is treated more as a color), and is therefore treated as linearly encoded data (not gamma).
rtx.volumetrics.spatialReuseMaxSampleCount	int	8			The number of spatial samples to perform, generally higher is better, but the law of diminishing returns applies.
rtx.volumetrics.spatialReuseSamplingRadius	float	0.8			Search radius (in froxels) to search for neighbour candidates in spatial reuse pass.
rtx.volumetrics.temporalReuseMaxSampleCount	int	2	1	65535	The number of samples to clamp temporal reservoirs to, should usually be around the value: desired_max_history_frames * average_reservoir_samples.
rtx.volumetrics.transmittanceColor	float3	0.999, 0.999, 0.999	0, 0, 0	1, 1, 1	The color to use for calculating transmittance measured at a specific distance. Note that this color is assumed to be in sRGB space and gamma encoded as it will be converted to linear for use in volumetrics.
rtx.volumetrics.transmittanceMeasurementDistanceMeters	float	200	0		The distance the specified transmittance color was measured at. Lower distances indicate a denser medium. The unit of measurement is meters, respects scene scale.
rtx.volumetrics.visibilityReuse	bool	True			Determines whether to reuse visibility ray samples spatially across the reservoir. Results in slightly less noise with the volumetric froxel grid light samples at the cost of a ray per froxel cell each frame and should generally be enabled.
rtx.volumetrics.waterFogDensityThreshold	float	0.065			The fog density threshold for determining when to use physical volumetrics vs fixed function fog. Values below this threshold will use physical volumetrics, while values above will fall back to fixed function fog. This threshold was created specifically for Portal RTX's underwater fixed function fog.
rtx.wboitDepthWeightTuning	float	2			Allows for tuning the weighted blended OIT depth weight - which can be used to fine tune blending for various circumstances. This control has a side effect, larger numbers here can adversely affect brightness of emissive blended materials.
rtx.wboitEnabled	bool	True			Enables the new rendering mode for handling alpha blended objects. Changing this will trigger a shader recompile. The new mode improves rendering accuracy, especially in cases where there are many layers of transparent things being rendered.
rtx.wboitEnergyLossCompensation	float	4			Multiplier for the coverage term in the weighted blended OIT imlementation - allows for some configuration to recover energy loss from the technique. This is non physical, be careful overtuning
rtx.worldSpaceUiBackgroundOffset	float	-0.01			Distance along normal to offset objects rendered as worldspace UI, specifically for the background of screens.
rtx.xess.jitterScale	float	1			Multiplier for XeSS jitter intensity. Values > 1.0 increase jitter, < 1.0 reduce it. Can help reduce aliasing or temporal artifacts.
rtx.xess.logJitterSequenceLength	bool	False			Log the current jitter sequence length being used for XeSS. Useful for debugging swimming artifacts.
rtx.xess.minJitterSequenceLength	int	8			Minimum jitter sequence length for XeSS, even at low scaling factors.
rtx.xess.preset	int	2			Adjusts XeSS scaling factor, trades quality for performance.
rtx.xess.responsivePixelMaskClampValue	float	0.8			Maximum value to clamp responsive pixel mask to. XeSS 2.1 default is 0.8 to prevent aliasing artifacts.
rtx.xess.scalingJitterDamping	float	0.6			Additional jitter damping factor to reduce swimming artifacts. Lower values = less jitter.
rtx.xess.useOptimizedJitter	bool	True			Use XeSS-optimized jitter patterns and scaling. When disabled, uses the same jitter as other upscalers.
rtx.xess.useRecommendedJitterSequenceLength	bool	True			Use XeSS 2.1 recommended jitter sequence length calculation based on scaling factor. When disabled, uses the global cameraJitterSequenceLength setting.
rtx.zUp	bool	False			Indicates that the Z axis is the "upward" axis in the world when true, otherwise the Y axis when false.

Complex Types

RTX Option	Type	Default Value	Min Value	Max Value	Description
rtx.animatedWaterTextures	hash set				Textures on draw calls to be treated as "animated water". Objects with this flag applied will animate their normals to fake a basic water effect based on the layered water material parameters, and only when rtx.opaqueMaterial.layeredWaterNormalEnable is set to true. Should typically be used on static water planes that the original application may have relied on shaders to animate water on.
rtx.antiCulling.antiCullingTextures	hash set				Textures that are forced to extend life length when anti-culling is enabled. Some games use different culling methods we can't fully match, use this option to manually add textures to force extend their life when anti-culling fails.
rtx.baseGameModPathRegex	string				Regex used to redirect RTX Remix Runtime to another path for replacements and rtx.conf.
rtx.baseGameModRegex	string				Regex used to determine if the base game is running a mod, like a sourcemod.
rtx.beamTextures	hash set				Textures on draw calls that are already particles or emissively blended and have beam-like geometry. Typically objects marked as particles or objects using emissive blending will be rendered with a special method which allows re-orientation of the billboard geometry assumed to make up the draw call in indirect rays (reflections for example). This method works fine for typical particles, but some (e.g. a laser beam) may not be well-represented with the typical billboard assumption of simply needing to rotate around its centroid to face the view direction. To handle such cases a different beam mode is used to treat objects as more of a cylindrical beam and re-orient around its main spanning axis, allowing for better rendering of these beam-like effect objects.
rtx.cameraSequence.filePath	string				File path.
rtx.captureHotKey	virtual keys	CTRL,SHFT,Q			Hotkey to trigger a capture without bringing up the menu. example override: 'rtx.captureHotKey = CTRL, SHIFT, P'. Full list of key names available in `src/util/util_keybind.h`.
rtx.captureInstanceStageName	string	capture_{timestamp}.usd			Name of the 'instance' stage (see: 'rtx.captureInstances').
rtx.captureTimestampReplacement	string	{timestamp}			String that can be used for auto-replacing current time stamp in instance stage name. Note: Changing this value does not change the default value for rtx.captureInstanceStageName.
rtx.crashHotkey	virtual keys	CTRL,SHFT,ALT,K			The hotkey combination that triggers a deliberate crash when the crash hotkey feature is armed. Default is Ctrl+Shift+Alt+K. Only takes effect when rtx.enableCrashHotkey is True. This setting is not saved to config files but can be set manually in rtx.conf.
rtx.decalTextures	hash set				Textures on draw calls used for static geometric decals or decals with complex topology. These materials will be blended over the materials underneath them when decal material blending is enabled. A small configurable offset is applied to each flat/co-planar part of these decals to prevent coplanar geometric cases (which poses problems for ray tracing).
rtx.dynamicDecalTextures	hash set				Warning: This option is deprecated, please use rtx.decalTextures instead. Textures on draw calls used for dynamically spawned geometric decals, such as bullet holes. These materials will be blended over the materials underneath them when decal material blending is enabled. A small configurable offset is applied to each quad part of these decals to prevent coplanar geometric cases (which poses problems for ray tracing).
rtx.freeCam.keyMoveBack	virtual keys	S			Move back in free camera mode. Example override: 'rtx.rtx.freeCam.keyMoveBack = P'
rtx.freeCam.keyMoveDown	virtual keys	Q			Move down in free camera mode. Example override: 'rtx.rtx.freeCam.keyMoveDown = P'
rtx.freeCam.keyMoveFaster	virtual keys	LSHIFT			Move faster in free camera mode. Example override: 'rtx.rtx.freeCam.keyMoveForward = RSHIFT'
rtx.freeCam.keyMoveForward	virtual keys	W			Move forward in free camera mode. Example override: 'rtx.rtx.freeCam.keyMoveForward = P'
rtx.freeCam.keyMoveLeft	virtual keys	A			Move left in free camera mode. Example override: 'rtx.rtx.freeCam.keyMoveLeft = P'
rtx.freeCam.keyMoveRight	virtual keys	D			Move right in free camera mode. Example override: 'rtx.rtx.freeCam.keyMoveRight = P'
rtx.freeCam.keyMoveUp	virtual keys	E			Move up in free camera mode. Example override: 'rtx.rtx.freeCam.keyMoveUp = P'
rtx.freeCam.keyPitchDown	virtual keys	I			Pitch down in free camera mode. Example override: 'rtx.rtx.freeCam.keyPitchDown = P'
rtx.freeCam.keyPitchUp	virtual keys	K			Pitch up in free camera mode. Example override: 'rtx.rtx.freeCam.keyPitchUp = P'
rtx.freeCam.keyYawLeft	virtual keys	J			Yaw left in free camera mode. Example override: 'rtx.rtx.freeCam.keyYawLeft = P'
rtx.freeCam.keyYawRight	virtual keys	L			Yaw right in free camera mode. Example override: 'rtx.rtx.freeCam.keyYawRight = P'
rtx.geometryAssetHashRuleString	string	positions,indices,geometrydescriptor			Defines which hashes we need to include when sampling from replacements and doing USD capture.
rtx.geometryGenerationHashRuleString	string	positions,indices,texcoords,geometrydescriptor,vertexlayout,vertexshader			Defines which asset hashes we need to generate via the geometry processing engine.
rtx.gpuCrashHotkey	virtual keys	CTRL,SHFT,ALT,G			The hotkey that triggers a GPU crash when the crash hotkey feature is armed. Default is Ctrl+Shift+Alt+G.
rtx.hairCardTextures	hash set				Textures on draw calls that should be treated as alpha-tested hair cards. Tagged materials preserve fine texture detail, render as cutouts instead of alpha blends, and disable backface culling.
rtx.hideInstanceTextures	hash set				Textures on draw calls that should be hidden from rendering, but not totally ignored. This is similar to rtx.ignoreTextures but instead of completely ignoring such draw calls they are only hidden from rendering, allowing for the hidden objects to still appear in captures. As such, this is mostly only a development tool to hide objects during development until they are properly replaced, otherwise the objects should be ignored with rtx.ignoreTextures instead for better performance.
rtx.ignoreAlphaOnTextures	hash set				Textures for which to ignore the alpha channel of the legacy colormap. Textures will be rendered fully opaque as a result.
rtx.ignoreBakedLightingTextures	hash set				Textures for which to ignore two types of baked lighting, Texture Factors and Vertex Color. Texture Factor disablement: Using this feature on selected textures will eliminate the texture factors. For instance, if a game bakes lighting information into the Texture Factor for particular textures, applying this option will remove them. This becomes useful when unexpected results occur due to the Texture Factor. Consider an example where the original texture contains red tints baked into the Texture Factor. If a user replaces the texture, it will blend with the red tints, resulting in an undesirable reddish outcome. In such cases, users can employ this option to eliminate the unwanted tints from their replacement textures. Similarly, users can tag textures if shadows are baked into the Texture Factor, causing the replacing texture to appear darker than anticipated. Vertex Color disablement: Using this feature on selected textures will eliminate the vertex colors. Note, enabling this setting will automatically disable multiple-stage texture factor blendings for the selected textures. Only use this option when necessary, as the Texture Factor and Vertex Color can be used for simulating various texture effects, tagging a texture with this option will unexpectedly eliminate these effects.
rtx.ignoreLights	hash set				Lights that should be ignored. Any matching light will be skipped and not added to be ray traced.
rtx.ignoreTextures	hash set				Textures on draw calls that should be ignored. Any draw call using an ignore texture will be skipped and not ray traced, useful for removing undesirable rasterized effects or geometry not suitable for ray tracing.
rtx.ignoreTransparencyLayerTextures	hash set				Textures on draw calls that should not be stored in the transparency layer, when DLSS-RR is on. The transparency layer stores noise-free transparent objects which bypasses DLSS-RR denoising, but it has lower anti-aliasing quality. Transparent objects that have aliasing/flickering issues, like laser beams, can be added to this list to achieve better anti-aliasing quality.
rtx.lightConverter	hash set				Textures on draw calls that should spawn Remix effect lights. An effect light is a dynamic sphere light placed at the tagged draw call's geometry centroid; radius, intensity, color, and plasma-ball animation are controlled in the Runtime UI's Lighting > Effect Light section.
rtx.lightmapTextures	hash set				Textures used for lightmapping (baked static lighting on surfaces) in older games. These textures will be ignored when attempting to determine the desired textures from a draw to use for ray tracing.
rtx.neuralRadianceCache.cudaDllDepsDirectoryPath	string				Optional setting for specifying a custom directory path where the CUDA run-time dll dependencies are located.
rtx.nonOffsetDecalTextures	hash set				Warning: This option is deprecated, please use rtx.decalTextures instead. Textures on draw calls used for geometric decals with arbitrary topology that are already offset from the base geometry. These materials will be blended over the materials underneath them when decal material blending is enabled. Unlike typical decals however these decals have no offset applied to them due assuming the offset is already being done by whatever is passing data to Remix.
rtx.opacityMicromapIgnoreTextures	hash set				Textures to ignore when generating Opacity Micromaps. This generally does not have to be set and is only useful for black listing problematic cases for Opacity Micromap usage.
rtx.particleEmitterTextures	hash set				Objects rendered with these textures will emit particles that inherit the material of the object itself.
rtx.particleTextures	hash set				Textures on draw calls that should be treated as particles. When objects are marked as particles more approximate rendering methods are leveraged allowing for more effecient and typically better looking particle rendering. Generally any billboard-like blended particle objects in the original application should be classified this way.
rtx.playerModelBodyTextures	hash set				Textures on draw calls that identify the player model body/root position. Remix uses the tagged body instance as the anchor for filtering nearby player-model parts and for creating or positioning virtual player-model instances through portals.
rtx.playerModelTextures	hash set				Textures on draw calls that are part of the third-person player model, such as body, head, or held equipment. Tagged instances use the player-model ray mask so their primary-ray visibility, shadows, reflections, and portal-space virtual copies can be controlled independently from regular world geometry.
rtx.postfx.motionBlurMaskOutTextures	hash set				Disable motion blur for meshes with specific texture.
rtx.rayPortalModelTextureHashes	hash vector				Texture hashes identifying ray portals. Entries are interpreted as pairs of hashes; the list length must be even and will be clamped to the internal max portal count.
rtx.raytracedRenderTargetTextures	hash set				DescriptorHashes for Render Targets. (Screens that should display the output of another camera).
rtx.remixMenuKeyBinds	virtual keys	ALT,X			Hotkey to open the Remix menu. example override: 'rtx.remixMenuKeyBinds = CTRL, SHIFT, Z'. Full list of key names available in `src/util/util_keybind.h`.
rtx.singleOffsetDecalTextures	hash set				Warning: This option is deprecated, please use rtx.decalTextures instead. Textures on draw calls used for geometric decals that don't inter-overlap for a given texture hash. Textures must be tagged as "Decal Texture" or "Dynamic Decal Texture" to apply. Applies a single shared offset to all the batched decal geometry rendered in a given draw call, rather than increasing offset per decal within the batch (i.e. a quad in case of "Dynamic Decal Texture"). Note, the offset adds to the global offset among all decals drawn with different draw calls. The decal textures tagged this way must not inter-overlap within a batch / single draw call since the same offset is applied to all of them. Applying a single offset is useful for stabilizing decal offsets when a game dynamically batches decals together. In addition, it makes the global decal offset index grow slower and thus it minimizes a chance of hitting the "rtx.decals.maxOffsetIndex limit".
rtx.skyBoxGeometries	hash set				Geometries from draw calls used for the sky or are otherwise intended to be very far away from the camera at all times (no parallax). Any draw calls using a geometry hash in this list will be treated as sky and rendered as such in a manner different from typical geometry. The geometry hash being used for sky detection is based off of the asset hash rule, see: "rtx.geometryAssetHashRuleString".
rtx.skyBoxTextures	hash set				Textures on draw calls used for the sky or are otherwise intended to be very far away from the camera at all times (no parallax). Any draw calls using a texture in this list will be treated as sky and rendered as such in a manner different from typical geometry.
rtx.smoothNormalsTextures	hash set				Textures on draw calls whose geometry should have smooth normals generated on the GPU. This is useful for older D3D9 games where the geometry may be missing smooth normals, especially when using the VertexShader Capture mechanism. When a draw call matches, area-weighted smooth normals will be computed from the triangle mesh and used for ray tracing.
rtx.terrainTextures	hash set				Albedo textures that are baked blended together to form a unified terrain texture used during ray tracing. Put albedo textures into this category if the game renders terrain as a blend of multiple textures.
rtx.uiTextures	hash set				Textures on draw calls that should be treated as screenspace UI elements. All exclusively UI-related textures should be classified this way and doing so allows the UI to be rasterized on top of the ray traced scene like usual. Note that currently the first UI texture encountered triggers RTX injection (though this may change in the future as this does cause issues with games that draw UI mid-frame).
rtx.welcomeMessage	string				Display a message to the user on startup, leave empty if no message is to be displayed.
rtx.worldSpaceUiBackgroundTextures	hash set				Hack/workaround option for dynamic world space UI textures with a coplanar background. Apply to backgrounds if the foreground material is a dynamic world texture rendered in UI that is unpredictable and rapidly changing. This offsets the background texture backwards.
rtx.worldSpaceUiTextures	hash set				Textures on draw calls that should be treated as worldspace UI elements. Unlike typical UI textures this option is useful for improved rendering of UI elements which appear as part of the scene (moving around in 3D space rather than as a screenspace element).