HuginnDB

---

Table of contents

• Why HuginnDB?
• How it compares
• Features
• Status
• Screenshots
• Installation
  • Prerequisites
  • From source
• Usage
  • Connecting to a sample database
  • Keyboard shortcuts
• Architecture
• MCP connector
• Security model
• Roadmap
• Contributing
• License
• Acknowledgements

Why HuginnDB?

Most database GUIs are either heavyweight Java IDEs or web-based dashboards that fight you the moment you need to inspect a 50 KB JSON blob inside a column. HuginnDB picks a narrower scope:

• Inspecting and editing data is the primary job. Every cell can be opened in a full Monaco editor with auto-detected syntax highlighting and validation.
• The SQL editor is a real editor. Same component, same shortcuts, schema-aware autocomplete, query history.
• Keyboard-first, minimal chrome. Dark mode by default, no nested toolbars, no popup soup.
• Credentials never touch disk in plaintext. Passwords go to the OS keychain.

It's named after Huginn, one of Odin's ravens — the one who fetches information.

How it compares

No two of these tools are chasing the same thing, and all four below are genuinely good at what they do (DBeaver and HeidiSQL are two of the reasons HuginnDB looks the way it does — see Acknowledgements). This is where HuginnDB sits relative to them, checked against each project's own docs/pricing pages as of writing (August 2026) — always double-check the vendor's site for anything that's moved since.

	HuginnDB	DBeaver (CE)	TablePlus	HeidiSQL	DataGrip
License / price	MIT, free	Apache-2.0 (CE) free; paid tiers from ~$110/yr for more drivers/SSO	Proprietary; free tier capped (2 tabs/windows/filters), ~$99 perpetual license	GPL-2.0, free	Paid (~$99/yr); free for non-commercial use since Oct 2025
Platforms	Windows, Linux (macOS unverified)	Windows, macOS, Linux	Windows, macOS, Linux	Windows-native (Linux via Wine; no native macOS)	Windows, macOS, Linux
MongoDB	✅ native	❌ in Community — only paid Lite/Enterprise/Ultimate	✅ (Beta)	❌	✅
SQL Server	✅	✅ (JDBC)	✅	✅	✅
Per-cell editor	Full Monaco pane — JSON/XML/SQL highlighting, live validation, F11 fullscreen	Inline / basic value viewer	Inline / basic value viewer	Inline / basic value viewer	Inline / basic value viewer
Credential storage	OS keychain, always	Local encrypted file + optional master password (not an OS keychain by default)	Keychain confirmed on macOS; Windows mechanism undocumented	Windows Registry, obfuscated (not strong encryption)	OS-native (Keychain / Secret Service / Credential-Store-backed)
AI / MCP connector	Built-in, free — any MCP client (Claude Code, Claude Desktop, Cursor, …)	MCP server is a paid Team Edition feature	Built-in LLM chat with MCP support, not exposed to external AI clients	None	Built-in MCP server (2026.1+), consent-gated
UI weight	Keyboard-first, minimal chrome	Full IDE (Eclipse-based)	Lightweight, native	Lightweight, native	Full IDE (JetBrains)

Sources: DBeaver editions · DBeaver MongoDB support · DBeaver master password · DBeaver Team Edition MCP server · TablePlus pricing · TablePlus MongoDB · TablePlus MCP announcement · HeidiSQL · HeidiSQL credential storage discussion · DataGrip free non-commercial tier · DataGrip password storage · DataGrip MCP server

Features

• Multi-driver connection manager. PostgreSQL, MySQL, SQLite, MongoDB, and SQL Server, each with a per-driver dialog and the right defaults, plus SSH tunnelling for remote hosts.
• Schema explorer. Tree of databases → tables/views/collections → columns (with type badges and primary-key indicators) and indexes.
• Data browser. Paginated, sortable, filterable grid built on TanStack Table. Inline cell edits are routed through the backend with PK-based safety.
• Expanded cell editor. Pop any cell into a Monaco editor with auto-detected JSON / XML / SQL highlighting, format/beautify, live JSON validation, and an F11 fullscreen toggle.
• SQL workspace. Monaco-based, self-hosted (no CDN dependency), with schema-aware autocomplete, Ctrl+Enter to run, per-statement "▶ Run" CodeLens, and a per-connection history sidebar that survives restarts.
• View editor. Create, edit, rename, and drop views with a live preview grid and a read-only DDL pane.
• Table structure editor. Visual ALTER TABLE — add/rename/drop columns, change types, PK/FK/index changes — previewed as the exact DDL that will run.
• Server-side security panel. Read users/roles and their privileges straight from the server, for every supported driver.
• MCP connector. huginndb-mcp, a headless stdio server, lets an AI coding assistant browse schemas, run queries, and (opt-in, per connection) write — see docs/MCP.md.
• Saved queries. A local library with name, description, and tags. Open any entry into a fresh query tab.
• Multi-window. Pop a connection's workspace, or even a single tab, out into its own OS window.
• Themes. Five built-in presets (HuginnDB Dark, HuginnDB Light, Dim, Solarized Dark, High Contrast) plus a visual colour editor. Editing a preset forks it into a new custom theme so the originals stay pristine.
• Resizable layout. Both horizontal (sidebar) and vertical (editor / results) splits are draggable, and the arrangement is restored across restarts.

Status

Stable, SemVer since 1.0. The MVP is feature-complete for read/write workflows against every supported driver, and the project has been through several triage rounds of real-world usage (see CHANGELOG.md). Known gaps: no automated frontend tests yet, macOS builds are unverified, Windows binaries aren't code-signed yet, and — despite the .deb/.AppImage bundler being fully configured — the release CI doesn't currently publish Linux artifacts, so Linux users need to build from source for now (see Roadmap).

Screenshots

Full Monaco editor for any cell — JSON / XML / SQL auto-detected, live validation, F11 fullscreen.

Schema-aware SQL editor — Ctrl+Enter to run, per-statement CodeLens, history that survives restarts.

_{Settings → MCP — point Claude Code, Claude Desktop, Cursor, or any MCP client at your real schema.}

Installation

From a release (Windows)

Download the latest .msi installer from the Releases page and run it.

Windows SmartScreen warning. Because HuginnDB binaries are not yet signed with an Authenticode certificate, Windows Defender SmartScreen will show a blue "Windows protected your PC" dialog on first launch. This is the default behaviour for any unsigned executable from a publisher SmartScreen has not seen before — it is not a malware detection. To continue, click More info (Más información) and then Run anyway (Ejecutar de todas formas). Code signing is on the roadmap; in the meantime, you can verify the SHA-256 of the downloaded .msi against the digest published on the Releases page. The full source is in this repository and reproducible builds are encouraged.

Prerequisites

Tool	Why	Install
Node.js ≥ 20	Vite, TypeScript, frontend tooling.	nodejs.org or fnm
pnpm ≥ 10	The only supported package manager.	npm i -g pnpm
Rust (stable)	Compiles the Tauri backend.	rustup.rs
Platform Tauri prereqs	Native build deps (compiler, webview, etc.).	See platform-specific list below.

Always use pnpm. Do not invoke npm or yarn against this repository — the lockfile is pnpm-only.

Windows

1. Visual Studio Build Tools 2022 with the Desktop development with C++ workload.

   winget install --id Microsoft.VisualStudio.2022.BuildTools -e --override "--add Microsoft.VisualStudio.Workload.VCTools --includeRecommended --quiet --wait"
   

2. WebView2 is preinstalled on Windows 11. On Windows 10, install the Evergreen Bootstrapper.

Linux

sudo apt install -y \
  libwebkit2gtk-4.1-dev build-essential curl wget file \
  libxdo-dev libssl-dev libayatana-appindicator3-dev \
  librsvg2-dev libsoup-3.0-dev libsecret-1-dev

Equivalent packages exist on Fedora, Arch, and Alpine — see the Tauri prerequisites for the per-distro names.

macOS

xcode-select --install

macOS is not a primary target yet but the build should work — please file an issue if you hit something.

From source

git clone https://github.com/Alexfp28/huginnDB.git
cd huginnDB
pnpm install
pnpm tauri:dev          # dev mode with HMR
# or
pnpm tauri:build        # release bundle in src-tauri/target/release/bundle/

The first tauri:dev is slow — Cargo compiles sqlx with three database drivers, the mongodb driver, keyring, tokio, and friends, all from scratch. Plan for 5–10 minutes on a typical laptop. Incremental rebuilds afterwards take well under 10 seconds.

Release bundles land under src-tauri/target/release/bundle/:

• Windows — .msi installer.
• Linux — .deb and .AppImage.

Usage

Connecting to a sample database

The fastest way to play with HuginnDB is the Chinook sample database in SQLite — a single file you can point HuginnDB at:

mkdir -p sample-data
curl -L -o sample-data/chinook.db \
  https://github.com/lerocha/chinook-database/raw/master/ChinookDatabase/DataSources/Chinook_Sqlite.sqlite

Then in HuginnDB:

1. Click the + in the Connections panel.
2. Pick SQLite as the driver.
3. Paste the absolute path to chinook.db into Database file path.
4. Test → Save → Connect.

Tables like Album, Artist, and Invoice should appear in the schema explorer. Try this query in a new query tab:

SELECT ar.Name AS artist,
       COUNT(*) AS albums
FROM Artist ar
JOIN Album al ON al.ArtistId = ar.ArtistId
GROUP BY ar.ArtistId
ORDER BY albums DESC
LIMIT 10;

Keyboard shortcuts

Action	Shortcut
Run the current query	Ctrl+Enter
Expand the focused cell	Double-click
Fullscreen the cell editor	F11
Exit fullscreen / close editor	Esc
Toggle light/dark mode	Sun/moon icon
Open settings & theme editor	Gear icon

Architecture

HuginnDB is split into two cooperating processes:

┌─────────────────────────────┐         ┌──────────────────────────────┐
│      Tauri webview          │         │       Rust backend            │
│  React + TypeScript + Vite  │  invoke │  tauri::command handlers      │
│  Zustand stores             │ <─────> │  sqlx (PG/MySQL/SQLite)       │
│  TanStack Table + Monaco    │   IPC   │  + mongodb driver             │
│                             │         │  keyring (OS keychain)        │
└─────────────────────────────┘         └────────────────────────────────┘

• The frontend never opens a database connection. It calls api.* (a thin typed wrapper around Tauri's invoke) and renders whatever the backend returns.
• The backend owns all live sqlx pools and resolves passwords against the OS keychain at the moment of use. Connection strings are never exposed to the webview.

For a deeper map of the code layout, read CONTRIBUTING.md. The two starter files are:

• src-tauri/src/lib.rs — Rust entry point and command registry.
• src/App.tsx — top-level React layout.

Tech stack

• Shell: Tauri 2 (Rust + WebView).
• Frontend: React 18, TypeScript (strict), Vite, Tailwind CSS, shadcn-style Radix primitives.
• State: Zustand with persist middleware for theme, history, and saved queries.
• Data grid: TanStack Table v8.
• Editor: Monaco (self-hosted; no CDN).
• Backend: Rust, sqlx (PostgreSQL, MySQL, SQLite), the official mongodb driver, keyring, tokio, thiserror.
• Bundling: Tauri bundler — .msi (Windows), .deb / .AppImage (Linux).

MCP connector

HuginnDB ships a headless Model Context Protocol server, huginndb-mcp, so an AI coding assistant can work against your actual databases instead of guessing schema and sample data from memory. It's a separate stdio process — installed as a sidecar right next to the main app, nothing to build — that reuses the connection profiles and OS-keychain passwords you already have in HuginnDB, opening its own pools lazily and only for the connections you explicitly expose.

• Any MCP client works: Claude Code, Claude Desktop, Cursor, Antigravity, Codex, or anything else that speaks the stdio MCP protocol.
• Read-only by default. Each exposed connection has a write policy — read-only (default), data, or full — set per connection in Settings → MCP, re-read from disk on every write attempt.
• Tools: list_connections, list_databases, list_tables, describe_table, list_indexes, run_query, browse_table, server_version, list_users/list_privileges, and (once a connection's policy allows it) insert_row/update_cell/delete_rows.
• Audited. Every write attempt — success or failure — is appended to mcp-audit.log. Whole-table UPDATE/DELETE with no WHERE is refused outright, at any policy level.
• Settings → MCP in the app shows the sidecar's resolved path and generates ready-to-paste config for your client.

Quick start with Claude Code:

claude mcp add huginndb -s user -- /absolute/path/to/huginndb-mcp --connections <profile-id>

Full reference — client-by-client config, all flags, the tool list, and the security model — in docs/MCP.md; design rationale in docs/MCP_CONNECTOR_ROADMAP.md.

Security model

HuginnDB is a single-user desktop tool. The threat model is primarily a curious local user or a hostile database operator, not a remote attacker reaching the user's machine.

• Credentials: stored in the OS keychain (Windows Credential Manager, libsecret on Linux, Keychain on macOS) via the keyring crate. The on-disk profile JSON contains only metadata (host, port, db, username, SSL toggle).
• Database I/O isolation: all sqlx access lives in the Rust process. The frontend cannot reach a database directly.
• No telemetry: the binary does not phone home.
• CSP: currently disabled (csp: null) because Monaco needs to load its workers. Workers are bundled by Vite — not loaded from a CDN — so the relaxation is narrowly scoped. Tightening this is on the roadmap.
• Identifier quoting in dynamic SQL is intended for catalog-sourced identifiers; user-supplied data always travels through bound parameters.

If you find a vulnerability, please follow SECURITY.md.

Roadmap

The full, current roadmap — what's shipped, what's open, ordered by priority — lives in ROADMAP.md. Top of the open list right now:

1. Bulk row insert in the data browser (bulk delete already shipped).
2. Schema diff and export (DDL extraction, side-by-side compare).
3. More drivers — ClickHouse, DuckDB (Microsoft SQL Server shipped; its DDL surface is still pending).
4. Tighter CSP for the webview.

Have a different priority? Open a feature request.

Contributing

PRs welcome. Read CONTRIBUTING.md first — it covers the project layout, commit conventions, coding standards per language, and a recipe for adding a new database driver.

Newcomer-friendly issues are labelled good first issue.

License

MIT. Use it, fork it, ship products with it.

Acknowledgements

HuginnDB stands on the shoulders of giants:

• Tauri for the desktop runtime.
• sqlx for the async, type-safe SQL toolkit.
• Monaco Editor — VS Code's brain transplanted into a browser pane.
• TanStack Table for the data grid.
• shadcn/ui for the design vocabulary and Radix primitive recipes.
• HeidiSQL and DBeaver — for showing what a great database client can look like.
• The Chinook sample database for making "try HuginnDB in 60 seconds" possible.