SysTuneX 2.12.1

Restore All no longer ends early when one step throws

Restorers run in order, so an exception in one took every later one with it — and the report that
says which changes came back was never returned at all. You would be told the rollback failed, with
nothing saying which half of it went through. A machine left mid-rollback is the worst state this
application can put one in.

Nothing was known to throw; that was checked rather than assumed. But the restorers reach bcdedit,
netsh, the registry, the task scheduler and PowerShell, and "everything down there reports rather
than throws" is not something the rollback can rely on. A throw is now what a refusal already was:
counted, named in your language, and not the end of the rollback.

A website

systunex on GitHub Pages — English and Russian, with
the download button in the first screen. A release page is where you go once you have already
decided; this is the page for someone who has not.

Two rules the settings page cannot enforce for itself

Splitting that page into five sections last release turned one loading flag into six independent
checks. A section that forgets it writes your settings file while the page is still filling its
controls in — and applies each value as though you had just chosen it. A section the page forgets
to load shows its defaults and then writes those over what you had. Neither is possible to add
silently now.

---

---

Download

SysTuneX.exe below is a self-contained single file — no .NET runtime to install. It asks for
administrator rights on launch because 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.

Verifying it

You are about to run an unsigned executable as administrator. That deserves a check, and there is a
real one available.

Get-FileHash .\SysTuneX.exe -Algorithm SHA256

That number should match SHA256SUMS.txt beside the download — and the SHA-256 printed by the
Checksum step of the Actions run that
built this release, in a public log nobody can edit afterwards.

If all three agree, this is the file that GitHub's runner built from the tagged commit. Nobody,
including whoever controls this release page, can swap the binary without the numbers disagreeing.
That is a stronger guarantee than a code signature, which proves only who shipped a file and
nothing about what it does.

SmartScreen will warn, because the executable is not code-signed — a certificate that avoids
that costs several hundred dollars a year and requires a registered company. The warning is about
how many people have run this file, not about what it does. Choose More info → Run anyway, or
check the hash first, or put the file through VirusTotal.

Full detail, including everything the app writes and how each change is undone, is in the
repository's Trust and safety section.

---

Known limitations

• Not code-signed, so SmartScreen will warn.
• The hosts-file block can be refused by Microsoft Defender tamper protection. The app reports that
  rather than failing silently.
• Restore points need System Protection switched on for the system drive; if it is off, the app says
  so instead of pretending a restore point was created.
• Ultimate Performance is unavailable on some Windows editions. SysTuneX falls back to High
  Performance and reports which one it used.
• Cleanup deletes files and is the one action that cannot be undone from the change journal. The app
  says so before doing it.

SysTuneX 2.12.0

A compact readout you can call up over a game

The numbers on the Monitor page are only useful while you are looking at them, and while you are
playing you are not. There is now a small window with the same readings that stays above other
windows, opened with Ctrl+Shift+M from wherever you are — including from inside a game.

It shows whatever you ticked on the Monitor page, and it keeps showing it: change a tick with the
window open and it follows. Drag it anywhere; it reopens where you left it, on a screen that still
exists — a position on a monitor that has since been unplugged is quietly corrected rather than
opening the window somewhere you cannot reach it.

What it is not. It is not an overlay. Nothing is injected into the game, nothing hooks its swap
chain, no driver is loaded — it is an ordinary window with its chrome removed. So it appears over a
game running borderless windowed, and it will not appear over one running in exclusive
fullscreen, which owns the display outright. That is a real limit, and it is the same trade this
project makes everywhere: nothing an anti-cheat could reasonably mistake for a cheat.

The key can be changed or switched off in Settings. If another program already owns the
combination, Settings says which and asks for a different one, rather than leaving you pressing a
key that does nothing — which is indistinguishable from a broken application.

Readings the machine cannot supply are still left out rather than drawn as zero, and a frame rate
counter that is running but has nothing to count shows -- rather than a number. Ten tests cover
how the readout is assembled, because the window is small, it sits over a game, and nobody reading
it has room to wonder whether a zero means zero.

Half of Core became testable

Everything SysTuneX cannot do through an API it does by running powercfg, netsh, bcdedit or
PowerShell and reading what they print. The reading is the part that goes wrong — those tools print
in the user's language and their output shape is not a contract — and the runner was a static class,
so none of it could be reached from a test. A comment in the power service said so out loud. Two
real defects came out of exactly that blind spot, both found by reading rather than by testing,
which is the expensive way.

The runner is injected now. Twelve tests cover what powercfg prints and what SysTuneX makes of it,
including the claim the scheme parser has carried since it was written — that powercfg's labels are
translated, so only the GUID and the name in brackets can be relied on. That had never once been run
against a Russian machine's output. It turns out to be correct. The power setting reader made the
same claim and was wrong.

Tests no longer write to your ProgramData folder. Half the services took an optional directory
and fell back to a fixed path when it was not given — and no test ever gave it, so every test of the
profile, snapshot, game-mode and game-watcher services read and wrote the real
%ProgramData%\SysTuneX on whatever machine ran them. The escape hatch is gone; the path comes from
one injected place, and a test fails if anything but the logger reaches for the fixed one.

Rebooting your PC left the view model. shutdown /r was a one-line call to a static process
runner from inside the class that describes the main window — the most consequential thing this app
can do, in the layer furthest from anything that could check it. It sits beside "relaunch elevated"
and "restart the shell" now, and it reports a refusal instead of failing silently.

Opening a folder too. Four commands called Process.Start directly; they go through one
launcher, which also refuses to hand Windows anything that is not plainly a web address — every URL
in the app is a constant in our own source, and that is exactly the kind of thing that stops being
true one edit later.

Four architecture tests keep all of it from coming back. Each one is a mistake this project actually
made.

The interface has an identity, and its numbers stop jittering

Live counters no longer shift about. The metric style carried a comment saying it used tabular
figures — every digit the same width — and a setter that did nothing of the kind. So a counter going
99 → 100 → 99 shoved the caption beside it back and forth, twice a second, on the two screens where
that is worst: the monitor page and the small window that sits over a game. It had done that since
the page was written, because nothing about a comment is enforced. The setting is now actually
applied.

Every page opens with the brand accent. The app has had a gradient in its palette and nowhere
that used it: every screen started with grey text on a grey background and looked like a settings
dialogue. Four pixels of colour under each page title is enough to say which application this is,
and unlike a drop shadow it costs nothing to draw — which matters in a tool whose whole argument is
that it does not waste the machine.

One type scale instead of three. Pages reached past the shared styles with hard-coded sizes —
13 here, 26 there — so two things that meant the same thing were set differently on different pages
and nothing said which was right. There is one scale now, and the sizes that were off it are on it.

A test that reads the markup. A {StaticResource} naming a key that does not exist is not a
build error: it throws when the page is parsed, which is when the user opens it, and takes the page
down. This project has already shipped that once. There is now a check that resolves every resource
key every page asks for, and it needs neither Windows nor WPF to run — so a resource renamed on any
machine is caught by the person who renamed it.

The frame counter reports a number again

Reported from a real machine: the FPS counter does not work. It was two clocks being compared
against each other.

Frame timestamps come from the trace — whatever epoch Event Tracing hands over. The window then
aged those timestamps against the local wall clock. Where the two do not line up, every frame looks
hours old on the first read, the window empties itself, and the counter reports nothing. Forever,
and silently: an empty window is a perfectly ordinary state, so there was nothing to log.

Every test passed the same value for both roles, which is exactly why nothing caught it. A frame
now carries two timestamps and the type says why: the presentation time, only ever used as a
difference against another presentation time, and the arrival time on this process's own monotonic
clock, which is the only value ever compared against "now".

Direct3D 9 games were never counted at all. A D3D9 title does not call IDXGISwapChain::Present,
so with the DXGI provider alone the counter sat at nothing for every game of that era and gave no
hint why. That provider is listened to as well now.

"No frame rate" said one thing for four different situations, which is why the only bug report
it ever produced was "it doesn't work". The page now tells them apart: the trace session would not
start; the session is up and nothing on this PC presents through DirectX at all, which is what a
Vulkan or OpenGL game looks like; frames are being presented but by some other window; or this game
was being counted and has stopped — which is what alt-tabbing out of an exclusive fullscreen game
does, and is not a fault.

Three new tweaks

PCI Express power saving, off. ASPM parks a PCIe link between transfers and wakes it on the next
one. Waking takes microseconds — which matters only when it lands between a mouse report and the
frame that should have used it, on the link carrying the drive a game streams from or the network
card a match is on. It costs power, and on a laptop on battery that is a real loss, so the tweak
says so instead of selling it as free. A machine whose firmware does not expose the setting now says
that, rather than offering a switch that cannot do anything.

The accessibility key shortcuts, off. Five taps of Shift opens the Sticky Keys dialogue, which
in a shooter means crouch, crouch, crouch and then a modal window over the game. The shortcuts go;
the features stay available in Settings for anyone who uses them.

The data-collection scheduled tasks, off. Seven of them: the Compatibility Appraiser, which
walks every installed program and can hold a core busy for minutes at a time, and six smaller
Customer Experience Improvement Program tasks. Only the ones actually running are switched off, and
only those are switched back on — a task you disabled yourself stays as you left it, which is the
rule the service tweaks already follow.

No "audio latency" tweak, although every optimizer has one. On stock Windows 11 the multimedia
scheduler's Audio task already sits at priority 6 and Pro Audio already at scheduling category
High — the values those guides tell you to write. The one value that is not already set is the Audio
task's category, and raising it puts the audio engine in the same scheduling band as the game. That
is a trade, not a win, and shipping it as a speed-up would be a placebo with a real cost.

Reading a power setting no longer guesses

Reading one meant scanning powercfg's output for a line with "index" in it — in English or in
Russian. That had never been run against either, because reaching it needed powercfg on a Windows
machine, and a scan that matches nothing does not fail: it returns zero, which for most of these
settings means "off". It would report a machine as tuned having read nothing at all.

The parsing is now a plain function with twelve tests over real powercfg output in both languages,
and a setting the machine does not expose reads as nothing rather than as zero.

The tuning score was wrong on a translated Windows

Found while moving the check that answers it out of the dashboard.

A fifth of the score is "is a high performance power scheme ac...

SysTuneX 2.11.0

The profiles page now says which profile is on

Reported after applying "Battle royale" and not being able to tell. The page showed, per card, what
share of that profile's tweaks were currently in place — and profiles deliberately share most of
their tweaks, so applying any one of them left every card reading somewhere in the high eighties.
Six near-identical percentages answer nothing.

A percentage never could answer it: it measures the machine, and the question is about a decision.
So the decision is recorded when it is made. The applied profile is remembered — on disk, because
the machine keeps the tweaks after the window closes — and its card carries a badge with the date.

Applying another profile moves the badge. Restoring everything clears it, because then no profile
is applied.

A card can also say partly held: applied, but since reverted in part by hand. Calling that
simply "on" would be the comfortable half of the truth, and calling it off would throw away what
the user did.

---

---

Download

SysTuneX.exe below is a self-contained single file — no .NET runtime to install. It asks for
administrator rights on launch because 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.

Verifying it

You are about to run an unsigned executable as administrator. That deserves a check, and there is a
real one available.

Get-FileHash .\SysTuneX.exe -Algorithm SHA256

That number should match SHA256SUMS.txt beside the download — and the SHA-256 printed by the
Checksum step of the Actions run that
built this release, in a public log nobody can edit afterwards.

If all three agree, this is the file that GitHub's runner built from the tagged commit. Nobody,
including whoever controls this release page, can swap the binary without the numbers disagreeing.
That is a stronger guarantee than a code signature, which proves only who shipped a file and
nothing about what it does.

SmartScreen will warn, because the executable is not code-signed — a certificate that avoids
that costs several hundred dollars a year and requires a registered company. The warning is about
how many people have run this file, not about what it does. Choose More info → Run anyway, or
check the hash first, or put the file through VirusTotal.

Full detail, including everything the app writes and how each change is undone, is in the
repository's Trust and safety section.

---

Known limitations

• Not code-signed, so SmartScreen will warn.
• The hosts-file block can be refused by Microsoft Defender tamper protection. The app reports that
  rather than failing silently.
• Restore points need System Protection switched on for the system drive; if it is off, the app says
  so instead of pretending a restore point was created.
• Ultimate Performance is unavailable on some Windows editions. SysTuneX falls back to High
  Performance and reports which one it used.
• Cleanup deletes files and is the one action that cannot be undone from the change journal. The app
  says so before doing it.

SysTuneX 2.10.2

The executable now says which version it is

SysTuneX.exe reported 2.0.0.0 in its file properties. It had said that since 2.0, through ten
releases — the number was written by hand in the build configuration and nobody thought to change
it, because nothing reads it and nothing checked.

The version is now read from release.version, the same file the release workflow tags from. One
source, so the two cannot disagree again.

The build no longer lets a warning through

Warnings are errors now. The build has carried zero of them for a long time on discipline alone,
and discipline is what a build stops having the week somebody is in a hurry.

The obvious risk is a future toolchain inventing a warning and blocking a release nobody broke, so
two things are pinned to stop the ground moving: the C# language version (it was "latest", which
means whatever the installed compiler feels like) and the analyzer level, which now follows the
target framework rather than whichever SDK patch the runner installed.

---

---

Download

SysTuneX.exe below is a self-contained single file — no .NET runtime to install. It asks for
administrator rights on launch because 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.

Verifying it

You are about to run an unsigned executable as administrator. That deserves a check, and there is a
real one available.

Get-FileHash .\SysTuneX.exe -Algorithm SHA256

That number should match SHA256SUMS.txt beside the download — and the SHA-256 printed by the
Checksum step of the Actions run that
built this release, in a public log nobody can edit afterwards.

If all three agree, this is the file that GitHub's runner built from the tagged commit. Nobody,
including whoever controls this release page, can swap the binary without the numbers disagreeing.
That is a stronger guarantee than a code signature, which proves only who shipped a file and
nothing about what it does.

SmartScreen will warn, because the executable is not code-signed — a certificate that avoids
that costs several hundred dollars a year and requires a registered company. The warning is about
how many people have run this file, not about what it does. Choose More info → Run anyway, or
check the hash first, or put the file through VirusTotal.

Full detail, including everything the app writes and how each change is undone, is in the
repository's Trust and safety section.

---

Known limitations

• Not code-signed, so SmartScreen will warn.
• The hosts-file block can be refused by Microsoft Defender tamper protection. The app reports that
  rather than failing silently.
• Restore points need System Protection switched on for the system drive; if it is off, the app says
  so instead of pretending a restore point was created.
• Ultimate Performance is unavailable on some Windows editions. SysTuneX falls back to High
  Performance and reports which one it used.
• Cleanup deletes files and is the one action that cannot be undone from the change journal. The app
  says so before doing it.

SysTuneX 2.10.1

A power scheme that changed is no longer reported as a failure

Reported from a real machine: switching the scheme took longer than the ten seconds SysTuneX
allowed, so it killed powercfg and said it could not activate the scheme — while the scheme was
in fact active. Being told a change did not happen when it did sends you looking for a problem that
is not there.

The wait is thirty seconds now, and more to the point a timeout is no longer taken as failure on
its own: the active scheme is read back afterwards and believed over the stopwatch.

A scheme that cannot be read back still counts as a failure. An unanswered question is not
evidence, and guessing in the app's favour there would be the same lie pointing the other way.

---

---

Download

SysTuneX.exe below is a self-contained single file — no .NET runtime to install. It asks for
administrator rights on launch because 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.

Verifying it

You are about to run an unsigned executable as administrator. That deserves a check, and there is a
real one available.

Get-FileHash .\SysTuneX.exe -Algorithm SHA256

That number should match SHA256SUMS.txt beside the download — and the SHA-256 printed by the
Checksum step of the Actions run that
built this release, in a public log nobody can edit afterwards.

If all three agree, this is the file that GitHub's runner built from the tagged commit. Nobody,
including whoever controls this release page, can swap the binary without the numbers disagreeing.
That is a stronger guarantee than a code signature, which proves only who shipped a file and
nothing about what it does.

SmartScreen will warn, because the executable is not code-signed — a certificate that avoids
that costs several hundred dollars a year and requires a registered company. The warning is about
how many people have run this file, not about what it does. Choose More info → Run anyway, or
check the hash first, or put the file through VirusTotal.

Full detail, including everything the app writes and how each change is undone, is in the
repository's Trust and safety section.

---

Known limitations

• Not code-signed, so SmartScreen will warn.
• The hosts-file block can be refused by Microsoft Defender tamper protection. The app reports that
  rather than failing silently.
• Restore points need System Protection switched on for the system drive; if it is off, the app says
  so instead of pretending a restore point was created.
• Ultimate Performance is unavailable on some Windows editions. SysTuneX falls back to High
  Performance and reports which one it used.
• Cleanup deletes files and is the one action that cannot be undone from the change journal. The app
  says so before doing it.

SysTuneX 2.10.0

The monitor page reads at a glance instead of asking you to remember what each number was.

Every reading says what it is

8 % 28°C was two different measurements at the same size with nothing to tell them apart, so the
page only worked for someone who already knew which figure was which. Each number now carries its
own caption, and the temperature is set smaller than the load — they are not equally important, and
the type should say so.

Temperature is coloured by how close the part is to throttling

Amber and red, from the same three brushes the risk pills use rather than a second palette. The
thresholds are per part and deliberately different: a laptop processor at 85 °C is having an
ordinary afternoon, a graphics card at 85 °C is already losing clocks. One shared limit would have
to be wrong about one of them, and a monitor that cries wolf gets ignored.

A reading in the normal range is not coloured. Painting every temperature would leave the page
looking like a warning light stuck on. A sensor that did not answer is not coloured either — that
would be inventing a fact about a machine that never replied.

The charts are readable

Each card's chart was laid over the whole card with a top margin, which left it drawing a few
pixels in one corner — present, but too small to read as anything but an artefact. Each card now
gives its chart a band of its own along the bottom, edge to edge, with a stronger fill. The cards
also size to their content rather than being pinned to a fixed height that cropped it.

---

Download

SysTuneX.exe below is a self-contained single file — no .NET runtime to install. It asks for
administrator rights on launch because 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.

Verifying it

You are about to run an unsigned executable as administrator. That deserves a check, and there is a
real one available.

Get-FileHash .\SysTuneX.exe -Algorithm SHA256

That number should match SHA256SUMS.txt beside the download — and the SHA-256 printed by the
Checksum step of the Actions run that
built this release, in a public log nobody can edit afterwards.

If all three agree, this is the file that GitHub's runner built from the tagged commit. Nobody,
including whoever controls this release page, can swap the binary without the numbers disagreeing.
That is a stronger guarantee than a code signature, which proves only who shipped a file and
nothing about what it does.

SmartScreen will warn, because the executable is not code-signed — a certificate that avoids
that costs several hundred dollars a year and requires a registered company. The warning is about
how many people have run this file, not about what it does. Choose More info → Run anyway, or
check the hash first, or put the file through VirusTotal.

Full detail, including everything the app writes and how each change is undone, is in the
repository's Trust and safety section.

---

Known limitations

• Not code-signed, so SmartScreen will warn.
• The hosts-file block can be refused by Microsoft Defender tamper protection. The app reports that
  rather than failing silently.
• Restore points need System Protection switched on for the system drive; if it is off, the app says
  so instead of pretending a restore point was created.
• Ultimate Performance is unavailable on some Windows editions. SysTuneX falls back to High
  Performance and reports which one it used.
• Cleanup deletes files and is the one action that cannot be undone from the change journal. The app
  says so before doing it.

SysTuneX 2.9.1

A defect in 2.9.0's own headline feature, found by auditing it rather than by hitting it, plus two
tests for the kinds of mistake this codebase keeps making.

Turning game mode on reported an error while turning it on

GameModeService raises its Changed event after await _gate.WaitAsync().ConfigureAwait(false),
so the event always arrives on a thread-pool thread — even when the user pressed the switch by
hand, and certainly when the schedule or the game watcher tick on their own timers.

That was harmless while the dashboard's handler only assigned scalar properties, which the binding
engine marshals by itself. 2.9.0 gave the card a bound collection, and a bound collection cannot be
changed off the UI thread: it throws. The throw then landed in the service's own catch, so game
mode came on for real — services stopped, power scheme switched, memory freed — while the screen
showed an error saying it had not.

The handler now hops to the dispatcher, the way the tray icon already did with the same event.

Two tests for two blind spots

Bindings. A {Binding} naming a property that does not exist fails silently: WPF writes to the
debug output and renders nothing. No exception, no warning, no failing test. When 2.8.0 rewrote the
monitor page, its fifty-four bindings had to be checked by hand for exactly this reason. They are
checked by a test now.

Unused strings. The suite already refused a key the interface asks for and nobody defined. The
opposite — a key defined and asked for by nobody — was invisible, and twenty had piled up behind
rewritten pages and renamed features, each one still needing translating and reviewing. They are
gone, and a test keeps them gone.

---

---

Download

SysTuneX.exe below is a self-contained single file — no .NET runtime to install. It asks for
administrator rights on launch because 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.

Verifying it

You are about to run an unsigned executable as administrator. That deserves a check, and there is a
real one available.

Get-FileHash .\SysTuneX.exe -Algorithm SHA256

That number should match SHA256SUMS.txt beside the download — and the SHA-256 printed by the
Checksum step of the Actions run that
built this release, in a public log nobody can edit afterwards.

If all three agree, this is the file that GitHub's runner built from the tagged commit. Nobody,
including whoever controls this release page, can swap the binary without the numbers disagreeing.
That is a stronger guarantee than a code signature, which proves only who shipped a file and
nothing about what it does.

SmartScreen will warn, because the executable is not code-signed — a certificate that avoids
that costs several hundred dollars a year and requires a registered company. The warning is about
how many people have run this file, not about what it does. Choose More info → Run anyway, or
check the hash first, or put the file through VirusTotal.

Full detail, including everything the app writes and how each change is undone, is in the
repository's Trust and safety section.

---

Known limitations

• Not code-signed, so SmartScreen will warn.
• The hosts-file block can be refused by Microsoft Defender tamper protection. The app reports that
  rather than failing silently.
• Restore points need System Protection switched on for the system drive; if it is off, the app says
  so instead of pretending a restore point was created.
• Ultimate Performance is unavailable on some Windows editions. SysTuneX falls back to High
  Performance and reports which one it used.
• Cleanup deletes files and is the one action that cannot be undone from the change journal. The app
  says so before doing it.

SysTuneX 2.9.0

Three things 2.8.0 got wrong on a real desktop, and the switch that changes the most now says what
it has changed.

The window opened empty

Picking any backdrop other than the default made the app unusable on every launch afterwards.
Applying one makes WPF-UI rebuild the window chrome, and replacing chrome that already carries an
inheritance context throws from inside WPF — from the first line of the window's startup handler,
which took the navigation on the line below it with it. The result was an empty content area, plus
a second crash from a title bar that had never finished initialising, on every click of the close
button.

Navigation runs first now: nothing decorative executes before the thing the window exists to show.
The backdrop is applied afterwards and a refusal is logged instead of thrown. The startup handler
is reachable from tests, and five of them drive it with every backdrop the settings page offers.

Dialogs ignored the mouse

Every dialog in the app rendered and then took no clicks — "Apply profile" could be confirmed with
Enter and by no other means. The wrapper around the dialog host was marked hit-test transparent so
the page underneath would stay clickable, with the hosts inside marked visible again. Hit testing
walks up the tree: a false ancestor stops it dead, and setting it back to true on a child does
nothing at all.

Game mode was minting a power scheme per session

Windows hides Ultimate Performance until it is duplicated into the machine's scheme list, and
powercfg /duplicatescheme mints a fresh GUID every time — so the lookup for the canonical GUID
never found last session's copy and simply made another. A day of ordinary use produced three,
none of them removed. It remembers the GUID it was given and reuses that scheme now, which also
works on a localised install, where the duplicate is called something else entirely.

Game mode shows its work

It stops services, replaces the power scheme and frees gigabytes, and it reported all of that in a
toast that vanished after a few seconds. A minute later there was no way to tell what the machine
was still holding.

While a session is on, the card now lists what is in effect: every service under the name Windows
uses, the scheme it switched to and the one that comes back, the memory the trim freed, how long it
has been on and what turned it on — by hand, by a game, or by the schedule. Each line says what
happens to it on exit, including the one that is not put back: the freed pages are gone and
Windows refills the standby list on its own, so calling that "restored" would be a comfortable lie.

The session records the name of the scheme it switched to by reading it back from the machine
rather than assuming it: "high performance" is Ultimate Performance where Windows offers it, a
duplicate where Windows hides it, and High Performance on the editions with neither.

The tray tooltip said only "Game mode", which answers whether it is on and nothing about what that
costs. It carries the counts now.

---

---

Download

SysTuneX.exe below is a self-contained single file — no .NET runtime to install. It asks for
administrator rights on launch because 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.

Verifying it

You are about to run an unsigned executable as administrator. That deserves a check, and there is a
real one available.

Get-FileHash .\SysTuneX.exe -Algorithm SHA256

That number should match SHA256SUMS.txt beside the download — and the SHA-256 printed by the
Checksum step of the Actions run that
built this release, in a public log nobody can edit afterwards.

If all three agree, this is the file that GitHub's runner built from the tagged commit. Nobody,
including whoever controls this release page, can swap the binary without the numbers disagreeing.
That is a stronger guarantee than a code signature, which proves only who shipped a file and
nothing about what it does.

SmartScreen will warn, because the executable is not code-signed — a certificate that avoids
that costs several hundred dollars a year and requires a registered company. The warning is about
how many people have run this file, not about what it does. Choose More info → Run anyway, or
check the hash first, or put the file through VirusTotal.

Full detail, including everything the app writes and how each change is undone, is in the
repository's Trust and safety section.

---

Known limitations

• Not code-signed, so SmartScreen will warn.
• The hosts-file block can be refused by Microsoft Defender tamper protection. The app reports that
  rather than failing silently.
• Restore points need System Protection switched on for the system drive; if it is off, the app says
  so instead of pretending a restore point was created.
• Ultimate Performance is unavailable on some Windows editions. SysTuneX falls back to High
  Performance and reports which one it used.
• Cleanup deletes files and is the one action that cannot be undone from the change journal. The app
  says so before doing it.

SysTuneX 2.8.0

An audit of 2.7.0 found nine defects in it. This fixes all of them and rebuilds the monitor's
settings around a catalogue instead of a row of booleans.

Nine defects in the release before this one

Four of them showed numbers that were not there. Binding a tile to its tick alone — without also
asking whether the machine can supply the reading — drew a bare °C or % with nothing in front
of it on any machine whose firmware exposes no temperature. That is the plausible-looking wrong
reading this project refuses everywhere else, and it shipped.

The rest: switching the frame counter off while its trace session was still starting lost the
stop, leaving a machine-wide ETW session running with the switch showing off. The "no sensors"
explanation was suppressed by a reading nobody had asked to see. Ticking the process count with
memory switched off showed nothing, because it lived inside the memory card. The sensor sample ran
unconditionally on every page visit, ignoring the gate that was the point of the feature. And the
three cards sat in a grid with fixed columns that did not give a hidden tile's width back —
with a comment claiming they did. The comment was the bug.

The readings are a catalogue now

Nine booleans, nine change handlers and two nine-line blocks copying them in and out of the
settings file, all replaced by one list. Adding a reading is an entry in the catalogue plus its two
strings; the ticks, the persistence, the grouping and the count all follow.

The point is not tidiness. All of it lived in a view model, where nothing is reachable from a test
that runs without Windows — which is exactly why a wrong answer sat on the page unnoticed. The
selection is in the core now, with fourteen tests on it.

The panel

Readings are grouped — frames, processor, graphics, memory, system — rather than listed flat, and
the header carries a live preview of the readout so the effect of a tick is visible without
closing the panel. A selection count sits beside the list, and a reading the cap would refuse is
disabled rather than silently ignoring the click.

Four new readings while the plumbing was open: frame time and 1% low as separate ticks, standby
memory, free disk space and uptime.

A settings file naming a reading this build does not know is skipped rather than refused, so a
file written by a newer version still opens.

---

---

Download

SysTuneX.exe below is a self-contained single file — no .NET runtime to install. It asks for
administrator rights on launch because 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.

Verifying it

You are about to run an unsigned executable as administrator. That deserves a check, and there is a
real one available.

Get-FileHash .\SysTuneX.exe -Algorithm SHA256

That number should match SHA256SUMS.txt beside the download — and the SHA-256 printed by the
Checksum step of the Actions run that
built this release, in a public log nobody can edit afterwards.

If all three agree, this is the file that GitHub's runner built from the tagged commit. Nobody,
including whoever controls this release page, can swap the binary without the numbers disagreeing.
That is a stronger guarantee than a code signature, which proves only who shipped a file and
nothing about what it does.

SmartScreen will warn, because the executable is not code-signed — a certificate that avoids
that costs several hundred dollars a year and requires a registered company. The warning is about
how many people have run this file, not about what it does. Choose More info → Run anyway, or
check the hash first, or put the file through VirusTotal.

Full detail, including everything the app writes and how each change is undone, is in the
repository's Trust and safety section.

---

Known limitations

• Not code-signed, so SmartScreen will warn.
• The hosts-file block can be refused by Microsoft Defender tamper protection. The app reports that
  rather than failing silently.
• Restore points need System Protection switched on for the system drive; if it is off, the app says
  so instead of pretending a restore point was created.
• Ultimate Performance is unavailable on some Windows editions. SysTuneX falls back to High
  Performance and reports which one it used.
• Cleanup deletes files and is the one action that cannot be undone from the change journal. The app
  says so before doing it.

SysTuneX 2.7.0

The monitor now measures what you ask it to, and nothing else.

The frame counter is a switch

It used to start itself the first time anyone opened the monitor page, and then stay running for
the life of the app. An Event Tracing session is a machine-wide resource that keeps consuming
kernel buffers for as long as it is open — leaving one running for a counter nobody is reading is
the opposite of what a tuning tool is for.

It is off until switched on, and switching it off closes the session rather than just hiding the
number. A second tick decides whether it keeps running after you leave the page: on, so you can
alt-tab into a game and read the numbers when you come back; off, and it stops the moment the page
does.

Starting a session takes long enough to be felt, so the switch shows that it is working, and a
refusal — usually missing administrator rights — is reported on the switch itself rather than only
as an empty tile.

Tick what you want to see

A panel on the monitor page, folded away because it is set once: CPU load and temperature, GPU
load, temperature and fan, memory, process count. Tiles you switch off are not drawn, and the row
closes up rather than leaving a hole. When nothing is ticked the page says so instead of showing
a blank screen.

The sensor sample — a WMI query and a call into the vendor's driver library — is skipped entirely
when no reading on the page needs it, rather than taken and thrown away.

Worth being precise about, since the panel says so too: this governs the monitor page. The tray
icon and the dashboard read temperatures on their own schedule regardless of these ticks.

---

---

Download

SysTuneX.exe below is a self-contained single file. No .NET runtime install needed. It requests
administrator rights on launch, because every change it makes needs a full administrator token.

Verify the download against SHA256SUMS.txt if you like:

Get-FileHash .\SysTuneX.exe -Algorithm SHA256

Windows SmartScreen will warn about an unsigned executable — the binary is not code-signed.
Choose More info → Run anyway if you are happy with that.

---

---

Known limitations

• Not code-signed, so SmartScreen will warn.
• The hosts-file block can be refused by Microsoft Defender tamper protection. The app reports that
  rather than failing silently.
• Restore points need System Protection switched on for the system drive; if it is off, the app says
  so instead of pretending a restore point was created.
• Ultimate Performance is unavailable on some Windows editions. SysTuneX falls back to High
  Performance and reports which one it used.