Repository navigation
ReLimiter 4.0.0 replaces the pacing core. Every capped frame is now paced against one shared cadence, and ReLimiter chooses by itself where each frame is held: on the GPU where the game supports it, at the game's Present marker or Present call elsewhere. Frame generation needs no separate setup, and the settings panel shrinks to the few options most people use. Defaults are the recommended ones, so you should not need to tune anything. The default log is much quieter. Existing settings are migrated once at the first launch; see Settings migration. To go back to 3.3.5, see Rolling back to 3.3.5.
64-bit DirectX 12 with NVIDIA Reflex is the supported and tested configuration; other APIs with Reflex run the same pacer untested; games without Reflex and all 32-bit games get a plain frame-rate cap.
The Present-based route that games without Reflex and all 32-bit games use is retained and covered by unit tests but has not yet been validated in a game. Nothing validates DirectX 11, Vulkan, OpenGL, DirectX 9 or 32-bit pacing.
See the User Guide for how to use it, Frame Pacing for how the cadence, lead and output points work, and the Developer Reference for diagnostics, developer settings and capture files.
New pacing core
- One cadence for every output. Each frame gets a planned release time and an output target on a shared cadence. Late frames are never held; after a stall or a clearly late frame the cadence restarts from that frame instead of catching up with a burst of short frames.
- The lead covers 99% of frames. Each frame is released early enough for 99% of recent frames (plus 0.5 ms) to reach their hold on time, so far fewer frames arrive late and are shown unevenly. In CONTROL Resonant with frame generation this about halved stutter for about 3.5 ms more PC latency; in Deep Rock Galactic: Rogue Core it cut late frames from about 8% to 4% and jitter several times over for about 0.5 ms more.
- Long simulation frames no longer starve the GPU. When the GPU runs right at the cap, the lead also covers a game's rare long simulation frames, so one slow frame on the CPU no longer leaves the GPU waiting and every later frame late. This costs a few milliseconds of latency in such scenes; lighter scenes keep their shorter lead.
- The output point is chosen automatically from the game, graphics API, display mode, frame-generation state and what qualifies at runtime:
- GPU queue wait (64-bit, DX12, native Reflex markers, VRR, no frame generation): the GPU waits for the target before the frame is presented.
- FG input wait (64-bit, DX12, native Reflex markers, static frame generation): the GPU waits before each real frame enters frame generation.
- Marker hold: a CPU hold at the game's Present marker on other marker routes, for example DX11 with Reflex or Vulkan with Streamline PCL.
- Source only: no output hold, for Present-based pacing, idle caps and frame generation that has not qualified.
- Plain pacing status. One line under the FPS controls says what pacing is doing, for example
Smooth: frames are held on the GPU to an even cadenceorLearning the game's frame timing.... The technical lines (route, output and reason, placement, lead, cadence restarts and more) are under a collapsed Details node. - Source wait in the Reflex Sleep. In 64-bit games that use Reflex markers and call the Reflex Sleep, ReLimiter does its waiting inside that Sleep call, before the game reads input for the next frame. While ReLimiter paces the game, its own wait replaces the driver's Reflex Sleep; Reflex markers and the game's Reflex mode still reach the driver, and the driver's Sleep is used again whenever ReLimiter is not pacing.
- GPU wait timing. The GPU waits release each frame a fixed distance ahead of the next frame's heavy GPU work (or, without NVIDIA Reflex latency reports, its next Present call), so the frame's resume does not queue behind that work, and they step aside in games where the next frame's GPU work already queues behind the wait. The distance is the same in every scene, so a heavy section never leaves a wider margin behind for the rest of the session. A GPU wait holds a frame for at most 3 frame intervals; a frame whose target is further ahead is presented without the wait.
- Held frames are presented ahead of the next frame's GPU work. In 64-bit DirectX 12 games that render and present on different command queues (frame generation not presenting), a held frame's Present now goes ahead of the next frame's GPU work, which steadies frame times at a frame-rate cap. It applies only where ReLimiter's own checks show it is safe; the developer setting
gpu_wait_present_first=falseturns it off. - A held frame no longer delays the game's start two frames on. Where held frames are presented ahead of the next frame's GPU work (the entry above), a frame held on the GPU at a frame-rate cap is now released early enough that it does not push back the game's start of the frame after next, which showed as a saw-tooth in the frame-time graph. ReLimiter measures the timing it needs from the game and steps aside where the game's own timing shows the limit does not apply. The developer setting
gpu_wait_start_limit=falseturns it off. - Fixed-refresh displays snap the cadence to measured vblanks when the cap is within 2% of a whole number of refresh intervals; other caps follow the VRR rules. A display without VRR at game start is now recognised at the first check instead of being paced as VRR.
- G-SYNC detection. ReLimiter decides G-SYNC by the driver's own answer for the game's frames, the same one Reflex and DLSS Frame Generation use, and follows it while the game runs. Before, it read the flags of the display it found when the game created its swapchain, which say whether that display can do variable refresh, not whether the game's frames get it. The startup log no longer prints a G-SYNC state before any frame exists, and each change of the driver's answer is named in the default log.
- DX11 games with native Reflex markers use the marker route (64-bit addon, untested) instead of Present-based pacing. The route is chosen again after a graphics API change or a new swapchain.
- Background FPS, FG-Off Cap and OLED Care run on the same cadence without an output hold.
- Finer timer resolution. While it waits, ReLimiter asks Windows for its finest system timer resolution (usually 0.5 ms) for the game's process and releases it when the game closes. Other programs' timers are unaffected on Windows 10 2004 and later.
- [WIP] A queue-based pacer, on by default in 64-bit DirectX 12 games. ReLimiter now watches what the game's own GPU queue does every frame (how long it sits empty, how far ahead its work arrives, how long waits hold it) and sets the frame interval from that instead of from the driver's per-frame GPU time reports. It follows the queue that carries the frame's rendering, even where the game presents on a separate queue. Where the game already queues a marker of its own behind each piece of GPU work, ReLimiter reads those markers instead of adding its own, so measuring adds very little to the game's threads. In Phantom Blade Zero without a cap this raised the frame rate by about 7% and the 1% low by about 9% in a GPU-limited scene for 3 to 4 ms more PC latency, and by about 5% with the 1% low up about 10% with frame generation 2×; in a scene limited by the game's render thread the frame rate was 0.6% lower with slightly better 1% lows. Where that measurement is not available (a graphics API other than DirectX 12, or while too few frames could be measured) the same pacer runs on the driver's per-frame reports, untested outside DirectX 12 with Reflex. Where held frames are presented ahead of the next frame's GPU work and a game cannot hold its frame-rate cap while rendering a frame ahead, the lead no longer grows to cover the time a finished frame waits behind the held one, which lowered PC latency by about 6 ms in Phantom Blade Zero at the same frame rate, with frame pacing marginally less even there. Settings saved by earlier test builds move to the new defaults once. Where DLSS Frame Generation presents from its own thread (no hardware flip metering), ReLimiter now orders the game's render queue behind the generated frame's Present, releases it behind the presenter's own work, gives the real frame's Present room on the GPU and, at a frame-rate cap, holds the real frames to the cap's grid before frame generation. In Phantom Blade Zero with 2× frame generation this raised the 1% low from 48 to 70 fps without a cap (hitches 325 to 48 a minute, 0.7% less frame rate), from 56.5 fps with NVIDIA's limiter to 69.5 fps at a cap of 104 (hitches 69 to 19 a minute, about 5 ms more PC Latency than NVIDIA's limiter) and from 40 to 46 fps at a cap of 60 (hitches 8 to 5 a minute; about 10 ms more PC Latency than ordering the render queue alone, because the frames are held for the spread of the game's own frame times), and in Gears of War with flip metering hidden from 37 to 62 fps without a cap (4% less frame rate) and from 43 to 61 fps at a cap of 90 (2.3 ms more PC Latency than NVIDIA's limiter); it is untested at 3× and 4×, in other games and on a GPU without hardware flip metering.
- [WIP] Less work on the game's threads. Hotkeys are checked on a background thread every 8 ms instead of once per frame on a game thread, and ReLimiter's per-frame hooks no longer ask Windows which modules are loaded or take a COM reference to confirm that nothing changed. This matters most in scenes limited by the game's own threads, also when ReLimiter is not pacing.
- [WIP] No periodic background work without a reader. With the OSD off and no capture running, ReLimiter no longer runs its telemetry worker (it woke 200 times a second and polled DXGI frame statistics up to 1,000 times a second), its hardware monitor (six NVIDIA driver queries every second), its CSV writer and log flush wake-ups, or ReShade's overlay frame. Hotkeys keep working. The OSD's own readouts recompute only what is shown. Idle GPU-wait and readiness workers sleep until they have work. Once the OSD's DLSS items or the settings panel have asked for the driver profile, it is read again only when the driver's profile database changes, instead of every 10 seconds (each read loads the whole database).
- Frame splitting on G-SYNC displays is set once. With frame generation on a G-SYNC display, ReLimiter sent the driver its frame-splitting override every 2 seconds; it now sends it once and again only when the display or the frame generation state changes.
- [WIP] Frame generation after a loading screen, in games that present on another thread than their frame markers. In games such as Gears of War: E-Day, which send a frame's start marker on one thread and present the frame on another, frame generation's pacing no longer fails to engage after a loading screen. ReLimiter now pairs each Present with its own frame's marker, by the frame number the driver states for that Present, instead of with the latest marker, and a Present it cannot match is left unpaired rather than paired with a guess.
Defaults and settings
- No smoothing levels or pacing method. The Low, Medium and High levels and the Pacing method selector are gone; there is nothing to choose.
- Fixed pacing behavior. There are no settings for these; ReLimiter always works this way:
- The output point is always chosen automatically.
- While it paces a cap, ReLimiter's own wait paces the game in place of the driver's Reflex Sleep, which reduces long frames and jitter in some games and is timing-neutral in others.
- The source wait runs inside the Reflex Sleep call; it uses the frame-start marker while a game does not call the Reflex Sleep.
- The frame interval is the cap's interval.
- Developer settings are hidden unless
developer_settings=trueis set under[FrameLimiter]inrelimiter.ini(defaultfalse). They cover the pacing test mode, GPU Wait Probes, flip metering and the queue measurement keys. They sit under Advanced with a Reset to defaults button. While any of them differs from its default, the main view showsN developer setting(s) changed from the defaultswith a Reset button, even when the settings are hidden. Details are in the Developer Reference. - VSync override: Game (default) keeps the game's own setting; Off or On forces it.
- Settings save automatically, and existing caps and compatible preferences are carried forward.
- [WIP] Pacing preference (64-bit DirectX 12 games). A new setting below the pacing status with Lower latency, Balanced (the default, unchanged behaviour) and Smoother. Smoother, with DLSS frame generation 2x and no cap the GPU can hold, gives up about 3% frame rate for more even frames: in Phantom Blade Zero 3.5 fps (2.7%) for a 1% low 2.6 ± 0.6 fps higher, hitches down from 65 to 38 a minute and display jitter down from 1.09 to 0.86 ms, for 0.4 ms more latency; in Gears of War: E-Day 3.0 fps for jitter down from 0.95 to 0.67 ms and 1.1 ms more latency. It changes nothing with a cap the GPU can hold or without frame generation. Lower latency keeps less work waiting for the GPU: 2.2 ± 0.6 ms lower latency in Phantom Blade Zero with frame rate, 1% low and jitter unchanged; 0.8 ± 0.4 ms lower in Gears of War: E-Day for 0.6 fps less and about 10% more jitter. A developer key set away from its default still decides its own value.
Settings migration
Older configurations are updated once at the first launch, when ReLimiter rewrites relimiter.ini and writes config_version=6:
- Settings that no longer exist (see Removed) are ignored and dropped. Your caps (
target_fps,background_fps,fg_off_fps),pacing_preferenceand every other setting that still exists are kept. - Nothing in an old file enters a test mode:
pacing_test_modeis never set by the migration. - One log line (at the
infolevel) names the removed keys that held a value other than their old default, for most users onlyadaptive_cap=true. Nothing is logged for defaults. - An INI saved before
config_version=5also moves once to the new defaultsunified_queue_law=true,gpu_queue_probe=trueandgpu_queue_probe_source=1(the queue-based pacer). A new INI starts with the recommended defaults. dmfg_output_capis dropped too.
See Removed and migrated keys for the full list.
Frame generation
- Frame generation needs no separate setup. ReLimiter detects supported static DLSS FG / MFG and NVIDIA Smooth Motion automatically, adjusts the render target for the multiplier and paces real frames against the same cadence as every other output.
- FG input wait. On 64-bit DX12 with native Reflex markers and static frame generation, real frames are held before they enter frame generation once the FG input route has qualified at runtime. Until then frame generation runs with
source_onlyand the reasonfg_unqualified. Frame generation without a qualified FG input route no longer uses a CPU marker hold. - Frame generation that paces its own frames. Where frame generation presents its frames from its own thread and queue, as DLSS Frame Generation does when hardware flip metering is not in use, the FG input wait can hold them only once ReLimiter has ordered the game's render queue behind the generated frame's Present (see the queue-based pacer entry above). Until then the main view reads Capped: frame generation paces its own frames here (frames are not held) with the reason
fg_route_unsupported, instead of staying on Getting ready.... The cap still applies. - [WIP] Even frames where frame generation paces its own frames. Where DLSS Frame Generation presents from its own thread (no hardware flip metering), ReLimiter now also times the display of each of its frames itself, as hardware flip metering would: the frames of a group are shown one displayed interval apart instead of whenever the GPU reaches them. In Phantom Blade Zero the displayed frame-to-frame change falls from 1.1 to 1.7 ms to 0.2 to 0.3 ms at 2×, 3× and 4×, with the 1% low 7 to 30 fps higher, for between none and about 4 ms more latency. It acts only once the ordering above is established, does nothing with hardware flip metering, and can be turned off with
fg_present_ahead=0under[FrameLimiter]inrelimiter.ini. Tested in Phantom Blade Zero only, with the hardware's flip metering hidden; other games and GPUs without the hardware have not been tested yet. - No catch-up after a late frame with frame generation. When a real frame reaches frame generation late, for example after a game hitch, the next real frame is now held about one frame interval after it instead of following it closely, which frame generation would show as one short displayed frame. In CONTROL Resonant at 60 FPS with 2× the worst displayed error after a hitch dropped from about 5.6 to 1.7 ms. A frame is never held longer while the game's render thread is still waiting in its Present, because the next frame would then wait too.
- Lower latency in games that simulate a frame ahead. The FG input wait lead no longer counts the time a finished frame waits for the render thread to leave the previous Present, so it does not keep an extra frame queued between the game's simulation and render threads.
- A GPU wait lead that follows the game's load. In games whose next frame's GPU work queues behind the wait, the lead no longer measures ReLimiter's own release of the previous frame, so it falls again after a heavier scene instead of keeping the extra latency. Frames whose own late submissions decide when they are ready still count in full, so they are released early enough to be ready on time.
- Better compatibility with other add-ons. The FG input wait can qualify when other add-ons hook the DXGI factory or Streamline's swap chain, for example other ReShade add-ons or DXGI proxy DLLs. A Streamline plugin change during the process still requires a restart.
- Dynamic MFG keeps its own passthrough handling: the driver paces the game and the game's Reflex Sleep always reaches it. If automatic detection misses a game,
dynamic_mfg_passthrough=trueis a manual compatibility option. - Games that present on a different thread than their frame-start marker (for example Gears of War: E-Day) can use the GPU waits once PC latency collection (
native_pcl_enabled=true) has confirmed the hand-off with ETW frame IDs. Without collection these games keep their previous behavior.
OSD, frame pacing and logging
- Optional stall report. With
hang_report=trueReLimiter writesrelimiter_<exe>.hang.txtand.hang.dmpnext to the log when the game stops presenting frames (off by default; it costs nothing while off). - Frame Pacing and Jitter replace PQI, its Breakdown and Smoothness, and work without PC latency collection, also with DLSS Frame Generation. Frame Pacing (formerly Display Pacing) shows, over the last 5 seconds, the typical and slowest frame time, the average and worst change from one frame to the next (jitter), hitches, and animation error, release to display, GPU residence and CPU hold where they can be measured. Jitter is the one-line figure of that average change: green under 8% of the frame interval, yellow under 16%, red above. The heading names what is measured: displayed frames from PC latency collection (ETW), from DXGI frame statistics without frame generation, or from ReLimiter's flip gate where DLSS Frame Generation presents from its own thread; with hardware flip metering, the real frames entering frame generation, because the generated frames are placed after ReLimiter and are not measured. Other frame generation is measured only with PC latency collection, and the readings say so. An INI or OSD preset that had PQI or Smoothness on gets Jitter on, and the old keys
osd_show_pqi,osd_show_pqi_breakdownandosd_show_smoothnessare dropped. The 1% Low and 0.1% Low tooltips now say that with frame generation they are the real-frame figure multiplied by the multiplier, an estimate of the displayed frames. A DXGI display time earlier than the frame's Present call, or not after the previous frame's display, leaves the frame unmeasured; Windows reports such times for most frames when it composes the game window (for example a game scaled by display scaling), and they used to show as long frames. - OSD anchors and OLED Care. The OSD has inward-facing anchors and clockwise corner cycling. OLED Care offers manual and idle activation, with keyboard, mouse and XInput activity detection.
- Quieter default log. At the default
log_level=warn,relimiter_<GameName>.logrecords only warnings and errors: something failed, data was lost, an INI value was invalid, or a developer setting is on. Messages that report normal events (device and swapchain capture, display and VRR detection, the first Reflex marker, route changes, Dynamic MFG passthrough, PC latency session lines and similar) are recorded atinfolevel, and the NvAPI marker census atdebug. Turn on Advanced Logging (info) before reproducing a problem. - Telemetry Logging writes two capture families,
relimiter_pacing_*andrelimiter_pacing_events_*; see Telemetry & Logging. The offlineanalyze_pacing.pyanalyzer reads them. Native PC latency event loss now marks a 2 s window instead of disabling measurement for the rest of the session.
Fixes
- The FG input wait can qualify when other add-ons hook the DXGI factory or Streamline's swap chain.
- Frame generation input wait keeps its route after a Streamline binding change instead of rejecting every input for the rest of the session.
- Frame generation caps no longer run below the cap on VRR. Low framerate compensation was judged on the rendered frame rate instead of the frame rate the display receives. With a 30 Hz VRR floor, a cap of 30 rendered frames per second or fewer (60 FPS with 2×, 90 with 3×, 120 with 4× frame generation, or less) could be rounded up to whole refreshes: a 60 FPS cap with 2× ran at 55 FPS on a 165 Hz display. It is now judged on the displayed frame rate. A cap of exactly 30 FPS is no longer treated as below a 30 Hz floor either.
- PC Latency with DLSS Frame Generation is measured on the real frame. The generated frame was labelled real, so PC Latency and the real-frame telemetry described the generated frame shown about half an interval earlier. PC Latency now updates about one displayed frame after the display it describes.
- Frame generation turned on while uncapped is recognized. With Streamline compatibility (the default), DLSS Frame Generation enabled while no cap was set was never confirmed as presenting: the OSD showed it off, and a cap set afterwards paced the real frames at the full cap until frame generation was switched off and on again. Seen in Phantom Blade Zero. ReLimiter also keeps reading Reflex latency reports while uncapped with frame generation, so its diagnostics stay current.
- Hook and device lifetime fixes and shutdown safeguards.
- A launch hang is fixed. When a game, launcher or driver created and released a second Direct3D 12 device while the game was running (for example on a second graphics card), the game could freeze at the moment the device was released, with ReLimiter loaded. ReLimiter no longer takes references on the game's device wrapper at all: it works on the underlying device, and its device create and release handling ignores devices that are not the game's without waiting for the game's rendering.
- [WIP] The pacer no longer fails to engage after some launches. ReLimiter now has its own native Present entry that overlays and other add-ons cannot remove, so a launch in which another tool took over the Present call no longer leaves the pacer idle.
- [WIP] Safer start-up. Hooks are installed in batches, so the game's threads are frozen for fewer and shorter moments, from a protected installer thread that other tools cannot suspend (
hook_installer_thread=falseinrelimiter.initurns the thread off for a game that does not tolerate it; it is a compatibility switch, not a tuning option). ReLimiter also writes a start-up evidence file and keeps the previous log asrelimiter_<exe>.prev.log. - [WIP] GPU wait gate fixes. No GPU wait is queued before the thread that signals it is running, and a removed graphics device no longer leaves that thread spinning.
- [WIP] Black screen with REFramework is fixed. In Resident Evil Requiem with REFramework the game kept running with a black screen: ReLimiter kept calling a Present hook REFramework had already moved, and REFramework then skipped every frame. ReLimiter now calls whatever Present the game's swap chain uses at that moment, and it never patches another mod's hook.
- [WIP] Lower latency with frame generation where a game splits its frame across GPU queues. In Resident Evil Requiem with DLSS Frame Generation at the GPU limit, ReLimiter followed a GPU queue that does only a small part of each frame, took its idle time for a GPU short of work, and never held a frame back: two frames waited in the queue and PC latency was about 27 ms higher than with Reflex alone. ReLimiter now checks every frame that the queue it follows is the one the frame finishes on, and otherwise paces from the driver's reports. In Requiem PC latency drops by about 22 ms with the same frame rate and steadier frame pacing.
- [WIP] Frame generation in Auto mode, and the right multiplier when ReLimiter missed the game's frame generation settings. ReLimiter now reads whether DLSS Frame Generation is generating, and how many frames, from what Streamline tells the driver every frame. Games that set frame generation to Auto, such as Fatekeeper, now get frame generation pacing; before, it never engaged. A game whose frame generation settings ReLimiter did not see is capped with its real multiplier: a game generating 3x was capped as 2x. When frame generation stops generating but stays switched on (for example at the end of a Gears of War: E-Day benchmark pass), the cap is no longer divided by the multiplier. Frame generation is also recognized within a fraction of a second instead of three seconds.
- [WIP] No lasting extra latency after a pause menu with frame generation at the GPU limit. In Resident Evil Requiem with DLSS Frame Generation and the GPU as the limit, a trip to the pause menu could leave ReLimiter holding frames that the GPU had no time for. That built a queue that stayed, and PC latency remained 3 to 5 ms above Reflex alone. ReLimiter no longer holds a frame once its budget for holds is used up. In Phantom Blade Zero with 2x frame generation and no cap, this also gives about 3.5% more frame rate with the same frame pacing.
- [WIP] ReLimiter loads again in games that release their first Direct3D device at start-up. ReShade unloads its add-ons when a game releases its last device and loads them again with the next one. After a launch that ended during start-up (a crash, or the game closed while it was still loading), ReLimiter stayed registered through that unload, and ReShade then refused to load it ("Failed to register add-on, because it provided an invalid module handle!"): the game ran without ReLimiter. Seen in Dragon Age: The Veilguard.
- [WIP] No repeating short-long frame pattern at a cap with frame generation. In Dragon Age: The Veilguard with DLSS Frame Generation at its automatic VRR cap, ReLimiter could release real frames early in a pattern that repeated every five or six frames and lasted for many seconds, so displayed frames alternated between short and long. A held frame that only fills time the GPU would spend waiting at the cap anyway no longer counts against ReLimiter's hold budget, so a shortfall left over from a heavy moment is repaid within a few frames instead of moving frames off their slots for seconds.
- [WIP] Frame generation holds its cap after a heavy moment. In Dragon Age: The Veilguard with DLSS Frame Generation at its automatic VRR cap, ReLimiter could keep frames waiting for longer than the game allows after a heavy moment: frame generation returns the game's next Present only once the frame before it has been released, and the game starts its next frame right after that, so each long wait delayed the next start. For about 20 seconds the game then ran at 68 instead of 78 fps, with about 15 ms more latency. ReLimiter now ends each wait early enough for the game's next start, measured from the game's own frame times, and does nothing where those times show the game does not wait (Gears of War: E-Day, Phantom Blade Zero, CONTROL and Resident Evil Requiem run a frame ahead).
- [WIP] Frame generation pacing in 007 First Light. With DLSS Frame Generation on, ReLimiter stayed on "Getting ready..." and never held frames. Before each frame the game checks its swap chain with a test call that presents nothing. ReLimiter took that check for the frame's Present, so the real Present that followed could not be matched to its frame. Test calls are now ignored, and the frame goes to the Present that shows it.
- [WIP] A heavy moment no longer keeps latency up for minutes where few frames can be timed. ReLimiter keeps a lead long enough for a game's rarest slow frames, remembered for about 2,000 frames. That memory advanced only on frames whose timing it could use, so in a game where few qualify (Resident Evil Requiem with frame generation) a pause menu's slow frames kept the lead about 13 ms longer for minutes of play. The memory now advances on every frame, and frame generation keeps its own, apart from the one used without it.
- [WIP] Pacing in Cyberpunk 2077. With DLSS Frame Generation on, ReLimiter stayed on "Getting ready..." and never held frames; without it, frames were held on the CPU instead of on the GPU. The game hands each frame's Present to whichever of its worker threads is free, and ReLimiter expected every frame on the thread that presented the first. Frames are now followed by who they are, whatever thread presents them.
- [WIP] Smooth pacing on every launch without frame generation. In Cyberpunk 2077 without DLSS Frame Generation, about one launch in three kept frame-to-frame jitter at the level of NVIDIA's own limiter for the whole session, alt-tabbing included. ReLimiter's guard against ending a hold inside the next frame's GPU work waited for proof that it could step aside, and its own limit kept that proof from ever arriving: every frame reached its wait too late to be held. The guard now steps aside unless it sees the next frame's GPU work running beside the wait, and comes back at once when it does.
- [WIP] Dynamic frame generation is named on the OSD. With DLSS Frame Generation in Dynamic mode the frame generation line reads "Dynamic", and the pacing summary says that frame generation paces its own frames there instead of giving a generic reason.
- [WIP] No extra latency after a loading screen. In Cyberpunk 2077 with DLSS Frame Generation, two slow frames while the benchmark's scene loaded kept ReLimiter's lead at its limit for the first 25 seconds, with 15–18 ms more PC latency; without frame generation, loading-screen frames raised it again after an alt-tab. The lead that covers a game's rarest slow frames now learns only from frames ReLimiter started on time, weighs each one with the GPU time of its own scene, and leaves out frames no lead could have covered.
Changed
- Pacing test mode (developers). A new developer setting,
pacing_test_mode(needsdeveloper_settings=true), says who paces, for comparison captures:off(default, ReLimiter paces),reflex_only(ReLimiter paces nothing and the game's own Reflex runs) anddriver_limiter(the cap goes to NVIDIA's Reflex driver limiter and ReLimiter holds nothing; where the limiter cannot apply, the game runs as it is and the pacing state saysdriver_limiter_unavailable). It is never entered automatically, and an old INI never sets it. - Pacing summary. While a test mode is on, the main view names it instead of the usual pacing line.
Removed
- Settings and INI keys. The Pacing method selector (
pacing_method), the GPU smoothing allowance (gpu_present_gate_slack_us), the Frame-Time Adaptation controls (adaptive_smoothing,smoothing_percentile,smoothing_window,smoothing_release_speed,smoothing_bias_us),gpu_present_gate_mode,gpu_present_gate_max_delay_us,estimator_a_mode,estimator_a_fixed_reserve_us,native_arrival_predictor_mode,presentation_gate_location,adaptive_deadline_reserve_mode,gpu_readiness_observer,reflex_pre_sleep_pacing,reflex_gpu_combined,gpu_present_gate_phase_controller,gpu_present_gate_hold,marker_gate_bypass,adaptive_cycle_trial,ready_present_*,readiness_phase_*anddmfg_output_cap. ReLimiter ignores old keys and drops them when it rewrites the INI. - Pacing settings of earlier 4.0 test builds. Adaptive cap (with its fit choice, OSD line and
Show on OSD), Smoothing on or off, Output override, Bypass Reflex Sleep, Source placement, Driver low latency off, Marker forward order, the lead coverage, lead spike floor and FG late-frame spacing switches, GPU queue wait render queue, GPU wait release headroom, GPU wait A/B blocks, GPU-paced cadence, the stall injector, the measurement experiments (the GPU start and priority probes, the presenter probe, the every-frame Sleep status) and the pacer's own on/off switch no longer exist as settings or INI keys. ReLimiter always behaves as these did at their defaults, with the Adaptive cap off. An INI that still has them is read once, the keys are ignored and dropped (configuration version 6; see Settings migration), and nothing in it enters a test mode. - The earlier pacing mechanisms of the 4.0 test builds. The overload pause (the panel message
Hold off: overload), the render handoff limit, the pre-Sleep placement with its learned margin (the placementpre_sleep), the Adaptive cap with its period steps and OSD line, GPU-paced cadence, the held GPU floor and rhythm, the native present hold, the stall injector and the measurement experiments are gone, with the code behind them. ReLimiter paces as these did at their defaults. The pacing capture rows (relimiter_pacing_*) lose the seven columns only these mechanisms filled (predicted_render_us,governor_step,governor_interval_us,plan_signal_advance_us,pre_sleep_margin_us,gpu_first_submit_qpcandgpu_start_qpc), and the events file no longer writes the event typesstall_injected,governor_stepandrung_feasibility; earlier captures still analyze. - Experimental pacing paths: Pace before Reflex Sleep, the combined Bounded GPU + pre-Reflex mode, the GPU deadline phase controller, the CPU Present hold, Bypass CPU marker hold and the tier readout on the Limiter OSD line.
- Legacy CSV families. The seven older capture families (
relimiter_frames_,relimiter_pcl_,relimiter_timeline_,relimiter_presents_,relimiter_present_associations_,relimiter_provenance_,relimiter_gpu_observations_) and the scripts that read them are gone. Telemetry Logging writes onlyrelimiter_pacing_*andrelimiter_pacing_events_*. Old captures remain readable with older versions of the scripts from version control. - MCP live debugging: the
RELIMITER_ENABLE_MCPbuild option, the live telemetry producer and the stdio bridge are gone.
Known limitations
- The GPU waits (GPU queue wait and FG input wait) need the 64-bit addon, DX12 and native Reflex markers. The GPU queue wait without frame generation also needs a VRR display.
- Only 64-bit DirectX 12 with NVIDIA Reflex is tested live with the new pacing core. Not tested: the Present-based fallback (games without Reflex, all 32-bit games), DX11, Vulkan and OpenGL games, fixed-refresh (non-VRR) displays and Dynamic MFG. Compatibility can vary between games, particularly older Vulkan titles.
- Frame generation on Vulkan is not held after the source wait (
source_only, reasonapi). The cap and the frame generation multiplier apply, but the FG input wait needs DX12, so real frames reach frame generation with the game's own frame-time variation. This can look uneven when the game is close to its GPU limit. - Telemetry Logging records frame rows only in DXGI games (DX10, DX11, DX12). In Vulkan, OpenGL and DX9 games the
relimiter_pacing_file has only its header; the events file is still written. - ReLimiter cannot remove shader-compilation, loading or other isolated game stalls, and no setting guarantees that every displayed frame meets its target.
- Cross-thread games (frame-start marker and Present on different threads) need PC latency collection to use the GPU waits; see Optional PC Latency Measurement.
- Frame generation switched on in the game takes a few moments to qualify; until then nothing is held (
fg_unqualified). - Frame generation that paces its own frames is held only while ReLimiter's ordering of the render queue holds (
source_only, reasonfg_route_unsupporteduntil then). DLSS Frame Generation does this when hardware flip metering is not in use: it presents from its own thread and queue. ReLimiter orders the game's render queue behind the generated frame's Present and, at a cap, holds the real frames once that is established; until then, and wherever it cannot be established, the cap and the multiplier apply and real frames reach frame generation with the game's own frame-time variation. At 3× and 4× DLSS Frame Generation presents the first generated frame before it lets the render queue go, so ReLimiter adds no wait of its own there and follows the frames; the hold acts as at 2×. This is tested at 2× in Phantom Blade Zero and Gears of War and at 3× and 4× in Phantom Blade Zero, with the hardware's flip metering hidden; GPUs without hardware flip metering and other games have not been tested yet.
Rolling back to 3.3.5
- Close the game.
- Download
relimiter.addon64(andrelimiter.addon32for 32-bit games) from the 3.3.5 release and replace the 4.0.0 files next to the ReShade DLL. - Keep
relimiter.ini. 3.3.5 reads the settings it knows, such as the cap, the background and FG-off caps, the OSD layout and keybinds, uses its own defaults for the rest and leaves the 4.0.0 keys in the file. To start 3.3.5 from its defaults instead, deleterelimiter.inibefore launching the game. - Updating to 4.0.0 again later keeps the file: it still records
config_version=6, so the one-time migration does not run again, and keys 4.0.0 no longer uses are dropped.