FluentCleaner: a WinUI 3 CCleaner alternative that parses winapp2.ini

What FluentCleaner is actually for

The README frames the project as a reaction to how CCleaner changed after its early years. The author writes that he built his own take on a cleaner, inspired by the old CCleaner from the 2006 era, and lists what he wanted to avoid: spyware, scareware, dark patterns, upsell prompts and what he calls fake registry magic. That is a positioning statement, not a feature list, but it points at the actual audience: people who already know which files they want gone and do not want a wizard deciding for them.

The second audience is the winapp2.ini community. The README credits that signature ecosystem with keeping CCleaner relevant, and FluentCleaner's design bet is that those signatures are the valuable part, not the GUI. If you maintain or read winapp2 entries, this project treats your file as the source of truth rather than as an optional add-on.

One engine, two front ends, one parser

The repository is split into FluentCleaner.Core, FluentCleaner.Classic, FluentCleaner and FluentCleaner.Inspector. The README states that Core is netstandard2.0 and holds the scan and clean logic plus the winapp2.ini parser, and that both shipped editions share it. That is the whole architecture in one sentence: the UI is replaceable, the engine is not.

The consequence is visible in the download table. The WinUI 3 build is .NET 10 plus Windows App SDK, self-contained, roughly 140 MB unpacked across 243 files. Classic is .NET Framework 4.8 WinForms, framework-dependent, roughly 3.57 MB across 20 files. Same cleaning behaviour, a 40x difference in payload. The README also notes the platform split: the modern build needs x64 or ARM64 on Windows 10 build 17763 or later, while Classic runs on practically any Windows because it borrows the .NET Framework already present on the machine.

FluentCleaner.Inspector has no description in the README. Based on the name and the repository layout it appears to be a separate tool in the same solution, but the documentation does not say what it inspects, so treat it as undocumented until you read its source.

Installing FluentCleaner with winget or a portable zip

The modern WinUI 3 edition is published in Windows Package Manager. The README gives this exact command, and the package ID must be matched exactly:

winget install --id Builtbybel.FluentCleaner --exact

To move an existing install to the current release, the README gives the upgrade form:

winget upgrade --id Builtbybel.FluentCleaner --exact

WinGet only carries the modern edition. FluentCleaner Classic stays a portable download, which is consistent with its 3.57 MB size and its framework-dependent design.

Before launching the modern build, install the runtime separately. The README points at the exact Windows App SDK 2.0.1 x64 runtime and warns that an older or newer runtime will not work, and that you should restart Windows afterwards so the runtime can register. If the app fails with Unknown Hard Error or refuses to start, that mismatch is the first thing to check, and the README directs reports to issue #85 with the exact error and your Windows version.

The first real use is a scan, then a review, then a clean. FluentCleaner does not hide the middle step: the point of the winapp2.ini approach is that the entries are readable text, so open Winapp2.ini or Winappx.ini from the repository and look at what a rule for an app you use actually targets before you let the cleaner touch it.

Where FluentCleaner is the wrong tool

It is Windows-only, and the two builds do not cover the same Windows. Classic runs on practically any Windows, but the modern build needs Windows 10 2004 (Build 19041) or later according to the requirements row, even though the platform row says Windows 10 build 17763 or later. Those two numbers disagree inside the same table, so if you are on a build between 17763 and 19041, verify which edition you are installing rather than trusting either line. The README does not resolve the conflict.

The runtime dependency is the sharper limitation. A self-contained 140 MB app that still needs a separately installed Windows App SDK, at one exact version, is a real deployment constraint on locked-down or offline machines. Classic sidesteps it entirely, which is probably why the README keeps it around rather than replacing it.

There is also the maintenance question the author raises himself. He writes that he will probably get bored, or that it will evolve into something else. A cleaner is only as good as its rules, and the rules here come from an external community format. If you need a tool with a support contract or a guaranteed release cadence, this is not it.

FluentCleaner versus CCleaner: same signatures, different wrapper

The honest comparison is not feature against feature. Both tools can consume winapp2.ini signatures, so the cleaning coverage overlaps by construction. What differs is the surrounding product. CCleaner ships a commercial installer, bundled offers and registry cleaning; FluentCleaner's README explicitly rejects those categories and ships as a zip or a winget package under MIT.

The second difference is the parser. The author claims his parser for the winapp2 format is surprisingly fast and faster than what he remembers from the old Piriform implementation. That is an anecdote from the author, not a measured benchmark, and the README offers no numbers, so treat it as a design intention rather than a verified result. The claim that matters and is verifiable from the repository is structural: the format is plain text and the parser is in a netstandard2.0 library you can read.

Against Microsoft's built-in Storage Sense, the difference is control. The FAQ notes that Microsoft recommends cleaning monthly and that Storage Sense does it automatically, then says FluentCleaner gives you more control over what exactly gets cleaned. That is the accurate framing: this is a manual instrument, not an automation layer.

Licence, updates and what maintenance costs you

The project is MIT-licensed, which permits commercial and private use, modification and redistribution provided the copyright notice and permission notice are kept. That is the licence text, not legal advice; if you plan to ship it inside a product, read LICENSE in the repository and get your own counsel.

The release history shows two parallel tracks: FluentCleaner 26.09.01 tagged as 1.18 (Classic) on 2026-09-17, and classic-1.17.227 and classic-1.16.206 earlier in the same month. The naming suggests the modern and Classic builds are versioned differently, and the README's comparison table confirms they are separate downloads. The last push to the repository was on 2026-09-17.

Upgrade cost is low on the modern edition because winget handles it. On Classic there is no package manager path, so you re-download the zip. If you maintain local winapp2.ini edits, note that the repository also carries Winapp2.ini and Winappx.ini directly, so an update may overwrite or conflict with changes you made by hand. The README does not document a merge strategy for that.

Editorial conclusion

FluentCleaner is for Windows 10 build 17763+ users who want to choose exactly what gets deleted and who are willing to read a winapp2.ini entry before trusting it, and for anyone who wants a cleaner small enough to run from a USB stick (Classic is about 3.57 MB unpacked). It is not for macOS or Linux users, and not for people who want a one-click tune-up that also touches the registry. Before you run it, verify which runtime you installed (the WinUI 3 build needs the exact Windows App SDK 2.0.1 x64 runtime, and an older or newer one will not work), then open Winapp2.ini and Winappx.ini in the repository and read the entries that match the apps you actually use.

Frequently asked questions

Official sources

1. builtbybel/FluentCleaner on GitHub
2. Issues
3. License: MIT
4. README
5. Releases