Native PostgreSQL schema engineering

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.

Key features    See it in action    Impressions

pgModeler Plus

Pre-built binaries + professional workflow features.

Academic student? Get 50% off!


Stable release

2.0.0

October 30, 2026 | Release notes


  • Source code

    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

    Capability pgModeler Cross-database modeling tools
    PostgreSQL-native object model

    Supports 30+ PostgreSQL object types including domains, custom types, operators, collations, procedural languages, event triggers, foreign data wrappers, extensions, and more.

    30+ PG object types Partial PG-specific support
    Relationship-driven schema propagation

    Relationships automatically propagate FK columns, constraints, and indexes with PostgreSQL-aware DDL generation.

    Auto FK/constraint propagation Varying DDL propagation depth
    Incremental model-to-database diff & sync

    Compares models against live PostgreSQL databases and generates minimal ALTER/DROP/CREATE statements for controlled schema synchronization.

    Generates ALTER/DROP/CREATE Basic diff/sync, limited PG fidelity
    Full PostgreSQL reverse engineering

    Reconstructs editable PostgreSQL models including views, functions, triggers, RLS policies, inheritance, partitions, extensions, and more.

    Full incl. RLS, triggers, FDW, foreign tables Tables & views focus only
    Row-Level Security (RLS) policy design

    Create, visualize, validate, and export PostgreSQL RLS policies directly in the model.

    First-class RLS support Rarely supported
    Table inheritance modeling

    Native support for PostgreSQL table inheritance with correct diagram representation and DDL generation.

    Native PostgreSQL inheritance Rarely modeled natively
    Functions, procedures & triggers in the model

    Model PL/pgSQL functions, procedures, and triggers directly in the schema with full source export support.

    PL/pgSQL in schema Limited visual integration
    Partitioned table support

    Supports declarative PostgreSQL partitioning (RANGE, LIST, HASH) including partition definitions and child partitions.

    Native PG table partitioning via relationship Partial or non-native support
    Design-time validation engine

    Detects broken references, circular dependencies, naming conflicts, and PostgreSQL rule violations before deployment.

    Pre-deploy validation Basic validation only
    Headless CLI for CI/CD pipelines

    Run exports, diffs, validation, and deployments through command-line workflows and automation pipelines.

    CLI automation ready Mostly GUI-oriented
    Open, human-readable model format

    Models stored as plain XML files designed for Git workflows, diffs, scripting, and long-term accessibility.

    Plain XML, Git-friendly Varies; may not be Git-friendly
    Multi-format export

    Export models as SQL, PNG, SVG, HTML data dictionaries, and deployment scripts from a single source model.

    SQL, PNG, SVG, HTML Varies by platform
    Local-first & offline-capable 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.

    Fully offline capable Partial cloud dependency
    Open-source core

    Fully open-source under GPL with source-code access and self-compilation support.

    GPL, self-compile Often proprietary
    Professional licensing model

    Flexible licensing focused on ready-to-run binaries, perpetual ownership options, and sustainable independent development.

    Perpetual and subscription models Subscription-centric
    Vendor lock-in risk

    Open model format, local-first workflows, and no proprietary hosted backend dependency.

    Low risk Lock-in level varies
    Long-term workflow ownership

    Models remain accessible independently of hosted infrastructure or subscription continuity.

    No vendor dependency Depends on vendor continuity
    Target workflow focus

    PostgreSQL-native schema engineering, architecture design, reverse engineering, and advanced database lifecycle workflows.

    PostgreSQL-specialized Generic multi-database focus
    Value proposition

    Deep PostgreSQL specialization combined with independent, sustainable, and ownership-friendly tooling.

    Deep PostgreSQL specialization Broad coverage, less PG depth

     Fully supported     Partial / limited / varies by tool     Rarely or not supported

    Edition comparison
    The core is free. Plus adds the professional workflow.

    Description pgModeler Plus logo
    pgModeler Plus
    pgModeler Community logo
    Community edition
    Software distribution Pre-built binaries + professional features Source code — free forever
    30+ PostgreSQL object types

    Design tables, views, schemas, functions, operators, custom types, domains, sequences, triggers, row-level security policies, and more — pgModeler covers the breadth of PostgreSQL's object model natively.

    Relationship-driven column propagation

    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.

    Export to SQL, PNG, SVG, HTML, or live server

    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.

    Open XML format — Git and tool-friendly

    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.

    Crash recovery and model restoration

    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.

    Schema validation and automatic fixes

    The validation engine checks cross-object references and constraint rules at design time, surfacing errors before deployment. Most issues can be fixed automatically.

    Extensive customization options

    With an extensive set of configurations, pgModeler gives the user the freedom to customize most of its features.

    Command-line interface (CLI)

    Export DDL, run diffs, and automate schema deployments without launching the GUI. Designed to integrate cleanly into CI/CD pipelines and scripted workflows.

    PostGIS support

    Geometry and geography types are recognized natively — not treated as unknown custom types. Design spatial schemas without workarounds.

    Reverse engineering from live databases

    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.

    Incremental diff & sync

    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.

    Built-in database management module

    Browse schemas, run SQL commands, and manage data directly in the built-in module — no need to switch to an external client for day-to-day operations.

    SSH tunneling for remote connections

    Integrated SSH tunneling support for secure remote connections.

    Git-friendly split-model format

    Allows saving objects in separate files to improve version control management (Git).

    Save and restore sessions

    Persist your opened tabs and connections in the database management module.

    Query variables for SQL testing

    Use variables in your SQL scripts to facilitate testing and execution.

    Database backup utilities

    Integrated interface for pg_dump and pg_restore tools.

    Quickly create objects

    Shortcuts and wizards to create objects faster.

    Quickly search and edit objects

    Global search tool to find and edit objects anywhere in your model.

    Additional features

    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

    Latest from Nullptr Labs
    Releases, fixes, and announcements

    pgModeler 2.0.0: The biggest release in the history of the project

    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.

    Read more

    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.