These are the actual workspace tabs shipped in Calíope — not a marketing tour.
Every one is native SwiftUI, works on macOS, iPad and iPhone, and opens as a dedicated tab you can pin, reorder or close.
Twenty-seven of them sit in the tool navigator; Table Builder and Visual EXPLAIN open in context from Catalogs and the SQL Editor.
A MongoDB session brings six more, listed below.
SQL Editor
Schema-aware autocomplete, SQL linter, formatter and multi-statement Player that runs the whole script or steps through it one query at a time.
The whole SQL Editor in twelve minutes: write, run, browse the schema, read the results, change data safely and analyse a query.
Run, stop and repeat
The schema, right there
Write with help
Edit like an IDE
The results grid
Take the result with you
Two databases at once
Change the data safely
Chart, terminal, map and history
Analyze a query
Spatial data, and that is the tour
Dashboard
Live server pulse: Threads_connected, QPS, InnoDB buffer pool hit rate, uptime and slow queries per second, polled at your chosen interval.
The Dashboard in two minutes: live metrics, where the load is going, your own layout and TV mode.
A server, live
Where it is going
Arrange it your way
Alerts and TV mode
AI Assistant
Plain-English prompts against the active database's schema. Apple Intelligence and Ollama need no key at all; the cloud providers take your own. Only metadata leaves the app — never rows or credentials.
The AI Assistant in a little over four minutes: a question in plain words answered by Apple Intelligence on the Mac itself, with its SQL in a panel and the notice to verify it; copying the answer or taking the SQL to the SQL Editor and running it; a follow-up question; the five providers, the empty key field of a cloud one and demo mode, and Ollama answering from the same Mac; the schema switch; the history with its search, its menu, iCloud sync and export; and dictation. No question leaves the Mac.
Ask in plain words
Copy it, or take it to the editor
Providers, keys and the schema
History, iCloud and export
Dictate the question
Catalogs
Full database → table → column tree with dedicated tabs for indexes, foreign keys, views, routines, triggers and events.
Catalogs in under three minutes: what a database is made of, the create buttons, the five editors and filling a new table.
What a database is made of
Create anything
Five editors, one per kind
Fill it, and edit what is there
Query Builder
Visual constructor: drag tables to a canvas, pick columns and WHERE conditions, and watch the SQL preview update as you build.
The Query Builder in just over four minutes: adding tables and letting the foreign keys write the JOINs, choosing columns and aliases, conditions with the outer JOIN warning and Move to ON, the table list, Insert into editor and running the result, and the WHERE builder from the schema tree.
Tables on the canvas
Filter with conditions
The table list
From the builder to the editor
The WHERE builder
Server information
Global and session variables, live status counters and HDD usage — all browseable in one panel with a filter box on top of every list.
Server Information in under two minutes: what identifies the server, every variable and status counter with its filter, which tables take the disk in HDD Usage, and auto-refresh and Export.
Who the server is
Every variable and counter
What takes the disk
Refresh and export
Process list
Running threads with filters, guided KILL QUERY / KILL CONNECTION and bulk kill of idle or busy sessions — with confirmation before every destructive action.
Processes in under two minutes: every connection to the server as it happens, how to stop a single query with a right-click, and how Idle > and Active > clear many at once without touching the server’s own threads.
Every connection, live
Stop one query
Many at once
SQL alerts
Custom health checks: define SQL probes, thresholds and operators, and get alerted when a metric crosses the line — long before your dashboard notices.
SQL alerts in about three minutes: a ready-made rule from Load example, two rules of your own written in Configure —one compares a number, the other text—, a query with a typo flagged Error with the server’s answer, the rules watching on their own with Auto-refresh until they cross into ALERT, and a rule deleted.
Start from an example
Write your own rule
Let it watch on its own
Delete and export
Backup
Granular selection of databases, tables, views and routines, and restore from a .sql or .sql.gz file. Scheduler (daily, weekly, weekdays, monthly or every N hours) with retention rules, on-demand presets and optional gzip compression.
Backup in four minutes: a scratch database picked in the schema tree, with the quick selections and the server users; the options, compression and Create Backup with its log; the database dropped and brought back with Restore, preview and confirmation included; and a preset saved for on-demand runs next to the editor of a scheduled backup.
Pick what to back up
Options and Create Backup
Restore from a file
Presets and scheduled backups
User admin
Create and modify users, manage grants by scope and switch auth plugins — no more hand-writing GRANT / REVOKE by memory. Identifiers escaped end-to-end.
User admin in under five minutes: an account created with New user, its privileges granted by database, table and routine with Save changes, a statement the server rejects and how it is reported; the password, the lock and the hourly limits read back from the server; and a system account that cannot be deleted next to one that is.
Create an account
Grant privileges
Password, lock and limits
Delete an account
Table maintenance
Run CHECK, REPAIR, OPTIMIZE, ANALYZE and CHECKSUM across a multi-selection on MySQL and MariaDB; on PostgreSQL, ANALYZE and VACUUM + REINDEX; on SQL Server, UPDATE STATISTICS, DBCC CHECKTABLE and index rebuilds, with progress and per-table error reporting.
Table maintenance in under four minutes: demo's seven tables picked in the schema tree, with its filter and Search all; ANALYZE, CHECK, OPTIMIZE with the note InnoDB answers, and CHECKSUM, one row per table and message; the modifiers each operation accepts, QUICK and FOR UPGRADE among them; and REPAIR with LOCAL and USE_FRM on a scratch database, where a warning and a note stand out.
Pick the tables
Run an operation
Modifiers
Repair a table
Data migration
Copy tables, views, triggers, events and stored procedures to another server, or into another database on the same one — without mysqldump | mysql.
Data Migration in three minutes: eleven objects of sakila picked in the schema tree — the film tables, the view built on them and their three triggers —, the SQL previewed without a destination, then Into database, the connection, Export data and Migrate, with one log line per object; and the copy checked in the tree, run again safely and disconnected.
Pick what to copy
Preview the SQL
Connect and migrate
Check the copy
ER Diagram
Interactive relational diagram with draggable tables, editable foreign keys and PNG / PDF export. Understand a legacy schema in thirty seconds.
The ER Diagram in under two and a half minutes: the schema drawn from its own foreign keys, the zoom, the two things a right-click gives you, and a second database on the same canvas.
The schema, drawn
Zoom, pan, tidy up
Right-click any table
Keep it, and take it with you
Two databases on one canvas
Schema diff
Compare two schemas side by side and generate the ALTER script that reconciles them. Sync staging with production without hand-writing migrations.
Schema Diff in just over three minutes: an empty copy of sakila built from the script that Compare writes, pasted into the SQL Editor and run with Run Script, then compared again until it comes out identical; after that, a copy that has drifted, with its modified, dropped and new objects, Changes only, the Copy SQL of each row, and the DDL History that recorded every change.
Pick the two databases
Build a copy from the script
Compare again
Read the differences
Apply it and check the DDL History
Replication monitor
Replica state, replication lag and binlog coordinates, refreshed in real time — spot a stalled replica and read its error without SSHing into the box.
The Replication Monitor in about three minutes: a replica read card by card —IO and SQL threads, lag, source server and binary log position—; changes on the primary followed into the full status; lag made to climb with a delay on the server; a duplicate row that stops the SQL thread, with its error and a still snapshot; and a primary, which is not a replica.
Read one replica
Follow the primary
Watch the lag
When replication stops
On a server that is not a replica
Binlog viewer
Read and filter binary log events without shelling into the server. Follow row-level changes, transactions and GTIDs from macOS, iPad or iPhone.
The Binary Log in about two minutes: the newest file and its header; a table created, filled, changed and dropped, event by event, with DDL, DML and System told apart; the Type filter and the search; and a big file read from its first events, with the limit that reads further.
Open the newest file
Changes as they arrive
Filter by type and text
Big files and the limit
Snippets
Reusable SQL library grouped by engine (MariaDB / MySQL / PostgreSQL / SQL Server) with one-shot seeding of built-in defaults per engine. Categorized, searchable, and synced across every Mac, iPad and iPhone on your Apple ID.
Snippets in under two and a half minutes: the samples it brings for each engine, searching titles and SQL, creating a snippet with its category and engines, editing and saving it, deleting with confirmation and bringing the samples back, and inserting one from the SQL Editor.
Your SQL library
Create a snippet
Edit and save
Delete, and bring the samples back
Use one in the SQL Editor
Query log
Persistent history of every executed query in local SQLite — searchable, filterable, exportable, and with opt-in iCloud sync.
The SQL Log in just over two minutes: every query you run, from every connection, kept in one file; filtering it by connection, result, text and session; the detail of a single row; and emptying it with Clear.
Every query, kept
One log for every connection
Filter and search
A row up close
The file, and purging it
Server health monitor
A history of your servers’ metrics —connections, queries per second, cache hit rate, running statements, network and DML— kept on a server you choose and collected in the background while Calíope is open.
The Health Monitor in about three and a half minutes: five minutes of history from a replica under load, chart by chart; the range, the engine status and auto-refresh; Monitoring Setup with the storage server, a second server added with its alias and interval, the health thresholds and the retention; and the charts moved, hidden and put back with Reset layout.
Read the charts
Set up the history
Watch another server
Arrange the charts
SQLite Editor
Open and edit local SQLite files with no server: structure designer, data grid, Execute SQL with highlighting and autocompletion, editable pragmas, Save/Revert transactions and CSV/JSON/SQL import-export. Unencrypted databases only.
Download the sample database — 80 MB of SQLite: two related tables, about 1,500 products and their real PNG photos, with indexes, a foreign key and a view. The text is in Spanish, with accents, emoji and other alphabets, and some values are deliberately NULL.
The SQLite Editor in five and a half minutes, with no server: opening a file, the structure with its designer for tables and columns, the data grid with sorting, search, filters, editing in place, NULL, the advanced editor for JSON and images, and adding and deleting rows; Execute SQL with its suggestions; saving or reverting the pending changes; importing a CSV; pragmas and maintenance; and a file that is read-only on disk. Every file in it is a demo file the video created.
A local SQLite file, without a server
Open a database
Structure
Browse and edit data
Execute SQL
Save or revert
Import and export
Pragmas and maintenance
Close, recents and read-only files
DuckDB Editor
Open local DuckDB files with no server: schema tree with sequences, types and macros, data grid, Execute SQL with row cap and Stop, settings, CSV/Parquet/JSON query over files in place, whole-database export and import, and attaching another database read-only.
Download the sample database — 3.8 MB, made with Calíope on DuckDB v1.5.5: a small shop with customers, products, 50,000 orders and their lines, plus a view, an index, a sequence, an ENUM, two macros and a second schema.
The DuckDB Editor in six minutes, with no server: opening a file, the structure with its sequences, types and macros, attaching another database read-only, the data grid with sorting, search, filters, editing and rows; saving or reverting; Summary, Execute SQL with a macro, Stop and the extensions it won't download; importing a CSV with its own types, exporting and importing the whole database as Parquet; querying a JSON and a Parquet file in place from a database in memory, and Save As…; settings and maintenance; and a file that is read-only on disk. Every file in it is a demo file the video created.
A local DuckDB file, without a server
Open a database
Structure
Browse and edit data
Save or revert
Execute SQL
Import and export
Query data files
Settings and maintenance
Close, recents and read-only files
File Previewer
Read-only viewer for .md, .sql, .json, .csv, .rtf and .log: rendered Markdown, highlighted SQL, re-indented JSON, CSV as a table, RTF as a document. Refreshes when the file changes on disk — and never runs anything.
The File Previewer in three minutes, with no server: opening a file, Markdown and rich text read as documents, SQL highlighted and with no run button, JSON folded and unfolded, a CSV as a table and a log as it is; searching inside the file; the view refreshing when the file changes on disk, and saying so when it disappears; and the recent files. Every file in it is a demo file the video created.
A viewer for local files
Open a file
Markdown
Rich text
SQL
JSON, CSV and plain text
Search inside the file
Auto-refresh
Recent files and Quick Look
Error log
What has gone wrong in the app, with its date, its device and what to do about it. Works offline.
The Error log in about four minutes: why a statement the server rejects stays in the editor and not here; the log turned off; three connection profiles that fail for three different reasons and a restore that stops halfway, each arriving as it happens; filtering by severity, area and profile, and searching; the full detail and the Help topic behind View solution; and export, clear and iCloud sync.
What goes in the log
Failures as they happen
Filter and search
The detail and its solution
Export, clear and iCloud
Global search and replace
Find text across every text column of a database and replace it in bulk, seeing how each row will look before anything is written.
Global search and replace in under four minutes: sakila's tables picked in the schema tree with the cost of the scan in view, a search for drama that finds 213 rows and warns that the replace would change none, Match case, a column locked with its reason, and a replace of Drama with Theatre on a copy, reviewed row by row, with View script and the rows changed checked against the rows announced.
Pick the database and tables
Find text
Columns that cannot be replaced
Review and replace
Reports
Save a query with its parameters and a defined output. The same report gives the same result, run after run, by hand or on a schedule.
Reports in about five minutes: a saved report run with its declared columns; parameters with their defaults, a value that isn’t one, and a new marker declared from the query; the output with its own title, a footer and a chart; a script with a temporary table, and the write to a real table it refuses; the export formats; a schedule and its limit; and the history of every run.
Run a saved report
Parameters
The defined output
Prepare before reading
Export
Schedule a report
Run history
Replication topology
Declare which machine is the primary and which are the replicas, and see the whole group at once: binlog and position up top, and a row per replica with its lag, its two threads and its GTID drift.
Replication Topology in about four minutes: a whole group at a glance —diagram, primary, one row per replica, and when it was measured—; one member in detail, with Next and Previous; a replica with its IO thread stopped, where lag says No reading and the GTID drift counts the three transactions it is missing; and a group declared wrong on purpose, which the tool contradicts instead of correcting.
The whole group at a glance
One member in detail
Why lag isn’t enough
Declare a group
Slow query log
What the server itself recorded about the queries that went over its threshold — from every client, not just this one. The settings up front, because a log that is off has nothing to show and an empty list does not say which of the two it is.
The Slow Queries tool in under four minutes: what the server says about its own log and how to change it from here; every slow execution from every client, with its full detail; sending one to the SQL Editor to profile it; and the per-statement summary, where queries that differ only in their values are one row.
What the server records
Every slow execution
From the log to the Profiler
By statement
Two more contextual tools — Table Builder (visual create/alter) and Visual EXPLAIN (query plan viewer) — open in-line from Catalogs and the SQL Editor.
The Table Builder in just over five minutes: opening it from Catalogs; columns with their types, constraints and defaults; indexes and foreign keys; the table options; creating the table from the SQL Preview; and changing it afterwards, where every edit becomes an ALTER TABLE.
Open the Table Builder
Define the columns
Indexes
Foreign keys
Table options
Create the table
Change an existing table
Every session starts in the Connection Manager: saved servers, groups, SSL/TLS and SSH tunnels, and the button that opens the workspace.
The Connection Manager in five minutes: the saved servers and the filter; a new profile with its alternate host, auto-reconnect and SSL/TLS; an SSH tunnel with password or private key; the four families with their default ports, and products, with the server correcting a profile that says MySQL; groups; clone and delete, each after a question that names what goes; and a failed test, then Connect, a second server at once, and Disconnect.
Your saved servers
Create a profile
SSH tunnel
Families and products
Groups
Clone and delete
Connect, and several servers at once
Document databases
And six more, when the session is MongoDB.
A MongoDB connection opens its own set of tabs — there is no SQL editor, no ER diagram and no binlog in a document database, so pretending otherwise would only produce empty screens. Every value shows its type, because in a schemaless collection two neighbouring documents may share no field at all.
MongoDB collections
Browse databases, collections and documents, and edit them as JSON.
The MongoDB collections browser in under three minutes: switching database and filtering collections, documents as trees with the type of every value, subdocuments and arrays, binary data, counting and loading more, a new document written as extended JSON and checked by Format, editing and deleting it, and the read-only views and capped collections. It writes only to a collection the video created and removed.
Databases and collections
Documents as trees
Counting and loading more
New, edit and delete
Views and capped collections
MongoDB query
Filter documents or run an aggregation pipeline.
The MongoDB query tool in under three minutes: picking a collection, a filter with projection and sort, results as trees with their count and time, batches of 50 and Load more, dates and ObjectIds written as extended JSON, aggregation pipelines with $match, $group and a $lookup join, and what happens when a query is wrong. It only reads: nothing on the server changes.
Find: filter, projection and sort
Batches and Load more
Dates and ObjectIds in a filter
Aggregate: a pipeline of stages
When the query is wrong
MongoDB indexes
Inspect, create and drop a collection’s indexes.
The MongoDB indexes tool in three minutes: the Collection menu, each index with its keys and its unique, sparse, text, 2dsphere and TTL kinds, the ESR rule for ordering a compound index, New index with a compound and an expiring index, the server refusing a unique index over repeated values, a sparse unique index, and dropping one with its bin. Indexes are created and dropped only on a collection the video creates and removes.
The indexes of a collection
Which index to pick
Create an index
When the server says no
Drop an index
MongoDB server
Server status, running operations, users and roles.
The MongoDB server tool in two and a half minutes: the server’s status with its host, version, uptime, connections, memory and cumulative operations, Refresh counting three new inserts, the running operations with a slow count from another client, Include idle, the server’s own threads that offer no Stop button, stopping the count, and the users of every database with their roles, and the custom roles of the database chosen in the other tabs. The video writes just one user, one role and one database of its own, and removes them.
Server status
Running operations
Users and roles
MongoDB commands
Send a command to the server and see its response.
The MongoDB commands tool in four minutes: a ping sent with Run, the database menu, the Examples menu with database and collection statistics, validating a collection, an explain with its execution statistics, getCmdLineOpts refused on caliope_demo and answered on admin, getParameter, an invalid JSON caught before sending, an unknown command, and a collection created with a validator that rejects a document inside writeErrors with code 121. The video writes just one collection of its own, and drops it.
Send a command
The Examples menu
Commands for admin
Errors and a validator
MongoDB profiler
Which operations the server recorded for crossing the threshold, and what level each database’s profiler is at.
The MongoDB profiler in under four minutes: the level, threshold and sample rate of caliope_demo, the operations it recorded with their plan and the documents and keys examined, the whole recorded document with a $where that sleeps, Copy the JSON and Copy and open Query, and then, on a scratch database, a slow find that crosses the threshold, a threshold raised to 500 ms with Apply, level All recording even Calíope’s own read, a sample rate of 0.5, Off, and Empty the profiler putting the level back. caliope_demo is only read; the scratch database is dropped at the end.