My friend's laptop is full of junk nobody dares delete. So I built him a local AI that explains what's safe.

Tarun Tiwari — Mon, 05 Oct 2026 00:58:07 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Every one of my friends has the same laptop problem, and so do I. We download everything: installers, zips, ISOs, datasets, entire SDKs for one assignment. And we delete almost nothing. When the "C: drive is almost full" warning finally shows up, we open Downloads, delete a few obvious things and give up, because the rest of the space is hiding in places none of us know about.

My friend Kunal is the worst case. His laptop is always filled with random downloads, caches, trash and other things nobody remembers putting there. Cleaning it means guessing which folders are safe to delete, and since nobody wants to guess wrong, most of it just stays.

So I built DiskSage for him: a Windows app that scans the whole PC for junk, then has Gemma 4, running locally on the laptop, explain every finding in plain English: what it is, whether it's safe to remove, and why.

It looks in the places we never check:

Downloads, properly. It finds setup files for apps that are already installed (it reads Windows' installed-apps list and compares versions), unpacked installer folders, zips you've already extracted, half-finished downloads and old ISOs.
Hidden caches. Temp files, browser caches, the Chromium caches inside Discord, VS Code and Slack, GPU shader caches, crash dumps.
Developer leftovers. pip, npm, Gradle and Cargo caches, plus node_modules, .venv and Rust target folders in projects you haven't opened in months.
AI leftovers. Ollama models you don't use, Hugging Face and LM Studio downloads.
Mystery folders. Big AppData folders that don't belong to any installed app. No rule can say what they are, so Gemma identifies them.

There's also a Remove an app tab. It runs the app's official uninstaller, then finds the settings and data folders the app leaves behind. And there's an Ask tab for questions like "is it safe to delete WinSxS?", answered using what the scan found on your PC.

The first time I ran it on my own laptop, it found 25.4 GB that was safe to clean. The biggest single item was a 15.5 GB unpacked SOLIDWORKS installer still sitting in Downloads, long after the app was installed.

Demo

The demo runs in this order: scan → Gemma reviews every finding → it identifies the mystery folders → confirm cleanup → remove an app → ask a question. File names are blurred with DiskSage's own "Blur file names" button.

There's no live link, and that's on purpose: a hosted DiskSage would have to scan someone else's PC. Here are two screens up close.

Gemma identifying folders no rule could name. Here it spots the Android SDK and the Dart/Flutter package cache, both still in use, so it says keep:

Removing an app completely. DiskSage runs the official uninstaller, and Gemma explains each leftover folder. It warns that Arduino15 may hold your own sketches:

Code

ttspb1357 / disksage

DiskSage

Finds the junk on your Windows PC, and explains it with an AI that never leaves your machine.

My friends and I download everything (installers, zips, ISOs, datasets, whole SDKs) and delete almost nothing. Downloads is the junk you can see. The rest hides in temp folders, browser and app caches, node_modules, pip/Gradle/Cargo caches, driver installer leftovers and forgotten AI models.

DiskSage scans for all of it. A local, open-weight model (running in Ollama) then reviews every finding and explains, in plain English, what it is and whether it's safe to remove. Nothing is deleted until you tick it and confirm.

On my own laptop, the first scan took 5.5 seconds and found 25.4 GB that was safe to clean. The biggest single item was a 15.5 GB unpacked SOLIDWORKS installer sitting in Downloads.

What it finds

Where	Examples
Downloads	Setup files for apps you've already

…

View on GitHub

To try it on Windows:

ollama pull gemma4:e4b
git clone https://github.com/ttspb1357/disksage

Then double-click DiskSage.bat. It checks for Python and Ollama, installs what's needed and opens the page.

How I Built It

Stack:

Python + Flask for a small local web app.
Plain HTML/CSS/JS, with no build step and no CDN, so it works offline.
Gemma 4 (gemma4:e4b) running in Ollama on my laptop's RTX 4060. It uses 4.7 GB of the GPU's 8 GB.

 Scanner (Python, read-only)        Gemma 4 on this laptop            You
 ───────────────────────────        ──────────────────────            ───
 walks folders, measures,    ──►    verdict + reason for     ──►      tick what
 hashes duplicates, reads           every finding (JSON),             to remove
 installed apps, matches            identifies mystery                    │
 installers to apps                 folders, advises on apps              ▼
                                                              actions.py re-checks every path
                                                              → Recycle Bin, or delete if it rebuilds itself

What it found on my laptop

Finding	Size	Verdict
Unpacked SOLIDWORKS installer (app already installed)	15.5 GB	safe
pip, Gradle and Cargo caches	3.7 GB	safe
Rust `target` folder in a project untouched for 336 days	1.6 GB	safe
Setup files for 6 apps already installed (Anaconda, OBS, Arduino…)	1.4 GB	safe
Chrome and Edge caches	1.4 GB	safe
App caches (VS Code, Riot Client…)	1.3 GB	safe
Conda package cache	14.8 GB	review: "use `conda clean --all`"
ASUS driver folder `C:\eSupport`	6.1 GB	review: "MyASUS may still use it"
An Ollama model I no longer use	4.9 GB	review
Android SDK + Dart/Flutter cache (mystery folders)	3.0 GB	Gemma: keep, still in use
`hiberfil.sys` + `pagefile.sys`	~20 GB	keep, with how to shrink them properly

Rules find, Gemma judges

Python does everything that has a right answer:

walking folders and measuring sizes,
hashing files to find exact duplicates,
reading the installed-apps list from the registry,
matching a setup file like VSCodeUserSetup-x64-1.93.1.exe to "Microsoft Visual Studio Code".

Gemma does everything that needs judgement: what is this, is it safe, and what's the catch?

Every scan ends with one structured call to the local model. DiskSage sends the findings (titles, sizes, paths, the scanner's own notes) along with a JSON schema through Ollama's format parameter, so the answer always comes back as verdicts and reasons the app can use directly. This is a real one from my scan:

{
  "id": "F9",
  "verdict": "review",
  "reason": "This is a large cache for Conda packages; you should use the `conda clean --all` command in the Anaconda Prompt for the safest removal."
}

Mystery folders get a second, more focused call. The scanner can't name AppData\Local\Pub, but it can tell Gemma the folder's age and the names of a few things inside it. That was enough for Gemma to recognise the Dart/Flutter package cache.

Gemma can never delete anything

That's the rule I didn't compromise on, together with a second one: the model can only make a verdict more cautious, never less.

A small local model guesses wrong sometimes. The first model I tried confidently called my ASUS driver folder "installer leftovers for an Autodesk product". So:

the scanner's rules set the baseline,
the model's verdict only counts when it's stricter, and
facts (installed versions, sizes, known vendor folders) are measured and handed to the model instead of left for it to guess.

What went wrong (and made it better)

A wrong "safe". My first matcher decided python-3.10.0-amd64.exe belonged to Anaconda, because both mention Python, and marked the file "safe". Now the app's main name word has to match.
A broken installer waiting to happen. The unpacked SOLIDWORKS installer showed up as "duplicate" and "large" .cab files. Deleting one would break the installer, so unpacked installers are now detected and offered as one whole folder.
12 GB of free space disappeared. While I was testing, free space dropped 12 GB without DiskSage writing a thing. Windows had grown pagefile.sys to 17.7 GB while the model was loaded. DiskSage now explains that file instead of ignoring it.
"Restorable" wasn't always true. Windows silently deletes permanently anything bigger than the Recycle Bin's size limit, and everything when the bin is switched off. DiskSage now reads each drive's Recycle Bin settings and refuses those items, because "you can restore it" has to be true.
The top tip missed the biggest win. Gemma's first "do this first" tip pointed at a 283 MB Windows cleanup instead of the 15.5 GB installer. The fix wasn't a smarter model: DiskSage now tells it which finding is the biggest safe one.

Safety, tested

Your own files go to the Recycle Bin. Only things that rebuild themselves (caches, node_modules) are deleted permanently, and the confirmation dialog says which is which.
Windows, Program Files and OneDrive folders are never touched, and folder links (junctions) are never followed.
The local server only answers requests from its own page, so other websites can't send it commands.

I tested the delete code on a throwaway folder (18 checks), on Python 3.10 and 3.13. One check plants a junction trap pointing at "important" files; those files survived. Another simulates a switched-off Recycle Bin. I also clicked through the whole UI with a browser-automation script, with every destructive request intercepted (22 checks).

Why Does Open Innovation Matter?

Because the input to this app is a list of your file names.

To tell you what's junk, the model has to read names like Resume_final_v3.pdf, client project folders, bank statements and folders named after people. It also reads your AppData, which is basically a list of every app you've ever installed. A cloud API would receive all of that on every scan. With Gemma running in Ollama, the request goes to 127.0.0.1 and stops there. I wouldn't send a listing of Kunal's laptop to anyone, and with DiskSage I don't have to.

Open also made it practical:

It costs nothing to run. A scan summary is thousands of tokens, so with a paid API every rescan costs money. Locally, Kunal can scan every week for free.
It works offline. No account, no API key, and no internet once the model is downloaded.
I control how the model behaves, and which model it is. I can force structured output with a JSON schema and enforce the "only more cautious" rule. I started on DeepSeek-R1 8B and moved to Gemma 4 by changing one setting (DISKSAGE_MODEL); nothing else in the code changed.

Where closed would win: a frontier model knows more trivia, and would probably have named that ASUS folder correctly the first time. I chose privacy and zero cost, and designed around the smaller model's limits: measure the facts, let the model judge, never let it act alone. For a tool that reads your file list, that's the right trade.

Limitations

Windows only. It relies on the registry, Recycle Bin settings and Windows' folder layout.
OneDrive folders are skipped on purpose. Deleting a synced file deletes it from the cloud too.
It doesn't touch the registry. Registry "cleaners" cause more problems than they solve.
Microsoft Store apps aren't in the Remove-an-app list yet.
Gemma can still be wrong about what an unknown folder is. That's why its "safe" never overrides the scanner, and why mystery folders always need you to review them.

Prize Categories

Best Use of Gemma. Gemma 4 (gemma4:e4b) is DiskSage's engine, running locally through Ollama on a laptop GPU. It powers all four AI features:

the scan review,
mystery-folder identification,
app-removal advice,
the Ask tab.

Every call uses structured output, so Gemma's answers go straight into the interface as verdicts, reasons and notes. Across every test run (full scans, app advice and questions), it returned valid structured answers each time. A full review of about 18 findings takes 25–35 seconds and uses 4.7 GB of GPU memory, and no data ever leaves the PC.

DEV Community: Tarun Tiwari