Performance

1. UTF-8 throughout. Files are UTF-8, so the reader scans bytes, not chars: no transcoding pass, half the memory traffic of a UTF-16 parser, and numbers parse straight from UTF-8. Strings are created only when asked for, with an ASCII fast path that widens straight into the new string.
2. 64-byte blocks, 64-bit masks. Each block yields bit masks of separators, quotes, CR and LF (two AVX2 loads, or one AVX-512 load).
3. Branch-free quotes. A carry-less multiply of the quote mask (prefix XOR) marks every byte inside quotes, which removes quoted separators and line breaks without per-character state. For well-formed data that rule is exactly RFC 4180. A quote that opens anywhere but at the start of a field (the one case where the parity rule and RFC 4180 disagree) is detected with a few mask operations, and only that block goes through an exact scalar state machine, which treats the quote as text.
4. Positions in bulk. Terminator positions are written in groups of eight with tzcnt/blsr and no per-field branches. The index stores position + 1 with spare high bits that mark "this field needs unquoting" (computed for all fields at once with an add-carry trick) and "this record ends in CRLF". Field access and record iteration therefore never touch the data bytes, so a plain field is two integer loads and a mask. A quoted field of up to 64 bytes is checked with one 64-byte vector comparison (no loop, no length-dependent branch) and returned in place without its quotes; only fields with escaped quotes are copied.
5. No per-row restarts. Unlike parsers that restart their vector loop at each record start, the scan runs continuously over 16 KiB chunks; records are cut from the index afterwards.
6. Exact, fast number parsing. Integers parse straight from UTF-8. Floats use a port of fast_float (Clinger's fast path, then Eisel-Lemire with a 128-bit power-of-five table, 8 digits at a time with SWAR): bit-identical to double.Parse/float.Parse (checked on the shortest and 9-digit strings of all 2^32 floats and on 200 million random doubles and long decimal strings), 3.4x (float) to 4.5x (double) faster on typical values, and float is rounded once, never parsed as double and cast. Anything unusual (thousands separators, other cultures, >19 digits on a rounding boundary) falls back to the BCL.
7. Strings on demand, optionally pooled per column. Strings are only created when asked for, widening ASCII straight into the new string. With PoolStrings, repeated values (up to 128 bytes) in a column share one instance, which cuts allocations and GC work when many records are kept in memory. A lookup costs about as much as a plain allocation: the first and last 16 bytes of the field, loaded with masks instead of length-dependent branches, are an exact key up to 32 bytes; the slot that matched last is checked before hashing, since neighbouring records often repeat a value; and a column of (nearly) unique values switches pooling off, after 512 values when nearly every record brought a new one, or when its table fills up while most lookups still miss. Pooling is off by default: for strings that are used and dropped, allocating them is cheaper.
8. A writer that formats in place. Every field goes straight into one UTF-8 buffer. Short strings are narrowed from UTF-16 with vector instructions, and the same pass detects the characters that need quoting. Quoting expands the field in place, from the back. Numbers skip the check, since invariant number output cannot contain the usual separators. float and double use a port of Dragonbox (shortest round-trip digits). Its output is byte-identical to double.TryFormat / float.TryFormat (checked on all 2^32 floats and a billion doubles) and about 3.5x faster on typical values.

Correctness is checked by fuzzing the reader against an independent character-by-character reference parser for every vector width (512/256/128/scalar only), every input source (memory, chunked streams, strings, text readers, async) and tiny buffer sizes, plus writer → reader round trips.