pgModeler is an multi-platform PostgreSQL schema engineering tool — locally installed,
Git-friendly, and built with a deep PostgreSQL specialization. Design schemas visually,
reverse-engineer production databases,
diff and sync across environments, and automate deployments through a powerful CLI.
No cloud dependency. No telemetry. No lock-in. Your schemas live in open files on your machine. Offered as community and commercial editions — both with the same core features.
Buy pgModeler Plus and fund Nullptr Labs,
ensuring you save time while keeping the project independent and evolving.
*Changes since:* ***v1.2.3***
**Summary:** pgModeler 2.0.0 is a major release and the direct successor to the 1.2.x series. The headline addition is multi-scene support, letting a single model split its canvas across multiple scenes so very large databases stay manageable to browse and edit. This cycle also brings a complete visual redesign of the application, a full translation of the interface into dozens of languages, initial PostgreSQL 18 support including temporal keys, and a substantial round of performance work targeting large models. Alongside the application itself, pgModeler now ships in two editions — Community and Plus — detailed below, with pgModeler Plus gaining a mature Git-based versioning workflow and an improved SSH tunnel plugin.
**pgModeler Community and pgModeler Plus:** Starting with this release, pgModeler is distributed in two editions. pgModeler Community remains free and open-source, and keeps the core modeling experience: creating and editing database models, generating SQL/XML, the model fix and metadata handling tools, and everything described in the rest of these notes unless stated otherwise. pgModeler Plus is a paid tier that, in addition to Community, includes the database import, model diff, SQL execution tool, data grid/data handling, and database explorer tools — all of which shipped with every build up to 1.2.3 and are now Plus-exclusive — plus the versioning and SSH tunnel plugins covered further below.
**Multi-scene support:** A model's canvas can now be segmented into multiple scenes instead of a single, ever-growing one, either automatically by schema or by a configurable object-count threshold. This keeps the editor responsive on databases with thousands of tables, where a single canvas used to become sluggish to pan, zoom and select on. A new panel lets you switch between scenes and change the segmentation mode, with previous/next navigation buttons for quick browsing. A table that relates to a table in a different scene shows a small marker instead of a relationship line crossing scenes; double-clicking it opens a dialog listing those relationships, with direct navigation to the related table or relationship. An option to also hide relationships between tables of the same scene is available, representing them the same way — useful for models where the drawn relationships add more visual noise than value. Both the segmentation mode and the hide-relationships option can be set up front when importing a database, in the GUI and via new `pgmodeler-cli --import-db` options (`--seg-mode`/`--seg-threshold` and `--hide-rels`); opening an existing model whose objects are concentrated in very few scenes now also offers to switch segmentation mode. The command-line model fix tool (`--fix-model`/`--fix-sdbm`) preserves a model's segmentation data instead of discarding it.
**Orthogonal relationship lines:** Relationships can now be drawn with an orthogonal line style, made only of horizontal and vertical segments routed around tables and the crow's foot areas of other relationships. Where lines cross, one hops over the other through a small arc whose shading tells which line is on top. Holding SHIFT and dragging a segment moves it, and the end segments can be shifted through a jog next to the table; these adjustments are saved with the model and in the metadata files (ALT+SHIFT+click discards them). The style (straight, curved or orthogonal) is now chosen in the relationships settings, with orthogonal as the new default, and replaces the former "Use curved lines" option.
**Relationship colors and line widths:** Relationships gained a "Line color" submenu in their context menu: with one or more relationships selected (and nothing else), you can assign a random custom color to them, which makes it easier to tell apart the lines of densely connected models, or disable the custom color again. Both actions can be undone. The appearance settings also got two new options, "Objects border width" and "Relationships line width", that adjust the thickness of the object borders and of the relationship lines as a percentage of the default width (from 50% to 200%) with a live preview in the settings page; the built-in themes now use 150% for the borders and 110% for the relationship lines.
**PostgreSQL 18 support:** Added initial support for PostgreSQL 18, including the new temporal keys: primary and unique constraints can be defined with `WITHOUT OVERLAPS`, and foreign keys can reference them using `PERIOD`, letting you model time-bound data such as validity periods or scheduling ranges following the SQL standard, instead of relying on ad-hoc check constraints.
**Integrated workflow tools:** The database import, model diff and model export tools are no longer separate dialogs — they are now integrated into the main window as dedicated views ("Import view", "Diff view", "Export view"), consistent with the main design view. The model fix and metadata handling tools were likewise merged into a single, integrated tool.
**Visual redesign:** The application went through a full visual overhaul. A new theming engine renders widgets contextually across all built-in themes (light, dark, inksaver and a custom-theme option), including tooltips, scrollbars, tab bars, progress bars, menus, checkboxes, radio buttons and more, with theme-adaptive accent colors and smart theme detection. A new default canvas font and a refreshed color scheme make tables, column types (PK, FK, NN, UQ) and constraints easier to tell apart at a glance; editing forms were modernized into cleaner tabbed and vertical layouts with consistent tab-key navigation; and the application's logo, icons and splash screen were redesigned across every platform.
**Internationalization:** The user interface can now be fully translated, and this release ships with translations for the languages that best represent pgModeler's current audience, based on usage statistics, including Brazilian Portuguese (pt_BR) — all of them generated with AI assistance, with human review of their accuracy still pending (collaborations are welcome!). More languages will be added as that audience grows. Every executable, not only the main GUI, now follows the configured UI language.
**Performance improvements:** Several bottlenecks that mattered most on large, real-world models were addressed. The internal template engine behind every bit of generated SQL and XML code was substantially reworked for speed, on top of no longer reloading and reprocessing those internal template files on every use — together, SQL and XML generation on real-world models is 50-70% faster, which also speeds up opening and saving large models. Also addressed: slow object lookups by name, and a multi-second stall when applying changes through the database editing form on large models. Canvas rendering was also optimized to stay smooth while panning, zooming or dragging, and when working with large or densely connected models.
**Stability and reliability:** This cycle closes a substantial number of crashes and memory-related issues, among them: a crash during model validation when a column was restored via undo; a crash/freeze condition in the model close and reload flow; data corruption when closing or reloading models that used certain user-defined types; crashes in the model export and SQL tool; crashes when moving segments of orthogonal lines; an intermittent crash when generating SQL/XML code from more than one thread at the same time (export, validation, database import and model diff all do); and a `--fix-sdbm` bug that was discarding almost every object of a split model saved with ID comments. A batch of memory leaks was also closed across relationship handling, the undo/redo history, copy-and-paste, and model loading, which should help keep memory usage in check during long editing sessions.
**Credentials protection:** The passwords of database connections and SSH tunnels are now saved encrypted in `connections.conf` and `sshtunnel.conf`, and these files become readable only by their owner. This keeps the passwords from being read by simply opening the files, e.g., by another user of the same machine or in a copy of the file; the protection is not meant to withstand someone who already controls your account. Existing passwords are converted the next time the settings are saved. Older pgModeler versions can't read the encrypted passwords, so after a downgrade the passwords must be typed again, and the configuration folder copied from the previous version (`pgmodeler-1.2`) still holds the old passwords in plain text. In the pgModeler Plus versioning plugin, the credentials (user and password, or access token) embedded in HTTPS remote URLs are masked in the plugin's log, in its error and warning messages and in the remote URL it shows; note that Git itself still stores them in plain text in the repository's `.git/config`.
**pgModeler Plus — Safer database dropping:** Dropping a database in the SQL tool (from the database explorer's toolbar or the database list) now has a second confirmation. After accepting the usual warning, a "Danger zone" dialog asks for the name of the database to be typed, and the drop only proceeds when it matches exactly, protecting against accidental drops.
**Compatibility notes:** The "Use curved lines" option no longer exists and the default relationship line style is now orthogonal; pick the style you prefer in the relationships settings after upgrading. The default foreign key column naming pattern changed to a table-first convention; if your models rely on the previous defaults, review your `relationships.conf` after upgrading. Developers building plugins should consult `CHANGELOG.md` for the complete list of code-level changes, since several widgets and classes were renamed or moved as part of the Community/Plus split and the visual redesign. Passwords saved by previous versions are re-saved encrypted; see "Credentials protection" above for what that means when downgrading.
**pgModeler Plus — Versioning plugin:** This cycle brings a Git client embedded directly in pgModeler as part of Plus. You can clone remote repositories with live progress, HTTPS credentials or SSH keys; manage remotes and their push URLs from Repository Settings; stage or unstage individual files with filters and a side-by-side diff view before committing (split-model files included); push, pull and sync with a configurable reconcile strategy and upstream tracking; resolve merge/pull conflicts in a dedicated mode that inspects base/local/remote versions of each file; merge any branch into the current one; cherry-pick commits; amend the last commit; reset to any historical commit (soft, mixed or hard); revert a commit without rewriting history; manage tags (create, remove, sync, annotate); and save, browse, apply, pop or drop stash entries. SSH agent keys are picked up automatically, and the Git credential manager can be configured directly from Repository Settings.
**pgModeler Plus — SSH tunnel plugin:** The SSH tunnel plugin gained more granular control over your tunnels: automatic startup on launch is now configured per tunnel instead of a single all-or-nothing switch, the toolbar button shows whether any tunnels are currently running with a tooltip summarizing active/stopped counts, and the tunnels menu lists every configured tunnel individually so each can be started or stopped on its own.
**Looking ahead:** With 2.0.0 out, the focus now shifts to collecting feedback from the community and addressing whatever issues come up with it, while development of 2.1.0 has not yet begun.
Feature highlights From schema design to production deployment
Visual schema construction
Design any PostgreSQL object visually — from simple tables to custom types, domains, operators, and procedural languages. The engine generates precise, production-grade DDL for every object.
Reverse engineering PLUS
Connect to any PostgreSQL server and reconstruct a full schema model from your live database. Recover legacy designs, document production schemas, or baseline a system for ongoing lifecycle management.
Incremental diff & sync PLUS
Compare your model against a live server. pgModeler generates the exact ALTER, DROP, and CREATE statements needed to synchronize the two states — no manual diffing required.
Validation & fixes
Catch broken references and rule violations at design time, before deployment. The validation engine checks cross-object dependencies and suggests automatic fixes.
Relationship-driven design
Link tables and pgModeler propagates columns, constraints, and indexes automatically. The column propagation engine handles inheritance and complex relationship chains.
Database management PLUS
Browse schemas, execute SQL, and manage data directly in the built-in module. Your model and your live database stay in the same workspace — no tool-switching required.
CLI for pipeline integration
Export DDL, run diffs, and push schemas to any environment — all from the command line, no GUI required. Fits naturally into any CI/CD workflow.
SSH tunneling PLUS
Connect securely to remote PostgreSQL servers over SSH tunnels. No VPN configuration needed — just your key and the host.
Git-friendly format PLUS
Save your schema as individual XML files — one per object. Each table, view, function, and policy becomes a separate file — making branches, diffs, and code reviews work naturally with any version control system.
Model versioning PLUS
Powered by Git, the version control for your models is built directly into the interface, keeping the entire model lifecycle in one single place.
No Saas lock-in
pgModeler runs entirely on your machine. Your schemas are never hosted on our infrastructure, so stop using pgModeler tomorrow and your work remains fully yours.
No proprietary format
Model files are open, human-readable XML. Inspect them in any text editor, transform them with standard tooling, and store them anywhere — forever.
Built specifically for PostgreSQL Designed around PostgreSQL-native schema engineering workflows
Fully local PostgreSQL modeling and engineering workflow with offline-capable usage and no mandatory cloud infrastructure. Commercial editions use periodic license validation without requiring cloud-hosted workflows.
With the column propagation mechanism, pgModeler automatically creates all columns and constraints as the user links tables using the available relationship objects avoiding repetitive tasks and improving productivity.
pgModeler can export the models to a SQL script, to a PNG image, to an SVG file, in the form of a data dictionary in HTML format, or directly to a PostgreSQL server.
Model files are stored in open, human-readable XML. You can diff them line-by-line in Git, process them with standard tooling, or inspect them in any text editor — no proprietary format, no vendor dependency.
In case of unexpected quit, the user doesn't lose all the work because pgModeler stores temporary models with the most recent changes and will restore them in the next startup.
The validation engine checks cross-object references and constraint rules at design time, surfacing errors before deployment. Most issues can be fixed automatically.
Export DDL, run diffs, and automate schema deployments without launching the GUI. Designed to integrate cleanly into CI/CD pipelines and scripted workflows.
Connect to any live PostgreSQL server and reconstruct a full schema model from your existing database. Useful for documenting production systems, recovering legacy designs, or baselining a schema for ongoing lifecycle management.
Compare your schema model against a live PostgreSQL server and generate the exact ALTER, DROP, and CREATE statements needed to bring them in sync — no hand-written migrations.
Other notable features include an object finder for navigating large models, a plugin development interface, a translatable user interface, and much more. For a comprehensive overview of all pgModeler's features, visit the official documentation.
From the community Engineers who use pgModeler in production
“Great progress, pgModeler is the best tool for PostgreSQL, for sure.
I use pgModeler as a tool to verify the database model generated by an ORM system.
The database structure is automatically created based on classes in the application code, I review the resulting model to ensure it looks correct.”
“We have used pgModeler in several projects and one of the things that most pleases and surprises us is the performance of the tool. Whether for small projects or models with hundreds of tables, pgModeler is practical, lightweight and very powerful.
No doubt it's the best Open Source project of its kind.”
“We have used pgModeler quite extensively for our database design - from creating the detailed databases, schemas and other DB objects. It was very helpful, especially for the unending iterations of our design enhancements as requested by our client. The fact it created SVG image files and data dictionaries as well, also helped immensely with the documentation.”
“I would like to leave my thanks and praise to the pgModeler team. I have been using the tool to model the entire database of my projects in Supabase and the experience has been fantastic.”
Ricardo AzevedoSystems Development Coordinator — AletoPalmas, Brazil
“Having a data modeling tool is essential for us. We maintain a DM with more than 500 tables in pgModeler and it does it job perfectly! We developed some enhancement for generating SQL from the DM. Here it really help that pgModeler stores the DM in a well structured easy to read XML file.”
Andreas BrandtBusiness Requirements and Design — brandt ITGrasbrunn, Germany
Latest from Nullptr Labs Releases, fixes, and announcements
Multi-scene, orthogonal relationships, a complete Git client and a whole new look
It took more than a year, one alpha, one alpha1, one beta, and one beta1, but pgModeler 2.0.0 is finally stable. This is
the biggest release the project has ever had, with more than 850 commits since 1.2.3 alone, and this post tells the
whole story from 1.2.3 to today. The headline feature is multi-scene support: a model can now split its canvas into
scenes, by schema or by number of objects, so databases with thousands of tables stay fast to browse and edit.
Relationships can now be drawn with orthogonal lines routed around the tables, the new default. The whole
application was redesigned, from the logo and icons to a new theming engine, new fonts, and completely rebuilt
editing forms, and the interface can finally be translated, shipping with 34 languages including Brazilian Portuguese.
Import, Diff, Export, and Fix are now views of the main window. Diff can compare two models with no database at all. The SQL tool is more capable, PostgreSQL 18 temporal keys are supported, and SQL/XML generation is 50-70% faster
on real-world models. A long list of crashes and memory leaks is gone, saved connection and SSH tunnel passwords
are now encrypted, and a completely revisited user manual covers everyone from first-time users to plugin developers.
pgModeler now comes in two editions: Community stays free and open-source, and Plus adds import, diff, the SQL
tool, data handling, the database explorer, a complete Git client built right into the app, and a redesigned SSH tunnel
plugin. There are a couple of things to know before upgrading, like the new foreign key naming pattern. Grab a coffee;
this one is long, and I am proud of every line of it.
The access to binary packages has changed. You must create a download token in the key management section before proceeding with the download.
Get source code
pgModeler has two main development branches: main and develop. The main branch is where features considered stable can be found. The development branch, reserved for alpha and beta releases, is where patches, new unstable features are placed and tested.
You can retrieve the source using the git command by running the following:
If you prefer, there are source tarballs ready to be compiled. Once you got the source, you can follow the instructions to compile pgModeler described in the Installation page.
Do you really want to generate a new token for this user? The current token will be invalidated and a new one will be sent by email.
Access key recovery
Preparing your
payment, please wait...
Do not close the page or cancel the loading!
Payment invoice
Support Development Invest in the tools you use
Why Donate?
pgModeler is proudly maintained by Nullptr Labs. While open source, continuous development requires significant resources.
By contributing financially, you ensure the project's long-term sustainability. If pgModeler adds value to your workflow, consider supporting its evolution. Donations are handled through GitHub Sponsors, where you choose the amount and frequency that suit you.
This is a voluntary contribution to open-source development and does not grant access to pre-compiled binaries. To purchase the installer, please visit the Purchase section.
Thank you for your purchase! In a few minutes you'll receive an email containing the instructions on how to download your packages as well some important notes about your purchase. Note that some email servers can flag the email as spam so make sure to check your SPAM box too. In case of problems, please contact the developer from the Support menu.
Enjoy pgModeler!
Get a trial key — pgModeler Plus
Student discount — pgModeler Plus
Contact the developer
For feature requests or bug reports we kindly ask you to open a ticket on the GitHub issues page.