HashCalculator and a Windows desktop tool for batch hashing and verification

Batch hashing, batch verification and duplicate hunting in one window

HashCalculator is described as an open source, free, single file, no installation hash calculation tool for files, with batch computation and batch verification of file hashes, plus statistics, search and filter features, aimed at daily file integrity checking and checking downloaded results.

The workflow it supports is the one the name suggests. You compute hashes by dragging files or folders into the main table, or by using the choose file and choose folder buttons, and the tool calculates the selected algorithms for the objects you added. You verify hashes by pasting checksum information into the hash verification input box, or by opening a verification information file, and the tool does the comparison and shows the result. Export is one click, to .txt, .csv or .hcb, and custom export formats are supported.

The third mode is a system context menu, installed with the shell subcommand, so that right clicking a file or folder in Explorer computes its hash. The documentation frames this as a way to get a hash with one right click instead of opening the application.

The application is built as a .NET 10 WPF desktop app with a modern interface, and its main UI dependency is WPF UI, described as a modern Fluent experience UI control library. The repository layout matches the feature set: `HashCalculator/` for the application, `ShellExtensions/` for the Explorer integration, `IconTools/`, a `Screenshots/` folder for the interface captures, an `OpenHashLibs` entry, a `HashCalculator.sln` solution, a `CHANGELOG.md` and a `TODO.md`.

The `OpenHashLibs` entry is the interesting one at the layout level, since it suggests the hash implementations are not all in the application project.

Twenty five algorithms, and the tool decides which to run

The algorithm list is the substance of the project, and it is long enough to be worth setting out in groups.

The SHA families are there in full: SHA1, SHA2 at 224, 256, 384 and 512, and SHA3 at 224, 256, 384 and 512. The XXH family appears as XXH32, XXH64, XXH3-64 and XXH3-128. Then there is SM3, the Chinese national hash standard, and the older MD4 and MD5, alongside CRC32 and CRC64.

The less common ones are where the tool earns its keep for anyone working with obscure formats: QuickXor, Whirlpool, Streebog at 256 and 512, the Blake family in several variants including Blake2b, Blake2bp, Blake2s and Blake2sp at various digest sizes, and Blake3 at 224, 256, 384 and 512. Then eD2k, the eDonkey2000 hash used by that file sharing network, Has160, and RipeMD160.

The output format is configurable too. The calculated hash can be output as Base64 or as hexadecimal in upper or lower case, which matters because a checksum manifest that expects one form will reject the other.

The application decides which algorithm to use when you do not pick one, and the documentation says this is governed by the software's own settings policy. That is worth knowing, because a user who wants to verify against a manifest and forgets to name the algorithm will get whatever the settings say rather than an error, and the comparison against the manifest will simply not match.

The command line covers scripting, and the shell subcommand covers Explorer

Three subcommands are documented, and together they are what makes the tool usable in a script as well as by hand.

The `compute` subcommand calculates hashes for files in a file or folder, with the first argument `-a` or `--algo` naming the algorithms to use and it being optional. The example given is:

hashcalculator compute -a sha_1,sha_256 "文件1路径" "文件2路径" "文件夹1路径" ...

The `verify` subcommand reads a checksum information file to learn which files need hashing, computes them, and compares the results with the values recorded in that file to check whether they agree. Its first argument is the same `-a` or `--algo`, optional, and when omitted the software's own settings decide which algorithm to use. Its second argument is `-l` or `--list`, the path to the checksum information file, which is mandatory and cannot be omitted. The example is:

hashcalculator verify -a sha_1,sha_256 -l "D:\xxx\sha256sums"

The `shell` subcommand installs or uninstalls the Explorer context menu. Its first argument is `-i` or `--install` and its second is `-u` or `--uninstall`, and the documentation is explicit that the two must not be used together. The third is `-s` or `--silent`, which can be combined with either of the others, and means install or uninstall without any prompt window, with the note that in a normal install or uninstall no prompt appears either way. The example is:

hashcalculator shell --install --silent

The verification subcommand is the one to look at first if you are automating, because it takes the manifest path as a required argument and leaves the algorithm selection to you, which is what a scheduled job should be doing anyway.

Filters, concurrency and a verification format you can write yourself

Several of the smaller features are the ones that decide whether a tool is usable on a large set of files.

The tool has built in filters for filtering, searching and processing large batches of hash results, and it can show statistics on the results. It supports running several hashing tasks at once, from 1 to 32, and each task can compute several algorithms for the same file, so a directory of large files with three algorithms each is a configuration rather than three passes.

During a run you can pause, resume, and cancel either all the running tasks or a single running task, which matters when a run over a large tree is competing with your other work for disk.

The verification side is the part with the most design thought in it. The tool supports a custom parse scheme for checksum information, so that a checksum list exported by a different tool can be opened directly for automatic verification. There are preset parse schemes for .txt, .csv, .hcb, .sfv, .sums and .hash files. The .sfv and .sums formats are the ones you meet constantly from scene and distribution archives, and the point of the custom scheme is that you are not limited to what happens to be built in.

That is a real difference from a simple hash utility. A tool that only computes digests is a calculator; a tool that parses a manifest format, compares it against what is on disk, and reports which files disagree is a verification tool, and the second is what you need when a download failed or an archive is incomplete.

A single file executable that still needs the desktop runtime

The distribution model has one subtlety that the documentation handles clearly, and it is the kind of detail that decides whether your team can deploy it.

The release form is a single file executable with no installation, and the tool is published as framework dependent, sharing the same .NET 10 desktop runtime as other .NET programs on the machine rather than bundling its own copy, which the documentation presents as saving disk space by avoiding repeated packaging of the runtime.

The consequence is stated just as plainly: the program depends on the .NET 10 Desktop Runtime, and you should install it before first use, choosing the x86 or x64 installer according to your system, or the program will not run. The documentation notes that .NET 10 does not support Windows 7, so the program cannot run there, and recommends Windows 10 or later.

Both platform versions are published, x86 and x64, and the choice is yours to make per machine rather than something the installer guesses.

So the installation is: download the executable from the Releases page, extract it or run it directly as `HashCalculator.exe`, and make sure the .NET 10 desktop runtime is present. The command line is also reachable as `hashcalculator` for scripting. The project ships both x86 and x64 platform versions, and the changelog is maintained separately in `CHANGELOG.md` at the repository root.

The licence is GNU GPL v3.0, with the details in `LICENSE.txt`.

Where a desktop hash tool is the wrong answer

There are three cases where this tool is the wrong choice, and the first is the simplest one.

The first is a non Windows machine. The interface is WPF, the context menu integration is Explorer, and the runtime is the .NET desktop runtime on Windows. A team on Linux or macOS needs a different tool, and the command line subcommands are useful but the package itself will not run there.

The second is when you need signatures rather than digests. Everything this tool does is in the hash and checksum list world. There is no certificate validation, no PGP signature check, no detached signature verification. If the question you need answered is whether a file came from a specific publisher, a digest against a known list answers a different question, and no amount of algorithm coverage changes that.

The third is a headless or high volume environment. The application is a desktop GUI, and while the compute and verify subcommands give you a scriptable path, a scheduled job over a large fleet is better served by a tool that was designed to run without a window, and the fact that this one is distributed as a Windows GUI executable with an optional shell extension says which way its author expected it to be used.

There is a fourth consideration that is less about the tool and more about the workflow. The 7.0 release line is in preview, with 7.0.0.2, 7.0.0.3 and 7.0.0.4 published in August and September 2026. Preview builds of a tool whose output you intend to store in a manifest or compare against a signed release is a slightly odd combination, and the sensible habit is to pin the version whose behaviour you have verified against your own file set rather than to track the newest preview.

Editorial conclusion

HashCalculator fits a Windows user who checks downloaded archives, verifies a large tree of files against a checksum manifest, or needs the same hashing in a script as well as by dragging files onto a window, because the compute, verify and shell subcommands cover all three cases. It is the wrong choice on Linux or macOS, since the interface is WPF and the Explorer shell extension is Windows specific, and it is the wrong choice if you need to verify signatures rather than digests, since the tool works in the hash list world rather than the PKI world. Before you adopt it, verify two things: that the .NET 10 desktop runtime is present on the machines, since the documentation states the program will not run without it, and whether the checksum manifest formats you already have are covered, because the built-in parsers handle .txt, .csv, .hcb, .sfv, .sums and .hash and anything else needs a custom parse scheme. The code is GPL-3.0, the repository publishes no GitHub releases, and the last push was on 2026-10-18.

Frequently asked questions

Official sources

1. hrpzcf/HashCalculator on GitHub
2. Issues
3. License: GPL-3.0
4. README
5. Releases