Open-source alternatives to EntityFramework

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

ActiveAndroid is an object-relational mapper and data persistence library for Android. It serves as a high-level wrapper for SQLite databases, translating database records into class instances to facilitate data manipulation. The library enables data persistence without the need to write manual SQL queries. It maps database rows to Java objects, allowing records to be saved, retrieved, and deleted using object-oriented methods. The toolkit covers local mobile data storage and database management, providing a layer that links database table structures to specific object properties.

Peewee is a SQL object-relational mapper and query builder that provides an object-oriented interface for mapping application classes to relational database tables. It functions as a relational database toolkit for managing schemas, executing migrations, and handling complex table relationships. The project distinguishes itself by providing an asyncio database driver for non-blocking database operations, ensuring event loop responsiveness. It also supports semi-structured data storage, allowing the storage and querying of flexible JSON documents within traditional relational database systems.

WCDB is a cross-platform storage layer and embedded database engine that serves as a framework for SQLite. It functions as an object relational mapper, linking application classes to database tables to enable data operations via objects rather than raw queries. The project is distinguished by an integrated encryption layer for securing data at rest and a full-text search engine that uses language-specific tokenizers for text lookups. It also features transparent field compression to reduce storage footprints and a connection-pooling model to coordinate simultaneous read and write operations a

greenDAO is an object-relational mapping library for Android that maps Java objects to SQLite databases. It provides infrastructure for high-performance data persistence by translating data objects into database records and vice versa. The library implements a type-safe query builder for retrieving records across multiple entities using joins and relationship chaining. It also includes a security layer that provides full-disk encryption for the SQLite database to prevent unauthorized access to stored information. The system utilizes compile-time code generation to create mapping classes, avo

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

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

This project is a markdown-based personal knowledge base and digital learning journal used to store notes and summaries from books and technical literature. It serves as a reading summary repository and technical reference library for archiving key takeaways and insights from non-fiction and professional materials. The collection functions as a digital garden for curating insights from books, articles, and videos. It specifically focuses on distilling complex architectural patterns, technical concepts, and professional leadership principles into a searchable format for long-term reference. T

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

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

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

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

FreeSql is a .NET object-relational mapper and data access layer that translates object-oriented code into SQL for multiple relational database providers. It functions as a fluent SQL query builder and database schema synchronizer, allowing developers to align database table and index structures with entity class definitions. The framework is specifically optimized for .NET Native AOT to ensure reduced memory footprints and faster startup times. It includes a database traffic manager to distribute load through read-write splitting, dynamic table sharding, and tenant-based data isolation. Bro

Ebean is a Java object-relational mapping framework designed to simplify database persistence through automated query generation, schema migration, and transaction management. It uses metadata-driven mapping and bytecode enhancement to bridge the gap between application objects and relational database tables, providing a persistent layer that handles complex data interactions while maintaining consistency across unit-of-work boundaries. The framework distinguishes itself through its focus on developer productivity and performance optimization. It provides type-safe query builders that generat

SqlSugar is an object-relational mapping library for .NET that translates C# and VB objects into database queries and tables without requiring raw SQL. It is designed as a multi-database ORM supporting SQL Server, MySQL, PostgreSQL, Oracle, MongoDB, ClickHouse, and other databases through a unified API, and it is compatible with .NET AOT compilation for native ahead-of-time deployment. The library distinguishes itself through high-speed bulk data operations that can insert or update millions of records in seconds using batch processing instead of row-by-row handling. It also provides multi-te

Yii is a full-stack PHP web framework and component-based system designed for building dynamic websites and RESTful services. It operates as an MVC application framework that separates business logic from the user interface and includes a built-in object-relational mapper for interacting with databases. The project provides a comprehensive command line toolset for project bootstrapping, automated code generation, and the execution of background tasks. It utilizes a component-based architecture and a service locator to manage dependency injection and object lifecycles. The framework covers a

Sequel is a relational database toolkit for Ruby that provides object-relational mapping, a fluent SQL query builder, and schema migration capabilities. It maps database tables to Ruby classes with support for associations, validations, lifecycle hooks, and eager loading, offering a comprehensive ORM layer for building data-centric applications. Sequel distinguishes itself through a plugin-based extension architecture that allows composable customization of models, databases, and datasets without relying on deep inheritance hierarchies. It includes a thread-safe connection pool with support f

Nodal is a Node.js API framework designed for building data-centric web services and JSON APIs using structured data models. It functions as an object-relational mapper that allows for the querying and manipulation of database records through objects instead of raw SQL queries. The project includes a database migration tool for tracking and applying bi-directional schema changes to maintain data integrity across different environments. It also features a command line interface for automating the registration and configuration of remote hosting environments. The framework provides capabilitie

sqlite-net is a lightweight object-relational mapper and data access layer for SQLite. It provides tools for translating application classes into database tables, managing records through an entity mapper, and implementing local data persistence. The library includes an encrypted wrapper that secures database files using connection keys and native encryption configurations. It also features a data access layer that supports both synchronous and asynchronous operations to maintain application responsiveness during disk access. The project covers a range of database management capabilities, in

Beego is a high-performance toolkit for building web applications and RESTful APIs using the Go programming language. It is structured as an MVC web framework that separates data models, views, and controllers to organize application logic. The project provides a comprehensive suite of integrated tools, including an object-relational mapper for translating code objects into database tables and a session manager for maintaining user identity and state across server requests. It also includes an internationalization framework for managing multilingual content and translating text based on user

Pothos is a code-first GraphQL schema builder and framework designed for type-safe development. It allows developers to construct schemas using typed definitions in TypeScript, eliminating the need for external code generation steps. The framework distinguishes itself through a dedicated data mapper that connects GraphQL types to relational databases and ORMs, such as Prisma, while optimizing query resolution. It provides a full implementation of the Relay specification, including global object identification and cursor-based pagination. The project covers several core capability areas, incl

EdgeDB is a graph-relational database that combines a PostgreSQL backend with a graph-based schema and query language. It functions as an object-relational mapper and graph query engine, allowing data to be modeled as objects and links to align storage with modern programming language structures. The system features a composable query language designed to retrieve deeply nested or interconnected data without the use of manual SQL joins. It includes an integrated AI-driven data retrieval solution with built-in support for vector embeddings. The platform provides a schema migration tool for tr

Sea-ORM is an asynchronous SQL object-relational mapper and database toolkit for mapping relational tables to strongly typed objects. It provides a relational database mapper for performing CRUD operations across MySQL, PostgreSQL, and SQLite, and includes a programmatic dynamic query builder for constructing complex SQL statements. The project distinguishes itself by providing a GraphQL schema generator that transforms database entities into typed schemas with built-in pagination and filters. It also features a dedicated database migration tool for defining and applying versioned schema chan

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

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-

Loco is a full-stack web framework for Rust designed to accelerate application development using a convention-over-configuration approach. It functions as an MVC web framework that provides a structured environment for building web applications and REST APIs. The project distinguishes itself through an integrated API development toolkit and a command-line scaffolding engine. These tools automate the creation of controllers, models, and migrations, allowing for the rapid generation of functional CRUD resources and application boilerplate. The framework covers a broad range of backend capabili

linq2db is a type-safe object-relational mapper that translates LINQ expressions into optimized SQL queries for multiple database providers. It functions as a database mapper that links classes to tables and includes a SQL query builder and a command-line schema tool for generating data classes from existing databases. The project provides high-performance bulk data processing for inserting and loading large volumes of records via batch or binary copy methods. It also supports advanced SQL operations, including window functions, common table expressions for recursive hierarchical querying, an