Optimize Windows. Track every frame. Keep every change reversible.
A free, open-source Windows optimizer for gamers. Apply smart performance profiles, reduce background load, monitor FPS, 1% lows, frame time, CPU, GPU, RAM and temperatures, and restore the exact settings you started with.
🌐 Website · ⬇️ Download SysTuneX · Latest release · SHA-256 · Report an issue
- 🎮 Gaming optimizer: competitive FPS, battle royale, open-world, racing, streaming and maximum-performance profiles.
- 📈 Your performance dashboard: enable only the readings you want—FPS, 1% low, frame time, CPU/GPU load and temperature, memory, fan and process count.
- 🪟 Compact readout: the same numbers in a small always-on-top window, one keypress away (Ctrl+Shift+M) — over borderless windowed games, without touching the game.
- ⚡ Game Mode: temporarily stops safe background services, raises the power scheme and restores the session when you are done.
- 🔎 Measure, do not guess: compare configuration before and after, watch frame-time behaviour and see real errors.
- ↩️ Exact rollback: SysTuneX records the real previous state before supported changes instead of writing an invented "default".
- 🛡️ Built with anti-cheat in mind: the frame counter uses Windows ETW and does not inject code into the game.
Full power, honest limits. SysTuneX can help remove bottlenecks and improve consistency, but no optimizer can guarantee the same FPS gain on every PC. The monitor is a configurable dashboard with a small always-on-top companion window — not an in-game overlay, so it cannot draw over exclusive fullscreen.
Windows tuning tools usually fall into one of two categories:
- one-click optimizers that do not tell you what they changed
- giant collections of registry tweaks copied from old gaming guides
SysTuneX takes a different approach.
Record before write.
Before SysTuneX changes a registry value, Windows service, DNS configuration, power scheme or boot option, it records the actual previous state.
Rollback restores your previous configuration, not an invented "default".
No undocumented magic tweaks. No silent failures. No pretending that every machine benefits from the same settings.
Go to the:
Download:
SysTuneX.exe
SysTuneX is published as a self-contained win-x64 single-file executable.
You do not need to install .NET.
Every release ships SHA256SUMS.txt beside the executable.
Get-FileHash .\SysTuneX.exe -Algorithm SHA256That number should match the one in SHA256SUMS.txt — and the one printed in the public build
log that produced the file. See Trust and safety for why that second check is
the one that actually proves something.
SysTuneX asks for elevation on launch. It cannot do its job without it: the registry keys it writes
live under HKEY_LOCAL_MACHINE, changing a service's start type goes through the service control
manager, and the frame counter needs an Event Tracing session. All three refuse a standard token.
Windows SmartScreen will warn, because the executable is not code-signed. The section below explains exactly what that warning means and how to check the file yourself rather than taking anyone's word for it.
You are about to run an unsigned executable as administrator on your own machine. That is a real thing to be careful about, and "it's fine, trust me" is not an answer. Here is what you can actually check.
A code-signing certificate that stops SmartScreen warning on day one is an EV certificate — several hundred dollars a year, tied to a registered company. SysTuneX is a free tool with no company behind it. Signing is worth doing and is not ruled out; it has simply not happened yet.
Worth being precise about what a signature would and would not tell you: it proves the file came from whoever holds the certificate and has not been altered since. It says nothing about whether the program is safe. Plenty of signed software is hostile. The checks below tell you more than a signature would.
The executable is not built on anyone's laptop. Every release is built by GitHub Actions, in public, from a commit you can read:
- Open the Actions tab and find the run for the release tag.
- The Checksum step prints the SHA-256 of the file it just built, into a log nobody can edit after the fact.
- Compare that to
Get-FileHashon your download and toSHA256SUMS.txt.
If all three agree, the file on your disk is the one that machine built from that source. Nobody — including whoever controls the release page — can substitute a different binary without the numbers disagreeing.
You can also build it yourself and compare; see Build from source.
The warning says "Windows protected your PC" and hides the run button behind a link. That is the default for any executable without an established reputation — it is a statement about how many people have run this file, not about what the file does.
More info → Run anyway. If you would rather not, verify the checksum first, or upload the file to VirusTotal and see what seventy engines make of it.
Every change SysTuneX makes is recorded before it is made and can be undone from the change journal — that is the rule the whole codebase is built around, and there are tests that fail if it is broken. Specifically, it writes to:
| What | Where | Undo |
|---|---|---|
| Tweaks | Registry values under HKLM and HKCU |
Previous value restored exactly, or deleted if it did not exist |
| Services | Start type via the service control manager | Original start type and running state restored |
| Power | Active power scheme | Previous scheme restored |
| Network | DNS servers, hosts file | Previous servers or DHCP restored; hosts entries removed |
| Cleanup | Temporary files, caches, crash dumps | Not undoable — files are deleted, and the app says so before doing it |
It does not install a driver, a service, or a background agent. It does not phone home; there is no telemetry and no network call except the DNS latency test you start yourself. Closing the app leaves nothing running except the tray icon, if you asked for one.
That is the point of it being open. The parts worth reading, in order: TweakEngine for how a
change is journalled before it is written, BackupService for what the journal holds, and the
catalogs under src/SysTuneX.Core/Tweaks/ for every registry value the app will ever touch —
there is no hidden list.
Security reports go through SECURITY.md, privately, rather than a public issue.
| Area | What SysTuneX does |
|---|---|
| Dashboard | Live CPU and memory monitoring, tuning status, Quick Optimize and full restore |
| Monitor | Frame rate with its 1% low and frame time, CPU and GPU load and temperature, memory — measured without touching the game, and only what you tick. Ctrl+Shift+M puts the same numbers in a small window above everything else |
| Profiles | Ready-made tuning profiles for different gaming and workload scenarios |
| Gaming | Game Bar, Game DVR, fullscreen optimizations, mouse acceleration, CPU scheduling, PCIe link power saving, accessibility shortcuts and more |
| Windows 11 | VBS, HVCI, hypervisor, Recall, Copilot, widgets, search features and other build-aware settings |
| Services | Safe service tuning with the original startup configuration recorded before changes |
| Privacy | Telemetry and its scheduled tasks, advertising ID, activity history, suggestions, location, clipboard sync and optional telemetry hosts blocking |
| Network | Nagle tuning, network throttling and DNS latency testing |
| Cleanup | Temporary files, update caches, crash dumps, shader caches, thumbnails and other disposable data |
| Game mode | One switch that stops background services, raises the power scheme and frees memory — and undoes all of it |
| Automation | Game mode follows the game, or a schedule, without either one undoing what you switched on by hand |
| Sensors | GPU temperature, load and fan through NVML and ADL; CPU temperature from the ACPI thermal zone where firmware exposes one |
| Search | One box across every tweak, service and cleanup target — it navigates to the page and filters it down to the result |
| Tray | Live counters on hover and the game mode switch in the menu |
| Appearance | Follows the Windows light/dark setting by default, or pin light or dark by hand; Mica, Acrylic or plain backdrop |
| Language | English, Russian and Ukrainian — the whole interface, including every tweak, service and profile with its description |
| Before/after | Record the machine either side of a change and see exactly what moved |
| Diagnostics | Persistent logs, verbose logging and a complete diagnostic report |
| Change log | Full history of recorded changes with individual or complete rollback |
SysTuneX includes workload-specific profiles instead of applying the same configuration to every PC.
| Profile | Focus |
|---|---|
| 🎯 Competitive FPS | Minimum input and background latency |
| 🏆 Battle Royale | Network latency and asset-streaming workloads |
| 🌍 Open World & RPG | Long sessions, CPU availability and reduced background I/O |
| 🏎️ Racing & Simulation | Frame-time consistency and latency |
| 🎥 Streaming & Recording | Gaming performance without starving OBS or capture workloads |
| 🚀 Maximum Performance | Includes advanced changes for users who understand the trade-offs |
Profiles automatically skip tweaks that do not apply to the current Windows build.
Advanced changes are never silently mixed into normal safe optimization.
One switch on the dashboard. It stops the background services the catalog grades as safe, raises the power scheme and frees memory.
It is deliberately not "apply a profile under another name". A profile writes registry values that survive a reboot and are undone from the change journal. Game mode only does things that can be undone immediately: services are stopped, not disabled, so their start type is untouched and the next boot is exactly as it was, and the previous power scheme is recorded and put back. Nothing it does needs a reboot, so switching it off really restores the machine instead of leaving it half-tuned.
The session is written to disk, so an interrupted one can still be turned off and restored rather than stranding a dozen stopped services.
While a session is on, the card lists what is in effect right now — every service by the name Windows uses, the power scheme it switched to and the one that comes back, how much memory the trim freed, how long it has been on and what turned it on. Each line says what happens to it on exit, including the one that is not put back: the memory. Windows refills the standby list on its own, and there is nothing to restore.
This replaced a toast that vanished after a few seconds and left no way to tell what the machine was still holding. Something that asks for administrator rights and changes services underneath you should not need to be taken on trust.
Turn on automatic game mode and SysTuneX watches for a game starting: twenty-five are recognised out of the box, and anything else is a one-field addition by executable name.
A schedule holds game mode on during a window of the day, optionally on chosen days. It is evaluated against the clock once a minute rather than set as timers on the two edges — a timer misses its moment whenever the machine sleeps through it, and a missed edge would leave game mode stuck on. A window that ends before it starts runs past midnight and belongs to the day it began.
Neither undoes what you switched on by hand. Turning game mode on yourself at 23:05 outlives a schedule that ended at 23:00, and a game exiting does not end a session you started.
Automation runs only while SysTuneX is open. Doing it with the app closed would mean a Windows service, and a background service that stops other services is a much bigger thing to ask someone to trust.
SysTuneX counts frames through Event Tracing for Windows, reading the Present events the DirectX stack already writes — the same source PresentMon and the Xbox Game Bar counter use.
Nothing is injected into the game. RTSS, Afterburner and Fraps hook the graphics API from inside the game process; that is how they draw an overlay, and it is also exactly what anti-cheat looks for. A tool whose whole point is to be run before playing cannot ship something that risks a ban.
The cost of that choice is stated rather than hidden: there is no overlay over a fullscreen game. The counter deliberately stays pointed at the game when SysTuneX comes to the foreground — retargeting to our own window would show SysTuneX's frame rate, which is worse than useless.
What there is instead is a compact readout: a small window with the same numbers, kept above other windows and summoned with Ctrl+Shift+M from wherever you are. It is an ordinary window with its chrome removed, not an overlay — so it appears over a game running borderless windowed, which is how most people play, and it will not appear over one running in exclusive fullscreen, which owns the display outright. That limit is real and is the price of never touching the game process. Drag it anywhere; it reopens where you left it, and it shows whatever you ticked on the Monitor page. The key can be changed, or switched off, in Settings — and if another program already owns the combination, Settings says so rather than leaving you pressing a key that does nothing.
Alongside the average, the Monitor shows the 1% low — the frame rate of the worst one percent of frames. An average of 144 with a 1% low of 40 stutters, and a steady 90 does not; an average on its own hides the exact problem this tool exists to fix.
The counter is a switch rather than something that starts itself: an Event Tracing session is a machine-wide resource, so it runs when asked and closes when switched off. Starting one needs administrator rights, and where it cannot start the page says so instead of showing a blank number.
GPU temperature comes from the vendor's own library, shipped with the driver and needing no install: NVML for NVIDIA — temperature, load and fan — and ADL for AMD, which reports temperature and fan. CPU temperature comes from the ACPI thermal zone where firmware exposes one — that is a board thermal zone rather than the CPU package, and the dashboard says so.
Only ADL's scalar calls are used. Its richer ones take large structs whose layout differs between driver branches, and getting one wrong corrupts memory rather than returning an error — a tuner that can crash the machine it is tuning is worse than one that shows no temperature. Intel GPUs are not covered yet.
SysTuneX ships no kernel driver, and will not. Reading a CPU package temperature properly needs a ring-0 helper, and the off-the-shelf ones are on Microsoft's vulnerable driver blocklist and trip anti-cheat. That is not a trade worth making in a tool people install to play games.
So a reading appears only when a sensor actually answered. Where none does, the card says so and why — a missing reading is not zero degrees. Readings outside anything a running part produces are dropped too: some firmware returns a placeholder, and a plausible-looking wrong number is worse than a blank.
Record the machine before a change and again after it, then compare the two. The result names every tweak that became applied, every service that started or stopped, and a changed power scheme.
It is not a performance measurement and does not pretend to be. It compares configuration, not speed — for frame times, watch the Monitor page while you play, or run the same benchmark on both sides and compare it yourself. Memory and process counts are reported only when they move further than they drift on their own — listing a 3 MB difference as the effect of a tweak would be a lie dressed as data.
SysTuneX is built around reversibility and visibility.
The previous state is journaled before the system is modified.
If a registry value existed before SysTuneX changed it, its original value is restored.
If the value did not exist before, rollback removes it instead of inventing one.
Tweaks are classified by risk.
Advanced changes require explicit confirmation and explain the possible consequences before being applied.
Windows 11-specific settings are only offered where the corresponding feature actually exists.
Failed registry writes, service operations and system commands surface their real error instead of being reported as successful.
SysTuneX calculates the target paths, file count and total size before cleanup.
The rollback journal is stored at:
%ProgramData%\SysTuneX\backup.json
It records the state required to restore supported changes, including:
- registry values
- Windows service configuration
- DNS settings
- power configuration
- boot-related options
The Change Log page can restore individual entries or roll back the recorded configuration.
The journal can also be exported as JSON.
Application logs are stored in:
%ProgramData%\SysTuneX\logs
SysTuneX keeps one log file per day and retains logs for seven days.
Messages shown in the UI are logged as well, so the interface and diagnostic log describe the same event.
Enable Verbose logging to additionally record registry reads and executed system commands.
The Build a report function collects useful troubleshooting information such as:
- Windows build and edition
- hardware information
- elevation state
- recorded changes
- recent application logs
Startup failures are additionally written to:
%ProgramData%\SysTuneX\errors.log
SysTuneX includes several network-oriented tuning functions.
Available providers include:
- Cloudflare
- Quad9
- OpenDNS
- AdGuard
SysTuneX measures response latency before you choose a resolver.
Settings such as Nagle's algorithm are applied where Windows actually stores them - per network adapter.
- Windows 10 version 1809 / build 17763 or newer
- Windows 11
- x64
- Administrator rights
Availability of individual tweaks may depend on:
- Windows version
- Windows edition
- build number
- hardware
- installed drivers
Unsupported tweaks are filtered instead of being blindly written.
| Component | Technology |
|---|---|
| Language / Runtime | C# / .NET 10 (LTS) |
| Desktop UI | WPF |
| UI framework | WPF UI 4.3 |
| Architecture | MVVM |
| MVVM toolkit | CommunityToolkit.Mvvm 8.4 |
| Dependency injection | Microsoft.Extensions.Hosting |
| Windows integration | Win32 API, Registry, WMI |
| Frame counting | Event Tracing for Windows |
| GPU sensors | NVML (NVIDIA), ADL (AMD) |
| System tooling | powercfg, netsh, bcdedit, ipconfig |
| Testing | xUnit |
| CI/CD | GitHub Actions |
SysTuneX separates operating-system logic from the desktop interface.
SysTuneX/
├── src/
│ ├── SysTuneX.Core/
│ │ ├── Abstractions/ # the contracts the app depends on
│ │ ├── Diagnostics/
│ │ ├── Models/ # records and the pure functions over them
│ │ ├── Native/
│ │ ├── Services/
│ │ │ └── Sensors/
│ │ └── Tweaks/ # the tweak, service, profile and cleanup catalogues
│ │
│ └── SysTuneX.App/
│ ├── Assets/
│ ├── Controls/
│ ├── Converters/
│ ├── Diagnostics/
│ ├── Localization/
│ ├── Resources/ # Strings.resx and one Strings.<lang>.resx per language
│ ├── Services/ # everything the UI needs that is not a screen
│ ├── ViewModels/
│ │ └── Settings/
│ └── Views/
│ └── Pages/
│
├── tests/
│ ├── SysTuneX.Core.Tests/ # also the checks that read the app's markup and source
│ └── SysTuneX.App.Tests/ # needs Windows; CI runs it
│
└── .github/workflows/
Contains system operations and tuning logic without a dependency on the WPF UI.
Contains the WPF interface, navigation, resources, localization and view models.
System changes are performed through the Core services instead of directly from the UI layer.
Every push and pull request is validated on a Windows GitHub Actions runner.
The pipeline performs:
Restore
↓
Build
↓
Core tests
↓
WPF startup tests
↓
Publish win-x64
↓
SHA256 checksum
↓
Release artifact
The WPF startup suite creates the real application, loads its resources and constructs the main window and pages.
This catches runtime XAML failures that a successful compilation alone cannot detect.
Releases are published from the default branch only. A release cut from a feature branch would
describe code nobody has merged, and would leave its tag on a commit that may never reach main.
- Add a
## vX.Y.Zsection at the top ofCHANGELOG.md. - Put the same version in
release.version. - Merge to
main.
CI then builds, tests, publishes SysTuneX.exe and SHA256SUMS.txt, and creates the release
with only that version's changelog section plus the shared footer.
A version with a suffix — v2.5.0-rc1 — is marked as a pre-release; a plain v2.5.0 is not.
Re-running the job on an unchanged version only refreshes the assets, so it is safe to repeat.
Requirements:
- .NET 10 SDK
- Windows for the complete WPF test suite
Clone the repository:
git clone https://github.com/Anton-Babaskin/SysTuneX.git
cd SysTuneXRestore and build:
dotnet restore
dotnet buildRun the Core tests:
dotnet test tests/SysTuneX.Core.Tests/SysTuneX.Core.Tests.csprojRun the startup tests. These need a real WPF stack, so they only do anything on Windows:
dotnet test tests/SysTuneX.App.Tests/SysTuneX.App.Tests.csprojPublish a self-contained executable:
dotnet publish src/SysTuneX.App/SysTuneX.App.csproj `
-c Release `
-r win-x64 `
--self-contained true `
-p:PublishSingleFile=true `
-p:PublishReadyToRun=trueSysTuneX changes system configuration. It does not promise a specific FPS increase.
If you want to measure whether a configuration improves your system, compare the same workload before and after using metrics such as:
- average FPS
- 1% and 0.1% lows
- frame-time consistency
- input latency
- DPC / ISR latency
- CPU and memory utilization
- network latency and packet loss
Use the same game scene, graphics settings and test duration for both runs.
Issues and pull requests are welcome. CONTRIBUTING.md has the full guide; the short version, when adding or changing a tweak:
- keep system operations out of the UI layer
- record the original state before modifying it
- distinguish between an absent registry value and a value set to
0 - validate Windows build requirements
- prefer documented Windows APIs and policies
- add or update catalog tests
- give every user-visible string an entry in
Strings.resxand in everyStrings.<lang>.resx
Releases are cut per merge; see RELEASING.md. Security reports go through SECURITY.md rather than a public issue.
SysTuneX modifies Windows settings related to performance, networking, privacy, services, power management and system behavior.
Although supported changes are recorded for rollback, no tuning tool can guarantee identical results across every Windows installation, hardware configuration or software stack.
Review advanced changes before applying them and consider creating a Windows restore point when testing development builds.
SysTuneX is released under the MIT License.
Built for people who want to know what their optimizer actually changed.