Performance compared with git

Command durations and storage sizes of kit and git. The page lists the machine, the versions and the kit commit.

Large files

Large files of random bytes and small edits to them. kit splits a large file into chunks and stores each chunk once.

Command duration

Mean wall-clock time of one command, including process start. Lower is better.

Commit a 1 MiB change to the 100 MiB file

kit 21.3× faster

Append 1 MiB to the committed 100 MiB file, then add and commit the new version.

kit

112ms

git

2.38s

Mean ± standard deviation: kit 112ms ± 8.1ms, git 2.38s ± 3.0ms. 10 runs of each command.

kit reads and hashes the whole file but stores only the chunks that changed. git compresses the file and stores the full 101 MiB blob again.

Add and commit one 1 GiB file

kit 7.4× faster

Add and commit a 1 GiB file of random bytes.

kit

3.73s

git

27.5s

Mean ± standard deviation: kit 3.73s ± 24.6ms, git 27.5s ± 44.7ms. 3 runs of each command, because git is slow here.

The time of both tools grows with the size of the file.

Add and commit one 100 MiB file

kit 7.0× faster

The file holds random bytes, which stand in for video or other compressed media.

kit

339ms

git

2.37s

Mean ± standard deviation: kit 339ms ± 5.3ms, git 2.37s ± 12.8ms. 10 runs of each command.

In a repeat run, one slow run raised the mean of kit to 382 ms with a standard deviation of 111 ms. Four other runs gave 334 ms to 341 ms. git gave 2.36 s to 2.37 s in every run.

Check out a branch that changed a 100 MiB file

no clear winner

Branch main holds a committed 100 MiB file. Branch v2 appends 1 MiB to it. The command switches from main to v2.

kit

311ms

git

338ms

Mean ± standard deviation: kit 311ms ± 3.5ms, git 338ms ± 0.6ms. 10 runs of each command.

The means differ by 8%, which is under the 15% limit of this page, so the row names no winner. kit was the faster tool by 8% to 9% in each of the five runs of the suite.

Storage size

Size of .kit and .git from du -k after the same commits. Lower is better.

One 100 MiB file, one commit

about even

Size of the repository after the first commit of the 100 MiB file.

kit

103.6 MiB

git

100.2 MiB

git uses 3% less space. The random bytes do not compress, so git stores one loose blob of about the file size. kit stores the file as chunk objects and a manifest. The extra 3.4 MiB is the cost of that layout.

Growth after a 1 MiB change

kit 91.4× smaller

Extra bytes in the repository after the 1 MiB append is committed as a second version.

kit

1.1 MiB

git

101.1 MiB

git gc

1.0 MiB

kit stores the appended data, the chunks that changed and a new manifest. Loose git stores the full 101 MiB blob again. After git gc, git grows by 1028 KiB, which is 9% less than kit.

Everyday operations

Small files and unchanged repositories. kit signs every commit and flushes object writes to disk. In these runs git uses its defaults: unsigned commits and no flush for loose objects.

Command duration

Mean wall-clock time of one command, including process start. Lower is better.

Add and commit 100 small files

git 1.6× faster

Add and commit 100 files of 10 KiB each, all in one commit.

kit

47.1ms

git

29.4ms

Mean ± standard deviation: kit 47.1ms ± 6.3ms, git 29.4ms ± 0.5ms. 53 runs of kit and 72 runs of git.

git is faster here. kit signs the commit and flushes the object writes to disk before the command returns. git does neither by default. The five runs of the suite gave 46 ms to 47 ms for kit and 29 ms to 30 ms for git.

Add an unchanged 100 MiB file again

kit 2.6× faster

Run touch on the committed file. This changes the modification time but not the content. Then add the file.

kit

96.2ms

git

251ms

Mean ± standard deviation: kit 96.2ms ± 8.0ms, git 251ms ± 0.2ms. 10 runs of each command.

The new modification time makes both tools read and hash the whole file again. kit hashes with BLAKE3 and git hashes with SHA-1.

Create an empty repository

too fast to compare

Run init in an empty directory.

kit

3.6ms

git

1.9ms

Mean ± standard deviation: kit 3.6ms ± 0.7ms, git 1.9ms ± 0.3ms. 562 runs of kit and 741 runs of git.

Both commands finish in under 5 ms, so the timer cannot rank them with confidence. The mean of git was lower than the mean of kit in all five runs of the suite, by about 1.5 ms.

Show the status with an unchanged 100 MiB file

too fast to compare

Run status in a clean repository that holds the committed 100 MiB file, after a first status call.

kit

1.3ms

git

1.1ms

Mean ± standard deviation: kit 1.3ms ± 0.0ms, git 1.1ms ± 0.0ms. 10 runs of each command.

Both commands finish in under 5 ms, so the timer cannot rank them with confidence. The mean of git was lower than the mean of kit in all five runs of the suite, by about 0.2 ms to 0.3 ms.

Storage size

Size of .kit and .git from du -k after the same commits. Lower is better.

100 small files, one commit

about even

Size of the repository after one commit of 100 files of 10 KiB each (1000 KiB of content).

kit

1.6 MiB

git

1.6 MiB

Both repositories hold the content plus the overhead of each object.

Method and limits

Date: Oct 28, 2026
Commit: 8cdb37e4e3eb (clean checkout)
Machine: A 32-core Arm cloud virtual machine with 125 GiB of RAM, running Linux.
Versions: kit 0.5.0 (release build) · git 2.43.0 · hyperfine 2.0.0 · rustc 1.99.1
Harness: scripts/bench-vs-git.sh runs hyperfine with a warm-up run (none for the 1 GiB row) and a prepare command that resets a temporary directory before each run. Most rows use 10 runs. The 1 GiB row uses 3 runs. hyperfine uses more runs for fast commands. The page shows the mean and the standard deviation from the JSON export. The script measures sizes with du -k.
Workload: Random bytes, which do not compress. They stand in for media files. Source code can compress well in the git object store. These runs do not measure it.

Signing: kit signs every commit with Ed25519. git does not sign commits by default. The two commands do different work.
Durability: kit makes the object writes of a command durable before it returns, with a batched flush. git does not flush loose objects by default.
One machine: the numbers come from one virtual machine and one file system. Other hardware, file systems and git versions give other ratios.
Repeats: the suite ran five times on a machine with no other user processes. The means agree within about 10% on every row. The exception is the 100 MiB add row, where one slow run in one repeat raised the mean of kit. The page shows the first of the last two runs.
Verdicts: a row names a winner only when the means differ by at least 15% and the ranges (mean plus or minus one standard deviation) do not overlap. A row where both commands finish in under 5 ms names no winner.
Defaults: both tools ran as command-line processes with their default settings. The run includes process start.

Commands to reproduce

cd rust
cargo build --release --locked -p kit-bin --bin kit
cd ..
scripts/bench-vs-git.sh rust/target/release/kit bench-results