pgNimbus

A blazing-fast, open-source PostgreSQL GUI client with a modern, native UI.
Launches in ~100 ms. Streams results before your query finishes. Sends zero telemetry.

Website · Installation · Quick Start · Features · Benchmarks · Roadmap

---

🎯 Why pgNimbus?

The PostgreSQL client market has a gap: truly fast + open source + modern UI.

• pgAdmin / DBeaver — powerful, but heavy and slow.
• TablePlus — fast and polished, but closed-source and paid.
• Beekeeper Studio — open source, but Electron.
• HeidiSQL — native and fast, but dated and MySQL-first.

pgNimbus delivers HeidiSQL's speed with TablePlus's polish — PostgreSQL-first, from the ground up. Built with .NET 10 + Avalonia 12, compiled to a NativeAOT binary, MIT licensed.

🎬 See It in Action

Instant launch (NativeAOT)	SQL completion that predicts the next move

Startup race: pgNimbus vs. pgAdmin	Safe mode: stage edits, commit as one transaction

📦 Installation

Microsoft Store (recommended)

The Store package is signed and auto-updated — no SmartScreen warnings.

Get pgNimbus on the Microsoft Store →

WinGet

winget install pgNimbus --source msstore

Direct download (MSI)

Grab pgNimbus-<version>-win-x64.msi from Releases — a per-user installer, no admin rights needed.

Note

The direct MSI is unsigned, so SmartScreen will warn on first run — click More info → Run anyway, or prefer the Store/WinGet path above. You can still verify where the file came from.

macOS (early beta)

pgNimbus-<version>-macos-arm64.dmg from Releases (Apple Silicon only). The beta is unsigned and unnotarized, so Gatekeeper shows a misleading "pgNimbus is damaged" dialog on first launch.

Fixing the Gatekeeper "App is damaged" error

The file is safe — this is standard macOS behavior for unsigned apps. Clear the quarantine flag once per downloaded update:

# If you moved the app to the Applications folder:
xattr -cr /Applications/pgNimbus.app

# If the app is still in your Downloads folder:
xattr -cr ~/Downloads/pgNimbus.app

Then launch pgNimbus.app normally. Proper signing and notarization are planned — see Roadmap.

Linux (early beta)

x64 and arm64 builds from Releases, in three formats:

• AppImage (any distro) — chmod +x pgNimbus-<version>-linux-<arch>.AppImage, then run it. Nothing to install.
• Debian/Ubuntu — sudo apt install ./pgNimbus-<version>-linux-<arch>.deb, then launch pgnimbus (or find pgNimbus in your app menu).
• tar.gz — unpack anywhere and run ./PgNimbus.App.

Every vX.Y.Z tag builds all of the above via release.yml.

Verifying a download

The direct-download builds are unsigned, but every release asset carries signed build provenance — one command proves a file was built by this repo's release workflow from the tagged commit, not tampered with or rehosted:

gh attestation verify pgNimbus-<version>-win-x64.msi --repo Shman4ik/pgNimbus

Each release also ships SHA256SUMS.txt and a CycloneDX SBOM (pgNimbus-<version>-sbom.cdx.json) listing every bundled dependency.

🚀 Quick Start

1. Launch pgNimbus — the connection dialog opens first.

2. Paste any connection string into the box at the top; the form fills itself. All common syntaxes work:

   postgres://alice:s3cret@db.example.com:5433/appdb?sslmode=require
   jdbc:postgresql://db.example.com:5433/appdb?user=alice&ssl=true
   Host=db.example.com;Port=5433;Database=appdb;Username=alice;Password=s3cret
   host=db.example.com port=5433 dbname=appdb user=alice sslmode=require
   PGPASSWORD=s3cret psql -h db.example.com -p 5433 -U alice appdb
   

3. Connect — your password goes to the OS credential store (DPAPI on Windows), never to disk.

4. Run a query with Ctrl+Enter, jump anywhere with the command palette (Ctrl+K), and press F1 for the full shortcut cheat sheet.

For scripted or repeated local testing, set PGNIMBUS_CONN (same formats as the paste box) to skip the dialog entirely:

export PGNIMBUS_CONN="postgres://postgres:secret@localhost:5432/mydb"
dotnet run --project PgNimbus.App

✨ Features

⚡ Fast & Dependable

• ~100 ms launch-to-window as a NativeAOT binary — measured on every release, not asserted (Benchmarks).
• Streaming, cancellable results — the first screenful renders before the full result set arrives, backed by a virtualized grid; Esc genuinely stops a query mid-flight.
• Auto-reconnect — a connection dropped by laptop sleep or an SSH-tunnel hiccup quietly reopens on the next run. An open explicit transaction is never silently re-established; it surfaces a clear "connection lost, nothing committed" state instead.
• Workspace restore — closing the app never prompts; the next session reopens your tabs, including never-saved scratch SQL, exactly as you left them.
• Zero telemetry — no analytics, no crash reporting, no update pings. The only connections the app opens are the ones you configure (Privacy).

✏️ A Smarter SQL Editor

• Schema-aware autocomplete — schema-qualified tables after FROM/JOIN, scoped columns in WHERE/ON/ORDER BY, alias. member access, CTE output columns (including SELECT * bodies resolved through the catalog), and user-defined functions with signature tooltips.
• FK-aware JOIN magic — after JOIN, tables connected by a foreign key rank first; after ON, the complete join condition (oi.order_id = o.id) is the top, one-keystroke suggestion.
• SQL formatting — Ctrl+Shift+F pretty-prints the statement under the cursor; a token round-trip self-check guarantees only whitespace ever changes.
• Script execution — run several ;-separated statements on one connection (BEGIN…COMMIT, SET, and temp tables carry across), each with its own result section and timing, stopping at the first error.
• Multi-tab editor with find & replace, current-line and bracket highlighting, font-size zoom, and SELECT * expansion into an explicit column list.
• Open/save .sql files — Ctrl+O/Ctrl+S, a recent-files list in the palette, and a dirty marker that distinguishes "unsaved scratch" from "diverges from disk".
• Query history — searchable, pinnable, scoped per connection; entries open in a new tab.
• Command palette — Ctrl+K fuzzy-jumps to any table, saved query, or action without touching the mouse.

🧮 Data Editing Without Fear

• Safe mode (pending-changes review) — stage grid edits, inserts, and deletes locally: dirty rows are highlighted (amber = edited, red = delete), "Review & commit…" shows the exact generated SQL, and everything applies as one transaction — or gets discarded with nothing ever sent. Built for the "inline edit on production" nerves.
• No-SQL table browsing — paged browsing with click-to-sort headers, all pushed down to Postgres (ORDER BY/LIMIT/OFFSET), so a huge table stays as cheap as one page. The composed SQL sits in the editor and doubles as the filter — add a WHERE and run.
• Follow foreign keys from the grid — right-click an FK cell to jump to the row it references, or a key cell to list all referencing rows, each hop opening a pre-filtered browse tab.
• Full grid CRUD — inline cell editing, an "Add row" dialog with server-side type casts, delete with confirmation, and "Set cell to NULL". Hand-typed SELECTs become editable too whenever the wire metadata proves it's safe.
• Postgres-native value editors — enum columns get a dropdown of their pg_enum labels, boolean a checkbox, date/timestamp a calendar picker; arrays and composites are syntax-checked before anything is sent, and domains resolve to their base type.
• Transaction control — an explicit Begin/Commit/Rollback flow on one held connection, with a status-bar indicator and automatic rollback on failure so you're never stranded in an aborted-transaction state.
• Cell inspector — double-click any cell to read the full value in an overlay, with JSON pretty-printed and one-click copy.
• Import & export — CSV/JSON import streamed via COPY with type inference; copy results as TSV, CSV, JSON, Markdown table, or INSERT statements.

🐘 PostgreSQL-First Tooling

• Real pg_catalog introspection — the schema tree sees materialized views, partitioned tables, and true primary-key flags; never the lowest-common-denominator information_schema.
• DDL reconstruction — a "Source (DDL)" action rebuilds an object's CREATE TABLE/CREATE VIEW — columns, defaults, identity, constraints, partition key, indexes — into a new tab; an "Alter Table" UI covers no-SQL column changes.
• EXPLAIN visualization — a graphical plan tree for EXPLAIN and EXPLAIN ANALYZE with per-node cost and timing, not just raw text.
• Server activity dashboard — a live pg_stat_activity view with per-backend cancel statement and terminate session, so a runaway query is one click to stop.
• LISTEN/NOTIFY monitor — subscribe to channels and watch notifications arrive live.
• Connection manager — saved profiles with per-connection accent colors (so production never looks like staging), SSH tunnels, and passwords held by the OS credential store — never written to disk.
• Multiple simultaneous connections — open profiles in separate self-contained windows (own pool, listener, tunnel, workspace), so dev and prod sit side by side; or switch the current window's connection without restarting.

📸 Screenshots

Query editor + results (light)	Query editor + results (dark)

EXPLAIN ANALYZE visualization	Command palette (Ctrl+K)

Server activity (pg_stat_activity)	Connection manager

⌨️ Keyboard Shortcuts

Press F1 in the app for the full cheat sheet. On macOS, Cmd takes the place of Ctrl automatically (except autocomplete, which stays on Ctrl+Space — Cmd+Space is Spotlight). The highlights:

Action	Shortcut
Command palette	Ctrl+K or Ctrl+P
Run query / run statement under cursor	Ctrl+Enter / Shift+Enter
Cancel running query	Esc
Format statement under cursor	Ctrl+Shift+F
Find / find & replace	Ctrl+F / Ctrl+H
New / close query tab	Ctrl+T / Ctrl+W
Open / save a .sql file	Ctrl+O / Ctrl+S
SQL autocomplete	Ctrl+Space (also triggers while typing)
Refresh database & schema	Ctrl+Shift+R
Toggle sidebar	Ctrl+B
Switch focus: editor ↔ results grid	F6
Edit selected result cell	F2
Preferences	Ctrl+,
Shortcuts cheat sheet	F1

📊 Benchmarks

"Fast" is the thesis, so it's measured, not asserted. The benchmark workflow runs on every tagged release and tracks:

Metric	What it proves
Startup, launch → first frame (NativeAOT and JIT)	On screen in the ~100 ms range — measured from OS process start to first rendered frame
Memory at first frame, AOT binary size	The footprint stays "native app", not "Electron app"
Connect (cold pool) / SELECT 1 round-trip	Interactive latency of the query path
First row batch / full stream of a 100 000-row SELECT	Streaming delivers the first screenful long before the full result

Historical charts live at https://shman4ik.github.io/pgNimbus/dev/bench/ — a regression shows up as a visible step in the release that introduced it.

Running the suite locally

Linux, needs Xvfb and a reachable PostgreSQL:

PGNIMBUS_BENCH_CONN="Host=localhost;Database=postgres;Username=postgres;Password=postgres" \
    scripts/benchmarks/run-benchmarks.sh          # add PGNIMBUS_BENCH_SKIP_AOT=1 to skip the slow AOT publish

Two pieces make it work: PGNIMBUS_STARTUP_PROBE=1 makes the app print launch-to-first-frame time and RSS and exit (StartupProbe.cs), and the PgNimbus.Benchmarks console project measures the query engine through the same streaming API the UI uses.

🏗️ Architecture

pgNimbus/
├── PgNimbus.Core/         # Engine. Depends only on Npgsql — zero UI dependencies.
├── PgNimbus.App/          # Avalonia MVVM front-end (CommunityToolkit.Mvvm).
├── PgNimbus.Core.Tests/   # TUnit tests for the engine.
└── PgNimbus.Benchmarks/   # Query-engine benchmarks.

PgNimbus.Core is a plain class library that knows nothing about Avalonia, keeping the engine reusable for a future CLI or test harness. Results stream as IAsyncEnumerable<RowBatch> with real mid-flight cancellation.

Building from source

Requires the .NET 10 SDK.

dotnet build
dotnet run --project PgNimbus.App

Publishing a NativeAOT build:

dotnet publish PgNimbus.App -c Release -r win-x64 -p:PublishAot=true    # Windows
dotnet publish PgNimbus.App -c Release -r linux-x64 -p:PublishAot=true  # Linux (needs clang + zlib1g-dev)

🔒 Privacy

pgNimbus sends zero telemetry. No usage analytics, no crash reporting, no update pings, no "anonymous statistics" — nothing. The only network connections the app ever opens are the ones you configure: your PostgreSQL servers and, if you use them, your SSH tunnel hosts. Queries, schemas, credentials, and history never leave your machine (passwords live in the OS credential store, everything else in local JSON files under your user profile). The code is MIT-licensed and open — verify it rather than take it on faith.

🗺️ Roadmap

Prioritized by how much it advances the thesis (fast + open + modern, PostgreSQL-first). Contributions welcome — items are intentionally scoped as individually shippable pieces; shipped items graduate into Features above.

Next up

• Full macOS support — Developer ID signing, notarization, real-world testing.
• macOS look & feel polish — the native menu bar, About box, and Settings… (Cmd+,) shipped 2026-07; still open: title-bar vibrancy/translucency (NSVisualEffectView-style material behind the merged command bar), sheet-style modals instead of separate dialog windows, Cmd+1…9 tab switching, a proper Window menu with the open-windows list, native context-menu styling, and full-height sidebar that tucks under the traffic lights (TablePlus-style).
• Linux builds — AppImage, .deb, and tar.gz for x64/arm64 ship from the release pipeline (Flatpak still a maybe-later).
• Table & index sizes and usage — sizes in the schema tree plus a per-database overview (largest relations, seq-vs-index scans, unused indexes, cache hit rate).
• Locks & blocking tree — a who-blocks-whom view in the activity window, with one-click cancel/terminate of the blocker.
• Row detail sidebar — a vertical name/value view of the selected row, doubling as a form-style editor.
• winget-pkgs submission — manifests are generated and validated per release; the first manual community-source PR is pending (the msstore source already covers winget install).
• Windows polish — Mica/acrylic backdrop; per-action hotkey remapping.

Bigger bets

• ER diagram — auto-laid-out foreign-key graph of a schema, exportable as SVG.
• EXPLAIN plan diffing — run a query before/after an index and diff the plan trees node-by-node.
• Backup/restore UI — pg_dump/pg_restore orchestration with progress streaming.
• AI, privacy-first — bring-your-own-key or local model, explicit opt-in, nothing leaves the machine otherwise; possibly an in-app assistant and/or a built-in MCP server exposing the current connection.
• Vim keybindings — opt-in modal editing over AvaloniaEdit.
• Parameterized queries — recognize :name / $1 placeholders and prompt for values on run.
• Quick chart of a result set — one click from grid to a bar/line/scatter view.
• PostGIS geometry viewer — render geometry/geography cells on a map.
• Notebook mode — mixed SQL + Markdown documents with inline result snapshots.
• Plugin/extension API — a stable surface for community panels.
• Localization — externalize UI strings; Russian and German first.

📄 License

MIT — see LICENSE.