Introduction
The open-source Git project has released version 2.54, bringing improvements from over 137 contributors—66 of whom are new to the project. This release, together with the previously unreviewed Git 2.53, introduces a range of features designed to make everyday version control tasks more efficient. In this article, we’ll explore one of the most notable additions: the experimental git history command, which offers a simpler alternative to rewriting commits.
The Challenge of Rewriting History
Git has long provided powerful tools for reshaping a repository’s commit history. The venerable git rebase --interactive (git rebase -i) is incredibly flexible—it lets you reorder, squash, edit, and drop commits. However, that flexibility comes at a cost. Interactive rebase operates on a range of commits, updates your working tree and index as it progresses, and can leave you in a conflicted state that must be resolved before moving on.
For simple tasks—such as fixing a typo in a commit message three commits back or splitting one commit into two—the full machinery of an interactive rebase feels heavy. You have to set up a to-do list, mark the commit for editing, and drive the rebase to completion. Git 2.54 introduces git history to address precisely these scenarios.
Introducing git history
The new git history command is designed for targeted, non-interactive rewrites. It currently supports two operations: reword and split. Built on the core machinery of git replay (which has been extracted into a library), git history aims to simplify common history-editing tasks without the overhead of a full rebase.
git history reword
To change a commit message, simply run git history reword <commit>. This opens your editor with the message of the specified commit. After you save and exit, Git rewrites the commit in place and updates all descendant branches accordingly. Unlike git rebase, this command does not touch your working tree or index. It can even operate in a bare repository, making it ideal for scripted or server-side workflows.
git history split
Sometimes a single commit contains changes that logically belong in separate commits. With git history split <commit>, you can interactively split a commit into two. The interface will feel familiar if you’ve ever used git add --patch (git add -p). Git presents each hunk of the commit and asks you to decide whether to include it in the new parent commit. For 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,?]? yOnce you’ve selected hunks, Git creates a new commit containing those changes as the parent of the original commit (which retains the remaining hunks). Any branches that descended from the original commit are automatically updated to point at the new history.
Intentional Limitations
The git history command is not meant to replace git rebase -i for complex rewrites. By design, it has two important limitations:
- It does not support histories containing merge commits.
- It will refuse to perform any operation that would result in a merge conflict.
These constraints reinforce the command’s purpose: it’s for targeted, non-interactive rewrites—fixing a commit message or splitting a commit—rather than open-ended history modifications. The underlying engine (git replay) ensures that changes are applied cleanly, without the need for conflict resolution.
Conclusion and Future Directions
Git 2.54’s git history command fills a gap between the all-powerful interactive rebase and no history editing at all. While still experimental, it already offers a streamlined workflow for two common tasks. As the command matures, we can expect additional operations and broader support. For now, if you’re using Git 2.54, give git history reword or git history split a try in your next project—it might become your go‑to tool for quick fixes.
For more details on Git 2.53 and 2.54, check the official release notes and the GitHub blog.