czkawka

Multi functional app to find duplicates, empty folders, similar images etc.

30,952

1,040

30,952

437

View on GitHub

Top Related Projects

ripgrep

66,071

ripgrep recursively searches directories for a regex pattern while respecting your gitignore

fd

43,919

A simple, fast and user-friendly alternative to 'find'

duf

15,034

Disk Usage/Free Utility - a better 'df' alternative

dust

11,668

A more intuitive version of du in rust

gdu

5,881

Fast disk usage analyzer with console interface written in Go

Quick Overview

Czkawka is an open-source, multi-functional app designed to find and remove unnecessary files from your computer. It offers various tools to detect duplicate files, empty directories, similar images, and more, helping users clean up their storage and organize their data efficiently.

Pros

Comprehensive set of tools for file management and cleanup
Cross-platform support (Windows, macOS, Linux)
User-friendly GUI and CLI options
Actively maintained and regularly updated

Cons

May require some technical knowledge for advanced features
Performance can be slower on very large file systems
Limited integration with cloud storage services
Some features may be overwhelming for casual users

Getting Started

To get started with Czkawka:

Download the latest release from the GitHub releases page.
Extract the downloaded archive.
Run the executable file:
- On Windows: Double-click the .exe file.
- On macOS: Open the .app file.
- On Linux: Run the binary file from the terminal or create a desktop shortcut.

For CLI usage, open a terminal and navigate to the extracted directory, then run:

./czkawka_cli --help

This will display available commands and options for the CLI version.

To use the GUI version, simply run the executable without any arguments:

./czkawka_gui

For more detailed instructions and advanced usage, refer to the official documentation.

Competitor Comparisons

ripgrep

66,071

ripgrep recursively searches directories for a regex pattern while respecting your gitignore

Pros of ripgrep

Faster search performance, especially for large codebases
More advanced regex support and search options
Better integration with command-line tools and workflows

Cons of ripgrep

Limited to text-based file searching
Lacks GUI, which may be less user-friendly for some users
Doesn't offer file deduplication or other disk space management features

Code comparison

ripgrep:

pub fn search<R: io::Read>(mut rdr: R) -> io::Result<()> {
    let mut buf = [0; 8 * (1<<10)];
    loop {
        let n = rdr.read(&mut buf)?;
        if n == 0 { break; }
        // Process buffer contents
    }
    Ok(())
}

Czkawka:

pub fn find_duplicates(
    directories: &[String],
    recursive: bool,
    excluded_directories: &[String],
    minimal_file_size: u64,
) -> Vec<Vec<FileEntry>> {
    // Implementation for finding duplicate files
}

While both projects are written in Rust, they serve different purposes. ripgrep focuses on efficient text searching, while Czkawka offers a broader set of file management tools, including duplicate file detection and disk space analysis. ripgrep excels in performance and command-line integration, whereas Czkawka provides a more user-friendly GUI and diverse file management features.

fd

43,919

A simple, fast and user-friendly alternative to 'find'

Pros of fd

Written in Rust, offering high performance and memory safety
Simpler syntax and more user-friendly than traditional find command
Supports colored output and parallel command execution

Cons of fd

Limited to file and directory search functionality
Lacks advanced features like duplicate file detection or disk space analysis
May not be as comprehensive for system-wide file management tasks

Code Comparison

fd:

let walker = WalkBuilder::new(root)
    .hidden(false)
    .ignore(false)
    .git_ignore(use_gitignore)
    .build();

Czkawka:

let mut directories: Vec<PathBuf> = Vec::new();
for dir in &directories_included {
    directories.push(PathBuf::from(dir));
}

Key Differences

fd focuses on fast and user-friendly file searching
Czkawka offers a wider range of file management tools, including duplicate detection and disk space analysis
fd is primarily a command-line tool, while Czkawka provides both CLI and GUI interfaces
Czkawka has more extensive configuration options for various file management tasks
fd is more lightweight and specialized, while Czkawka is a more comprehensive file management suite

Both projects are open-source and written in Rust, leveraging the language's performance benefits. While fd excels at quick file searches, Czkawka provides a broader set of file management utilities for users needing more advanced features.

duf

15,034

Disk Usage/Free Utility - a better 'df' alternative

Pros of duf

Focused on disk usage visualization, providing a clean and intuitive interface
Supports colorized output for better readability
Lightweight and fast, with minimal system resource usage

Cons of duf

Limited functionality compared to Czkawka's broader feature set
Lacks file management capabilities like duplicate detection and removal
Only available as a command-line tool, without a graphical user interface

Code Comparison

duf (Go):

func (m *Mount) Usage() (*UsageStat, error) {
    stat := syscall.Statfs_t{}
    err := syscall.Statfs(m.Mountpoint, &stat)
    if err != nil {
        return nil, err
    }
    // ... (calculation logic)
}

Czkawka (Rust):

pub fn get_disk_usage(path: &Path) -> Result<DiskUsage, String> {
    match fs2::available_space(path) {
        Ok(available) => {
            let total = fs2::total_space(path)?;
            Ok(DiskUsage { available, total })
        }
        Err(e) => Err(e.to_string()),
    }
}

While both projects deal with disk-related operations, duf focuses specifically on disk usage visualization, whereas Czkawka offers a broader range of file management features. duf provides a more specialized tool for disk usage analysis, while Czkawka aims to be a comprehensive file management utility.

dust

11,668

A more intuitive version of du in rust

Pros of dust

Written in Rust, offering high performance and memory safety
Provides a simple and intuitive command-line interface
Lightweight and focused solely on disk usage analysis

Cons of dust

Limited functionality compared to Czkawka's broader feature set
Less customization options for sorting and filtering results
No graphical user interface, which may be less accessible for some users

Code comparison

dust:

pub fn get_dir_size(path: &Path) -> Result<u64, Error> {
    let mut size = 0;
    for entry in WalkDir::new(path).min_depth(1).into_iter().filter_map(|e| e.ok()) {
        size += entry.metadata()?.len();
    }
    Ok(size)
}

Czkawka:

pub fn get_dir_size(dir: &Path) -> u64 {
    WalkDir::new(dir)
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| e.file_type().is_file())
        .map(|e| e.metadata().map(|m| m.len()).unwrap_or(0))
        .sum()
}

Both projects use similar approaches for calculating directory sizes, utilizing the walkdir crate to traverse directories efficiently. Czkawka's implementation is more concise, using functional programming constructs like filter_map and sum. dust's version is more explicit, using a mutable size variable and a for loop.

lsd

15,987

The next gen ls command

Pros of lsd

Focused on enhancing the ls command with color coding and icons
Lightweight and fast for directory listing operations
Cross-platform support (Linux, macOS, Windows)

Cons of lsd

Limited functionality compared to Czkawka's file management features
Doesn't provide file deduplication or cleanup capabilities
Less suitable for large-scale file organization tasks

Code Comparison

lsd (main.rs):

fn main() -> io::Result<()> {
    let flags = Flags::parse();
    let mut stdout = StandardStream::stdout(ColorChoice::Auto);
    let config = Config::from_flags(&flags)?;
    let output = Core::new(config).run()?;
    display::print(&mut stdout, &output, &flags)
}

Czkawka (main.rs):

fn main() {
    let gui_running = Arc::new(AtomicBool::new(false));
    let arguments = Arguments::parse();
    match arguments.command {
        Some(Commands::Gui) => start_gui(gui_running),
        Some(Commands::Cli { command }) => start_cli(command),
        None => println!("No command specified. Use --help for more information."),
    }
}

The code comparison shows that lsd focuses on directory listing and output formatting, while Czkawka offers a more complex structure with GUI and CLI options for file management tasks.

gdu

5,881

Fast disk usage analyzer with console interface written in Go

Pros of gdu

Written in Go, potentially offering better performance for disk usage analysis
Provides a terminal user interface (TUI) for easier navigation and visualization
Supports multiple platforms including Linux, macOS, and Windows

Cons of gdu

Focused solely on disk usage analysis, lacking additional file management features
May require more system resources compared to lightweight command-line tools

Code Comparison

gdu (Go):

func (a *App) analyzeDir(dir string, parent *File) (*File, error) {
    f, err := os.Open(dir)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    // ... (additional code)
}

Czkawka (Rust):

pub fn find_duplicates(
    directories: &[PathBuf],
    recursive_search: bool,
    excluded_directories: &[PathBuf],
    minimal_file_size: u64,
    maximal_file_size: u64,
    ignore_hard_links: bool,
) -> Vec<Vec<FileEntry>> {
    // ... (implementation details)
}

Summary

While gdu focuses on disk usage analysis with a user-friendly TUI, Czkawka offers a broader range of file management features. gdu may provide better performance for its specific task, but Czkawka's versatility makes it suitable for various file-related operations. The choice between the two depends on the user's specific needs and preferences.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

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

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)

Krokiet

Czkawka

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

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

Comparison to other tools

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).

	Krokiet	Czkawka	Cedinia	FSlint	DupeGuru	Bleachbit
Language	Rust	Rust	Rust	Python	Python/Obj-C	Python
Framework base language	Rust	C	Rust	C	C/C++/Obj-C/Swift	C
Framework	Slint	GTK 4	Slint	PyGTK2	Qt 5 (PyQt)/Cocoa	PyGTK3
OS	Lin,Mac,Win	Lin,Mac,Win	Android	Lin	Lin,Mac,Win	Lin,Mac,Win
Duplicate finder	â	â	â	â	â
Empty files	â	â	â	â
Empty folders	â	â	â	â
Temporary files	â	â	â	â		â
Big files	â	â	â
Similar images	â	â	â		â
Similar videos(audio)	â	â	â
Similar videos(frames)	â	â
Music duplicates(tags)	â	â	â		â
Music duplicates(content)	â	â	â
Invalid symlinks	â	â		â
Broken files	â	â	â
Invalid names/extensions	â	â	â	â
Exif cleaner	â		â
Video optimizer	â
Bad Names	â		â
Names conflict				â
Installed packages				â
Bad ID				â
Non stripped binaries				â
Redundant whitespace				â
Overwriting files				â		â
Portable version	â	â				â
Multiple languages	â	â	â	â	â	â
Cache support	â	â	â		â
In active development	Yes	No**	Yes***	No	No^*	Yes

^* 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

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

GUI

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

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

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

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?

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:

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:

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

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

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

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

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

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot