Open-source alternatives to Pony

SQLAlchemy is a comprehensive Python SQL toolkit and object-relational mapper that provides a full suite of tools for interacting with relational databases. It serves as a foundational layer for database connectivity, offering both a high-level object-oriented interface for data persistence and a programmatic SQL expression language for constructing complex, dialect-agnostic queries. The project distinguishes itself through its sophisticated unit of work persistence, which coordinates atomic transactions and tracks object state changes to minimize redundant database operations. It provides a

Mikro-ORM is a TypeScript-based object-relational mapping system that provides a unified persistence layer for Node.js applications. It translates TypeScript entities into relational or document-based database schemas, supporting a variety of engines including PostgreSQL, MySQL, MariaDB, MS SQL Server, SQLite, and MongoDB. The project implements the data mapper pattern to decouple in-memory domain models from the database persistence layer. It utilizes a unit of work pattern to track entity changes in memory and commit them in a single coordinated database transaction. The library covers com

Doctrine ORM is a PHP object-relational mapper that connects application objects to relational database tables. It uses the data mapper and identity map patterns to decouple the in-memory object model from the database schema, allowing developers to manage data persistence without writing manual SQL. The project features a dedicated object-oriented query language and programmatic builder for retrieving data based on entities rather than tables. It implements a unit-of-work system to track object changes during a request and synchronize them via atomic transactions. The capability surface inc

Dapper is a lightweight object-relational mapper for .NET that functions as a high-performance data access library. It operates by extending standard database connection interfaces, allowing developers to execute raw SQL queries while automating the mapping of database results to strongly-typed objects. The library distinguishes itself through its use of runtime code generation, which creates high-performance instructions to map database rows to object properties with minimal overhead. It provides flexible data retrieval options, supporting both memory-buffered loading for speed and row-by-ro

Objection.js is an object-relational mapper for Node.js that maps SQL database tables to classes and rows to model instances. It functions as a high-level abstraction layer built on top of the Knex.js query builder to provide structured model definitions and relational data mapping. The project distinguishes itself through its ability to manage complex object graphs, allowing for the persistence and eager-loading of deeply nested related data in single operations. It incorporates a data integrity layer that uses JSON schema validation to verify model instances before they are persisted to the

GORM is a developer-focused object-relational mapping library for Go that provides a comprehensive data persistence framework. It serves as a database access layer, allowing developers to map application structures to database tables and perform CRUD operations using a fluent, type-safe query builder instead of writing raw SQL. The library distinguishes itself through its association-aware persistence, which automatically tracks and synchronizes complex entity relationships during database operations. It utilizes a driver-agnostic interface to maintain consistent behavior across various stora

DoctrineBundle is a Symfony integration that configures and manages the Doctrine Object Relational Mapper and Database Abstraction Layer. It provides the fundamental tools required to map application objects to relational database tables and execute raw queries through a consistent programmatic interface. The project includes a database schema manager with command-line tools for synchronizing database structures with entity mappings and executing migrations. It also provides a database query debugger and activity debugging tools to track performance and execution details via a web-based inter

TypeORM is an object-relational mapper for TypeScript and JavaScript that bridges the gap between object-oriented application code and relational database tables. It provides a comprehensive data persistence layer that allows developers to define database entities using class decorators or configuration objects, enabling seamless interaction with data through object-oriented patterns. The project distinguishes itself through a flexible architecture that supports both the data mapper and repository patterns, alongside a fluent query builder that translates high-level method calls into platform

SQLModel is a type-safe object-relational mapping library for Python that integrates database schema definitions with data validation logic. By combining these two roles into a single class, it allows developers to manage relational data structures and enforce data integrity for web APIs simultaneously. The framework is built to support asynchronous database operations, enabling high-performance applications to execute queries and transactions without blocking the main execution thread. The library distinguishes itself by leveraging Python type hints to provide IDE autocompletion and compile-

Beekeeper Studio is a cross-platform desktop application designed for database management and SQL development. It provides a unified graphical interface to connect to, query, and modify data across a wide range of relational and NoSQL database systems. The application functions as a comprehensive workspace, integrating tools for schema design, record editing, and data visualization. The project distinguishes itself through a focus on secure, flexible connectivity and AI-assisted workflows. It supports advanced authentication methods, including enterprise single sign-on, multi-factor authentic

This project is a SQL data access layer and schema generator that allows for reading and writing records in relational databases by treating tables as simple data structures. It functions as an automatic schema generator that creates database tables and columns on the fly based on the structure of the incoming data. The tool provides a high-performance bulk loader that imports large datasets using grouped atomic transactions to ensure data consistency. It also includes a record upsert mechanism that determines whether to update an existing row or insert a new one based on unique identifiers.

TablePro is a cross-platform database management client designed for browsing, querying, and administering both SQL and NoSQL databases. It functions as a unified workspace that integrates a code-centric SQL editor with schema visualization tools, allowing developers to manage complex data models and execute queries across diverse database engines. The application distinguishes itself through an agentic AI integration layer that connects language models directly to database tools, enabling automated query generation, optimization, and error fixing with configurable approval gates. It features

Django is a full-stack web framework designed for rapid backend development. It provides an integrated environment for building data-driven applications by combining an object-relational mapping layer for database management with a modular request-response pipeline for handling HTTP traffic. The framework emphasizes security and maintainability, offering a suite of tools to protect against common web vulnerabilities while decoupling site structure from implementation through a centralized URL routing system. A defining characteristic of the framework is its ability to generate production-read

This project is an asyncio database abstraction layer that provides a common interface for performing non-blocking database operations in Python. It functions as an asynchronous database driver wrapper and a SQL expression builder, allowing for the construction of raw SQL strings from structured Python objects. The library includes an asyncio connection pool manager that utilizes task-local storage to handle connection lifecycles and reduce resource overhead. It also serves as an async database transaction manager, wrapping operations in atomic transactions and savepoints to maintain data int

Tortoise ORM is an asynchronous object-relational mapper for Python that mirrors Django's model and queryset API while running on asyncio. It defines database tables as Python classes with typed fields and supports foreign key, many-to-many, and one-to-one relations, providing a chainable query API for filtering, annotating, grouping, and prefetching related objects without blocking the event loop. The ORM includes a built-in migration engine that detects model changes, generates migration files, and applies or reverts schema changes through a command-line tool. It connects to PostgreSQL, MyS

Prisma is a database toolkit that provides a unified access layer for interacting with relational and document databases. It centers on a declarative schema modeling approach, where developers define their data structures in a human-readable language. This schema serves as the single source of truth, from which the toolkit automatically generates type-safe database clients that provide compile-time validation and editor autocomplete for all data operations. The project distinguishes itself through a high-performance, Rust-based query engine that handles query planning and connection pooling o

Ever Gauzy is an integrated business management suite providing an ERP and CRM framework for professional services automation. It functions as a multi-tenant SaaS platform that combines time tracking, billing, and human resource management into a unified system. The project is distinguished by its headless architecture, utilizing a REST and GraphQL API gateway to expose business operations. It features a Model Context Protocol server that allows AI assistants to interact with system data and execute functional tools for automated business workflows. The platform covers a broad operational su

Hibernate ORM is a Java object-relational mapper and a full implementation of the Jakarta Persistence API. It serves as a SQL database abstraction layer that translates Java object models into relational database schemas to manage data persistence and lifecycles. The framework distinguishes itself with a multi-tenant data isolation framework for separating customer data within a single database instance. It also features a database schema generator that automatically produces and updates relational structures based on entity mappings. The system covers broad capability areas including transa

Flask-SQLAlchemy is a relational database toolkit that integrates the SQLAlchemy object-relational mapper into web applications. It serves as a database session manager and schema toolkit, providing the necessary infrastructure to define data models and execute queries within a request lifecycle. The project is distinguished by its multi-database routing engine, which uses bind-keys to map different models to multiple distinct database engines. It also includes a SQL query auditing tool that captures and logs executed statements and timing data for a single request to identify performance bot

Sequelize is an object-relational mapping library that provides a unified interface for managing relational data through code. By implementing the Active Record pattern, it maps database tables to application objects, allowing developers to perform standard create, read, update, and delete operations using high-level method calls. The library abstracts complex database interactions by translating these calls into optimized, engine-specific SQL statements, ensuring consistent behavior across different database systems. The project distinguishes itself through a comprehensive suite of tools for

This project is a comprehensive guide to architectural standards and coding patterns for developing maintainable applications within the Laravel framework. It focuses on clean code standards, applying the single responsibility and DRY principles to ensure codebase predictability and consistency. The guide emphasizes decoupling components by moving business logic into service layers and shifting input validation into dedicated request classes to keep controllers lean. It advocates for the use of a service container and dependency injection to reduce class coupling and improve testability. The

Gorp is a lightweight object-relational mapper for Go that binds structs to relational database tables. It functions as a relational data mapper and SQL dialect abstraction layer, automating the translation between application data and relational rows. The project provides a translation layer that generates vendor-specific SQL for PostgreSQL, MySQL, SQLite, Oracle, and SQL Server. It distinguishes itself by implementing optimistic locking via version columns to prevent concurrent update conflicts and providing a database schema generator to create tables and indexes from object definitions.

CodeIgniter is a PHP web framework built on the Model-View-Controller pattern, designed for building full-stack web applications. It provides a lightweight toolkit with minimal configuration, organizing application logic into controllers, models, and views for clean separation of concerns. The framework includes a fluent query builder for constructing SQL statements programmatically, PSR-4 autoloading with namespace mapping, and a service-based dependency injection container for managing shared class instances. The framework distinguishes itself through its comprehensive set of built-in tools

Oatpp is a high-performance C++ web framework and API development kit used for building REST APIs and web services. It functions as an asynchronous HTTP server that utilizes coroutines to handle thousands of simultaneous connections without blocking threads. The toolkit includes a native C++ object-relational mapping layer for executing SQL queries and transforming database results into data objects. It also provides a WebSocket communication library for establishing full-duplex channels to support real-time data streaming and live media. The framework covers a broad range of capabilities, i

xorm is a relational mapper and object-relational mapping tool for Go. It translates Go structures into SQL queries and maps database rows back into native objects, providing a multi-dialect database driver that supports MySQL, PostgreSQL, SQLite, Oracle, SQL Server, and TiDB. The project features a read-write splitting manager that routes modification requests to a primary database and read requests to replicas. It includes a database schema synchronizer to automatically align table structures and indexes with application data models, as well as a fluent SQL query builder for constructing co

LearnPython is a programming tutorial consisting of a collection of practical code examples used to demonstrate Python language features and programming patterns. It serves as a comprehensive learning resource that implements core language concepts through functional code. The project provides specialized guides and samples covering several key domains. These include asynchronous network programming with event loops and coroutines, data visualization using numerical datasets for 2D and 3D plots, and web scraping for fetching content and automating login flows. It also features instructions on

Kùzu is an embedded property graph database engine designed for high-performance analytical queries and local data management. It operates as a library within the host application process, utilizing a columnar-based storage architecture and just-in-time query compilation to execute complex graph traversals and pattern matching efficiently. By mapping database files directly into system memory, it ensures data durability and high-speed access while maintaining ACID-compliant transactional integrity. The engine distinguishes itself by integrating vector similarity search and full-text search di