Git 2.56: What's New and How to Update

Git 2.56 shipped on September 28, 2026, and the headline changes are a safer way to stage merge-conflict fixes with git add --resolved, a one-command way to prune merged branches with git branch --delete-merged, four new low-level reference commands under git refs, a fetch.followRemoteHEAD config option for controlling how Git tracks a remote's default branch, better git log --follow behavior across renamed paths, an auto-reset flag for git bisect run, hardening in the "ort" merge backend against corrupt trees, and a batch of performance fixes that make merge-base lookups, repacking, and diffing dramatically faster on very large repositories. Anyone running Git can get it by updating their package manager, their Xcode Command Line Tools, or Git for Windows, as outlined below.

What is Git 2.56?

Git 2.56 is the newest stable release of the open-source Git version control system, the software that underpins GitHub, GitLab, Bitbucket, and virtually every modern development workflow. The Git project ships a new minor release roughly every ten to twelve weeks, and GitHub's engineering blog traditionally rounds up the most consequential changes for developers who don't read the full RelNotes document or the git mailing list patch-by-patch. This release leans heavily toward quality-of-life fixes for everyday commands (staging, branching, logging) alongside serious under-the-hood performance work aimed at teams running Git against very large monorepos.

Unlike major version bumps, a minor release like 2.56 never requires you to change how your repositories are stored or touch existing history — every improvement here is either an opt-in command, a new flag you can ignore until you need it, or a performance fix that simply makes existing commands run faster. That makes upgrading low-risk even for teams managing shared infrastructure or CI runners.

Git 2.56 at a glance

The table below summarizes the new commands and flags introduced in this release and what each one actually does.

git add --resolved: a safer way to stage conflict fixes

The most immediately useful change for day-to-day work is the new git add flag, --resolved. When you're in the middle of resolving a merge or rebase conflict, the usual advice is to run git add <file> once you've fixed it — but that stages the entire file, including any unrelated local edits sitting alongside the conflict. git add --resolved instead considers only the paths the index currently marks as unmerged. Before staging anything, it scans those unmerged files for leftover conflict markers (the familiar <<<<<<<, =======, and >>>>>>> lines) and aborts if it finds any, so you can't accidentally commit a half-resolved conflict. It's a narrow but genuinely practical safety net for anyone who resolves conflicts regularly, whether in a terminal or inside an editor's merge tool.

git branch --delete-merged: cleaning up stale branches in one shot

Local branch clutter is one of those problems every long-running repository accumulates. git branch now has a --delete-merged option that removes local branches that are already merged into their tracked remote-tracking branches. It supports branch-name patterns, so you can scope it to a naming convention like feature/*, and a --dry-run flag lets you preview exactly which branches would be deleted before committing to the cleanup. This replaces a fairly common shell-scripting ritual (piping git branch --merged into xargs git branch -d) with a single built-in command.

git refs gets a proper create/update/delete/rename toolbox

Git's plumbing-level reference management has historically been spread across commands like git update-ref and git symbolic-ref. Git 2.56 extends the newer git refs command with four dedicated subcommands: create, update, delete, and rename, each operating directly on a reference name with optional old/new value checks. This is squarely aimed at tooling authors and CI systems that manipulate refs programmatically, rather than at everyday interactive use, but it's a sign that git refs is maturing into the unified entry point the project has been building toward.

fetch.followRemoteHEAD: a saner default for tracking a remote's HEAD

Git already lets you control whether a clone follows a remote's symbolic HEAD (the branch a remote considers its default, such as main) with the per-remote remote.<name>.followRemoteHEAD setting. Git 2.56 adds a global fetch.followRemoteHEAD configuration variable that supplies the default for that per-remote setting, so teams and CI environments can set the behavior once instead of configuring it remote by remote. This matters more than it sounds: mismatched expectations about which branch is "the default" have been a recurring source of confusion since GitHub and other hosts started letting repositories rename their default branch away from master.

git log --follow and --graph get more reliable on messy histories

Two related fixes land in the history-inspection commands most developers use constantly. git log --follow, which tracks a file across renames, now records the renamed path separately for each parent commit, so the result no longer depends on which order Git happens to traverse a non-linear history — previously, following a file through multiple merge or rebase paths could silently pick up the wrong rename. Separately, git log --graph now indents "visual roots" when necessary, preventing commits from unrelated lines of history from appearing visually connected in the ASCII graph; this can be turned off with --no-graph-indent or the log.graphIndent config variable if you prefer the old layout.

git bisect run automates its own cleanup

git bisect is the standard tool for binary-searching a history for the commit that introduced a regression, and git bisect run automates the whole search by running a test script at each step. Git 2.56 adds --reset-when-found[=<where>], which automatically runs git bisect reset once the culprit commit is identified. By default that returns you to the commit you started the bisect from; optionally, you can tell it to leave the culprit commit checked out instead, which is handy if your next step is to inspect or fix that exact commit.

The ort merge backend is hardened against corrupt trees

Since becoming the default merge strategy, the "ort" backend has steadily absorbed edge-case fixes, and 2.56 adds another: it's now hardened against corrupt trees, meaning it explicitly aborts under the appropriate error conditions instead of risking undefined behavior when it encounters malformed tree objects during a merge. It's not a user-facing feature so much as a reliability fix, but it reflects the ongoing work to make ort the trustworthy default for every merge, rebase, and cherry-pick operation.

Performance: faster merge-base, repacking, and diffs at scale

Git 2.56's least visible changes may be its most impactful for large organizations. The merge-base computation — used constantly by merges, rebases, and git log range queries — was optimized to stop walking early once one side's exclusive commits are exhausted, which the project says cut traversal time from 0.68 seconds to 0.01 seconds in a real monorepo test case, and from 0.29 seconds to 0.01 seconds against the Linux kernel repository. Path-walk repacking improvements were shown shrinking a 558.5 MB pack down to 164.4 MB — roughly 71% smaller — on the Fluent UI repository. Other internal fixes eliminated a quadratic (O(N²)) regression in packfile loading on a repository with 37,815 pack files, made reftable write performance scale independently of the number of filesystem stat calls, and sped up working-tree diffs on a Chromium checkout from roughly 8 minutes down to 0.07 seconds. None of these require any action from you beyond updating — they simply make common operations faster on the repositories where it was previously painful. Organizations running self-hosted Git at scale, or monorepos with years of accumulated history, are the most likely to notice the difference immediately; for smaller personal or team repositories, the gains will mostly show up as fewer multi-second pauses during routine rebases, log queries, and checkouts.

Other notable additions

A handful of smaller changes round out the release. git history drop is a new experimental command that removes a selected commit and replays its descendants onto that commit's parent, with known limitations around merge commits. git replay --linearize flattens merge topology by replaying commits onto a single line and dropping merges entirely, matching the effect of a rebase but without touching the working tree. And git repack gained filtering support — --filter=blob:limit=1m --drop-filtered — that removes large, recoverable blobs from a partial clone's local pack so they can be re-fetched from the promisor remote on demand, which is useful for keeping partial clones lean. Git also now recognizes common command-line slips, such as typing git push origin/main instead of git push origin main, and suggests the correct form.

What's next: how to update to Git 2.56

Git doesn't auto-update itself, so you'll need to pull the new version through whatever installed it in the first place:

• macOS (Homebrew): run brew update && brew upgrade git, or update the Xcode Command Line Tools if you rely on Apple's bundled Git.
• Windows: download the latest installer from git-scm.com/downloads, or run winget upgrade --id Git.Git if you installed Git via winget. If you work inside a Linux environment on Windows, see this site's WSL2 explainer for updating Git inside your distro with apt.
• Linux: most distributions package Git through their standard package manager (sudo apt update && sudo apt install git on Debian/Ubuntu, sudo dnf upgrade git on Fedora), though repository versions can lag behind upstream; the Git project's official downloads page lists distribution-specific instructions and PPAs for getting the latest release sooner.
• Verify the update: once installed, run git --version in a terminal and confirm it reports 2.56.0 or later.

If you work primarily inside an editor rather than a terminal, note that your editor's own Git integration — including the source control tooling bundled with recent VS Code releases — typically just shells out to whatever Git binary is installed on your system, so updating Git itself is enough to pick up these changes there too. No project files or repository data need to change; Git 2.56 is fully backward compatible with repositories created by older versions.

Written byFelix Moreau

Felix Moreau writes Pandromeda's software coverage and how-to guides. He covers Windows, macOS and Linux updates, the apps people rely on, emulators and developer tools, and turns official documentation into clear, numbered steps that work on the current version.

More from Felix MoreauAll Software & Guides coverage