Fb-cpp 1.0.0: A feature-complete modern C++ wrapper for Firebird

Adriano Fernandes announced the 1.0.0 release of fb-cpp, a modern C++ wrapper for the Firebird database API.

This release marks an important milestone: fb-cpp is now feature-complete in the scope of its public database client API. The project has grown from a collection of wrappers around the Firebird interfaces into a complete, consistent library for building Firebird applications in modern C++.

Introducing fbadmin and cloudnative-firebird: a web admin tool and a Kubernetes operator for Firebird

Two open source projects for running and managing Firebird have grown up side by side: fbadmin, a pgAdmin-style web administration tool for Firebird, and cloudnative-firebird, a Kubernetes operator for Firebird modelled on CloudNativePG. They also work together: fbadmin can list and manage the Firebird clusters the operator runs.

fbadmin: a web admin tool for Firebird

fbadmin gives Firebird a modern admin UI that runs in the browser. It works as a local desktop app (like pgAdmin's desktop mode) or as a container next to your server. It supports Firebird 3.0, 4.0, 5.0 and the 6.0 snapshots, and the UI is available in 8 languages, including Romanian. The current release is 2.1.1, MIT licensed.

Highlights:

• Object Explorer for tables, views, procedures, functions, packages, triggers, sequences, domains, roles, users and more (with Firebird 6 schemas), plus create/alter dialogs with SQL preview and full DDL extraction.
• Query Tool with autocompletion, detailed plans and a plan diagram, per-statement I/O stats, transaction settings, charts and export to CSV, JSON, SQL or XLSX.
• Editable data grid, schema diff and migration scripts, an ERD designer, data compare and an upgrade assistant for Firebird 4, 5 and 6.
• Monitoring: a multi-server overview, live dashboards, OIT/OAT alerts by email, Slack or webhook, the Firebird 5 profiler, an index advisor and a Prometheus /metrics exporter.
• Maintenance: backup and restore through the browser, nbackup, validate and sweep, the Trace API, and scheduled jobs with test restores and uploads to S3, Azure or Google Cloud Storage.
• Security: server mode with logins, two-factor sign-in, API tokens, LDAP/OIDC, per-database permissions and an audit log.

Install it from PyPI:

pip install firebird-admin
fbadmin                      # opens http://localhost:5050

Desktop installers for Windows, macOS and Linux are on the releases page, and there are also a Docker image and a Helm chart.

cloudnative-firebird: a Kubernetes operator for Firebird

cloudnative-firebird is written in TypeScript and inspired by CloudNativePG. You describe a cluster in a FirebirdCluster resource, and the operator creates and runs it: StatefulSet, persistent volumes, Services and Secrets. It is tested end to end with Firebird 4, 5 and the 6.0 snapshot.

• Replication: journal-based asynchronous replication, an optional synchronous standby, and read-only routing to replicas.
• High availability: opt-in automatic failover, planned switchover, rolling updates with the primary restarted last, fencing and replica re-seeding.
• Backups: gbak and nbackup backups, scheduled backups, restores and point-in-time recovery, with S3 storage.
• Declarative resources for databases, users and roles, plus image catalogs that roll out new Firebird versions, including major upgrades.
• Day-to-day operations: hibernation, online volume expansion, and a kubectl firebird plugin for status, switchover, backups, isql and logs.

Install the latest release with one command:

kubectl apply -f https://github.com/mariuz/cloudnative-firebird/releases/latest/download/cloudnative-firebird.yaml

Managing Firebird clusters from fbadmin

When fbadmin runs inside a Kubernetes cluster, or has a kubeconfig, a Kubernetes page lists the operator's Firebird clusters. For each cluster it shows the phase, instances and their roles, backups and scheduled backups, databases, users and recent events.

From the same page you can scale a cluster, hibernate it, do a rolling restart, restart, fence or promote one instance, take a backup, restore it into a new file, read instance logs, and register the cluster in fbadmin with one click to browse its databases. fbadmin acts with its own Kubernetes service account, so what it can do is set by RBAC: a read-only Role gives a read-only page. Every action is written to the audit log.

To try both together, fbadmin includes an example that deploys a Firebird 5 cluster and fbadmin side by side:

kubectl apply -k deploy/k8s-operator
kubectl -n fbadmin-demo port-forward svc/fbadmin 5050:80   # http://127.0.0.1:5050

The full guide, covering credentials, RBAC, the Helm settings and the API, is in docs/KUBERNETES.md.

Links

• fbadmin: github.com/mariuz/fbadmin
• cloudnative-firebird: github.com/mariuz/cloudnative-firebird
• Kubernetes guide: fbadmin/docs/KUBERNETES.md

Feedback, bug reports and pull requests are welcome on both projects.

Electric Firebird / firebird-wasm: six releases in four days (v0.10.0 - v0.14.0)

Electric Firebird runs the Firebird database engine compiled to WebAssembly, in the browser and in Node, similar to what PGlite does for PostgreSQL. It ships on npm as firebird-wasm, and the repo and the package share version numbers. Six releases came out between October 24 and October 27, 2026. Here is what each one brought.

npm install firebird-wasm@0.14.0

v0.14.0 – Zero-copy results and Firebird 5.0 LTS builds (Oct 27)

v0.14.0 release notes on GitHub

• Zero-copy query results across workers. Query results now travel in a packed binary format (FBR\x01) and are handed from the worker to the page without copying, through WorkerTransport, SharedEngineTransport and serveEngine.
• Firebird 5.0 LTS and 6.0 engines. wasm/build.sh --firebird-ref 5 now builds a Firebird 5.0 LTS (ODS 13.1) WASM engine, alongside Firebird 6.0 (ODS 14.0). CI builds and tests both.
• Idle cached statements are released before DDL or dropping a database.

v0.13.0 – BLOB streaming, migrations, sweep and an offline write queue (Oct 27)

v0.13.0 release notes on GitHub

• Segmented BLOB streaming: db.openBlobStream() and db.createBlobStream() read and write large BLOBs as Web streams, segment by segment.
• Schema introspection and migrations: db.introspect() returns typed metadata for tables, views and sequences. db.migrate() runs ordered, transactional migrations and tracks them in FB_MIGRATIONS$.
• Sweep: db.sweep() (and a Sweep button in <firebird-repl>) runs garbage collection and reports how far the OIT moved and how many pages were reclaimed.
• Durable offline writes for Electric sync: pending changes are stored in a FB_WRITE_QUEUE$ table, survive page reloads, and roll local rows back if the server rejects them.
• Prepared statement streaming: stmt.queryStream() streams rows in batches without preparing the SQL again.

v0.12.0 – Developer experience: live queries, plans, diagnostics (Oct 26)

v0.12.0 release notes on GitHub

• Zero-config live queries: db.live(sql, onChange) and the React/Vue useLiveQuery(sql) hooks now find the tables a query uses and install the change triggers themselves.
• Query plans: db.explain(sql) returns the compact PLAN (...) or Firebird's detailed plan tree, without running the query.
• Database diagnostics: db.databaseInfo() reports page size, database size, ODS version, OIT/OAT/OST transaction counters, memory use and I/O counters.
• Prepared statement handles: db.prepare(sql) returns a reusable statement with query, exec and execBatch.
• Streaming dump and restore: dumpDataStream() and loadDataStream() work in 64 KiB chunks, with optional gzip, so the whole database never has to sit in memory at once.
• ICU locale packs: locale collations such as de_DE, es_ES, fr_FR and ja_JP can be loaded on demand, so the default WASM binary stays the same size.

v0.11.0 – Unicode collations built in (Oct 25)

v0.11.0 release notes on GitHub

• The engine now embeds ICU 68 collation data (about 130 KB gzipped), so COLLATE UNICODE, UNICODE_CI (case-insensitive) and UNICODE_CI_AI (case- and accent-insensitive) work out of the box in tables, ORDER BY, WHERE, GROUP BY and indexes.
• Fixed an ICU function signature mismatch that WebAssembly's strict call checking rejected.

v0.10.1 – Fixed npm package (Oct 25)

v0.10.1 release notes on GitHub

• The 0.10.0 npm package had shipped the older 0.9.0 WASM binaries by mistake. 0.10.1 ships the rebuilt ones, so queryStream() and DECFLOAT support actually work.
• Multi-row INSERTs in the Kysely and Drizzle dialects now go through execBatch, avoiding Firebird error -804 (Data type unknown).
• Build script and CI fixes, including GCC 15 support.

v0.10.0 – Kysely and Drizzle ORMs, streaming queries (Oct 24)

v0.10.0 release notes on GitHub

• ORM dialects: firebird-wasm/kysely and firebird-wasm/drizzle support Firebird pagination, upserts via UPDATE OR INSERT ... MATCHING, RETURNING, identity columns, transactions and savepoints.
• Streaming queries: queryStream() returns rows in batches (500 by default) over an open cursor. Stopping a for await loop early closes the cursor right away.
• Node parity: the Node backend now returns the same value types and field metadata as the browser.
• Electric shape server: replica=full sends old values on updates and deletes, and applyWrite() confirms queued writes directly.
• Faster batches on Node through Firebird 4.0+'s native IBatch API, plus zero-copy OPFS reads and writes in the browser.

Try it

The source, demos and full changelog are on GitHub, and the package is on npm. Bug reports and feedback are welcome.

Firebird can now be built with CMake + Clang on Windows, Linux and macOS (PR #9111 merged)

Pull request #9111 "Build FirebirdSQL CMake+CLang" by Sergey Khalyutin was merged into the Firebird master branch on October 21, 2026. It makes it possible to build the whole Firebird project with CMake + Clang on Windows, Linux and macOS, for both amd64 and arm64.

What changed

• One build system for all platforms – Firebird can now be built with CMake and Clang everywhere. The only exception is the ICU (icu4c) prebuild on Windows, which still uses MSBuild + MSVC.
• Works as a project or a sub-project – Firebird can be built on its own or embedded as a CMake sub-project inside a larger build, which helps teams that maintain their own fork or derivative.
• Bundled third-party libraries – a new extern/CMakeLists.txt and builds/cmake/BuildICU.cmake build the external dependencies (ICU, libtomcrypt, libcds and others) as part of the CMake build.
• Ready-to-use distribution – the build produces a zipped distribution folder in ./distr.
• CI on GitHub Actions – a new workflow, .github/workflows/cmake-multi-platform.yml, builds Firebird with CMake on several platforms.
• Documentation – a new doc/README.build.cmake.md gives step-by-step build commands for Windows, Linux and macOS.

In total the PR touches 15 files, with about 1,466 lines added and 400 removed, mostly in CMakeLists.txt, src/CMakeLists.txt and the builds/cmake helper scripts.

How to build (Linux example)

SOURCE="path/to/firebirdSourceFolder"
cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -G "Unix Makefiles" -S ${SOURCE} -B ${SOURCE}/build
cmake --build ${SOURCE}/build --config Debug --target all -j 8

Windows uses the same commands with the LLVM tools (clang.exe, clang++.exe, llvm-rc.exe), and macOS works with CMake installed from Homebrew. See doc/README.build.cmake.md for details.

Testing

The author reported successful builds with Clang and GCC on RHEL and Debian, and with Clang on Windows 11 and macOS. The GitHub Actions release build for the PR passed, and the bundled unit tests ran without errors. During review, maintainer Adriano dos Santos Fernandes hit duplicate-symbol link errors in libtomcrypt on a Linux machine, which the author could not reproduce – something to watch for if you try the new build in a tree that was previously built with the old make system.

Why it matters

The goal is to make Firebird easier to build by unifying the build process across platforms, and to lower the entry barrier for developers who want to contribute to – or maintain their own fork of – an industrial-strength open source SQL server. The authors plan to keep supporting and extending the CMake + Clang build.