# openhare: A Flutter SQL Client That Puts the Database Drivers in Go

> openhare is an Apache-2.0 licensed cross-platform desktop SQL client built with Flutter, where the database drivers are Go libraries reached through Dart FFI, and the AI features flag risky statements before they run. It suits developers and DBAs who want one client across MySQL, Postgres, SQL Server and eight more engines.

**sjjian/openhare** — AI-powered desktop SQL client. Cross-platform. Built with Flutter.

- Repository: https://github.com/sjjian/openhare
- Website: https://sjjian.github.io/openhare/
- Stars: 816 · Forks: 51
- Language: Dart
- License: Apache-2.0
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/sjjian-openhare

## The client is Flutter, the drivers are Go

The architectural decision that defines openhare is stated in one line: database drivers are implemented in a Go package and invoked from the Flutter client through Dart FFI. So the interface is Dart and Flutter, and everything that talks to a database is Go. That split is unusual and it is the reason the project can offer native drivers for nine engines without writing them twice, since Go has mature database libraries that the project simply reuses. The listed drivers are go-sql-driver/mysql for MySQL, jackc/pgx for PostgreSQL, microsoft/go-mssqldb for SQL Server, mattn/go-sqlite3 for SQLite, duckdb-go for DuckDB, clickhouse-go for ClickHouse, sijms/go-ora for Oracle, gomongo and the official mongo-go-driver for MongoDB, and go-redis for Redis. The FFI boundary is what keeps the Flutter side free of a bundled browser engine, which the feature list stresses.

## Lightweight because there is no WebView

The first key feature is called lightweight and native, and the reasoning is explicit: you download, install and run in seconds, with no WebView or bundled browser engine. Built with Flutter for a native desktop UI and a lean memory footprint. That is a real distinction for a database client, because the Electron-based tools in this category ship a whole browser with them, and the memory cost shows up when you have six or eight database connections open at once. The badges cover macOS, Windows and Linux, and the readme frames the tool for everyday development, data analysis and DBA management workflows, which is a broader brief than a developer query runner. The project page for the app is hosted under the author's GitHub Pages site.

## Nine database engines and one client

The supported list runs to MySQL, PostgreSQL, SQL Server, SQLite, DuckDB, ClickHouse, Oracle, MongoDB, Redis and more. It is a deliberately broad spread that covers relational engines of three different lineages, two columnar stores, an embedded analytical database, a document database and a key value store, and the fact that DuckDB and ClickHouse are both included is a signal that the tool is aimed at people doing analytics rather than only application development. The embeddable and serverless options are covered too, with SQLite for local files and DuckDB for in-process analytics. There is one caveat stated in the readme, that MongoDB syntax is intended to be mongosh compatible, and that the actual supported surface should be checked against the gomongo project rather than assumed.

## AI assistance that stops before it runs something

The AI feature is described as helping you write, optimize and understand SQL, with built-in AI, and the important part is the safety clause: high-risk statements are flagged and require your confirmation before execution. That is a meaningful design position for a tool whose whole job is sending SQL to a database, because a query assistant that silently rewrites and runs a statement against production is a different proposition from one that shows you what it intends to do and waits. The AI component sits inside the client, so whatever service it talks to will see your schema and your statements, and that is worth checking against your own data handling rules before you point it at a customer database. The project tags include nl2sql and sqlagent, which suggests both directions are in play, generating SQL from language and answering questions about it.

## The Flutter stack behind the interface

The framework section names each layer. The application is Flutter, state management is Riverpod with GoRouter for navigation, the SQL editor comes from the re-editor project, icons are HugeIcons and desktop window handling is the leanflutter window_manager package. Storage is ObjectBox, an object database, which is a sensible choice for a desktop client that has to remember connections, saved queries and settings without a server. The SQL editor being a third-party component rather than something written from scratch tells you where the effort went, and it means the editing experience depends on that project's own pace. Riverpod with GoRouter is a common Flutter pairing, and the presence of a window manager package confirms this is a desktop-first application rather than a web build wrapped up.

## Building the client and the drivers from the Makefile

The build targets in the Makefile show the shape of the project. The `pub_get` target runs flutter pub get across the client, several database driver packages, the SQL parser and the SQL editor, so each of those is a separate Dart package with its own dependencies. Code generation is a second target, running build_runner in the client with the delete-conflicting-outputs flag, then flutter_launcher_icons for the app icon and flutter gen-l10n for localisation, and finally flutter_rust_bridge_codegen in the MySQL driver package.

```bash
	cd client && flutter pub get
	cd pkg/db_driver/impl/mysql && flutter pub get
```

That last line is worth pausing on, because it implies the MySQL driver path also contains a Rust component, since the code generator named is the Rust bridge one, even though the readme describes the drivers as Go. The macOS build target runs flutter build macos and then a packaging script that produces the disk image.

```bash
	cd client && flutter build macos --release
	scripts/package_macos_dmg.sh
```

The repository also carries a `windows_build.ps1` script and a `windows_setup.iss` file, which is the Inno Setup script used to build the Windows installer.

## Release rhythm and the size of the codebase

The releases move quickly for a desktop tool, with v0.14.0 on 2026-10-02, 0.13.0 on 2026-08-09 and 0.12.0 on 2026-06-19, and the last push was on 2026-10-02. Two months between minor releases on a project with nine database backends and an AI component is a fast pace, and it means the changelog matters: there is a `changelog_latest.md` at the repository root as well as the GitHub releases. The repository itself is split into `client/` for the Flutter application, `pkg/` for the shared packages including the database driver implementations, the SQL parser and the SQL editor, `server/` for a server-side component, plus `docs/`, `scripts/` and a `.gitmodules` file. The version numbers stay below 1.0, which is the usual signal that the interface is still settling.

## What to check before you trust it with a real database

Two caveats deserve a careful look before you connect something that matters. The first is the AI behaviour. The feature list says high-risk statements are flagged and require confirmation, but the documentation excerpt does not define what counts as high risk, or whether a statement you have already confirmed once will be re-confirmed later, and those are exactly the details that determine whether the safeguard holds up in daily use. The second is MongoDB, where syntax compatibility is described as intended rather than guaranteed. Beyond those, the practical caution is the same as with any client: your connection strings hold credentials, and the tool supports saving them, so the ObjectBox storage location and the way the application handles secrets on disk are worth understanding before you connect a production instance with write access.

## Conclusion

openhare fits a developer or DBA who works across several database engines and wants a single lightweight desktop client with AI assistance that stops before running a dangerous statement. It is the wrong choice if you need a browser-based client or a server-side tool, since it is a native desktop application, and the wrong choice if you cannot accept an AI component in a tool that sees your schema. Before you connect a production database, read the AI confirmation behaviour and the MongoDB support caveat, since MongoDB syntax is only intended to be mongosh compatible.

## FAQ

### Which databases does openhare support?

MySQL, PostgreSQL, SQL Server, SQLite, DuckDB, ClickHouse, Oracle, MongoDB and Redis, each through a Go driver called from the Flutter client over Dart FFI. MongoDB syntax is intended to be mongosh compatible, with actual support defined by the gomongo project.

### How does openhare use AI for SQL, and is it safe?

The built-in AI helps write, optimize and understand SQL. High-risk statements are flagged and require your confirmation before execution, so the assistant does not run a dangerous statement on its own. The documentation excerpt does not define what counts as high risk.

### What is openhare built with?

Flutter for the application and UI, Riverpod with GoRouter for state and navigation, the re-editor project for the SQL editor, HugeIcons and leanflutter window_manager for the desktop shell, and ObjectBox for storage. The database drivers are Go libraries reached through Dart FFI.

### How is openhare built and packaged?

The Makefile has a pub_get target that runs flutter pub get across the client and the shared packages, a dart_gen_code target for code generation including flutter_rust_bridge_codegen, and a build_macos target that runs flutter build macos and then scripts/package_macos_dmg.sh. Windows packaging uses windows_build.ps1 and windows_setup.iss.

### Is openhare open source and how active is it?

It is licensed under the Apache License 2.0. Releases v0.14.0, 0.13.0 and 0.12.0 landed on 2026-10-02, 2026-08-09 and 2026-06-19, and the last push was on 2026-10-02.

## Sources

- [License: Apache-2.0](https://github.com/sjjian/openhare/blob/main/LICENSE)
- [Project website](https://sjjian.github.io/openhare/)
- [README](https://github.com/sjjian/openhare/blob/main/README.md)
- [Releases](https://github.com/sjjian/openhare/releases)
- [sjjian/openhare on GitHub](https://github.com/sjjian/openhare)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/sjjian-openhare