AutoMapperLite vs. AutoMapper vs. Mapster

A feature comparison to help you choose the right tool, plus real measured throughput — not marketing claims.

Feature comparison

Throughput rows are measured with BenchmarkDotNet — see Performance for the full results, methodology, and every scenario. AutoMapperLite now beats AutoMapper on simple-object mapping, collection mapping, and has the fastest cold start of the three; its allocation is within a few percent of Mapster's/manual mapping's at any collection size. Its value proposition remains dependency footprint and simplicity — Mapster is still faster on raw per-call throughput.
Capability	AutoMapperLite	AutoMapper	Mapster
License	MIT, free	Commercial license required above revenue threshold	MIT, free
Runtime mapping strategy	Compiled expressions (cached delegate per type pair)	Compiled expressions	Compiled expressions / source generators
Dependency footprint	One small package (`Microsoft.Extensions.DependencyInjection.Abstractions`)	Larger, more moving parts	Small
LINQ `IQueryable` projection (`ProjectTo`)	No	Yes	Yes
Convention-based auto-mapping	Same-name, same-type properties	Extensive convention engine	Extensive convention engine
`ForMember` / custom member mapping	Yes	Yes	Yes
Deep nested destination paths	Yes (`ForPath`)	Yes	Yes
Collection mapping	Yes — `List<T>`, arrays, and common collection interfaces as destinations, incl. nested properties	Yes	Yes
Dependency injection integration	Built in (`AddAutoMapperLite`)	Via separate package	Via separate package
.NET targets	net6.0 – net10.0	Broad, actively maintained	Broad, actively maintained
Mapping a simple object (mean time, generic API)	27.5 ns	63.4 ns	18.4 ns
Mapping a simple object (allocated)	32 B	32 B	32 B
Mapping a 100-item collection (mean time, generic API)	666.8 ns	922.7 ns	553.1 ns
Mapping a 100-item collection (allocated)	3.96 KB	5.27 KB	3.96 KB
Cold start (first call, incl. compilation)	214.0 µs	409.2 µs	460.3 µs

When to choose which

Choose AutoMapperLite

You want straightforward DTO/entity mapping with a minimal dependency footprint and no commercial licensing considerations, and don't need LINQ projection.

Choose AutoMapper

You need ProjectTo-style LINQ projection, a large convention/configuration surface, or already depend on its ecosystem.

Choose Mapster

You want compiled-expression or source-generator performance with a broad feature set — Mapster was the fastest of the three in our own benchmarks.

See Performance for the full measured results across every scenario, including where AutoMapperLite is slower than the alternatives.