Git 2.56 History Editing and the Planned Git 3.0 Shift

The Git project released Git 2.56.0 on September 28, 2026, as GitHub’s release coverage records. Developers can now remove a commit with git history drop and replay a branch with merge commits as a linear sequence. Changes to repository defaults and the Rust build requirement remain planned for Git 3.0.

The Git 2.56 release notes also list commands for staging resolved conflicts, deleting branches already merged into their tracked upstreams, and managing references. These are operations developers choose to run in the current release. The planned compatibility changes concern the defaults used when creating repositories and the tools needed to build Git.

Remove a commit with git history drop

The experimental git history command now accepts git history drop <commit>. It removes the selected commit and replays its descendants onto that commit’s parent. On a hypothetical feature branch with an unwanted middle commit, this replaces the step of opening an interactive rebase plan and marking the commit for removal.

The replay creates replacement descendants with new commit identities. Branches pointing into the affected descendant history move to the rewritten commits, so dropping a commit can change more than the branch currently checked out. That matters when another developer or an automated process already uses the old commit IDs: the shorter command does not remove the coordination involved in rewriting shared history.

The operation has defined limits. Git history drop cannot remove a root commit or a merge commit, and it cannot operate on a history containing merge commits. It aborts if replaying a descendant would cause a conflict or overwrite an unrelated local change. If HEAD moves, Git updates the index and working tree while preserving unrelated changes. Those boundaries make the command a focused way to edit a simple commit chain, rather than a general replacement for every interactive rebase.

Replay a merged branch as a straight sequence

Git replay gains a different history-editing option: --linearize. Previously, a replay range containing a merge commit was refused. The new option drops merge commits from the replayed range and produces linear history, matching the broad behavior of git rebase --no-rebase-merges.

Consider a hypothetical feature branch that merged a bug fix from main and then received another feature commit. The command git replay --linearize --onto main main..feature replays the branch’s work onto main without retaining the merge junction. The feature commits appear in a straight sequence on the new base. This changes the branch’s topology; a conflict resolution recorded in the omitted merge deserves attention when assessing the result.

Git replay remains experimental and can operate without a working tree, which makes it relevant to server-side history rewriting. The addition expands the kinds of ranges it can process. It does not preserve the original merge structure, and the rewritten commits have new identities. For a branch whose merges carry meaningful integration work, the choice to linearize is therefore a substantive one, not merely a different way to display the graph.

Finish conflicts and maintain branches and refs

Git add --resolved addresses the point after a developer has edited conflicted files but before the merge is recorded as resolved. It considers paths still marked unmerged in the index and stages their resolved contents while leaving unrelated local edits unstaged. For regular files, it checks for remaining conflict markers first; if it finds any among the selected paths, it stages none of them. A pathspec can narrow the selection, while resolved deletions and binary conflicts do not depend on a textual marker check.

Branch cleanup gains git branch --delete-merged. It deletes local branches whose tips are reachable from their configured upstreams, which covers a branch merged into a tracked remote branch such as origin/main. A dry run can show the candidate branches before deletion. The condition depends on each branch’s upstream configuration; it does not simply ask whether the branch has been merged into whichever local branch happens to be checked out.

For lower-level automation, git refs now has create, delete, update and rename subcommands. An update or deletion may include an expected old value, so the operation proceeds only if the reference still points where the script expects. That guards against silently changing a ref that moved between inspection and update. Renaming through git refs moves the ref and its reflog; scripts that need the branch configuration changes performed by git branch -m must account for that distinction.

Git 3.0 carries the planned compatibility break

The Git 3.0 timetable described by GitLab places Git 2.98 in December 2026 and a paired Git 2.99 and Git 3.0 release in spring 2027. This is a contributor-summit plan, not a set of defaults shipped in Git 2.56. The jump in version numbering is intended to signal the approaching change to downstream maintainers.

Under that plan, Git 3.0 would make SHA-256 the default object hash for new repositories, reftable the default reference storage format, and Rust a required build dependency. These technologies already have support in Git, but libraries, applications and hosting services have uneven support for them. The compatibility question for an integration is whether it assumes the current hash or ref format when creating or inspecting a repository, or whether its build environment lacks a Rust toolchain.

Git 2.99 is intended as a long-term support release for platforms without Rust, with features otherwise aligned with Git 3.0. That proposed pairing gives maintainers a concrete boundary: the history commands are available in Git 2.56, while the planned default changes belong to the major-version release. The next scheduled marker is Git 2.98 in December 2026, before the paired releases targeted for spring 2027.