Highlights from each version, newest first. The complete changelog — with signed artifacts and checksums — lives on GitHub Releases.
On Windows, updates no longer stop with “Failed to kill Maylyn”: the installer now waits for Maylyn to finish closing instead of checking once, and Maylyn shuts down its background service before handing over. Canvas art now sets up its own Python 3.12, like the music backend, so it installs on machines without Python or with a version too new for its graphics libraries.
On windows up to 32k Maylyn’s standing instructions and tool descriptions are the compact versions, modelled on Cline’s compact prompt for local models, which frees about half the space they took. Condensing now writes opencode’s structured handoff (goal, done, in progress, blocked, next step, files), so about two and a half times as much recent work survives. A missed edit always allows a fresh look at the file, repeated searches in a cycle are caught, and a syntax-only type check points at the bracket that was never closed.
When a turn ends on “I’ll read the file to find the error” instead of actually reading it, Maylyn is sent back to do it. That check missed every promise that named a file, because the dot in a name like canvas.ts looked like the end of a sentence; now it catches them.
The lint and test commands Maylyn runs after every change work again; they stopped in September when the agent changed engines. Notes the code has moved past are flagged as out of date instead of fed back as fact, her plan’s ticks no longer outrank the files, and automatic follow-up turns no longer reach her as orders from you. TypeScript syntax errors point at the bracket that was never closed, searching inside a single file works, and colored type-check output is understood.
When the check after an edit finds errors in three or more files, Maylyn hands each file to her implementer helper, one request per file, largest first. Each helper starts with a fresh memory and reports back, instead of one long conversation condensing itself every few minutes while it juggles every file. Aider’s split between planning and editing, on helpers Maylyn already had.
After every edit Maylyn runs the project’s own checker (TypeScript, Go, Rust, or Python with ruff) and gets the real result: how many errors, how that changed, and where they are, the way opencode and Aider keep their agents honest. An edit that would break a file that parsed cleanly is refused and shown to her with and without the change, as SWE-agent does. A syntax error that hides every other error is called out instead of reading as progress, a missed edit shows the closest real lines, and a failing test run is never taken for a broken tool. Plan steps like “fix the errors” stay open while the check still fails, and global or forced software installs now ask you first.
With the background reminder service running, the desktop app kept whatever model was already loaded, so choosing another changed the name on the reply but not the model writing it. Your choice now loads on the next message, while a model another Maylyn on the same computer is using is still left alone. A scheduled automation also no longer restarts the model to suit itself, which could cut off a reply you were waiting on.
The desktop app’s file browser can now open a project folder in your file manager or a file in its usual app; scripts and programs are shown in their folder, never run. A chat that loses its connection mid-reply reconnects on its own and picks up where it stopped, without repeating anything or running your message twice. When only you know the answer, Maylyn asks in the chat: a few options with her pick first, room for your own answer, and Skip, a design taken from opencode. A skipped question is never treated as a yes. Long tasks condense their working memory far less often (it was every two or three steps, about 75 seconds each) and reread far less of the conversation between tool steps. Tools no longer drop out of a conversation you come back to after a break, and image edits on the web find pictures in the conversation’s own project.
Small local models rarely copy a line of code exactly, so their edits used to fail. Maylyn now tries looser matches (spacing, indentation, escaped quotes, a block’s first and last lines) before giving up, an approach borrowed from opencode. Every write is checked for syntax errors and the error goes straight back to her. She won’t edit a file that changed since she read it, can rewrite short files whole, and can read several files in one step. The background service now frees the GPU when the app quits and leaves its model running.
Asked to fix a calculator, Maylyn checked the page, ticked off her plan and listed six fixes without editing a single file. A reply that describes changes when nothing that edits files ran now starts with “No files were changed this turn”, and that note stays in the conversation, so she knows the work is still to do.
When Maylyn edited a file with text that wasn’t in it exactly, she was told “nothing changed, stop repeating this edit” and tried the same fix again (nine times on a calculator). She is now told the text wasn’t found and to re-read the file. A failed edit also no longer counts as a write, which had started extra “the previous turn stopped before finishing” turns on its own.
v0.53.4’s bigger prompt batches looked 2.6× faster in a benchmark tool but were about half as fast in the real server (an 8,000-token prompt took 28 s instead of 18 s), so Maylyn is back on the smaller batch. Greetings and thanks now answer without thinking first, follow-up messages on the web and phone reuse the agent that answered the last one, and two schedulers firing in the same minute no longer fail a brief. The background service also unloads a model it started after 10 idle minutes, so the GPU isn’t left pinned while the app is closed.
Correction: the batch change below made prompt reading slower on the real server and was reverted in v0.53.5. Since September Maylyn fed the model small batches to avoid a GPU hang on one AMD card; on today’s engine those had become the slow path (340 vs 880 tokens a second on a 12 GB card). She now uses the engine’s standard batch and, if your GPU ever hangs, switches that machine to the smaller one by herself — nothing to tune. Naming a service (“what time is it in Utah”) no longer makes the next two replies re-read the whole prompt, and a selected knowledge base is now searched in under 2 ms instead of missing its time budget on every turn.
A quick “test” or “hello” changed the very start of Maylyn’s prompt, so that reply and the next each re-read the whole thing — 25–40 seconds on a 12 GB card. Every message now keeps the same start and the model reuses what it already read. The start-up warm-up also skips itself once you are already chatting.
Tell her “call me Jake”, “I prefer short answers” or “my dog’s name is Maylyn” and she saves it on the spot; she also learns from your conversations in the background, and what you asked her to keep is part of every new chat. Replies are faster on a graphics card the display shares: the animated background pauses while the model answers, and restarting the engine no longer starts several warm-ups that block your messages.
A flow step that named a model you don’t have installed started a different model under the missing name and reloaded the GPU between steps; it now uses your app’s model. The background scheduler also re-reads your settings when they change, so a new default model applies to the next automation, and file-edit previews on the web read from the conversation’s project.
Each turn’s tool calls now stay with the conversation, so “what did you just run?” gets the real command instead of “I have no record of that”. “Remember the 13th in Vegas” creates a real reminder instead of a note in a file. Web pages are checked by using them — clicking the buttons and reading the result — not just by loading. New installs and automations default to qwen3-8b, which answered 5 of 5 tool-calling checks where the old default answered 1. Settings → Advanced gains Free GPU & restart models for a stuck graphics card and an Update engine button for llama.cpp, and the scheduler now stops a model server a crashed app left behind.
A render that ran out of GPU memory could leave part of the image model on the card, so the next attempt failed with “Expected all tensors to be on the same device”. Failed renders now put everything back in system RAM, and a stack over 512 MB is merged into the model’s weights for the render — the card holds only the base model however many LoRAs are stacked. The first render with a new heavy stack spends 15–30 s merging; the same stack again renders at normal speed.
With the image model offloaded to system RAM, every LoRA the art backend had ever loaded rode onto the GPU with it for each render — active, switched off, or left over from an earlier stack — so a few large ones pushed SDXL past its memory cap and stacks failed with “out of memory”. Only the requested stack stays loaded now, every out-of-memory render retries after freeing what it can, and a stack that still does not fit says how big it is and which LoRA to drop. Renders stay at native resolution.
A project folder that points at a checkout elsewhere on disk resolved the agent’s context root to the empty pointer folder — so the map block, the map tool and the workspace listing never engaged, even for a mapped repo. Context now resolves through the same project resolver every file tool uses, follows a re-link immediately, and never re-creates a deleted checkout.
Once a project is mapped, every chat turn now tells the agent the map exists — how big it is and where its structure concentrates — and keeps the map’s query tool on the surface whether or not the question mentions it. “How do the controllers work?” is answered from the graph and the files it names, not from general knowledge. The map’s summary is cached, so a rebuilt map is picked up on the next turn and nothing is promised for a project whose Graphify server is no longer installed.
Viewing a mapped project’s code map showed a blank page in the Linux and Mac desktop apps, whose web engine refused the way the map was loaded. It now opens everywhere, still drawn offline and walled off from the rest of the app.
Since v0.50.1, clicking Install on the Linux “Update available” prompt did nothing, and Maylyn started on the old version a minute later. The prompt can answer the app again, and it now says so if it ever can’t. Desktop Control’s screenshot packages are now recommended rather than required, so a missing one no longer fails the update. On v0.50.1 or v0.51.0 on Linux, install this version once from the download page; updates work from inside the app again after that.
Once a project is mapped, the Files panel opens Graphify’s interactive map of it: search for a file, class or function, click a piece to see what it connects to, and filter by cluster. It’s drawn offline on your computer and nothing about your code is sent anywhere. Connect your computer under Settings → Account to use it from the EchoBark Hub, with chats, files and approvals still running on your machine. maylyn-mcp lets VS Code and other MCP clients inspect projects, run chats and queue renders through your own sign-in. Graphify’s pull-request tools are now off, since they used your GitHub login.
The desktop app was refusing the page’s requests to its own built-in actions, so Link a folder reported “Couldn’t open the folder picker.” The picker opens again, and so do choosing files, keeping tokens in your system keyring, notifications, keeping the computer awake during a reply, and Discord status. A new Files panel button maps the open project with Graphify so you can ask Maylyn what calls what.
Add Graphify in Settings → Library → MCP, then ask what calls a function, what a change would touch, or how two pieces connect. Maylyn maps the project into a graph of every file, function and class and answers from it. Built from the code’s structure alone: no model calls, no GPU, nothing leaves your machine.
Cancelling now stops the image engine itself, whether the render is queued, starting, loading its model or mid-way. Upscale 2× doubles a picture and redraws fine detail, and doubles pixel art crisply. Create presets from scratch, duplicate, rename, update and delete your own, and export or import them. The status line reads in plain words. Verified live on a real GPU through the full app.
The live preview fills the canvas cleanly and identifies the current image in a batch. New images explains how many fresh takes are queued. Cancellation stays available through submission and rendering, with queueing held until the cancelled worker exits. Downloads use authenticated requests and show failures.
Text pasted into the Image Studio’s prompt box is no longer mistaken for a picture.
Closing the desktop window on Linux now quits Maylyn, and Quit Maylyn (Ctrl+Q) works everywhere.
The Create screen shows your LoRA stack, keeps it working with every preset, and lets you save the whole setup.
Reference pictures and twenty-two presets across photo, art, characters and design.
The Image Studio opens on your picture, with the presets and prompt beside it and the expert panels one click away.
The Image Studio gives your GPU back between pictures and starts from ready-made presets.
The Image Studio renders at the size its models were built for, adds a fast painterly fantasy model, and can cut characters out onto transparency.
Outpainting gets its own buttons, and a slow edit no longer keeps your graphics card busy after Maylyn has stopped waiting.
LoRAs are shared across the desktop app, web and terminal, Auto picks the model your LoRAs were made for, and the negative prompt is easy to find and works on every model.
Find, install and stack LoRAs without leaving the Image Studio, and chat models and image renders now take turns on the GPU instead of slowing the whole computer down.
.safetensors, SHA-256 checked; adult LoRAs off unless you turn them on; LoRAs of real people refusedv0.44.6 and v0.44.7: long prompts reach the model in full, Auto picks one model and sticks to it, and FLUX.1 schnell joins the image models you can install from Settings.
v0.44.4 and v0.44.5: pixel scenes keep the pixels the model drew, four Image Studio settings that did nothing now work, and a style you pick stays that style.
v0.44: paste a picture into chat for a vision model to read, render in the Image Studio again, and remove any model you’re done with.
v0.43.7 and v0.43.8: headlines arrive as links even small models copy correctly, and every link must come from your sources.
Automations hand the AI clean data from any source, tell it which ones failed, and deliver the whole result.
v0.43.4 and v0.43.5: a brief can no longer invent email, meetings, news or issues to fill its sections.
Scheduled briefs fire on time, even with the app closed, and report real numbers instead of filler.
Automations can now message you on Discord as your bot and read your Asana tasks.
Read any API, Slack, feeds and calendars; hear only about what’s new; split on a condition; send the result where you choose.
This release fixes unattended automation tool authorization, updates the flow UX and model defaults, and ships the current packages for direct download.
One Maylyn per computer, cleaner Windows, cleaner chat.
maylyn serve), the desktop app opens it instead of starting a second copy that fought it over the model — first words in ~2 s instead of 20–30The prompt cache now works on sliding-window models.
The standing prompt Maylyn sends with every message is more than a third smaller.
The Song panel now follows the structure ACE-Step’s prompting guides recommend.
Suggestions that fit your song, instead of every tag at once.
Two- and three-minute songs finish now, and ACE-Step's planner joins in when the card has room.
The song form could be hidden behind the studio's own panels.
Making songs in the Sound Studio now works the way songwriters think: pick a style, write lyrics, press Create, and remix what you like.
ACE-Step 1.5 is the default music model, and it works on AMD graphics cards.
The safety check v0.37.2 added for AMD graphics cards could probe the card dozens of times before a reply even started.
A fresh install no longer picks a model too big for your card, and Maylyn can no longer be linked as a project of its own source code.
The desktop app and the command line now share one projects folder you can open and browse.
~/Maylyn/projects, for the desktop app and the command line alike — a project made in one is right there in the otherMAYLYN_PROJECTS_DIR to keep them somewhere elseBig jobs stop going in circles, answers stop going missing, local models run much faster, and your wiki fills itself.
Faster from the moment Maylyn opens, more reliable with the tools you install, and honest when a step didn't happen.
Maylyn stops re-reading its whole setup before every reply, and knowledge questions use your installed packs.
Installed tools get used, skills install as whole folders, and Linux stops opening to a blank window.
A sign-in fix for small screens, two reliability fixes, and a security hardening pass.
Two Windows fixes, and a pass that makes Maylyn's tools, skills and knowledge actually reach each other in the desktop chat.
Settings has a new Library group with Knowledge, Skills, Models and MCP Tools panes, replacing the sidebar panel — and Knowledge does two new things.
Expanding a thought while Maylyn was still working only ever showed a sliver of it — scrolling revealed a little more, never the whole thing.
A follow-up to the previous release: raising the auto-sizing floor did nothing for anyone who already had a model server running from before that fix shipped.
A local model could silently lose access to every tool, on every turn, with no way to fix it short of manually raising --ctx-size — exactly what auto-sizing exists to avoid.
Signing in through the hub could get stuck in a loop — fixed, plus a new admin panel for managing accounts.
A Pack invite link followed in a plain browser now offers to open the native app first, the same way Slack or Discord invite links do.
One more gap from the same family as the last two releases.
Two more bugs found immediately after the previous release shipped.
http://127.0.0.1:8799/... — the app's own local backend — unusable by anyone but the exact machine that made it. The desktop app's webview always talks to its own local backend directly, so the request used to build the link never carried the real public address. Invite links now use the actual hub the desktop app is a client ofAn emergency fix. The previous release's Kratos routing change broke sign-in completely for every desktop install within minutes of shipping.
Sign-in was breaking for real users with a raw "Kratos unreachable" error, even when a hub was right there and ready. Two separate bugs stacked on each other; both are fixed.
Two more issues reported live: a guest with no account at all, and a desktop app that seemed impossible to fully close on Windows.
Three bugs reported live by an actual friend testing on a fresh Windows machine, fixed the same day.
C:\Windows\System32 by default — linking a system directory, a bare drive root, or Maylyn's own data is now refused outright, and the launch-time "start a project here?" prompt doesn't even ask about one in the first placecould not create canvas art venv: exit status 9009 on a machine with no real Python — Windows ships stub python.exe/python3.exe "App Execution Alias" files that do nothing but open the Microsoft Store; Maylyn now actually runs --version on whatever it finds before trusting it, and tries the official py launcher tooA real account-requirement bypass, closed — and the account system it protects gets an actual front door instead of the one dead end it had before.
maylyn users CLI, so a Kratos-signed-in owner silently stayed a "guest" for tool capability until someone ran that by handA project's own data kept turning out to be unreachable from the UI that was supposed to show it — this release chases that down everywhere it was found, and folds project management into one real surface instead of two.
maylyn launch races the app's own boot — reported live, repeatedly, on WindowsA big batch: the Studio's image-generation backend was fundamentally disconnected from its own setup flow — clicking "Install image models" could report success and do nothing useful, forever — plus several smaller fixes that came out of actually using it.
setup/art (onboarding and the Studio both) was checking and configuring an old backend nothing actually renders through — a fresh, "successful" install still left image generation brokenFixed a case where the first-run setup wizard could silently overwrite an already-configured model. Also the first real move onto Arch-based distros: an AUR package for Omarchy and friends, and the desktop app now recognizes itself in your app launcher even when run as a bare AppImage with no package manager involved.
The third and final pass on the composer footer: every icon button is square again, dropdown menus no longer get stuck behind message-level menus, and the skill picker shows what's actually selected on page load. The desktop app also checks for updates immediately at launch instead of waiting 20 seconds for no reason.
"Thinking mode: Off" now suppresses reasoning for any model, not one hardcoded family. "Work" mode now actually narrows the tool surface for speed, the way "Ask" already did. Plus another alignment pass on the composer footer.
The footer picker row got a real redesign — model, chat mode, thinking mode, skill, and auto-approve pickers reordered and verified pixel-by-pixel against a live rendered page, plus a quick way to switch models without leaving the conversation.
Fixed a quiet, self-inflicted mismatch where the app could keep a different model loaded in VRAM than the one you'd actually selected.
Maylyn ships as a native desktop app for macOS, Windows, and Linux. The EchoBark layer lets you form a Pack with people you trust and share compute directly between machines — no cloud in the path.
/mesh/envelope transport, mutual sharing on joinReliability pass on the long-running pieces.
Watch a turn unfold step by step — planning, tool calls, sub-agents — while the answer stays pinned in view as the detail scrolls past.
The creative Studio gains audio generation and an animation timeline alongside the pixel-art and game-art pipelines, plus reusable node-graph presets.
Make the app prove what it did rather than describe it, and make what it's doing visible while it does it.
The agent loop runs on LangChain's deepagents in a provisioned Node sidecar. Planning, tool selection, and sub-agents come from the library; tools, sandbox, safety kernel, and approval UX stay in Go.
Profile-safe memory and auth, rebuilt attachment UX with multi-file support, server-side PDF ingestion, and single-use replay links with transcript + artifact snapshots.