README.md

.NET Matrix

Evidence, not faith.
Choose .NET libraries with confidence using reproducible feature, execution-time and allocation comparisons.

Open the interactive matrix → · How to read the results · Reproduce the results · Link to the matrix

8 CATEGORIES

51 LIBRARIES

99 SCENARIOS

Explore the matrix

Category	Leader	Libraries	Scenarios
CSV Processing	Sep	4	10
Dependency Injection	Pure.DI	23	15
JSON Serialization	System.Text.Json	3	14
LINQ Queries	ZLinq	6	18
Logging	ZLogger	6	9
Object Mapping	Mapperly	4	10
Validation	Microsoft.Extensions.Validation	4	10
ZIP Archives	SharpZipLib	3	13

How to read the results

• Correctness comes first. Every implementation is checked against the same feature contract before its benchmark results are compared.
• Lower is better. Overview charts show execution time and allocated memory together.
• The rating measures distance, not placings. In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario scores nothing. A library's rating is the sum, so speed, economy and breadth all count and a narrow win cannot outweigh them.
• The Web application is the primary explorer. Use it to select libraries and switch between overview, features, benchmarks and environment details. Chrome and Edge can install it as a desktop application, with a shortcut per category.

The README is a generated snapshot of the reports committed to this repository.

CSV Processing

Sep leads the current rating · 4 libraries · 10 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1000 each here, so the maximum is 2000. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	Sep	10/10	1000	1000	2000	gold in Correctness, gold in Read, gold in Throughput, gold in Write
2	TinyCsvParser	9/10	560	392	952	silver in Correctness, silver in Read, bronze in Throughput
3	Sylvan.Data.Csv	9/10	635	270	904	silver in Throughput, silver in Write, bronze in Correctness, bronze in Read
4	CsvHelper	10/10	233	213	446	bronze in Write

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. Sep — 2000 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	708.72 ns	708.72 ns	100	1.89 KB	1.89 KB	100
Read Typed Records	851.08 ns	851.08 ns	100	1.7 KB	1.7 KB	100
Read Large Dataset	1 ms	1 ms	100	1016.97 KB	1016.97 KB	100
Quoted Fields	601.3 ns	601.3 ns	100	1.34 KB	1.34 KB	100
Escaped Delimiters	544.95 ns	544.95 ns	100	1.35 KB	1.35 KB	100
Header Mapping	874.95 ns	874.95 ns	100	1.7 KB	1.7 KB	100
Custom Conversion	421.33 ns	421.33 ns	100	1.11 KB	1.11 KB	100
Streaming Read	814.42 μs	814.42 μs	100	1.34 KB	1.34 KB	100
Write Rows	493.7 ns	493.7 ns	100	1.89 KB	1.89 KB	100
Async Read	842.91 μs	842.91 μs	100	1.44 KB	1.44 KB	100

2. TinyCsvParser — 952 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	1.49 μs	708.72 ns	69.1	5.56 KB	1.89 KB	58.5
Read Typed Records	1.73 μs	851.08 ns	70.1	5.3 KB	1.7 KB	56.8
Read Large Dataset	3.01 ms	1 ms	57.7	2.91 MB	1016.97 KB	58.5
Quoted Fields	1.34 μs	601.3 ns	67.1	4.87 KB	1.34 KB	52.9
Escaped Delimiters	1.41 μs	544.95 ns	62.3	4.98 KB	1.35 KB	52.4
Header Mapping	1.89 μs	874.95 ns	68.1	5.3 KB	1.7 KB	56.8
Custom Conversion	958.95 ns	421.33 ns	66.3	4.32 KB	1.11 KB	51.1
Streaming Read	3.03 ms	814.42 μs	51.8	2.75 MB	1.34 KB	2.196
Write Rows	—	493.7 ns	0	—	1.89 KB	0
Async Read	3.8 ms	842.91 μs	47.1	1.39 MB	1.44 KB	3.209

3. Sylvan.Data.Csv — 904 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	2.13 μs	708.72 ns	57.7	35.38 KB	1.89 KB	23.3
Read Typed Records	2.21 μs	851.08 ns	62	35.11 KB	1.7 KB	22.1
Read Large Dataset	1.1 ms	1 ms	95.3	1.03 MB	1016.97 KB	98.4
Quoted Fields	2.05 μs	601.3 ns	54.3	34.34 KB	1.34 KB	19.9
Escaped Delimiters	1.69 μs	544.95 ns	56.9	34.3 KB	1.35 KB	20
Header Mapping	2.56 μs	874.95 ns	58.5	35.11 KB	1.7 KB	22.1
Custom Conversion	—	421.33 ns	0	—	1.11 KB	0
Streaming Read	841.03 μs	814.42 μs	98.4	34.75 KB	1.34 KB	19.8
Write Rows	1.26 μs	493.7 ns	62.6	32.78 KB	1.89 KB	24.2
Async Read	1.07 ms	842.91 μs	88.8	36.05 KB	1.44 KB	20.1

4. CsvHelper — 446 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	3.23 μs	708.72 ns	46.9	21.95 KB	1.89 KB	29.5
Read Typed Records	853.9 μs	851.08 ns	3.159	53.87 KB	1.7 KB	17.9
Read Large Dataset	4.97 ms	1 ms	44.9	2.65 MB	1016.97 KB	61.3
Quoted Fields	525.07 μs	601.3 ns	3.387	40.85 KB	1.34 KB	18.3
Escaped Delimiters	561.7 μs	544.95 ns	3.118	40.89 KB	1.35 KB	18.3
Header Mapping	854.67 μs	874.95 ns	3.201	53.52 KB	1.7 KB	17.9
Custom Conversion	3.1 μs	421.33 ns	36.9	21.95 KB	1.11 KB	22.7
Streaming Read	4.05 ms	814.42 μs	44.9	2.16 MB	1.34 KB	2.48
Write Rows	785.12 μs	493.7 ns	2.51	40.5 KB	1.89 KB	21.7
Async Read	4.35 ms	842.91 μs	44	2.16 MB	1.44 KB	2.568

Benchmark overview

Read

More overview charts (3)

Correctness

Throughput

Write

Compared libraries (4)

	CsvHelper 33.1.0 A widely used CSV library with record mapping, type conversion, and synchronous and asynchronous readers and writers.	Compare →
	Sep 0.17.0 A modern SIMD-accelerated separated-values reader and writer with span-based conversion and async enumeration.	Compare →
	Sylvan.Data.Csv 1.4.4 A high-performance forward-only CSV data reader and writer with strongly typed accessors and asynchronous I/O.	Compare →
	TinyCsvParser 3.0.11 A strongly typed CSV parser with declarative property mapping, custom converters, lazy streaming, and asynchronous readers.	Compare →

Benchmark scenarios (10)

01 · Read Simple Rows

Parses three CSV records and materializes every field as text.

02 · Read Typed Records

Parses three CSV records and materializes typed scalar values.

03 · Read Large Dataset

Parses and materializes 10,000 typed CSV records.

04 · Quoted Fields

Parses doubled quote escapes inside quoted CSV fields.

05 · Escaped Delimiters

Parses quoted fields containing a comma or an LF newline.

06 · Header Mapping

Maps a reordered CSV header to the correct typed record members.

07 · Custom Conversion

Converts sku-NNNN fields to the matrix-owned ProductCode value type.

08 · Streaming Read

Aggregates 10,000 typed rows with forward-only reading and no row materialization.

09 · Write Rows

Writes three records with a header to an exact LF-terminated CSV string.

10 · Async Read

Asynchronously aggregates 10,000 typed CSV rows through the library async API.

Dependency Injection

Pure.DI leads the current rating · 23 libraries · 15 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1400 each here, so the maximum is 2800. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	Pure.DI	13/14	1300	1294	2594	gold in Basic, gold in Prepare, silver in Advanced
2	DryIoc	14/14	820	1106	1926	gold in Advanced, bronze in Prepare
3	Grace	13/14	849	1042	1891	silver in Basic
4	Stashbox	14/14	787	1092	1880	bronze in Advanced, bronze in Basic
5	LightInject	12/14	640	930	1570
6	Simple Injector	11/14	636	863	1499
7	Lamar	12/14	635	743	1378
8	Singularity	9/14	536	710	1246
9	Microsoft Extensions Dependency Injection	9/14	452	675	1128
10	Faster.Ioc	8/14	460	608	1067
11	Managed Extensibility Framework 2	10/14	360	455	814
12	Unity	13/14	271	444	714
13	Maestro	11/14	261	347	608
14	StructureMap	13/14	217	331	548
15	ZenIoc	7/14	157	284	441
16	Autofac	13/14	165	243	408
17	Castle Windsor	13/14	131	224	354
18	Spring.NET	10/14	106	224	330
19	MvvmCross	6/14	85	245	329	silver in Prepare
20	Ninject	12/14	54	134	189
21	Visual Studio MEF	9/14	40	99	139
22	Catel	8/14	47	89	136

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. Pure.DI — 2594 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	1.49 ns	1.49 ns	100	0 B	0 B	100
Transient	17.78 ns	17.78 ns	100	72 B	72 B	100
PerResolve	14.94 ns	14.94 ns	100	56 B	56 B	100
Scoped	48.01 ns	48.01 ns	100	184 B	160 B	94.1
Combined	46.29 ns	46.29 ns	100	168 B	168 B	100
Complex	105.51 ns	105.51 ns	100	360 B	360 B	100
Property	75.63 ns	75.63 ns	100	336 B	336 B	100
Generics	35.22 ns	35.22 ns	100	144 B	144 B	100
Array	138.74 ns	138.74 ns	100	624 B	624 B	100
Conditional	39.21 ns	39.21 ns	100	144 B	144 B	100
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	76.28 ns	76.28 ns	100	248 B	248 B	100
Prepare And Register	0 ns	0 ns	100	0 B	0 B	100
Prepare And Register And Simple Resolve	6.23 ns	6.23 ns	100	24 B	24 B	100

2. DryIoc — 1926 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	36.93 ns	1.49 ns	25.6	0 B	0 B	100
Transient	54.05 ns	17.78 ns	58.4	72 B	72 B	100
PerResolve	473 μs	14.94 ns	0.58	1.65 KB	56 B	21.6
Scoped	176.56 ns	48.01 ns	52.5	448 B	160 B	62.4
Combined	79.72 ns	46.29 ns	76.5	168 B	168 B	100
Complex	129.63 ns	105.51 ns	90.3	360 B	360 B	100
Property	111.46 ns	75.63 ns	82.5	336 B	336 B	100
Generics	75.37 ns	35.22 ns	68.9	144 B	144 B	100
Array	188.99 ns	138.74 ns	85.8	624 B	624 B	100
Conditional	70.32 ns	39.21 ns	75.1	144 B	144 B	100
Child Container	735.66 ns	735.66 ns	100	1.59 KB	1.59 KB	100
Interception With Proxy	85.48 ns	76.28 ns	94.5	248 B	248 B	100
Prepare And Register	1.35 μs	0 ns	2.716	2.42 KB	0 B	9.79
Prepare And Register And Simple Resolve	1.7 μs	6.23 ns	6.515	3.04 KB	24 B	12.4

3. Grace — 1891 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	20.05 ns	1.49 ns	34.4	0 B	0 B	100
Transient	34.75 ns	17.78 ns	72.5	72 B	72 B	100
PerResolve	111.96 ns	14.94 ns	37.6	296 B	56 B	50
Scoped	118.38 ns	48.01 ns	64.1	232 B	160 B	84.8
Combined	56.94 ns	46.29 ns	90.3	168 B	168 B	100
Complex	114.52 ns	105.51 ns	96	360 B	360 B	100
Property	91.83 ns	75.63 ns	90.9	336 B	336 B	100
Generics	50.29 ns	35.22 ns	84	144 B	144 B	100
Array	163.39 ns	138.74 ns	92.2	624 B	624 B	100
Conditional	48.25 ns	39.21 ns	90.4	144 B	144 B	100
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	84.88 ns	76.28 ns	94.9	248 B	248 B	100
Prepare And Register	11.19 μs	0 ns	0.945	21.66 KB	0 B	3.288
Prepare And Register And Simple Resolve	198.09 μs	6.23 ns	0.604	32.77 KB	24 B	3.781

4. Stashbox — 1880 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	53.42 ns	1.49 ns	21.4	0 B	0 B	100
Transient	44.34 ns	17.78 ns	64.3	72 B	72 B	100
PerResolve	68.98 ns	14.94 ns	47.7	192 B	56 B	60.9
Scoped	118.66 ns	48.01 ns	64	304 B	160 B	74.9
Combined	76.47 ns	46.29 ns	78.1	168 B	168 B	100
Complex	193.51 ns	105.51 ns	74	360 B	360 B	100
Property	101.26 ns	75.63 ns	86.6	336 B	336 B	100
Generics	63.77 ns	35.22 ns	74.8	144 B	144 B	100
Array	164.68 ns	138.74 ns	91.8	624 B	624 B	100
Conditional	61.93 ns	39.21 ns	79.9	144 B	144 B	100
Child Container	88.67 μs	735.66 ns	9.115	7.59 KB	1.59 KB	46
Interception With Proxy	87.78 ns	76.28 ns	93.3	248 B	248 B	100
Prepare And Register	4.97 μs	0 ns	1.419	8.77 KB	0 B	5.164
Prepare And Register And Simple Resolve	202.19 μs	6.23 ns	0.598	14.93 KB	24 B	5.599

5. LightInject — 1570 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	57.69 ns	1.49 ns	20.6	0 B	0 B	100
Transient	38.15 ns	17.78 ns	69.3	72 B	72 B	100
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	252.99 ns	48.01 ns	43.9	568 B	160 B	55.8
Combined	97.6 ns	46.29 ns	69.3	168 B	168 B	100
Complex	272.78 ns	105.51 ns	62.4	360 B	360 B	100
Property	99.05 ns	75.63 ns	87.5	336 B	336 B	100
Generics	57.65 ns	35.22 ns	78.6	144 B	144 B	100
Array	161.61 ns	138.74 ns	92.7	624 B	624 B	100
Conditional	147.88 ns	39.21 ns	52	144 B	144 B	100
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	198.63 ns	76.28 ns	62.2	560 B	248 B	68.2
Prepare And Register	11.25 μs	0 ns	0.943	33.07 KB	0 B	2.661
Prepare And Register And Simple Resolve	693.27 μs	6.23 ns	0.323	43.45 KB	24 B	3.284

6. Simple Injector — 1499 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	36.04 ns	1.49 ns	25.9	0 B	0 B	100
Transient	47.88 ns	17.78 ns	62	72 B	72 B	100
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	229.07 ns	48.01 ns	46.2	504 B	160 B	59
Combined	68.56 ns	46.29 ns	82.5	168 B	168 B	100
Complex	128.18 ns	105.51 ns	90.8	360 B	360 B	100
Property	118.01 ns	75.63 ns	80.2	336 B	336 B	100
Generics	63.61 ns	35.22 ns	74.9	144 B	144 B	100
Array	—	138.74 ns	0	—	624 B	0
Conditional	64.05 ns	39.21 ns	78.6	144 B	144 B	100
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	86.8 ns	76.28 ns	93.8	248 B	248 B	100
Prepare And Register	60.78 μs	0 ns	0.406	63.48 KB	0 B	1.921
Prepare And Register And Simple Resolve	274.04 μs	6.23 ns	0.513	105.42 KB	24 B	2.108

7. Lamar — 1378 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	43.34 ns	1.49 ns	23.7	120 B	0 B	40.8
Transient	71.23 ns	17.78 ns	51	192 B	72 B	66.7
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	1.27 μs	48.01 ns	19.6	1.08 KB	160 B	40.4
Combined	91.02 ns	46.29 ns	71.7	288 B	168 B	78.4
Complex	145.13 ns	105.51 ns	85.4	480 B	360 B	87.3
Property	127.01 ns	75.63 ns	77.4	456 B	336 B	86.6
Generics	84.75 ns	35.22 ns	65	264 B	144 B	76.4
Array	192.71 ns	138.74 ns	84.9	744 B	624 B	91.9
Conditional	83.46 ns	39.21 ns	69	264 B	144 B	76.4
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	102.36 ns	76.28 ns	86.5	288 B	248 B	93.4
Prepare And Register	128.83 μs	0 ns	0.279	62.9 KB	0 B	1.93
Prepare And Register And Simple Resolve	148.72 μs	6.23 ns	0.697	63.64 KB	24 B	2.713

8. Singularity — 1246 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	17.44 ns	1.49 ns	36.8	0 B	0 B	100
Transient	38.75 ns	17.78 ns	68.7	72 B	72 B	100
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	55.61 ns	48.01 ns	93	160 B	160 B	100
Combined	57.42 ns	46.29 ns	90	168 B	168 B	100
Complex	113.85 ns	105.51 ns	96.3	360 B	360 B	100
Property	—	75.63 ns	0	—	336 B	0
Generics	55.67 ns	35.22 ns	79.9	144 B	144 B	100
Array	295.38 ns	138.74 ns	68.7	624 B	624 B	100
Conditional	—	39.21 ns	0	—	144 B	0
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	—	76.28 ns	0	—	248 B	0
Prepare And Register	5.74 μs	0 ns	1.319	12.49 KB	0 B	4.327
Prepare And Register And Simple Resolve	39.27 μs	6.23 ns	1.357	15.67 KB	24 B	5.465

9. Microsoft Extensions Dependency Injection — 1128 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	31.15 ns	1.49 ns	27.8	0 B	0 B	100
Transient	48.77 ns	17.78 ns	61.4	72 B	72 B	100
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	186.81 ns	48.01 ns	51.1	472 B	160 B	60.9
Combined	68.12 ns	46.29 ns	82.7	168 B	168 B	100
Complex	130.66 ns	105.51 ns	89.9	360 B	360 B	100
Property	—	75.63 ns	0	—	336 B	0
Generics	67.21 ns	35.22 ns	72.9	144 B	144 B	100
Array	—	138.74 ns	0	—	624 B	0
Conditional	116.19 ns	39.21 ns	58.6	144 B	144 B	100
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	—	76.28 ns	0	—	248 B	0
Prepare And Register	1.77 μs	0 ns	2.374	6.05 KB	0 B	6.21
Prepare And Register And Simple Resolve	2.25 μs	6.23 ns	5.664	6.8 KB	24 B	8.29

10. Faster.Ioc — 1067 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	23.95 ns	1.49 ns	31.6	0 B	0 B	100
Transient	35.05 ns	17.78 ns	72.2	72 B	72 B	100
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	66.4 ns	48.01 ns	85.3	192 B	160 B	92.3
Combined	59.97 ns	46.29 ns	88.1	168 B	168 B	100
Complex	115 ns	105.51 ns	95.8	360 B	360 B	100
Property	—	75.63 ns	0	—	336 B	0
Generics	51.54 ns	35.22 ns	83	144 B	144 B	100
Array	—	138.74 ns	0	—	624 B	0
Conditional	—	39.21 ns	0	—	144 B	0
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	—	76.28 ns	0	—	248 B	0
Prepare And Register	1.28 μs	0 ns	2.79	4.36 KB	0 B	7.313
Prepare And Register And Simple Resolve	105.01 μs	6.23 ns	0.83	7.46 KB	24 B	7.916

11. Managed Extensibility Framework 2 — 814 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	141.74 ns	1.49 ns	13.2	360 B	0 B	25
Transient	112.5 ns	17.78 ns	40.7	312 B	72 B	53.5
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	—	48.01 ns	0	—	160 B	0
Combined	199.08 ns	46.29 ns	48.6	528 B	168 B	59
Complex	384.3 ns	105.51 ns	52.6	1.05 KB	360 B	59
Property	396.11 ns	75.63 ns	43.9	1.15 KB	336 B	54.8
Generics	131.18 ns	35.22 ns	52.3	384 B	144 B	64.2
Array	505.62 ns	138.74 ns	52.5	1.27 KB	624 B	70.1
Conditional	132.05 ns	39.21 ns	55	384 B	144 B	64.2
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	—	76.28 ns	0	—	248 B	0
Prepare And Register	108.03 μs	0 ns	0.304	44.44 KB	0 B	2.296
Prepare And Register And Simple Resolve	286.24 μs	6.23 ns	0.502	56.7 KB	24 B	2.875

12. Unity — 714 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	140.44 ns	1.49 ns	13.3	336 B	0 B	25.8
Transient	207.26 ns	17.78 ns	30	408 B	72 B	47.1
PerResolve	336.48 ns	14.94 ns	21.7	808 B	56 B	31
Scoped	2.06 μs	48.01 ns	15.4	4.57 KB	160 B	19.8
Combined	667.22 ns	46.29 ns	26.6	792 B	168 B	48.5
Complex	1.41 μs	105.51 ns	27.5	1.66 KB	360 B	47.1
Property	722.1 ns	75.63 ns	32.6	1.08 KB	336 B	56.5
Generics	2.17 μs	35.22 ns	12.9	1008 B	144 B	40.3
Array	2.4 μs	138.74 ns	24.1	9.59 KB	624 B	25.7
Conditional	420.98 ns	39.21 ns	30.9	624 B	144 B	50.9
Child Container	7.14 μs	735.66 ns	32.1	8.81 KB	1.59 KB	42.7
Interception With Proxy	—	76.28 ns	0	—	248 B	0
Prepare And Register	8.31 μs	0 ns	1.097	19.28 KB	0 B	3.484
Prepare And Register And Simple Resolve	13.34 μs	6.23 ns	2.327	21.89 KB	24 B	4.625

13. Maestro — 608 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	222.66 ns	1.49 ns	10.6	720 B	0 B	18
Transient	220.43 ns	17.78 ns	29.1	648 B	72 B	37.8
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	852.2 ns	48.01 ns	24	1.63 KB	160 B	32.9
Combined	446.59 ns	46.29 ns	32.5	1.24 KB	168 B	38.5
Complex	1.05 μs	105.51 ns	31.9	2.79 KB	360 B	36.5
Property	810.79 ns	75.63 ns	30.7	1.8 KB	336 B	43.9
Generics	297.29 ns	35.22 ns	34.8	912 B	144 B	42.4
Array	—	138.74 ns	0	—	624 B	0
Conditional	427.6 ns	39.21 ns	30.6	1.01 KB	144 B	39.9
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	669.79 ns	76.28 ns	33.9	1.03 KB	248 B	50.2
Prepare And Register	20.47 μs	0 ns	0.699	27.62 KB	0 B	2.912
Prepare And Register And Simple Resolve	20.94 μs	6.23 ns	1.858	28.62 KB	24 B	4.046

14. StructureMap — 548 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	755.79 ns	1.49 ns	5.738	2.58 KB	0 B	9.492
Transient	450.3 ns	17.78 ns	20.4	1.17 KB	72 B	28
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	6.67 μs	48.01 ns	8.569	9.67 KB	160 B	13.6
Combined	1.38 μs	46.29 ns	18.5	2.86 KB	168 B	25.5
Complex	3.5 μs	105.51 ns	17.4	4.64 KB	360 B	28.4
Property	1.28 μs	75.63 ns	24.5	1.64 KB	336 B	46
Generics	1.36 μs	35.22 ns	16.3	2.63 KB	144 B	24.9
Array	3.36 μs	138.74 ns	20.4	4.99 KB	624 B	35.5
Conditional	825.58 ns	39.21 ns	22.1	1.38 KB	144 B	34.2
Child Container	1.02 ms	735.66 ns	2.682	60.01 KB	1.59 KB	16.4
Interception With Proxy	212.07 ns	76.28 ns	60.2	624 B	248 B	64.8
Prepare And Register	81 μs	0 ns	0.351	60.82 KB	0 B	1.963
Prepare And Register And Simple Resolve	1.05 ms	6.23 ns	0.263	100.46 KB	24 B	2.16

15. ZenIoc — 441 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	135.16 ns	1.49 ns	13.5	168 B	0 B	35.4
Transient	152.4 ns	17.78 ns	35	240 B	72 B	60.3
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	—	48.01 ns	0	—	160 B	0
Combined	361.13 ns	46.29 ns	36.1	504 B	168 B	60.3
Complex	818.26 ns	105.51 ns	36.1	1.17 KB	360 B	56
Property	—	75.63 ns	0	—	336 B	0
Generics	—	35.22 ns	0	—	144 B	0
Array	—	138.74 ns	0	—	624 B	0
Conditional	363.4 ns	39.21 ns	33.2	480 B	144 B	57.7
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	—	76.28 ns	0	—	248 B	0
Prepare And Register	4.06 μs	0 ns	1.57	4.48 KB	0 B	7.211
Prepare And Register And Simple Resolve	44.15 μs	6.23 ns	1.279	8.94 KB	24 B	7.232

16. Autofac — 408 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	376.04 ns	1.49 ns	8.129	1.92 KB	0 B	11
Transient	877.73 ns	17.78 ns	14.6	2.44 KB	72 B	19.5
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	1.74 μs	48.01 ns	16.8	4.5 KB	160 B	19.9
Combined	2.06 μs	46.29 ns	15.2	4.48 KB	168 B	20.4
Complex	5.16 μs	105.51 ns	14.4	9.05 KB	360 B	20.3
Property	13.91 μs	75.63 ns	7.421	20.91 KB	336 B	13
Generics	1.88 μs	35.22 ns	13.9	3.91 KB	144 B	20.4
Array	6.74 μs	138.74 ns	14.4	8.6 KB	624 B	27.1
Conditional	1.65 μs	39.21 ns	15.6	3.16 KB	144 B	22.7
Child Container	11.14 μs	735.66 ns	25.7	16.03 KB	1.59 KB	31.7
Interception With Proxy	2.54 μs	76.28 ns	17.5	2.58 KB	248 B	32
Prepare And Register	53.63 μs	0 ns	0.432	48.75 KB	0 B	2.192
Prepare And Register And Simple Resolve	54.69 μs	6.23 ns	1.149	50.46 KB	24 B	3.047

17. Castle Windsor — 354 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	273.6 ns	1.49 ns	9.526	984 B	0 B	15.4
Transient	1.02 μs	17.78 ns	13.6	2.34 KB	72 B	19.9
PerResolve	1.85 μs	14.94 ns	9.277	3.03 KB	56 B	16
Scoped	4.43 μs	48.01 ns	10.5	3.79 KB	160 B	21.7
Combined	3.38 μs	46.29 ns	11.8	5.34 KB	168 B	18.7
Complex	9.26 μs	105.51 ns	10.7	12.42 KB	360 B	17.4
Property	6.46 μs	75.63 ns	10.9	9.09 KB	336 B	19.6
Generics	6.95 μs	35.22 ns	7.221	5.84 KB	144 B	16.7
Array	8.27 μs	138.74 ns	13	12.94 KB	624 B	22.1
Conditional	2.7 μs	39.21 ns	12.2	4.8 KB	144 B	18.4
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	1.73 μs	76.28 ns	21.2	2.36 KB	248 B	33.4
Prepare And Register	143.07 μs	0 ns	0.264	75.78 KB	0 B	1.758
Prepare And Register And Simple Resolve	132.2 μs	6.23 ns	0.739	78.08 KB	24 B	2.45

18. Spring.NET — 330 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	1.04 μs	1.49 ns	4.883	432 B	0 B	22.9
Transient	2.37 μs	17.78 ns	8.9	1.05 KB	72 B	29.5
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	—	48.01 ns	0	—	160 B	0
Combined	7.33 μs	46.29 ns	8.033	4.59 KB	168 B	20.2
Complex	17.28 μs	105.51 ns	7.852	13.9 KB	360 B	16.4
Property	69.91 μs	75.63 ns	3.311	363.72 KB	336 B	3.109
Generics	—	35.22 ns	0	—	144 B	0
Array	20.5 μs	138.74 ns	8.256	11.44 KB	624 B	23.5
Conditional	6.07 μs	39.21 ns	8.141	3.91 KB	144 B	20.4
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	267.95 ns	76.28 ns	53.6	392 B	248 B	80.9
Prepare And Register	5.66 μs	0 ns	1.329	16.23 KB	0 B	3.797
Prepare And Register And Simple Resolve	16.95 μs	6.23 ns	2.065	39.98 KB	24 B	3.423

19. MvvmCross — 329 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	172.93 ns	1.49 ns	12	0 B	0 B	100
Transient	338.39 ns	17.78 ns	23.5	360 B	72 B	50
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	—	48.01 ns	0	—	160 B	0
Combined	1.26 μs	46.29 ns	19.4	1.24 KB	168 B	38.5
Complex	3.26 μs	105.51 ns	18.1	3.47 KB	360 B	32.8
Property	—	75.63 ns	0	—	336 B	0
Generics	—	35.22 ns	0	—	144 B	0
Array	—	138.74 ns	0	—	624 B	0
Conditional	—	39.21 ns	0	—	144 B	0
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	—	76.28 ns	0	—	248 B	0
Prepare And Register	843.05 ns	0 ns	3.442	2.35 KB	0 B	9.934
Prepare And Register And Simple Resolve	1.07 μs	6.23 ns	8.215	2.6 KB	24 B	13.4

20. Ninject — 189 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	1.78 μs	1.49 ns	3.738	2.23 KB	0 B	10.2
Transient	6.63 μs	17.78 ns	5.32	4.8 KB	72 B	13.9
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	1.05 ms	48.01 ns	0.685	1.95 MB	160 B	0.949
Combined	16.81 μs	46.29 ns	5.304	13.17 KB	168 B	11.9
Complex	42.84 μs	105.51 ns	4.986	33.07 KB	360 B	10.6
Property	28.68 μs	75.63 ns	5.169	20.11 KB	336 B	13.2
Generics	18.94 μs	35.22 ns	4.373	11.2 KB	144 B	12.1
Array	46.37 μs	138.74 ns	5.49	26.77 KB	624 B	15.4
Conditional	14.17 μs	39.21 ns	5.327	10.27 KB	144 B	12.6
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	4.22 μs	76.28 ns	13.5	3.48 KB	248 B	27.5
Prepare And Register	236.94 μs	0 ns	0.205	33.73 KB	0 B	2.635
Prepare And Register And Simple Resolve	599.38 μs	6.23 ns	0.347	48.35 KB	24 B	3.113

21. Visual Studio MEF — 139 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	4.47 μs	1.49 ns	2.36	5.79 KB	0 B	6.35
Transient	8.23 μs	17.78 ns	4.775	7.85 KB	72 B	10.9
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	—	48.01 ns	0	—	160 B	0
Combined	12.74 μs	46.29 ns	6.092	9.84 KB	168 B	13.8
Complex	21.87 μs	105.51 ns	6.979	13.92 KB	360 B	16.4
Property	19.99 μs	75.63 ns	6.191	12.09 KB	336 B	17
Generics	—	35.22 ns	0	—	144 B	0
Array	28.38 μs	138.74 ns	7.016	17.48 KB	624 B	19
Conditional	11.76 μs	39.21 ns	5.847	9.8 KB	144 B	12.9
Child Container	—	735.66 ns	0	—	1.59 KB	0
Interception With Proxy	—	76.28 ns	0	—	248 B	0
Prepare And Register	594.36 μs	0 ns	0.13	180.37 KB	0 B	1.14
Prepare And Register And Simple Resolve	588.18 μs	6.23 ns	0.351	183.95 KB	24 B	1.596

22. Catel — 136 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	200.96 ns	1.49 ns	11.1	304 B	0 B	27.1
Transient	3.55 μs	17.78 ns	7.268	5.62 KB	72 B	12.9
PerResolve	—	14.94 ns	0	—	56 B	0
Scoped	—	48.01 ns	0	—	160 B	0
Combined	8.02 μs	46.29 ns	7.678	12.18 KB	168 B	12.4
Complex	17.59 μs	105.51 ns	7.781	26.02 KB	360 B	12
Property	—	75.63 ns	0	—	336 B	0
Generics	—	35.22 ns	0	—	144 B	0
Array	—	138.74 ns	0	—	624 B	0
Conditional	4.64 μs	39.21 ns	9.31	7.01 KB	144 B	15.3
Child Container	2.06 ms	735.66 ns	1.889	2.27 MB	1.59 KB	2.629
Interception With Proxy	—	76.28 ns	0	—	248 B	0
Prepare And Register	3.04 μs	0 ns	1.813	6.8 KB	0 B	5.859
Prepare And Register And Simple Resolve	971.67 μs	6.23 ns	0.273	1.14 MB	24 B	0.634

Benchmark overview

Basic

More overview charts (2)

Advanced

Prepare

Compared libraries (23)

	Autofac 9.3.2 A flexible inversion of control container for building extensible .NET applications.	Compare →
	Castle Windsor 6.0.0 The Castle Project container, with bound lifestyles and Castle DynamicProxy interception.	Compare →
	Catel 6.2.0 An MVVM application framework whose service locator and type factory perform constructor injection.	Compare →
	DryIoc 5.4.3 A fast, small and feature-rich container with expression-compiled resolution and rich reuse options.	Compare →
	Faster.Ioc 5.0.0 A minimalistic container focused on the shortest possible resolve path.	Compare →
	Grace 7.2.1 A container with a fluent registration model, per-object-graph lifestyles and decorator support.	Compare →
	Hand-coded Direct dependency injection written in C# without a container.	Compare →
	Lamar 16.0.0 The successor to StructureMap, built around runtime code generation.	Compare →
	LightInject 7.1.0 A lightweight container with an ultra-small API surface and its own interception package.	Compare →
	Maestro 3.6.6 A small container with a fluent configuration API and pluggable activation interceptors.	Compare →
	Managed Extensibility Framework 2 10.0.11 The lightweight Managed Extensibility Framework composition engine shipped as System.Composition.	Compare →
	Microsoft Extensions Dependency Injection 10.0.11 The built-in .NET dependency injection container and its service collection abstractions.	Compare →
	MvvmCross 10.1.2 A cross-platform MVVM framework with its own inversion of control provider.	Compare →
	Ninject 3.3.6 A container built around fluent bindings, contextual conditions and pluggable extensions.	Compare →
	Pure.DI 2.5.3 A compile-time dependency injection framework that generates strongly typed compositions.	Compare →
	Simple Injector 5.6.0 A fast, opinionated dependency injection library that promotes explicit configuration and maintainable application design.	Compare →
	Singularity 0.18.0 An expression-tree based container that validates the whole object graph when the container is built.	Compare →
	Spring.NET 3.1.0 The Spring.NET application framework and its XML or code configured object factory.	Compare →
	Stashbox 5.21.0 A fast container with per-request lifetimes, conditional registrations and child containers.	Compare →
	StructureMap 4.7.1 A mature container with a fluent registry DSL, nested containers and decorators.	Compare →
	Unity 5.11.10 The Unity container, offering per-resolve lifetimes and hierarchical child containers.	Compare →
	Visual Studio MEF 17.13.41 The Visual Studio composition engine, a fast attribute-driven MEF implementation.	Compare →
	ZenIoc 1.0.1 A tiny container with compiled registrations, named resolution and nested containers.	Compare →

Benchmark scenarios (15)

01 · Singleton

Registers three singleton services and resolves each of them repeatedly. Every resolve of the same service must return the same instance.

02 · Transient

Registers three transient services and resolves each of them repeatedly. Every resolve must create a new instance, never reusing an earlier one.

03 · PerResolve

Resolves an object graph that asks for the same dependency twice. Both requests inside one resolution share an instance, while the next resolution gets a new one.

04 · Scoped

Resolves scoped services inside explicit scopes. One instance per scope, different instances across scopes, and scope-owned disposables are disposed when the scope ends.

05 · Combined

Resolves three roots that mix singleton and transient dependencies. The singleton is shared across every root while each transient dependency is distinct.

06 · Complex

Registers and resolves three multi-level object graphs, checking that every nested dependency has the expected implementation type and lifetime.

07 · Property

Resolves three roots that carry writable service properties. The container, or its intended property-injection extension, must assign them during activation.

08 · Generics

Registers one open generic service mapping and resolves roots closed over int, float and object. Registering every closed type separately does not count.

09 · IEnumerable

Injects a sequence of five plugin implementations and requires it to be genuinely lazy: nothing is created until enumeration, and every enumeration yields new transients.

Not rated: Too few rated libraries implement genuine lazy enumeration for this to be a competitive result; the scenario was measured and drawn in no chart group before it briefly entered one by accident. (3 of 22 rated libraries support this.)

10 · Array

Resolves three roots that materialise their injected sequence of five plugins into an array while the root is being activated.

11 · Conditional

Gives each of three consumers a different implementation of one contract, chosen through the metadata, key, predicate or consumer-context mechanism of the library.

12 · Child Container

Creates a real nested child container that inherits the registrations of its parent and can add or override them without changing the parent.

13 · Interception With Proxy

Resolves a service through the interception or activation extension point of the library. The result must be a proxy whose interceptor proceeds to the real target.

14 · Prepare And Register

Measures creating the container and registering the whole prescribed graph, without resolving anything from it.

15 · Prepare And Register And Simple Resolve

Measures the same setup as Prepare And Register, followed by a single resolve of one singleton root.

JSON Serialization

System.Text.Json leads the current rating · 3 libraries · 14 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1300 each here, so the maximum is 2600. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	System.Text.Json	13/13	1156	1149	2306	gold in Advanced, gold in Basic, gold in Collections, gold in Stream, silver in Nested, silver in Prepare
2	ServiceStack.Text	12/13	1103	888	1991	gold in Nested, gold in Prepare, silver in Advanced, silver in Basic, silver in Collections, silver in Stream
3	Newtonsoft.Json	13/13	794	398	1193	bronze in Advanced, bronze in Basic, bronze in Collections, bronze in Nested, bronze in Prepare, bronze in Stream

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. System.Text.Json — 2306 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
Serialize Simple Object	167.09 ns	167.09 ns	100	96 B	96 B	100
Deserialize Simple Object	225.84 ns	179.63 ns	89.2	64 B	64 B	100
Serialize Nested Object	353.61 ns	353.61 ns	100	504 B	504 B	100
Deserialize Nested Object	562.39 ns	466.37 ns	91.1	768 B	320 B	65.9
Serialize Collection	472.23 ns	472.23 ns	100	560 B	560 B	100
Deserialize Collection	807.57 ns	681.65 ns	91.9	800 B	472 B	77.6
Serialize Dictionary	177.45 ns	177.45 ns	100	88 B	88 B	100
Deserialize Dictionary	294.09 ns	217.69 ns	86.1	312 B	312 B	100
Enum Round Trip	305.21 ns	298.27 ns	98.9	88 B	88 B	100
Custom Converter Round Trip	281.51 ns	273.71 ns	98.6	120 B	120 B	100
Polymorphic Round Trip	1.74 μs	1.74 μs	100	1.32 KB	1.32 KB	100
UTF-8 Stream Round Trip	499.17 ns	499.17 ns	100	280 B	280 B	100
Prepare Serializer	18.88 μs	0 ns	0.728	7.45 KB	0 B	5.599

2. ServiceStack.Text — 1991 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
Serialize Simple Object	258.83 ns	167.09 ns	80.4	336 B	96 B	57.7
Deserialize Simple Object	179.63 ns	179.63 ns	100	112 B	64 B	80.4
Serialize Nested Object	569.81 ns	353.61 ns	78.8	792 B	504 B	80.4
Deserialize Nested Object	466.37 ns	466.37 ns	100	320 B	320 B	100
Serialize Collection	805.02 ns	472.23 ns	76.6	1000 B	560 B	75.5
Deserialize Collection	681.65 ns	681.65 ns	100	472 B	472 B	100
Serialize Dictionary	194.95 ns	177.45 ns	95.4	288 B	88 B	59.9
Deserialize Dictionary	217.69 ns	217.69 ns	100	424 B	312 B	86.6
Enum Round Trip	298.27 ns	298.27 ns	100	336 B	88 B	55.8
Custom Converter Round Trip	273.71 ns	273.71 ns	100	392 B	120 B	58.8
Polymorphic Round Trip	—	1.74 μs	0	—	1.32 KB	0
UTF-8 Stream Round Trip	965.35 ns	499.17 ns	71.9	2.8 KB	280 B	32.4
Prepare Serializer	0 ns	0 ns	100	0 B	0 B	100

3. Newtonsoft.Json — 1193 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
Serialize Simple Object	355.18 ns	167.09 ns	68.7	1.41 KB	96 B	28.6
Deserialize Simple Object	520.93 ns	179.63 ns	58.8	2.61 KB	64 B	18.1
Serialize Nested Object	608.28 ns	353.61 ns	76.3	1.63 KB	504 B	55.9
Deserialize Nested Object	1.03 μs	466.37 ns	67.3	2.89 KB	320 B	34
Serialize Collection	881.98 ns	472.23 ns	73.2	1.83 KB	560 B	55.5
Deserialize Collection	1.53 μs	681.65 ns	66.7	2.99 KB	472 B	40.1
Serialize Dictionary	352.96 ns	177.45 ns	71	1.48 KB	88 B	27
Deserialize Dictionary	543.53 ns	217.69 ns	63.4	2.83 KB	312 B	33.9
Enum Round Trip	973.87 ns	298.27 ns	55.4	4.68 KB	88 B	15.2
Custom Converter Round Trip	851.6 ns	273.71 ns	56.8	4.68 KB	120 B	17.3
Polymorphic Round Trip	3.55 μs	1.74 μs	69.9	7.79 KB	1.32 KB	41.5
UTF-8 Stream Round Trip	1.13 μs	499.17 ns	66.5	4.13 KB	280 B	26.8
Prepare Serializer	45.95 μs	0 ns	0.466	11.57 KB	0 B	4.496

Benchmark overview

Basic

More overview charts (5)

Nested

Collections

Advanced

Stream

Prepare

Compared libraries (3)

	Newtonsoft.Json 13.0.4 A mature JSON framework for .NET with configurable contracts, converters, and streaming readers and writers.	Compare →
	ServiceStack.Text 10.1.4 A high-performance text library with typed JSON, stream, collection, and type-specific serialization APIs.	Compare →
	System.Text.Json The reflection-based and source-generated JSON serializer included with .NET.	Compare →

Benchmark scenarios (14)

01 · Serialize Simple Object

Serializes one scalar object to a compact JSON string.

02 · Deserialize Simple Object

Deserializes one compact JSON object and validates every scalar member.

03 · Serialize Nested Object

Serializes an order, customer, and address object graph.

04 · Deserialize Nested Object

Deserializes and materializes an order, customer, and address object graph.

05 · Serialize Collection

Serializes three ordered objects to a compact JSON array.

06 · Deserialize Collection

Deserializes a compact JSON array to three ordered objects.

07 · Serialize Dictionary

Serializes three ordered string and integer entries to a JSON object.

08 · Deserialize Dictionary

Deserializes a JSON object to three ordinal string and integer entries.

09 · Enum Round Trip

Serializes an enum as its string name and deserializes it back.

10 · Custom Converter Round Trip

Serializes a strongly typed identifier as a JSON string and deserializes it back.

11 · Polymorphic Round Trip

Round-trips a base-type collection through safe cat and dog discriminators.

12 · UTF-8 Stream Round Trip

Serializes a simple object to a new UTF-8 memory stream and deserializes it back.

13 · Source Generation Round Trip

Round-trips a simple object with compile-time generated JSON metadata.

Not rated: With this few rated entrants, the reference is a library's own result, not a result earned against a competitor, so the full 200 points would not reflect a win. (1 of 3 rated libraries support this.)

14 · Prepare Serializer

Creates fresh serializer settings and explicit type metadata without serializing data.

LINQ Queries

ZLinq leads the current rating · 6 libraries · 18 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1700 each here, so the maximum is 3400. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	ZLinq	17/17	1571	1697	3269	gold in Advanced, gold in Core, gold in Sequences, gold in Sources, silver in Partitioning
2	System.Linq	16/17	1465	1373	2837	gold in Partitioning, silver in Advanced, silver in Core, bronze in Sequences, bronze in Sources
3	StructLinq	14/17	977	1229	2207	silver in Sequences
4	LinqAF	16/17	1093	1072	2165	bronze in Advanced, bronze in Partitioning
5	NetFabric.Hyperlinq	12/17	950	900	1850	silver in Sources, bronze in Core

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. ZLinq — 3269 of 3400

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	8.23 μs	7.04 μs	92.5	0 B	0 B	100
Project To Array	3.8 μs	3.8 μs	100	39.09 KB	39.09 KB	100
Filter, Project, Materialize	6.49 μs	5.86 μs	95	9.83 KB	9.83 KB	100
Chained Pipeline	8.74 μs	7.05 μs	89.8	3.93 KB	3.93 KB	100
List Source	14.8 μs	10.12 μs	82.7	13.07 KB	13.07 KB	100
Opaque Source	25.24 μs	19.88 μs	88.8	13.1 KB	13.1 KB	100
Span Source	12.36 μs	12.01 μs	98.6	13.07 KB	13.07 KB	100
Paged Slice	232.88 ns	204.44 ns	93.7	3.93 KB	3.93 KB	100
Any Match	2.79 μs	2.7 μs	98.5	0 B	0 B	100
First Match	1.91 μs	1.91 μs	100	0 B	0 B	100
Flatten Nested Sequences	25.25 μs	4.74 μs	43.3	39.09 KB	39.09 KB	100
Distinct Values	27.9 μs	25.55 μs	95.7	3.98 KB	3.98 KB	100
Zip Pairs	10.46 μs	10.46 μs	100	39.09 KB	39.09 KB	100
Aggregate	2.85 μs	2.85 μs	99.9	0 B	0 B	100
Ordered Top N	36.11 μs	31.23 μs	93	264 B	248 B	97.2
Group and Aggregate	70.24 μs	70.24 μs	100	130.59 KB	130.59 KB	100
Join and Project	58.52 μs	58.52 μs	100	129.19 KB	129.19 KB	100

2. System.Linq — 2837 of 3400

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	7.04 μs	7.04 μs	100	48 B	0 B	57.7
Project To Array	4.25 μs	3.8 μs	94.5	39.13 KB	39.09 KB	99.9
Filter, Project, Materialize	5.86 μs	5.86 μs	100	9.93 KB	9.83 KB	99.5
Chained Pipeline	10.87 μs	7.05 μs	80.5	4.14 KB	3.93 KB	97.4
List Source	10.12 μs	10.12 μs	100	13.22 KB	13.07 KB	99.4
Opaque Source	19.88 μs	19.88 μs	100	13.22 KB	13.1 KB	99.6
Span Source	—	12.01 μs	0	—	13.07 KB	0
Paged Slice	204.44 ns	204.44 ns	100	4.02 KB	3.93 KB	98.8
Any Match	2.7 μs	2.7 μs	100	0 B	0 B	100
First Match	1.92 μs	1.91 μs	99.8	0 B	0 B	100
Flatten Nested Sequences	4.74 μs	4.74 μs	100	39.18 KB	39.09 KB	99.9
Distinct Values	61.29 μs	25.55 μs	64.6	179.3 KB	3.98 KB	14.9
Zip Pairs	60.52 μs	10.46 μs	41.6	39.24 KB	39.09 KB	99.8
Aggregate	2.85 μs	2.85 μs	100	0 B	0 B	100
Ordered Top N	31.23 μs	31.23 μs	100	78.56 KB	248 B	5.814
Group and Aggregate	73.41 μs	70.24 μs	97.8	131.27 KB	130.59 KB	99.7
Join and Project	79.15 μs	58.52 μs	86	129.45 KB	129.19 KB	99.9

3. StructLinq — 2207 of 3400

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	9.4 μs	7.04 μs	86.5	64 B	0 B	52.2
Project To Array	7.7 μs	3.8 μs	70.2	39.09 KB	39.09 KB	100
Filter, Project, Materialize	25.81 μs	5.86 μs	47.6	9.9 KB	9.83 KB	99.6
Chained Pipeline	9.05 μs	7.05 μs	88.2	4.06 KB	3.93 KB	98.4
List Source	12.88 μs	10.12 μs	88.6	13.14 KB	13.07 KB	99.7
Opaque Source	22.37 μs	19.88 μs	94.3	13.16 KB	13.1 KB	99.8
Span Source	—	12.01 μs	0	—	13.07 KB	0
Paged Slice	758.39 ns	204.44 ns	52	3.99 KB	3.93 KB	99.2
Any Match	5.38 μs	2.7 μs	70.9	32 B	0 B	65.5
First Match	4.02 μs	1.91 μs	69.1	32 B	0 B	65.5
Flatten Nested Sequences	35.22 μs	4.74 μs	36.7	54.77 KB	39.09 KB	84.5
Distinct Values	25.55 μs	25.55 μs	100	4.01 KB	3.98 KB	99.7
Zip Pairs	17.95 μs	10.46 μs	76.3	39.19 KB	39.09 KB	99.9
Aggregate	5.62 μs	2.85 μs	71.1	32 B	0 B	65.5
Ordered Top N	476.97 μs	31.23 μs	25.6	248 B	248 B	100
Group and Aggregate	—	70.24 μs	0	—	130.59 KB	0
Join and Project	—	58.52 μs	0	—	129.19 KB	0

4. LinqAF — 2165 of 3400

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	8.01 μs	7.04 μs	93.7	0 B	0 B	100
Project To Array	20.22 μs	3.8 μs	43.3	151.38 KB	39.09 KB	50.8
Filter, Project, Materialize	6.73 μs	5.86 μs	93.3	32.27 KB	9.83 KB	55.2
Chained Pipeline	7.05 μs	7.05 μs	100	3.93 KB	3.93 KB	100
List Source	18.48 μs	10.12 μs	74	45.31 KB	13.07 KB	53.7
Opaque Source	30.36 μs	19.88 μs	80.9	45.34 KB	13.1 KB	53.8
Span Source	—	12.01 μs	0	—	13.07 KB	0
Paged Slice	2.53 μs	204.44 ns	28.5	3.93 KB	3.93 KB	100
Any Match	2.72 μs	2.7 μs	99.6	0 B	0 B	100
First Match	2.08 μs	1.91 μs	96	0 B	0 B	100
Flatten Nested Sequences	79.75 μs	4.74 μs	24.4	151.38 KB	39.09 KB	50.8
Distinct Values	171.39 μs	25.55 μs	38.6	246.72 KB	3.98 KB	12.7
Zip Pairs	23.52 μs	10.46 μs	66.7	151.38 KB	39.09 KB	50.8
Aggregate	2.85 μs	2.85 μs	100	0 B	0 B	100
Ordered Top N	284.06 μs	31.23 μs	33.2	257.14 KB	248 B	3.214
Group and Aggregate	150.28 μs	70.24 μs	68.4	194.63 KB	130.59 KB	81.9
Join and Project	210.61 μs	58.52 μs	52.7	374.56 KB	129.19 KB	58.7

5. NetFabric.Hyperlinq — 1850 of 3400

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	10.84 μs	7.04 μs	80.6	0 B	0 B	100
Project To Array	7.02 μs	3.8 μs	73.5	39.09 KB	39.09 KB	100
Filter, Project, Materialize	7.71 μs	5.86 μs	87.2	32.27 KB	9.83 KB	55.2
Chained Pipeline	8.81 μs	7.05 μs	89.4	8.3 KB	3.93 KB	68.9
List Source	13.5 μs	10.12 μs	86.6	29.48 KB	13.07 KB	66.6
Opaque Source	21.09 μs	19.88 μs	97.1	29.52 KB	13.1 KB	66.7
Span Source	12.01 μs	12.01 μs	100	29.48 KB	13.07 KB	66.6
Paged Slice	731.54 ns	204.44 ns	53	3.93 KB	3.93 KB	100
Any Match	5.35 μs	2.7 μs	71.1	0 B	0 B	100
First Match	2.37 μs	1.91 μs	89.9	0 B	0 B	100
Flatten Nested Sequences	23.3 μs	4.74 μs	45.1	103.7 KB	39.09 KB	61.4
Distinct Values	43.54 μs	25.55 μs	76.6	179.21 KB	3.98 KB	15
Zip Pairs	—	10.46 μs	0	—	39.09 KB	0
Aggregate	—	2.85 μs	0	—	0 B	0
Ordered Top N	—	31.23 μs	0	—	248 B	0
Group and Aggregate	—	70.24 μs	0	—	130.59 KB	0
Join and Project	—	58.52 μs	0	—	129.19 KB	0

Benchmark overview

Core

More overview charts (4)

Sources

Partitioning

Sequences

Advanced

Compared libraries (6)

	Hand-coded Direct loops written in C# without any query library.	Compare →
	LinqAF 3.0.0 A low-allocation re-implementation of LINQ-to-Objects that shadows the System.Linq operators and returns struct enumerables. Last released in 2019.	Compare →
	NetFabric.Hyperlinq 3.0.0-beta9 A value-enumerable LINQ implementation with span sources and low-allocation pipelines. The compared version is a prerelease.	Compare →
	StructLinq 0.28.2 A struct-based LINQ implementation with optional struct predicates that avoid delegate indirection. Last released in 2022.	Compare →
	System.Linq The LINQ-to-Objects implementation included with .NET, exposing the Enumerable operators over IEnumerable sequences.	Compare →
	ZLinq 1.5.6 A zero-allocation LINQ implementation built on struct enumerators, with span and SIMD support and a complete operator surface.	Compare →

Benchmark scenarios (18)

01 · Filter and Count

Filters 10,000 integers with a predicate and counts the survivors.

02 · Project To Array

Projects 10,000 integers through a selector and materializes a new array.

03 · Filter, Project, Materialize

Filters 5,000 orders by amount, projects one property, and materializes a list.

04 · Chained Pipeline

Composes a filter, a projection, a second filter, and a limit into one four-stage query.

05 · List Source

Runs the canonical filter and projection over a List<int>.

06 · Opaque Source

Runs the same query over an IEnumerable<int> exposing no count, indexer, or array.

07 · Span Source

Runs the same query over a ReadOnlySpan<int>.

08 · Paged Slice

Skips 4,000 integers, takes the next 1,000, and materializes them.

09 · Any Match

Reports whether any of 10,000 integers satisfies a predicate first met at index 9,500.

10 · First Match

Returns the first of 5,000 orders satisfying a predicate first met at index 4,500.

11 · Flatten Nested Sequences

Flattens 500 inner arrays of 20 integers and materializes the result.

12 · Distinct Values

Reduces 10,000 integers containing 1,000 distinct values to the distinct set.

13 · Zip Pairs

Pairs two sequences of 10,000 integers and materializes the products.

14 · Aggregate

Folds 10,000 integers with a caller-supplied accumulator and a seed.

15 · Ordered Top N

Orders 5,000 orders by descending amount and materializes the identifiers of the top 20.

16 · Group and Aggregate

Groups 5,000 orders by region and produces one summed total per region.

17 · Join and Project

Joins 5,000 orders to 500 customers on the customer key and projects the pairs.

18 · Struct Predicate Filter

Filters and counts 10,000 integers with a struct-typed predicate instead of a delegate.

Not rated: With this few rated entrants, the reference is a library's own result, not a result earned against a competitor, so the full 200 points would not reflect a win. (1 of 5 rated libraries support this.)

Logging

ZLogger leads the current rating · 6 libraries · 9 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 900 each here, so the maximum is 1800. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	ZLogger	9/9	402	801	1203	silver in Core, silver in Structured
2	Microsoft.Extensions.Logging	7/9	545	584	1129	gold in Structured
3	NLog	9/9	696	420	1115	gold in Core, bronze in Prepare, bronze in Structured
4	Serilog	9/9	526	432	958	gold in Prepare
5	log4net	9/9	417	383	800	silver in Prepare
6	OpenTelemetry	8/9	328	453	781	bronze in Core

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. ZLogger — 1203 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	3.99 ns	0 ns	44.8	0 B	0 B	100
Simple Message	145.69 ns	18.21 ns	36.2	0 B	0 B	100
Structured Properties	177.95 ns	50.87 ns	53.8	0 B	0 B	100
Exception	148.99 ns	17.76 ns	35.4	0 B	0 B	100
Scope Or Context	324.04 ns	73.27 ns	47.8	336 B	120 B	63.2
Template Rendering	162.12 ns	35.48 ns	47.3	0 B	0 B	100
Buffered Logging	453.27 ns	94.81 ns	45.9	0 B	0 B	100
Prepare Logger	27.04 μs	1.15 μs	20.6	21.27 KB	3.07 KB	38.1
Formatted Output	422.3 ns	207.28 ns	70.1	0 B	0 B	100

2. Microsoft.Extensions.Logging — 1129 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	10.9 ns	0 ns	29	0 B	0 B	100
Simple Message	18.21 ns	18.21 ns	100	0 B	0 B	100
Structured Properties	50.87 ns	50.87 ns	100	88 B	0 B	46.3
Exception	17.76 ns	17.76 ns	100	0 B	0 B	100
Scope Or Context	73.27 ns	73.27 ns	100	120 B	120 B	100
Template Rendering	35.48 ns	35.48 ns	100	0 B	0 B	100
Buffered Logging	—	94.81 ns	0	—	0 B	0
Prepare Logger	45.71 μs	1.15 μs	15.9	21.25 KB	3.07 KB	38.1
Formatted Output	—	207.28 ns	0	—	0 B	0

3. NLog — 1115 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	0 ns	0 ns	100	0 B	0 B	100
Simple Message	46.24 ns	18.21 ns	63.8	120 B	0 B	40.8
Structured Properties	87.1 ns	50.87 ns	76.7	248 B	0 B	29.7
Exception	43.69 ns	17.76 ns	64.8	120 B	0 B	40.8
Scope Or Context	105.26 ns	73.27 ns	83.6	248 B	120 B	72.8
Template Rendering	92.32 ns	35.48 ns	62.5	232 B	0 B	30.6
Buffered Logging	94.81 ns	94.81 ns	100	120 B	0 B	40.8
Prepare Logger	5.83 μs	1.15 μs	44.4	24.46 KB	3.07 KB	35.6
Formatted Output	207.28 ns	207.28 ns	100	272 B	0 B	28.5

4. Serilog — 958 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	1.26 ns	0 ns	66.6	0 B	0 B	100
Simple Message	92.95 ns	18.21 ns	45.2	160 B	0 B	36.1
Structured Properties	207.24 ns	50.87 ns	49.9	448 B	0 B	22.5
Exception	95.26 ns	17.76 ns	44.1	160 B	0 B	36.1
Scope Or Context	229.99 ns	73.27 ns	56.7	544 B	120 B	50.4
Template Rendering	202.82 ns	35.48 ns	42.3	432 B	0 B	22.9
Buffered Logging	379.85 ns	94.81 ns	50.2	160 B	0 B	36.1
Prepare Logger	1.15 μs	1.15 μs	100	3.07 KB	3.07 KB	100
Formatted Output	407.38 ns	207.28 ns	71.4	296 B	0 B	27.4

5. log4net — 800 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	8.66 ns	0 ns	32.2	0 B	0 B	100
Simple Message	114.26 ns	18.21 ns	40.8	160 B	0 B	36.1
Structured Properties	219.31 ns	50.87 ns	48.5	336 B	0 B	25.8
Exception	111.79 ns	17.76 ns	40.8	160 B	0 B	36.1
Scope Or Context	410.32 ns	73.27 ns	42.5	896 B	120 B	39.6
Template Rendering	144.43 ns	35.48 ns	50.1	272 B	0 B	28.5
Buffered Logging	503.19 ns	94.81 ns	43.6	840 B	0 B	16.7
Prepare Logger	14.39 μs	1.15 μs	28.3	6.79 KB	3.07 KB	67.4
Formatted Output	255.84 ns	207.28 ns	90.1	197 B	0 B	33

6. OpenTelemetry — 781 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	10.96 ns	0 ns	28.9	0 B	0 B	100
Simple Message	120.06 ns	18.21 ns	39.8	48 B	0 B	57.7
Structured Properties	256.93 ns	50.87 ns	44.8	216 B	0 B	31.6
Exception	123.55 ns	17.76 ns	38.8	48 B	0 B	57.7
Scope Or Context	190.33 ns	73.27 ns	62.3	168 B	120 B	86.6
Template Rendering	278.8 ns	35.48 ns	36.1	112 B	0 B	42
Buffered Logging	192.31 ns	94.81 ns	70.4	48 B	0 B	57.7
Prepare Logger	272.41 μs	1.15 μs	6.5	81.39 KB	3.07 KB	19.5
Formatted Output	—	207.28 ns	0	—	0 B	0

Benchmark overview

Core

More overview charts (2)

Structured

Prepare

Compared libraries (6)

	log4net 3.4.0 A mature Apache logging framework with hierarchical repositories, contextual properties, layouts, and appenders.	Compare →
	Microsoft.Extensions.Logging 10.0.11 The standard .NET logging abstraction and logger factory with providers, filtering, structured state, and scopes.	Compare →
	NLog 6.2.0 A configurable logging platform with structured events, scope context, targets, layouts, and asynchronous wrappers.	Compare →
	OpenTelemetry 1.18.0 The OpenTelemetry .NET logging provider and processing pipeline for collecting, enriching, batching, and exporting MEL log records.	Compare →
	Serilog 4.4.0 A structured event logger with message templates, contextual enrichment, and a broad sink ecosystem.	Compare →
	ZLogger 2.5.10 A source-generated and interpolated-string logger built on Microsoft.Extensions.Logging with UTF-8 and processor APIs.	Compare →

Benchmark scenarios (9)

01 · Disabled Log

Submits an Information event to a logger whose minimum level is Warning.

02 · Simple Message

Delivers one literal Information message to an in-memory sink.

03 · Structured Properties

Delivers one event with independently queryable OrderId and ElapsedMs properties.

04 · Exception

Delivers one Error event retaining the original exception metadata.

05 · Scope Or Context

Creates a temporary RequestId context and captures it on one event.

06 · Template Rendering

Formats amount 12.5 and customer Ada through the logger template API.

07 · Buffered Logging

Enqueues one event to a library-provided async or buffering wrapper and validates delivery after flush. Measures the cost of accepting the event; the remaining delivery work happens on a background thread.

08 · Prepare Logger

Creates, verifies, and releases one Information-enabled logger with an in-memory sink.

09 · Formatted Output

Formats one event synchronously into a bounded in-memory sink.

Object Mapping

Mapperly leads the current rating · 4 libraries · 10 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1000 each here, so the maximum is 2000. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	Mapperly	10/10	1000	1000	2000	gold in Advanced, gold in Basic, gold in Prepare
2	Mapster	10/10	581	792	1372	silver in Advanced, silver in Basic, bronze in Prepare
3	AutoMapper	10/10	418	802	1220	silver in Prepare, bronze in Advanced, bronze in Basic

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. Mapperly — 2000 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Simple Object	10.32 ns	10.32 ns	100	56 B	56 B	100
Nested Object	48.26 ns	48.26 ns	100	248 B	248 B	100
Collection	1.09 μs	1.09 μs	100	6.27 KB	6.27 KB	100
Flattening	10.09 ns	10.09 ns	100	56 B	56 B	100
Map To Existing	3.23 ns	3.23 ns	100	0 B	0 B	100
Null Handling	11.44 ns	11.44 ns	100	40 B	40 B	100
Custom Conversion	75.08 ns	75.08 ns	100	88 B	88 B	100
Polymorphic Mapping	35.53 ns	35.53 ns	100	144 B	144 B	100
Prepare Configuration	0 ns	0 ns	100	0 B	0 B	100
Prepare And Simple Map	10.71 ns	10.71 ns	100	56 B	56 B	100

2. Mapster — 1372 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Simple Object	18.14 ns	10.32 ns	76.9	56 B	56 B	100
Nested Object	63 ns	48.26 ns	87.7	248 B	248 B	100
Collection	1.55 μs	1.09 μs	83.7	6.27 KB	6.27 KB	100
Flattening	20.11 ns	10.09 ns	72.5	56 B	56 B	100
Map To Existing	16.16 ns	3.23 ns	49.6	0 B	0 B	100
Null Handling	29.67 ns	11.44 ns	63.7	40 B	40 B	100
Custom Conversion	91.47 ns	75.08 ns	90.7	112 B	88 B	90.7
Polymorphic Mapping	115.97 ns	35.53 ns	55.9	144 B	144 B	100
Prepare Configuration	23.68 ms	0 ns	0.021	2.6 MB	0 B	0.297
Prepare And Simple Map	24.93 ms	10.71 ns	0.069	2.75 MB	56 B	0.527

3. AutoMapper — 1220 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Simple Object	70.97 ns	10.32 ns	39.7	56 B	56 B	100
Nested Object	102.1 ns	48.26 ns	69.1	248 B	248 B	100
Collection	1.23 μs	1.09 μs	94.1	6.27 KB	6.27 KB	100
Flattening	82.17 ns	10.09 ns	36.5	56 B	56 B	100
Map To Existing	62.81 ns	3.23 ns	25.7	0 B	0 B	100
Null Handling	69.35 ns	11.44 ns	42	40 B	40 B	100
Custom Conversion	127.11 ns	75.08 ns	77.1	88 B	88 B	100
Polymorphic Mapping	319.46 ns	35.53 ns	33.8	144 B	144 B	100
Prepare Configuration	13.56 ms	0 ns	0.027	624.91 KB	0 B	0.612
Prepare And Simple Map	14.18 ms	10.71 ns	0.091	656.21 KB	56 B	1.091

Benchmark overview

Basic

More overview charts (2)

Advanced

Prepare

Compared libraries (4)

	AutoMapper 16.2.0 A convention-based object-object mapper with runtime configuration and compiled mapping plans.	Compare →
	Hand-coded Direct object mapping written in C# without a mapping library.	Compare →
	Mapperly 4.3.1 A source generator that creates readable object mapping code at compile time.	Compare →
	Mapster 10.0.12 An object mapper with runtime configuration, expression compilation, and projection support.	Compare →

Benchmark scenarios (10)

01 · Simple Object

Maps one object with scalar values to a newly allocated destination object.

02 · Nested Object

Maps an order with nested customer and address objects to a new destination graph.

03 · Collection

Maps an array of 100 objects while preserving count, order and member values.

04 · Flattening

Maps nested customer values into a flat order summary through member-path configuration.

05 · Map To Existing

Overwrites a supplied destination object and returns that same instance.

06 · Null Handling

Preserves null text, nested object and collection members in the destination.

07 · Custom Conversion

Maps string values through registered code and invariant decimal conversions.

08 · Polymorphic Mapping

Maps a base array containing cats and dogs to matching destination runtime types.

09 · Prepare Configuration

Creates the complete mapper configuration and eagerly prepares its runtime mapping plans.

10 · Prepare And Simple Map

Creates the complete mapper configuration and maps one simple object.

Validation

Microsoft.Extensions.Validation leads the current rating · 4 libraries · 10 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 900 each here, so the maximum is 1800. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	Microsoft.Extensions.Validation	8/9	747	791	1539	gold in Basic, silver in Object Graph, silver in Prepare, bronze in Rules
2	DataAnnotations	9/9	731	734	1465	gold in Prepare, gold in Rules
3	MiniValidation	8/9	736	720	1455	gold in Object Graph, silver in Basic, bronze in Prepare
4	FluentValidation	9/9	659	567	1226	silver in Rules, bronze in Basic, bronze in Object Graph

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. Microsoft.Extensions.Validation — 1539 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	611.8 ns	207.33 ns	58.3	592 B	592 B	100
Single Failure	894 ns	890.2 ns	99.8	984 B	984 B	100
Multiple Failures	1.31 μs	1.31 μs	100	1.37 KB	1.37 KB	100
Nested Object	1.07 μs	1.07 μs	100	1.55 KB	1.55 KB	100
Collection	2.78 μs	2.28 μs	90.6	3.32 KB	2.77 KB	91.5
Conditional Rule	337.04 ns	327.33 ns	98.6	864 B	864 B	100
Custom Rule	524.37 ns	524.37 ns	100	896 B	896 B	100
Stop On First Failure	—	397.89 ns	0	—	576 B	0
Prepare Validator	0 ns	0 ns	100	0 B	0 B	100

2. DataAnnotations — 1465 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	1.14 μs	207.33 ns	42.7	1.8 KB	592 B	57.4
Single Failure	1.28 μs	890.2 ns	83.4	1.88 KB	984 B	71.9
Multiple Failures	1.93 μs	1.31 μs	82.5	2.41 KB	1.37 KB	75.5
Nested Object	1.6 μs	1.07 μs	81.9	2.31 KB	1.55 KB	82
Collection	3.48 μs	2.28 μs	81.1	5.27 KB	2.77 KB	72.7
Conditional Rule	527.83 ns	327.33 ns	78.8	1.2 KB	864 B	84.4
Custom Rule	802.08 ns	524.37 ns	80.9	1.08 KB	896 B	90.3
Stop On First Failure	397.89 ns	397.89 ns	100	576 B	576 B	100
Prepare Validator	0 ns	0 ns	100	0 B	0 B	100

3. MiniValidation — 1455 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	491.99 ns	207.33 ns	65	760 B	592 B	88.6
Single Failure	890.2 ns	890.2 ns	100	1.34 KB	984 B	85.1
Multiple Failures	1.65 μs	1.31 μs	89.3	2.16 KB	1.37 KB	79.7
Nested Object	1.19 μs	1.07 μs	95	1.86 KB	1.55 KB	91.3
Collection	2.28 μs	2.28 μs	100	2.77 KB	2.77 KB	100
Conditional Rule	327.33 ns	327.33 ns	100	1008 B	864 B	92.8
Custom Rule	703.57 ns	524.37 ns	86.4	1.31 KB	896 B	82
Stop On First Failure	—	397.89 ns	0	—	576 B	0
Prepare Validator	0 ns	0 ns	100	0 B	0 B	100

4. FluentValidation — 1226 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	207.33 ns	207.33 ns	100	632 B	592 B	96.9
Single Failure	905.54 ns	890.2 ns	99.2	1.76 KB	984 B	74.3
Multiple Failures	2.95 μs	1.31 μs	66.7	6.02 KB	1.37 KB	48
Nested Object	1.25 μs	1.07 μs	92.8	2.38 KB	1.55 KB	80.8
Collection	3.52 μs	2.28 μs	80.6	6.57 KB	2.77 KB	65.1
Conditional Rule	777.6 ns	327.33 ns	64.9	1.77 KB	864 B	69.6
Custom Rule	795.58 ns	524.37 ns	81.2	1.85 KB	896 B	69.2
Stop On First Failure	780.94 ns	397.89 ns	71.4	1.76 KB	576 B	57.4
Prepare Validator	2.87 μs	0 ns	1.866	6.33 KB	0 B	6.075

Benchmark overview

Basic

More overview charts (3)

Object Graph

Rules

Prepare

Compared libraries (4)

	DataAnnotations The validation attributes and validation APIs included with the .NET framework.	Compare →
	FluentValidation 12.1.1 A strongly typed validation library with fluent rules, nested validators, cascade modes, and asynchronous validation.	Compare →
	Microsoft.Extensions.Validation 10.0.11 The official source-generated validation infrastructure for DataAnnotations-based object graph validation outside ASP.NET Core.	Compare →
	MiniValidation 0.10.0 A minimal DataAnnotations-based validator with recursive object graph traversal and cycle detection.	Compare →

Benchmark scenarios (10)

01 · Valid Object

Validates one object whose scalar properties satisfy every rule.

02 · Single Failure

Validates one object and returns its single property failure.

03 · Multiple Failures

Validates one object and materializes three independent property failures.

04 · Nested Object

Traverses a nested object and reports the complete failing property path.

05 · Collection

Traverses three collection elements and reports an indexed failure path.

06 · Conditional Rule

Applies a tax ID rule only when the input represents a business.

07 · Custom Rule

Applies a custom predicate that accepts only even integer codes.

08 · Stop On First Failure

Stops validation after the first failing rule in the declared order.

09 · Async Validation

Runs a deterministic asynchronous availability rule through the library async API.

Not rated: With this few rated entrants, the reference is a library's own result, not a result earned against a competitor, so the full 200 points would not reflect a win. (1 of 4 rated libraries support this.)

10 · Prepare Validator

Creates the complete scalar validator or rule graph without validating an input.

ZIP Archives

SharpZipLib leads the current rating · 3 libraries · 13 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1300 each here, so the maximum is 2600. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	SharpZipLib	13/13	1129	1058	2187	gold in Advanced, gold in Metadata, silver in Read, silver in Write
2	System.IO.Compression	12/13	1172	968	2140	gold in Read, gold in Write, silver in Metadata, bronze in Advanced
3	SharpCompress	13/13	889	886	1775	silver in Advanced, bronze in Metadata, bronze in Read, bronze in Write

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. SharpZipLib — 2187 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
List Entries	233.7 μs	196.95 μs	91.8	305.15 KB	305.15 KB	100
Find Entry By Name	247.09 μs	189.23 μs	87.5	305.23 KB	305.23 KB	100
Read Stored Entry	15.5 ms	15.37 ms	99.6	1.02 KB	1.02 KB	100
Decompress Entry	16.04 ms	15.6 ms	98.6	41.05 KB	5.38 KB	36.3
Extract Many Small Entries	17.87 ms	15.72 ms	93.8	35.98 MB	987.53 KB	16.4
Create Stored Archive	377.29 μs	243.88 μs	80.4	957.7 KB	645.86 KB	82.1
Create Deflate Fast Archive	2.32 ms	660.85 μs	53.4	622.91 KB	329.69 KB	72.8
Create Deflate Optimal Archive	2.76 ms	1.26 ms	67.6	621.27 KB	193.67 KB	55.8
Create Many Small Entries	7.2 ms	4.98 ms	83.1	13.99 MB	12.66 MB	95.1
Append Entry	246.28 μs	234.61 μs	97.6	398.18 KB	394.87 KB	99.6
Sequential Non-Seekable Read	18.23 ms	18.22 ms	99.9	458.67 KB	458.67 KB	100
Read Zip64 Archive	31.32 ms	31.32 ms	100	19.5 MB	19.5 MB	100
Read AES Encrypted Entry	2.84 ms	1.63 ms	75.9	43.93 KB	43.93 KB	100

2. System.IO.Compression — 2140 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
List Entries	196.95 μs	196.95 μs	100	659.41 KB	305.15 KB	68
Find Entry By Name	189.23 μs	189.23 μs	100	659.37 KB	305.23 KB	68
Read Stored Entry	15.39 ms	15.37 ms	99.9	5.12 KB	1.02 KB	45.1
Decompress Entry	15.6 ms	15.6 ms	100	5.38 KB	5.38 KB	100
Extract Many Small Entries	15.72 ms	15.72 ms	100	987.53 KB	987.53 KB	100
Create Stored Archive	243.88 μs	243.88 μs	100	645.86 KB	645.86 KB	100
Create Deflate Fast Archive	660.85 μs	660.85 μs	100	329.69 KB	329.69 KB	100
Create Deflate Optimal Archive	1.26 ms	1.26 ms	100	193.67 KB	193.67 KB	100
Create Many Small Entries	4.98 ms	4.98 ms	100	12.66 MB	12.66 MB	100
Append Entry	234.61 μs	234.61 μs	100	394.87 KB	394.87 KB	100
Sequential Non-Seekable Read	19.04 ms	18.22 ms	97.8	16.84 MB	458.67 KB	16.3
Read Zip64 Archive	56.57 ms	31.32 ms	74.4	39.39 MB	19.5 MB	70.4
Read AES Encrypted Entry	—	1.63 ms	0	—	43.93 KB	0

3. SharpCompress — 1775 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
List Entries	834.05 μs	196.95 μs	48.6	660.69 KB	305.15 KB	68
Find Entry By Name	838.39 μs	189.23 μs	47.5	660.58 KB	305.23 KB	68
Read Stored Entry	15.37 ms	15.37 ms	100	67.85 KB	1.02 KB	12.4
Decompress Entry	15.99 ms	15.6 ms	98.8	33.56 KB	5.38 KB	40.1
Extract Many Small Entries	18.23 ms	15.72 ms	92.9	2.27 MB	987.53 KB	65.2
Create Stored Archive	1.14 ms	243.88 μs	46.3	646.26 KB	645.86 KB	100
Create Deflate Fast Archive	3.13 ms	660.85 μs	46	345.04 KB	329.69 KB	97.7
Create Deflate Optimal Archive	3.64 ms	1.26 ms	58.8	344.59 KB	193.67 KB	75
Create Many Small Entries	23.25 ms	4.98 ms	46.3	12.69 MB	12.66 MB	99.9
Append Entry	1.17 ms	234.61 μs	44.8	721.46 KB	394.87 KB	74
Sequential Non-Seekable Read	18.22 ms	18.22 ms	100	2.28 MB	458.67 KB	44.3
Read Zip64 Archive	89.12 ms	31.32 ms	59.3	38.07 MB	19.5 MB	71.6
Read AES Encrypted Entry	1.63 ms	1.63 ms	100	89.79 KB	43.93 KB	70

Benchmark overview

Metadata

More overview charts (3)

Read

Write

Advanced

Compared libraries (3)

	SharpCompress 0.50.4 A fully managed archive library with random-access, forward-only, non-seekable, encrypted, and asynchronous ZIP APIs.	Compare →
	SharpZipLib 1.4.2 A mature managed compression library supporting ZIP, Zip64, stored and deflate entries, streaming, and AES encryption.	Compare →
	System.IO.Compression The ZIP implementation included with .NET, exposing ZipArchive, ZipArchiveEntry, and ZipFile APIs.	Compare →

Benchmark scenarios (13)

01 · List Entries

Opens a ZIP archive and enumerates 1,000 entry names and sizes.

02 · Find Entry By Name

Opens a 1,000-entry ZIP archive and locates its final entry by exact name.

03 · Read Stored Entry

Opens and reads one uncompressed 4 MiB ZIP entry.

04 · Decompress Entry

Opens and inflates one 4 MiB deflated ZIP entry.

05 · Extract Many Small Entries

Opens and reads all 1,000 small entries from a ZIP archive.

06 · Create Stored Archive

Creates a stored ZIP archive containing a deterministic mixed corpus.

07 · Create Deflate Fast Archive

Creates a Deflate level 1 ZIP archive containing the deterministic mixed corpus.

08 · Create Deflate Optimal Archive

Creates a Deflate level 6 ZIP archive containing the deterministic mixed corpus.

09 · Create Many Small Entries

Creates a stored ZIP archive containing 1,000 small files.

10 · Append Entry

Opens an existing ZIP archive for update and appends one stored entry.

11 · Sequential Non-Seekable Read

Reads all entries through a forward-only ZIP API from a non-seekable stream.

12 · Read Zip64 Archive

Opens and enumerates a Zip64 archive containing 65,536 entries.

13 · Read AES Encrypted Entry

Opens and decrypts one AES-256 encrypted ZIP entry.

Reproduce the results

Environment requirements

The complete workflow requires:

• a 64-bit operating system supported by the .NET 10 SDK;
• the .NET 10 SDK available as dotnet on PATH;
• access to the configured NuGet sources on the first run, or a populated local package cache;
• a writable repository checkout and several GB of free space for build, BenchmarkDotNet, report, and Web artifacts;
• at least 8 GB of RAM as a practical minimum.

For meaningful performance comparisons, run on an otherwise idle machine, connected to power, without a debugger, with a fixed performance-oriented power profile. Do not combine results produced by different frameworks, runtimes, operating systems, architectures, or processors without reviewing the recorded benchmark environment.

Run the complete reproducible workflow:

dotnet run --project .\build -- reproduce

The target validates and benchmarks every library, regenerates reports, charts, metadata, README, and Rider configurations, and starts the local Web application on an automatically selected available port. Use --no-browser to suppress automatic browser opening. Press Ctrl+C to stop the local application.

To use the reports already on disk and go directly to artifact generation and the local application:

dotnet run --project .\build -- reproduce --skip-benchmarks

Child-process output is saved under artifacts/logs; the console shows concise progress and prints the relevant log tail if an operation fails.

The Run .NET Matrix Reports GitHub Actions workflow produces one matrix-reports archive containing every category report, the raw BenchmarkDotNet evidence, summaries, a manifest, and SHA-256 checksums. Download that archive and import the complete verified snapshot manually with:

dotnet run --project .\build -- import-reports --archive .\matrix-reports.zip

Repository report JSON files and their evidence are updated under reports from the same archive. Evidence is committed with the report, so a Git tag preserves the measurements and their provenance together.

To regenerate source-controlled artifacts without starting the local application:

dotnet run --project .\build -- finalize-commit

Running the complete benchmark matrix can take a long time. Use dotnet run --project .\build -- --help to find commands for a single category or library.

Link to a category or a library

The application reads five optional query parameters, so a page about a library can link straight to the relevant comparison instead of the front page:

Link	Opens
https://matrix.dev-team.org/	the default category, newest reports
https://matrix.dev-team.org/?category=csv-processing	that category
https://matrix.dev-team.org/?library=CsvHelper	the library overview, in its own category
https://matrix.dev-team.org/?version=latest&library=CsvHelper	the same overview, newest release named explicitly
https://matrix.dev-team.org/?category=csv-processing&libraries=CsvHelper	that category, narrowed to one library
https://matrix.dev-team.org/?category=csv-processing&features=ReadSimpleRows	that category, narrowed to one scenario

The five are independent and combine freely; the links in the tables above are the same thing with the values filled in.

category

Accepts the category id or its displayed name, for example ?category=csv-processing. Matching ignores case, spaces and punctuation.

library

Accepts the library id, its displayed name or its NuGet package id, and finds the category on its own, so ?library=CsvHelper needs no category beside it. Add category only to break a tie between two categories that use the same library id. The library overview opens as a dialog over the matrix.

libraries

Narrows the comparison to the libraries you name, for example ?libraries=CsvHelper. Ids, displayed names and NuGet package ids all work, separated by commas and matched the same forgiving way as category. Start the list with - to name what to leave out instead, as in ?libraries=-CsvHelper, and use none for an empty comparison.

This one changes the numbers, which is why it is in the address at all: points are measured against the best result among the compared libraries, so a link that dropped the selection would show a different rating under the same names. Leave it out for the whole category — that is the default view, and the reason it carries no parameter. Ticking boxes in the application writes it for you, taking whichever list is shorter.

features

Narrows the comparison to the scenarios you name, for example ?features=ReadSimpleRows. Scenario ids and displayed names both work, separated by commas and matched the same forgiving way as category. Start the list with - to name what to leave out instead, and use none for an empty comparison — the same spelling as libraries.

It changes the numbers for the same reason libraries does: a score is the sum over the scenarios compared, so dropping the ones a project does not need reranks the libraries around the ones it does. The feature matrix, the benchmark charts, the overview groups and the rating all read the one selection, and a group left without scenarios disappears rather than being drawn empty. Leave the parameter out for every scenario of the category — that is the default view.

version

Pins the reports to one release. It takes a release name exactly as the picker shows it, for example ?version=1.2.0, or the word latest. Unlike the other two, the value is matched exactly: dropping punctuation would make 1.2.3 and 12.3 indistinguishable.

Leave it out to follow every new release — a link without it always shows the newest reports, which is what a page about a library normally wants. Use it when the link has to keep showing the numbers it was written against, for example next to a quoted result in an article.

The release picker in the application writes the parameter into the address, and the copy buttons follow the same rule: the release appears in the copied link only while an older one is being viewed.

An unknown value of any of them falls back to the default view rather than to an error, so a typo in a link published elsewhere still lands the reader in the matrix.