Freespace

A fast, safety-first disk scanner and cleaner for Windows.

Scan a whole drive in seconds, see exactly what is eating your space, and reclaim it without the fear of deleting the wrong thing.

Download for Windows  ·  Website  ·  Releases  ·  Report a bug

---

Table of contents

• Why Freespace
• Features
• What it cleans
• How it keeps you safe
• Installation
• Building from source
• Testing
• Releasing
• Architecture
• Contributing
• Acknowledgements
• License

Why Freespace

Most disk cleaners are either too timid to free real space or too aggressive to trust. Freespace reads your whole drive in parallel, groups everything it finds into clear categories, and labels every single item Safe, Review or Do not delete, with a reason and a note on how to get it back. Nothing is touched until you tick it and confirm.

It is built for everyday users and developers: alongside temp files and Windows leftovers, it finds the gigabytes hiding in node_modules, build output, Python environments and tool caches.

Features

Scanning

• Blazing-fast, parallel scan. Walks millions of files in seconds across all CPU cores, with live progress and a stop button.
• Any drive or any folder. Pick a drive from the list, or paste a folder path such as D:\projects to scan just that.
• One scan, every view. Cleanup, space usage and large files all come from the same scan, so switching pages is instant.

Smart cleanup

• Grouped by category. Findings are sorted into clear categories (temp files, caches, node_modules, and more) with their total size.
• A safety label on every item. Each one is Safe, Review or Do not delete, with a reason and a "how to get it back" note.
• Filter, search and sort. Show only Safe, Review or Protected items, filter by path, and sort by size, path or category.
• Details before you delete. Open any item to see why it was flagged, or jump to it with Show in Explorer.

Space usage explorer

• Biggest-first folder browser. Drill into any folder and see exactly where the space went.
• Interactive treemap. A visual map of the current folder, sized by what each child takes up.
• Delete any folder in one tick. Mark folders straight from the explorer; protected paths stay locked.

Project analyzer

• Every code project on the drive. Node.js, Rust, .NET, Python, Go, Java, Flutter, PHP and more, found by their project files and git repositories, with monorepos counted as one project.
• What each one really costs. Total size, your own files, and what can be rebuilt: node_modules, target, bin/obj, .next, .venv, dist, .pnpm-store, test reports and the dependencies of agent worktrees. Your source code is never offered for deletion.
• Active or dormant. Last activity comes from file edits and git history. Projects untouched for 90 days are marked dormant, and one click ticks everything safe in them.
• Checks before it recommends. node_modules without a lockfile, a virtual environment without a requirements file and build output committed to git all drop to Review, and every item shows how to get it back, such as pnpm install or git restore dist.
• Reads git without running it. Scanning a drive can reach folders you do not trust, and a repository's config can make git run programs, so Freespace only reads the files in .git.

Large file finder

• Surfaces the biggest files on the drive, wherever they hide, so old ISOs, videos and installers stop slipping through.

Full clean

• Everything safe in one go, plus Windows rollback leftovers such as previous Windows installations.
• Deeper system cleanup with optional DISM component store cleanup (optionally with /ResetBase to drop update backups) and hibernation file removal.
• Preview first. See the per-category breakdown and total, then run it or just pre-select the items to review them yourself.
• Shortcut to Reset this PC for when you want a truly fresh Windows.

App uninstaller

• Desktop and Microsoft Store apps in one list, with publisher, version, install date and size.
• Search, filter and sort by name, publisher, install date or size.
• Leftover sweep. After uninstalling, Freespace looks for the folders the app left behind and lets you remove them.
• Broken entries. Remove stale entries for apps that are already gone from disk.
• Reset app data. Delete an app's settings, sign-ins and local data so it starts like a fresh install, while the program stays installed. Tick several apps to reset them together.

Safe by design

• Recycle Bin mode. Send items to the Recycle Bin instead of deleting them permanently.
• Clean report. A summary after every clean of what was removed, what was skipped, and how much space came back.
• Runs as administrator. Asks once per launch through the Windows prompt, so system caches can be cleaned. Say no and it still runs as a normal user, and offers to restart elevated from the top bar. See How it keeps you safe for the full picture.

In the background

• Lives in the tray. Closing the window keeps Freespace running; click the tray icon to come back, or use Quit in its menu to exit. It starts in the tray too, once you have run a first scan. Launching it again opens the window that is already running.
• Rescans on a schedule. Repeats your last scan every 30 minutes to once a day (1 hour by default), or never. The tray tooltip shows how much can be cleaned. It only reads the disk: nothing is ever deleted without you.
• Stays out of your way. A rescan waits while you are using the window or have items ticked.

Built to be fast to use

• Keyboard-first lists. Every list page can be driven without the mouse:

  Key	Action
  Up / Down	Move through a list
  Space	Tick the highlighted row
  Del	Clean what is ticked
  Enter / Backspace	Open a folder / go back up
  Ctrl + F	Search
  Esc	Clear search, close a dialog

• Auto-updates. Installed copies check signed GitHub releases on start and every 6 hours, and offer a one-click update from the top bar.

• Lightweight. A small native Tauri app with no background service and nothing running when it is closed.

What it cleans

Area	Categories
Windows	Recycle Bin, user and system temp files, Windows Update cache, crash dumps and error reports, Windows logs, previous Windows installations and upgrade files, thumbnail cache
Apps	Browser caches, app caches, GPU shader caches, older app versions and downloaded updates, extracted driver installers, leftovers from uninstalled apps
Developers	node_modules, build artifacts, Python virtual environments, developer tool caches, log files
You decide	Large files, plus any folder you pick in the space usage view

How it keeps you safe

• Three clear labels. Every item is Safe, Review or Do not delete, so you always know the risk.
• Protected paths stay protected. Windows, installed programs, profile folders and .git directories can never be deleted, whatever you select.
• Double-checked in Rust. Every delete is checked against the safety rules a second time in the backend, right before it runs, and only for items that came from the current scan.
• Nothing happens on its own. Freespace deletes only what you tick and confirm, and Recycle Bin mode lets you undo.

Installation

1. Download Freespace-setup.exe.
2. Run it. The installer is per-user, so it needs no administrator rights, and it fetches the WebView2 runtime if it is missing.
3. Launch Freespace and pick a drive to scan.

Some cleanups (Windows temp, the Windows Update cache, other users' files and most uninstalls) need administrator rights, so Freespace asks for them through the Windows prompt each time it starts.

Requirements

• Windows 10 or Windows 11 (64-bit)
• Microsoft Edge WebView2 runtime (built into Windows 11, installed automatically otherwise)

Building from source

Prerequisites

• Rust (stable) with the MSVC toolchain
• Node.js 20 or newer
• Windows 10 or 11 with the WebView2 runtime

Run in development

git clone https://github.com/ezzdin-atef/freespace.git
cd freespace
npm install
npm run tauri dev        # the full app with hot reload

Working on the UI only? npm run dev runs the frontend in a browser against a fake backend (ui/src/dev/mock.ts), so no Rust build is needed.

Production build

npm run tauri build                   # NSIS installer + portable exe
npm run tauri build -- --no-bundle    # portable exe only

Output	Path
Installer	target/release/bundle/nsis/Freespace_<version>_x64-setup.exe
Portable exe	target/release/freespace.exe

The first bundled build downloads Tauri's NSIS tools, so it needs an internet connection.

Testing

cargo test               # Rust: scanner, safety rules, delete plans, a scan-plan-clean round trip
npm test                 # frontend unit tests (Vitest)
npm run check            # Svelte and TypeScript type check

Releasing

npm run release                     # prompts for the next version (patch / minor / major / custom)
npm run release -- -Version 0.2.0   # no prompt
npm run release -- -DryRun          # validate only

scripts/release.ps1 verifies that you are on a clean, up-to-date main, that tauri.conf.json, Cargo.toml and package.json agree, and that the new version is valid semver, newer than the current one and not yet tagged. It then bumps every version file (lockfiles included), runs the checks, commits Release vX.Y.Z, tags it and pushes.

The tag triggers release.yml, which builds the installer, signs the update and publishes a GitHub release with latest.json. Installed apps check that file on start and every 6 hours and offer "Update to vX.Y.Z" in the top bar.

The landing page lives in site/ and is deployed by pages.yml. It reads the latest release from the GitHub API, so it never needs a redeploy per release.

One-time setup for maintainers

1. Generate the updater signing key. Keep the private key secret: losing it means installed copies can no longer update.

   npx tauri signer generate -w ~/.tauri/freespace.key

2. Put the contents of ~/.tauri/freespace.key.pub in tauri.conf.json > plugins.updater.pubkey.
3. In the GitHub repo, add the secrets TAURI_SIGNING_PRIVATE_KEY (contents of ~/.tauri/freespace.key) and TAURI_SIGNING_PRIVATE_KEY_PASSWORD (empty if you set none).
4. Under Settings > Pages > Source, choose GitHub Actions.

Architecture

Freespace is a Tauri 2 app: a Rust backend does all the disk work and exposes a small set of commands, and a Svelte 5 + TypeScript frontend renders the UI in WebView2.

+---------------------------+        Tauri commands         +-----------------------------+
|  UI  (Svelte 5 + TS)      |  ------------------------->   |  Backend (Rust)             |
|  pages, treemap, dialogs  |  <-------------------------   |  scanner -> rules -> safety |
|                           |     progress events           |  cleaner, apps, updater     |
+---------------------------+                               +-----------------------------+

Layer	Stack
Backend	Rust, rayon for parallel scanning, Win32 APIs via windows-sys and winreg, trash for Recycle Bin mode
Frontend	Svelte 5, TypeScript, Vite
Shell	Tauri 2 / WebView2, with the updater and process plugins
Icons	Solar bold duotone, compiled to components at build time by unplugin-icons (picked in ui/src/lib/icons.ts)

Project layout

src/            Rust backend
  commands.rs   Tauri commands and progress events: the only surface the UI can call
  state.rs      session state and delete-plan building (ids are checked against the scan they came from)
  scanner.rs    parallel disk walk
  cleaner.rs    deletes with per-path safety re-checks
  projects.rs   groups dev findings by project, checks lockfiles and git
  safety.rs     what may and may not be deleted
  rules.rs      categories and matching rules
  apps.rs       installed apps, leftovers and uninstall
ui/src/         Svelte frontend
  lib/          API wrappers, session store, icons, formatting
  components/   buttons, table, dialogs, ...
  pages/        one file per page
icons/          app icons (generated from icons/source.svg with `npx tauri icon`)
capabilities/   Tauri permissions
scripts/        release.ps1: version bump, tag and push
site/           landing page for GitHub Pages
.github/        release and Pages workflows
docs/           design notes, including the migration from the earlier egui UI

Contributing

Contributions are welcome, from bug reports to new cleanup rules.

1. Open an issue to report a bug or discuss a feature before starting larger work.
2. Fork the repo and create a branch from main.
3. Make your change. New cleanup rules go in src/rules.rs; anything that affects what may be deleted belongs in src/safety.rs and needs a test.
4. Run cargo test, npm test and npm run check, and make sure they pass.
5. Open a pull request describing what changed and why.

Safety is the core promise of this app: changes that widen what can be deleted get extra scrutiny.

Acknowledgements

• Tauri for the lightweight desktop shell
• Svelte and Vite for the frontend
• rayon for effortless parallelism
• Solar icons by 480 Design

License

Freespace is released under the MIT License. Copyright (c) 2026 Ezzdin Atef.

If Freespace saved you some space, consider giving it a star.