Redline

Open a Markdown or text file and choose Redline beside Diff and File. The whole document reads as prose, with the words that were removed struck through and the words that replaced them right after. Copying gives you the new text.

The page reads like a marked-up document. The column is wide enough for prose, a marking that wraps onto a second line is drawn as one passage, and the change you are on is shown by a bar in the margin. Accept all and the count of changes line up with your text.

A Markdown table is marked row against row, so renaming a column shows the words that changed rather than the whole table struck through and repeated.

Redline is for prose. A source file gets no Redline option, because a diff already reads the way code is read.

A file Git tracks is marked against its last commit. A file Git does not know about is marked against what it held when you opened it. The redline says which of the two it is using, so a page with nothing on it is never mistaken for one that has not loaded.

It redraws by itself when an agent writes to the file. While you have unsaved edits it waits, so a redraw never takes your own typing away.

Point at a change, or step to it with ⌥↓ and ⌥↑. Press ⌥⌫ and that one phrase goes back to what it was, while every other edit in the file stands. The redline then moves to the change that came next, and ⌥↓ and ⌥↑ come round at the ends, so a run of changes is one key pressed again and again. A small panel appears beside the change with the same keys written on it, and the Edit menu carries the same rows while a redline is open.

Your own paragraph carries the same control as an agent's. ⇧⌥⌫ undoes the last rewind you made, for as long as the tab is open.

Press ⌥↩ on a change and it stops being marked, without a byte of the file being written, and the redline moves on to the next change. From then on the redline is measured from that point, so what stays marked is what you have not read yet.

Accept all sits at the top of the redline and clears everything marked at once. It has no keyboard shortcut on purpose, so nothing is one keystroke away from accepting a whole file, and there is no undo for it.

A typo you notice while reading no longer means switching to Source to fix it and switching back. Type in the redline and what you type is drawn as an insertion like any other change. ⌘Z takes it back, and ⌘S writes the file.

The controls belong to the change you are on rather than to your pointer. They stay put while you read, while you type in that change, and while an agent writes to the file, and they move with the change when the text reflows underneath them. Clicking anywhere else in the text puts them away.

What you accept outlasts the tab. Close the file, reload the window, or quit and come back, and the marking is still narrowed to what you accepted, with the day it was taken written beside it.

It lasts until the file's committed version changes, or a week after you accepted, whichever comes first. After that the redline goes back to marking every change since the commit.

• Redline is for Markdown and text files. A source file opens as a diff instead.
• Accept all cannot be undone, which is why it has no keyboard shortcut.
• Undoing a rewind lasts as long as the tab is open, and ends the moment you accept anything.
• A paragraph you rewrote rather than edited still shows as the old one struck through and the new one after it, because there is no single word left to mark.
• A table over about four thousand characters gets no redline at all.
• On a narrow pane the controls sit over the prose, because there is no room beside it.
• A write of exactly the same size, landing in the same instant as your rewind or save, can still be written over.