# Git Interactive Rebase Tool for Git Sequence Editing

> Git Interactive Rebase Tool is a Rust terminal sequence editor for Git interactive rebase. It gives developers keyboard-driven control over actions, ordering, breaks, commit inspection, and exec commands.

**MitMaro/git-interactive-rebase-tool** — Native cross-platform full feature terminal-based sequence editor for git interactive rebase.

- Repository: https://github.com/MitMaro/git-interactive-rebase-tool
- Website: https://gitrebasetool.mitmaro.ca/
- Stars: 1,886 · Forks: 56
- Language: Rust
- License: GPL-3.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/mitmaro-git-interactive-rebase-tool

## Why Git Interactive Rebase Tool targets rebase todo editing

Git interactive rebase gives developers a todo file containing commits and commands that Git will process. Editing that file in a general text editor works, but changing several actions, moving entries, or inserting commands can become repetitive. Git Interactive Rebase Tool specializes in this file. The README identifies it as a native, cross-platform terminal sequence editor for Git 1.7.8 and later.

The project is intended for developers who rebase branches, squash commits, reword commit messages, remove entries, pause a sequence, inspect revisions, or execute commands between selected lines. It does not replace Git's rebase engine. Instead, Git launches it as a sequence editor, the program edits the todo list, and Git reads the saved file when the editing session ends.

That boundary keeps Git responsible for applying the rebase. Actions such as `pick`, `squash`, `fixup`, `edit`, `reword`, and `drop` remain Git rebase commands. The contribution here is a specialized interface for changing them, arranging entries, viewing commit information, and editing the resulting sequence. For occasional manual changes, this extra interface may not justify a separate editor. For frequent sequence editing, it removes much of the repetitive navigation associated with editing raw todo text.

## How the terminal editor connects to Git rebase

Git is configured to invoke a sequence editor when an interactive rebase begins. Git Interactive Rebase Tool receives the rebase todo filepath as its positional argument, displays that sequence in the terminal, and writes the edited file back when a write command is selected. The README's direct usage syntax uses the rebase todo filepath as that argument, so the practical invocation in normal use comes from Git rather than from a manually typed path.

The interface has normal and diff modes. The documented default navigation includes Up and Down for selection, Page Up and Page Down for movement in groups of five lines, and Home and End for moving through the list. `j` and `k` move selected commits down and up. `w` writes the interactive rebase file, while `W` writes it immediately. `q` aborts the interactive rebase, and `Q` aborts immediately. The `?` key opens built-in help in every mode.

The package is a Rust binary named `interactive-rebase-tool`. Its `Cargo.toml` declares edition 2021 and lists `crossterm`, `git2`, `pico-args`, `crossterm`, and Unicode-related dependencies. On macOS, the manifest enables the `use-dev-tty` feature for `crossterm`. These details match the repository's terminal-oriented design. The release profile enables link-time optimization, incremental compilation, symbol stripping, and a single codegen unit, although these settings describe build behavior rather than runtime performance guarantees.

## Installing and configuring Git Interactive Rebase Tool

The README links to `./readme/install.md` for installation, but the project overview does not reproduce that document's commands. Obtain the `interactive-rebase-tool` executable through the documented installation path, then make sure Git can find it. The base setup is a global Git configuration assignment. On most systems, the documented command is:

```shell
git config --global sequence.editor interactive-rebase-tool
```

After this change, Git will use the executable when it needs an interactive rebase sequence editor. Check the installed binary's command-line help before starting a rebase:

```shell
interactive-rebase-tool --help
interactive-rebase-tool --version
```

The first command exposes documented command-line help, and the second reports the installed version. The package manifest currently declares version `2.4.1`, so the version output is useful when checking a system installation against the repository package.

Windows requires path-specific examples. Command Prompt and Windows Terminal can use the executable path in single quotes:

```shell
git config --global sequence.editor "'C:/path/to/interactive-rebase-tool.exe'"
```

Git Bash requires `winpty` according to the README:

```shell
git config --global sequence.editor "winpty /c/path/to/interactive-rebase-tool.exe"
```

For a first interactive rebase, Git can then open its normal todo sequence. Once the sequence editor opens, use `?` for built-in help. Select a commit, change its action, reorder it with the movement keys, inspect its overview or diff, and press `w` to write the todo file. Before writing, confirm that the resulting sequence contains the intended Git commands, because Git will act on those entries after the editor exits.

The README also documents a per-operation override through Git's `GIT_SEQUENCE_EDITOR` environment variable. It shows `emacs` as an example, confirming that the project is intended to coexist with other sequence editors rather than replace every editor on a system.

## Visual mode, breaks, exec entries, and commit inspection

Visual mode is the feature that distinguishes this editor from simple todo-file manipulation. The README states that users can change actions and reorder multiple lines at once. That is useful when a contiguous block of commits must move together or undergo the same action change. The documented `break` toggle adds or removes `break` entries, allowing a developer to choose where Git should pause during execution. The editor does not define what happens after the pause; Git resumes through its normal rebase workflow.

Commit inspection is also built into the session. A key press opens the commit overview, and another documented view presents the full commit diff. These views provide context before deciding whether to `reword`, `edit`, `squash`, `fixup`, or `drop` a commit. The `exec` editor changes the command associated with an `exec` entry, while an external-editor command temporarily hands control to the user's configured Git editor and then returns to the tool.

The README documents Unicode and emoji support, along with width-aware dependencies in `Cargo.toml`. That matters because rebase todo subjects are arbitrary commit text, and incorrect cell-width handling can shift selections or render lines poorly. However, the documentation does not describe every terminal emulator, font, or remote console combination. A team with unusual terminal infrastructure should verify rendering on its actual host.

The README does not publish every key binding in its feature list, but it directs users to `readme/customization.md` for configurable bindings. Users should consult that file before writing team procedures around keys beyond the common defaults. This matters because an editor intended for speed becomes inconsistent if documentation assumes bindings that have been customized locally.

## Generating exec commands after modified rebase lines

The optional `interactive-rebase-tool.postModifiedLineExecCommand` setting inserts an `exec` action after modified todo lines. The README defines a modified line as one whose action, command, or reference changed. The configured value points to an executable or script. Documented uses include updating references after an amended commit and running a test suite only for modified commits.

The README supplies this global configuration example:

```shell
git config --global interactive-rebase-tool.postModifiedLineExecCommand "/path/to/global/script"
```

It also describes repository-specific scripts, but the command printed for that example still uses `--global` and points to `/path/to/repo/script`. As written, the command does not establish repository-local scope. Users who need targeted scripts should inspect the project's customization documentation or Git configuration behavior instead of assuming the prose and command are equivalent.

The script receives a stable action argument, followed by data specific to the modified line. Commit actions receive the original commit hash. An `exec` change receives the original and new commands. Label, reset, merge, and update-ref changes receive the original and new label or reference. A generated sequence can therefore look like this:

```text
label new-onto
exec script.sh "label" "onto" "new-onto"
```

This mechanism has real consequences. Every modified line may add another process invocation to Git's rebase sequence, and a failing script can affect whether the rebase proceeds as intended. The README does not document script sandboxing, timeout behavior, or automatic recovery. Scripts should therefore remain explicit and inspectable in the generated todo file.

## Platform constraints, licensing, and upgrade costs

The README claims operation on Linux, macOS, Windows, and many other systems. Windows support has documented caveats. Git Bash needs `winpty`, while Windows versions before version 10 can display saturated dark colors poorly. The README points to Microsoft's ColorTool as the remedy for updating the console theme. It does not promise identical rendering across every terminal, so visual verification remains necessary on unsupported or unusual environments.

The repository is not archived, and its last push was on 2026-04-14. Release records include version 2.4.1 from 2024-06-27 and version 2.4.0 from 2024-06-13. Another entry carries the label `Latest Release` and a date of 2019-07-24, but the release list does not explain how that label relates to the newer numbered releases. Users should select artifacts by actual version rather than relying on the label.

`Cargo.toml` specifies `GPL-3.0-or-later`, while the repository summary identifies GPL-3.0. The package includes `COPYING` and marks it as the license file. Organizations that redistribute the executable should review that license text and assess their compliance obligations. This review does not replace advice from qualified counsel.

Upgrade cost includes checking `CHANGELOG.md`, custom key bindings, and any scripts used with `postModifiedLineExecCommand`. The repository contains Rust source, tests, a lockfile, package metadata, and separate documentation. The README does not document an automatic migration for configuration or key bindings, so an upgrade should be checked against the local configuration rather than treated as a transparent replacement.

## Git Interactive Rebase Tool versus ordinary todo editing

The documented alternative is to keep a general editor as Git's sequence editor. Git Interactive Rebase Tool can be bypassed for one operation through `GIT_SEQUENCE_EDITOR`, and the README uses `emacs` in that example. A general editor opens the generated todo file as text, leaving the developer to locate lines, edit commands manually, and save the file.

Git Interactive Rebase Tool adds dedicated controls for action changes, single-key reordering, multiline visual mode, `break` toggles, commit overviews, full diffs, external-editor access, and optional generated `exec` entries. Those additions reduce repeated text navigation for frequent rebase work. They also add another terminal application, its key-binding model, and its own configuration to understand.

A general editor is the more proportionate choice when a team edits interactive rebase files occasionally or already has editor automation for Git todo syntax. Git Interactive Rebase Tool is more suitable when rebase sequence editing is routine and the team values visual operations or automatic post-modification commands. The deciding factor is workflow fit, not a claim that one editor produces different Git commits. Both edit the same rebase instructions, so Git remains responsible for executing them.

## Conclusion

Adopt Git Interactive Rebase Tool if repeated interactive rebase edits are part of your workflow and you want dedicated terminal controls for actions, ordering, visual changes, and generated exec commands. Do not adopt it for occasional todo edits if your existing editor and Git configuration already cover that need. Before deployment, verify the installed version on each target platform, the intended Git configuration scope, and the GPL-3.0-or-later obligations for your distribution.

## FAQ

### How do I install Git Interactive Rebase Tool?

The README links to `readme/install.md` for installation instructions but does not reproduce them. After obtaining the executable, the documented base setup configures Git to use it as the sequence editor.

### How do I configure Git to use Git Interactive Rebase Tool?

On most systems, run `git config --global sequence.editor interactive-rebase-tool`. The README provides separate path and `winpty` forms for Windows Command Prompt, Windows Terminal, and Git Bash.

### Can Git Interactive Rebase Tool reorder commits and change rebase actions?

Yes. It documents single-key reordering, visual mode for multiple lines, and support for `pick`, `squash`, `fixup`, `edit`, `reword`, and `drop`.

### Does Git Interactive Rebase Tool support commit diffs and exec commands?

Yes. The README documents commit overviews, full commit diffs, editing existing `exec` commands, and optional `exec` actions after modified lines.

### What license applies to Git Interactive Rebase Tool?

`Cargo.toml` specifies `GPL-3.0-or-later`, and the package identifies `COPYING` as its license file. Distribution requirements should be evaluated against that license text.

## Sources

- [License: GPL-3.0](https://github.com/MitMaro/git-interactive-rebase-tool/blob/master/LICENSE)
- [MitMaro/git-interactive-rebase-tool on GitHub](https://github.com/MitMaro/git-interactive-rebase-tool)
- [Project website](https://gitrebasetool.mitmaro.ca/)
- [README](https://github.com/MitMaro/git-interactive-rebase-tool/blob/master/README.md)
- [Releases](https://github.com/MitMaro/git-interactive-rebase-tool/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mitmaro-git-interactive-rebase-tool