v2.4.0

Looks like your system

The theme follows your system's light or dark by default and switches with it,
the native menus and dialogs follow the app's theme, and the window opens in its
colours. The text size setting now reaches Code mode too, at chat's size.

Reading as it streams

Answers fade in word by word as they are written, in chat and Code mode, and
nothing flashes on the way: a heading, rule or table being typed waits until it
says what it is. Mermaid diagrams are drawn as they are written without stalling the
reply, follow the theme, and show an error only if the finished one is wrong. Code is
coloured while it streams — an HTML page's script and style included. Prompt processing reads the same percent in the
folded line and the ring, and a run's line counts match the changes card.

Long work, in the background

Downloads, model loads, pictures and music show their progress on the Dock icon /
taskbar button, and the machine does not idle into sleep while they run. When the
coding agent stops to ask, or a long job finishes while you are elsewhere, the
Dock icon bounces once / the taskbar button flashes.

Keyboard and clipboard

Shortcuts for a new chat (⌘N / Ctrl+N), Settings (⌘,), chat and Code (⌘1 / ⌘2),
search (⌘F) and stopping a reply (Esc). Paste a screenshot or a file into the
input and it attaches — in chat, in Code mode and in the image studio.

More context on a big GPU

An automatic context window on Windows and Linux now fills the memory left after the
weights — the GPU's for the layers on it, RAM for any on the CPU — up to what the model
was trained for. It was 8192 tokens whatever the card. Hybrid and sliding-window
models (Qwen3.5/3.6, LFM, Gemma 4) are counted by the layers that keep a cache, and
get several times the context they did.

Windows and Linux

The icon fills its tile like other apps' and is sharp at every size, the taskbar's
included (#25). Fedora no longer opens to a gray window: Chaty keeps WebKitGTK away
from the COLRv1 emoji font it cannot draw, and draws emoji in colour with its own
(#30 — thanks @davidecelentano). AppImage managers can update Chaty from the update
information and .zsync it now carries. Downloads go to the models folder Settings
shows — on Windows the one beside the program when your models are there.

Engine updates

An engine update is used only by the Chaty release it was built for: a runtime pack
carries Chaty's own code around its engine, and one built for an older release would
bring that code back.

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:

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: v2.3.9...v2.4.0

v2.3.9

Engines that update without a Chaty release

Settings → Runtimes lists llama.cpp, stable-diffusion.cpp, audio.cpp and MLX
with the build each is on, and a newer one to switch to at a click — or by
itself, once you turn that on. Every day each engine's newest upstream is
built into this release's own wrappers and published only if it starts; the
list is signed, and a newer engine is checked and started once on your
machine before it is used. One that will not start is set aside and the
bundled one takes over by itself.

llama.cpp in a process of its own

GGUF models now run in chaty-llama, a helper beside the app, as the image,
music and MLX engines already did. That is what lets it be replaced, and a
crash inside llama.cpp ends that process instead of the window. Loading shows
llama.cpp's own progress.

MLX on upstream

MLX runs on upstream mlx-swift-lm and mlx-swift 0.33 instead of our fork:
upstream's own Qwen3.5 MTP support made it unnecessary. Speculative decoding
stays as fast — Qwen3.5-4B MTPLX at 69 tokens a second against 40 without it
on an M4 Pro.

Linux

Open models folder works on Fedora: the AppImage no longer carries its own
xdg-open, and the programs Chaty starts get your system's environment
instead of the image's library paths (#28). Folders and files are picked with
your desktop's own chooser through the XDG Desktop Portal — Nautilus's on
GNOME, Dolphin's on KDE — with the GTK dialog kept for a desktop with no
portal (#29). Thanks to @davidecelentano for both.

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:

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: v2.3.8...v2.3.9

Runtimes

Engine updates for Chaty, used through Settings → Runtimes. Not an app release — download Chaty from the latest release.

v2.3.8

FLUX.2 [klein]

FLUX.2 [klein] 4B and 9B, distilled and base, now load and draw. A klein GGUF
is the denoiser alone; Chaty recognises it, offers the Qwen3 encoder and the
FLUX.2 VAE it needs in the same download, and draws at the settings it was
made for — four steps at CFG 1 for the distilled ones. klein 4B draws
1024×1024 in about a minute on an M4 Pro.

LFM3

llama.cpp moves to v0.8.0: LFM3 and LFM3-VL load, read pictures and call
tools, and as hybrid models they now reuse 90–99% of each prompt from the
last turn instead of reading the whole conversation again.

Errors in the language you picked

Every message from the backend is now in the language the UI is in, from the
first one at startup on, instead of Chinese until a coding turn started, or
both languages at once. An engine's own words come after a line in yours, and
an image model missing a file says which one.

Linux, and the store

Thanks to @davidecelentano: on Linux Chaty picks one GPU through Vulkan —
discrete over integrated — and sizes offload by what the driver says is free;
music plays in the AppImage, which also opens on Fedora instead of a gray
window and updates itself in place. The download of an update shows how far
it has got. The store gains a Text generation filter, links
to Hugging Face, and a fit hint that knows whether a model fits the GPU, or,
on a Mac, fits in memory with everything it downloads.

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:

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

• Improve Linux Vulkan support, model catalog and media playback by @davidecelentano in #24

New Contributors

• @davidecelentano made their first contribution in #24

Full Changelog: v2.3.7...v2.3.8

v2.3.7

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.

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:

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: v2.3.6...v2.3.7

v2.3.6

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.

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:

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: v2.3.5...v2.3.6

v2.3.5

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. YuE2's instrumentals are made the way its
makers make them — a score, its vocal melody handed to an
instrument — which takes out most of the singing empty lyrics left in.
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, a
mouse wheel glides on a Mac as it does in Chrome, 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: Code's answers are set cleanly and come without emoji, a Code
session exports as a full JSONL trace, K2 Horizon's MLX quants load,
Code's sessions can be searched, several sessions at once can be
deleted in Code and the image studio, the model store keeps its
lists when Hugging Face cannot list models, and a web search is no
longer held to six sources — they fold into one line under the
answer, and stay with it.

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:

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 #22

Full Changelog: v2.3.0...v2.3.5

v2.3.0

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 — and in under two as an
MLX model: on a Mac, mflux's MLX saves of Z-Image, Qwen-Image and
FLUX.1 run on the MLX engine, with the same studio.

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.

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:

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 #21

New Contributors

• @Fangyuan025 made their first contribution in #21

Full Changelog: v2.2.2...v2.3.0

v2.2.2

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 searches its own record now — this session and every
other one, tool calls included, each marked done or failed — and
reads back what it finds: a whole session, one turn with every call
that turn made, or one of those calls in full. "Which session did we
talk about the database schema in, and what was said?" is one
question with one answer. Typing @ in the composer also offers
your other sessions alongside the workspace's files, to point it at
one directly.

Gemma 4 on MLX reasons again in code mode and in long chats, where
it had taken to opening its thinking and closing it again empty.

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 several at a time, and a click outside an approval dialog no
longer denies it.

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:

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: v2.2.1...v2.2.2

v2.2.1

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.

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:

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: v2.2.0...v2.2.1