Features the pig is genuinely proud of

workspace✓ functional

Tabs that come back

Every query lives in its own tab with its own server and database context. Close SQLly, reopen it, and your whole workspace - open tabs, query text, layout - is exactly where you left it.

crash-safe session restore

execution✓ functional

Run it all, run the selection, cancel anytime

Execute the whole document or just the highlighted statement, with proper cancellation that actually stops the server-side query. Multiple result sets land as separate grids, with a messages pane for errors, PRINT output, and timings.

formatter✓ functional

A SQL formatter that can’t hurt your SQL

Configurable pretty-printing with a hard safety contract: the output is re-lexed and compared token-by-token against your input, and any mismatch returns your SQL untouched. Mark regions -- formatter:off / -- formatter:on to leave them verbatim.

never drops a comment or mangles a literal

execution plans◐ in progress

Query plans in human terms, by default

Hit Explain (or ⌘L) and SQLly captures the SHOWPLAN_XML, parses it in-process, and opens the Execution Plan pane right next to your results. Instead of a tree of operators, it leads with plain-language findings ranked by how much of the query’s cost they explain - the elements actually driving performance, each with its fix attached:

-- the plan pane, no EXPLAIN decoder ring required
● Add an index on dbo.Orders (CustomerId)  - optimizer estimates ~93% improvement
● Scans every row in dbo.Orders (48.2K rows) to find matches
● Estimated 10 rows but read 48.2K  - run UPDATE STATISTICS

Every finding says what’s wrong, why it matters, and what to do next - missing indexes come with a ready-to-adapt CREATE NONCLUSTERED INDEX skeleton, key columns and INCLUDEs filled in. Implicit conversions that quietly block seeks, joins missing their ON clause, tempdb spills, and (on actual plans) estimates that diverged wildly from reality get the same treatment. Below the findings, operators list most-expensive-first - “Nested Loops - 8,210 rows estimated, 75% of cost” - while node ids, cost figures, and output lists stay one expansion away.

Actual plans - captured by running the query, with real row counts - are the dependable path today. The no-execution estimated plan toggle is in the toolbar but currently has a capture bug on SQL Server that’s being fixed. Multi-statement batches get a per-statement switcher, clean plans say so explicitly, and the graphical node-and-edge canvas is the piece still being drawn.

SQL Server & Azure SQL

value autocomplete✓ functional

Autocomplete for column values

IntelliSense doesn’t stop at schema matches. In a WHERE clause, hit Shift+Ctrl+Space and SQLly completes straight from your table’s actual data.

-- explicit gesture, live values
WHERE Name = 'Acme␣'  ⟶ Acme Corp, Acme Labs…

Behind the scenes it fetches the top 100 distinct values for the column, caches them, and quotes them correctly for the column’s type. Strictly opt-in, so normal typing never waits on the database.

fully configurable

introspection○ planned

Auto-magic string documentation

See a magic string or mystery code in your results? When SQLly can trace it through DDL introspection, it drops an inline comment explaining exactly where that value comes from.

SELECT status /* ← enum: orders.status_id → status_codes.code */

multi-modal schema source✓ functional

Multi-modal schema source

Start with your live database as the source of truth, then layer reality on top of it:

• Real-time local file overlay - a killer feature if you do Git-based schema management.
• SQLly compares the DB object’s last-modification time (where your engine supports it) against your local files.
• Got a newer local file? It swaps that file in for the live table, view, sproc, function, or query.

The query still fails if you run it before the schema catches up - but you get to build against the future, today. A huge time-saver when you work on checked-in DDL.

incomplete-model intellisense✓ functional

Incomplete-model IntelliSense

Working from a rough sketch? SQLly reads “general vibes” DDL - not technically valid, but clearly headed somewhere - and overlays its best guess on top of your real schema.

That means IntelliSense for column names, keys, indexes, and data types even before the model is finished and valid - tracked internally as an incomplete region with its own provenance and confidence, never silently passed off as authoritative.

git-aware○ planned

Git modification times & live DDL blame

The overlay isn’t limited to local filesystem timestamps - SQLly applies Git modification times too, so the right version wins.

And it gives you live DB DDL git blame with notes: hover any object and see who changed it, when, and why.

key ↔ name○ planned

Swap key lookup for name lookup

Hunting for a value that lives behind a foreign key? Just type the name you’re after. SQLly adds the join on the fly and lets you check against the readable value directly - no manual JOIN gymnastics.

fk display values◐ in progress

Smart foreign-key display values

SQLly uses DDL introspection to figure out the most likely human-friendly display value for each foreign key. In the row editor, foreign-key fields already offer searchable dropdowns of the real referenced values; showing those friendly names directly in the result grid is the piece in flight.

wildly configurable

comment-based✓ functional

Output pivot & result pivoting

Pivot your output with a comment. No wizard, no separate pivot tool - annotate the query and SQLly reshapes rows into columns right in the result grid.

--! pivot rows=region cols=quarter value=revenue

comment-based✓ functional

Custom result layouts

Stop reading result sets stacked one after another. Define configurable rows and columns for your results, so multiple sets land in a layout that actually makes sense - -- sqlly 4x2 and you’re done.

DDL-driven✓ functional

Dynamic data forms - the row editor

Right-click any result row and SQLly generates a per-column edit form from the table’s own metadata - data types, defaults, and constraints included - so you can view and edit your data without writing a line of UI.

• Edit, insert, duplicate, and delete rows with guarded, parameterized writes.
• Foreign-key fields get searchable dropdowns of the real referenced values.
• CHECK constraints are validated before the save ever leaves the app.
• Related rows one click away, opened in their own tab.

where we’re going, we don’t need applications 🚗⚡

comment-based◐ in progress

Custom data types & formatting

Date formats, number formats, rounding - driven by comments so they reapply on every run. The parsing and per-column formatting are in; the UI that rewrites the comments for you is still being wired.

--: amount  money  round=2
--: created date   'yyyy-MM-dd'

export✓ functional

Export every which way

Copy or save any result set as CSV, TSV, JSON, Markdown, HTML, XML, SQL INSERT, temp-table SQL, or VALUES - or straight to a real .xlsx workbook that opens as a formatted Excel table with banded rows and an auto-filter header.

mutation review✓ functional

Refuse an UPDATE or DELETE with no WHERE

SQLly scans every batch before it runs - masking strings and comments so keywords inside literals don’t false-positive - and flags UPDATE/DELETE statements with no WHERE clause. Per-connection policy can block them outright.

DELETE FROM orders  ⟶ ⚠ affects every row

environment cues✓ functional

Color prod an angry red

Custom colors and icons per client, project, environment, or server - so the “wait, that was prod?” moment gets intercepted by your peripheral vision before it reaches your fingers.

ai review◐ in progress

AI review for data-changing queries

Require a generated, plain-language review of a query’s side effects before it can run in a protected context. The detection, gating, and review dialog are in - including the big, explicit WE WILL MAKE UPDATE AND DELETE CHANGES. warning; the on-device model that writes the explanation is being wired up.

connect gate◐ in progress

Verify your identity to connect

Require your OS-native identity check (Touch ID, Windows Hello, or your platform’s equivalent) before SQLly will even open a connection. Set it at any level of your hierarchy - lock down a single touchy server or an entire client’s prod environment in one switch.

# inherits down the tree, override anywhere
client:    Acme Corp   identity=connect
env:       prod        identity=connect
server:    db-01.prod  identity=inherit

per client · project · env · server · database

write gate◐ in progress

Identity check for anything but a SELECT

Reads stay frictionless. The moment a statement isn’t a plain SELECT - an INSERT, UPDATE, DELETE, DROP, TRUNCATE, DDL, anything with teeth - SQLly asks you to verify your identity first. The statement classification that decides what has teeth already works; the OS-native prompt is the in-flight piece.

SELECT * FROM orders        ✓ runs
UPDATE orders SET …         ☝ identity check required

read-free, write-guarded

inheritance◐ in progress

Set it once, inherit it everywhere

Identity rules ride the same multi-dimensional hierarchy as everything else. Set a rule on a client and every project, environment, and server underneath picks it up - until you deliberately override a branch.

Lock all of prod with one switch; carve out a single read-replica as the exception. No copy-pasting policy across fifty connections.

audit trail○ planned

Tamper-evident verification log

Every gated action records who verified, what statement, which target, and when - a local, tamper-evident audit trail you can point at when someone asks “who ran that against prod?”

stays on device unless you export it

graceful fallback○ planned

Watchdog & passcode fallback

No biometric hardware, or a sensor that won’t cooperate? SQLly falls back to your device passcode or OS account sign-in, so a gate is never a lockout, just a deliberate pause.

Pair it with statement classification: SQLly shows you exactly why a prompt fired before you approve it.

multi-dimensional grouping✓ functional

Server multi-dimensional grouping

A database is any combination of the things below - and at each level you can define your own customizations: security rules, icons, colors, and fuck-up protections that stop the “wait, that was prod?” moment.

• Client
• Project
• Environment
• Server

Color prod an angry red, lock it behind a confirmation, give each client their own icon - whatever keeps you safe and fast.

rust engine✓ functional

Dedicated Rust query & IntelliSense engine

IntelliSense and querying are driven by a dedicated, multithreaded, heavily-tested Rust engine - not a bolted-on afterthought.

• No long schema updates stalling you mid-thought.
• Advanced caching keeps everything instant.
• On-the-fly intelligent cache invalidation - fresh when it needs to be, fast the rest of the time.

remote access◐ in progress

Reach your database from anywhere

Connect to your databases from wherever you are - no VPN scavenger hunt, no jump-box ritual. An end-to-end encrypted tunnel runs through a relay that can route your traffic but never read it - here’s exactly how it works.

part of SQLly Cloud · included with Lifetime · direct connections stay free

private by design✓ functional

No check-ins, period

SQLly doesn’t phone home - there is no telemetry in the app today, full stop. If opt-in check-ins ever arrive, the privacy policy gets updated first, they ship off by default, and they’d only ever be used to help improve the product. Your data and your habits stay yours.

cross-platform✓ functional

macOS, Windows & Linux from one tree

A GPU-rendered native UI on all three desktop platforms - not a webview in a trench coat. Same engine, same features, same pig.

macOS builds target Apple Silicon (M-series)

wasm◇ in-tab demo

SQLLY browser preview (in-tab demo)

A labeled preview of the workbench compiles to WebAssembly and runs in your tab against a sample database. It is not a hosted Cloud app and cannot reach your servers, relay, or production SQL Server. Cloud AI, Azure sign-in, and local files stay native-only; download the desktop app for the real product.

demo only - not a Cloud SKU

iCloud Drive○ planned

Everything comes with you

Switch it on and your whole SQLly world follows you to every Mac you own - credentials, configuration, and customization, all carried by Apple’s sync, not ours. Sit down at another Mac and it’s already set up exactly how you left it. We never see your data.

Preferences○ planned

On when you say so, off when you don’t

A single toggle in Preferences → iCloud. Enable it to sync, disable it to keep everything strictly local. Off doesn’t mean half-on - flip it off and the files never leave the machine.

// Preferences → iCloud
Sync via iCloud Drive   [ off ]
↳ stores everything locally only