CSV Parser Comparison Benchmarks

May 9, 2026 ยท View on GitHub

This directory is intentionally standalone. It is not referenced by the top-level build, so comparison benchmarking remains opt-in and cannot slow normal developer or CI builds.

Executive Summary

These benchmarks were run on:

  • Windows 11 Home 25H2 (OS build 26200.8246)
  • Visual Studio 2026 / MSVC 19.50
  • Windows SDK 10.0.26100.0
  • C++20
  • AVX2 enabled
  • CSV_ENABLE_THREADS=ON
  • Google Benchmark 1.8.5
  • 12th Gen Intel(R) Core(TM) i5-12400
  • 12 logical CPUs at ~2.5 GHz
  • Samsung 990 EVO SSD storage

The short version:

  • fast-cpp-csv-parser remains a strong single-parser-worker baseline, especially on smaller raw read loops.
  • With positional access and 4+ parser workers, csv-parser overtakes fast-cpp-csv-parser on clean and quoted read workloads.
  • csv-parser beats Glaze's CSV reader on the mixed string/numeric/quoted workloads shown below, including the no-background-thread path.
  • csv-parser wins the materialization and materialize+aggregation ETL benchmarks shown below, while also supporting multiline CSV that fast-cpp-csv-parser cannot parse.
  • csv-parser beats rapidcsv for both DataFrame load and edited load+save workflows at 500K and 5M rows.

All tables below use median real time from the Google Benchmark output.

Scope

  • csv_parser_read_bench: read benchmarks for this library, using the filename constructor and therefore the native mmap parser where supported.
  • csv_parser_multi_pass_bench: single-parser-worker materialization and multi-pass ETL-style benchmarks using reusable CSVRow objects.
  • csv_parser_fast_cpp_read_bench: one-binary positional-read comparison between this library, fast-cpp-csv-parser, and Glaze. It labels scheduling explicitly: csv-parser no-background-thread, csv-parser SPSC producer/consumer, csv-parser speculative parallel parsing, and fast-cpp-csv-parser SPSC-style background I/O.
  • fast_cpp_csv_parser_read_bench: read-focused benchmarks for fast-cpp-csv-parser.
  • fast_cpp_csv_parser_multi_pass_bench: single-parser-worker materialization and multi-pass ETL-style benchmarks for fast-cpp-csv-parser, materializing into named-field row structs before running repeated passes.
  • glaze_csv_read_bench: read-focused benchmarks for Glaze's CSV reader, materializing into reflected row structs through glz::read<glz::opts_csv>.
  • glaze_csv_multi_pass_bench: single-parser-worker materialization and multi-pass ETL-style benchmarks for Glaze, using reflected row structs with native numeric deserialization for the aggregation fields.
  • dataframe_rapidcsv_roundtrip_bench: table/round-trip-oriented benchmarks comparing this library's DataFrame workflow with rapidcsv, including load-only and edited full round-trip cases.

The rapidcsv round-trip benchmark uses rapidcsv::Document::Save() for the rapidcsv write side. The csv-parser benchmark writes through this library's CSVWriter, so benchmark names call that out explicitly.

Configure

From the repository root:

cmake -S benchmarks -B build/benchmarks -DCMAKE_BUILD_TYPE=Release
cmake --build build/benchmarks --config Release

By default, CMake uses FetchContent for Google Benchmark and the comparison libraries if they are not already available. For offline or pinned dependency work, provide local include directories instead:

cmake -S benchmarks -B build/benchmarks `
  -DFAST_CPP_CSV_PARSER_INCLUDE_DIR=C:/src/fast-cpp-csv-parser `
  -DGLAZE_INCLUDE_DIR=C:/src/glaze/include `
  -DRAPIDCSV_INCLUDE_DIR=C:/src/rapidcsv/src

The Glaze benchmark targets are compiled with C++23 flags because current Glaze headers use C++23 library facilities. The rest of the benchmark project remains configured as C++20.

Datasets

The benchmark programs expect a CSV file with this 8-column schema:

id,city,state,category,amount,quantity,flag,note

Three payload profiles are supported:

  • clean: deterministic scalar fields with no embedded commas, quotes, or line breaks.
  • quoted: quoted commas and doubled quotes in the note column, but no embedded line breaks.
  • multiline: quoted commas, doubled quotes, and embedded line breaks in the note column.

Two row shapes are supported:

  • standard: the original compact schema values
  • wide: longer string values across the same 8 columns

Use enough rows to cross csv-parser's 10 MB chunk boundary when measuring reader behavior. At least 500K rows is the project baseline for large-file coverage.

How To Run

Example run:

build/benchmarks/Release/csv_parser_read_bench.exe --benchmark_format=json data/bench_8col_500k.csv
build/benchmarks/Release/csv_parser_multi_pass_bench.exe --benchmark_format=json data/bench_8col_500k.csv
build/benchmarks/Release/csv_parser_fast_cpp_read_bench.exe --benchmark_format=json data/bench_8col_500k.csv
build/benchmarks/Release/fast_cpp_csv_parser_read_bench.exe --benchmark_format=json data/bench_8col_500k.csv
build/benchmarks/Release/fast_cpp_csv_parser_multi_pass_bench.exe --benchmark_format=json data/bench_8col_500k.csv
build/benchmarks/Release/glaze_csv_multi_pass_bench.exe --benchmark_format=json data/bench_8col_500k.csv
build/benchmarks/Release/dataframe_rapidcsv_roundtrip_bench.exe --benchmark_format=json data/bench_8col_500k.csv

Or use the helper script, which generates the default 500K-row dataset, builds the standalone benchmark tree, and runs any benchmark executables that were available in the build:

benchmarks/scripts/run_benchmarks.ps1

For Python reader comparisons against stdlib csv.reader, build the Python binding and run:

python python/benchmarks/compare_readers.py path/to/input.csv

The Python helper prints one tab-separated line per available variant with file path, file size, rows, columns, elapsed seconds, MiB/s, and rows/s. The matrix compares stdlib csv.reader, csvpy.reader, stdlib csv.DictReader, and csvpy.DictReader, with separate csvpy string-only and cast=True runs.

The script writes JSON results to benchmarks/results/<row-count>_rows/<profile>/<benchmark-name>.json and also copies the exact input CSV locally to benchmarks/results/<row-count>_rows/<profile>/benchmark_input.csv.

By default it runs clean, quoted, and multiline payloads at 500K rows and 5M rows. The helper skips the fast-cpp-csv-parser benchmarks on multiline payloads because that library does not support quoted line breaks.

csv-parser vs fast-cpp-csv-parser

What To Compare

There are two very different stories here:

  1. Raw parsing throughput

    • Count rows
    • Read rows
    • Minimal downstream work

  2. Actual ETL / aggregation work

    • Materialize rows into a reusable row structure
    • Run repeated passes over the data
    • Pay the cost of turning bytes into something you can work with

fast-cpp-csv-parser is excellent at the first category. These benchmarks are included because that speed is real and worth acknowledging.

The second category is where csv-parser pulls ahead in these runs. It is faster on the materialize and materialize+multi-pass workloads shown below, and it supports multiline CSV files that fast-cpp-csv-parser cannot parse.

One more important point: the materialization and multi-pass ETL comparisons below are intentionally single-parser-worker runs to stay as apples-to-apples as possible. In real use, fast-cpp-csv-parser stops at parsing. The caller owns row materialization, repeated-pass analysis, and any thread-pool or chunk-parallel orchestration. csv-parser ships those higher-level pieces out of the box, including chunk_parallel_apply(), so the benchmark is conservative with respect to the actual library surface each user gets.

Raw Parse Throughput

Median real time, 8-column datasets.

Datasetcsv-parser countfast-cpp countcsv-parser readfast-cpp read
500K clean146.5 ms81.8 ms164.9 ms82.8 ms
500K quoted197.2 ms118.8 ms223.5 ms136.2 ms
5M clean547.6 ms881.5 ms1,087 ms944.2 ms
5M quoted665.4 ms1,153 ms1,140 ms1,164 ms

That is the honest "bytes in, rows out" picture. fast-cpp-csv-parser wins the smaller raw throughput tests on the inputs it supports, while the mmap path is faster on the current 5M-row count runs.

It is also worth noting that csv-parser supports a more dynamic row model by default. If users choose positional access, which is much closer to the access pattern fast-cpp-csv-parser effectively pushes users toward, the mmap path changes the picture. In this table, csv-parser SPSC means one background producer/parser worker feeding the foreground consumer through the reader queue; spec-N means speculative parallel parsing with N parser workers. fast-cpp-csv-parser SPSC means its default background block reader plus one foreground parser.

New runs of csv_parser_fast_cpp_read_bench also include csv_parser_no_background_thread_read_8col, which disables the background CSVReader worker at runtime.

The no-background-thread result is useful for constrained environments and extremely cheap caller loops. If user code does almost nothing per row, the background producer/consumer layer has little downstream work to hide and may not improve raw throughput. The SPSC-style mode is still the better default for general use because it decouples parser progress from caller-side work, and it helps speculative parsing keep the parser side busy while the foreground consumer performs conversions, filtering, aggregation, or other row handling.

Datasetcsv-parser no backgroundcsv-parser SPSCcsv-parser spec-2csv-parser spec-4csv-parser spec-8fast-cpp SPSC read
500K clean155.4 ms154.5 ms123.9 ms76.6 ms77.7 ms88.0 ms
500K quoted192.9 ms196.3 ms117.6 ms89.3 ms83.1 ms119.1 ms
5M clean1,390 ms1,442 ms975.8 ms702.2 ms605.0 ms915.1 ms
5M quoted1,712 ms1,889 ms1,331 ms977.0 ms819.9 ms1,320 ms

That is the core performance story for modern csv-parser: positional reads scale with worker threads and overtake fast-cpp-csv-parser by 4 threads on these clean and quoted runs.

Materialization Throughput

This table compares the one-pass row materialization benchmarks:

  • csv-parser: materialize_csvrow_8col
  • fast-cpp-csv-parser: materialize_struct_8col

Lower is better.

Datasetcsv-parserfast-cpp-csv-parserWinner
500K clean156.8 ms218.8 mscsv-parser
500K quoted211.1 ms301.9 mscsv-parser
500K multiline207.4 msunsupportedcsv-parser
5M clean739.6 ms2,105 mscsv-parser
5M quoted930.6 ms2,489 mscsv-parser
5M multiline827.1 msunsupportedcsv-parser

Materialize + Aggregation Throughput

This table compares the closest apples-to-apples ETL benchmark:

  • csv-parser: materialize_and_multi_pass_csvrow_8col
  • fast-cpp-csv-parser: materialize_and_multi_pass_struct_8col

Lower is better.

Datasetcsv-parserfast-cpp-csv-parserWinner
500K clean215.4 ms237.1 mscsv-parser
500K quoted262.9 ms280.7 mscsv-parser
500K multiline287.5 msunsupportedcsv-parser
5M clean1,251 ms2,252 mscsv-parser
5M quoted1,517 ms3,090 mscsv-parser
5M multiline1,372 msunsupportedcsv-parser

Takeaway

  • fast-cpp-csv-parser is still a strong single-parser-worker raw-read baseline on the inputs it supports.
  • csv-parser wins the positional-read comparison once 4 parser workers are available.
  • csv-parser wins the materialization and ETL-style tables above.
  • csv-parser handles quoted line breaks; fast-cpp-csv-parser does not.

csv-parser vs Glaze

Glaze was added because its reflected struct API is a natural comparison point for users who want typed CSV deserialization. Its CSV reader is much smaller and simpler than csv-parser's parser core, which is a reasonable tradeoff for a general serialization library. These results measure a mixed workload with strings, quoted fields, numeric fields, and row-oriented access. A dense number-heavy CSV may move the relative numbers, but this mixed workload is a realistic target for csv-parser.

Raw Mixed Read Throughput

This table comes from the same csv_parser_fast_cpp_read_bench bundle used in the fast-cpp comparison. It reports positional string access for csv-parser, caller-owned strings for fast-cpp-csv-parser, and reflected row structs for Glaze.

Datasetcsv-parser no backgroundcsv-parser SPSCcsv-parser spec-8Glaze read
500K clean155.4 ms154.5 ms77.7 ms243.0 ms
500K quoted192.9 ms196.3 ms83.1 ms302.5 ms
5M clean1,390 ms1,442 ms605.0 ms2,418 ms
5M quoted1,712 ms1,889 ms819.9 ms3,122 ms

Materialization Throughput

This table compares one-pass materialization into each library's natural row representation:

  • csv-parser: reusable CSVRow objects backed by parser-owned row data
  • Glaze: reflected row structs through glz::read<glz::opts_csv>
Datasetcsv-parserGlazeWinner
500K clean156.8 ms209.8 mscsv-parser
500K quoted211.1 ms267.1 mscsv-parser
500K multiline207.4 ms282.9 mscsv-parser
5M clean739.6 ms1,972 mscsv-parser
5M quoted930.6 ms2,930 mscsv-parser
5M multiline827.1 ms2,492 mscsv-parser

Materialize + Aggregation Throughput

Both libraries use their own numeric conversion/deserialization paths for the numeric fields in this benchmark.

Datasetcsv-parserGlazeWinner
500K clean215.4 ms232.6 mscsv-parser
500K quoted262.9 ms283.1 mscsv-parser
500K multiline287.5 ms287.7 mseffectively tied
5M clean1,251 ms2,084 mscsv-parser
5M quoted1,517 ms3,381 mscsv-parser
5M multiline1,372 ms2,649 mscsv-parser

csv-parser vs rapidcsv

The benchmark edits two columns before save paths, so the test is not merely "load a file and dump it back unchanged." Both libraries are asked to do small, realistic table mutation work.

These rapidcsv comparisons are single-threaded table load/save benchmarks. They do not include a speculative parallel CSVReader, DataFrameExecutor, column_parallel_apply(), or chunk_parallel_apply(); using those primitives would likely widen the gap for real ETL workloads.

500K Rows

Median real time, lower is better.

Datasetcsv-parser loadrapidcsv loadcsv-parser load+saverapidcsv load+save
clean156.7 ms244.7 ms310.5 ms683.0 ms
quoted211.6 ms330.1 ms409.8 ms890.5 ms
multiline220.4 ms325.2 ms412.7 ms905.8 ms

5M Rows

Median real time, lower is better.

Datasetcsv-parser loadrapidcsv loadcsv-parser load+saverapidcsv load+save
clean666.3 ms2,587 ms2,070 ms7,140 ms
quoted951.6 ms3,450 ms2,910 ms10,425 ms
multiline771.1 ms3,494 ms2,515 ms8,987 ms

Headline Ratios

Some representative median ratios:

WorkflowDatasetResult
Load500K cleancsv-parser 1.56x faster
Load+save500K quotedcsv-parser 2.17x faster
Load5M multilinecsv-parser 4.53x faster
Load+save5M cleancsv-parser 3.45x faster
Load+save5M quotedcsv-parser 3.58x faster

Notes On Interpretation

  • These are Windows/MSVC results. The relative ordering may shift on different compilers, CPUs, or storage setups.
  • Google Benchmark adds its own harness overhead, so absolute runtimes here are not the same as a minimal hand-timed production loop. Real-world throughput is often somewhat better, especially for the shortest benchmarks.
  • The thread-count comparisons are Google Benchmark tests too. They are useful for relative comparisons, but a dedicated application loop will usually give a cleaner view of peak throughput.
  • Some row-count benchmarks showed noisy count-only means on the 5M datasets, so the tables above use median real time instead of means.
  • The multiline profile matters. Many CSV libraries look great until quoted line breaks appear.
  • "Faster parser" and "faster ETL tool" are not the same claim. This directory intentionally measures both.

Result Files

Raw JSON outputs for the current benchmark runs live under:

benchmarks/results/

The repository tracks the benchmark JSON files. The generated CSV inputs are kept out of git because they are large and reproducible.

Each profile directory may contain:

  • benchmark_input.csv: the exact generated input used for the run, ignored by git
  • csv_parser_read_bench.json
  • csv_parser_multi_pass_bench.json
  • csv_parser_fast_cpp_read_bench.json where applicable; includes the side-by-side csv-parser, fast-cpp-csv-parser, and Glaze read comparison when those dependencies are available
  • fast_cpp_csv_parser_read_bench.json where applicable
  • fast_cpp_csv_parser_multi_pass_bench.json where applicable
  • glaze_csv_read_bench.json where applicable
  • glaze_csv_multi_pass_bench.json where applicable
  • dataframe_rapidcsv_roundtrip_bench.json