VisuaLeaf v1.0.2091 Release Notes

Release Date: July 30, 2026

Headline: Faster Results, Schemas You Can Build For Real, One Connections List, and a Modern Look Throughout

This release is mostly about the app you use every day — the grid, the sidebar, the editors, the dialogs — getting faster, tidier, and more consistent. The things you'll feel first:

Big query results arrive sooner — aimed squarely at the extreme end, like a page of 50 documents at MongoDB's 16 MB limit each load even faster than before ( which was already pretty fast)
Materialize a schema diagram into a real database — design it once, preview the exact DDL or validators, then build the tables or collections for real.
One connections list for every engine — MongoDB, SQL, and Redis in the same sidebar, with the connection manager to match.
Real folders for saved queries, scripts, and charts, offered everywhere you save.
Live index-build progress, and index errors written in plain English instead of driver-speak.
Results from your own SQL are editable, and browsing tables on a remote database is much faster.
A modern look across modals and editors — the dialogs you live in no longer each look like the year they were written.

Also shipping: Deploy MongoDB (BETA) — stand up and run a standalone server, replica set, or sharded cluster on your own cloud accounts, servers, or Docker — Redis as a first-class connection type (BETA), and backups and exports straight to S3 / Cloudflare R2.

Faster Large Result Sets

Big query results arrive sooner. Loading a large result no longer alternates between waiting on the network and processing what arrived — both happen at once, on both sides of the connection. The target case is the punishing one: a page of 50 documents at MongoDB's 16 MB ceiling each, roughly 800 MB in one go, where the load used to spend most of its time idle in the middle. If anything goes wrong the app falls back to the old behaviour rather than failing.
Loading a collection of those documents is lighter on memory — moving between pages of 16 MB documents settles faster and leaves less behind.
Scrolling a long result stays smooth as the data grows, including in the tree view.
The query builder no longer stalls on complex queries — building up a big filter, projection, or sort no longer gets slower with every field you add.
Binary and UUID fields survive the trip. Streamed results used to be able to corrupt Binary and UUID values in rare cases; every path now reads them the same, correct way.

Connections Sidebar & Connection Manager

One list for every engine. MongoDB, SQL, and Redis connections sit in a single sidebar list, each with its own brand logo, and the connection manager looks the same — so you're not moving between two different-looking lists of the same connections.
Recent connections first — both the sidebar and the connection manager can filter to what you've actually opened lately, instead of scrolling a list of fifty.
Every SQL object action came with it — views, procedures, triggers, sequences, packages, and events are still edited straight from the tree in the unified list.
Capped collections are labelled in the tree, so you know before you try to write to one.
SQL connections show when you last connected, like MongoDB ones do.
Redis over SSH — reach a Redis server on a private network through an SSH tunnel.
Reconnect without hunting — if a connection dropped, actions that need it now offer to reconnect instead of failing.

Saved Queries, Scripts & Charts: Real Folders

Folders are real now. A folder you create exists on its own, so the Save As dialogs offer the same folders the list shows — including an empty one you just made.
Rename a folder and everything in it follows.
Sensible default names when saving from the file explorer, instead of a blank field.
Saved lists behave. What you save lands where you saved it, the list shows it without a manual refresh, and the counts are right — across saved queries, scripts, charts, dashboards, schemas, and JSON schemas.

Index Management

Watch an index build. Creating or rebuilding an index shows live progress, and that progress survives switching tabs or closing and re-opening the index screen. When it finishes you get a notification, wherever you are.
Index errors in plain English. A failed index no longer dumps a driver error at you — you get a short sentence naming the problem (a duplicate value blocking a unique index, a field that's too long, an unsupported option) and what to do about it.

SQL Editing & Query Building

Edit the results of your own SQL. Results from a hand-written query used to be read-only. Now, when a result column traces back to a real table column, you can edit it in place — and a badge on the grid tells you which cells are editable and why the others aren't.
Browsing tables on a remote database is much faster. Opening a table on a distant Oracle, SQL Server, or Postgres box no longer re-reads the whole catalogue every time — the second visit is close to instant.
Change the schema and the tree keeps up. Run a CREATE, DROP, or ALTER in the editor and the connection tree refreshes itself; you don't have to reconnect to see the new table.
Paging shows real numbers. Changing a filter no longer leaves a stale row count on screen while the new page loads.
Writing SQL and editing JSON feels quicker — typing stays responsive on long statements, with sharper highlighting and completion that keeps up.
Smart split layout — the query editor and its results now arrange themselves from the shape of the panel: side-by-side when it's wide, stacked when it's tall, with the results getting the space. Drag the divider and your size is respected until you change the layout.
A better SQL query builder — a cleaner layout and a much more responsive one on large queries.
SQL table schemas get their own list view, alongside the MongoDB JSON-schema list.
Query profiling tells you where you stand — if your engine doesn't support profiling, it says so in a sentence instead of showing an empty screen, and on SQL Server the statistics no longer drop ad-hoc queries.
Writes respect the engine. Generated and imported SQL now adapts to what each dialect actually supports — upsert style, foreign keys, transactions, identity columns, batch sizes, identifier limits — so a script that works on Postgres also works on MySQL, ClickHouse, or SQLite.
Fixed SQLite connections and imports.

A Modern Look for Modals and Editors

A broad styling pass — the dialogs and editors you live in every day were brought up to the same modern standard, instead of each one looking like the year it was written.

Modals across the app share one look — rounded panels, a proper iconified header with the context you're working in, a soft fade on open, and consistent buttons. Query History, Load Query, the Save Query / Script / Chart dialogs, the command palette, the keyboard-shortcut sheets, the feedback and help panels, the JSON-schema editor, and the whole Settings screen (Appearance, AI Configuration, Storage, Email, License Information) all follow it now.
Query History is genuinely searchable — filter by type and status, search as you type, and see a real "nothing matches" message instead of a blank panel.
Load Query got the same treatment — search your saved queries, with clear empty states when you have none yet.
Editors look and behave consistently — the shell, SQL, and JSON editors share one visual language, and the aggregation stage editors show a ghost hint of the expected shape while they're empty, so an empty stage tells you what goes in it.
Dropdowns look the same on every OS — the AI model picker no longer renders as a native menu that looks out of place on Windows.

Schema Diagram (VisuaSchema)

Import a schema from a "smart query" JSON dump — paste the metadata output from tools like ChartDB and get tables, columns, keys, indexes, and views laid out for you.
Smoother pan and zoom — the minimap no longer redraws the whole canvas while you move around, and a locate bug that jumped you to the wrong place is fixed.
A new collection shows up in the diagram without a manual refresh.
JSON schema on collection stats — see a collection's schema where you're already looking at its numbers.
Exported diagrams keep their fonts, so a shared PNG looks like what you saw.

Materialize a diagram into a real database

A diagram doesn't have to stay a drawing. Materialize takes the schema you designed and builds it for real, on the connection and database you point it at.

See exactly what will run before it runs. Every materialization starts as a dry run: on SQL you get the full generated DDL script in an editor; on MongoDB you get the JSON Schema validator that will be attached to each collection. Nothing touches the database until you say so.
Tables get created in the right order. Foreign keys are worked out ahead of time so parent tables exist before the tables that reference them — no hand-sorting your CREATE TABLE statements.
Collections come with their rules attached. On MongoDB, each collection is created with its JSON Schema validator in place, so the shape you designed is enforced from the first insert.
Decide what happens to anything that already exists — skip it (the safe default), attach or refresh just its validator, or stop the whole run and fail. You get a per-collection report of what was created, skipped, or updated.

Deploy MongoDB (BETA)

A new Deploy MongoDB launcher creates and runs MongoDB for you, and a Cluster tab manages each deployment afterwards. It works the same whether the machine is a cloud VM you've never logged into, a server you already own, or Docker on your laptop.

What you can see

A card per cluster with its phase, members, versions, and live resource usage (CPU, memory, disk) that refreshes on its own instead of being a one-shot snapshot.
An Infrastructure tab listing every server behind your clusters with live status, so you can tell a sick machine from a sick database.
A live progress panel for long operations — adding a shard, growing a disk, upgrading a version — instead of a spinner that tells you nothing.
An Audit log tab recording every deploy, scale, restart, password reset, and destroy, with who ran it and when.
Plain-English preflight before anything is created: whether Docker or the deploy tooling is present, whether the port is free, and what to do about it if not. If port 27017 is already taken on the target machine, the deploy stops immediately and tells you, instead of failing halfway through. Nothing to install by hand first — VisuaLeaf fetches the tooling it needs for a cloud deploy on its own.

What you can do

Pick a deployment shape — standalone server, replica set, or sharded cluster (config servers, shards, and a router), on cloud VMs, your own SSH hosts, Docker, or Kubernetes.
Bring your own accounts and servers — add a target once (DigitalOcean, AWS EC2, Hetzner Cloud, Hostinger VPS, OVHcloud, DigitalOcean Kubernetes, your own Kubernetes, an SSH host, or Docker), and reuse it for every cluster. Targets are editable after the fact, credentials are checked against the provider when you save them, and SSH hosts get a real reachability test rather than a hopeful "saved".
Authenticate SSH targets your way — private key or password, and per-server credentials when the members live on different machines with different logins.
Deploy secured by default — set the admin password yourself (the field starts empty on purpose), turn on TLS with one toggle, and download the cluster's CA certificate from the Overview tab so other tools can trust it.
Get a working connection immediately — VisuaLeaf creates the connection for you, matching the cluster's TLS setting, and marks it as managed. For a database on a private network, open an SSH tunnel from the Tunnels pane and connect through it.
Run day-2 operations without a shell — reset the admin password, scale members up or down, grow a disk, add a shard, scale config servers, restart a member, do a rolling MongoDB version upgrade, or convert a replica set into a sharded cluster.
Schedule backups — pick a schedule and retention window, organise runs into folders, and optionally push copies offsite to S3 / R2. Each run shows up as a task you can open, and delete failures now surface an error instead of quietly doing nothing.
Set up alerts and auto-heal — get told when a cluster is unhealthy, and let VisuaLeaf bring failed members back on its own with the auto-heal toggle on each cluster card.
Place members deliberately — spread a replica set across regions or across different targets, one member at a time.
Adopt what already exists — point VisuaLeaf at a replica set you built yourself and watch it read-only, then take over management of it. It can also scan a remote Docker host or an SSH host for MongoDB it didn't create, recover a cluster whose container is gone but whose data volume survives, and add a new member to an existing set for you.
Remove things safely — a target that still has databases on it can't be removed, and the app tells you which ones are in the way. Adding an account you already added reuses it instead of creating a duplicate.

Deployments survive an app restart, and the deploy and cluster screens are ordinary tabs, so they can be split and popped out like anything else.

Redis Support (BETA)

Redis now behaves like every other connection: add it from the connection manager, see it in the sidebar with its own logo, and open activities against it.

Connect to any shape of Redis — standalone, cluster (with seed nodes), or Sentinel (with sentinel nodes and a master name), plus Redis Enterprise and Redis Cloud using their management APIs. Pick a database index, or authenticate with a username and password.
Browse keys — a searchable key tree with a value filter, so you can find session:* without scanning by eye. Values open in a proper editor: a form view for simple values, a code view for JSON, and per-type editing for hashes, lists, sets, and sorted sets (with member and score fields).
Run commands — a Redis CLI tab with command help built in.
Read server health — the System Monitor button opens Redis Server Info for a Redis connection instead of a Mongo-shaped screen.
Manage security — the Users & Roles button opens Redis Security for a Redis connection: manage ACL users and permissions, set or change the server password, and manage users on Redis Enterprise and Redis Cloud. A banner makes clear that ACL changes apply to the remote Redis server, and the panel refreshes once instead of thrashing.

Backups & Exports to S3 / Cloudflare R2

Save your buckets once — a new Cloud Storage screen holds your S3 and Cloudflare R2 buckets with a connection test, so tasks can just pick one. Secrets are stored encrypted with no extra setup on your part.
Export to a bucket — pick a saved bucket and a path, and browse the bucket's folders (or create one) right from the picker instead of typing a path blind.
Restore from a bucket — a dump sitting in S3 or R2 can now be the source of a job, not just the destination.
Back up a whole cluster — every database in one job, and restore the same way.
Dated paths without editing the job — use date tokens in the path and every run lands in its own folder.
Job lists read correctly — object-storage sources and targets show up properly instead of a red "Unknown", and jobs that don't have a field mapping (whole-database and object-storage jobs) no longer show an irrelevant preview.

Improvements

Stability

An AI provider rejecting your key no longer signs you out of VisuaLeaf. You get a clear message about the AI key instead of being dropped back to the login screen.
Fixed a start-up failure that could stop the desktop app from opening at all.
Control your crash reports. Settings now has a Crash Reporting panel: send reports automatically, keep them local only, and view the recent ones yourself.

Tabs & Workspace

Put a popped-out tab back. A tab you popped into its own window can be returned to the main window.
Heavy tabs no longer break your workspace. Long-running monitor and oplog tabs used to be able to grow your saved workspace past its limit, which meant it stopped saving; they now keep their history locally and repaint instantly when you come back.
A workspace saved by a newer build opens in an older one instead of failing to load.
Custom tooltips across the app render properly instead of getting clipped at panel edges.
Select-all no longer runs away on very large selections.

Export & Import Jobs

Paste documents straight into a task — no file needed. An import task's file source now has a Paste JSON box: drop in an array or one document per line, hit Use this JSON, and it becomes the task's source. Handy for a quick one-off set of documents you'd otherwise have to save to disk first. Pasted data is kept as a file behind the scenes, so the job still streams, resumes, and re-runs like any other; anything over 8 MB should still come from a file.
One job at a time. Clicking a job that takes a moment to open no longer opens it three times.
Standalone imports are editable — choose insert, upsert, or drop-and-insert per import.
Exported queries match what you ran — a query saved into a job now carries its exact values, so ObjectId, Decimal128, dates, and binary fields survive round-tripping instead of being re-parsed from text.
Shell-style JSON import and export works correctly, including ObjectId(...) and friends.
Export tasks run on connection existence, not on whether the connection is currently open — a scheduled task no longer skips because you closed a tab.
Tell running, pending, and scheduled work apart at a glance in the Execution Monitor and a job's history — and when a section is empty, it says why instead of leaving you guessing.
Saving a job sticks. A batch of bugs where job and export settings didn't save, or came back changed after a reload, is fixed.
Renaming the key field no longer loses your records. An import that mapped _id to a different name with "include unmapped fields" turned off used to produce rows with no key at all; the key now follows the mapping (SOZO-1329).
Opening a run's log is instant, even on a job with a long history, and old execution history is cleaned up on a retention schedule instead of growing forever.
Import warnings belong to the right item. When several items of a task run at once, each one's warnings now stay with it instead of bleeding into its neighbours.
Job history and live progress work in the desktop app's own storage — some log and running-status lookups used to fail there, which could leave a running export looking stuck.
The help panels answer the question you have — bulk import, field mapping, and data-source variables now explain what to type and show an example.

Users & Roles

Rebuilt user and role management — clearer user and role lists, a cleaner create-user and create-role flow, role detail, and an effective-privileges view that answers "what can this user actually do?".

Queries, Aggregations & Profiling

Complex aggregations save correctly. Pipelines with nested stages and rich values used to come back altered — or not save at all. Save, reopen, and you get exactly the pipeline you wrote.
Aggregation builder uses the space it has — a much more compact, readable layout.
Aggregation history works again.
Query profiling shows correct data, and you can now inspect active sessions.
Copy and paste files in the file explorer, including JSON files.
Capped collections get a proper configuration panel, with a clear warning that converting is irreversible.

Naming & Navigation

Names that say what the tool does. The schema diagram is now Visual Schema (ERD), the JSON-schema editor is Schema Manager, and Mongo Sync is now Database Sync — since it moves data between SQL engines as well, not just MongoDB. Each new name is used everywhere: sidebar, tabs, and the command palette.
Every create flow goes through the same picker. Starting a chart, query, aggregation, shell, or schema from the welcome page, the + button, or the command palette now behaves identically, and each one only offers what the connection actually supports.
Redis sits in the same list as MongoDB, rather than in a separate tree of its own.

Dashboards & Onboarding

An empty dashboard offers to create a chart instead of leaving you at a dead end.
Pick your chart's source — including an aggregation — from a clearer source picker.
Check for updates manually from within the app.
Getting-started guides for the comparison and compare screens, and a refreshed getting-started modal.
The free-trial prompt only appears if you haven't already started a trial.

Notes

Deploy MongoDB and Redis support are BETA. They're complete enough to use daily, but expect rough edges; the destructive operations (destroy, convert-to-sharded, force reconfig) are all behind confirmations for a reason.
Deploying to a cloud provider needs your own account and credentials. VisuaLeaf spawns servers in your account and you pay your provider directly — nothing runs through us.
A cluster deployed with TLS uses a self-signed certificate. Use Download CA certificate on the cluster Overview tab to make other tools trust it.
Adopted clusters start read-only. A replica set you import is observed first; take over management explicitly when you're ready.
Existing workspaces, connections, and export jobs upgrade in place — nothing to migrate.