PulseORM is a lightweight ORM for .NET 8 and above. It reduces raw SQL compared to Dapper, stays far more minimal than EF Core, and is designed to deliver Dapper-level performance with predictable ADO.NET-based mapping.

• .NET 8,9 and 10 support
• Lightweight query API with expression-based filtering
• CRUD operations (Insert, Update, Delete, GetById)
• Bulk operations (BulkInsert, BulkUpdate)
• Pagination support
• Join pipeline with projection support
• Raw SQL entry point with typed materialization
• Multi-dialect support:
  • PostgreSQL
  • SQL Server
  • Oracle

• PulseORM.Core: Core ORM library

** This is an example Project. Please Check it

• PulseORM.Entities: Shared entities/models
• PulseORM.DemoEntities: Demo entity models
• PulseORM.DemoDataLayer: Demo data access layer
• PulseORM.DemoService: Demo service layer
• PulseORM.DemoApi: Demo API application

Clone the repository and restore dependencies:

git clone <https://github.com/unutma/PulseORM.git>
cd PulseORM
dotnet restore

using PulseORM.Core;

var factory = new NpgsqlConnectionFactory(connectionString);
var dialect = new PostgresDialect();

var db = new PulseLiteDb(factory, dialect);

var users = await db.Query<User>()
    .FilterSql(x => x.IsActive)
    .ToListAsync();

PulseORM supports both built-in and custom attributes.

using PulseORM.Core;

[Table("users")]
public class User
{
    [Key]
    [Column("id")]
    public int Id { get; set; }

    [Column("email")]
    public string Email { get; set; } = string.Empty;

    [Column("is_active")]
    public bool IsActive { get; set; }
}

var user = new User { Email = "john@site.com", IsActive = true };

await db.InsertAsync(user);
await db.UpdateAsync(user);
await db.DeleteByIdAsync<User>(user.Id);

var byId = await db.GetByIdAsync<User>(user.Id);
var all = await db.GetAllAsync<User>();

var (items, total) = await db.GetAllPagedAsync<User>(
    page: 1,
    pageSize: 20,
    orderBy: x => x.Id,
    descending: false,
    whereInclude: x => x.IsActive
);

var admins = await db.SqlQuery<User>(
    "SELECT id, email, is_active FROM users WHERE role = @role",
    new Dictionary<string, object?> { ["role"] = "admin" }
).ToListAsync();

var result = await db.QueryJoin<Order>()
    .IncludeOne<Customer>(o => o.Customer, o => o.CustomerId, c => c.Id, JoinType.Left)
    .FilterSql(o => o.IsActive)
    .SortBy(o => o.Id)
    .Pagination(1, 20)
    .ToListAsync();

• PostgreSQL: PostgresDialect + NpgsqlConnectionFactory
• SQL Server: SqlServerDialect + SqlConnectionFactory
• Oracle: OracleDialect + OracleConnectionFactory

dotnet build PulseORM.sln

• PulseORM focuses on writing less bare SQL than Dapper while preserving explicit query control.
• The implementation is intentionally much more minimal than EF Core.
• Performance goals target Dapper-like throughput and low overhead.
• For production usage, make sure all entity keys and mappings are explicit and verified.