czkawka Documentation

File: README.md Copy Chapter

Krokiet ((IPA: [ˈkrɔcɛt]), "croquette" in Polish) new generation GUI frontend, simple, multiplatform, fast and free app to remove unnecessary files from your computer.

Czkawka (tch•kav•ka (IPA: [ˈʧ̑kafka]), "hiccup" in Polish) older gtk4 GUI frontend, superseded by Krokiet. Version 12.0 is the last released version - no new binaries will be provided. New users and existing users are encouraged to switch to Krokiet.

Cedinia - Android touch friendly GUI frontend for Czkawka Core, built with Slint.

Features Copy Chapter

• Written in memory-safe Rust - almost 100% unsafe code free
• Amazingly fast - due multithreading and efficient algorithms
• Free, Open Source without any ads
• Multiplatform - runs on Linux, Windows, macOS, FreeBSD, x86, ARM, RISC-V and even Android
• Cache support - second and further scans should be much faster than the first one
• Easy to run, easy to compile - minimal runtime and build dependencies, portable version available
• CLI frontend - for easy automation
• GUI frontend - uses Slint or GTK 4 frameworks
• Core library - allows to reuse functionality in other apps
• Android app - touch-friendly frontend for Android devices
• No spying - Czkawka does not have access to the Internet, nor does it collect any user information or statistics
• Multilingual - support multiple languages like Polish, English or Italian
• Multiple tools to use:
  • Duplicates - Finds duplicates based on file name, size or hash
  • Empty Folders - Finds empty folders with the help of an advanced algorithm
  • Big Files - Finds the provided number of the biggest files in given location
  • Empty Files - Looks for empty files across the drive
  • Temporary Files - Finds temporary files
  • Similar Images - Finds images which are not exactly the same (different resolution, watermarks)
  • Similar Videos - Looks for visually similar videos
  • Same Music - Searches for similar music by tags or by reading content and comparing it
  • Invalid Symbolic Links - Shows symbolic links which point to non-existent files/directories
  • Broken Files - Finds files that are invalid or corrupted
  • Bad Extensions - Lists files whose content not match with their extension
  • Exif Remover - Removes Exif metadata from various file types
  • Video Optimizer - Crops from static parts and converts videos to more efficient formats
  • Bad Names - Finds files with names that may be not wanted (e.g., containing special characters)

Changelog about each version can be found in CHANGELOG.md.

New releases can be found in Github releases and nightly builds also in Nightly releases

You can read more about the 12.0 release, its new features, and the issues that were fixed in the following articles:

• English article - https://medium.com/@qarmin/krokiet-czkawka-12-0-6fa09c43c3b9
• Polish article - https://medium.com/@qarmin/krokiet-czkawka-12-0-c5dad2116793

Usage, installation, compilation, requirements, license Copy Chapter

Each tool uses different technologies, so you can find instructions for each of them in the appropriate file:

• Krokiet GUI (Slint frontend)
• Czkawka GUI (GTK frontend)
• Czkawka CLI
• Czkawka Core
• Cedinia

Comparison to other tools Copy Chapter

In this comparison remember, that even if app have same features they may work different(e.g. one app may have more
options to choose than other).

Few small commits added recently and last version released in 2023
Czkawka GTK 12.0 was the last released version - no new binaries will be provided
Cedinia is an android app, video tools are not available due missing ffmpeg in Android

Other apps Copy Chapter

There are many similar applications to Czkawka on the Internet, which do some things better and some things worse:

GUI Copy Section

• DupeGuru - Many options to customize
• FSlint - A little outdated, but still have some tools not available in Czkawka
• AntiDupl.NET - Shows a lot of metadata of compared images
• Video Duplicate Finder - Finds similar videos(surprising, isn't it)

CLI Copy Section

Due to limited time, the biggest emphasis is on the GUI version so if you are looking for really good and feature-packed
console apps, then take a look at these:

• Fclones - One of the fastest tools to find duplicates; it is written also in
  Rust
• Rmlint - Nice console interface and also is feature packed
• RdFind - Fast, but written in C++ ¯\_(ツ)_/¯

Projects using Czkawka Copy Chapter

Czkawka exposes its common functionality through a crate called czkawka_core, which can be reused by other projects.

It is written in Rust and is used by all Czkawka frontends (czkawka_gui, czkawka_cli, krokiet, cedinia).

It is also used by external projects, such as:

• Czkawka Tauri - https://github.com/shixinhuang99/czkawka-tauri - A Tauri-based GUI frontend for Czkawka.
• page-dewarp - https://github.com/lmmx/page-dewarp - A library for dewarping document images using a cubic sheet model.

Bindings are also available for:

• Python - https://pypi.org/project/czkawka/

Some projects work as wrappers around czkawka_cli. Without directly depending on czkawka_core, they allow simple scanning and retrieving results in JSON format:

• Schluckauf - https://github.com/fadykuzman/schluckauf

Thanks Copy Chapter

Big thanks to Pádraig Brady, creator of fantastic FSlint, because without his work I wouldn't create this tool.

Thanks also to all the people who contributed to the project in every possible way

Also, I really appreciate work of people that create crates on which Czkawka is based and for that I try to report bugs to make it even better.

How to help? Copy Chapter

• Creating issues - Mainly related to bugs, oddly behaving functionality, etc. As you can see from the issue tracker, there are plenty of ideas for new features, but most of them are either difficult to implement or not aligned with the vision of the project, which evolves slightly over time.
• Creating pull requests - Bug fixes are of course very welcome. Regarding new features, it is best to consult with me before implementing them to confirm they align with the project vision. A POC implemented in Rust as external script/project would be useful, especially for more complex features, to ensure there are no technical limitations.
• Updating translations - The project uses the Crowdin platform, where translations can be created and updated. In the case of a new release and missing translations, I use machine translation, which is often inaccurate, so updating translations is highly appreciated.
• Creating packages for various platforms - Due to the difficulties related to adding and maintaining support for each new platform, such as learning package formats like deb or rpm, creating installers and packages, I decided to mainly focus on providing prebuilt binaries. However, having the project available in distribution repositories or in projects such as Chocolatey, Homebrew or Winget would be beneficial for users who prefer centralized repositories.
• Creating articles, videos, tutorials, etc. - Any material that helps people better understand this program and its capabilities is welcome.
• Recommending it to friends, family, coworkers, etc. - This is probably the simplest way to help the project become even more popular, which gives me motivation to continue developing the program. Here are a few example ways to naturally mention this program in a regular conversation:

S - Someone
Y - You

Situation 1: Copy Section

• S - Hey Anon, I have a lot of junk on my disk, what should I do?
• Y - Download Krokiet/Czkawka. They are completely free and works on almost every system.
• S - Thanks man!

Situation 2: Copy Section

• S - I am so thirsty...
• Y - Have you heard about Krokiet/Czkawka?
• S - Wait, what?
• Y - Krokiet and Czkawka, in case you did not know, let you clean unnecessary files from your disk. They are completely free...
• S - That is nice, but I am thirsty...
• Y - ...they work on Windows, Linux and macOS, and some people even port them to FreeBSD and Android...

AI Policy Copy Chapter

The vast majority of the code in this project was written by me (qarmin) without using AI. However, as AI tools have improved and can significantly simplify development and reduce boilerplate, I see no reason to forbid their use. I have also added a AGENTS.md file to the repo to make it easier to provide AI tools with context about the project’s style and code structure.

That said, every pull request, whether created with AI or not, must meet proper quality standards. The author must be able to clearly explain what the code does, without relying on AI for that explanation. I manually review every PR and test each change, so the risk of incorrect code slipping through is low. Still, to avoid wasting time, please refrain from submitting AI Slop PRs.

Officially Supported Projects Copy Chapter

Only this repository, prebuild-binaries, projects on crates.io and flathub are directly maintained by me.

Czkawka does not have an official website, so do not trust any sites that claim to be the official one.

If you use packages from unofficial sources, make sure they are safe.

License Copy Chapter

The entire code in this repository is licensed under the MIT license.

All images and audio files are licensed under the CC BY 4.0 license.

The Czkawka GTK GUI and CLI applications are licensed under the MIT license, while the Krokiet and Cedinia(due Slint license requirements) are licensed under the GPL-3.0-only license.

Donations Copy Chapter

If you are using the app, I would appreciate a donation for its further development, which can be
done here.

File: czkawka_cli/README.md Copy Chapter

Czkawka CLI

CLI frontend that allows you to use Czkawka from the terminal.

Requirements Copy Chapter

Precompiled binaries should work without any additional dependencies on Linux (Ubuntu 22.04+), Windows (10+), and macOS (10.15+).

On Linux, it is even possible (with eyra) to avoid libc entirely and use a fully static Rust binary, but alternatively you can use musl for this task.

If you want to use the similar videos tool, you need to install ffmpeg (runtime dependency).
If you want to use heif/libraw/libavif (build/runtime dependency), you need to install the required packages.

• macOS: brew install ffmpeg libraw libheif libavif dav1d - ffmpeg formula
• Linux: sudo apt install ffmpeg libraw-dev libheif-dev libavif-dev libdav1d-dev
• Windows: choco install ffmpeg - or, if not working, download from ffmpeg.org and
  unpack to the location with czkawka_cli.exe. heif and libraw features are very hard to set up on Windows and are not available in prebuild binaries(there are some unofficial builds, that enables this features)

Compilation Copy Chapter

To compile, you need to have Rust installed via rustup. Then, build with:

cargo run --release --bin czkawka_cli

You can enable additional features with:

cargo run --release --bin czkawka_cli --features "heif,libraw,libavif"

How to use Copy Chapter

The application includes concise help for each tool, which you can display by running:

czkawka_cli --help

You can also get detailed information about the parameters of a specific tool by running, for example:

czkawka_cli dup --help

Example usage:

czkawka dup -d /home/rafal -e /home/rafal/Obrazy  -m 25 -x 7z rar IMAGE -s hash -f results.txt -D aeo
czkawka empty-folders -d /home/rafal/rr /home/gateway -f results.txt
czkawka big -d /home/rafal/ /home/piszczal -e /home/rafal/Roman -n 25 -x VIDEO -f results.txt
czkawka empty-files -d /home/rafal /home/szczekacz -e /home/rafal/Pulpit -R -f results.txt
czkawka temp -d /home/rafal/ -E */.git */tmp* *Pulpit -f results.txt -D
czkawka music -d /home/rafal -e /home/rafal/Pulpit -z "artist,year, ARTISTALBUM, ALBUM___tiTlE"  -f results.txt
czkawka symlinks -d /home/kicikici/ /home/szczek -e /home/kicikici/jestempsem -x jpg -f results.txt

LICENSE Copy Chapter

MIT

File: czkawka_core/README.md Copy Chapter

Czkawka Core

Core scanning library shared by Czkawka GUI, Czkawka CLI, Krokiet, and Cedinia.

Overview Copy Chapter

czkawka_core implements all the scanning tools (duplicate files, empty folders, similar images, similar videos, broken files, and more). It has no UI dependency and is designed to be embedded in any frontend.

Requirements Copy Chapter

The base build has no mandatory native dependencies - it is pure Rust.

Optional features require additional native libraries:

The similar_videos tool requires ffmpeg at runtime (not a build dependency).

Linux (Ubuntu / Debian) Copy Section

# Runtime: similar videos
sudo apt install ffmpeg 

# Optional build + runtime: extra image formats
sudo apt install libheif-dev libraw-dev libavif-dev libdav1d-dev

macOS Copy Section

brew install ffmpeg libraw libheif libavif dav1d

Windows Copy Section

• ffmpeg: choco install ffmpeg or download from ffmpeg.org and place ffmpeg.exe in your PATH.
• heif and libraw features are very hard to set up on Windows and are not available in prebuild binaries(there are some unofficial builds, that enables this features)

Compilation Copy Chapter

# Base (no optional features)
cargo build --release -p czkawka_core

# With all optional image format features
cargo build --release -p czkawka_core --features "heif,libraw,libavif"

License Copy Chapter

MIT

File: czkawka_gui/README.md Copy Chapter

Czkawka GUI is a graphical user interface for Czkawka Core, built with GTK 4.

Deprecation Notice - 12.0 is the Last Version Copy Chapter

Version 12.0 is the last released version of Czkawka GTK. No new binaries will be provided. All users are encouraged to migrate to Krokiet, the new Slint-based GUI.

The source code remains in the repository and compatibility with czkawka_core will be maintained for some time, so the application can still be built manually. However, all issues and feature requests specific to Czkawka GTK will be closed, except for critical problems affecting widely used unofficial builds such as Debian or Docker packages.

Requirements Copy Chapter

Requirements depend on your platform.

Prebuilt binaries are available here: https://github.com/qarmin/czkawka/releases/

Additional features such as HEIF, libraw, and libavif require extra libraries to be installed, which may increase the number of dependencies.

Linux Copy Section

Prebuilt binaries / Self-compiled

Ubuntu:
sudo apt install libgtk-4-bin libheif1 libraw-bin ffmpeg -y

Mac Copy Section

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install gtk4 ffmpeg librsvg libheif libraw dav1d

Windows Copy Section

Prebuilt binaries

All required libraries are bundled in the zip (except ffmpeg, which you can install manually and place ffmpeg.exe in a directory included in your system PATH).

Installation Copy Chapter

Prebuilt binaries (All OS) Copy Section

After installing the required dependencies, download the prebuilt binaries for your platform from the releases page.

Linux Copy Section

Flatpak

flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
flatpak install flathub com.github.qarmin.czkawka

Debian package (Unofficial)

Requires Debian 13 (or derivatives) or later.

sudo apt install czkawka_gui

PPA (Unofficial) - Debian-based distributions (Ubuntu, Linux Mint, etc.)

sudo add-apt-repository ppa:xtradeb/apps
sudo apt update
sudo apt install czkawka

PPA page

Mac Copy Section

Homebrew (Unofficial)

brew install czkawka

Formula page

Windows Copy Section

MSYS2 (Unofficial)

pacman -S mingw-w64-x86_64-czkawka-gui

Package link

The file should be installed to C:\msys64\mingw64\bin\czkawka_gui.exe and can be run from there.
This version is likely the most feature-complete on Windows, as it is compiled with optional features enabled.

Compilation Copy Chapter

Compiling the GUI is more complex than compiling the CLI, core, or Krokiet, because it uses GTK4 (written in C) and requires many build and runtime dependencies.

Requirements Copy Section

The Rust version corresponds to the latest rustc available in Debian Sid: https://packages.debian.org/sid/rustc

Linux (Ubuntu; similar steps apply to other distributions) Copy Section

sudo apt install libgtk-4-dev -y # Base
sudo apt install libgtk-4-dev libheif-dev libraw-dev libavif-dev libdav1d-dev -y # With features
cargo run --release --bin czkawka_gui
# Or with support for heif, libraw, libavif
cargo run --release --bin czkawka_gui --features "heif,libraw,libavif"

Mac Copy Section

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install rustup gtk4 adwaita-icon-theme ffmpeg librsvg libheif libraw dav1d pkg-config
rustup-init
cargo run --release --bin czkawka_gui
# Or with support for heif, libraw, libavif
cargo run --release --bin czkawka_gui --features "heif,libraw,libavif"

Windows Copy Section

Currently, there are no instructions for compiling the app natively on Windows.
You can check the CI for instructions on how to cross-compile the app from Linux to Windows (using a prebuilt Docker image): CI Instructions
There is also a mingw recipe you can try to adapt for your needs: https://github.com/msys2/MINGW-packages/blob/master/mingw-w64-czkawka/PKGBUILD

Limitations Copy Chapter

Not all features and components are implemented here. The main limitations are:

• The Windows version does not support HEIF and WebP files with prebuilt binaries (the MSYS2 version supports them).
• On Windows, text may appear very small on high-resolution displays. You can manually change DPI scaling for this app:
  • Recommended fix (modify gtk.css)
  • Alternative workaround (modify Windows DPI settings for this app; this works too, but the text may be a bit blurry).

License Copy Chapter

The code is distributed under the MIT license.

The icon was created by jannuary and is licensed under CC-BY-4.0.

The Windows dark theme is from the WhiteSur project, licensed under MIT.

The program is completely free to use.

"Gratis to uczciwa cena" - "Free is a fair price"

Name Copy Chapter

Czkawka is a Polish word meaning hiccup.

I chose this name because I wanted to hear people speaking other languages pronounce it, so feel free to say it however you like.

This name is not as difficult as it seems; I also considered words like żółć, gżegżółka, or żołądź, but decided against them because they contain Polish characters, which would make searching for the project harder.

At the beginning of the project, if the response to the name was unanimously negative, I was prepared to change it, but the opinions were extremely mixed.

File: krokiet/README.md Copy Chapter

Krokiet is a new Czkawka frontend written in Slint.

It aims to provide a more consistent experience across all platforms (Linux, Windows, macOS) compared to the previous GTK 4 frontend.

How to install? Copy Chapter

Prebuilt binaries are available for Windows 10/11, Mac and Ubuntu 22.04(base)/24.04(with additional libraries) - or distros with same/newer glibc/libraries versions.

You can download them from https://github.com/qarmin/czkawka/releases/, which contains recommendations, which variant to use depending on your needs.

Requirements Copy Chapter

Prebuilt binaries have no mandatory runtime dependencies.

Optional features require native libraries installed before compilation:

The similar videos tool requires ffmpeg at runtime.

Linux (Ubuntu / Debian) Copy Section

# Runtime: similar videos
sudo apt install ffmpeg

# Optional build + runtime: extra image formats
sudo apt install libheif-dev libraw-dev libavif-dev libdav1d-dev

macOS Copy Section

brew install ffmpeg libraw libheif libavif dav1d

Windows Copy Section

• ffmpeg: choco install ffmpeg or download from ffmpeg.org and place ffmpeg.exe in your PATH.
• heif and libraw features are very hard to set up on Windows and are not available in prebuild binaries(there are some unofficial builds, that enables this features)

Compilation Copy Chapter

Another option is to compile it yourself.

The easiest way is to compile newest Krokiet, is to run

cargo install krokiet --locked

which will install, the latest and optimized version of Krokiet.

Compilation with cargo build --release should produce a working binary, that without any additional dependencies should run on user os.

To enable support for extra image formats, compile with optional features:

cargo build --release --bin krokiet --features "heif,libraw,libavif"

If you have installed new cargo, you can easily compile and install it via cargo install krokiet

Additional Renderers Copy Chapter

By default, only femtovg (OpenGL) and the software renderer are enabled, but you can enable more renderers by compiling the app
with additional features.

Most users will want to use the app with a windowing system/compositor, so features starting with winit in the name are
recommended.

For example:

cargo build --release --features "winit_skia_opengl"
cargo build --release --features "winit_software"

To run the app with a different renderer, set the SLINT_BACKEND environment variable(but app must be compiled with the appropriate feature):

SLINT_BACKEND=winit-femtovg ./target/release/krokiet
SLINT_BACKEND=software ./target/release/krokiet
SLINT_BACKEND=skia ./target/release/krokiet

If you use an invalid or non-existing backend, the app will show a warning:

slint winit: unrecognized renderer skia, falling back to FemtoVG

To check which backend is actually used, add the SLINT_DEBUG_PERFORMANCE=refresh_lazy,console,overlay environment variable:

SLINT_DEBUG_PERFORMANCE=refresh_lazy,console,overlay cargo run

You should see output like:

Slint: Build config: debug; Backend: software

Why create a new frontend instead of improving the existing Czkawka GTK 4 app? Copy Chapter

For many, it might seem surprising to abandon the existing GTK 4 frontend of Czkawka especially considering that GTK is one of the most popular GUI frameworks and replace it with a new one based on Slint, which is still relatively unknown.

This decision was driven by several key factors:

• GTK on Windows and macOS performs poorly - There are random bugs that don’t appear on Linux or on other systems with similar environments. Slint, on the other hand, behaves consistently and reliably across all platforms.
• Complicated compilation and cross-compilation - Due to GTK’s complexity on Windows, the easiest way to compile the application is by using a Docker image with Linux. This makes testing and debugging on Windows much more difficult.
• External dependencies - I’m a fan of applications that work right after downloading, without requiring installation. With GTK, this is rarely the case. On Linux and macOS, several dynamically linked libraries must be installed first, and they may exist in different versions across systems. On Windows, you often have to manually include DLLs. This wouldn't be such an issue if the GTK team officially distributed these libraries and maintained a list of required files, but they don’t, so you’re left compiling everything yourself or, like in my case, relying on external Docker images. With Slint, all I need is a single binary file that runs out of the box on almost any system.
• GTK version fragmentation across platforms - On Linux, GTK is dynamically linked, and different versions may introduce unique bugs or inconsistencies. On Windows, the libraries are bundled, but outdated in my app, since newer ones aren’t available in the Docker image I use, and some versions crash on some OSes. macOS (with Homebrew) is in the best position here, as it usually keeps GTK up to date. With Slint, each Krokiet release is bundled with the latest Slint version, ensuring consistency across all systems and reducing platform-specific issues.
• Cambalache is the only no-code GUI tool - While Cambalache itself works reasonably well, it isn’t officially supported or maintained by the GTK team, but by an independent developer. In contrast, while the Slint GUI is mostly created via code, it offers live previews in VS Code/VSCodium, which is extremely convenient.
• Difficult to modify built-in widgets - GTK enforces a specific visual style, which can be very restrictive. In my case, I had to tweak internal widget parameters just to achieve the desired look, something that might cause a lot of issues in the future. Slint takes the opposite approach: its built-in widgets are quite limited, which often makes it easier to build fully custom components from scratch.
• GTK is still C code - Even though the library is wrapped and provides a relatively safe Rust interface, you still occasionally have to work with low-level structures, which have caused issues and crashes for me in the past. Another downside is the large number of warnings printed to the console, even with correct code, due to internal GTK issues. These warnings are often unhelpful and rarely assist in identifying actual bugs.

License Copy Chapter

The code is licensed under the MIT license, but the entire project is licensed under GPL-3.0 due to Slint license restrictions.

All icons and images are licensed under the CC BY 4.0 license.

Name Copy Chapter

Why Krokiet (eng. Croquette)?
Because I like croquettes (the Polish version), the ones with meat and mushrooms wrapped in breadcrumbs... it makes my mouth water.
I also considered other dishes I like, such as pierogi, żurek, pączek, schabowy, or zapiekanka.
This name should be much easier to remember than czkawka or szyszka.