Chaty: download ældre versioner

## Watch it work

Code mode now shows what the agent is doing as it does it. The tool calls
between two things the model says fold into one line — what is going on now,
tool by tool, then what the run did ("Read 3 files, ran 2 commands, 1
failed") — and opening it shows every step as before. After each small step
the model says what it did and what comes next：a thinking model wrote that
inside its thought whatever it was asked, so it now rides in the tool call
itself, and Qwen3.6 35B, which made 8 or 9 calls without a word on a
find-the-bug task, now never goes more than two calls without one.

## Five permission modes, and a plan before the work

Auto, Manual, Accept edits, Plan and Bypass permissions, as Claude Code has
them, kept by each session and Auto for a new one. Auto goes ahead with
routine work and asks before what is hard to take back. Plan researches and
hands you the plan, with the choice under it to carry it out — a change
attempted while planning is stopped as its name is written, not after a whole
file has been generated. A message sent mid-run asks whether to queue or
interrupt, and folders granted outside the workspace are named to the model.

Also：browser tabs per Code session and a console-like `browser_eval`; a long
chat opens in half the time; a file read a third time unchanged, an empty
file, and a Gemma 4 thought going round on digits no longer cost minutes.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run |

### macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.3.6...v2.3.7

## Long Code sessions keep their pace

An MLX model was given its whole trained context, whatever the
machine. Qwen3.6 35B-A3B on a 48 GB Mac got 262k tokens, and past
100k a Code session's cache outgrew the GPU's memory：decoding fell
from 26 to 3 tok/s and stayed there. The engine now measures what
the loaded model's cache costs per token and holds the context to
what memory can carry — 90k for that 35B, which ran at 24 to 29
tok/s up to the session's compaction. A long prompt is read in
chunks that fit, a step left with its tool call open no longer
makes the next one re-read the whole conversation (302 s at 86k
tokens), and a forward pass that breaks stops the reply instead of
writing noise.

## Each conversation keeps its numbers

The context ring stays with its chat conversation or Code session —
after a switch, after a restart, and through a model change until
the next reply counts again — and chat's ring is now Code mode's,
the counts on hover. Deleting a conversation clears its numbers for
good, and chat shows how far a long prompt has been read, thinking
on or off.

## Every source, in its own script

A web search is no longer held to six sources：every result on topic
goes in while it fits, folded into one line under the answer and
kept with it. Pages and files are read in their own character set —
GBK sites, Notepad's UTF-16, Big5 and Shift_JIS — instead of rows of
replacement characters.

Also：a model's README in the store reads as it does on Hugging
Face, and the store keeps its lists when Hugging Face cannot list
models; YuE2's instrumentals keep the voice out; a mouse wheel
glides on a Mac; a Code session exports as a full JSONL trace, and
Code's answers come set cleanly and without emoji.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run |

### macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.3.5...v2.3.6

## Songs, made on your own machine

Load a text-to-music model — YuE2, ACE-Step 1.5, MiniMax Music 3,
HeartMuLa, Stable Audio 3, MiDashengLM-Gen — and the whole app
becomes a music studio：your style and lyrics as a bubble, the piece
as a waveform to play and seek, and each family's own edits of an
earlier round — rearrange or continue a song, repaint a stretch,
cover it in a new style. It runs on audio.cpp in a helper of its own
— Metal on a Mac, Vulkan on Windows and Linux. On an M4 Pro, YuE2
writes and sings a 30-second verse and chorus in 33 s, and Stable
Audio 3 Small makes 20 s in 1.2 s.

## A lighter frame

No title bar across the window：the window's controls and a mode
switch of icons sit over the sidebar, the working area runs to the
window's edges, and the transcript passes under the top row instead
of stopping at a bar. Chaty draws its own scrollbars everywhere, and
Code's thinking and bypass switches sit under its input.

## Live mode, interrupted

Cut a spoken reply short and it is your turn at once — the model
remembers what it said up to there, not the rest. The light no
longer ends at a line across the screen, and the window moves from
its top edge even with Live mode or a dialog open.

Also：K2 Horizon's MLX quants load, Code's sessions can be searched,
and several sessions at once can be deleted in Code and the image
studio.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run |

### macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

## What's Changed
• music：text-to-music GGUF support, and a music mode for the whole app by @Fangyuan025 in https://github.com/Fangyuan025/Chaty/pull/22

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.3.0...v2.3.5

## Pictures, drawn on your own GPU

Load a text-to-image model — Z-Image Turbo, Qwen-Image 2.1, FLUX.1,
Chroma, Stable Diffusion — and the whole app becomes an image studio:
sessions that read like conversations, a live preview while it draws,
each model's recommended settings filled in, and editing that starts
the next round from any picture. A GGUF is only the denoiser; Chaty
finds its VAE and text encoder, or downloads the missing ones in one
click. It runs on stable-diffusion.cpp in a helper of its own — Metal
on a Mac, Vulkan on Windows and Linux. On an M4 Pro, Z-Image Turbo
draws 1024 × 1024 in under three minutes.

## Each model in its own dialect

K2 Horizon loads on both engines, MoVA-36B included, with its own
reasoning tags and effort ladder. GLM-4.5/4.6/4.7 and MiniCPM5 tool
calls are read and written in their own formats — GLM's had been no
call at all. A GGUF whose own chat template says more than
llama.cpp's built-in guess is rendered from the template, as
transformers would (MiniCPM5 answered in fragments without it), and
a refused model says why in llama.cpp's own words.

## Edits that land

An edit is checked against the file while the model is still writing
it, and stopped the moment it cannot land. A retyped line with the
wrong spaces, escapes or line numbers lands where exactly one place
fits; calls written in every shape small models actually use are
read; and a long diff now opens in full.

## A quieter, more finished look

The window is redesigned：one frame, a floating composer, the app's
own menus throughout, and the accent kept for what matters. Settings
are regrouped, and a line above the composer shows what the next
message will use. All of Settings → Sampling but temperature now
applies to Code as well.

Also：MLX models stop cleanly (the repetition penalty had been
counting the prompt's own markup), and a round of fixes to races,
recovery paths and a window that froze on slow commands.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run |

### macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

## What's Changed
• image：text-to-image GGUF support, and an image mode for the whole app by @Fangyuan025 in https://github.com/Fangyuan025/Chaty/pull/21

## New Contributors
• @Fangyuan025 made their first contribution in https://github.com/Fangyuan025/Chaty/pull/21

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.2.2...v2.3.0

## Commands that ask for input

A command that stops to ask — a `[y/N]`, a password prompt, `rm -i`, a
Python `input()` — used to fail at once in code mode. It now moves to
the background the way a dev server does, and the model answers it
with the new `bg_input` tool, typing a line or pressing keys. REPLs,
editors and project scaffolders run in a terminal of their own
(ConPTY on Windows), and arrow-key menus are driven with arrow keys.
Commands also run in bash now, as the tool's name always said.

## Edits you can watch

A write or edit shows its card while the model is still writing it:
the block being replaced is found and lit, rewritten in place, and the
view moves on to the next, the way Canvas applies a patch. A call that
is stopped takes its card with it.

## Files by the handful, in the shell you use

Reading five files used to be five round trips; `multi_read` takes a
list and brings them back together, naming any it could not read
without losing the ones it could. And on Windows, where the shell is
`cmd` but models write bash, Settings → Code now lists the shells you
actually have — Git Bash, PowerShell — and runs commands in the one
you pick.

## The agent remembers your sessions

A session's record outlives what the model can hold in front of it,
so asked what was decided earlier, the agent used to go looking in
the code. It can now search its own record — this session past what
compaction dropped, or every session — and typing `@` in the
composer offers your other sessions alongside the workspace's
files, so you can point it at one and ask about it.

## Long chats with search stay fast

With web search or the knowledge base on, every chat turn read the
whole conversation again. Search results now stay with the question
they answered and side generations keep their own cache：0% of the
conversation reused per turn became 96–99%.

## Also

A code session opens at its end with a button back down to it, a new
session no longer inherits the last one's pause, servers left running
when Chaty was killed are stopped, skill files can be imported in
Settings, and a click outside an approval dialog no longer denies it.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run. First Linux release — please report anything odd |

### ⚠️ macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.2.1...v2.2.2

## Tool calls in the model's own format

Chaty asked every model for its tool calls as one line of JSON, which
is not how most local models were trained：Qwen 3.5, 3.6 and 3.8 write
an XML form, and Gemma 4 and LFM2 their own. Long edits came back as
broken JSON and were rejected and rewritten, round after round. Chaty
now reads the format from the loaded model's chat template and uses it
everywhere the model looks — the prompt, the tool list, every hint and
correction, and the calls kept in its history. A model whose template
names none gets XML, and Settings → Code can choose one by hand.

## Fewer wasted rounds in code mode

A broken call is told where it broke, and four in a row pause the
turn. A long edit retyped with different indentation still lands, and
browser_read with a selector reads just the elements it matches.

## Pictures on GGUF

The first picture in a conversation that had been talking — or a code
turn's first screenshot — no longer makes a Qwen3.5 GGUF model read the
whole conversation again before it looks at the image.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run. First Linux release — please report anything odd |

### ⚠️ macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.2.0...v2.2.1

## Voice, web search and citations

Voice models now download through the HF endpoint in Settings, so a
mirror such as hf-mirror.com reaches them too, and a download that still
fails says which folder the files belong in and where to get them; the
folder opens from Settings → Voice. A first download shows its
progress, and speech recognition writes Chinese in Simplified
characters. Web search and thinking can be on
together. Search results that are about something else are dropped
instead of cited, every source the model was given shows under the
answer, a citation past them is no longer printed, and hovering a source
near the edge no longer makes the conversation jitter on Windows.

## The knowledge base answers the question asked

A short question asked of the knowledge base was read as part of the
passages found for it, so the model summarised them or answered the
previous question instead; it is now set apart. Scanned PDFs are read
page by page by the loaded vision model, and without one the message
says which model it needs.

## Code mode

A turn that walked through its page in the browser is no longer told
to run the code before delivering; the check still stops code that
never ran, a failed build, and edits made after the walk. The browser's
console starts over when the page reloads, so the agent stops reading
back errors the page no longer throws. An opened step card shows
exactly what the model was given, all of it, and read_file reaches the
end of a file past 400 KB. A binary file in a tool's output no longer
breaks the session it lands in.

## Chat, settings and the installer

Right-click copies the message under the pointer, a picture in a
message opens full size, and a reply stopped mid-thought no longer
keeps saying it is thinking. Settings shows the models folder its
button opens, the Windows tray icon fills its slot, a command awaiting
approval is shown once, and the Windows installer speaks Chinese on a
Chinese Windows — upgrades included.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run. First Linux release — please report anything odd |

### ⚠️ macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.1.9...v2.2.0

## A session of its own

In Code mode, background tasks now belong to the session that started
them. Each session sees only its own — the tasks panel and the agent alike
— while another session's dev server keeps running in its own workspace,
and what each task ran, how it ended and what it printed stays with the
session across restarts until it is cleared. A session also belongs to its
workspace：opening one moves to its folder, and the session list can be
grouped by workspace.

## Background tasks you can see into

The background pill now opens a panel of running and finished tasks —
status, running time, the full command and its output, live — where they
can be stopped one by one and cleared.

## What a turn changed

A turn that edits files now ends with a card of every file it changed,
each with its net +/−, its diff one click away, and an undo for that file
or for all of them — folded to its totals when there are more than five.

## A window that opens the right size

Chaty opens scaled to the screen and centred instead of at a fixed
1040×720, and on macOS closing from fullscreen now leaves fullscreen
smoothly and goes to the tray every time.

## Voice, web search and citations

Voice models now download through the HF endpoint in Settings, so a
mirror such as hf-mirror.com reaches them too, and a download that still
fails says which folder the files belong in and where to get them; the
folder opens from Settings → Voice. Web search and thinking can be on
together. Search results that are about something else are dropped
instead of cited, every source the model was given shows under the
answer, a citation past them is no longer printed, and hovering a source
near the edge no longer makes the conversation jitter on Windows.

## The knowledge base answers the question asked

A short question asked of the knowledge base was read as part of the
passages found for it, so the model summarised them or answered the
previous question instead; it is now set apart. Scanned PDFs are read
page by page by the loaded vision model, and without one the message
says which model it needs.

Several things reached v2.1.8 as a rebuild after it went out and are in
here for anyone who installed it on release day：the macOS menu-bar icon
is a glyph that matches the bar, and long coding sessions no longer
re-read the whole conversation — after the first turn, after forty steps
on MLX, after the agent remembers something, or at every turn past 40% of
the window.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run. First Linux release — please report anything odd |

### ⚠️ macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.1.8...v2.1.9

## A book that closed the app now imports

A 348-page book in Chinese closed the app every time it was
imported, and left nothing in the log. The note the previous
release taught indexing to leave named the moment — the first batch
of pieces — and the cause was a size：the embedding model reads each
piece in one pass, llama.cpp cannot split it, and the pass held 512
tokens while pieces were cut at 1020. English runs near 200 tokens a
piece and never came close; Chinese runs near 650, and past the line
llama.cpp does not return an error, it ends the process. The pass now
holds a whole piece, and the whole book indexes.

On the way there, the embedder also stopped asking a shared graphics
card for every layer it has, and on a Mac it now runs on the GPU:
377 pieces in 36 s instead of 164, with the same vectors to within a
cosine of 0.997 and no memory left behind when it unloads.

## The agent can press a key

The browser tools could click and fill a field, and there was no way
to press a key — no Enter to submit, no Escape to dismiss, no Tab,
no arrows, no shortcuts. Typing into a field sends no keystroke at
all. `browser_key` sends real ones, optionally focusing a field
first.

Several things reached v2.1.7 as a rebuild after it went out and are
in here for anyone who installed it on release day：an import that
closes the app now leaves a note naming the file and the step it
stopped in (it is how the crash above was found), a document that
never finished indexing is no longer listed as though it had, a
scanned PDF is read from its pictures, describing a document's
figures can be switched off, and models can live on a drive other
than the system one.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run. First Linux release — please report anything odd |

### ⚠️ macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.1.7...v2.1.8

## A long run that stops starting over

A prompt is resumed from the engine's cache up to the first token
that differs from last time. On the architectures the Qwen3.5
family uses that is all-or-nothing：three quarters of their layers
keep a recurrent state that cannot be rewound to a midpoint, so
anything the cache cannot account for throws all of it away and the
conversation is read from the beginning. Six things in code mode
were doing exactly that.

The clock sat in the system prompt, to the minute, so a turn that
began in a new minute matched about twenty tokens and re-read the
rest. The answer that ended a turn was never written down, so every
continuation started cold — and the model could not see what it had
last told you. Tool results arrived as if you had typed them, which
a Qwen3.5 template counts as a new request：the model would
announce that you had sent one halfway through the work it was
already doing, and repeat your request back at you. The closing tag
of a tool call went missing, and one round threw away 5006 cached
tokens over the four it could not account for. Two paths recorded a
turn their own way. And a repeated call — usually progress,
re-running the tests after an edit — turned reasoning off for one
step, which re-renders the whole history, and then back again.

After：a median of 99% of each prompt resumed from cache on both
engines, across turn boundaries as well as within a turn. A first
turn still costs a full read, so does a conversation crossing the
point where its history must be compacted, and so does the first
turn after the app restarts — the cache lives in memory and does
not outlive the process. The turn after that resumes 99% again.

## Speculative decoding, on models that bring their own head

Some checkpoints carry a small block trained to guess the tokens
the model is about to produce. The model then checks a whole run of
guesses in one pass instead of one pass per token, and every token
that survives is one its own sampler drew — the reply is the reply
it would have given either way. Both engines can drive it now.

It ships off, and marked experimental. Measured, it is a large win
on text whose continuation is obvious and roughly a wash on
ordinary prose, and nothing readable before a reply starts says
which one it will be; a default that is sometimes slower is not a
default. The switch is in Settings → Model, offered only on models
that actually carry a head — read from the file, not assumed.

Three things that reached v2.1.6 as a rebuild are in here for
anyone who installed that version on release day：a chat reply now
survives the interface reloading under it, the composer stops
losing a line to a scrollbar at 110% and 120% UI scale, and the
error log can be emptied from Settings.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run. First Linux release — please report anything odd |

### ⚠️ macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.1.6...v2.1.7

## Chinese speech, and a picture that stops costing the conversation

Chaty listens and answers in Chinese. Speech recognition was
English-only and text-to-speech had no Chinese voice at all, so the
whole voice section was hidden outside the English UI. Recognition
now runs multilingual Whisper when Chinese is in play, and a Chinese
reply is spoken by a local VITS voice while English keeps Kokoro,
decided per utterance. English speech did not get worse to make room
for it：multilingual Whisper is a real accuracy drop on English, so
English stays on `base.en` — the model already on disk, no
re-download and nothing orphaned — and the multilingual model is
fetched only when the UI is Chinese or the Chinese-voice switch is
on. Its files are pinned to a revision rather than to a moving
branch, so a size check can no longer pass on bytes that changed
underneath it. (#8, by @wisetwo)

Around that：a voice model left half-downloaded now repairs itself
one file at a time instead of being fetched again from the start,
files land in a staging directory and are moved into place
atomically, the preview plays — WKWebView applies Safari's
user-activation rules, so the audio context is unlocked on the first
gesture rather than after the synthesis round-trip — and a preview
or transcription that fails says why. Live Mode stops racing the
microphone：the capture thread signals when it has actually released
the device and the next start waits for that, instead of guessing at
a delay.

A picture stopped throwing the conversation away. Through MLX, any
prompt carrying an image was evaluated from the very beginning — the
whole transcript, every turn, on the screenshot round and on every
round after it. Measured across seven local models in both thinking
modes：0% of the window reused from the moment a screenshot entered
a conversation until the end of it. Two causes, both fixed. The chat
template rewrites a stored turn's reasoning when pixels force it to
render the history, and re-encoding a turn's text is not the inverse
of generating it — on Qwen3.5 2B the word "Chaty" comes back as a
different pair of tokens than the model emitted, and one pair is
enough to end the match. Chaty now replays the exact tokens each
turn occupies in the cache. Same sweep afterwards：99-100% on every
round after a picture, all fourteen combinations.

A second screenshot resumes the conversation instead of re-reading
it. That round used to start over, because a call carrying pixels
was assumed to be positionable only from the beginning. It is not —
the model takes its positions from the cache — so only the new
picture is read now and the conversation beneath it is kept. The
older screenshot also stays visible instead of being dropped to save
an encode that no longer happens.

And a screenshot in a long conversation stopped taking minutes. The
span a vision model reads in one pass ran from the start of the
prompt to the last picture in it, so a screenshot's cost was set by
the transcript underneath：12.3k tokens took 187 seconds on a 35B,
and a real 50k round had produced nothing after ninety minutes with
20 GB of swap churning. The text below a picture is ordinary text
and now goes in chunks like any other; only the picture's own span
is one pass. A 48k-token conversation with a four-tile screenshot
reads in 13 seconds against a warm cache and 131 cold.

A turn that stops saying anything is now cut. Not a runaway thought
— the think budget is the only ceiling on how much a model may
reason, and that stays. This is the other failure：output carrying
no information at all. A 35B step ran to 31,416 tokens of "!" at 1.1
tokens a second, twenty minutes of it, because the only ceiling was
the token cap. Four hundred characters of one repeated character now
ends the step, the wreckage is kept out of the transcript rather
than handed back as a pattern to continue, and twice in a row pauses
instead of grinding. Separately, when the window tightens, the file
bodies inside earlier `writ

## A long conversation stops starting over

Chat mode re-wrote its own compaction summary on every single
message. A fresh wording each time, sitting in the system message —
the opening of the prompt — so everything behind it moved and the
engine could match nothing it had already computed. Measured on
Gemma-4 26B through MLX：99% of the window reused on the turns
before compaction began, and 0% on every turn after it, plus a whole
extra generation per turn to write the summary again. The summary is
kept now until the conversation outgrows the room it left, and it is
written from the previous summary rather than from a transcript that
gets more elided each time. Same measurement afterwards：99-100% on
the turns in between.

Reasoning kept in its own field counts against the window again.
Some templates read a turn's thinking from `reasoning_content`
rather than from the message body, so Chaty splits it out for them —
and the budget counted only the body, reading a whole reasoning
history as very nearly free. Qwen3.8 27B is the one local model that
splits it, and in a fourteen-model sweep it was the one model that
walked off the end of its own window：six turns in a row answered
with "context" and generated nothing, the conversation simply dead,
while the budget still reported room to spare. Same shape as
pictures counting for nothing before 2.1.2. Afterwards the same ten
turns never overflow, and each turn recovers on the next one.

Today's date and the web-search results moved out of the system
message and onto the turn that produced them. A regex on the current
question decided whether the date line was there, and the results
were new every turn — so one question containing the word "recent"
cost two full re-prefills, the turn that added the line and the turn
that dropped it again：2% and 1% reused, against 81% and 94% around
them. An answer that cited a source now keeps the source, too.

Code mode's cross-turn trim leaves room to grow. It freed exactly
enough to slip back under its ceiling, so the next turn was over
again — the same ceiling-hugging that mid-turn compaction was fixed
for in 2.1.2, on the other side of the turn boundary.

Thinking and web search can no longer both claim to be on. They are
mutually exclusive — a searching turn is sent with reasoning
suppressed — and turning search on from the command palette left a
tick beside Thinking in the Tools menu while every later turn
quietly stopped reasoning. If some of your turns seemed not to
think, this was why, and it was never the model.

A turn with no answer in it now says so. The prompt outgrew the
window and nothing was generated, or the model reasoned to the end
of its budget and stopped before writing anything：all of it used to
land as an empty bubble, or as a turn that vanished on reload.

A GPU load that was quietly cut back says so. After a driver crash
the next load takes fewer layers, and only the bottom of that ladder
was ever reported — the rungs in between just ran slower for no
stated reason.

The knowledge base answered out of six chunks, whatever size your
library was — the count was written into the search with a ceiling
of twelve above it and nothing in the app could raise it. It is a
setting now. Indexing a large file could also take the app down：a
file with no blank line in it is one paragraph, and the chunker
pulled the whole thing into memory four bytes a character first.

Code mode's deep / standard switch does something now. On any model
without a native effort ladder the rung was one bullet in a
six-thousand-character system prompt, while the off switch rode on
the last user message — which is where the model decides whether to
think, and how much. Measured across five paired tasks：deep used to
produce 0.95x the reasoning of standard on Qwen3.6 35B and was the
longer of the pair once in five; it now gives 1.52x there (5 of 5),
1.81x on Qwen3.5 9B and 3.20x on Gemma-4 E4B through the other
engine.

"Continue" after a paused turn no longer re

## The model stops re-reading what it just did

Between turns, code mode threw away everything the agent had
actually done. The follow-up arrived with the tool results gone and
"(tools run：read_file, bash)" in their place, so the model no
longer knew what any of those calls had returned and re-read files
it had just read. The exchange now carries over intact — and that is
cheaper than discarding it was：2035 of 2058 prompt tokens reused,
75ms, against a cold 208ms for the summary it replaces.

A follow-up question no longer re-reads the conversation on MLX
either. Chaty lays a conversation out one message at a time now,
from a layout learned off the model's own template and used only
when it reproduces that template's token ids exactly. Qwen3.5 2B and
Gemma-4 26B both go from 0% to 99% reuse on the second turn's first
step — 1587ms to 95ms, 4292ms to 216ms.

Thinking off no longer costs a full prefill every turn. Chaty
prefills an empty reasoning block after the assistant header, but a
stored turn was rendered without it, so round two diverged right
there — 0% reuse on Qwen3.5 and LFM2, and thinking off is code
mode's default. Now 100%, on both engines.

LFM2's tool calls run. The engine rendered control tokens as
nothing, so `<|tool_call_start|>[read_file(path='x')]<|tool_call_end|>`
reached Chaty as ordinary prose and the call never fired.

A screenshot the model has already seen is no longer re-encoded.
Three consecutive tool-result rounds on Qwen3.5 4B cost 2826ms,
5596ms and 5741ms before; they now cost about 150ms each. Dropping
stale screenshots turned out to make llama.cpp slower, not faster,
so it keeps them.

Context compaction condenses the work with a model-written summary
instead of a 60-character index per turn, and leaves room to breathe
rather than skimming the limit：the same task on an 8k window went
from 63 rounds and 633 seconds to 18 rounds and 132 seconds. Chat
and code share one token budget now, calibrated against what the
engine actually charges, and attached pictures count toward it.

A follow-up question no longer re-reads the conversation on MLX
either：Qwen3.5 2B and Gemma-4 26B both go from 0% to 99% cache
reuse on the second turn's first step (1587ms to 95ms, 4284ms to
217ms).

A screenshot the model has already seen is no longer re-encoded.
Three consecutive tool-result rounds on Qwen3.5 4B cost 2826ms,
5596ms and 5741ms before; they now cost about 150ms each, and a
fresh screenshot encodes only itself. Dropping stale screenshots
turned out to make llama.cpp slower, not faster, so it keeps them.

A chat reply now travels the way the model wrote it — stripping the
reasoning out of stored turns meant every reply re-read the whole
conversation. Attached pictures count toward the context budget.

Context compaction now condenses the work with a model-written
summary instead of a 60-character index per turn, and leaves room to
breathe rather than skimming the limit：the same task on an 8k
window went from 63 rounds and 633 seconds to 18 rounds and 132
seconds. Chat and code also share one token budget now, calibrated
against what the engine actually charges.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run. First Linux release — please report anything odd |

### ⚠️ macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
``

## An agent turn stops re-reading the conversation

In code mode, prefill used to crawl as the rounds piled up：the
prompt could no longer reproduce what the model had just generated,
so the cache died at the first assistant turn every step — and a
model whose memory cannot rewind answered that by re-reading the
whole conversation. A turn is now recorded so the next prompt is a
true append, and how to record it is probed per model on each engine
rather than assumed.

Second agent step, reused prompt tokens：Qwen3.5 0.8B 0 → 233,
Qwen3.8 27B 0 → 202, Qwen3.6 35B-A3B 0 → 233, Qwen3.5 4B (GGUF)
0 → 62. Only the genuinely new tail is computed, and the reused span
grows with the transcript instead of the cost doing so. Gemma 4, QwQ
and the Qwen3 line report identical counts before and after.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run. First Linux release — please report anything odd |

### ⚠️ macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.1.0...v2.1.1

## What the model actually wrote

The MLX engine stops altering the model's own output. Every CSS
class selector was losing its leading dot — `.card {` reached the
screen as `card {`, so a page the model had written correctly
opened with no styling — on every MLX model, not one family. The
rendered prompt no longer gains a newline the reference never had,
so the same weights answer the same prompt they would anywhere
else. Nine local models across four families now render prompts
identical to the reference implementation.

Numbers and files describe what you actually have：opening a canvas
in the browser reuses the file already there instead of leaving a
copy behind, and Settings → Data stops counting messages nobody can
open (84 of 94 on one machine) while model and database sizes are
no longer understated.

<!-- Highlights go above this line, hand-written per release —
the release page is where people who found Chaty through a
model's name land, and a bare install table tells them
nothing about why this version exists. -->

## Install

| Platform | File |
|---|---|
| **Windows x64** | `Chaty_*_x64-setup.exe` — per-user installer, no admin |
| **macOS (Apple Silicon)** | `Chaty_*_aarch64.dmg` |
| **Linux x64 (beta)** | `Chaty_*_amd64.AppImage` — `chmod +x` and run. First Linux release — please report anything odd |

### ⚠️ macOS first launch — "Apple could not verify…" / "damaged"

Chaty is **ad-hoc signed but not notarized** (no paid Apple Developer
account), so Gatekeeper flags it on first launch. The app is safe —
everything runs locally. Clear the download quarantine once, in Terminal:

```sh
xattr -dr com.apple.quarantine /Applications/Chaty.app
```

Then open Chaty normally. (Alternatively：try to open it once, then go to
**System Settings → Privacy & Security → Open Anyway**.)

---

**Full Changelog**：https://github.com/Fangyuan025/Chaty/compare/v2.0.9...v2.1.0