The manual

Install #

Download IdleMasterSetup.exe from Releases and run it. One file, about 675 KB, with the app carried inside it as an embedded resource.

It installs to %LOCALAPPDATA%\Programs\IdleMaster — your own profile, so installing needs no administrator. The app elevates itself when it runs, which is where admin is actually needed: stopping a Windows service requires it. You get a Start Menu shortcut, a normal entry in Installed apps, and the offer of a logon task for the sentry.

Silent, for scripts

IdleMasterSetup.exe --silent                        install or update, no window
IdleMasterSetup.exe --silent --dir D:\Apps\IdleMaster somewhere else
IdleMasterSetup.exe --silent --desktop              ...and a desktop shortcut too
IdleMasterSetup.exe --silent --relaunch             ...and start Idle Master when done
IdleMasterSetup.exe --uninstall                     remove it, keep your config

Portable

You do not have to install at all. IdleMaster.exe from Releases (or from dist\ if you built it) runs from any folder. It writes its config, log and state file next to itself, so a copy on a USB stick stays entirely self-contained.

First run #

1. Run --report before anything else. It touches nothing. It prints every process and service that is costing you RAM and tags each one with the mode that would close it, so you see the plan before anything dies.
2. Read the rows tagged IDLE. Those are the ones that close your browser and your shell. If something there is precious, put it in [protect] now — see the lists.
3. Press BOOST NOW. It takes about three seconds and leaves everything you opened yourself alone.
4. Try Restore desktop. Doing it once while you are awake and sitting in front of the machine is worth more than reading about it.

IdleMaster.exe --report

Updating and uninstalling #

Updating is the same file. Run a newer setup and it replaces the exe in place. Your idlemaster.ini is never overwritten.

Or let the app do it. It asks GitHub on its own — a minute after start, then every UpdateCheckHours (6 by default; 0 turns it off) — and if there is something newer you get a tray toast, the arrow in the top right corner of the window turns green, and the tray menu grows an Update now. One click on that arrow downloads that release's installer, hands over to it silently, pointed at the folder this copy is running from — so a portable copy updates itself where it stands — and Idle Master comes back on its own with your idlemaster.ini untouched. The arrow is white while there is nothing to say, and clicking it then asks right now and tells you where you stand — v0.25.1 is the newest, or v0.26.0 is available. Nothing downloads until you click.

Uninstall from Installed apps like any other program, or run IdleMasterSetup.exe --uninstall. Either way it stands the sentry down first and leaves your config file behind, in case you come back.

The two modes #

Both work off the same lists in idlemaster.ini. Idle is applied on top of boost — it runs both sets of lists, not a separate one.

Idle mode ignores the foreground and open-window guards on purpose. The premise of the mode is that nobody is there to lose work.

Restore #

Every run writes idlemaster.state with the exact list of what it stopped. Restore desktop (or --restore) walks that list backwards: it starts the services again, relaunches whatever is listed in [restore.launch], and brings back explorer.exe if idle mode left the machine without a shell — normally it does not, because Windows rebuilds the session itself.

Restore disarms the sentry first. If it did not, the sentry would shoot everything Restore just brought back on its next sweep, twenty seconds later.

The sentry appends to the same state file, so anything it re-stops hours later still gets undone by a Restore you run tomorrow.

The sentry #

A boost is a snapshot. Twenty minutes later WebView2 has respawned for a tray icon, WSearch has trigger-started itself and Razer's launcher is back. The sentry is a background thread that re-applies the same lists on a timer, so the RAM stays where you put it.

It enforces whichever mode ran last — the boost lists after Boost Now, the full idle lists after Absolute Idle — and it stands down the instant you hit Restore. In the window it is the Sentry: keep hunting checkbox with a live count of what it has reaped; on the command line it is --watch and --unwatch.

Two brakes

• Respawn backoff. If one process name comes back SentryRespawnLimit times (6 by default), the sentry stops fighting it for SentryBackoffMinutes and writes a line saying so. Something on the machine clearly wants that process alive, and an endless kill/respawn loop burns more CPU than the process ever cost you in RAM. After the backoff it puts the name back and tries again.
• Open windows are sacred. With SkipOpenApps=1, boost never touches a process whose app has a window on the desktop — helper processes included. WhatsApp and Discord do their real work in msedgewebview2 workers, and killing those crashes the app even though its own name is not on any list. Close the window and the leftovers get reclaimed on the next sweep. SentrySkipForeground=1 is the narrower version: never kill the window you are actually looking at.

Two things worth knowing before you leave it on

• The sentry is the thing that stops you re-opening apps on the kill list. If you boost and then want Discord back, uncheck the box (or run --unwatch) first, otherwise it dies within 20 seconds.
• Only one sentry runs at a time. A second one refuses the watch and says so. Closing the window stops the thread but leaves the watch armed, so opening Idle Master again picks it up where it left off.

Surviving a reboot

--installtask registers a logon scheduled task called IdleMaster Sentry, running with highest privileges, so the watch comes back after a restart. It is off unless you ask for it; --removetask deletes it.

Everything the sentry does goes to idlemaster.log, and only when it actually acts — a quiet night leaves no lines at all.

Being asked first #

On its first sweep the sentry takes a census. Everything running then that matches a list is the junk the mode was aimed at, and dies without a word. Anything that appears after that is something you deliberately started, so it gets a toast in the corner instead of a bullet.

Network guard #

The sentry guards the RAM; the network guard guards the way back in. A headless laptop that is only ever reached over Sunshine-through-Tailscale is useless the moment its Wi-Fi drops, its DHCP lease goes stale, tailscaled stops, or Sunshine sits alive without listening — and nothing on the machine will notice except you, from somewhere else, too late.

So whenever Idle Master is running — window, tray, --watch or --guard — the guard checks every NetworkGuardSeconds (60), in this order, and repairs the first thing that is wrong:

Each check that still finds trouble reaches one rung higher up that ladder. After six in a row it keeps measuring every minute but only repairs every fifth one, so a router that is genuinely off does not get the adapter bounced all night. The moment a check comes back clean it says how long the outage was and what fixed it, and goes quiet again.

The VPN that cannot be turned off

Stop a VPN client after it has been connected and it can leave its adapter up holding two routes — 0.0.0.0/1 and 128.0.0.0/1 — pointed at a gateway that died with the tunnel. Between them those two cover the whole address space and they are more specific than the real default route, so they win however good its metric is. The DNS servers left on that adapter only ever resolved through the tunnel. The machine then looks online: the router still pings, because that is a directly connected route, and nothing else works. Turning the VPN back on appears to fix it, which is how people end up believing the VPN can never be switched off.

The guard removes that residue — the two dead half-routes and the adapter's DNS. Every step is gated on no service of that VPN running: all of it is legitimate while the tunnel is up, and the client rebuilds it on the next connect, so a live tunnel's configuration is never touched. It runs before the guard tries restarting a stopped network service, because restarting the VPN is the wrong repair for this.

Two rules it will not break

• It never drops a link that Tailscale is still up through. An internet probe can be firewalled; your session cannot be argued with.
• It never rebuilds a working link more than once in 15 minutes, or bounces an adapter more than once in 10.

Wi-Fi

It uses the Windows WLAN API directly, not netsh, so it works in any language. It can only join networks Windows already has a profile for — connect once by hand and it can reconnect forever; it cannot type a password. [network.wifi] says which networks to try first (saved profile names, * works); after those it tries every other saved profile. It is edited under the Network guard page (and Settings › Advanced › Network guard), with a picker of the saved networks.

It never asks for location. Windows 11 counts a Wi-Fi scan — and even naming the network you are on — as knowing where you are, and prompts you to allow it. By default the guard does neither: reconnects go by [network.wifi] order, then Windows' own saved order, and the status line just says Wi-Fi. Set NetworkGuardScan=1 and it scans (in-range networks first, strongest first, the name shown, the picker marks what is in range) — Windows asks for location permission once, for Idle Master.

NetworkGuardKeepWifiAwake (on) also tells the power plan and the adapter not to switch the Wi-Fi off to save energy — the usual reason a headless laptop falls off the network at 3am. Best effort; silent when the driver has no such knob.

Where it shows

Quiet while all is well. Every fix is one line in idlemaster.log, every outage one trouble line and one back after line. In the window it is the Network guard button — red while the guard is fighting something — which opens its own page: the four-line picture of what it last saw, Check now, its switches, the check interval, and the [network.wifi] list with a picker of the saved networks. The tray has Network guard... and Check the connection now. Closing the window while it guards hides to the tray, like the sentry. Only one guard runs at a time; a second Idle Master says so and leaves it to the first.

On the command line, --network does one check-and-fix and prints the picture (exit 0 = all up, 1 = something still is not), --guard sits in the tray running only the guard, and --installtask --guard makes that happen at every logon.

The windows #

Under the two mode slabs the buttons are grouped into four named bands, each one running the full width of the window:

Two things ride on the slabs themselves rather than in a band: the handle on the left of each one opens the list that mode kills, and the dial on the right of BOOST NOW is the repeat loop below. The arrow in the top corner is the update check — white while there is nothing to say, green once a release is out, one click to install.

Sentry lists & timers (button on the sentry row, and on the tray menu) is the sentry's own page: the active mode's kill list and service list as checklists — add from what is running, type a name, remove, untick to comment out — plus every timer it runs on and the two boost again knobs: a whole pass every N minutes (SentryFullPassMinutes) and a whole pass the moment free RAM drops under a line (BoostWhenFreeBelowMb). Save re-reads the config; a running sentry uses the new lists on its next sweep.

Repeat boost every N minutes

The refresh arrow on the right of BOOST NOW, with the interval inside the ring. Clicking the arrow does not boost — it opens a small menu: on/off, a spinner for any number of minutes up to a day, and the usual 5 / 10 / 15 / 30 / 60 / 120. From then on the window presses that button on that interval — the same lists, the same asking, the sentry re-armed after each pass. The ring fills as the next one comes round and the tooltip counts it down; a boost that is still running only pushes the clock, so two never stack. It lives in the window (close Idle Master and the loop is over), the interval is kept in RepeatBoostMinutes so it arms itself again next launch, and the tray menu carries the same toggle. Not to be confused with SentryFullPassMinutes, which is the sentry doing a full pass inside its own watch.

What's eating RAM?

The Master's own little task manager: a live table that refreshes every two seconds and tags each row with the list it is on (BOOST IDLE KEEP). Right-click any row for End it now, Close on every boost, Also close on absolute idle, or Never touch. Each choice is written straight into the ini, dated, and picked up by a running sentry on its next sweep.

This is the fastest way to tune the lists, and it is the reason most people never open the ini by hand.

Settings, and Advanced settings

Settings holds the switches most people touch — sentry on/off, ask-before-kill, tray, sweep interval, emergency trim — in plain words. Advanced settings… behind it is the whole config: every switch as a checkbox, every interval as a number, and each list as a checklist you can add to from what is running right now, sorted by how much RAM it is costing (or, for services, by display name).

Unchecking an entry comments it out rather than deleting it, so the suggestions that ship commented-out are visible and one click from being live. Saving re-reads the config immediately — no restart.

Disk cleanup #

Separate from anything to do with RAM, and deliberately timid. The cleanup window only suggests. Nothing is deleted until you tick it and press Clean, and everything ticked goes to the Recycle Bin, not into the void.

It scans for temp files, caches, Windows update leftovers, old installers sitting in Downloads untouched for CleanupInstallerDays, big folders over CleanupBigDirMinMb, and possible leftovers from uninstalled software. Rows are marked safe or review — a big folder is a finding, not an accusation.

Two exceptions to the Recycle Bin rule: emptying the Recycle Bin row itself is permanent (that is what it means), and anything matching [cleanup.protect] is never touched at all, whatever the scanner thinks. That section takes full paths, supports *, and a path protects everything underneath it.

The one thing that is not recycled

C:\Windows\SoftwareDistribution\Download is routinely several GB spread across hundreds of thousands of files. Sending that to the Recycle Bin means moving every file individually, each with its own metadata record: it runs for hours, and when it finishes the bin is holding all of it, so nothing is actually freed until you empty the bin as well. Those are deleted outright. Windows' own Disk Cleanup does the same, and they are payloads for updates that are already installed.

The confirmation lists by name anything going for good and what it adds up to, so the exception is never a surprise. Everything else still goes to the bin.

Three views of the same scan

• Findings — the default. Every finding opens into what is actually inside it, biggest first, with an owner column naming the app the bytes belong to and a safe or review verdict.
• Drive tree — the whole of C: as a tree, sorted by size, the way a disk-space tool shows it.
• Drive map — the same walk as a treemap. Click a block to see what it is, double-click a folder to go in, up to come back. Right-click gives the same verdicts as the list.

While it is running

Each item names itself before it starts, with its size, and says whether it is going to the bin or for good — the item that takes a long time is the one you most need named. Stop cleaning is honest about its limit: a single shell delete cannot be called off once Windows has it, so Stop prevents the next item starting and tells you it is finishing the current one first.

IdleMaster.exe --cleanup-report prints the same findings to a console and deletes nothing, ever.

Debloat #

The Store apps nobody asked for. Debloat (main window, second band) asks Windows what is installed, groups it, and shows every package with its category, its package name and how much disk it is holding. Nothing happens until you tick something and press Remove.

Groups, in the order they are listed: Preinstalled junk, Sponsored apps, Xbox & gaming, Microsoft extras, Everything else — top-down from "tick it" to "your call". Anything Windows itself marks as non-removable, and every framework package, is left out of the list entirely.

This one is not a boost. Removing is an uninstall: no reboot brings it back, and the only undo is the Store. That is why it sits in the same band as disk cleanup rather than next to the two mode slabs.

The machine's own lifelines are protected in code, where no ini edit can reach them: the Store, its purchase app, the App Installer and winget, Windows Terminal, the Security health UI, Edge, the app runtimes, WSL, the language and handwriting packs, the video and image codec extensions, and the NVIDIA display stack. Losing the Store means losing the way to undo a removal, so the remover is never pointed at it.

[debloat.protect] adds your own — package names as Get-AppxPackage lists them, * works — and that list wins over every suggestion. IdleMaster.exe --debloat-report prints the same table to a console and removes nothing, ever.

Remote desktop setup #

The network guard keeps the link, Tailscale and Sunshine alive on its own. This page adds your apps to that watch, so a machine you only reach from another room is checked for the things you actually reach it with.

[remote.apps] is the list — process names, * works. The window offers the common streaming and remote tools first, but anything can be added, and the live picture at the top shows the guard's four lines followed by one line per app.

Calibrated reconnects

Get everything connected the way you like it — stream running, apps signed in — and press Calibrate now. The guard records each app's exe, its service, and the ports it is listening on. From then on every check also checks that list: an app that is gone, or no longer on its calibrated ports, is restarted or relaunched until the picture matches again.

Calibrate saves the list first, so what you see ticked is what gets calibrated. Apps that are not running are skipped — start them, then calibrate again. Timing, Wi-Fi and the guard's own switches live on the Network guard page, not here.

Report a bug #

Something looked wrong; say so without leaving the app or hunting for the repo. Report a bug (main window, bottom band) writes the report for you: which build, which Windows, whether it was running elevated, and the last lines of idlemaster.log — which is usually the difference between a report somebody can act on and one nobody can.

Nothing leaves the machine by itself. The preview shows the report byte for byte before anything happens. Pressing the button opens github.com in your browser with it pre-typed, and the Submit press over there is the sending. Close the browser tab and nothing was sent.

The log tail is the part worth reading before you send: it is your machine's process and service names. Edit anything out of the preview that you would rather not publish — it is an ordinary text box.

Backup kit #

For the day you reinstall Windows. Backup kit (main window, tray menu) opens a window with two lists and a few switches, and writes one zip that can put a fresh install back the way this one is.

• Apps — it asks winget what is installed. Everything with a winget or Store package is listed with its id and pre-ticked; things Windows ships (Edge, WebView2, the VC++ runtimes) start unticked; things winget cannot reinstall are listed greyed, so you at least know what to fetch by hand.
• Files and folders — Documents, Desktop, Pictures and .ssh start ticked; Downloads, Videos and Music are listed but off (they are usually the big ones). Add folder / Add file take anything else. Sizes are counted in the background; junctions and symlinks are skipped so nothing loops.
• On the new machine, also: install Idle Master with this idlemaster.ini; run zoicware/RemoveWindowsAI (Copilot, Recall, the lot — non-interactive, all options); apply a Chris Titus WinUtil preset without clicking (Standard, Minimal or Advanced); and leave WinUtil open at the end for anything more you want from it.

The zip holds IdleMasterRebuild.exe, a plain-text rebuild.ini with everything you picked (edit it if you like), an apps.json in winget import format, files\, your idlemaster.ini, and — when the app finds its own installer next to it — IdleMasterSetup.exe of the same version, so the rebuild works offline apart from the two scripts. Nothing on this machine is changed by building a kit.

On the fresh Windows: extract the whole zip, run IdleMasterRebuild.exe (it asks for administrator), tick, press Rebuild, read the log. Files go back where they were — the old profile path is remapped to the new account, so a different user name is fine — or into Desktop\Restored files if you prefer; existing files are left alone unless you say otherwise. Apps go through winget install one at a time, so one failure costs one app. If the kit carries no installer, the Idle Master step downloads the latest release. IdleMasterRebuild.exe --auto starts with whatever the ini says ticked and no click.

idlemaster.ini #

Written on first run, next to the exe. Plain text, edited line by line by the Settings window so every comment in it survives being saved.

• One entry per line.
• * is a wildcard — LenovoVantage-*, vmmem*.
• # at the start of a line switches it off.
• Process names are matched without .exe — writing .exe is fine, it gets stripped.
• Matching is case-insensitive.

Two entries ship deliberately commented out, because they are the ones that can bite you from bed:

• NvContainerLocalSystem hosts the NVIDIA App. Some drivers get unhappy about NVENC when it is gone, and a black stream is exactly what you cannot debug asleep. Test a stream without it before enabling.
• powershell / WindowsTerminal in [idle.kill] — enable only if you never leave a long job running overnight.

Every setting #

All of these live under [settings]. Booleans are 1 or 0.

What a run does

The sentry

Asking first

Disk cleanup

Network guard

The lists #

Why Docker is protected, not killed

It used to be in [idle.kill]. It is in [protect] now: containers you left running matter more than the ~700 MB the backend costs, and the engine costs almost nothing once it is idle. Delete it from [protect] if you would rather have the RAM.

Command line #

Everything the window does, scriptable. Running any mode needs administrator — the app elevates itself.

IdleMaster.exe                   open the window
IdleMaster.exe --boost           boost mode, no UI
IdleMaster.exe --idle            absolute idle, no UI
IdleMaster.exe --restore         undo the last run (also stops the sentry)
IdleMaster.exe --report          print what's eating RAM, and the plan
IdleMaster.exe --cleanup-report  scan the disk, print findings, delete nothing
IdleMaster.exe --debloat-report  list the removable Store apps, remove nothing
IdleMaster.exe --boost --watch   boost, then keep hunting
IdleMaster.exe --watch           take up the watch for whichever mode ran last
IdleMaster.exe --unwatch         stop the sentry
IdleMaster.exe --network         check link + internet + Tailscale + Sunshine, fix what is down (exit 0 = all up)
IdleMaster.exe --guard           sit in the tray running only the network guard
IdleMaster.exe --installtask     run the sentry (and the guard) at every logon
IdleMaster.exe --installtask --guard   ...or only the network guard at logon
IdleMaster.exe --removetask      undo that

A watch does not run as a console loop — it runs as a tray app, because it needs a message pump to put the something just started dialog on screen. Starting a second watch while one is running prints a sentry is already on watch and exits with code 1.

The trim notice #

Up to v0.25 Idle Master trimmed working sets and purged the standby list at the end of every boost, and again every ten minutes for as long as the sentry was armed. That was wrong — see TrimWorkingSets for why — and v0.26 stopped doing it.

But updating keeps your idlemaster.ini exactly as it found it, which is the right promise to keep and also means a machine that has been running Idle Master for a while carries the old setting forward and goes on trimming. So it gets told, once, on the same frosted pane the theme picker uses: what it has been doing, why that stopped being the default, and two buttons — Stop trimming automatically, which writes TrimWorkingSets=0 and ClearStandbyList=0, or Leave it as it is, which changes nothing.

Either answer writes TrimNotice=1 and it never comes back. A prompt that reappears every start is a nag, and the point of the change was to stop doing things to your machine you did not ask for. A fresh install ships TrimNotice=1 and never sees the pane at all; neither does a machine that had already turned trimming off by hand. Trim RAM now stays on the window either way.

Themes #

The first time Idle Master opens it starts normally — gauge reading, log already saying Ready — and then the window goes soft behind frosted glass while one card asks what it should look like. You are asked once, ever. Answering it or dismissing it both write ThemeIntro=1; after that the door is Settings → Theme… or the tray menu.

Switching is instant — no restart. The outgoing palette is lined up against the incoming one and every control on screen wearing colour N of the old look is handed colour N of the new one. The single exception is the window frame: changing that rebuilds the window handle, which would drop the tray icon and every running timer, so a theme that asks for its own title bar says so in the log and applies it next start.

Writing your own

A theme is a plain text file — no plugin, no DLL, no code. All three built-ins are written into themes\ next to the exe on first start precisely so there is something to copy. Nineteen colours, two font families, and six keys for shape; anything you leave out or mistype keeps the default, so a typo costs one colour rather than the app.

name=Midnight
bg=#0d0f14        the window itself
fg=#e2e6ec        normal writing
accent=#8fc1f0    titles and captions
good=#1e4e78      BOOST NOW and every primary action
danger=#6e2830    ABSOLUTE IDLE and every destructive one
onaccent=#ffffff  writing ON those - flip it for a light theme
ready=#38aa68     ONLY the corner arrow when a release is waiting

radius=4          corner rounding, 0-24
gradient=22       how much lighter the top of a slab is, 0-90
glow=64           accent bloom just inside the edge, 0-255
borderwidth=1     outline on every button, 0-4
chrome=custom     the theme draws the title bar, not Windows

Save it as themes\midnight.imtheme, restart, and it is in the picker. Delete the file and the theme is gone; delete a built-in’s file and the compiled-in copy comes back, so the app can never end up with nothing to draw with.

Every shape key is off by default, and off means WinForms paints the button — the same code path the app has always used, not an imitation of it. That is tested, not asserted: the regression check builds a window in Minimalistic, switches it to another theme at runtime, and requires zero of 564,900 pixels to differ from a window that started that way.

Getting more

The extra themes are not in the installer, on purpose. Idle Master is one small download; shipping a gallery of looks most people never open would make every install bigger and every update slower, for paint. Three live inside the app and the rest are fetched only if you ask.

Get more themes pulls IdleMasterThemes.zip from the same GitHub release the app updates itself from and unpacks the .imtheme files into themes\. A few KB of text — themes hold no images and no code, which is why they are safe to pass around. Only .imtheme entries are read, only the last segment of each name is used, and anything that will not parse afterwards is deleted rather than left in the picker doing nothing.

Files and paths #

The runtime files live next to the exe — for an installed copy, %LOCALAPPDATA%\Programs\IdleMaster.

In the repository: src/IdleMaster.cs is the engine, config, sentry, updater and CLI entry point; src/NetGuard.cs is the network guard — the WLAN API wrapper, the measuring, the repair ladder; src/Ui.cs is every window; src/Cleanup.cs is the disk scanner; src/DiskScan.cs reads the drive's file table and src/TreeMap.cs draws it as a map; src/Debloat.cs is the Store-app remover; src/Vpn.cs is the stopped-VPN residue the guard clears; src/Feedback.cs is the bug-report door; src/Backup.cs is the backup kit (inventory, zip writer, window); src/Rebuild.cs is the standalone exe that ships inside a kit; src/Theme.cs, src/Themes.cs, src/Skin.cs and src/ThemeGate.cs are the palette, the three built-in looks, the painting and the first-run picker; src/Setup.cs is the installer, which carries the app as an embedded resource. src/idlemaster.ico is the icon, drawn by make-icon.ps1.

Recovery #

The desktop is gone — blank screen, no taskbar

This should not last. With KillExplorer=1, absolute idle terminates the shell and Winlogon rebuilds the session within seconds — a black flash, then the desktop, taskbar and Start menu back and fresh. If the rebuild never arrives, Task Manager is hosted by winlogon, not explorer, so it still works with no shell running:

1. Ctrl+Shift+Esc to open Task Manager.
2. File → Run new task.
3. Browse to IdleMaster.exe and run it, ticking administrative privileges.
4. Press Restore desktop.

In a hurry, Run new task → explorer.exe brings the desktop straight back — but use Restore afterwards so the stopped services come back too. Note that a shell raised by hand this way may have a Start button that answers nothing: the packaged hosts cannot be launched by path, they only return with a real session, so sign out and back in if Start stays dead. And if you would rather never see this screen at all, set KillExplorer=0.

A reboot fixes everything

Nothing is ever disabled, only stopped. If you cannot reach the machine any other way, a power cycle returns it to normal — no Idle Master involvement required.

Something keeps closing an app I want

That is the sentry enforcing the last mode. Uncheck Sentry: keep hunting, or run IdleMaster.exe --unwatch. To keep the app permanently, add it to [protect] — via Never touch in What's eating RAM?, or by hand. If you also registered the logon task, --removetask stops it coming back tomorrow.

Troubleshooting #

A service will not stop

Defender is the usual one: tamper protection will normally refuse WinDefend, whatever any list says. That refusal is Windows working correctly. Some vendor services also restart themselves within seconds — that is what SentryServiceMinutes is for.

The same process keeps coming back

After SentryRespawnLimit returns the sentry writes respawned 6× — backing off 30 min and leaves it alone. Something on the machine wants it alive. Either accept it (add it to [protect] and stop paying the CPU) or find what starts it — usually a scheduled task or a tray helper you can disable at the source.

The RAM number barely moved

Run --report and look at what carries no tag. Idle Master only closes what is on a list, and the shipped lists were written from one real machine. Yours has different junk on it. Add rows from What's eating RAM? and the numbers change.

My remote session dropped

Put every piece of your remote-access stack in [protect.services] and its processes in [protect]. The network guard then checks that each service is running, that its port is listening and that the adapter is up — before the run finishes, and repeatedly during idle mode. The shipped example is a Sunshine + Tailscale pair because this is a streaming host; swap in RDP, Parsec, Moonlight, SSH or your own VPN.

If the machine fell off the network rather than a service dying, that is the network guard's job: it reconnects Wi-Fi, renews the lease, restarts Tailscale and Sunshine, and writes what it did. Read the [guard] lines in idlemaster.log; if they end in Tailscale needs a login, that is the one thing it cannot do for you.

Bad idlemaster.ini

The app says so on startup and points at the line. The safe fix is to rename the file and let it write a fresh default on the next run — you lose your customisations, not your machine.

Build from source #

It compiles with the .NET Framework compiler that already ships inside Windows. No SDK, no NuGet, no internet.

powershell -ExecutionPolicy Bypass -File build.ps1

Outputs dist\IdleMaster.exe and dist\IdleMasterSetup.exe, the app embedded in the installer.

License #

FSL-1.1-MIT — the Functional Source License, with an MIT future grant. Copyright 2026 Mild-Solvent. In plain words, and the file is what actually counts:

• Use it however you like. At home, at work, on one machine or five hundred. Fork it, patch it, redistribute it, build on it. No fee, no permission needed.
• Keep my name on it. Redistribute it and the copyright notice goes with it.
• Don't sell my tool as your product. The one forbidden thing is a competing use — packaging this into a commercial product or service that substitutes for it. If you want to do that, ask; I'm reachable through GitHub and open to it.
• It becomes MIT in two years. Every release picks up a plain MIT license on the second anniversary of its publication, automatically and irrevocably.