Noureddine RAMDI / Czkawka: a Rust core library powering multi-frontend file cleanup tools

Created Mon, 04 May 2026 10:23:02 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
981 Words
github-stars rust file-cleanup cross-platform desktop-app multithreading perceptual-hashing

qarmin/czkawka

File cleanup utilities abound, but Czkawka takes a different approach: it builds a nearly 100% safe Rust core library that powers multiple frontends — GTK4, Slint (Krokiet), Android — plus a CLI. This multi-frontend architecture driven by a shared core is a notable example of a library-first desktop application in Rust that balances performance, safety, and cross-platform reach.

What Czkawka does and how it’s built

Czkawka is a file cleanup utility designed to help users identify and remove duplicates, empty folders, similar media files, broken files, and more. It offers 14 distinct tools targeting common file system clutter and media similarity problems. The project is implemented in Rust with a focus on memory safety, concurrency, and cross-platform compatibility.

Architecturally, Czkawka consists of a core Rust library that encapsulates the main logic and algorithms. This core is then used by three GUI frontends and a command-line interface:

  • Krokiet GUI using Slint, a modern UI toolkit
  • Czkawka GUI based on GTK4 (in maintenance mode)
  • Cedinia Android frontend
  • CLI tool

The core library is written in nearly 100% safe Rust, which minimizes runtime errors and memory bugs. It supports multithreading to leverage multiple CPU cores for parallel scans, and uses caching to speed up incremental scans by avoiding redundant work.

Czkawka is cross-platform, targeting Linux, Windows, macOS, FreeBSD, ARM architectures, RISC-V, and Android. It achieves zero telemetry and minimal third-party dependencies, focusing on user privacy and performance.

The core library and multi-frontend design: technical strengths and tradeoffs

What distinguishes Czkawka is its library-first architecture. Rather than embedding the logic directly in a single frontend, it exposes a reusable Rust crate that any frontend or CLI can use. This approach provides several advantages:

  • Code reuse: The same core logic and data structures serve all interfaces, reducing duplication.
  • Consistency: Bug fixes and features in the core benefit all frontends instantly.
  • Flexibility: New frontends or integrations can be built without rewriting core algorithms.

Inside the core, the code is mostly safe Rust, which ensures memory safety without garbage collection overhead. The project also leverages Rust’s powerful concurrency primitives to run file scans in parallel, which is critical given the I/O-bound and CPU-bound nature of file hashing and media similarity calculations.

Czkawka implements perceptual hashing to detect similar media files, which is more advanced than simple byte-by-byte duplicate detection. This technique computes hash fingerprints that are resilient to minor variations (e.g., resized images or transcoded videos), allowing the tool to find near-duplicates.

Scan caching is another key feature: by storing metadata and hash results from previous runs, Czkawka can perform incremental scans much faster, skipping files that haven’t changed. This improves the DX for users dealing with large file collections.

The choice to maintain multiple frontends has tradeoffs. The newer Krokiet (Slint) GUI is positioned as the future-facing frontend, while the GTK4 frontend is now in maintenance mode. Supporting multiple UIs increases maintenance overhead but also widens user reach, especially with the Android frontend.

The code quality in the core is surprisingly clean and idiomatic Rust, emphasizing modularity and testability. The frontends handle UI concerns but delegate all heavy lifting to the core library, preserving separation of concerns.

Explore the project

The repository is organized to reflect the multi-frontend design:

  • Core library: Contains the shared logic, algorithms, and data structures in Rust.
  • Krokiet GUI: The Slint-based frontend with modern UI features.
  • Czkawka GUI: The GTK4 frontend, currently in maintenance mode.
  • CLI: Command-line interface for scriptable and terminal use.
  • Cedinia: Android frontend.

Each frontend and the core library have their own installation and usage instructions, which you can find in their respective folders or documentation files. The README points users to these specific instructions rather than bundling a single quickstart.

This layout makes it straightforward to choose the interface that fits your environment. If you want to integrate file cleanup features into your Rust project, using the core crate directly is viable, while end users can pick the GUI or CLI they prefer.

Verdict

Czkawka is a solid example of a Rust project that prioritizes a reusable core library architecture to support diverse frontends across platforms. Its use of safe Rust, multithreading, caching, and perceptual hashing make it a practical and performant file cleanup tool.

It’s well-suited for developers interested in building or embedding file cleanup features in Rust or those wanting a privacy-conscious, open-source alternative to bloated file cleaners. The multi-frontend approach means users can find a UI that fits their workflow, though maintaining multiple interfaces adds complexity.

One limitation is the maintenance status of the GTK4 frontend, signaling a shift towards the newer Slint-based Krokiet UI, which might affect users tied to the older interface. Also, while Rust’s safety and concurrency features shine here, newcomers to Rust might face a learning curve when diving into the core library.

Overall, Czkawka offers an insightful case study in library-first Rust desktop app design and practical file cleanup engineering.

→ GitHub Repo: qarmin/czkawka ⭐ 30,845 · Fluent