1.26247 — 4 September 2026

Three days after 1.26244, and a short release by the calendar — but two of these change something you do every day, and one of them changes a key you press.

If you read only one thing: a spreadsheet in gezel is now a spreadsheet on screen, with sortable columns, filters and cells you can type into, instead of a table flattened into prose.

Spreadsheets stay spreadsheets

Last release taught your crew to count your data. This one lets you look at it.

Open an .xlsx or a .csv — from a project's files, or from your document library — and you get a real grid. Columns sort. Each one has a filter with the operators you'd expect (contains, starts with, greater than, is empty) and a picker listing the values actually in that column, so you don't have to remember how a region was spelled. It scrolls a hundred thousand rows without complaining, because the rows never enter the document: the file stays where it is and the document carries a reference to it.

That last part fixes a specific old failure. A large table used to be pasted into the document as markdown, which is fine at twenty rows and hopeless at two thousand — the editor re-reads the whole document as you type, so a big table made writing sluggish and reading impossible. Anything past about a hundred rows now stays in its own file and appears as a grid.

Workbooks are editable, not just readable. Type in a cell and the change is written back into the file behind the document, and only the sheet you touched is rewritten — charts, formatting, and everything else in the workbook survive byte-for-byte. Formula cells show in italic, edit as the formula rather than the result, and everything depending on them recalculates the moment you commit. Around 460 functions are covered, XLOOKUP and LET included; a workbook too big to recalculate inside a sensible budget drops back to editing values rather than locking up. You can paste a block copied straight out of Excel or Sheets and it lands as a single undo step, and the previous version of the file is kept before each save.

CSV files are read-only for now. They open in the same grid and sort and filter the same way, but writing your edits back out to the .csv itself is still to come.

Most of this comes from the editor gezel is built on, which also brought sharper contrast in its menus and a proper right-click menu of its own.

Conversations make room for themselves

A conversation with a local model has a ceiling. Every message, every file it read, and the standing instructions it carries all sit in the same window, and when that window fills, the thread stops.

There are now two things where there used to be nothing useful. Beside the thread picker sits a small ring that fills as the thread does — click it and you get the real numbers, the model's capacity, and how full this thread is. And when the thread reaches about 70% full, gezel summarizes the older part of it by itself and carries on, leaving a marker in the conversation saying so. Open the marker and you can read exactly what was kept: the decisions made, what you asked for, what has already been tried and didn't work, and what's still outstanding. That last part is the point — a summary that loses it makes the model repeat work you already watched it abandon.

You can also run that collapse yourself, from Compact now in the ring's popover, rather than sending a throwaway message and hoping the threshold trips. If it can't — the thread is mid-turn, or there is nothing old enough to summarize — it says so in a sentence, where the button is.

The ring replaces a strip that used to run the width of the window telling you the model's capacity and gezel's policy, which were the same on the first turn and the fiftieth, and never once told you how full the thread was.

An unsent message is a thing you own

A message you are still writing is now a real object with a place to live, not scratch in a box that empties when you look away.

Drafts survive a restart. They keep their attachments. They appear in the thread picker — under Not sent yet if they aren't attached to a conversation yet, or behind a thread's own Drafts key if they are — so a brief you started yesterday is where you'd look for it rather than gone. The picker's + New still starts a conversation; the new + Draft starts only a message, because those are different intentions and running them together is what left empty threads lying around. While you type, a quiet dot in the toolbar is the whole of the save indicator: someone writing should not be told that writing is working.

Two things about the composer changed alongside it, and you will notice the first one immediately:

Enter now makes a new line. Shift+Enter sends. It used to be the other way around, which meant writing anything longer than a sentence involved dodging the key that makes a paragraph. The terminal is unchanged — a command is a line, and a line ends with Enter.
The draft can take the window. The key just left of Send grows the composer from its three-line strip to about four-fifths of the chat column, and back. Nothing else moves and nothing is lost; it's a size, not a mode, so it never has to be a decision.

Sent drafts are cleared out after 90 days by default. Unsent ones are never deleted on their own.

The Village grew streets

The Village — the map that draws your codebase as a town — used to run every street as the same strip of ground. Now each one is built to the traffic it carries: the files fronting it, the connections travelling along it, and everything leaving the folders it bounds. That comes out as eight grades, from a dirt track with grass verges up to a broad avenue with a trolley line, rails and overhead wire. The road you see is a reading of how busy that part of the codebase actually is, and at street zoom there are carts, walkers and trolleys moving along it.

Roads also meet each other now. Streets used to stop a few units short of the road they turned onto, which is the single most artificial-looking thing a map can do.

And a file's purpose now decides what kind of place it gets, before anything else. Data files are fields, furrowed and under crop. Configuration is a signal tower — a squat municipal block with a glazed control cab on the roof. Stylesheets are parks, with lawns, paths, a flowerbed and a bandstand. Everything else is a building, as before. A big data fixture is a big field rather than the largest structure in town.

Knowledge catalogs, opened up

The .gezk format that packages a body of knowledge for your crew is now an open format, specified outside gezel entirely, with a published specification, a conformance suite and a second reader written in Python. Anyone can build, host and read a catalog without this app, and a catalog is plain SQLite that any client can open. Gezel is the reference implementation rather than the only one.

The visible half is Settings → Knowledge. It used to want a URL pasted into a box. It is now the same browser the model downloader uses: catalogs as cards, progress while one installs, cancel, and downloads that resume where they stopped instead of starting over. On a shared machine a catalog can be installed once for everyone rather than once per account, the way models already were.

Smaller things

First run tells you what this is. The setup screen now carries the "What is gezel?" introduction beside it, rather than opening as a settings form and leaving the explanation somewhere you had to go looking for.
Your documents are in the sidebar, with the ones you use most listed and any of them pinnable, plus a right-click route to the folder in Explorer or Finder.
Indexing stopped looking like a job you should worry about. The background pass that reads your files used to appear in chat as a stream of engineering; it now settles into one quiet line saying what was read and when it finished.
A long conversation keeps its bearings. A header stays at the top of the transcript naming the message the current stretch of work came from, so scrolling through a long turn doesn't leave you wondering what was asked.
Craftbook steps carry only the tools they need. A craftbook — a saved recipe for a piece of work — can now say per step which sets of tools it has no business touching, which keeps a model from wandering into browser automation when it was asked to write a paragraph.
Model downloads use Hugging Face's newer chunked transfer where it's offered, which resumes more reliably on a bad connection.
A deliverable that must be a real file says so more firmly. Asked for a .pptx, a gezel is now told plainly that a markdown outline with the right name is not the thing, and to report itself blocked rather than substitute a format.
Nanbeige models are supported, and memory planning now accounts for models that run their layer stack more than once — the estimate used to come out several times too small on those.
Catalog content moved to @bendyline/gilde 0.1.54, and the editor libraries to squisq 2.11.

For developers

.gezk 0.5 is an open format, specified in a repository of its own: the spec under CC BY 4.0, JSON Schemas generated from the definitions, a conformance fixture with test vectors, and a Python reference reader. Vectors are plain BLOB tables rather than a pre-1.0 extension's private layout, archives store their entries uncompressed so builds are byte-identical, and references are publisher-qualified. There is no compatibility with the previous generation — a reader refuses it with a typed reason. @bendyline/gezk is a new published package carrying the format alone, with no dependency on gezel; the reasoning is recorded in decision 0012.
Two store lanes exist, for the Microsoft Store and the Mac App Store, alongside the direct download rather than instead of it. Neither is submitted yet. They follow one rule with wide consequences: a store build may not download or install executable code, so engine downloads, the Copilot SDK, Playwright and npm installs are all refused by a distribution profile that sits beside the security policy and cannot be argued out of its own restrictions by an inherited environment variable. Model weights and catalogs are data, which is what makes a packed-in starter model legal — a store build answers its first prompt, speaks and transcribes with nothing downloaded.
Sessions record their parent. A thread opened by a delegation, a consultation, a task entry or a handoff now stamps which session opened it, and each message stamps which session sent it, so a session tree reconstructs identically from a live timeline or from disk.
Eval runs record themselves and distill into a scene-by-scene walkthrough in the eval viewer — the first thing built on run recordings.
A screenshot-grounded UX review of the whole app was produced, driven by two new permanent Playwright specs that boot a genuinely fresh home and then build a warm world through the UI itself. Most of the interface changes above answer it.

Things to see and do after update

Open a spreadsheet. Any .xlsx in a project or in your document library will do — it will look like a spreadsheet now, and you can sort it, filter it and type in it. And if you keep long conversations with a local model, look for the small ring beside the thread picker: it tells you how much room the thread has left, and gives you the button that makes more.