astradevlabsastradevlabs
← All posts
Dev Tips4 min

The 8 Best New Tricks in Git 2.55, Ranked

Dev Tips

Git 2.55 shipped on June 29 with contributions from over 100 developers, and buried in its release notes are some of the best quality-of-life upgrades Git has picked up in years. Here are the eight changes most worth knowing, counted down to the one that will change your daily workflow.

8. Incremental repacking that scales

Big repositories accumulate packfiles, and rewriting one giant multi-pack index (MIDX) on every maintenance run gets expensive. Git 2.55 teaches git repack to write incremental MIDX chains directly:

bash
git repack --write-midx=incremental --geometric=2 -d

Combined with geometric repacking, Git compacts adjacent index layers only when newer layers grow large enough relative to older ones — controlled by repack.midxSplitFactor. Routine maintenance now touches metadata incrementally instead of rewriting the whole index.

7. Faster bitmap generation

Reachability bitmaps make object traversals fast, but building them was slow. This release avoids unnecessary tree recursion, reuses computed bitmaps, and sorts before XORing. In benchmarks from the patch series, generation time on one large repository dropped from about 612 seconds to about 294. Pseudo-merge bitmaps also keep most of their near-20x traversal speedup while costing far less to build.

6. Readable graphs in wide histories

git log --graph becomes unreadable when dozens of parallel branches eat your terminal width. New in 2.55:

bash
git log --graph --graph-lane-limit=8

Lanes beyond the limit render as ~, so the commit subjects stay on screen where you can read them.

5. The oldest commits, without the hack

Getting the 10 oldest commits in a range used to mean git log --reverse | tail -10, which formats every commit just to throw most of them away. Now:

bash
git log --max-count-oldest=10 <range>

It works across git rev-list and the whole git log family.

4. Push to several remotes at once

Remote groups have worked with git fetch for years. Git 2.55 finally brings them to push:

bash
git config remotes.publish "github gitlab mirror"
git push publish main

One command, three remotes, in sequence. The only caveat: --atomic isn't supported across a group, since atomicity only holds within a single connection.

3. Parallel hooks

Config-based hooks (introduced in 2.54) can now run concurrently. If your lint and unit-test pre-commit hooks are independent, declare hook.<name>.parallel = true and Git runs them simultaneously. Tune concurrency with hook.jobs globally, hook.<event>.jobs per event, or git hook run -j ad hoc. Hooks that touch shared state, like commit-message hooks, still run serially.

2. fsmonitor lands on Linux

If git status pauses for seconds on a large working tree, Git's built-in filesystem monitor is the fix — and until now it only existed on macOS and Windows. Git 2.55 brings the daemon to Linux via inotify:

bash
git config core.fsmonitor true

No elevated privileges needed, though very large repositories may need a higher fs.inotify.max_user_watches since inotify uses one watch per directory.

Linux was the last major platform without fsmonitor. For monorepo developers, this single config line may be the biggest speed win in the release.

1. git history fixup

The winner. You've polished a branch, then spot a change that belongs in an earlier commit. The old ritual — git commit --fixup=<commit> followed by git rebase --autosquash — spells out mechanism instead of intent. Git 2.55 adds a fixup subcommand to the experimental git history command:

bash
git add path/to/fix
git history fixup <commit>

Git folds the staged change into the target commit and replays the descendants on top. The target keeps its message and authorship unless you pass --reedit-message, and if the fixup would conflict, the command aborts cleanly rather than stranding you mid-rewrite. It's still experimental, but it's the closest Git has come to matching how developers actually think about editing history.

Honorable mentions

  • Safer `checkout -m`: conflicted local changes are now autostashed, so you can resolve immediately or reapply later.
  • `git format-rev`: pretty-format revisions from stdin in a pipeline, without spawning a Git process per commit.
  • Sideband hardening: servers can no longer inject arbitrary terminal control sequences through remote: progress output; ANSI colors still work.

Upgrade, flip on fsmonitor if you're on Linux, and give git history fixup a spin on a scratch branch.

References