Git 2.55:
History Fixup, Linux FSMonitor, Push Groups

Introduction

Git 2.55 was released on June 29, 2026, with features and bug fixes from over 100 contributors. This release is notable for several long-requested improvements: a built-in filesystem monitor daemon for Linux that makes git status dramatically faster on large repositories, a new git history fixup subcommand that simplifies amending changes into earlier commits, and the ability to push to a group of remotes in a single command.

Beyond the headline features, Git 2.55 marks a milestone in the project's evolution — Rust is now enabled by default in the build system, incremental multi-pack indexes land in git repack, and partial clone performance gets a meaningful boost through batched blob downloads for git-grep and git-cherry.

This article covers every significant feature in the release, with practical examples and migration advice.

git history fixup — Amend Changes into Earlier Commits

Anyone who has polished a commit series before sending it for review knows the pain: you make a change in your working tree that really belongs in an earlier commit, not at the tip of the branch. Before Git 2.55, the standard workflow was:

git commit --fixup=<commit>
git rebase -i --autosquash <commit>^

That works, but it spells out the mechanism instead of expressing the intent. Git 2.55 adds a fixup subcommand to the experimental git-history(1) command first introduced in Git 2.54:

git history fixup <commit>

This single command takes the staged changes and amends them into the specified commit, then replays all descendant commits on top. The key advantage is that git history fixup automatically updates all local branches that contain the fixed-up commit. When working with stacked branches, fixup-ing a commit in the stack rebases all related branches — no manual re-parenting needed.

This feature was implemented by Patrick Steinhardt and is a significant quality-of-life improvement for anyone who regularly polishes commit history before review.

fsmonitor Daemon for Linux — Faster git status

The core.fsmonitor setting has existed since Git 2.16 (January 2018), but it required a third-party tool such as Facebook's Watchman. In April 2022, Git added a built-in daemon that could replace the external tool — but only for Windows and macOS. Linux users were left out.

Git 2.55 closes that gap. The built-in fsmonitor daemon now supports Linux using inotify(7), which monitors filesystem events without elevated privileges. Enable it with:

git config core.fsmonitor true

Once enabled, the daemon runs in the background and watches for file changes. When you run git status, Git returns the cached result instead of traversing the entire working tree. On large repositories — especially monorepos with tens of thousands of files — the speedup is dramatic.

The feature was contributed by Paul Tarjan, based on earlier work by Eric DeCosta and Marziyeh Esipreh.

git push to a Remote Group

git fetch has supported remote groups for a long time — you can fetch from multiple remotes in one go. But git push could not use the same group mechanism. Git 2.55 fixes this asymmetry.

# Configure a remote group
git config set remotes.forks "origin upstream"

# Push to all remotes in the group
git push forks main

Each remote in the group is pushed independently, respecting its own remote.<name>.push mapping and mirror settings. This is particularly useful for maintainers who publish the same branch to multiple hosting services — a primary host plus mirrors on GitLab, SourceHut, or a self-hosted instance.

Submitted by Usman Akinyemi, suggested by Git maintainer Junio C Hamano.

Limiting git log --graph Lane Width

Anyone who works in a repository with many active branches has seen git log --graph grow impractically wide. In the git.git repository itself, the graph reaches nine lanes only 30 commits back. Each lane continues downward to the commit where the branch was created, pushing commit messages off the right edge of the terminal.

Git 2.55 adds the --graph-lane-limit=<n> option:

git log --graph --graph-lane-limit=5 --oneline

Lanes beyond the limit are replaced with a ~ truncation mark, so it stays visually clear that the graph was trimmed. The default is 0 (no limit). Zero or negative values disable the limit, similar to --max-parents.

This feature was submitted by Pablo Sabater.

Incremental Multi-Pack Indexes in git repack

Large repositories accumulate packfiles over time as fetches, pushes, and maintenance tasks leave many packs behind. Git's multi-pack index (MIDX) gives a single index across all packs, but rewriting the entire MIDX on every maintenance run is expensive in large repositories.

Git 2.55 introduces incremental MIDX chains. The new --write-midx=incremental option in git repack writes a new MIDX layer for the packs created during repacking, without disturbing existing layers:

# Append-only: writes a new layer without touching older ones
git repack --write-midx=incremental

# Combined with geometric repacking for automatic compaction
git repack --write-midx=incremental --geometric=2 -d

When used with geometric repacking, Git decides whether adjacent MIDX layers should be compacted together. The behaviour is controlled by two new config options: repack.midxSplitFactor (default ratio for layer compaction) and repack.midxNewLayerThreshold (minimum pack count before a tip layer joins the geometric candidate set).

The result is a middle ground between two extremes. A single-file MIDX minimises lookup complexity but requires large rewrites during maintenance. A purely append-only chain minimises each write but allows the chain to grow without bound. Geometric incremental repacking keeps the number of layers logarithmic in the total number of objects — the newest and smallest layers are rewritten more often than older, larger ones.

Rust Enabled by Default in the Build System

Git 2.55 marks a turning point for the project's codebase evolution. Rust code was first added to Git 2.49 (March 2025) as experimental bindings. Git 2.52 (November 2025) introduced the first production Rust code — a reimplementation of the varint subsystem — as an optional fallback. Git 2.54 added the ObjectID type in Rust to support SHA-1/SHA-256 interoperability.

In Git 2.55, the Rust compiler is required by default when building Git from source. Both the Make and Meson build systems now fail unless a Rust compiler is found, unless you explicitly disable it:

# Meson build
meson configure -Drust=disabled

# Make build
make NO_RUST=YesPlease

This change only affects people who compile Git from source. If you install Git through your distribution's package manager (apt, dnf, brew, or a pre-built binary), you are not affected — the distribution maintainers handle the build configuration. The Rust requirement is an infrastructure step that enables future performance and safety improvements within Git's internals.

Faster git-grep and git-cherry in Partial Clones

Partial clones with --filter=blob:none can dramatically speed up initial clones of large repositories, but they come with a cost: commands that need file contents — like git grep — must download blobs on demand. Previously, each blob was fetched individually, creating many round-trips to the server.

Git 2.55 batches the blob downloads together into a single negotiating round-trip with the server. This optimisation applies to git-grep(1) and git-cherry(1):

# Before 2.55: each blob fetched individually — many round trips
git grep TODO HEAD~100

# After 2.55: blobs batched into a single server negotiation

For developers working with partial clones of large monorepos — a common pattern in CI/CD environments and on resource-constrained machines — this change can reduce search times from minutes to seconds. The batching applies automatically; no configuration change is needed.

Submitted by Elijah Newren.

Negotiation Commit Controls

During a fetch, the client and server negotiate by having the client advertise commits it already has as have lines, letting the server avoid sending objects the client already has. In repositories with many references, the negotiation algorithm may skip a ref that is especially important for finding common history.

Git 2.55 adds new controls for which references participate in negotiation. The --negotiation-commit=include and --negotiation-commit=restrict options, along with corresponding remote.*.negotiationCommit configuration, allow users to require certain refs to be sent as have lines or to limit negotiation to a specific set of refs. This can reduce fetch times in repositories with complex reference namespaces.

Summary of Changes in Git 2.55

FAQ

Upgrade and Start Using Git 2.55

Git 2.55 is available now. Check your distribution's package manager or download the source from git-scm.com. The fsmonitor feature alone makes this release worth upgrading for anyone working on large repositories on Linux.

As a full-stack web developer who works with version control daily, I follow every Git release closely. The fsmonitor Linux support and history fixup command are two changes I've wanted for years. If you are planning a web development project and want an experienced partner who keeps up with tooling improvements, reach out. I provide free initial consultations to help you choose the right approach for your project.