Git 2.55: History Fixup, Rust by Default, Safer Checkouts

Originally published on DevToolHub.

Git 2.55 landed on June 29, 2026, and the headline change isn't a new command — it's a build requirement. Starting with this release, building Git from source requires a Rust toolchain unless you explicitly opt out. Alongside that, Git 2.55 Git ships git history fixup for editing an old commit without a full interactive rebase, a safer git checkout -m that won't leave you with a half-resolved mess, and native fsmonitor support on Linux.

Here's exactly what changed, the commands you'll actually use, and what breaks if you build Git from source in CI.

git history fixup: Editing an Old Commit Without Rebase

Interactive rebase has always been the tool for folding a small fix into an earlier commit, but it means dropping into an editor and picking through a to-do list even for a one-line change. git history fixup skips that:

git add foo.c
git history fixup abcdef01

Stage your change normally, then point git history fixup at the target commit. It folds the staged change into that commit and replays every commit after it on top — the target commit keeps its original message and authorship unless you pass --reedit-message. The command is intentionally conservative: it requires a clean working tree and aborts outright if replaying the later commits would produce a conflict, rather than leaving you halfway through a rebase.

If you're already comfortable with git rebase --autosquash and fixup! commit prefixes, this covers the same use case with one command instead of a two-step commit-then-rebase dance. For anyone who's avoided rebase, stash, and cherry-pick because the interactive editor felt like overkill for a single-line fix, this is the more direct path.

Safer git checkout -m Behavior

git checkout -m <branch> re-applies your local changes on top of the branch you're switching to, merging them in. Before Git 2.55, if that merge hit a conflict, you got exactly one shot to resolve it on the spot — mess it up and you were stuck with a half-resolved working tree.

Git 2.55 changes the mechanics: checkout -m now uses an autostash internally, so your local changes land in a stash entry instead of a conflicted working tree. You can resolve the conflict immediately, or walk away and come back to it later with git stash pop when you're ready. If you've ever hit a merge conflict mid-checkout and had to untangle it under pressure, this removes the time pressure entirely.

Rust Now Required to Build Git From Source

This is the change that affects the most people indirectly, even if most Git users will never notice it. As of Git 2.55, the Rust compiler is required to build Git from source, unless you explicitly disable it:

# Makefile-based builds
make NO_RUST=YesPlease

# Meson-based builds
meson configure -Drust=disabled

If you install Git through your OS package manager or a prebuilt binary, this changes nothing for you — the maintainers handle the build. It matters if your CI pipeline compiles Git from source as part of a custom image or hardened build process. Any pipeline like that needs a Rust toolchain available now, or it needs the NO_RUST flag set explicitly, or the build breaks the next time it runs.

This is part of a longer-term push by the Git project to replace selected components with Rust for memory safety, the same direction several other systems-level open source projects have taken. Don't expect Rust to become mandatory with no opt-out in the very next release, but treat this as the direction things are heading and plan your build pipeline accordingly.

fsmonitor Now Works on Linux

fsmonitor speeds up status checks on large repositories by watching the filesystem in the background instead of walking the whole working tree on every git status. It's had Windows and macOS implementations for a while — Git 2.55 adds a Linux implementation, built on inotify.

The daemon doesn't need elevated privileges to run, but it does need one watch per directory, so very large repositories may need a higher fs.inotify.max_user_watches limit than the Linux default. Network-mounted repositories stay opt-in for fsmonitor, matching the behavior on the other platforms. If you manage a monorepo where git status has always felt sluggish, this is worth enabling.

[IMAGE: articles/images/2026-07-24-git-2-55-new-features-diagram.png | alt: "how git history fixup folds a staged change into an earlier commit"]

Git 2.55 Parallel Hooks

Hooks configured through Git's config system — as opposed to plain scripts dropped in .git/hooks — can now run in parallel instead of one after another. Turn it on per hook:

git config hook.pre-commit.parallel true

Control concurrency globally with hook.jobs, per-event with hook.<event>.jobs, or per-invocation with -j. Hooks that depend on shared state still run serially — Git doesn't parallelize anything that could race. If you're using Git hooks to automate parts of your workflow and have several independent checks running on every commit, this can meaningfully cut down the wait.

Git 2.55 Remote-Group Push

You can now push to multiple remotes in one command by defining a remote group:

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

git push publish main pushes sequentially to every remote listed under remotes.publish. One limitation worth knowing: --atomic isn't supported for grouped pushes, since atomicity can't be guaranteed across multiple independent connections. If a push to one remote fails partway through, the others may already have succeeded.

Should You Upgrade to Git 2.55 Now

For most people, yes — none of the changes in this release are disruptive if you're using Git normally through a package manager or prebuilt binary. The one group that needs to act before upgrading: anyone with a CI pipeline or Docker image that compiles Git from source. Add a Rust toolchain to that build, or set NO_RUST=YesPlease explicitly, before you pull in 2.55.

Everyone else gets a genuinely useful set of additions — git history fixup for quick historical edits, a safer checkout -m, and fsmonitor finally working on Linux — without anything to migrate or rewrite. If you want the full technical rationale behind each change, GitHub's release highlights and GitLab's breakdown both cover the implementation details this article doesn't.

Frequently Asked Questions

Q: Do I need Rust installed to use Git 2.55?
A: Only if you're building Git from source. If you install it through a package manager, Homebrew, or a prebuilt binary, this change is invisible to you.

Q: Does git history fixup replace git rebase --autosquash?
A: Not entirely — it covers the common case of folding one staged change into an earlier commit in a single step. Complex interactive rebases with reordering or multiple fixups still need the full git rebase -i workflow.

Q: Will git checkout -m break my existing scripts if they expect the old conflict behavior?
A: If a script parses the exact output of a conflicted checkout -m and expects the working tree to be left in a conflicted state, yes, that output changes. Scripts that just check the exit code are unaffected.

Q: Can I use remote-group push with --force?
A: Yes, --force works with grouped pushes. It's specifically --atomic that's unsupported, because Git can't guarantee all-or-nothing delivery across multiple separate remote connections.

Quick Summary:

• Git 2.55 requires Rust to build from source now, unless you set NO_RUST=YesPlease or -Drust=disabled explicitly — end users installing prebuilt Git are unaffected
• git history fixup <commit> folds a staged change into an older commit and replays descendants, without a full interactive rebase
• git checkout -m now autostashes conflicts instead of leaving a half-resolved working tree
• fsmonitor finally has a Linux implementation, using inotify to speed up git status on large repos
• Parallel hooks and remote-group push (git push publish main) round out the release

That's the full Git 2.55 picture: if you maintain a CI image that compiles Git from source, check that build today — that's the one place this release can break something without warning.