Asexweb

Git 2.54: A Simpler Way to Rewrite History with `git history`

Explore Git 2.54's new experimental `git history` command for simple commit rewrites like reword and split, without the complexity of interactive rebase.

Asexweb · 2026-05-01 20:46:14 · Open Source

Introduction

The open-source Git project has just released version 2.54, bringing improvements from over 137 contributors, 66 of whom are new to the project. Since we last covered a major release with Git 2.52, this update also includes changes from Git 2.53. Among the many enhancements, one experimental command stands out: git history, designed to simplify common history-rewriting tasks without the overhead of a full interactive rebase.

Git 2.54: A Simpler Way to Rewrite History with `git history`
Source: github.blog

Why a New Command?

Interactive rebase (git rebase -i) is a powerful tool for reordering, squashing, editing, and dropping commits. However, its flexibility comes with complexity: it operates on a range of commits, modifies your working tree and index, and can leave you in a conflicted state. For simple fixes like correcting a typo in a commit message three commits back or splitting a single commit into two, the interactive rebase workflow can feel excessive. You must prepare a todo list, mark commits for editing, and then drive the rebase to completion—often requiring multiple steps.

The Git community recognized the need for a more targeted approach. Enter git history, an experimental command that handles these straightforward scenarios with minimal fuss.

Introducing git history

Currently, git history supports two operations: reword and split. Both operate directly on commits without altering your working tree or index, making them ideal for quick, focused edits.

git history reword

The reword operation lets you change any commit message in your history. Simply run:

git history reword <commit>

Your editor opens with the specified commit’s message. After editing, git history rewrites the commit in place and updates all descendant branches accordingly. Unlike interactive rebase, this command doesn’t touch your working tree or index, and it even works in a bare repository. For example, if you notice a typo in a commit message two commits back, you can fix it with a single command, no rebase necessary.

git history split

The split operation allows you to break one commit into two by interactively selecting which hunks go into the new parent commit. The interface mirrors git add -p, so it feels familiar. Here’s a quick example:

$ git history split HEAD
diff --git a/bar b/bar
new file mode 100644
index 0000000..50810a5
--- /dev/null
+++ b/bar
@@ -0,0 +1 @@
+bar
(1/1) Stage addition [y,n,q,a,d,p,?]? y

After you choose hunks, Git creates a new commit containing those changes, making it the parent of the original commit (which retains the unselected hunks). The command then rewrites any descendant branches to point to the updated history. This is perfect for separating a logical change that was accidentally committed together.

Git 2.54: A Simpler Way to Rewrite History with `git history`
Source: github.blog

Limitations and Design Philosophy

git history intentionally avoids some scenarios. It does not support histories that include merge commits, and it refuses to perform any operation that could result in a merge conflict. The design goal is focused, non-interactive rewrites—not the open-ended history manipulation typically associated with git rebase -i. By keeping the scope narrow, the command stays fast and predictable.

Under the hood, git history is built on the core machinery of git replay, which was extracted into a library as part of this work. This foundation ensures reliability and opens the door for future enhancements.

Looking Beyond

The introduction of git history is part of a broader effort to make Git’s history-editing capabilities more approachable. While interactive rebase remains the go-to for complex rewriting, the new command lowers the barrier for everyday tasks. As the Git project continues to evolve, we can expect further refinements and possibly additional operations built on the same library.

Conclusion

Git 2.54 brings a welcome addition for developers who occasionally need to tweak commit messages or split commits without diving into a full rebase. The git history command, though experimental, offers a clean, efficient alternative for simple rewrites. To learn more about all the changes in this release, check the official release notes or upgrade your Git installation today.

Recommended