Bookmarks and incidents

• Saved bookmarks are never overwritten. A bookmark set while a large file was still indexing could replace the file's saved bookmarks and notes with that one bookmark. The saved set and the session's bookmarks are now merged when the saved set loads, and every save merges the same way.
• Move Line keeps bookmarks through undo. Moving a line up or down carried its bookmark and note, but undoing the move left them on the wrong line. Undo and redo now restore them exactly. A move involving the last line of a file with no final line ending used to drop the bookmark; it keeps it.
• Join Lines keeps the first line's bookmark. Joining a selection kept the bookmark of the last joined line instead of the first; Replace All of a whole line did the same. The first line keeps its bookmark and note.
• Extract Incident Window works on a followed log. It refused with "Document changed" on any file that was being appended to while the dialog was open. It now refuses only for edits made in Caxton, and Delete Bookmarked Lines and Delete Lines Matching check the same way.
• The Bookmarks panel. The Text column no longer ends in a replacement character on a long line with accented text; a note edit finished after the bookmark moved no longer creates a stray bookmark; the title follows a rename; the ring tooltip refreshes after the note is edited.

Following

• Rotation under Follow. When a followed file is rotated, the follower finishes reading the old file, shows the rotation prompt, and starts fresh on the new file. No byte of the old file lands in the new one. A renamed file is followed as before, and if the file is deleted the banner says how many bytes were read after the rename and how many could not be.
• A Catch Up that cannot reload leaves the follower where it was and says so. Before, it skipped the backlog silently or re-read bytes it had already shown.
• Catch Up and dialogs. The automatic catch-up never fires while a dialog is open. Choosing Discard in the Catch Up dialog keeps Follow on, and a manual Catch Up leaves Follow the way you had it.
• Open Skipped Range as Slice is disabled for a file reopened in another encoding (the tooltip says why) and after a rotation clears the range.
• Follow starts exactly where the file was loaded, so bytes written in the instant between the load and the first poll are shown once, not twice.

Go to Time and timestamps

• Followed syslogs keep the right year. A syslog followed across a month boundary dated the new lines a year earlier and reported the log out of order. The year reference now refreshes from the file as it grows, and a year typed in Timestamp Format replaces it outright.
• Short logs detect. A file with one or two stamped lines, or a followed file that starts empty, gets a timestamp format. Before, it never became a log for the session.
• Go to Time lands on the record when a record is followed by a long block without timestamps (a dump or a trace longer than the lookback budget), instead of at the end of the file.
• More zone forms. GMT+02:00, UTC+2 and GMT-0530 are read as offsets. An offset typed with no unit (+5) is refused with a hint instead of being read as a line number. A log whose lines carry different offsets is shown in a named zone rather than one fixed offset.

Filtering

• The bar's Severity gate is the one that applies. Apply and Extract All in the Filter Lines panel use the gate as it stands, even when it changed after the panel opened.
• Stack traces follow their record further. A line with no level word and no timestamp follows its record up to 4,096 lines or 1 MB back, the same reach as Go to Time and Extract Incident Window. The filter used to stop at 64 lines.
• Whole-second To edges. A time window's To edge typed without a fraction covers its whole second, so 14:10:59 includes 14:10:59.999.
• Small fixes. A severity level not in the menu shows as its own row instead of a blank; the panel focuses its first field when that row is a time or severity row; a gate is dropped cleanly when a document leaves Log Mode; a level word cut by the scan limit no longer counts by its prefix.

Encodings

• Windows-1252 with sparse accents is detected again. 1.7.1 asked for two sampled windows before calling a file legacy, which left an export whose only accented bytes were a few names open as UTF-8 with replacement characters. A single window that reads as text is enough again; a UTF-8 file with a burst of binary garbage still stays UTF-8.
• The banner names the likely encoding. A low-confidence UTF-8 open says "Some bytes look like Windows-1252. Reopen with that encoding?" and File ▸ Reopen with Encoding preselects it.

Under the hood

• Severity Patterns states that patterns are tried top to bottom with the first match winning; an entry written by a newer Caxton shows greyed and can be removed or moved.
• Syntax coloring after an external reload no longer reuses the previous file's states.
• Large pastes and tail appends no longer make a second copy of the inserted bytes.
• Split panes share the regex-pause state, so both panes agree and the pause banner shows once.

Following

• Catch Up asks first. Catching up on a file with unsaved edits asks before discarding them; the automatic catch-up past half a gigabyte of lag pauses Follow instead. Bookmarks and their notes re-anchor into the new window when its index completes.
• Reopened files catch up correctly. A file reopened in another encoding resumed from the wrong byte after Catch Up, re-appending part of the file or reporting a truncation that never happened. The follower now resyncs to the source file's length. The automatic catch-up is off for those files; View ▸ Log ▸ Catch Up to Live does it on demand.
• Nothing dropped silently, kept honest. Follow starts from the bytes already loaded, so lines written between the open and the first poll stream in. A rotation prompt names any bytes of the old file that had not been read. A read error pauses Follow with the reason. The Following pill and the automatic catch-up track the lag against the last report, so a steady drift is reported.
• The read size grows only when a tick was full. A trickling log no longer walks the read size to its ceiling and then absorbs the next burst in a single 128 MB read.
• Open Skipped Range as Slice. View ▸ Log ▸ Open Skipped Range as Slice opens the bytes a Catch Up left outside the window in their own window, and the banner's byte range is the range actually outside the window.

Bookmarks and incidents

• Notes stay on their line. Delete Line, Move Line Up and Down, Delete Non-Bookmarked Lines, Delete Bookmarked Lines, and undo of any of them keep notes with the lines they belong to. A note on a deleted line goes with it instead of landing on the next record.
• Notes persist within seconds of a change, not at quit.
• A rename during indexing no longer loses the sidecar. Bookmarks and markers from earlier sessions follow a move even while the index is still building, markers added this session follow too, and changes made after the move reach both paths.
• The Bookmarks panel is titled with its document, closes with it, keeps an in-progress note edit through other changes, refreshes its text after edits, and edits a note on Return. Hovering a noted bookmark's ring shows the note.
• Extract Incident Window validates Before and After, refuses when the document changed while the dialog was open, writes headers in the document's line ending, and bounds a seconds window that runs into untimestamped lines. Copy as Incident Notes flattens newlines and tabs and cuts long text on a character boundary.
• Severity Patterns apply top to bottom. Literals and regexes are tried in the order listed, first match wins, Move Up and Move Down reorder them, blank rows are not saved, and a malformed entry no longer discards the others.

Filtering

• Severity is a gate. The bar's Severity popup applies over every condition, OR joiners included, and the digest says so. The Filter Lines panel keeps its Severity rows on Apply and Extract All, and gains Time window rows (From and To in the Go to Time forms).
• Stack traces stay with their record. A line with no level word and no timestamp follows the record above it, so Error and above keeps the trace under its error line.
• One vocabulary. The row tint, the minimap ticks, the filter and the Bookmarks panel classify a line the same way; bracketed levels, level=ERROR and JSON logs tint the way they filter. Changing Severity Patterns re-runs an active severity filter, the split pane takes the rules, and a slow pattern pauses regex patterns for ten seconds instead of stalling scrolling.

Go to Time and timestamps

• The log's own zone. Typed times and the landing banner use the zone the lines carry when they carry one, instead of this Mac's.
• More formats recognized. Apache access and error logs, nginx error logs and Go's log package parse now.
• Detection votes among recognized lines and waits for the full sample, so a log whose records span several lines detects. Day-first dates win when any sampled line proves them. Syslog years roll per line across New Year. UTC and GMT and a DST boundary are read correctly, February 31 and request IDs are not dates, and the Timestamp Format choice is kept with the session.
• Honest landings. A continuation line deep in a stack trace keys to its own record, the banner says when a log is not in time order near the landing, and a Go To entry that does not parse says why instead of closing.

Under the hood

• Syntax coloring stays right after Replace All. The incremental re-lex invalidates on bulk edits, applies each edit at its own line, settles on the right line for multi-line pastes, and extends its states when the index completes.
• Encoding detection needs two windows to call a file legacy. One window of bad bytes in an otherwise UTF-8 file is damage, not a reason to transcode the whole file.

Time and severity

• Go to Time. In a log whose lines start with a timestamp, the Go To field (⌥⌘L) takes 14:03, 2026-09-04 14:03, or +5m from the caret line, and lands on the first line at or after it. The search probes a few dozen lines through the index, so it is instant at 10 GB, and the banner names the line and time it landed on.
• Timestamps recognized. ISO 8601, syslog, Apache and nginx, Unix epoch in seconds or milliseconds, and slash-dated forms. Caxton votes the format from the first lines; View ▸ Log ▸ Timestamp Format… overrides the vote, the zone for lines that carry none, and the year syslog lines lack.
• Filter by severity. The filter bar gains a Severity popup in log documents (Warn and above, Error and above, Fatal only, and the rest), and any row in the Filter Lines panel can match by level instead of text. One vocabulary drives the row tint, the new red and amber ticks in the minimap, and the filter: ERROR, WARN, INFO, DEBUG, FATAL and their relatives, plus your own words or regexes from View ▸ Log ▸ Severity Patterns…, which win over the built-ins.

Incidents

• Notes on bookmarks. Edit ▸ Bookmarks ▸ Add Note to Bookmark… puts a note on the caret line, bookmarking it first if needed. A noted bookmark shows as a ring in the gutter; notes move with their line, go when it goes, and survive relaunch.
• The Bookmarks panel (⌥⌘M) lists every bookmark with its timestamp and severity in a log, its first line of text, and its note, editable in place. Double-click navigates. Copy as Incident Notes puts the table on the clipboard as plain text for a ticket.
• Extract Incident Window… takes the lines around every bookmark, N lines before and after, or in a timestamped log N seconds before and after by record time, merges overlapping windows, and writes them to a new document with a header naming each block's source span.

Following a fast file

• Behind by how much. When a file grows faster than one poll absorbs, the Following pill says how far behind it is and the read size adapts to what a tick can take.
• Catch Up to Live. Past half a gigabyte of backlog Caxton reloads the last 64 MB and tells you exactly which byte range it skipped; View ▸ Log ▸ Catch Up to Live does the same on demand. Nothing is dropped silently.
• Follow works on reopened files. A file reopened in another encoding can Follow now; appended bytes are transcoded as they arrive, code units split across a poll included.

Fixed

• The reopen hint stopped nagging. 1.6.1 showed "Detected: UTF-8 (85%)" on every plain text file over 256 KB. Detection now samples four windows through the file plus the tail: all-ASCII is near-certain, a valid multibyte window confirms UTF-8, and only a window that is not UTF-8 keeps the hint, naming the encoding it found. A stray bad byte is treated as damage, not a legacy encoding.
• Scratch files from a killed Caxton are swept at the next launch instead of after a day; each Tier-2 line index was 1.2 GB on disk.
• Bookmarks and markers follow a rename. When a file is moved or renamed under an open window, its bookmarks and markers are copied to the new path and the banner names it.
• Under the hood. Fold detection runs off the main thread, syntax coloring re-lexes from the edited line instead of the whole file, and the code base builds clean under Swift's complete concurrency checking.

Saving

• Closing waits for the save. Closing a window or quitting while a save was still writing used to tear the document down underneath it. The close now waits, and a streaming save finishes first.
• Symlinks save through. A file opened through a symbolic link is written to its target in every save tier. The atomic path used to replace the link with a plain file and leave the target untouched.
• Lost-update checks before the write. A save compares the file on disk with what was opened before writing the temporary copy and again before the swap. An external change you chose to overwrite once is asked about again if the file changes again.
• Recovery, tidied. The recovery journal writes off the main thread. A journal whose file has moved offers Locate, Discard, or Decide Later instead of being deleted, and replaying recovered edits rebuilds the index once. Untitled documents keep their backing file under Application Support and never appear in a session.
• Tail mode saves honestly. Saving a file that grew while you followed it stops with an offer to Save As instead of writing a stale copy.
• Save As of a reopened file says UTF-8. A file reopened in another encoding is written as UTF-8 on Save As, and the panel says so before you click.

Editing

• Invalid bytes are left alone. Text menu transforms refuse a target that contains invalid UTF-8 and name the line, instead of quietly rewriting those bytes as replacement characters.
• The Text menu works under a filter. With a filter or Narrow active, transforms apply to the visible lines. Operations that reorder or change the line count need one contiguous block and say so.
• Folds and bookmarks survive bulk edits. Replace All, Delete Lines Matching, and the other bulk operations rebase folds and bookmarks in one pass. Typing on a fold's first line no longer unfolds it.
• Split view targets the focused pane. Every Text menu operation, ⌘/ and the bracket commands act on the pane with focus, not always the left one.
• Multiple cursors, completed. Cut removes every selection, Copy joins them in document order, completion lands at every caret, and snippet stops follow mirrored typing.
• Small truths. Alphabetical sort is stable for lines that compare equal. Hard Wrap keeps runs of spaces. Word Count counts lines the way the gutter does. A per-pattern tab width applies to indenting and outdenting, not only to display. Clicks and the caret agree with the screen on wrapped long lines.

Find, Filter, Compare

• Exact counts past two million. Find keeps counting after the highlight cap and reports the total with how many are highlighted. Replace All still replaces every one.
• Replace All, faster. The regex compiles once and each line is scanned once. Fifty thousand matches on one very long line no longer rescan it per match.
• Whole word means the same everywhere. Filter's word boundaries read the neighboring character the way Find does, and Find accepts zero-length regex matches the way Filter does.
• Extract All refuses a partial view. When a regex filter timed out before covering the whole file, Extract All and cut-visible say so instead of exporting the scanned prefix.
• Batch Replace. Runs report each pair as it starts and cancel between pairs. Across all open documents, each window keeps its own undo and its own caret. Pair lists import with quoted newlines intact, a .tsv extension means tabs, and export offers .tsv. A match after an invalid byte on its line is replaced instead of dropped.
• Compare, made careful. CR-only files compare line by line, differing line endings are noted, a target that changes on disk is flagged when you return, Save Report reports write failures, a copy waits for the alignment it belongs to, and the window reads under VoiceOver.
• Sort by Match Text is off the main thread. A million-match results panel sorts without freezing the window.

CSV

• Decimal commas do not make a column. A comma that mostly sits between digits forfeits its vote, so semicolon and tab files with European decimals detect correctly. A file with one value per line opens as a one-column grid.
• Edits during a save say so. Grid paste, clear, fill, row delete, transpose, and the column operations banner when a save is in flight instead of failing silently or claiming success.
• Header truths. Insert Sequential Numbers respects the header flag, Promote Row to Header flips it after the move lands, and Delete Row on a one-row table works.
• Filters and structure. A structural operation on a filtered grid releases the row filter and tells you. A quoted field followed by a bare carriage return is reported instead of silently re-encoded.

Opening and watching

• One bad byte no longer fails the open. Legacy encodings decode in chunks; a chunk that fails is bisected and only the undecodable bytes become replacement characters. Transcoding runs in the background with progress and a cancel.
• Detection admits what it does not know. Confidence is capped for a pure-ASCII head of a larger file, overlong and surrogate sequences are rejected, and a forced encoding wins over the BOM sniff.
• The external-change prompt gains Compare. See the difference before choosing. Keep Mine covers one change; a later external write asks again. A deleted, renamed, or unmounted file is reported in tail mode too.
• One file, one window. The same file opened through different paths lands in the existing window. Files opened while a panel is key join the last active editor's group.
• Window menu. Show Previous Tab and Show Next Tab (⌃Tab, ⇧⌃Tab) walk the tabs. Quitting with several unsaved documents offers Review Changes, Discard Changes, or Cancel.

Licensing

• Deactivation reports what happened. Released; released on this Mac after the server refused; or kept when the server could not be reached, in which case the Mac stays activated so a retry can free the seat.
• Banners name the reason. A refused edit says the document is read-only, or that editing is off until Caxton is licensed, instead of "unavailable while saving" for everything. Trial state is written to the keychain only when it changes.

Also

• Markers. A marker whose regex does not compile says so in the Markers panel. A pattern that takes too long to match is disabled for that document with one banner instead of stalling every redraw.
• Quieter when idle. The status bar refreshes at most ten times a second, the caret blink repaints only the caret, and the syntax rebuild for large source files is linear in bytes and cancels when a newer one starts.
• Workspaces and slices. Workspace import and export report failures and confirm overwrites, Windowed Slice validates its range, and the Command Palette re-validates a menu action before running it.
• Privacy policy. Names Lemon Squeezy as merchant of record and lists exactly what activation sends.

Compare, completed

• Copy changes across. Click a difference to select it, then copy it left or right. A file that is open in Caxton compares as its live text, unsaved edits included and labeled, and copies land in its buffer as one undo step. After a copy the panes recompute, and a comparison left open catches up when you come back to it.
• Ignore Case joins Ignore Whitespace. ASCII case folding; accented case stays significant.
• A report you can file. Save Report writes the differences as plain text: line numbers, minus and plus lines, one hunk per change.
• Honest at scale. Copy works only on fully captured sides, refuses blocks over 64 MB, and the arrows are ⌘↓ and ⌘↑.

The keyboard you expect

• Tab indents the block. With a selection, Tab indents the selected lines and ⇧Tab outdents them, repeatable, one undo step each. It used to replace the selection with a tab character.
• Rectangles from the keyboard. ⌥⇧ with ↑↓ starts or grows a rectangular selection at the caret, ←→ widen it, PgUp and PgDn extend it a viewport at a time, and a mouse-started rectangle keeps growing from the keyboard.
• Home, End, and pages. Home and End jump to the line's start and end (⌘ variants: the document's), and PgUp and PgDn move the cursor a viewport at a time instead of only scrolling. ⇧ extends throughout.
• ⌘D selects the next occurrence. First press selects the word under the caret; each press adds a cursor at the next occurrence, wrapping around, bounded to a 64 MB scan per press on very large files.

The Find panel, filled in

• Search Mode. Normal, Extended (escape sequences), or Regular expression: one choice in its own group, Notepad++ grammar.
• In selection. Count, Find All, Bookmark All, and Replace All stay inside the selection you had when you checked it. The zone follows your edits and clears visibly when it can no longer be trusted.
• Backward direction. Find Next walks toward the top of the document.
• Two Find Alls. Find All in Document opens the results panel; Find All in Open Docs hands the query to Find in Files on its All Open Documents scope and runs it.

Fixed

• A five-agent review hardened all of it. Seventeen fixes before release; the ones worth naming: a copy refreshes the edited window's display, a copy refused during a save says so instead of claiming success, comparing a file with unsaved edits against its own path is a buffer-versus-disk check again, and an armed In selection scope applies immediately rather than after the next option change.

Start from nothing

• A blank sheet that works. Delete every row of a headerless table and a sheet remains: numbered columns, the select-all corner, a blank row 1, and the add row below it. The table keeps its width, and typing starts row 1 at full width.
• New document, new CSV. Toggle CSV Grid on an empty document and a fresh three-column sheet appears, comma delimited, rows numbered from 1. Empty .csv, .tsv, and .psv files open straight to the sheet their extension promises instead of a could-not-parse banner.
• Type past the last column. One empty column now sits past the last on every editable sheet. Type in it and the column materializes with your value at that row; the + in its header still adds an empty column with one click. Rows already worked this way; columns now match.
• Paste builds tables. Raw delimited lines pasted into a cell spread across cells and rows, quotes respected. Pasted into a blank sheet they become the whole table. Prose with a comma in it stays one cell.

Fixed

• Wide pastes tell the truth. A paste wider than the table clips the overflow on every row the same way, and the banner counts exactly what was dropped. It used to truncate quietly on existing rows while appending full-width rows below.
• Wide-table safety. On tables past the grid's 512-column display cap the type-past-the-end column stays off, so typing there can never overwrite a column the grid was not showing.
• An emptied table forgets its troubles. Emptying a table that had parse warnings resets the structure state, so the blank sheet accepts typing instead of refusing with a stale warning. Sorting an empty sheet now says there is nothing to sort.

Power editing

• Comment anything. ⌘/ toggles line comments across the selection as one undo step, language aware, markers in a straight column, blank lines untouched. ⌥⌘/ wraps a block comment, and HTML routes ⌘/ there automatically since it has no line marker.
• Brackets behave. Typing a bracket or quote closes the pair with the caret between; typing the closer walks over it; backspace on a fresh pair removes both. Hand-typed closers are never swallowed and apostrophes stay single in prose. The matching bracket highlights at the caret, and Edit ▸ Brackets jumps to, selects, deletes, or changes the surrounding pair.
• Snippets with tab stops. Author them in Edit ▸ Snippets: placeholders with defaults, mirrors that type in two places at once, date and filename variables. Type the abbreviation, press Tab, and walk the stops while they track your typing. Esc bails out. Malformed syntax passes through untouched; a snippet never eats text.
• Complete from the document. ⌥⎋ lists identifiers from the file itself, frequency first, in a panel at the caret. No dictionary and no guessing, and the scan is bounded, so it is instant in a 10 GB log.
• Clipboard history. ⇧⌘V shows everything you cut or copied in Caxton, searchable. Pin what you reuse; pins survive relaunch. It never reads the system pasteboard, entries over a megabyte are not kept, and copies from files that look like secrets (.env, key material) are never recorded. With several cursors, ⌥Return spreads a matching multi-line entry one line per cursor.
• Per-file rules. Glob patterns set wrap, tab width, encoding, and syntax at open: *.log opens unwrapped as a log, and the vendor who ships Shift-JIS every week just opens right. First match wins per setting.

The grid, with Excel manners

• The select-all corner. The header row's gutter cell carries the corner triangle and selects every data row. Delete then clears the data and keeps the header; on a headerless file it can honestly empty the table, one undo either way, and nothing is left active afterward.
• Numbers that agree. With a header row, data starts at 1 in the gutter, the status bar, and VoiceOver alike; the header names itself.
• Autofit reads the title. Double-click a divider and the column fits its header as well as its data. Several columns selected fits them all; everything selected fits the table.
• A fuller toolbar catalog. Customize Toolbar now offers Quick Open, Commands, Clipboard, Go To Line, Find in Files, Word Wrap, Split, and Bookmark, and every tile shows its icon.

Fixed

• Fold chevrons on HTML files. Brace islands in a style block suppressed the indent chevrons for the whole file, while clicking where they belonged still folded. Detection now merges brace and indent regions, which is what the folding release promised.

The grid stopped rebuilding

• Add Column is quick now. Adding, inserting, or deleting a column used to rewrite the whole file and parse it again. Caxton now makes one small edit per row and updates the table as it goes. On a million-row file, Add Column lands in under a second, and undo is still one step.
• You keep your place. Adding rows, deleting rows, filling cells, and column edits no longer throw the grid back to the top. Sort and column moves still rebuild, but they put you back where you were when they finish.
• Add a row from the gutter. The empty row past the end now shows a plus in the gutter. Click it and you get a fresh row with the first cell selected, ready to type. Typing straight into the empty row works like before.
• Any delimited file opens in the grid. A file with real table structure goes straight to grid mode no matter the extension, so a tab-delimited .txt lands in the grid like a .tsv would. Tabs need only consistent columns; commas, semicolons, and pipes need near-perfect structure across the whole sample first, so logs and prose stay text.

Extract acts like a new document

• No more temp paths. Extract, match export, column extract, and streamed rewrites used to open with a temporary path in the title bar, and saving quietly wrote to that temp file. They now open as unsaved documents named for what made them, like “server-log (filtered)”, and the first save always asks where.
• The right extension. A result extracted from a CSV saves as a CSV. The Save panel suggests the document’s real extension instead of .txt.

Fixed

• A license could register the same Mac twice. Pressing Return while an activation was already running sent a second activation, and the key showed two devices for one Mac. Activation now locks while it runs, and entering a key this Mac already holds revalidates the existing seat instead of taking a new one. If a key of yours shows a duplicate device, write hello@caxton.app and we will clear it.
• Opening from Finder flashed a blank window. A leftover window from the app template showed for a moment before the document appeared, longest on large files. It is gone.
• Change markers below a deletion. Deleting lines marked every line after them in the gutter instead of only the seam. Only the seam carries the tick now.
• The gutter behaves like a control. The pointer over the line-number gutter is an arrow instead of the text cursor, and clicking the gutter to select a line works while scrolled sideways.
• Toolbar labels moved into the buttons. With Icon and Text on, each button in the pill shows its own name instead of one “Actions” caption under the whole group.
• Filtering landed at the bottom. Applying a filter from deep in a file left the view clamped to the bottom of the shorter result. It now goes to the top of the results, and keeps your cursor in view when its line survives the filter.

Go anywhere

• Quick Open. ⇧⌘O fuzzy-searches your open tabs, recent files, and every file your workspaces reference, with size, modified time, and path on every row. Picking an already-open file switches to it instead of reopening. No folder crawling, ever: the candidates are the files Caxton already knows about.
• Go To grew three targets. ⌘L still takes a line number; now 50% jumps to the middle of the file (it works even while a huge file is still indexing), b1234 lands on an exact byte without ever splitting a character, and r1234 goes to a record when the document has one.
• Change markers. Lines you’ve edited since the last save carry an accent bar in the gutter; deletions leave a tick at the seam. ⌃⌘↑ and ⌃⌘↓ jump between changes, and Revert Selected Change puts the original bytes back as one undo step. Sorting a CSV marks moved rows honestly: marked, but revert points you at undo instead of guessing.

Windows, tabs, and folding

• More than one window. Drag a tab out of the strip (or Window ▸ Move Tab to New Window) and it becomes its own window; drag it onto another window’s tab row to move it there. Drag within the strip to reorder.
• Pin and reopen. Right-click a tab to pin it: pinned tabs lead the row behind a pin glyph and lose their close button, so a stray click can’t take them down. ⇧⌘T reopens the last closed tab with its cursor, scroll position, and mode intact.
• Folding. Indented regions and brace pairs fold from the gutter chevrons, the keyboard (⌥⌘← and friends), or Fold All, which runs as a cancellable job on big files. A folded anchor shows how many lines it hides; search hits and Go To targets inside a fold open it automatically. Braces inside strings and comments never fool it.

Workspaces that travel

• Relative paths and moved files. Workspaces remember their common folder, so a project that moves or mounts elsewhere still opens. A file that moved inside the project is found again by name, size, and modified time, with the search bounded so it can never crawl your disk.
• Export and import. A workspace exports as a JSON file you can drop in the project folder or send to another Mac; importing resolves files against wherever the definition sits.

Looks and feel

• The gutter has its own plane now. In dark mode the gutter, tab bar, and status bar share one chrome tone with a clean separator against the editing surface, in both the text view and the grid.
• A real toolbar pill. Find, Filter, and CSV live together in a single capsule, Safari-style, and the Find button now closes the bar on a second click. Document tabs are larger and stand out from the bar.
• Recovered new documents behave. A new document restored after a crash is still called “Untitled” and saving it always asks where, so a temp path never leaks into your face.
• Crash loops break themselves. If two launches in a row die while restoring the previous session, Caxton offers to start without restoring; the session is kept either way.

Fixed

• A disk that vanishes no longer takes Caxton with it. If a file’s storage stopped answering while Caxton was reading it (a network drive dropping off, an external drive ejected, a cloud file evicted from local storage), the app crashed, and since the next launch reopened the same file, it crashed again. Unreachable bytes now read as empty, the app stays up, and the changed-on-disk prompt handles the rest.
• Sorting a CSV with a column selected. With a header row on and a whole column selected, the selection statistics could catch the grid mid-rebuild right after a sort and crash. They now sit out the rebuild.

Batch Replace

• Hundreds of find/replace pairs, one run. Edit ▸ Find ▸ Batch Replace… holds a pairs list with per-pair case, whole-word, and regex options. Two modes, stated plainly in the panel: one pass (every pair matches the original text, overlaps go to the earlier pair, one undo step) or in order (each pair sees the previous pair's output, one undo step per pair).
• Per-pair results. Every row reports found, replaced, and dropped counts after a run; a bad regex in one pair never stops the others.
• Pair lists travel. Import and export as CSV or TSV; save named presets, mode included. Apply to one document or every open document.

Find All results

• Group and sort. Group matches by regex capture value or by CSV column; sort by match text. Grouping caps at 100,000 matches and says so.
• Filter to Matches routes the search query into the filter bar in one click; Export writes grep-style numbered lines to a new document.
• Saved searches. Named presets with the full option set and replacement text, plus JSON import and export for moving them between Macs.

Find in Files

• Filename patterns (*.log; *.csv), an All Open Documents scope, and a skip report: files over the 50 MB scan cap, binary files, and unreadable files are listed, never silently omitted.
• UTF-16 files are searched now (they previously matched nothing), and a very long single line no longer produces wrong line numbers; literal matches on such lines are exact at any length.
• Replace across files, carefully: a preview with per-file counts before anything is touched, .bak backups on by default, atomic writes, and a report covering every file skipped and why. Documents open in Caxton are left to Batch Replace.

Fixed

• The grid never shows shifted data after a bulk edit. A big fill, paste, or its undo could briefly paint columns misaligned while the index caught up. The index now rebuilds before the repaint; what you see during the catch-up is honest progressive loading.
• Undo after a partially-applied bulk edit is exact. Internal replacements that overlap now drop cleanly and never leave a wrong undo record.

Fixed

• Panels open where you are. The advanced filter, Fill Series, and friends now appear centered over your document window instead of wherever the screen felt like, and a panel you reposition stays where you put it.
• The unsaved-changes dot is instant. Editing a cell in the grid marks the window and tab modified immediately, not after switching modes.
• The CSV menu opens instantly. With a cell selected in a dense file, menu validation was scanning up to 200,000 rows to decide whether Fill Down should be enabled. It now checks exactly one.

Added

• Does Not Contain in the Advanced Filter’s match menu, and with the any column scope it means what you’d hope: no field contains the text.

Columns & navigation

• Hide and freeze columns. CSV ▸ Hide Column tucks columns out of view (data and operations still include them, Excel semantics); Freeze Columns pins the first one to three (or up to the selected column) during horizontal scroll. Auto-Fit All Columns sizes everything to content.
• Go to Cell. Cmd+L in the grid accepts 5000 or 5000:12 and lands on the exact cell, header-aware, honest when a row filter hides the target.
• Selection statistics. Select a block of cells and the status bar shows count, sum, average, numeric and blank tallies, computed off the main thread, capped honestly on giant selections.
• Header tools. Promote any row to the header, Rename Column… edits a header name in place, and Add Header Row generates Column1…ColumnN placeholders above headerless data, each one undoable.

Sorting & filtering

• Typed sorts. Sort Rows now understands six interpretations: Text, Text (case-sensitive bytes), Natural (Finder-style, “file2” before “file10”), Numeric, Currency (symbols and thousands separators stripped, accounting parentheses read as negative), and Date. Currency columns are detected automatically for header-click sorts.
• Sort presets. Save a sort configuration under a name and re-apply it from the dialog’s Preset menu.
• Filter by Column Values. The Excel-style value browser: every distinct value in a column with its count, searchable, with checkboxes, check what you want to see and apply.
• Right-click quick filters. Filter to a cell’s value, exclude it, or filter greater/less than a numeric value, one click from any cell.
• Greater Than / Less Than conditions. The advanced filter’s match menu grew numeric comparisons alongside Contains and Equals.
• Filters play fair. The text filter bar and CSV row filters used to silently overwrite each other’s view; now the last one applied wins, a banner says what happened, and clearing one hands the view back to the other.

Cell editing & CSV fidelity

• Full-value cell editor. Multiline and long values open in a real editor sheet instead of a read-only popover, edit the decoded value with quoting handled for you, or flip to Raw to see and edit the stored bytes exactly as they are in the file. Cmd+Return saves, Esc cancels.
• Ragged rows, visible and fixable. Cells a short row doesn’t actually have are drawn dimmed; editing one materializes it, padding the row out to that column.
• Fidelity verbs. Quote All Cells, Remove Unnecessary Quotes, and Normalize Column Count… (pads short rows; optionally trims surplus cells), each a single undoable rewrite that never touches rows with quoting problems. Plus Convert Fixed-Width to Columns…: split a fixed-width text file into a delimited document at the character widths you give, with a live preview, at any file size.
• CR-only CSV files open in the grid. Classic-Mac line endings no longer stop CSV detection.
• Column settings follow their columns. Widths, hidden flags, and sort choices now travel with a column through moves, inserts, deletes, splits, and combines instead of sticking to positions.

Caxton remains signed and notarized by Apple, with Hardened Runtime enabled; updates install automatically.

Table Mode

• One Advanced Filter, everywhere. The filter bar’s expand button and the menus now open a single advanced filter that matches your mode: in the text view, multi-condition line filtering as before; in the grid, row filtering where each condition targets the whole line, any column, or one specific column, with Contains/Equals, match case, ≠ exclude, and and/or chaining (AND binds tighter than OR). Whole-line conditions test the raw record, a query containing a comma can match across fields, which per-column filtering can’t. The panel keeps your conditions between opens so a filter can be tweaked and re-run.
• Numbered columns without a header row. With First Row Is Header off, the grid now shows a frozen numbered band (1, 2, 3…, EmEditor-style): click it to select a column, drag to select several, resize and sort on it exactly like a real header. Dialogs use the same numbers, so “column 3” means the same thing everywhere.
• Whole-column selection enables column operations. Clicking a column header no longer greys out the CSV menu: Insert/Delete/Move/Split/Combine Column, Extract Column, and Count Frequent all work from a column selection, and the sort and filter dialogs preselect that column. Row operations still ask for a cell, a column has no anchor row.

Editor feel

• The caret blinks. Standard cadence, solid the instant you type or move, steady when a pane isn’t focused, and much easier to find in a wall of text.
• Option+Shift+Click places cursors on every line between. Click one spot, Option+Shift+Click another: the column selection sweeps the whole span, the click version of the Option+Drag you already have.
• Line numbers are readable in Dark. Near-white, matching the status bar, no more squinting at slate-on-slate.
• Tabs show the whole filename. No more mid-name cutoff; tabs only compress when the strip truly runs out of room.
• Documents open filling the screen (the regular kind of full, menu bar and Dock stay). The welcome window keeps its compact size.

Word wrap

• Soft wrap is here. View ▸ Word Wrap (⌥⌘W) wraps at the window edge or a fixed column (80/100/120, with a guide line), with ↪ continuation markers in the gutter, visual indent on wrapped rows, and full syntax color, selection, marker, and input-method overlays under wrap.
• Built for big files. Wrap stays responsive on multi-gigabyte documents; a pathologically long line (hundreds of KB without a break) opts out with an ↔ marker instead of stalling the window.
• Arrows, Home/End, clicks, and the caret think in visual rows when wrap is on, including under filters and in split view, where each pane wraps to its own width.
• Large grid fills got faster along the way , building wrap surfaced a shipped double-refresh in the CSV grid, now removed.

Selection & navigation

• Expand / Contract Selection (⌃⇧⌘→ / ⌃⇧⌘←) grows the selection structurally, word, dotted token, quoted string, brackets, line, paragraph, and steps back exactly.
• Word-wise everything: ⌥←/→ moves by word, ⌥-deletes remove a word at a time, and ⌘-deletes clear to the ends of the visual row, all multi-cursor aware.
• Empty files show their caret. A 0-byte document now has a line 1 like every other file.

Lines & paragraphs

• Text ▸ Lines: duplicate (⇧⌘D), delete (⇧⌘K), copy, move up/down (⌥⌘↑↓), join (⌃J), split at a delimiter, shuffle, remove empty, keep only duplicates, indent/outdent (⌘] / ⌘[), number lines, add prefix/suffix. Duplicates and moves are byte-exact, even on lines containing invalid UTF-8.
• Text ▸ Paragraphs: hard wrap to a column, reflow paragraphs, unwrap paragraphs, quote and comment prefixes are kept on every wrapped line, and a list dash isn’t multiplied into new bullets.

Case, whitespace & numbers

• Case: Sentence case, Toggle case, and identifier conversions, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, space case.
• Whitespace: trims, collapse repeated spaces, convert non-breaking spaces, tabs ↔ spaces, normalize indentation, detect mixed indentation, plus a configurable tab width (2/3/4/8) the editor actually renders with.
• Show Invisibles (View menu): faint marks for spaces, tabs, and line ends, with non-breaking and zero-width characters highlighted, the classic invisible-diff culprits from PDFs and web copy-paste.
• Numbers: increment/decrement every number in a selection, arithmetic on all of them, zero-padding, base conversion (2/8/10/16), and a sum / count / average readout. Padded columns keep their shape, 007 + 1 is 008.

Escapes, hashes & dates

• Escapes: HTML entities, XML, JSON strings (full surrogate handling, malformed input is refused, never mangled), hex, \uXXXX Unicode escapes, ROT13, and Unicode normalization (NFC/NFD/NFKC/NFKD).
• Hash a selection: SHA-256, SHA-512, SHA-1, MD5, shown in a panel with a Copy button, never replacing your text.
• Insert Date/Time: six stable formats (ISO 8601 local and UTC, epoch seconds, and friends) that never depend on the display locale, inserted at every cursor.

Statistics & fixes

• Text ▸ Statistics: bytes, characters, Unicode scalars, words, lines, paragraphs, sentences, blank and unique lines, longest and average line, reading time, and an indentation report, for the document or the selection.
• Word Count now counts CRLF files correctly. Windows-style documents reported one line no matter their size.
• A bulk edit that grows the file no longer truncates line tracking. A growing Replace All or a large multi-cursor edit could leave line numbers and navigation stuck at the old file size until the next save.
• Text transforms refused during a save say so , instead of reporting “applied” for an edit that never landed.

Saving & recovery

• Quit waits for an in-flight save. “Quit Anyway” answers the unsaved-changes question , it no longer aborts a save that’s still streaming to disk.
• Anything refused during a save says so. Sorts, delimiter conversions, row and line deletes, cell edits, and multi-cursor typing that land while a save is writing now show “unavailable while saving” instead of reporting success that didn’t happen.
• Crash-recovery data is safer. It moved out of the purgeable system cache into Application Support, survives a failed restore instead of being deleted with it, and is kept when a file’s volume is simply unplugged.
• Cell edits during a long save queue up: tabbing across several cells no longer keeps only the last one.

Fresh data, honest dialogs

• Sort, dedupe, row filters, and bookmark/pattern line deletes re-check the file after their dialogs. If the document changed underneath (a growing log, an external reload), the operation asks you to run it again instead of applying stale coordinates.
• The CSV grid stops painting stale rows while it rebuilds after bulk operations, and if a reloaded file no longer parses as CSV, Caxton returns to the text view honestly instead of keeping the old grid on screen.
• Structure problems now block single-cell edits too , the same rule every bulk operation already followed.

Search & filter

• Wrap Around now means it: with the toggle off, Next stops at the last match instead of looping.
• A reopened find bar searches again. Closing the bar with ✕ and reopening left Return doing nothing.
• Regex (?i) patterns find everything under Match Case, a fast-path filter was silently dropping matches.
• Searches started during indexing finish the job , they re-run automatically when indexing completes, same as filters since 1.0.6.
• Replace with $1 captures never inserts the literal template: a site that can’t be re-verified is skipped, with an honest count.
• Entire-file filter scans report failures instead of presenting an empty result as “no matches,” cancelling one from the Jobs panel no longer freezes the filter bar, and closing a window stops its background scan.

Editing & menus

• Edit ▸ Delete and File ▸ Revert to Saved work now. (Revert deliberately has no shortcut; ⌘R belongs to CSV Fill Right.)
• Menus enable truthfully: no more clickable Undo with nothing to undo, or Paste on a read-only file.
• Home, End, ⌘↑ and ⌘↓ clear extra cursors like the arrow keys always did.
• Filtered-out lines can’t be edited blind , a cursor stranded inside hidden lines refuses to type into content you can’t see.
• Chinese and Japanese input compose correctly , the candidate highlight landed on the wrong characters for all non-ASCII composition.
• Markers on very long lines no longer tank the frame rate, and the diagnostics overlay is off by default (View ▸ Diagnostics Overlay brings it back).

Files

• Empty files open. A freshly-created 0-byte file no longer shows “Could not open, file is empty.”
• Format XML preserves your data: > inside attribute values, comments, and CDATA no longer splits the document.
• External truncation mid-operation can’t spin or crash: indexing stops cleanly and sorting tolerates the shorter file.

Crash recovery

• Recovered edits survive every path. Choosing Restore used to delete the recovery data immediately, if the open was then cancelled, failed, or landed read-only, the edits were gone for good. Recovery data now survives until your restored work is safely re-protected, cancelling says “Recovery postponed,” and relaunching by double-clicking the crashed file in Finder no longer skips the restore.

Files changed outside Caxton

• Safe-saves from other apps are recognized as changes, not deletions. Most editors (and tools like rsync) save by writing a new file over the old one, Caxton misread that as “file was deleted” and stopped watching. It now reloads (or asks, if you have unsaved edits) and keeps watching the new file.
• “Keep Mine” now really means it. After keeping your version over an external change, Save used to fail forever with “the file changed on disk.” Keeping your version now authorizes exactly that overwrite, the next Save writes your version, once.
• Moved or renamed files are reported honestly , a clear banner instead of silence, with your content intact and Save re-creating the file at its original path.

Editing

• Very large edits warn before becoming non-undoable. Deleting or typing over a selection past the undo memory cap now asks first, same as large pastes always have, instead of silently losing undo (and briefly doubling memory) after the fact.
• Sorting or deduplicating very large CSVs streams to a new document instead of holding the whole reordered file in memory, same policy the other big-file transforms already follow, original untouched.
• Filters started while a file is still indexing now finish the job: the filter re-runs automatically when indexing completes, so matches always cover the whole file.
• Line-index exactness in two corners: typing at the very end of a file after a final newline now registers the new last line, and edits made while a huge file is still being indexed can no longer skew the line offsets that indexing produces.

CSV grid

• Excel/Windows CSV exports with a quoted last column could open in a degraded state: every row flagged malformed, CSV editing disabled. The parser now reads the CRLF line ending correctly after a closing quote.
• Fill and copy no longer use the display version of a cell. Values over 1,000 characters or containing embedded newlines were written back truncated (with a trailing …) or with ↵ standing in for the newline. Both now read the exact stored value.
• Grid stability: cell edits committed while a save or a background parse was still running could knock the grid’s row map out of sync (the same family as 1.0.3’s undo fix); they now apply the moment it’s safe. Undo during a save says so instead of guessing. Keyboard focus can no longer land on the hidden raw-text view after a dialog or app switch. Fixed a crash when find navigation landed on a field beyond the displayed columns of a ragged row.
• ⇧⌘C now toggles Grid View, as the docs always said, a leftover Show Colors menu item was swallowing the shortcut.

Find & Replace

• Replace All always acts on the current query. Clicked in the moment between typing a new query and its search finishing, it could operate on the previous query’s results. It now searches first and replaces exactly what you asked for.
• Results reset when the file reloads. After an external change or log rotation, old results could linger with outdated positions, and Replace could edit the wrong bytes. Results now clear and the search re-runs automatically.
• Byte-exact matches on lines with invalid UTF-8. Matches after an invalid byte reported skewed positions; replacing at those positions could corrupt surrounding bytes.

Non-UTF-8 files

• A disk read error is no longer mistaken for the end of the file. Opening could silently show a truncated document; saving could write a truncated copy over the original. Both now stop with an error instead.
• Mis-detected files are no longer unopenable. Encoding detection samples the first 256 KB; a wrong guess used to dead-end with an error. Caxton now offers to open the file as Windows-1252 so you can switch encodings once it’s open.
• Follow tail is disabled for converted (non-UTF-8) documents instead of appending garbled bytes to the view.

New

• Caxton ▸ Automatically Check for Updates , a menu toggle for Sparkle’s automatic update checks, as described in the privacy policy.

Fixed

• Save could skip the changes made by a bulk operation. When everything unsaved came from bulk edits, Replace All, CSV grid operations, multi-cursor typing, the quick in-place save could report success without actually writing those changes to the file. Bulk edits now save byte-for-byte, verified against the file on disk before and after writing. (Same-length Replace All also now gets the fast save path it was always meant to have.)
• Large UTF-16 files could turn to garbage partway through. If an emoji or other 4-byte character sat exactly astride an internal 4 MB read boundary, every character after it decoded wrong. The converter now keeps UTF-16 code units aligned across boundaries, and an incomplete character at the very end of a file shows as a replacement character instead of silently disappearing.

Fill, done right

• Fill Series dialog (right-click ▸ Fill Series…), linear and growth series, dates and times (days, weekdays, weeks, months, quarters, years, hours, minutes, seconds), text-plus-number patterns like Item01, weekday and month name lists, or repeat the selection as-is. Terminate by selection, count, or stop value; optionally fill only empty cells. A live preview shows exactly what will be written before you commit.
• The fill handle now drags in all four directions, with a live summary of what it will do (“Fill 1,234 cells · Linear series, step 5”). Hold ⌥ to copy instead of extending a series, and use the options chip afterwards to switch between Auto, Copy, and Repeat.
• Fill Down ⌘D, Fill Up, Fill Right ⌘R, Fill Left in the CSV menu and the right-click menu, straight copies of the selection edge, Excel-style.
• Smarter, safer AutoFill. Dates continue by their real calendar rules (Jan 31 → Feb 28 → Mar 31; Feb 29 returns in the next leap year), Item007 counts up without losing its padding, 1.50, 2.00 keeps two decimals, and decimal math is exact, never 0.30000000000000004. A single number copies instead of incrementing, and irregular values repeat as a pattern instead of inventing a trend.
• Very large fills report how many cells they will replace before running; every fill is one undo step.

Fixed

• Undo in the grid could show data shifted into the wrong columns after a find-bar replace or a quick series of edits. The file’s bytes were never corrupted, the grid’s map of row boundaries could go stale and freeze that way. The grid now re-checks its map before every undo, redo, and cell commit.

Fixed

• Automatic updates now install correctly. Earlier builds could detect an update but failed at the last step with “An error occurred while launching the installer.” Caxton now updates itself cleanly through Caxton ▸ Check for Updates….
• Crash recovery works for files anywhere on your Mac, including network drives and external volumes, not just files inside the app’s former sandbox container.

Caxton remains signed and notarized by Apple, with Hardened Runtime enabled. If you are still on 1.0.0 or 1.0.1, this is a one-time manual update: download the current version and drag it over the copy in your Applications folder. Future updates install automatically.

Fixed

• Saving to a network drive no longer fails with a false “not enough disk space.” The pre-save space check misread free space on SMB/NFS/AFP shares; it now proceeds and reports a real error only if the volume is genuinely full.
• The CSV grid refreshes after Replace All (and other bulk edits) instead of showing stale cells until you switched views.
• Large delete-lines operations now tell you honestly whether they can be undone on your Mac, matching Replace All.

CSV grid, spreadsheet editing

• Select ranges: drag across cells, or Shift-click to extend a selection of cells, rows, or columns.
• Resize columns by dragging the header border; double-click the border to auto-fit to content.
• Fill: drag the fill handle to copy a value or extend a number series; double-click it to fill down; right-click for Fill Down / Fill Series.
• Paste blocks from Excel or Sheets straight into the grid (no need to open a cell first); paste a single value to fill a selection.
• Delete: a selected row or column is removed; selected cells are cleared. All one undo step.
• Rename a column by double-clicking its header, and reorder rows or columns by dragging them.

Desktop app

• Closing the last window now returns to the launcher instead of forcing a blank new document.
• Wider default window, sized to your screen.
• The About panel shows version and build details.
• Now runs on macOS 13 (Ventura) and later, on both Apple Silicon and Intel.
• Shift-clicking a line number in the text editor extends the selection to every line in between.

• Find, filter, and Replace All at multi-gigabyte scale.
• CSV workbench: sort, dedupe, frequency, column operations.
• Live tail with follow, bookmarks, color markers, multi-cursor, split view.
• Crash recovery and power-loss-durable saves.
• 7-day trial; licensed via caxton.app.