← Lily DB

Release notes

Lily DB

Get the latest — v0.25.0 85 releases and counting

v0.25.0

August 28, 2026

Understand your database as a living map

"Understand this database" is now a living graph. Each sub-system is a glowing node sized by its tables, connected to the others by the real relationships that cross between them — so a big schema reads at a glance instead of piling into a blur.
It's a canvas you can explore: drag a sub-system to rearrange it, hover to light up its connections, drag the background to pan, and pinch to zoom. Click one to explore its tables or move its data.

v0.24.2

August 28, 2026

Ask across your databases, smarter

Federated Ask now reaches the right database. It never skips one it has never analyzed — it can't rule out what it hasn't seen — and it matches by meaning across singular and plural, so "user" finds your users table.
And it self-heals: if the generated query hits a missing function or column, Lily rewrites it once and retries — always read-only. It also steers clear of Postgres extension functions (like unaccent) that may not be installed.

v0.24.1

August 28, 2026

iCloud sync that runs itself

iCloud sync now runs on its own — when you launch Lily, when you switch it on, and (debounced) after you add or remove a connection. A "last synced" line tells you when it last ran, so you're never guessing.
Changed your mind? Turn sync off and remove your synced copy from iCloud in one step, right from Settings.
Quieter under the hood: a steady sync with nothing new no longer re-uploads every connection each round, concurrent rounds can't race, and a group deleted on another Mac no longer leaves a dangling reference.
A fresher first run: the welcome tour was rebuilt around what Lily can do now — asking across your databases, Investigate that applies and proves a fix, and moving data between engines.

v0.24.0

August 28, 2026

Your connections, on all your Macs

Turn on iCloud sync and your saved connections follow you to every Mac you sign into — names, hosts, ports, options. New connections and deletions carry across; it stays off until you turn it on in Settings → iCloud sync.
Private by construction: only connection metadata syncs. Your passwords, keys and secrets never leave this Mac's Keychain and never touch iCloud — the synced record structurally can't carry a secret.
More ways in and out: export a real .xlsx that opens cleanly in Excel and Numbers, and import JSON, NDJSON and Parquet files straight into a table. The file readers are defensive — a malformed file is refused with a clear error instead of crashing.
Local AI fix: OpenAI Codex passes its connection test again and drives every AI feature.

v0.23.0

August 28, 2026

Ask across your databases

Ask a question in plain language without picking a connection. Lily figures out which of your open databases holds the answer — by what each one is about — asks each on its own, and gives you one answer that says which database each fact came from. The ✨ button appears in the connection bar when two or more databases are open.
Safe and honest: every database answers read-only with its own values redacted, and nothing crosses between them — the combined answer is stitched from each database's own already-masked reply, never its raw rows. Lily tells you exactly which connections it consulted, which failed, and which it judged unrelated. On-device, no API key.

v0.22.0

August 27, 2026

Investigate applies the fix — and proves it

Investigate no longer stops at the diagnosis. It proposes a concrete fix — like a missing index — and with one click applies it, measures the estimated query cost before and after, and reverts it automatically if it didn't actually help. Nothing is left behind that didn't earn its place.
Safe by design: on a read-only connection it only proposes and never writes; every fix must cite the evidence behind it or it's dropped; and because adding an index can't run in a transaction, a fix that doesn't pan out is undone with a compensating drop — not a promise. Fully on-device, and queries are redacted before analysis.

v0.21.0

August 27, 2026

Sharper AI on big databases

On a large database, Lily now grounds the AI on the tables relevant to your request — found with an on-device language model, no API key — instead of sending the whole schema. And it tells you exactly which tables it left out, so a big schema no longer silently loses tables from the AI's view.
Semantic search now finds a table by meaning, not just keywords: ask for "money returned to buyers" and it finds refunds — even when your question is in Portuguese and the tables are named in English.
Fully on-device and private — the first use downloads a small Apple language model once, then it works completely offline; nothing about your schema ever leaves your Mac. On by default; turn it off in Settings to always send the full schema.

v0.20.0

August 27, 2026

Move and convert big databases too

Moving a whole table to another engine now streams the rows in bounded memory, so a big table goes through instead of being refused. Its target schema is taken from the source, so a column keeps the type it has at the source — a numeric-looking text column doesn't turn into a number.
Converting a relational database to MongoDB now streams too: it reads the root table in batches and fetches only each batch's children, keyed — so a large database converts without loading all of its tables into memory at once.

v0.19.0

August 27, 2026

Copy tables of any size

Migrating a database, exporting to CSV/JSON/NDJSON, and dumping SQL now stream the rows through in bounded memory — so a table with millions of rows goes through without loading it all into RAM (or being refused, as it was last version). It's keyset-paged for speed wherever the engine supports it.
Under the hood the copy can't silently truncate a large table, and it pages correctly even when a table's key doesn't declare a clean type — like a type-less SQLite primary key that stores integers.

v0.18.0

August 27, 2026

Dashboards, tab management, and safer big-database copies

Dashboards — pin your queries as a live dashboard: a grid of tiles, each its own SQL rendered as a chart, a big number, or a compact table, refreshing on a timer you choose. Saved per connection, so an analysis survives a restart instead of scattering across query tabs.
Close all tabs — or all the others — with a right-click on any tab, the way you'd expect. Pinned tabs stay put, and a tab with unsaved table edits asks before it's discarded.
Two reliability fixes: the window can't open cut off anymore — it's clamped back onto the visible screen — and a database migration now refuses a table too large to copy safely instead of silently dropping the rows past its limit.

v0.17.0

August 27, 2026

Convert between SQL and MongoDB — with AI

Turn a relational database into MongoDB documents — right-click a schema, pick a Mongo connection, choose (or name) a target database, and Lily designs the document model with AI following NoSQL best practices: it embeds the data a row owns, references what's shared, nests children into their parent and drops the linking keys before writing the documents.
…and the other way, into a real SQL schema — right-click a MongoDB database and Lily samples each collection to infer tables: scalar fields become columns, nested objects flatten, and arrays become child tables with foreign keys and indexes. AI then refines it — clearer names and narrower types (a text field that's really a date or a number) — with every change re-checked against the data so the result still loads.

v0.16.0

August 27, 2026

Migrate a whole database to another engine

Cross-engine database migration — right-click a schema and copy it, structure and data, into a different connection: any relational source into PostgreSQL, MySQL, SQLite or SQL Server (SQL Server → PostgreSQL and back). Column types are mapped, keys (primary, foreign, and composite) are recreated in dependency order, and the rows are copied parent-first — with a DDL preview before anything runs, and a rollback if it doesn't.
It preserves what makes the database usable: enums migrate as a real enum where the engine has one (and a CHECK where it doesn't), auto-increment keys keep generating past the copied data, and defaults, unique constraints, arrays and indexes all come along. Anything that can't be auto-translated — views, procedures, triggers — is listed, never silently dropped.

v0.15.0

August 27, 2026

A playground to test in, and notebooks to think in

Docker Playground — spin up a throwaway, seeded database in one click, right inside Lily. Pick Postgres, MySQL, SQL Server, Redis, MongoDB, DynamoDB, Trino or ClickHouse and Lily starts the container, waits for it, seeds sample data, and connects. "Keep" mode gives it a volume and files it under a Playground group so it survives as a real dev database — with a copy-ready connection string for your own app. Needs Docker installed.
Notebooks — SQL, Markdown and charts in one document you run cell by cell. Keep several queries side by side, each with its own result, write prose between them, and flip any result to a chart. Saved per connection, so an analysis survives a restart instead of scattering across query tabs.
Keep the conversation going — after you act on something the AI wrote, the Ask panel now remembers the thread instead of starting over.

v0.14.0

August 25, 2026

Move data between any two engines

Move data across engines — the one thing only a nine-engine client can do. Take a query result or a whole table and materialize it into another connection: any SQL engine (Postgres, MySQL, SQLite, SQL Server, ClickHouse, Trino), MongoDB, or DynamoDB. Lily infers the column types and creates the target table (or appends to an existing one), with a DDL preview before it runs.
Ask in plain language, then move it: describe the rows you want, let the AI write the query, and send the full result to another engine in a click.
Trino joins the activity monitor — see its running queries and kill one. Trace now spans seven engines.
Export to NDJSON — the newline-delimited JSON that jq, DuckDB and log pipelines ingest for streaming loads.

v0.13.0

August 23, 2026

See what MongoDB and Redis are doing — and build Mongo pipelines visually

The activity monitor now covers MongoDB and Redis too. On MongoDB, watch live operations (from currentOp) and kill a runaway one. On Redis, see the slow commands (SLOWLOG) and every connected client — and disconnect one. Trace now spans the whole fleet, not just the SQL engines.
Build a MongoDB aggregation visually — stack $match, $group, $sort, $lookup and more as cards you can reorder and edit, then flip to raw JSON whenever you want. No more hand-balancing brackets.
Watch a collection change live: a change stream tails inserts, updates and deletes as they happen, colour-coded newest-first (on replica-set deployments).
Two more ways to chart a result — area and scatter join bar, line and pie.

v0.12.0

August 23, 2026

MongoDB and SQL Server, done right

MongoDB, reimagined: documents open as clean key→value cards (nested fields and all), and you can ask your data in plain language — Lily writes the aggregation pipeline, runs it, and answers. Collection details show indexes, Explain flags a full scan (COLLSCAN vs IXSCAN), you can create an index, and editing keeps types exact (Decimal128 no longer rounds).
A full activity monitor for SQL Server: see every running query, who's blocking whom, and the top queries by cost — read straight from the DMVs — and kill a runaway session. Plus a visual execution plan (SHOWPLAN) and one-click "speed up this query" that applies an index and proves the win, before and after.
Edit Redis collections, not just strings: add, change and remove hash fields, set and sorted-set members, and list items — and every key now shows its type at a glance in the browser.
The AI reaches further: Investigate and reversible AI migrations now work on Trino and ClickHouse too, grounded in each engine's real plan and DDL.
Cross-engine tidy-up: saved queries remember which engine they were written for (with a same-engine filter), and query history can scope to just the connection you're on.

v0.11.1

August 22, 2026

A sharper DynamoDB icon

A small polish: DynamoDB now wears a key, not a box — fitting for a key-value store.

v0.11.0

August 22, 2026

DynamoDB, done right — native queries, AI, and a document view

Query the way DynamoDB is meant to be used: search by partition + sort key (begins-with, between, ranges) on the table or any secondary index, instead of scanning everything. A quick filter bar narrows a browse without writing PartiQL, and pages load on demand with the read cost (RCU) shown.
Edit an item in place — and your data keeps its exact shape: String/Number Sets and Binary now round-trip losslessly instead of collapsing into lists. A details panel shows keys, indexes, billing and TTL, and you can create a table with a global secondary index.
Ask your DynamoDB data in plain language — Lily samples the table's schema, writes the PartiQL, runs it (reads only) and answers. "Understand" describes what a table stores and how it's modelled.
A cleaner item view: documents open as tidy key→value cards — sets as chips, types colour-coded, true to a NoSQL store — with a one-click table view for uniform data. And a guard flags a live AWS account, asking you to type a table's name before dropping it.

v0.10.0

August 21, 2026

Amazon DynamoDB — the ninth engine

Amazon DynamoDB is here — the ninth engine. Connect with your AWS keys (or a local endpoint for DynamoDB Local), browse tables and items as colour-highlighted JSON, and query with PartiQL, a SQL-like language over your items.
Full read-write, right from the app: create a table (partition + optional sort key), add items from a JSON editor, and delete items or whole tables — each with a confirmation, and blocked on read-only connections.
A guided onboarding — a quick 5-step tour that actually explains what Lily does: connect any database, query it in plain language, Trace what's happening, and stay safe by default.

v0.9.14

August 20, 2026

The real error message — and the AI's SQL comes out clean

You see the database's real error now. When a query fails, Lily shows the actual message — the exact syntax error or the column that doesn't exist — instead of a cryptic "PSQLError error 1". Postgres was surfacing the real cause only while streaming the result, and it slipped past the error handler.
Generated SQL comes out clean. When an AI provider added a note before the query, that text could leak into the SQL and break it when you ran it. Lily now keeps only the SQL and drops any surrounding chatter.

v0.9.13

August 20, 2026

Use all your AIs at once — in parallel, and nothing stalls on one

Turn on more than one AI provider and rank them. Lily uses them together — the top one leads, the rest are ready to help.
A big analysis — understanding a database, writing recipes, scanning for sensitive columns — now splits its batches across your enabled providers and runs them in parallel, so it finishes faster. Each batch is still done once, so it costs no more.
If a provider is offline or fails mid-run, its batch is retried on a healthy one — the analysis no longer stalls on one flaky CLI.
Test any provider from Settings with a click to confirm it actually answers, and the Settings window no longer stretches down the screen.

v0.9.12

August 20, 2026

The AI handles big SQL Server databases — and never just hangs

Understanding and asking questions about a large SQL Server database works now. Reading a schema with thousands of tables was doing one query per table over a single connection and timing out; it's now a single fast catalog query, so "Understand" and "Ask your data" finish instead of loading forever.
No AI task runs forever. Understanding a database, writing recipes and the sensitivity scan now stop after a few minutes and keep what they finished (you can pick up where they left off), instead of spinning with no end in sight.
When the AI fails, you see it. A failed explain, optimize, fix, index suggestion or documentation now shows a clear, persistent error instead of a message that flashes and vanishes — and a partial analysis says so rather than pretending it finished.

v0.9.11

August 20, 2026

A row inspector for JSON — and AI you can watch and stop

Click a row and open the inspector to read the whole record in a side drawer, one field per line — and a JSON column is finally shown formatted and colour-highlighted instead of crammed into a cell. Image columns preview as a thumbnail.
AI features tell you what they're doing. "Ask your data", Investigate and Generate SQL now show their steps — reading the schema, writing the query, validating, fixing — instead of one silent spinner, so a big request no longer looks stuck.
…and you can stop them. A Stop button (and closing the window) now actually cancels the AI and frees it immediately, rather than waiting out a two-minute timeout. Recipes appear as each batch is written instead of all at the end.
Big schemas don't hang the AI anymore. Building the schema context is now time-bounded and capped, so a database with thousands of tables gets an answer (or a clear result) instead of loading forever.

v0.9.10

August 15, 2026

Faster and lighter — big tables scroll smoothly again

Large results scroll smoothly. The grid only builds the rows you can see again (a wide table had quietly stopped), each cell does far less work as it appears, and clicking a row selects it instantly instead of pausing to see if you meant a double-click. It stays fluid all the way to the 50,000-row cap.
The whole app feels more responsive. Typing in the SQL editor, moving the cursor, and browsing the schema no longer re-render parts of the screen that didn't change — so a keystroke updates the editor, not the results below it.
Row-count badges load all at once. Open a schema and the sidebar fills in every table's row count in one step, instead of trickling in one query at a time.
Lighter on your Mac when idle. The animated background and title now rest instead of repainting forever, and old query results are freed as soon as you move on — so Lily sips less GPU, CPU and memory just sitting open.

v0.9.9

August 14, 2026

Nothing gets deleted without asking — and Mongo opens as a grid

Deleting always asks first now. Removing a row straight from the grid — in any SQL engine, a MongoDB collection, or a Redis key — shows exactly what it will touch before it happens, the same blast-radius check the SQL editor already had. TRUNCATE and DROP TABLE from the sidebar make you type the table's name to confirm.
"Understand" no longer hangs on a giant schema. On a database with thousands of tables it stays responsive and can be cancelled, instead of loading forever.
MongoDB collections open as a real grid, not just JSON cards — columns with _id first, nested values shown inline, and the same export as every other table.
Cells that hold an image now preview it: a PNG, JPEG, GIF, BMP or WebP stored as bytea, base64 or a data URI renders right in the cell inspector, with its dimensions.
The editable table gained a footer — aggregate any column (count, sum, average, min, max; distinct and null counts for text), and export just the rows you selected.
Reopening a connection brings your whole workspace back — the table tabs you had open return too, not only the query drafts.

v0.9.8

August 14, 2026

Smoother on big results — and the header stays at the top

On macOS 26 the result grid could render its column header at the bottom of the grid instead of the top. It now stays pinned at the top on every redraw.
Large query results feel lighter: the grid no longer rebuilds every row on each redraw, the ⌘F search is memoized so navigating matches doesn't re-scan, and a multi-statement script now caps the total rows it keeps in memory. Closing a tab mid-query cancels the query instead of leaving it running.
Open or select a query tab past the edge of the tab strip and it now scrolls into view, instead of staying hidden at the end.

v0.9.7

August 6, 2026

See what a write will touch — before it runs

Before a risky DELETE or UPDATE runs, the confirmation now shows the rows it will touch — a real sample straight from the table, with the true affected count — instead of just a number. Works for DELETE … RETURNING and subquery writes too; the SQL stays collapsed so the rows are front and center.
PostgreSQL jsonb columns now display their JSON instead of "<JSONB>". The binary value carries a version byte the previous decode didn't strip; scalar jsonb and arrays of jsonb both read correctly now, ready for the JSON cell viewer.
Postgres UUIDs now display lowercase, the way Postgres, psql and other tools emit them — so a UUID copied out of Lily matches exactly when you paste it into a lookup elsewhere.
Editing an enum cell now opens its value list right on the cell, as a dropdown. It used to open detached at the top of the grid.

v0.9.6

August 4, 2026

SQL Server shows all your databases

Connect to SQL Server and the sidebar now lists every database on the instance — master and all your own — with a switcher to move between them, just like Postgres. Before, it showed only the schemas of the one database you connected to.

v0.9.5

July 30, 2026

The AI reaches more of your engines

Ask your data, Investigate and generate-SQL now work on SQLite. SQLite has no information_schema, so the AI used to write SQL with no idea of your tables — it now reads them the same way it does on every other relational engine.
Understand now works on Trino and ClickHouse. Mapping your schema to the business behind it needs tables and columns, not foreign keys — so the two query and columnar engines get it too.

v0.9.4

July 30, 2026

Smarter AI, and queries you can describe

Ask your data writes better SQL. It now sees each enum type's real values (so it won't invent an invalid one like "CANCELED") and quotes case-sensitive column names correctly (so "userId" no longer folds to a missing "userid").
AI answers follow your language. Explaining a query, summarizing a result, the health review and Investigate write in your selected app language — and an explanation opens with a short title naming what the query does.
Save a query with a description. A cleaner save sheet with a name and a details note; with AI configured it suggests a title and description from the query. The library shows, edits and searches the note.

v0.9.3

July 29, 2026

Big results stay smooth

Sorting or filtering a large result no longer freezes the app. A big query result — think SELECT * over tens of thousands of rows — used to lock up for a moment when you clicked a header to sort or typed a filter; that work now runs off the main thread, so the window stays responsive and the rows reorder a beat later.
Exporting a large table no longer freezes the app. The CSV, JSON, and Excel write loop now streams to disk in the background instead of blocking the interface.
Smoother scrolling on big tables. On macOS 15 and later the result grid again builds only the rows you can see, so scrolling and resizing columns on large tables feels lighter.

v0.9.2

July 29, 2026

Snappier, and a fix from Julio

Less work as you browse: the schema sidebar builds only the rows you can see instead of the whole tree, enum column values are looked up once per table rather than on every sort and page, and the animated background runs lighter. Most noticeable on large schemas.
Adding a row to an empty table works. An empty table used to draw a "No rows" placeholder with no grid, so a new row had nowhere to appear — it now shows the editable row straight away. Thanks Julio.

v0.9.1

July 29, 2026

Two fixes from Igor

Reopening a connection now shows the database you're actually on. If you'd switched databases in an earlier session, the sidebar could paint the previous database's tables until you hit reload — now the tree refreshes to the live database on open.
Sorting sorts the column you clicked. On a wide table scrolled to the right, clicking a header could sort a different column — the pinned header's tap area drifted from the scroll. The grid now keeps them aligned.

v0.9.0

July 28, 2026

Investigate, data diff, and enums

Investigate: describe a symptom in plain language — "why is the orders page slow?" — and Lily reasons over your schema, recent queries, their execution plans, and the slowest traces to name the likely cause. Every claim is cited to the specific query, plan, or table behind it, and every query is redacted before analysis, so no row value is sent.
Data diff between connections: pick the same table on two connections — prod and staging — and see which rows exist only on one side and which share a key but differ, cell by cell. The row-level companion to the schema diff.
Manage enum types. On Postgres, create an enum, add a value, or rename one from the sidebar — and enum values (including arrays like status[]) display as their labels instead of a raw type id. On MySQL, right-click an enum column to edit its values, with nullability preserved.
Drop a database and rename a schema, rounding out the schema-management tools — dropping a database is gated behind the same type-the-name confirmation as Drop schema.
Fixes from Igor's report: a new connection shows the database you actually opened, the Recipe book no longer times out on large schemas (it generates in batches with a progress bar), and user-defined enums render properly. Plus two sidebar glitches: a stray blue focus line, and rows that could vanish until you scrolled.

v0.8.3

July 25, 2026

Drop a schema

You can now drop a whole schema (or database, on MySQL) — right-click it in the sidebar and choose "Drop schema…". Lily shows the exact SQL first, and because dropping a schema takes every table in it, the button stays disabled until you type the schema's name to confirm.

v0.8.2

July 25, 2026

Small fix

SQL Server appeared twice on the New Connection screen — once as a real engine and once as a leftover "Coming soon" tile. It's a real engine now, so the placeholder is gone.

v0.8.1

July 25, 2026

SQL Server — a few more column types

More SQL Server column types now display correctly: XML shows its content, REAL numbers show cleanly (no float rounding noise), and sql_variant columns holding a number are no longer blank. Found by testing every type against a live server.

v0.8.0

July 25, 2026

SQL Server — the eighth engine

Lily now connects to Microsoft SQL Server. Everything you use on the other relational engines works here: browse and edit tables, sort and filter in place, follow foreign keys, run T-SQL, the schema Health Check, and the AI features. Just pick SQL Server when you add a connection.
It's a native connection — no ODBC driver to install, nothing to configure. Lily speaks the SQL Server wire protocol directly, so it's the same fast, self-contained experience as every other engine.
Every column type renders correctly, verified against a real server: dates and times, uniqueidentifier (GUID) keys, money, decimals, BIT, and binary — no placeholders, no surprises.

v0.7.4

July 21, 2026

OpenCode joins the AI providers

If you already use OpenCode in your terminal, Lily can drive it — pick it in Settings → AI, alongside Claude Code and OpenAI Codex. Every AI feature works the same through it: Understand, Ask your data, generate and fix SQL, index advice.
Your OpenCode setup decides the model — Lily doesn't override it, because OpenCode names models differently than the other CLIs. Whatever provider and model you've configured there is what answers.
Clearer wording about what the AI costs. Lily used to say "no API cost". The local CLIs still call remote APIs on your own plan — what Lily actually saves you is managing API keys, and that's what it says now.

v0.7.3

July 21, 2026

Lily runs on your Mac now

Lily used to require macOS 26 — the newest release — which locked out most Macs in use, including machines from 2023 that run everything else fine. It now runs on macOS 14 (Sonoma) and later. If you've been unable to install it, you can.
Nothing was cut to get there. On macOS 26 the interface still uses Liquid Glass exactly as before; on earlier versions the same panels are drawn with a frosted material instead. One visual effect, one fallback — every feature is identical on both.

v0.7.2

July 20, 2026

Delete many rows at once

Select several rows and delete them together. Until now the menu acted only on the row you right-clicked, so a selection of fifty looked staged and wasn't — one row went, forty-nine stayed. Right-click inside a selection and it's "Delete 50 rows"; right-click outside it and you still get just that row.
The table grid now takes the keyboard. ⌘A selects every visible row (only the ones your filter is showing), arrows move the selection, ⇧-arrows extend it, and ⌘C copies. The read-only result grid always had this; the editable one didn't.
Deleting many is as careful as deleting one: each row is still matched by its own primary key, they all commit in a single transaction, and if any row in the selection isn't safe to delete, the whole save stops — a half-deleted selection is worse than none, because you can't tell what survived.
Under the hood, Lily's engine now compiles and runs outside macOS, checked on every change. Nothing about the Mac app changes; it's the groundwork for a native Windows version becoming real rather than assumed.

v0.7.1

July 20, 2026

Português, completo

Every release note is now in Portuguese. The What's New for 16 older versions had quietly stayed in English — Lily falls back to English silently, so nothing looked broken and no one noticed. All 43 versions are translated now, and the check that catches a missing one runs on every build.
Two more of Lily's macOS-only pieces — the SSH tunnel and the way your local AI CLI is launched — now sit behind a platform boundary. Nothing changes for you on macOS: same tunnels, same AI, same speed. It's the groundwork that lets the same engine build for Windows.

v0.7.0

July 20, 2026

The engine stands on its own

The groundwork we started in 0.6.6 is done: Lily's database engine is now fully separated from its Mac interface — every driver, query, and AI feature lives in its own self-contained core that runs with no interface code at all. It's the foundation a native Windows version will be built on.
Nothing changes for you on macOS. Same app, same speed, same privacy — your data still never leaves your machine, and the local AI still only ever sees a redacted view. This release is invisible on purpose: it's the plumbing that makes what's next possible without slowing today's app down.
The separation isn't just a promise — a headless check runs the whole engine on its own, with zero interface loaded, on every build. If the engine ever drifted back into needing the interface, the build would stop. That's what keeps the door to Windows open.

v0.6.8

July 15, 2026

Quotes on a Brazilian keyboard

Fixed typing quotes in the SQL editor on the Brazilian (and US-International) keyboard. There, ' and " are "dead keys" that wait to compose an accent, so a quote wouldn't appear until you pressed space — painful when you type quotes all day. The editor now inserts a straight ', " or backtick immediately, so a string literal just types.
Accents still work where you want them: ~ + a still makes ã. Only the quote and backtick keys are made immediate; every other accent composes as before.

v0.6.7

July 15, 2026

Quotes that just work

Fixed a filter that came back empty. If macOS "Smart Quotes" was on, typing a filter like id = '…' turned the straight quotes into curly ones, which the database doesn't accept as a string — so the filter matched nothing even when the row existed. Lily now straightens them for you, so a filter you type just works.
The same fix covers everywhere you type a value: table filters, the filter builder, inline cell edits, query parameters, and Mongo/Redis filters. Accented letters (José, ação) are untouched — only the curly quotes are corrected.

v0.6.6

July 14, 2026

Groundwork

Under the hood, Lily's core is being separated from its Mac interface — the first step toward a native Windows version, and toward keeping the engine testable on its own. Nothing changes for you on macOS; everything works exactly as before.
A new build-time guardrail keeps that separation honest, so the database engine stays free of interface code. It's invisible, but it's what makes the next chapter possible without slowing the Mac app down.

v0.6.5

July 14, 2026

Sharper edges

Query history now remembers how each run went. Every entry shows whether it succeeded, how long it took, and how many rows it returned — filter to just the failures, or sort by slowest to find what's dragging.
Saved queries remember their parameters. A library query with :placeholders now pre-fills with the values you used last time — "orders for :customer_id" remembers the customer_id — so a saved report is one click, not a re-type.
Fixing a failed script is easier. After a run that kept going past errors, "Open failed statements" drops just the ones that failed — each labeled with its error — into a fresh tab to fix and re-run. And Lily remembers whether you prefer all-or-nothing or keep-going.

v0.6.4

July 14, 2026

See why it's slow — right now

See why a query is slow, live. Right-click any query running in the activity monitor (or a captured one) and "Explain this query" shows its plan as a visual tree — costliest node highlighted — without copying it into the editor.
The performance suite now speaks MySQL. The visual EXPLAIN tree, one-click index boost, and the Top-queries tab — all Postgres-only until now — work on MySQL too, reading its own plan format and performance_schema.
The plan is read locally against your real query and never leaves your machine — only the AI index suggestion ever sees a redacted version.

v0.6.3

July 13, 2026

Trace watches for you

Trace can now warn you the moment something goes wrong — no need to stare at the monitor. Turn on "Alert me while Trace is recording" in Settings and Lily posts a native notification when a query runs too long or a new lock wait forms.
Set your own bar: choose how slow is "too slow", toggle block alerts, and optionally keep recording while Lily is in the background so you're warned even when you're in another app. A menu-bar item shows when a recorder is armed.
Private by design: an alert carries only the session, how long it ran, and the wait — never a row value or your query text. Click one to jump straight into Trace on the offending session.

v0.6.2

July 13, 2026

Trace remembers

Trace now has a real memory. Turn on "Remember Trace history on disk" in Settings and the timeline survives quitting Lily — reopen hours later and scrub back to what your database was doing at 3:47 AM, per connection.
Private by design: query text is redacted before anything is saved, so no row value ever touches the disk. Saved timelines expire after a day, and "Clear saved timeline" forgets it instantly.
Honest across restarts — samples loaded from disk are labeled "from a previous session", and the gap where Lily was closed is drawn on the timeline, so history never reads as if it were live.

v0.6.1

July 12, 2026

A quick fix

Fixed a crash on launch when the app ran in Portuguese. If you're coming from 0.5.0, everything new is in the 0.6.0 notes below.

v0.6.0

July 12, 2026

Meet Trace — see what your database is doing

Trace — arm the activity monitor and it gains a memory. Record the last minutes of what's running, then scrub the timeline back to the moment things slowed down. Captured queries stay in a list after they finish, with how long each one ran — no more watching a slow query flash by.
Top queries — queries that finish in under a second slip past the live sampler. The new Top tab reads pg_stat_statements, so your fast-but-frequent queries are there anyway, ranked by total time, with calls and mean duration.
See who's blocking whom — a live tree of the lock chain: the root blocker on top, the sessions waiting on it nested below, each with its wait time. Kill any of them right from the graph.
And Lily tells you why — right-click a slow or blocked session and the local AI explains the root cause in plain language, with one concrete fix (an index, a kill, a rewrite). Fully offline; your query text never leaves your machine.
Run a .sql file — the missing half of import. Pick a script or a dump, see how many statements and which destructive ones it contains, choose all-or-nothing or keep-going, and run it with a progress bar.
Wide import — bring in a CSV, TSV, or Excel (.xlsx) file, pick the sheet, and map each column to your table (with auto-match). Reads .xlsx natively, no extra tools.
Generate fake data — seed a table with realistic-but-fake rows, grounded in your schema and the PII scan: a government-id column gets a format-valid but fake CPF/CNPJ, foreign keys reference real parent rows, nothing invented leaves your machine.

v0.5.0

July 10, 2026

Understand, ask, and change your database with AI

A redesigned Understand screen — your database as a living constellation. Business sub-systems (Payments, Merchants, Products…) become luminous clusters you click to explore; the map is generated in your language now, not the schema's.
Recipe book — for each entity, Lily writes the everyday queries you actually run ("recent orders for a customer", "find by email"), parameterized and ready to open in the editor. It pre-warms your core entities in the background, so they're waiting when you look.
A living data dictionary — the Understanding now remembers the schema it documented. Change the schema and reopen it: a banner shows what's new, removed or altered, and "Update" re-documents only what changed instead of re-analyzing everything.
Change your schema with AI — right-click a table → "Change with AI…", describe a change ("add soft-delete", "make email unique") and get the forward DDL plus its exact rollback. Nothing runs until you open it in the editor and confirm; destructive changes are flagged.
A reload button (⌘R) in the sidebar re-introspects the database after a migration — new columns and tables show up without reconnecting.

v0.4.0

July 9, 2026

Find it, sort it, ship it safely

Semantic schema search — ask "where do we store refunds?" in the Understand screen and get the actual tables/columns ranked, each with a one-line reason. It searches your schema's meaning, not just names, and a click jumps straight to the table.
Blast-radius preview before every write — before an UPDATE/DELETE/TRUNCATE/DROP runs, Lily tells you roughly how many rows it hits and which tables it reaches by foreign key, without ever running the write. The scariest ones ask you to type the table name to confirm.
PII / sensitive-column scan — Lily flags columns that hold personal data (CPF/CNPJ, cards, emails…) using local format fingerprints, and automatically redacts them before any AI feature ever samples your rows. Your data never leaves for the fingerprinting.
Sort and filter results in place — click a column header to sort (numbers, dates and text handled correctly), and filter any column with real operators (>, <, contains, is empty…). No re-query; Export and Chart use exactly what you see.
Freeze columns — right-click a header → "Freeze up to this column" to keep the first columns pinned while the rest scroll sideways. Great for wide tables where you lose track of which row is which.
SSH tunnels now support password and key-passphrase auth (not just key/agent) — for the many corporate bastions that require a password. The secret is delivered securely and never touches the command line or disk.

v0.3.4

July 6, 2026

Safer, smarter, more polished

Read-only connections are now airtight — the guard understands EXPLAIN ANALYZE, data-modifying CTEs and every write path (kill query, create database, NOTIFY, Mongo/Redis writes), so nothing slips through on a connection you marked read-only.
Ask your data and Generate SQL now use your database understanding — once you've analyzed a database, the AI maps your words ("customers") to the real tables (even cryptic legacy names), so its queries are far more accurate.
Editing MongoDB documents no longer corrupts types — ObjectIds, dates and binary fields survive a save intact (proper Extended JSON), instead of turning into plain strings.
Full Português — the menu bar and dozens of remaining labels are now translated, and every window resizes cleanly so longer text never gets clipped.
Under the hood: a test suite + CI, a big internal cleanup, and VoiceOver labels across the toolbars.

v0.3.3

July 3, 2026

Fresh look & big-database understanding

Redesigned connections screen — each card now carries its engine's own color and icon, with a soft glow on hover. Prettier and easier to scan at a glance.
Understand this database now handles large production schemas — it analyzes tables in batches, saves as it goes, shows real progress, and can resume if interrupted (no more timeouts).
You can now support Lily DB — a small heart in the header opens a page to sponsor the project. Lily stays free; if it helps you, a donation keeps it growing.

v0.3.2

July 3, 2026

Correct data for every column type

Array columns now show their values (e.g. {1,2,3} and even nested {{1,2},{3,4}}) instead of a <TEXT[]> placeholder — Postgres, plus proper quoting and NULLs.
Many more Postgres types render correctly: inet/cidr (with IPv6 :: compression), interval, time-with-zone, ranges, bit, macaddr, point, and JSON/bytea inside arrays.
MySQL BIT and binary columns (BLOB/BINARY) no longer show garbage — BIT shows its number, binaries show hex. SQLite blobs show hex too.
Hardened the type decoders against corrupt data so a bad value can never crash the app — audited across every engine.

v0.3.1

July 1, 2026

Understand fixed & data correctness

Understand this database now actually works — a JSON decoding bug made it always fail with "couldn't analyze". It's also ~2.5× faster, can't hang forever (clear timeout), tolerates incomplete AI replies, and never hides an entity from the flow.
Fixed numeric columns showing garbage instead of the value (and a crash on very large numbers). Dates, OIDs, money, time and bytea now render correctly too.
AI CLI stability — the runner no longer hangs if the CLI leaves a child process behind, and a verbose shell startup can't wedge the app.
Result grid — few-column tables fill the width and start from the top again, and dragging a column border now tracks the cursor precisely.

v0.3.0

June 30, 2026

Understand any database with AI

Understand this database — the headline feature. Instead of just drawing tables, Lily's AI reads your schema and explains the business behind it: it maps cryptic legacy names (tb_usr → Customers, tb_ord_hdr → Orders), detects the domain, and shows the flow in plain language — even when there are no foreign keys. Open it from the ✨ in the schema sidebar.
Bulk copy as INSERT — select multiple result rows (click, ⇧-click, ⌘-click) and right-click to copy them all as a SQL INSERT, TablePlus style. Works in query results and table data.
Editor fixes — the SQL editor no longer eats single quotes, and autocomplete stopped picking words you didn't want: it only suggests now, never replaces your text until you choose.
Remembers your database — reopening the app puts you back on the database you were last using, instead of snapping to the first one (Postgres / MySQL / Trino).
Polish — tables with few columns now fill the width nicely, accurate row counts on un-analyzed Postgres tables, and tooltips on every toolbar icon.

v0.2.10

June 17, 2026

Ask your data — crash fix

Fixed a crash when starting an AI action (Ask your data, Explain, Optimize…) on machines whose shell startup prints a banner — the AI CLI is now resolved safely.

v0.2.9

June 17, 2026

Ask your data

Ask your data (⇧⌘A) — ask a question in plain language and Lily DB reads your schema, writes the SQL, runs it, and answers you directly. No SQL required.
It's a conversation — follow-up questions refine the previous answer, so you can drill into your data one question at a time.
Full transparency — every answer shows the exact query it ran and a preview of the rows; open the SQL in the editor with one click to tweak it.
Runs on your local AI CLI (claude / codex) — no API key, no data leaving your machine.

v0.2.8

June 17, 2026

ClickHouse & admin tools

ClickHouse support — connect to a ClickHouse cluster over its HTTP interface and run blazing-fast analytical queries. That makes 7 engines in one native app.
Activity monitor — see the queries running right now and kill a stuck one (Postgres / MySQL / ClickHouse), from the database sidebar.
Object browser — the sidebar now lists functions, procedures, triggers and sequences under each schema; click one to view its definition.
Visual EXPLAIN — see the query plan as a tree with cost bars and the bottleneck node highlighted, instead of plain text (Postgres).
Query library (⌘B) — keep your saved queries in folders and open any one in a click. Your reusable queries, finally in one browsable place.

v0.2.7

June 16, 2026

Productivity boost

Query history browser — search everything you've run, preview it, copy or re-open in the editor (⌘Y). Save any past query straight to favorites.
Result grid power — quick-filter any column from its header, select rows (click / ⇧ / ⌘), navigate by keyboard (arrows, ⌘A, ⌘C), and copy or export just the selected rows.
Multiple result sets now open as tabs — run a script with several SELECTs and switch between each result.
Organize favorites into folders with search, and create your own Tab-expanded SQL snippets in Settings.
Export results as SQL INSERT statements — handy for moving data between databases.

v0.2.6

June 16, 2026

Deeper checks & polish

Health Check catches more: secrets stored in plaintext (password / api_key columns in text types), tables missing created_at / updated_at, and foreign keys left on the default ON DELETE behavior.
Filter findings by severity — tap a count chip to focus on just the critical issues, and Copy report exports everything (with fixes) plus the AI review as Markdown.
Editing a connection now opens straight to its form instead of asking you to pick the engine again.
Connection cards: the Connect button moved to its own row so it no longer squeezes the engine/environment tags.

v0.2.5

June 16, 2026

Security check-up

Health Check now flags missing Row-Level Security — critical on API-exposed databases (Supabase/PostgREST), where a table without RLS is readable & writable by anyone. Comes with a ready-to-run ALTER TABLE … ENABLE ROW LEVEL SECURITY fix.
Catches tables granted to PUBLIC (every role, including unauthenticated) — so over-permissive access stops hiding in plain sight.
Flags unused indexes (never touched by the planner) as drop candidates — and stays quiet on fresh databases where the stats aren't meaningful yet, so no false alarms.

v0.2.4

June 16, 2026

Trino & auto-update

Trino support — connect to a Trino cluster over its HTTP protocol, browse catalogs/schemas/tables, and run federated SQL. Catalogs work like the database switcher.
Automatic updates — Lily DB now updates itself. Toggle it under Settings → Updates, or use Check for Updates… in the app menu. No more re-downloading by hand.
Sharper Health Check — the 'probable missing foreign key' rule now only fires when a real target table exists, cutting false positives dramatically.

v0.2.3

June 5, 2026

Say hello to Lily DB

New name & look — Cortex DB is now Lily DB, with a fresh app icon. Same app, your saved connections and settings are untouched.
Health Check — one click audits your database for real issues: missing primary keys, unindexed foreign keys, redundant indexes, oversized tables and more, each with a ready-to-run fix.
AI architecture review runs automatically after the audit — prioritized advice on indexing, modeling, scaling and security, in plain language (local CLI, no API key).
Works across engines — Postgres/MySQL/SQLite check schema & indexes; Redis checks TTLs, big keys & memory policy; MongoDB checks indexes & document size.

v0.2.2

June 2, 2026

Productivity & safety

Read-only connections — flag a connection read-only and the app hard-blocks UPDATE/DELETE/INSERT/DROP before they run, with a READ-ONLY badge in the editor.
Aggregation footer — click any column header in a result to see count, sum, avg, min, max & nulls (or distinct count for text columns) over the loaded rows.
Summarize a result with AI — get plain-English insights, patterns, outliers and data-quality flags for the current result set.
Favorite tables — star the tables you use most and they pin to a Favorites section at the top of the sidebar, per connection.
Paste a connection URL — drop a postgres:// / mysql:// / mongodb:// / redis:// string on the form and it fills itself in.
Pin & reorder tabs — keep the tabs that matter pinned, and drag to reorder them.
SQL snippets — type a trigger and press Tab to expand common statements; copy any table as a SELECT / INSERT / UPDATE skeleton from its context menu.
Semantic cell coloring — numbers, dates, booleans, NULLs and JSON get subtle color hints in the grid.
Query drafts persist per connection between launches, and ⌘+ / ⌘- / ⌘0 zoom the SQL editor. Optional format-on-run in Settings.

v0.2.1

June 1, 2026

Performance & footprint

Schema cache — when you re-open a connection the sidebar paints instantly from disk while a fresh fetch runs in the background.
Query result cap (default 50k rows, configurable in Settings) keeps a runaway SELECT from blowing up memory; the result tells you when it was trimmed.
Per-statement timing breakdown when a script has more than one statement — e.g. 3 statements · 12ms / 800ms / 4ms.

v0.2.0

June 1, 2026

Schema tools

Export a whole schema as SQL — CREATE TABLE for every table, optionally with INSERTs for the data.
Diff a schema between two open connections — added / removed tables, plus per-table column additions, deletions and type/nullability changes.
Generate sync DDL — CREATE TABLE and ADD COLUMN for what's missing on the target; destructive changes (DROP, type change) are listed as comments for manual review.

v0.1.12

June 1, 2026

Multi-database

Switch databases on the same server without opening a new connection — a database pill appears under the connection name in the sidebar.
Postgres & MySQL — pick from every database on the instance, or create a new one right there.
Redis — jump between the 16 numbered databases with a single SELECT (no reconnect).
SQLite — open another .sqlite file in the same workspace.
The Database field on the connection form is now optional — leave it blank and pick from the switcher after connecting.

v0.1.11

May 29, 2026

Polish & finishing touches

Tighter connection screen — close button (⎋), card top bar finally respects the rounded borders & tilts with hover, a Connect → pill appears on hover, and each card shows when it was last opened.
Snappier UI — the Aurora background throttles to ~10fps when the app loses focus (much lighter CPU/battery), and sidebars show shimmering skeleton rows while they load.
Smarter data grids — numeric columns are right-aligned with monospaced digits, NULL shows as a subtle ⌀, ⌘F highlights matches inside cells with ↑↓ to jump between them, column widths now use real text measurement, and rows highlight on hover.
Beautiful AI results — table docs / explain / optimize now render Markdown (headings, lists, code blocks, **bold** & `code`).
Clearer feedback — pretty elapsed times (<1ms · 1.4ms · 234ms · 1.2s), failed queries shown as a clean card with Copy error / Fix with AI, tooltips include the keyboard shortcut, and the window title shows the focused connection.
Mongo helpers — six aggregation pipeline templates (match+sort+limit, group+count, sum/avg, lookup+project, count distinct, date histogram) in a Templates menu.

v0.1.10

May 29, 2026

Looking sharp

JSON syntax-highlighted everywhere — cell inspector, Mongo docs, Redis values, and a native JSON code editor for the Mongo document & aggregation pipeline editors.
Connection manager shows folder hierarchy — grouped connections are indented with a vertical guide.
Tabs now show a dirty dot when there are unsaved edits, a spinner while a query runs, and an accent underline on the selected tab.
Edited cells have a richer glow; the grid pulses green when a commit succeeds. Rows highlight on hover.
Context menus across the app got SF Symbols — everything's a bit easier to scan.

v0.1.9

May 27, 2026

Safe & smart

Production guardrails — confirm before UPDATE/DELETE with no WHERE, or any write on a production connection.
Query parameters — fill in :name placeholders before running.
Run in a transaction — BEGIN/COMMIT with rollback on error; inline edits now commit atomically.
Document a table with AI — generate Markdown docs from its schema.