Retcon

Drag, drop, done.

Rewrite Git history with a single drag-and-drop. Undo anything with ⌘Z. All speed, no bumps.

14-day trial • Requires macOS 14.3+

Let your code do the talking.

The Git history is a communication tool. And with Retcon, your word is clear. What prompted that refactor? How did these design choices come about? What the code can't say, the Git history recounts in great detail.

The trick is, your first draft is never your last. Commits begin their life as a stream of consciousness, created whenever they're needed, worded as best as the moment allows. They hold your code, certainly, but they don't showcase it.

So you rewrite. You take your hard work, and present it for all it's worth. Each decision, tradeoff, insight—now freed from your mind, illuminating your code with meaning and intent.

All of that, with none of the effort.

What people are saying.

[Retcon] turns rewriting Git history entries from a chore into a breeze.

John Gruber Daring Fireball

Retcon is a new app that applies a massive dose of Mac usability to rewriting Git histories. Bravo!

Daniel Jalkut Red Sweater Software

I always use Retcon when preparing step-by-step git repos for our workshops. It's *so* much more efficient for me than any other client for rewriting history, feels like magic.

Chris Eidhof objc.io

It saved me from myself within minutes of installing it

Joshua Nozzi Developer

It's incredibly convenient to just try something, get immediate conflict information and then decide to start working on it or back out. I cannot tell you how much time it has saved me for making decisions while working on complex rewrites.

Don Denton Developer

What Git should have always been like

Niléane Dorffer MacStories contributor

Typing is rewording.

From small refinements to sweeping reworks, you do everything faster in Retcon. Edits take fewer steps, and don't mess with the repo's state.

To reword in Retcon:

Select the commit to reword. Its details are displayed.
Enter the new message.

All done. Your files and stage have been left intact.

To reword in a conventional GUI:

If there are uncommitted changes, click Stash.
A window opens. Choose OK.
Right-click the commit to reword, and choose Reword.
A window opens with the commit’s current message. Enter the new message, and confirm.
If you stashed changes in step 1, click Restore Apply to restore them.
A window opens. Choose OK.

All done. Your uncommitted changes are restored, but the stage may have been reset.

To reword through the Git CLI:

If there are uncommitted changes, run git reset, then git stash.
This unstages all changes, and sets them aside.
Run git log. The current branch's history is displayed.
Find the commit to reword in the list. Copy its hash, and exit.
Run git rebase -i COPIED_HASH^ to start an interactive rebase.
An editor opens with a commit list. Change the first commit’s action to r. Save and exit.
A new editor opens with the commit’s current message. Enter the new message. Save and exit.
If you stashed changes in step 1, run git stash pop to restore them.

All done. Your uncommitted changes are restored, but the stage has been reset.

The cheatsheet you won’t need.

Retcon frees you to quickly experiment by making it easy to undo mistakes. So easy, in fact, that you already know exactly how.

	How to undo in Retcon	How to undo through the Git CLI
Undo creating a commit
Created a commit	Press `⌘Z`.	Run `git reset --soft HEAD~`.
Undo deleting a commit
Deleted a commit	Press `⌘Z`.	Run `git reflog` to display the list of recent head commits. Copy the first one’s hash. Run `git reset`, then `git stash` to set changes aside. Run `git reset --hard COPIED_HASH` to revert to the previous head commit. Run `git stash pop` to restore stashed changes.
Undo rebasing a branch (reword, move, delete, fixup)
Rebased a branch (reword, move, delete, fixup)	Press `⌘Z`.	See above.
Undo pulling from a remote
Pulled from a remote	Press `⌘Z`.	See above.
Undo pushing to a remote
Pushed to a remote	Press `⌘Z`.	Find the output of the `git push` command to undo. On the last line of the output, copy the first commit hash. Run `git push --force-with-lease COPIED_HASH`. If the remote branch was changed since your push, the new changes might be silently overwritten.
Undo creating a branch
Created a branch	Press `⌘Z`.	Run `git branch -d BRANCH_NAME`.
Undo deleting a branch
Deleted a branch	Press `⌘Z`.	Find the output of the `git branch -d` command to undo. Copy the commit hash. Run `git branch BRANCH_NAME COPIED_HASH`.
Undo staging a file
Staged a file	Press `⌘Z`.	To unstage the whole file, run `git restore --staged FILE_PATH`. To unstage specific hunks, instead run `git reset -p FILE_PATH`, and manually select the hunks.
Undo unstaging a file
Unstaged a file	Press `⌘Z`.	To stage the whole file, run `git add FILE_PATH`. To stage specific hunks, instead run `git add -p FILE_PATH`, and manually select the hunks. If some of the staged changes were not in the working directory, they cannot be recovered.
Undo confirming a conflict resolution
Confirmed a conflict resolution	Press `⌘Z`.	Abort the current rebase by running `git rebase --abort`. Restart the rebase from scratch. Recreate the same rebase list, perform the same message edits, and redo every conflict resolution yourself.

Sweat-free conflict resolution.

Retcon surfaces crystal-clear context at every step, and gives you the tools to quickly resolve any conflict—or even avoid them entirely.

Retcon doesn’t stop at telling you that a file has conflicts: it actually shows its detailed diff.

Get full context around the pausing commit: see the successfully applied parents, and what commits will be inserted next, including any mutations.

Don’t wait to find out whether your changes cause conflicts. Each manipulation is applied instantly, giving you full visibility at every step.

Made a mistake during a rebase? Just undo one operation at a time—no need to start over from scratch. Go back just enough, fix the mistake, and resume from there.

When in doubt, glance at the contextual guide: a concise, context-aware summary of your next steps to resolution.

You can manipulate the history at any time; even when there’s a conflict waiting. And sometimes, just reordering commits is enough to resolve a conflict.

Stay in the loop.

Subscribe to the newsletter and stay up-to-date with Retcon news. It’s only a few emails a year, and nothing else.

Packed with capabilities. Refined to perfection.

You can’t summarize years of steady R&D in just a few sentences. Here’s more of the countless features that make Retcon an incredible tool.

Browser-like head history.: Use familiar shortcuts to quickly check out recent branches.
Pause badge in Dock.: Stay focused on the current rebase even through distractions.
Built-in test sandbox.: Freely experiment with Git in a dedicated repository that resets automatically.
Parent pull+rebase.: In a single click, update the parent branch, and rebase on it.