# pgModeler draws PostgreSQL schemas and generates the DDL for you > A C++ and Qt desktop tool that models PostgreSQL databases visually and exports SQL scripts, with reverse engineering and database diff reserved for a paid Plus edition. **nullptrlabs/pgmodeler** — Open-source data modeling tool designed for PostgreSQL. No more typing DDL commands. Let pgModeler do the work for you! - Repository: https://github.com/nullptrlabs/pgmodeler - Website: https://pgmodeler.io - Stars: 3,606 · Forks: 428 - Language: C++ - License: GPL-3.0 - Published: 2026-10-07 · Updated: 2026-10-07 · Language: en - Canonical page: https://hysenlabs.com/projects/nullptrlabs-pgmodeler ## PostgreSQL first, which rules most rivals out immediately pgModeler describes itself as a PostgreSQL-first, multiplatform database modeling platform, and that qualifier is the whole product decision. The repository description is blunter about the pitch: no more typing DDL commands. Everything the tool models, it models with PostgreSQL semantics in mind, and the topic list backs it up with postgresql, sql-standards, ddl-commands and entity-relationship-diagram alongside database-modeling and code-generator. That focus is what separates it from the generic diagram tools. The Community edition covers tables, views, relationships, functions and operators, plus many other PostgreSQL specific objects, and it generates SQL scripts from those models while preserving advanced object definitions. A generic ER tool will happily draw a box and a line and then hand you workarounds when you need partitioned tables, sequences with the right ownership, or a constraint that has to be deferred. The cost of the focus is equally clear. If you maintain MySQL or SQL Server schemas, this is not the tool, because the parity you are being promised is parity with one engine. The README also positions the project as an open source reference for the PostgreSQL ecosystem rather than as a general purpose modelling suite, and that is the correct way to read it. ## Where the Community edition ends and Plus begins The split is drawn explicitly in the README, which is unusual candour for a project with a commercial tier. Community is free software under GPLv3 and covers visual modelling, SQL generation, validation for broken references and dependency problems, and the cross platform C++ and Qt shell. Plus is where the lifecycle features live. Reverse engineering connects to a running PostgreSQL instance and produces a visual representation of it. Database Diff and Synchronization compares a model against a database or another model file and writes the migration script. Integrated database management runs SQL, browses data and administers objects from the same window. Those three items are the ones practitioners ask for most, and two of them are commercial. That reframes the evaluation: pgModeler Community is a schema design and code generation tool, not a full database design lifecycle tool. If your starting point is an existing production database, you cannot just point Community at it and get a model back. Revenue from Plus is what funds the platform, which is stated plainly rather than hidden, and it also means the Plus feature set grows faster than the Community one. ## Building from source with CMake rather than downloading a package The README does not hand you a build command. It links to a step by step installation section on the project site and offers two other routes: officially packaged pre-compiled binaries for Linux, Windows and macOS, or compiling yourself. There is no Docker image and no package manager recipe in the README, which is worth knowing before you plan a containerised CI for schema work. What the repository tree does give you is the shape of the build. `CMakeLists.txt` sits at the root next to `BuildConfs.cmake`, and the platform split is explicit in `LinuxPaths.cmake`, `MacOsPaths.cmake` and `WindowsPaths.cmake`. There is `PluginBuildConfs.cmake` for the plugin side, `InstallAssets.cmake` and `DefaultPaths.cmake` for installing, and `PrintSummary.cmake` for the configure output. Source lives under `apps/` with `libs/` alongside it, tests under `tests/`, and static assets under `assets/`. Build numbering is scripted in `getbuildnum.sh` for Unix and `getbuildnum.bat` for Windows. Two developer tooling signals sit in the root as well: `.clang-format` and `.clang-tidy`, with the tidy configuration in `ClangTidyConf.cmake` and editor support via `.clangd` and `.vscode/`. A codebase that ships its own format and lint configuration is one that expects outside contributors, and the README asks specifically for C++ and Qt developers. ## Known issues the README volunteers, including the MSVC wall Most READMEs advertise. This one has a technical notes section titled known issues, and it is the most useful part of the page. The Windows build is the hard constraint: the source relies on GCC and Clang specific extensions and is not compatible with Microsoft Visual Studio compilers. That is a real decision point for a Windows shop whose build infrastructure is MSVC. The Windows path is the pre-compiled package, or WSL, or a Linux or macOS build host. Rendering is the second. Because of the Qt raster rendering engine, very large models with hundreds of tables may slow down depending on hardware and relationship complexity. If your model is large enough that diagram performance matters, this is the failure mode you will hit first, and it scales with relationship count rather than table count alone. Third, thread safety. Very large exports, validations and model processing operations may still hit race conditions in specific scenarios, and the README says improvements are being implemented continuously, which is an honest admission rather than a promise. The fourth note is quieter but useful: special characters, uppercase names and reserved keywords automatically trigger quoted identifier generation to keep SQL standard compatibility. If you have a naming convention that relies on unquoted lowercase, the tool will quote for you and the generated DDL will look different from what you expected. ## Version 2.0 is still in beta, and the notes are about crashes Three releases are published and all three are pre-releases of 2.0. v2.0.0-alpha1 came on 2026-02-13 and was mostly an interface job: every model object editing form was redesigned, from roles and schemas up to tables, relationships and constraints, with tabbed layouts for the complex ones. v2.0.0-beta followed on 2026-05-19 with data loss prevention, which is the feature most likely to change how you work. Pressing Escape to close an editing form now detects unsaved modifications and asks before discarding them. It also added a customisable interface font, better crash diagnostics, and a clean separation between the Community and Plus build outputs. v2.0.0-beta1 on 2026-09-14 is described as a stability release and reads like a bug fix list: a crash when a column was restored through undo during validation, a use-after-free race in model close and reload caused by deferred object destruction, and stale pointers in the export tool. It added support for PostgreSQL 18 temporal keys, and expanded the Plus versioning plugin into a full Git workflow tool while reworking the SSH tunnel plugin. Read that list as a signal. Two of the three releases exist to fix crashes and data loss in code paths that were already shipped, which is what a large C++ rewrite looks like before it settles. The repository is not archived and the last push was on 2026-09-14, the same day as beta1. ## Licensing that draws a line around forks The Community edition is GPLv3, which is the licence to plan around if you intend to extend it rather than just run it. The extra condition is on branding, not on use: pgModeler, Nullptr Labs and their logos are registered trademarks of Nullptr Labs, and forks or redistributed versions must adopt distinct branding and may not present themselves as official distributions without prior authorisation. That combination, copyleft code plus a trademark boundary, is a fairly standard way to let a community edition exist without letting a downstream vendor ship an indistinguishable binary. It also means GPL obligations apply to a modified distributed build, and no legal reading is offered here. One small inconsistency is worth flagging rather than resolving. The README's licence link points at the LICENSE file on the repository's `main` branch, while the repository metadata reports `develop` as the default branch. Both can be true, since a project commonly keeps a stable branch and a development branch, but if you are pinning a version for a build, check which branch your checkout is actually on. The README also says the project has been evolving for nearly two decades and is now backed by Nullptr Labs, which is the funding and continuity story behind the Plus tier. ## Conclusion pgModeler makes sense for a PostgreSQL shop that wants its schema designed visually and its DDL generated, especially one already generating code with Qt and comfortable patching a CMake build. It is the wrong pick if you need to model MySQL or SQL Server objects, if reverse engineering a live database is a requirement rather than a nicety, or if a browser based tool is what your team will actually use. Two things are worth verifying before you commit: whether the Qt raster renderer holds up at the size of your model, since the README warns about hundreds of tables, and which edition your workflow needs, because diffing against a live database and reading a running database back into a model are Plus features, not Community ones. Build from source on Linux or macOS and you avoid the MSVC constraint entirely. ## FAQ ### Is pgModeler free? The Community edition is free and open source under GPLv3, covering visual modelling, SQL generation and validation. Reverse engineering a live database, diffing a model against a database or another model file, and running SQL from inside the tool are pgModeler Plus features that require a paid licence. ### How do I install pgModeler on Windows? The straightforward route is the officially packaged Windows binary. Compiling from source on Windows is not supported by the README, which states that the code depends on GCC and Clang extensions and does not build with Microsoft Visual Studio, so source builds there mean WSL or a Unix host. ### Can pgModeler generate SQL from a model file? Yes, that is the core of the Community edition: it generates SQL scripts directly from visual models while preserving PostgreSQL compatibility and advanced object definitions. You can also export from the tool to other formats, and Plus adds synchronized scripts generated by comparing models against databases or other model files. ### Does pgModeler work with databases other than PostgreSQL? No, and that is deliberate. The README describes it as PostgreSQL-first and built around PostgreSQL feature parity, with topics covering the postgresql standard and DDL generation. Its advantage on PostgreSQL is the same thing that disqualifies it for MySQL or SQL Server work. ## Sources - [License: GPL-3.0](https://github.com/nullptrlabs/pgmodeler/blob/develop/LICENSE) - [nullptrlabs/pgmodeler on GitHub](https://github.com/nullptrlabs/pgmodeler) - [Project website](https://pgmodeler.io) - [README](https://github.com/nullptrlabs/pgmodeler/blob/develop/README.md) - [Releases](https://github.com/nullptrlabs/pgmodeler/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nullptrlabs-pgmodeler