diff --git a/.gitignore b/.gitignore
index 83458ab2057b..dc53bf2c0d82 100644
--- a/.gitignore
+++ b/.gitignore
@@ -94,3 +94,6 @@ rat.txt
 
 # for ODBC DLL
 *.rc
+
+# Local out-of-tree benchmark build dir
+cpp/build-bench/
diff --git a/ab_compare.sh b/ab_compare.sh
new file mode 100755
index 000000000000..71c1bbd19e9a
--- /dev/null
+++ b/ab_compare.sh
@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+#
+# A/B comparison protocol for pfor_comparison_benchmark.
+#
+# WHY THIS EXISTS
+#   This benchmark has two deterministic confounds, both larger than most
+#   effects being measured. Neither is noise; neither shrinks with more
+#   repetitions. See INTEL_RESULTS.md section 10.
+#
+#   (1) ARROW_USER_SIMD_LEVEL caps Arrow's runtime dispatch (bpacking.cc:29-45).
+#       It reaches BM_PforDecode only -- the FastLanes kernel has no dispatch.
+#       Capping to AVX2 makes Arrow's sequential decoder 3.21x FASTER than
+#       leaving it uncapped on Granite Rapids, because the AVX-512 family takes
+#       a second pass for the frame bias where the xsimd kernels fold it in.
+#       unset == MAX == AVX512, so the DEFAULT selects the slow path.
+#
+#   (2) The interleaved arm reads either ~36 or ~48 GiB/s (1.33x) at identical
+#       binary, cap, filter and reps. It is stable to 1.00-1.03x across
+#       consecutive processes but flips between batches minutes apart, and it
+#       also moves with how many columns the filter admits (more columns ->
+#       more corpora allocated before the hot buffer). fl_order is immune.
+#
+# THE PROTOCOL
+#   Run every variant ALTERNATING inside one batch, several processes each, with
+#   the cap pinned. Ratios are then taken within a batch, where confound (2) is
+#   constant. Report the cross-process spread, because the within-process stddev
+#   is 0.2-1% here and hides both confounds completely.
+#
+#   The arms come from bench_arms.sh, which also states which of them may be
+#   divided by which. This script used to name the production decoder against an
+#   exception-free standalone one and call the ratio a layout result.
+#
+# USAGE
+#   ./ab_compare.sh <binA>:<cap> <binB>:<cap> [...]      # binaries under bin/
+#   ROUNDS=3 REPS=3 CORE=2 ./ab_compare.sh bench_O2_256:AVX2 fix_O2_256:AVX2
+#   ARM_SETS='ARMS_LAYOUT ARMS_DEST' ./ab_compare.sh bench_O2_256:AVX2
+#
+set -uo pipefail
+cd "$(dirname "${BASH_SOURCE[0]}")"
+. ./bench_arms.sh
+
+BIN_DIR=${BIN_DIR:-$HOME/Projects/pfor_x86_handoff/width_matrix_v2/bin}
+OUT=${OUT:-/tmp/ab}
+ROUNDS=${ROUNDS:-3}
+REPS=${REPS:-3}
+CORE=${CORE:-2}
+
+# Which arm groups to time. Several in one process is fine and preferred, since
+# arms timed together share the machine state; dividing across groups is not --
+# see bench_arms.sh.
+ARM_SETS=${ARM_SETS:-'ARMS_LAYOUT ARMS_ORDER'}
+SETS=()
+for NAME in $ARM_SETS; do SETS+=("${!NAME}"); done
+FILTER=$(bench_filter "${SETS[@]}")
+
+[ $# -ge 1 ] || { sed -n '2,40p' "$0"; exit 1; }
+
+mkdir -p "$OUT"
+LOAD=$(awk '{print int($1)}' /proc/loadavg)
+if [ "$LOAD" -gt 2 ] && [ "${FORCE:-0}" != 1 ]; then
+  echo "!! loadavg is $LOAD -- too busy. Set FORCE=1 to override."; exit 1
+fi
+
+for i in $(seq 1 "$ROUNDS"); do
+  for SPEC in "$@"; do
+    IFS=: read -r B CAP <<<"$SPEC"
+    [ -x "$BIN_DIR/$B" ] || { echo "-- no binary $BIN_DIR/$B, skipping"; continue; }
+    # Cap pinned per variant. Stated in the output filename so the analysis
+    # cannot silently mix caps -- that is confound (1).
+    ARROW_USER_SIMD_LEVEL="${CAP:-MAX}" taskset -c "$CORE" "$BIN_DIR/$B" \
+      --benchmark_filter="$FILTER" \
+      --benchmark_repetitions="$REPS" \
+      --benchmark_report_aggregates_only=true \
+      --benchmark_out="$OUT/${B}__${CAP:-MAX}__$i.json" \
+      --benchmark_out_format=json >/dev/null 2>&1 \
+      && echo "  $B cap=${CAP:-MAX} round $i" \
+      || echo "  !! $B cap=${CAP:-MAX} round $i FAILED"
+  done
+done
+echo
+echo "analyze with: python3 ~/Projects/pfor_x86_handoff/ab_analyze.py $OUT"
diff --git a/bench_arms.sh b/bench_arms.sh
new file mode 100644
index 000000000000..13680b457812
--- /dev/null
+++ b/bench_arms.sh
@@ -0,0 +1,69 @@
+# Shared arm sets and column set for pfor_comparison_benchmark drivers.
+# Sourced, not executed:  . "$(dirname "$0")/bench_arms.sh"
+#
+# WHY THIS FILE EXISTS
+#   Four drivers each carried their own copy of the column list and the arm
+#   regex, and all four copies named the same wrong pair: BM_PforDecode (the
+#   production decoder, which patches exceptions) against BM_InterleavedPforDecode
+#   and BM_InterleavedPforFlOrderDecode (a standalone path with no exception
+#   handling at all). A ratio between those is not a layout result -- the
+#   interleaved side is doing less work. The correct pair had already landed in
+#   the same benchmark file when those drivers were written.
+#
+#   Keeping the sets here means the rule below is stated once and cannot drift
+#   between drivers.
+#
+# WHICH ARMS MAY BE COMPARED WITH WHICH
+#   Only within a group. Every arm in a group runs the same code with the same
+#   exception handling and the same destination policy, so the named variable is
+#   the only difference.
+#
+#   ARMS_LAYOUT  sequential vs interleaved container, both through the
+#                production encoder and decoder with delta declined on both
+#                sides. This is the pair a layout verdict is read from.
+#
+#   ARMS_ORDER   file order vs the paper's lane assignment inside the
+#                interleaved container. These run arrow/util/fastlanes/
+#                interleaved_pfor.h, which has no exception handling anywhere in
+#                it, so the file-order arm in this group is their only valid
+#                baseline. Never pair one of these against a production arm.
+#                The production format has no lane-assignment mode, which is why
+#                this group exists outside it.
+#
+#   ARMS_DEST    whole-output materialization vs a reused block-sized
+#                destination, at each layout. Answers what the output buffer
+#                costs, not what the layout costs.
+#
+#                ARMS_DEST arms arrive with the output-buffer-reuse change and
+#                are absent from a tree without it; a filter naming them then
+#                matches nothing, which google-benchmark reports as no
+#                benchmarks to run.
+#
+#   ARMS_SHIPPED the shipping default, planner free to difference a vector. Not
+#                a layout arm: on a sorted or correlated column it deltas, and
+#                the decode then also pays a serial prefix sum.
+#
+# COLUMN SET
+#   Changing it changes the numbers, because the count of columns a filter
+#   admits decides how many corpora are allocated before the timed buffer. Hold
+#   it fixed across anything meant to be compared.
+
+COLS=${COLS:-'TpcdsSoldDateSk|TpcdsStoreSk|TpcdsItemSk|TpcdsQuantity|EventDate|ClientIP|CounterID|SortedKeys|MonotoneRowId|RandomWalk'}
+
+ARMS_LAYOUT='BM_(PforPlainSeqDecode|PforPlainInterleavedDecode)'
+ARMS_ORDER='BM_(InterleavedPforDecode|InterleavedPforFlOrderRawDecode|InterleavedPforFlOrderDecode)'
+ARMS_DEST='BM_Pfor(Whole|Reuse)(Seq|Interleaved)Decode'
+ARMS_SHIPPED='BM_Pfor(64)?Decode'
+
+# Build a google-benchmark filter from one or more arm sets.
+#   FILTER=$(bench_filter "$ARMS_LAYOUT" "$ARMS_ORDER")
+# Groups are unioned so one process can time several of them -- that is fine and
+# is in fact preferred, since arms timed in one process share the machine state.
+# What is not fine is dividing a number from one group by a number from another.
+bench_filter() {
+  local joined="" a
+  for a in "$@"; do
+    joined="${joined:+$joined|}${a}"
+  done
+  printf '(%s)/(%s)/' "$joined" "$COLS"
+}
diff --git a/build_transpose_ab.sh b/build_transpose_ab.sh
new file mode 100755
index 000000000000..8ad3d05573b8
--- /dev/null
+++ b/build_transpose_ab.sh
@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+#
+# Build the AVX2 Transpose32x32 A/B points.
+#
+# Treatment: transposed_delta.h gained Transpose32x32Avx2 (sixteen in-register
+# 8x8 transposes) behind #if defined(__AVX2__). Before this, x86 fell through to
+# Transpose32x32Scalar -- 1024 four-byte loads at a 128-byte stride plus 1024
+# scalar stores per block, because only NEON had a hand-written path. Isolated,
+# the permutation goes 28.67 -> 73.56 GiB/s (2.57x).
+#
+# Only the kFlOrder arm calls the transpose, so BM_InterleavedPforDecode (file
+# order) and BM_PforDecode are controls this change cannot reach. If either
+# moves by more than the cross-process spread, the comparison is contaminated --
+# see INTEL_RESULTS.md section 10.
+#
+# Correctness is not left to inspection: pfor_comparison_benchmark.cc
+# round-trips every column through encode+decode and ARROW_CHECKs the result
+# before timing starts, for both orders. A wrong transpose aborts the binary.
+# Transpose32x32 is also its own inverse on a square grid, so encode and decode
+# share the path and a broken permutation cannot cancel itself out.
+#
+# BUILD ONLY. Time with ab_compare.sh.
+set -uo pipefail
+cd "$(dirname "${BASH_SOURCE[0]}")"
+export PATH="$HOME/.local/bin:$PATH"   # cmake must be <4
+
+BUILD=build-x86-sweep
+OUT="$HOME/Projects/pfor_x86_handoff/width_matrix_v2"
+mkdir -p "$OUT/bin"
+
+# Matched to the existing fix_* binaries so the only difference is the transpose.
+POINTS=(
+  "tr_O3_256:AVX2:-O3:256"
+  "tr_O2_256:AVX2:-O2:256"
+)
+
+for P in "${POINTS[@]}"; do
+  IFS=: read -r NAME LEVEL OPT PVW <<<"$P"
+  echo "== $NAME : ARROW_SIMD_LEVEL=$LEVEL $OPT -mprefer-vector-width=$PVW"
+  # Explicit every time: CMAKE_CXX_FLAGS_RELEASE is a CACHE variable and would
+  # otherwise inherit the previous point's value.
+  if ! cmake -S cpp -B "$BUILD" -GNinja \
+      -DCMAKE_BUILD_TYPE=Release \
+      -DARROW_SIMD_LEVEL="$LEVEL" \
+      -DCMAKE_CXX_FLAGS_RELEASE="$OPT -DNDEBUG -mprefer-vector-width=$PVW" \
+      -DCMAKE_C_FLAGS_RELEASE="$OPT -DNDEBUG -mprefer-vector-width=$PVW" \
+      -DARROW_PARQUET=ON -DARROW_BUILD_BENCHMARKS=ON \
+      -DARROW_WITH_ZSTD=ON -DARROW_WITH_LZ4=ON \
+      -DARROW_BUILD_TESTS=OFF > "$OUT/configure_$NAME.log" 2>&1; then
+    echo "!! configure FAILED -- $OUT/configure_$NAME.log"; continue
+  fi
+  if ! cmake --build "$BUILD" --target parquet-pfor-comparison-benchmark -j 6 \
+      > "$OUT/build_$NAME.log" 2>&1; then
+    echo "!! build FAILED -- tail:"; tail -30 "$OUT/build_$NAME.log"; continue
+  fi
+  cp "$BUILD/release/parquet-pfor-comparison-benchmark" "$OUT/bin/bench_$NAME"
+  echo "   -> $OUT/bin/bench_$NAME"
+  # Prove the AVX2 transpose is actually in the kFlOrder kernel.
+  objdump -d --demangle "$OUT/bin/bench_$NAME" 2>/dev/null | awk '
+    /^[0-9a-f]+ <.*InterleavedPforDecode<.*>:$/ {
+      inside=1
+      name=($0 ~ /InterleavedPforOrder\)1/) ? "kFlOrder(1)" : "kFileOrder(0)"
+      n=0; y=0; z=0; perm=0; next
+    }
+    /^[0-9a-f]+ </ { if (inside) printf "      %-14s insns=%-7d ymm=%-6d zmm=%-6d vperm2x128=%d\n", name,n,y,z,perm; inside=0; next }
+    inside { nf=split($0,p,"\t"); if (nf<3) next; n++
+             y+=gsub(/%ymm[0-9]+/,"&",p[3]); z+=gsub(/%zmm[0-9]+/,"&",p[3])
+             if (p[3] ~ /vperm2[fi]128/) perm++ }
+    END { if (inside) printf "      %-14s insns=%-7d ymm=%-6d zmm=%-6d vperm2x128=%d\n", name,n,y,z,perm }'
+done
+echo "TRANSPOSE_BUILDS_DONE"
diff --git a/build_width_matrix.sh b/build_width_matrix.sh
new file mode 100755
index 000000000000..8cab44981370
--- /dev/null
+++ b/build_width_matrix.sh
@@ -0,0 +1,177 @@
+#!/usr/bin/env bash
+#
+# Register-width x optimizer matrix.
+#
+# WHAT THIS FIXES
+#   An earlier version of this sweep, now deleted, assumed
+#   CMAKE_BUILD_TYPE=Release means -O2, which is true for upstream
+#   Arrow but NOT on this branch. cpp/cmake_modules/SetupCxxFlags.cmake:637
+#   carries a local override:
+#       "keep -O3 from CMake's default Release flags for the pfor benchmark"
+#   so Release keeps CMake's default -O3 -DNDEBUG. It passed an explicit -O3
+#   only for its "-O3" points and let the "-O2" points default -- which also
+#   came out -O3. Proof, from its own artifacts:
+#       verify_O2_AVX2.txt   sha256 22ae7451045ce1f5...
+#       verify_O3_AVX2.txt   sha256 22ae7451045ce1f5...   <- same binary
+#       verify_O2_AVX512.txt sha256 440bf51c5ec1f62c...
+#       verify_O3_AVX512.txt sha256 440bf51c5ec1f62c...   <- same binary
+#   and configure_O2_AVX2.log: "CMAKE_CXX_FLAGS_RELEASE: -O3 -DNDEBUG
+#   -ftree-vectorize". So its "-O3 is a non-factor (1.01x/0.97x)" was a binary
+#   compared against itself -- it measures the shared-VM noise floor (+-3%),
+#   not the optimizer. Only its 512-bit pair differed for real.
+#
+#   Consequence for the headline: that width scaling of 30.32/35.41/38.22 mixed
+#   levels -- 128 and 256 were -O3 builds, 512 was the one genuine -O2 build.
+#   Not a clean axis. This script fixes it by ALWAYS setting the optimizer
+#   explicitly, never inheriting it.
+#
+# ALSO FIXED
+#   - CMAKE_CXX_FLAGS_RELEASE is a CACHE variable, so a value set at one point
+#     persists into the next configure of the same build dir. v2 passes it every
+#     time, so no point can inherit a neighbour's flags.
+#   - -mprefer-vector-width is set explicitly at every point. Arrow's
+#     ARROW_SIMD_LEVEL=AVX512 uses -march=skylake-avx512, and GCC defaults that
+#     target to -mprefer-vector-width=256, so a nominally-512 build emits zero
+#     zmm unless asked. The earlier sweep hit exactly this (ymm 221908, zmm 0),
+#     and a separate driver existed only to add the flag back. That driver is
+#     gone: the flag is set at every point here.
+#   - Width is verified INSIDE the kernel function, not across the whole binary.
+#     Whole-binary counts are dominated by Arrow's own explicit-vector code and
+#     say nothing about what the autovectorizer did to the FastLanes kernel.
+#   - Each binary is preserved under $OUT/bin/ so timing can be replayed later
+#     without rebuilding, and so builds and timing runs never overlap.
+#
+# NO 512-BIT LEG
+#   Arrow's bit-unpack dispatch is capped at 256 bits, because the AVX-512
+#   kernels assemble their input register from scalar loads and measure 0.67x of
+#   the scalar kernel. Asking for the 512-bit level therefore hands the
+#   sequential arm the 256-bit kernel back while the interleaved kernel really
+#   does widen, so such a point compares two widths on one side and one on the
+#   other. It comes back when a 512-bit unpack kernel exists that beats the
+#   256-bit one.
+#
+# BUILD ONLY. Time the binaries with ab_compare.sh, which alternates the
+# variants inside one batch -- these numbers come from a shared virtualized
+# container and a point timed minutes after its neighbour is not comparable to
+# it.
+#
+set -uo pipefail
+cd "$(dirname "${BASH_SOURCE[0]}")"
+export PATH="$HOME/.local/bin:$PATH"   # cmake must be <4; 3.31.10 lives here
+
+BUILD=build-x86-sweep                  # reused so bundled deps are not rebuilt
+# Output directory keeps its name so the binaries and verification logs already
+# on the x86 box are not orphaned.
+OUT="$HOME/Projects/pfor_x86_handoff/width_matrix_v2"
+mkdir -p "$OUT/bin"
+
+# The autovectorized FastLanes kernel under test. Order 0 = plain interleaved,
+# Order 1 = the paper's lane assignment. Order 0 is the one the width claim is
+# about. This kernel has no exception handling, so its timings belong to the
+# order group in bench_arms.sh and never against a production arm.
+KERNEL='arrow::util::fastlanes::InterleavedPforDecode<(arrow::util::fastlanes::InterleavedPforOrder)0>'
+
+# name | ARROW_SIMD_LEVEL | optimizer | prefer-vector-width
+POINTS=(
+  "O2_128:SSE4_2:-O2:128"
+  "O2_256:AVX2:-O2:256"
+  "O3_128:SSE4_2:-O3:128"
+  "O3_256:AVX2:-O3:256"
+)
+
+for P in "${POINTS[@]}"; do
+  IFS=: read -r NAME LEVEL OPT PVW <<<"$P"
+  echo "=================================================================="
+  echo "== $NAME : ARROW_SIMD_LEVEL=$LEVEL  $OPT  -mprefer-vector-width=$PVW"
+  echo "=================================================================="
+
+  # Explicit every time. Nothing inherited, nothing assumed about Release.
+  if ! cmake -S cpp -B "$BUILD" -GNinja \
+      -DCMAKE_BUILD_TYPE=Release \
+      -DARROW_SIMD_LEVEL="$LEVEL" \
+      -DCMAKE_CXX_FLAGS_RELEASE="$OPT -DNDEBUG -mprefer-vector-width=$PVW" \
+      -DCMAKE_C_FLAGS_RELEASE="$OPT -DNDEBUG -mprefer-vector-width=$PVW" \
+      -DARROW_PARQUET=ON -DARROW_BUILD_BENCHMARKS=ON \
+      -DARROW_WITH_ZSTD=ON -DARROW_WITH_LZ4=ON \
+      -DARROW_BUILD_TESTS=OFF > "$OUT/configure_$NAME.log" 2>&1; then
+    echo "!! configure FAILED -- $OUT/configure_$NAME.log"; continue
+  fi
+  # Record the flags cmake actually resolved, so the log proves the level.
+  grep -E "CMAKE_CXX_FLAGS(_RELEASE)?:" "$OUT/configure_$NAME.log" | sed 's/^/   /'
+
+  if ! cmake --build "$BUILD" --target parquet-pfor-comparison-benchmark -j 6 \
+      > "$OUT/build_$NAME.log" 2>&1; then
+    echo "!! build FAILED -- $OUT/build_$NAME.log"; continue
+  fi
+
+  SRC="$BUILD/release/parquet-pfor-comparison-benchmark"
+  BIN="$OUT/bin/bench_$NAME"
+  cp "$SRC" "$BIN"
+
+  # ---- verify the width the autovectorizer gave THIS kernel ----------------
+  # Disassemble only the kernel's address range: from its symbol to the next.
+  ADDR=$(nm -C "$BIN" | grep -F "$KERNEL" | awk '{print $1}' | head -1)
+  {
+    echo "point=$NAME level=$LEVEL opt=$OPT prefer=$PVW"
+    echo "sha256: $(sha256sum "$BIN" | cut -d' ' -f1)"
+    echo "kernel: $KERNEL"
+    echo "kernel addr: 0x$ADDR"
+    if [ -n "$ADDR" ]; then
+      # Boundaries come from objdump's OWN '<addr> <symbol>:' labels, not from
+      # sorting nm addresses. The nm approach silently produced an empty range
+      # for O2_256 -- kernel_O2_256.asm came out 0 bytes and the point then
+      # reported "zmm: 0 ymm: 0", which reads as a failed vectorization rather
+      # than a failed extraction. nm lists symbols from the symbol table in an
+      # order that need not bracket the function body (aliases, local symbols
+      # and ifunc resolvers all land in between), so "next address after this
+      # one" is not the function's end. objdump cannot disagree with itself.
+      objdump -dC --no-show-raw-insn "$BIN" 2>/dev/null \
+        | awk -v s="$KERNEL" '
+            /^[0-9a-f]+ </ { inside = index($0, s) > 0 }
+            inside' > "$OUT/kernel_$NAME.asm"
+      echo "kernel insns: $(grep -cE '^\s+[0-9a-f]+:' "$OUT/kernel_$NAME.asm")"
+      echo "IN-KERNEL vector register usage:"
+      for R in xmm ymm zmm; do
+        echo "    $R: $(grep -c "%$R" "$OUT/kernel_$NAME.asm")"
+      done
+      echo "IN-KERNEL notable ops:"
+      # v?-prefixed: a 128-bit SSE build emits non-VEX psrld/movdqa, so
+      # VEX-only patterns reported zero shifts and zero stack traffic for every
+      # 128-bit point -- which made the narrow builds look spill-free when
+      # O3_128 in fact had the most stack traffic in the matrix.
+      for OP in 'v?psrld' 'v?pslld' 'vpsrlvd' 'vpsllvd' 'v?pand' 'v?por' \
+                'v?movdqu' 'v?movdqa' 'vpgatherdd' 'vpermd' 'v?pshufb' \
+                'vpbroadcastd' 'vzeroupper'; do
+        C=$(grep -cE "^\s+[0-9a-f]+:\s+$OP" "$OUT/kernel_$NAME.asm")
+        [ "$C" -gt 0 ] && echo "    $OP: $C"
+      done
+      # Vector moves with a stack-relative operand. Reported as traffic, not
+      # spills: a genuine stack scratch buffer matches this too, which is
+      # exactly what the pre-fix kFileOrder path was (a 4 KiB grid, ~1984
+      # write-only stores with zero matching reloads).
+      echo "    stack vector traffic: $(grep -cE '^\s+[0-9a-f]+:\s+v?mov(dqu|dqa|ups|aps).*\((%rsp|%rbp)' "$OUT/kernel_$NAME.asm")"
+    else
+      echo "!! kernel symbol not found -- cannot verify width"
+    fi
+  } > "$OUT/verify_$NAME.txt" 2>&1
+  cat "$OUT/verify_$NAME.txt"
+
+  # A width that did not materialize is reported, never silently averaged in.
+  case "$PVW" in
+    256) grep -qE '^    ymm: [1-9]' "$OUT/verify_$NAME.txt" \
+           || echo "!! WARNING $NAME: no ymm IN KERNEL -- this is NOT a 256-bit point" ;;
+  esac
+  echo
+done
+
+echo "=== builds complete. binaries in $OUT/bin/ ==="
+sha256sum "$OUT"/bin/* 2>/dev/null
+echo
+echo "Distinct binaries (if two points share a sha256, they are the SAME build"
+echo "and any difference between their timings is noise):"
+sha256sum "$OUT"/bin/* 2>/dev/null | awk '{print $1}' | sort -u | wc -l
+echo
+echo "Now time them, when the box is quiet:"
+echo "  BIN_DIR=$OUT/bin ./ab_compare.sh \\"
+echo "    bench_O2_128:SSE4_2 bench_O2_256:AVX2 \\"
+echo "    bench_O3_128:SSE4_2 bench_O3_256:AVX2"
diff --git a/cpp/cmake_modules/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake
index 21341167fe99..8887a1ed9294 100644
--- a/cpp/cmake_modules/SetupCxxFlags.cmake
+++ b/cpp/cmake_modules/SetupCxxFlags.cmake
@@ -633,21 +633,12 @@ endif()
 
 if(NOT MSVC)
   set(C_RELEASE_FLAGS "")
-  if(CMAKE_C_FLAGS_RELEASE MATCHES "-O3")
-    string(APPEND C_RELEASE_FLAGS " -O2")
-  endif()
+  # Local override: keep -O3 from CMake's default Release flags for the
+  # pfor benchmark — the bench is sensitive to inlining/unrolling that
+  # -O3 enables. Upstream Arrow downgrades to -O2 here; we skip that.
   set(CXX_RELEASE_FLAGS "")
-  if(CMAKE_CXX_FLAGS_RELEASE MATCHES "-O3")
-    string(APPEND CXX_RELEASE_FLAGS " -O2")
-  endif()
   set(C_RELWITHDEBINFO_FLAGS "")
-  if(CMAKE_C_FLAGS_RELWITHDEBINFO MATCHES "-O3")
-    string(APPEND C_RELWITHDEBINFO_FLAGS " -O2")
-  endif()
   set(CXX_RELWITHDEBINFO_FLAGS "")
-  if(CMAKE_CXX_FLAGS_RELWITHDEBINFO MATCHES "-O3")
-    string(APPEND CXX_RELWITHDEBINFO_FLAGS " -O2")
-  endif()
   if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     string(APPEND C_RELEASE_FLAGS " -ftree-vectorize")
     string(APPEND CXX_RELEASE_FLAGS " -ftree-vectorize")
diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 8750598f6c3b..0a239e893258 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -566,6 +566,8 @@ set(ARROW_UTIL_SRCS
     util/math_internal.cc
     util/memory.cc
     util/mutex.cc
+    util/pfor/pfor.cc
+    util/pfor/pfor_wrapper.cc
     util/ree_util.cc
     util/secure_string.cc
     util/string.cc
diff --git a/cpp/src/arrow/meson.build b/cpp/src/arrow/meson.build
index 831bc1218083..ebba2cd22fbb 100644
--- a/cpp/src/arrow/meson.build
+++ b/cpp/src/arrow/meson.build
@@ -204,6 +204,8 @@ arrow_util_srcs = [
     'util/math_internal.cc',
     'util/memory.cc',
     'util/mutex.cc',
+    'util/pfor/pfor.cc',
+    'util/pfor/pfor_wrapper.cc',
     'util/ree_util.cc',
     'util/secure_string.cc',
     'util/string.cc',
diff --git a/cpp/src/arrow/util/CMakeLists.txt b/cpp/src/arrow/util/CMakeLists.txt
index 628e9a4d1c7e..9be9dbfa7188 100644
--- a/cpp/src/arrow/util/CMakeLists.txt
+++ b/cpp/src/arrow/util/CMakeLists.txt
@@ -118,6 +118,10 @@ add_arrow_test(threading-utility-test
                test_common.cc
                thread_pool_test.cc)
 
+add_arrow_test(pfor-test SOURCES pfor/pfor_test.cc)
+
+add_arrow_benchmark(pfor/pfor_benchmark)
+
 add_arrow_benchmark(bit_block_counter_benchmark)
 add_arrow_benchmark(bit_util_benchmark)
 add_arrow_benchmark(bitmap_reader_benchmark)
diff --git a/cpp/src/arrow/util/bpacking.cc b/cpp/src/arrow/util/bpacking.cc
index 1bf81df4f28f..cea16fe55089 100644
--- a/cpp/src/arrow/util/bpacking.cc
+++ b/cpp/src/arrow/util/bpacking.cc
@@ -38,7 +38,39 @@ struct UnpackDynamicFunction {
         ARROW_DISPATCH_TARGET_SVE256(&bpacking::unpack_sve256<Uint>)  //
         ARROW_DISPATCH_TARGET_SSE4_2(&bpacking::unpack_sse4_2<Uint>)  //
         ARROW_DISPATCH_TARGET_AVX2(&bpacking::unpack_avx2<Uint>)      //
-        ARROW_DISPATCH_TARGET_AVX512(&bpacking::unpack_avx512<Uint>)  //
+        // Cap the bit-unpack dispatch at 256 bits. The 512-bit target is the one
+        // still driven by the legacy generated kernels in
+        // bpacking_simd512_generated_internal.h, which build their SIMD input
+        // register from an initializer list of scalar loads (one vmovd + one
+        // vpinsrd per element) and are not force-inlined, so each step is an
+        // out-of-line call. Measured on Granite Rapids over 102400 values, that
+        // makes it 6.26x slower than the AVX2 target (geomean widths 1..31: 6.54
+        // vs 40.97 GiB/s) and 0.67x of the *scalar* kernel. Since
+        // ARROW_RUNTIME_SIMD_LEVEL defaults to MAX, every AVX-512 machine was
+        // preferring it. Re-enable once the 512-bit kernels issue real vector
+        // loads -- naively pointing this TU at the Kernel<> machinery used by
+        // bpacking_simd_{128,256}.cc is NOT the fix: it measures 1.17 GiB/s,
+        // 5.6x worse again, because most widths land on is_oversized() ->
+        // NoOpKernel and fall through to the naive path.
+        // ARROW_DISPATCH_TARGET_AVX512(&bpacking::unpack_avx512<Uint>)  //
+    };
+  }
+};
+
+template <typename Uint>
+struct UnpackBiasDynamicFunction {
+  using FunctionType = decltype(&bpacking::unpack_bias_scalar<Uint>);
+
+  static constexpr auto targets() {
+    return std::array{
+        ARROW_DISPATCH_TARGET_NONE(&bpacking::unpack_bias_scalar<Uint>)    //
+        ARROW_DISPATCH_TARGET_NEON(&bpacking::unpack_bias_neon<Uint>)      //
+        ARROW_DISPATCH_TARGET_SVE128(&bpacking::unpack_bias_sve128<Uint>)  //
+        ARROW_DISPATCH_TARGET_SVE256(&bpacking::unpack_bias_sve256<Uint>)  //
+        ARROW_DISPATCH_TARGET_SSE4_2(&bpacking::unpack_bias_sse4_2<Uint>)  //
+        ARROW_DISPATCH_TARGET_AVX2(&bpacking::unpack_bias_avx2<Uint>)      //
+        // Capped at 256 bits for the reason given in UnpackDynamicFunction above.
+        // ARROW_DISPATCH_TARGET_AVX512(&bpacking::unpack_bias_avx512<Uint>)  //
     };
   }
 };
@@ -57,4 +89,19 @@ template void unpack<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&);
 template void unpack<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void unpack<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void unpack_bias(const uint8_t* in, Uint* out, const UnpackOptions& opts, Uint bias) {
+  static const DynamicDispatch<UnpackBiasDynamicFunction<Uint>> dispatch;
+  return dispatch(in, out, opts, bias);
+}
+
+template void unpack_bias<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&,
+                                   uint8_t);
+template void unpack_bias<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&,
+                                    uint16_t);
+template void unpack_bias<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&,
+                                    uint32_t);
+template void unpack_bias<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&,
+                                    uint64_t);
+
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_dispatch_internal.h b/cpp/src/arrow/util/bpacking_dispatch_internal.h
index 6ea6adee1800..a2f344009233 100644
--- a/cpp/src/arrow/util/bpacking_dispatch_internal.h
+++ b/cpp/src/arrow/util/bpacking_dispatch_internal.h
@@ -31,23 +31,54 @@
 namespace arrow::internal::bpacking {
 
 /// Unpack a zero bit packed array.
-template <typename Uint>
-ARROW_FORCE_INLINE void unpack_null(const uint8_t* in, Uint* out, int batch_size) {
-  std::memset(out, 0, batch_size * sizeof(Uint));
+template <bool kHasBias = false, typename Uint>
+ARROW_FORCE_INLINE void unpack_null(const uint8_t* in, Uint* out, int batch_size,
+                                    Uint bias = Uint{}) {
+  if constexpr (kHasBias) {
+    // Every unpacked value is zero, so every output value is the bias.
+    std::fill(out, out + batch_size, bias);
+  } else {
+    std::memset(out, 0, batch_size * sizeof(Uint));
+  }
 }
 
 /// Unpack a packed array where packed and unpacked values have exactly the same number of
 /// bits.
-template <typename Uint>
-ARROW_FORCE_INLINE void unpack_full(const uint8_t* in, Uint* out, int batch_size) {
+template <bool kHasBias = false, typename Uint>
+ARROW_FORCE_INLINE void unpack_full(const uint8_t* in, Uint* out, int batch_size,
+                                    Uint bias = Uint{}) {
   if constexpr (ARROW_LITTLE_ENDIAN == 1) {
-    std::memcpy(out, in, batch_size * sizeof(Uint));
+    if constexpr (kHasBias) {
+      // Two things are needed for this loop to reach memcpy speed, and it is
+      // 10.8x slower than the memcpy below without them -- far worse than the
+      // second add pass the bias exists to remove.
+      //   1. A constant-size memcpy for the load, not SafeLoadAs: SafeLoadAs
+      //      builds an AlignedStorage per element and the vectorizer refuses it,
+      //      while a fixed-size memcpy is just an unaligned load.
+      //   2. A restrict qualifier: `in` is a uint8_t*, so it may alias
+      //      anything, including `out`. Without restating that they are
+      //      distinct the compiler has to assume overlap and emits a scalar
+      //      loop.
+      const uint8_t* ARROW_RESTRICT src = in;
+      Uint* ARROW_RESTRICT dst = out;
+      for (int k = 0; k < batch_size; k += 1) {
+        Uint val;
+        std::memcpy(&val, src + (k * sizeof(Uint)), sizeof(Uint));
+        dst[k] = static_cast<Uint>(val + bias);
+      }
+    } else {
+      std::memcpy(out, in, batch_size * sizeof(Uint));
+    }
   } else {
     using bit_util::FromLittleEndian;
     using util::SafeLoadAs;
 
     for (int k = 0; k < batch_size; k += 1) {
-      out[k] = FromLittleEndian(SafeLoadAs<Uint>(in + (k * sizeof(Uint))));
+      Uint val = FromLittleEndian(SafeLoadAs<Uint>(in + (k * sizeof(Uint))));
+      if constexpr (kHasBias) {
+        val = static_cast<Uint>(val + bias);
+      }
+      out[k] = val;
     }
   }
 }
@@ -96,9 +127,9 @@ using SpreadBufferUint = std::conditional_t<
 /// This function works for all input batch sizes but is not the fastest.
 /// In prolog mode, instead of unpacking all required element, the function will
 /// stop if it finds a byte aligned value start.
-template <int kPackedBitWidth, bool kIsProlog, typename Uint>
+template <int kPackedBitWidth, bool kIsProlog, bool kHasBias = false, typename Uint>
 ARROW_FORCE_INLINE int unpack_exact(const uint8_t* in, const uint8_t* in_end, Uint* out,
-                                    int batch_size, int bit_offset) {
+                                    int batch_size, int bit_offset, Uint bias = Uint{}) {
   static_assert(kPackedBitWidth > 0);
 
   // For the epilog we adapt the max spread since better alignment give shorter spreads
@@ -168,6 +199,9 @@ ARROW_FORCE_INLINE int unpack_exact(const uint8_t* in, const uint8_t* in_end, Ui
       }
     }
 
+    if constexpr (kHasBias) {
+      val = static_cast<Uint>(val + bias);
+    }
     *out = val;
     out++;
     start_bit += kPackedBitWidth;
@@ -190,12 +224,12 @@ ARROW_FORCE_INLINE int unpack_exact(const uint8_t* in, const uint8_t* in_end, Ui
 ///                       This is used to safely overread.
 ///                       Negative value to deduce from batch_size.
 template <int kPackedBitWidth, template <typename, int> typename Unpacker,
-          typename UnpackedUInt>
+          bool kHasBias = false, typename UnpackedUInt>
 void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_offset,
-                  int max_read_bytes) {
+                  int max_read_bytes, UnpackedUInt bias = UnpackedUInt{}) {
   if constexpr (kPackedBitWidth == 0) {
     // Easy case to handle, simply setting memory to zero.
-    return unpack_null(in, out, batch_size);
+    return unpack_null<kHasBias>(in, out, batch_size, bias);
   } else {
     // Number of bytes to read according to batch_size.
     const int bytes_batch = static_cast<int>(
@@ -206,8 +240,8 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
     const uint8_t* in_end = in + (max_read_bytes >= 0 ? max_read_bytes : bytes_batch);
 
     // In case of misalignment, we need to run the prolog until aligned.
-    int extracted =
-        unpack_exact<kPackedBitWidth, true>(in, in_end, out, batch_size, bit_offset);
+    int extracted = unpack_exact<kPackedBitWidth, true, kHasBias>(
+        in, in_end, out, batch_size, bit_offset, bias);
     // We either extracted everything or found a alignment
     const int start_bit = extracted * kPackedBitWidth + bit_offset;
     ARROW_DCHECK((extracted == batch_size) || ((start_bit) % 8 == 0));
@@ -218,7 +252,7 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
 
     if constexpr (kPackedBitWidth == 8 * sizeof(UnpackedUInt)) {
       // Only memcpy / static_cast
-      return unpack_full(in, out, batch_size);
+      return unpack_full<kHasBias>(in, out, batch_size, bias);
     } else {
       using UnpackerForWidth = Unpacker<UnpackedUInt, kPackedBitWidth>;
       // Number of values extracted by one iteration of the kernel
@@ -229,9 +263,30 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
 
       if constexpr (kValuesUnpacked > 0) {
         const uint8_t* in_last = in_end - kBytesRead;
+        // Whether this unpacker family folds the bias into its own stores. The
+        // xsimd kernels do; the generated scalar and AVX-512 families do not, so
+        // they get a second pass over the values the kernel just wrote. That
+        // pass is over kValuesUnpacked elements still in L1, not over the whole
+        // output, but it is a second pass all the same and the measured cost of
+        // one is 1.47-2.40x the unpack -- so the fallback is for correctness on
+        // those targets, not a substitute for folding it in.
+        constexpr bool kUnpackerTakesBias =
+            requires(const uint8_t* i, UnpackedUInt* o, UnpackedUInt b) {
+              UnpackerForWidth::unpack(i, o, b);
+            };  // NOLINT(readability/braces)
+
         // Running the optimized kernel for batch extraction
         while ((batch_size >= kValuesUnpacked) && (in <= in_last)) {
-          in = UnpackerForWidth::unpack(in, out);
+          if constexpr (kHasBias && kUnpackerTakesBias) {
+            in = UnpackerForWidth::unpack(in, out, bias);
+          } else {
+            in = UnpackerForWidth::unpack(in, out);
+            if constexpr (kHasBias) {
+              for (int k = 0; k < kValuesUnpacked; ++k) {
+                out[k] = static_cast<UnpackedUInt>(out[k] + bias);
+              }
+            }
+          }
           out += kValuesUnpacked;
           batch_size -= kValuesUnpacked;
         }
@@ -245,406 +300,412 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
       // Running the epilog for the remaining values that don't fit in a kernel
       ARROW_DCHECK_GE(batch_size, 0);
       ARROW_COMPILER_ASSUME(batch_size >= 0);
-      unpack_exact<kPackedBitWidth, false>(in, in_end, out, batch_size,
-                                           /* bit_offset= */ 0);
+      unpack_exact<kPackedBitWidth, false, kHasBias>(in, in_end, out, batch_size,
+                                                     /* bit_offset= */ 0, bias);
     }
   }
 }
 
-template <template <typename, int> typename Unpacker, typename UnpackedUint>
-static void unpack_jump(const uint8_t* in, UnpackedUint* out, const UnpackOptions& opt) {
+template <template <typename, int> typename Unpacker, bool kHasBias = false,
+          typename UnpackedUint>
+static void unpack_jump(const uint8_t* in, UnpackedUint* out, const UnpackOptions& opt,
+                        UnpackedUint bias = UnpackedUint{}) {
+  // A bias on a bool output would have to saturate rather than add, which is not
+  // what any caller means by it.
+  static_assert(!(kHasBias && std::is_same_v<UnpackedUint, bool>),
+                "unpack with a bias is not defined for bool output");
   if constexpr (std::is_same_v<UnpackedUint, bool>) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 1) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 2) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<9, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<10, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<11, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<12, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<13, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<14, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<15, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<16, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 4) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<9, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<10, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<11, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<12, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<13, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<14, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<15, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<16, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 17:
-        return unpack_width<17, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<17, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 18:
-        return unpack_width<18, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<18, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 19:
-        return unpack_width<19, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<19, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 20:
-        return unpack_width<20, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<20, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 21:
-        return unpack_width<21, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<21, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 22:
-        return unpack_width<22, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<22, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 23:
-        return unpack_width<23, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<23, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 24:
-        return unpack_width<24, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<24, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 25:
-        return unpack_width<25, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<25, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 26:
-        return unpack_width<26, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<26, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 27:
-        return unpack_width<27, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<27, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 28:
-        return unpack_width<28, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<28, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 29:
-        return unpack_width<29, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<29, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 30:
-        return unpack_width<30, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<30, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 31:
-        return unpack_width<31, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<31, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 32:
-        return unpack_width<32, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<32, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 8) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<9, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<10, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<11, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<12, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<13, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<14, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<15, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<16, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 17:
-        return unpack_width<17, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<17, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 18:
-        return unpack_width<18, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<18, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 19:
-        return unpack_width<19, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<19, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 20:
-        return unpack_width<20, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<20, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 21:
-        return unpack_width<21, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<21, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 22:
-        return unpack_width<22, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<22, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 23:
-        return unpack_width<23, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<23, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 24:
-        return unpack_width<24, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<24, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 25:
-        return unpack_width<25, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<25, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 26:
-        return unpack_width<26, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<26, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 27:
-        return unpack_width<27, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<27, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 28:
-        return unpack_width<28, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<28, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 29:
-        return unpack_width<29, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<29, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 30:
-        return unpack_width<30, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<30, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 31:
-        return unpack_width<31, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<31, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 32:
-        return unpack_width<32, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<32, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 33:
-        return unpack_width<33, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<33, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 34:
-        return unpack_width<34, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<34, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 35:
-        return unpack_width<35, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<35, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 36:
-        return unpack_width<36, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<36, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 37:
-        return unpack_width<37, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<37, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 38:
-        return unpack_width<38, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<38, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 39:
-        return unpack_width<39, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<39, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 40:
-        return unpack_width<40, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<40, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 41:
-        return unpack_width<41, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<41, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 42:
-        return unpack_width<42, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<42, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 43:
-        return unpack_width<43, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<43, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 44:
-        return unpack_width<44, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<44, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 45:
-        return unpack_width<45, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<45, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 46:
-        return unpack_width<46, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<46, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 47:
-        return unpack_width<47, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<47, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 48:
-        return unpack_width<48, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<48, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 49:
-        return unpack_width<49, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<49, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 50:
-        return unpack_width<50, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<50, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 51:
-        return unpack_width<51, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<51, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 52:
-        return unpack_width<52, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<52, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 53:
-        return unpack_width<53, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<53, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 54:
-        return unpack_width<54, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<54, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 55:
-        return unpack_width<55, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<55, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 56:
-        return unpack_width<56, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<56, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 57:
-        return unpack_width<57, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<57, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 58:
-        return unpack_width<58, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<58, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 59:
-        return unpack_width<59, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<59, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 60:
-        return unpack_width<60, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<60, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 61:
-        return unpack_width<61, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<61, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 62:
-        return unpack_width<62, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<62, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 63:
-        return unpack_width<63, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<63, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 64:
-        return unpack_width<64, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<64, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   }
   ARROW_DCHECK(false) << "Unsupported num_bits " << opt.bit_width;
diff --git a/cpp/src/arrow/util/bpacking_internal.h b/cpp/src/arrow/util/bpacking_internal.h
index 329a1ae959b5..dbdad2082c6b 100644
--- a/cpp/src/arrow/util/bpacking_internal.h
+++ b/cpp/src/arrow/util/bpacking_internal.h
@@ -48,4 +48,29 @@ extern template ARROW_TEMPLATE_EXPORT void unpack<uint32_t>(  //
 extern template ARROW_TEMPLATE_EXPORT void unpack<uint64_t>(  //
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+/// \brief Unpack, adding `bias` to every value.
+///
+/// Equivalent to `unpack()` followed by a loop adding `bias`, but the addition
+/// happens inside the unpacker before its store, so the output is traversed
+/// once instead of twice. Frame-of-reference decoders are the motivating
+/// caller: the separate add pass costs as much as the unpack it follows.
+///
+/// `bias + value` is computed in `Uint`, so it wraps rather than saturating.
+/// Not defined for `bool` output, where an add has no meaning.
+template <typename Uint>
+ARROW_EXPORT void unpack_bias(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                              Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint8_t>(  //
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint16_t>(  //
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint32_t>(  //
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint64_t>(  //
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_scalar.cc b/cpp/src/arrow/util/bpacking_scalar.cc
index 5226ad55cd3e..be3c9ded3462 100644
--- a/cpp/src/arrow/util/bpacking_scalar.cc
+++ b/cpp/src/arrow/util/bpacking_scalar.cc
@@ -33,4 +33,19 @@ template void unpack_scalar<uint16_t>(const uint8_t*, uint16_t*, const UnpackOpt
 template void unpack_scalar<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void unpack_scalar<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void unpack_bias_scalar(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                        Uint bias) {
+  return unpack_jump<ScalarUnpackerForWidth, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void unpack_bias_scalar<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&,
+                                          uint8_t);
+template void unpack_bias_scalar<uint16_t>(const uint8_t*, uint16_t*,
+                                           const UnpackOptions&, uint16_t);
+template void unpack_bias_scalar<uint32_t>(const uint8_t*, uint32_t*,
+                                           const UnpackOptions&, uint32_t);
+template void unpack_bias_scalar<uint64_t>(const uint8_t*, uint64_t*,
+                                           const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_scalar_internal.h b/cpp/src/arrow/util/bpacking_scalar_internal.h
index 2f62174f5f3f..c6a52a82e3b7 100644
--- a/cpp/src/arrow/util/bpacking_scalar_internal.h
+++ b/cpp/src/arrow/util/bpacking_scalar_internal.h
@@ -42,4 +42,20 @@ extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void unpack_bias_scalar(const uint8_t* in, Uint* out,
+                                     const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_simd_128.cc b/cpp/src/arrow/util/bpacking_simd_128.cc
index 1bc756b2aa7d..ee90d22a37f5 100644
--- a/cpp/src/arrow/util/bpacking_simd_128.cc
+++ b/cpp/src/arrow/util/bpacking_simd_128.cc
@@ -17,9 +17,11 @@
 
 #if defined(ARROW_HAVE_NEON)
 #  define UNPACK_PLATFORM unpack_neon
+#  define UNPACK_BIAS_PLATFORM unpack_bias_neon
 #  define KERNEL_PLATFORM KernelNeon
 #elif defined(ARROW_HAVE_SSE4_2)
 #  define UNPACK_PLATFORM unpack_sse4_2
+#  define UNPACK_BIAS_PLATFORM unpack_bias_sse4_2
 #  define KERNEL_PLATFORM KernelSse42
 #endif
 
@@ -45,7 +47,23 @@ template void UNPACK_PLATFORM<uint16_t>(const uint8_t*, uint16_t*, const UnpackO
 template void UNPACK_PLATFORM<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void UNPACK_PLATFORM<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void UNPACK_BIAS_PLATFORM(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                          Uint bias) {
+  return unpack_jump<KERNEL_PLATFORM, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void UNPACK_BIAS_PLATFORM<uint8_t>(const uint8_t*, uint8_t*,
+                                            const UnpackOptions&, uint8_t);
+template void UNPACK_BIAS_PLATFORM<uint16_t>(const uint8_t*, uint16_t*,
+                                             const UnpackOptions&, uint16_t);
+template void UNPACK_BIAS_PLATFORM<uint32_t>(const uint8_t*, uint32_t*,
+                                             const UnpackOptions&, uint32_t);
+template void UNPACK_BIAS_PLATFORM<uint64_t>(const uint8_t*, uint64_t*,
+                                             const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
 
 #  undef UNPACK_PLATFORM
+#  undef UNPACK_BIAS_PLATFORM
 #endif  // UNPACK_PLATFORM
diff --git a/cpp/src/arrow/util/bpacking_simd_128_alt.cc b/cpp/src/arrow/util/bpacking_simd_128_alt.cc
index bd4799d3cd31..9ffaec4899b5 100644
--- a/cpp/src/arrow/util/bpacking_simd_128_alt.cc
+++ b/cpp/src/arrow/util/bpacking_simd_128_alt.cc
@@ -17,6 +17,7 @@
 
 #if defined(ARROW_HAVE_RUNTIME_SVE128)
 #  define UNPACK_PLATFORM unpack_sve128
+#  define UNPACK_BIAS_PLATFORM unpack_bias_sve128
 #  define KERNEL_PLATFORM KernelSve128
 #endif
 
@@ -46,6 +47,22 @@ template void UNPACK_PLATFORM<uint16_t>(const uint8_t*, uint16_t*, const UnpackO
 template void UNPACK_PLATFORM<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void UNPACK_PLATFORM<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void UNPACK_BIAS_PLATFORM(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                          Uint bias) {
+  return unpack_jump<KERNEL_PLATFORM, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void UNPACK_BIAS_PLATFORM<uint8_t>(const uint8_t*, uint8_t*,
+                                            const UnpackOptions&, uint8_t);
+template void UNPACK_BIAS_PLATFORM<uint16_t>(const uint8_t*, uint16_t*,
+                                             const UnpackOptions&, uint16_t);
+template void UNPACK_BIAS_PLATFORM<uint32_t>(const uint8_t*, uint32_t*,
+                                             const UnpackOptions&, uint32_t);
+template void UNPACK_BIAS_PLATFORM<uint64_t>(const uint8_t*, uint64_t*,
+                                             const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
 
 #undef UNPACK_PLATFORM
+#undef UNPACK_BIAS_PLATFORM
diff --git a/cpp/src/arrow/util/bpacking_simd_256.cc b/cpp/src/arrow/util/bpacking_simd_256.cc
index 8c5ce4dc7d06..98f7d210fb94 100644
--- a/cpp/src/arrow/util/bpacking_simd_256.cc
+++ b/cpp/src/arrow/util/bpacking_simd_256.cc
@@ -17,9 +17,11 @@
 
 #if defined(ARROW_HAVE_SVE256) || defined(ARROW_HAVE_RUNTIME_SVE256)
 #  define UNPACK_PLATFORM unpack_sve256
+#  define UNPACK_BIAS_PLATFORM unpack_bias_sve256
 #  define KERNEL_PLATFORM KernelSve256
 #elif defined(ARROW_HAVE_RUNTIME_AVX2)
 #  define UNPACK_PLATFORM unpack_avx2
+#  define UNPACK_BIAS_PLATFORM unpack_bias_avx2
 #  define KERNEL_PLATFORM KernelAvx2
 #endif
 
@@ -48,6 +50,22 @@ template void UNPACK_PLATFORM<uint16_t>(const uint8_t*, uint16_t*, const UnpackO
 template void UNPACK_PLATFORM<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void UNPACK_PLATFORM<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void UNPACK_BIAS_PLATFORM(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                          Uint bias) {
+  return unpack_jump<KERNEL_PLATFORM, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void UNPACK_BIAS_PLATFORM<uint8_t>(const uint8_t*, uint8_t*,
+                                            const UnpackOptions&, uint8_t);
+template void UNPACK_BIAS_PLATFORM<uint16_t>(const uint8_t*, uint16_t*,
+                                             const UnpackOptions&, uint16_t);
+template void UNPACK_BIAS_PLATFORM<uint32_t>(const uint8_t*, uint32_t*,
+                                             const UnpackOptions&, uint32_t);
+template void UNPACK_BIAS_PLATFORM<uint64_t>(const uint8_t*, uint64_t*,
+                                             const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
 
 #undef UNPACK_PLATFORM
+#undef UNPACK_BIAS_PLATFORM
diff --git a/cpp/src/arrow/util/bpacking_simd_avx512.cc b/cpp/src/arrow/util/bpacking_simd_avx512.cc
index bef7aebe175e..408ee5f3df19 100644
--- a/cpp/src/arrow/util/bpacking_simd_avx512.cc
+++ b/cpp/src/arrow/util/bpacking_simd_avx512.cc
@@ -33,4 +33,19 @@ template void unpack_avx512<uint16_t>(const uint8_t*, uint16_t*, const UnpackOpt
 template void unpack_avx512<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void unpack_avx512<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void unpack_bias_avx512(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                        Uint bias) {
+  return unpack_jump<Simd512UnpackerForWidth, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void unpack_bias_avx512<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&,
+                                          uint8_t);
+template void unpack_bias_avx512<uint16_t>(const uint8_t*, uint16_t*,
+                                           const UnpackOptions&, uint16_t);
+template void unpack_bias_avx512<uint32_t>(const uint8_t*, uint32_t*,
+                                           const UnpackOptions&, uint32_t);
+template void unpack_bias_avx512<uint64_t>(const uint8_t*, uint64_t*,
+                                           const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_simd_internal.h b/cpp/src/arrow/util/bpacking_simd_internal.h
index d5a81baaec09..3fbdaa8a237a 100644
--- a/cpp/src/arrow/util/bpacking_simd_internal.h
+++ b/cpp/src/arrow/util/bpacking_simd_internal.h
@@ -26,8 +26,10 @@ namespace arrow::internal::bpacking {
 
 #if defined(ARROW_HAVE_NEON)
 #  define UNPACK_ARCH128 unpack_neon
+#  define UNPACK_BIAS_ARCH128 unpack_bias_neon
 #elif defined(ARROW_HAVE_SSE4_2)
 #  define UNPACK_ARCH128 unpack_sse4_2
+#  define UNPACK_BIAS_ARCH128 unpack_bias_sse4_2
 #endif
 
 #if defined(UNPACK_ARCH128)
@@ -50,11 +52,29 @@ extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void UNPACK_BIAS_ARCH128(const uint8_t* in, Uint* out,
+                                      const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif  // UNPACK_ARCH128
 #undef UNPACK_ARCH128
+#undef UNPACK_BIAS_ARCH128
 
 #if defined(ARROW_HAVE_RUNTIME_SVE128)
 #  define UNPACK_ARCH128_ALT unpack_sve128
+#  define UNPACK_BIAS_ARCH128_ALT unpack_bias_sve128
 #endif
 
 #if defined(UNPACK_ARCH128_ALT)
@@ -78,13 +98,32 @@ extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128_ALT<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128_ALT<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void UNPACK_BIAS_ARCH128_ALT(const uint8_t* in, Uint* out,
+                                          const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif  // UNPACK_ARCH128_ALT
 #undef UNPACK_ARCH128_ALT
+#undef UNPACK_BIAS_ARCH128_ALT
 
 #if defined(ARROW_HAVE_SVE256) || defined(ARROW_HAVE_RUNTIME_SVE256)
 #  define UNPACK_ARCH256 unpack_sve256
+#  define UNPACK_BIAS_ARCH256 unpack_bias_sve256
 #elif defined(UNPACK_ARCH256) || defined(ARROW_HAVE_RUNTIME_AVX2)
 #  define UNPACK_ARCH256 unpack_avx2
+#  define UNPACK_BIAS_ARCH256 unpack_bias_avx2
 #endif
 
 #if defined(UNPACK_ARCH256)
@@ -107,8 +146,25 @@ extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH256<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH256<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void UNPACK_BIAS_ARCH256(const uint8_t* in, Uint* out,
+                                      const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif  // UNPACK_ARCH256
 #undef UNPACK_ARCH256
+#undef UNPACK_BIAS_ARCH256
 
 #if defined(ARROW_HAVE_AVX512) || defined(ARROW_HAVE_RUNTIME_AVX512)
 
@@ -130,6 +186,22 @@ extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void unpack_bias_avx512(const uint8_t* in, Uint* out,
+                                     const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif
 
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
index 83a969cca643..a9c36a8f4c1a 100644
--- a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
+++ b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
@@ -645,9 +645,10 @@ struct MediumKernel {
   static constexpr int kValuesUnpacked = kPlan.unpacked_per_kernel();
   static constexpr int kBytesRead = kPlan.total_bytes_read();
 
-  template <int kReadIdx, int kSwizzleIdx, int kShiftIdx>
+  template <bool kHasBias, int kReadIdx, int kSwizzleIdx, int kShiftIdx>
   ARROW_FORCE_INLINE static void unpack_one_shift_impl(const simd_batch& words,
-                                                       unpacked_type* out) {
+                                                       unpacked_type* out,
+                                                       const simd_batch& bias) {
     constexpr auto kRightShiftsArr =
         kPlan.shifts.at(kReadIdx).at(kSwizzleIdx).at(kShiftIdx);
     constexpr auto kRightShifts = array_to_batch_constant<kRightShiftsArr, arch_type>();
@@ -662,44 +663,62 @@ struct MediumKernel {
     const auto shifted = right_shift_by_excess(words, kRightShifts);
     const auto vals = shifted & kMask;
     if constexpr (std::is_same_v<unpacked_type, bool>) {
+      static_assert(!kHasBias, "no bias on bool output");
       const xsimd::batch_bool<uint_type, arch_type> bools = vals != 0;
       bools.store_unaligned(out + kOutOffset);
+    } else if constexpr (kHasBias) {
+      // The whole point: the bias lands before the store, so there is no second
+      // pass over the output to add it.
+      (vals + bias).store_unaligned(out + kOutOffset);
     } else {
       vals.store_unaligned(out + kOutOffset);
     }
   }
 
-  template <int kReadIdx, int kSwizzleIdx, int... kShiftIds>
+  template <bool kHasBias, int kReadIdx, int kSwizzleIdx, int... kShiftIds>
   ARROW_FORCE_INLINE static void unpack_one_swizzle_impl(
-      const simd_bytes& bytes, unpacked_type* out,
+      const simd_bytes& bytes, unpacked_type* out, const simd_batch& bias,
       std::integer_sequence<int, kShiftIds...>) {
     constexpr auto kSwizzlesArr = kPlan.swizzles.at(kReadIdx).at(kSwizzleIdx);
     constexpr auto kSwizzles = array_to_batch_constant<kSwizzlesArr, arch_type>();
 
     const auto swizzled = xsimd::swizzle(bytes, kSwizzles);
     const auto words = xsimd::bitwise_cast<uint_type>(swizzled);
-    (unpack_one_shift_impl<kReadIdx, kSwizzleIdx, kShiftIds>(words, out), ...);
+    (unpack_one_shift_impl<kHasBias, kReadIdx, kSwizzleIdx, kShiftIds>(words, out, bias),
+     ...);
   }
 
-  template <int kReadIdx, int... kSwizzleIds>
+  template <bool kHasBias, int kReadIdx, int... kSwizzleIds>
   ARROW_FORCE_INLINE static void unpack_one_read_impl(
-      const uint8_t* in, unpacked_type* out, std::integer_sequence<int, kSwizzleIds...>) {
+      const uint8_t* in, unpacked_type* out, const simd_batch& bias,
+      std::integer_sequence<int, kSwizzleIds...>) {
     using ShiftSeq = std::make_integer_sequence<int, kPlanSize.shifts_per_swizzle()>;
     const auto bytes =
         safe_load_bytes<kPlan.bytes_per_read(), arch_type>(in + kPlan.reads.at(kReadIdx));
-    (unpack_one_swizzle_impl<kReadIdx, kSwizzleIds>(bytes, out, ShiftSeq{}), ...);
+    (unpack_one_swizzle_impl<kHasBias, kReadIdx, kSwizzleIds>(bytes, out, bias,
+                                                              ShiftSeq{}),
+     ...);
   }
 
-  template <int... kReadIds>
+  template <bool kHasBias, int... kReadIds>
   ARROW_FORCE_INLINE static void unpack_all_impl(
-      const uint8_t* in, unpacked_type* out, std::integer_sequence<int, kReadIds...>) {
+      const uint8_t* in, unpacked_type* out, const simd_batch& bias,
+      std::integer_sequence<int, kReadIds...>) {
     using SwizzleSeq = std::make_integer_sequence<int, kPlanSize.swizzles_per_read()>;
-    (unpack_one_read_impl<kReadIds>(in, out, SwizzleSeq{}), ...);
+    (unpack_one_read_impl<kHasBias, kReadIds>(in, out, bias, SwizzleSeq{}), ...);
   }
 
   ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out) {
     using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
-    unpack_all_impl(in, out, ReadSeq{});
+    unpack_all_impl<false>(in, out, simd_batch{}, ReadSeq{});
+    return in + (kPlan.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
+  }
+
+  /// Same, with `bias` added to every value before it is stored.
+  ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out,
+                                                  unpacked_type bias) {
+    using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
+    unpack_all_impl<true>(in, out, simd_batch(static_cast<uint_type>(bias)), ReadSeq{});
     return in + (kPlan.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
   }
 };
@@ -934,9 +953,10 @@ struct LargeKernel {
   static constexpr int kValuesUnpacked = kPlanSize.unpacked_per_kernel();
   static constexpr int kBytesRead = kPlan.total_bytes_read();
 
-  template <int kReadIdx>
+  template <bool kHasBias, int kReadIdx>
   ARROW_FORCE_INLINE static void unpack_one_read_impl(const uint8_t* in,
-                                                      unpacked_type* out) {
+                                                      unpacked_type* out,
+                                                      const simd_batch& bias) {
     constexpr auto kLowSwizzles =
         array_to_batch_constant<kPlan.low_swizzles.at(kReadIdx), arch_type>();
     constexpr auto kLowRShifts =
@@ -967,18 +987,34 @@ struct LargeKernel {
     // We can have a single mask and apply it after OR because the shifts will ensure that
     // there are zeros where the high/low values are incomplete.
     const auto vals = (low_shifted | high_shifted) & kPlan.mask;
-    xsimd::store_unaligned(out + kReadIdx * kShape.unpacked_per_simd(), vals);
+    if constexpr (kHasBias) {
+      // As in MediumKernel: fold the bias into this store rather than sweeping
+      // the output again afterwards.
+      xsimd::store_unaligned(out + kReadIdx * kShape.unpacked_per_simd(), vals + bias);
+    } else {
+      xsimd::store_unaligned(out + kReadIdx * kShape.unpacked_per_simd(), vals);
+    }
   }
 
-  template <int... kReadIds>
+  template <bool kHasBias, int... kReadIds>
   ARROW_FORCE_INLINE static void unpack_all_impl(
-      const uint8_t* in, unpacked_type* out, std::integer_sequence<int, kReadIds...>) {
-    (unpack_one_read_impl<kReadIds>(in, out), ...);
+      const uint8_t* in, unpacked_type* out, const simd_batch& bias,
+      std::integer_sequence<int, kReadIds...>) {
+    (unpack_one_read_impl<kHasBias, kReadIds>(in, out, bias), ...);
   }
 
   ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out) {
     using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
-    unpack_all_impl(in, out, ReadSeq{});
+    unpack_all_impl<false>(in, out, simd_batch{}, ReadSeq{});
+    return in + (kPlan.kPlanSize.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
+  }
+
+  /// Same, with `bias` added to every value before it is stored.
+  ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out,
+                                                  unpacked_type bias) {
+    using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
+    unpack_all_impl<true>(
+        in, out, simd_batch(static_cast<typename Traits::uint_type>(bias)), ReadSeq{});
     return in + (kPlan.kPlanSize.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
   }
 };
@@ -1016,6 +1052,26 @@ struct CastingKernel : WorkingKernel {
     }
     return in;
   }
+
+  /// Same, with `bias` added to every value.
+  ///
+  /// The add goes in the cast loop, not in the working kernel's stores. The
+  /// working kernel can be *narrower* than `unpacked_type` (uint32 working /
+  /// uint64 unpacked on SSE4.2), and adding there would compute the bias modulo
+  /// the working width before widening -- wrong for any bias that does not fit.
+  /// Adding after the widening is correct for both directions, and the cast loop
+  /// was going to run anyway.
+  ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out,
+                                                  unpacked_type bias) {
+    using working_type = typename WorkingKernel::unpacked_type;
+
+    working_type buffer[kValuesUnpacked] = {};
+    in = WorkingKernel::unpack(in, buffer);
+    for (int k = 0; k < kValuesUnpacked; ++k) {
+      out[k] = static_cast<unpacked_type>(static_cast<unpacked_type>(buffer[k]) + bias);
+    }
+    return in;
+  }
 };
 
 /*******************************
diff --git a/cpp/src/arrow/util/bpacking_test.cc b/cpp/src/arrow/util/bpacking_test.cc
index d4d588228e7e..87e4570f4de8 100644
--- a/cpp/src/arrow/util/bpacking_test.cc
+++ b/cpp/src/arrow/util/bpacking_test.cc
@@ -321,4 +321,161 @@ TYPED_TEST(TestUnpack, UnpackSve256) {
 
 TYPED_TEST(TestUnpack, Unpack) { this->TestAll(&unpack<TypeParam>); }
 
+// ----------------------------------------------------------------------
+// unpack_bias
+
+template <typename Uint>
+using UnpackBiasFunc = void (*)(const uint8_t*, Uint*, const UnpackOptions&, Uint);
+
+template <typename Uint>
+class TestUnpackBias : public ::testing::Test {
+ protected:
+  /// `unpack_bias` must agree with `unpack` followed by an add, elementwise.
+  ///
+  /// This is a differential test against the plain unpacker on the same target,
+  /// which TestUnpack already covers, so it needs no second reference
+  /// implementation -- and it catches the failure mode that matters most here: a
+  /// kernel that folds the bias into some of its stores but not all of them.
+  void TestOne(UnpackBiasFunc<Uint> unpack_bias, UnpackFunc<Uint> unpack,
+               const UnpackOptions& opts, Uint bias) {
+    SCOPED_TRACE(::testing::Message() << "Testing bias=" << static_cast<uint64_t>(bias));
+
+    const auto original =
+        GenerateRandomValuesForPacking<Uint>(opts.batch_size, opts.bit_width);
+    const auto packed =
+        PackValues(original, opts.batch_size, opts.bit_width, opts.bit_offset);
+
+    std::vector<Uint> expected(opts.batch_size);
+    unpack(packed.data(), expected.data(), opts);
+    for (auto& v : expected) {
+      v = static_cast<Uint>(v + bias);
+    }
+
+    // Prefilled with a value the unpacker should never leave behind, so a store
+    // the kernel skips shows up as a mismatch rather than a lucky zero.
+    std::vector<Uint> actual(opts.batch_size, static_cast<Uint>(~Uint{0}));
+    unpack_bias(packed.data(), actual.data(), opts, bias);
+
+    ASSERT_EQ(expected, actual);
+  }
+
+  void TestAll(UnpackBiasFunc<Uint> unpack_bias, UnpackFunc<Uint> unpack) {
+    constexpr int kMaxBitWidth = 8 * sizeof(Uint);
+
+    // 0 must reproduce plain unpack. The top two force the add to wrap, which is
+    // the documented behaviour (the add is modular in Uint) and is what
+    // frame-of-reference callers rely on when they reinterpret the result as
+    // signed.
+    const std::vector<Uint> kBiases = {Uint{0}, Uint{1}, static_cast<Uint>(~Uint{0}),
+                                       static_cast<Uint>(Uint{1} << (kMaxBitWidth - 1))};
+
+    for (int num_values_base : {64, 128, 2048}) {
+      SCOPED_TRACE(::testing::Message() << "Testing num_values=" << num_values_base);
+
+      for (int bit_width = 0; bit_width <= kMaxBitWidth; ++bit_width) {
+        SCOPED_TRACE(::testing::Message() << "Testing bit_width=" << bit_width);
+
+        // Every misalignment, to reach the prolog with a bias.
+        for (int bit_offset = 0; bit_offset < 8; ++bit_offset) {
+          SCOPED_TRACE(::testing::Message() << "Testing bit_offset=" << bit_offset);
+          const UnpackOptions opts{
+              .batch_size = num_values_base,
+              .bit_width = bit_width,
+              .bit_offset = bit_offset,
+              .max_read_bytes = -1,  // No over-reading in testing (strict ASAN)
+          };
+          for (Uint bias : kBiases) {
+            TestOne(unpack_bias, unpack, opts, bias);
+            if (testing::Test::HasFailure()) return;
+          }
+        }
+
+        // Every epilog size, to reach the tail with a bias.
+        for (int epilogue_size = 0; epilogue_size <= kMaxBitWidth; ++epilogue_size) {
+          SCOPED_TRACE(::testing::Message() << "Testing epilog_size=" << epilogue_size);
+          const UnpackOptions opts{
+              .batch_size = num_values_base + epilogue_size,
+              .bit_width = bit_width,
+              .bit_offset = 0,
+              .max_read_bytes = -1,  // No over-reading in testing (strict ASAN)
+          };
+          for (Uint bias : kBiases) {
+            TestOne(unpack_bias, unpack, opts, bias);
+            if (testing::Test::HasFailure()) return;
+          }
+        }
+      }
+    }
+  }
+};
+
+// No bool: an add has no meaning on a bool output and unpack_bias is not
+// instantiated for it.
+using UnpackBiasTypes = ::testing::Types<uint8_t, uint16_t, uint32_t, uint64_t>;
+
+TYPED_TEST_SUITE(TestUnpackBias, UnpackBiasTypes, UnpackTypeNames);
+
+TYPED_TEST(TestUnpackBias, UnpackBiasScalar) {
+  this->TestAll(&bpacking::unpack_bias_scalar<TypeParam>,
+                &bpacking::unpack_scalar<TypeParam>);
+}
+
+#if defined(ARROW_HAVE_SSE4_2)
+TYPED_TEST(TestUnpackBias, UnpackBiasSse4_2) {
+  this->TestAll(&bpacking::unpack_bias_sse4_2<TypeParam>,
+                &bpacking::unpack_sse4_2<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
+TYPED_TEST(TestUnpackBias, UnpackBiasAvx2) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX2)) {
+    GTEST_SKIP() << "Test requires AVX2";
+  }
+  this->TestAll(&bpacking::unpack_bias_avx2<TypeParam>,
+                &bpacking::unpack_avx2<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_AVX512)
+TYPED_TEST(TestUnpackBias, UnpackBiasAvx512) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX512)) {
+    GTEST_SKIP() << "Test requires AVX512";
+  }
+  this->TestAll(&bpacking::unpack_bias_avx512<TypeParam>,
+                &bpacking::unpack_avx512<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_NEON)
+TYPED_TEST(TestUnpackBias, UnpackBiasNeon) {
+  this->TestAll(&bpacking::unpack_bias_neon<TypeParam>,
+                &bpacking::unpack_neon<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_SVE128)
+TYPED_TEST(TestUnpackBias, UnpackBiasSve128) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::SVE128)) {
+    GTEST_SKIP() << "Test requires SVE128";
+  }
+  this->TestAll(&bpacking::unpack_bias_sve128<TypeParam>,
+                &bpacking::unpack_sve128<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_SVE256)
+TYPED_TEST(TestUnpackBias, UnpackBiasSve256) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::SVE256)) {
+    GTEST_SKIP() << "Test requires SVE256";
+  }
+  this->TestAll(&bpacking::unpack_bias_sve256<TypeParam>,
+                &bpacking::unpack_sve256<TypeParam>);
+}
+#endif
+
+TYPED_TEST(TestUnpackBias, UnpackBias) {
+  this->TestAll(&unpack_bias<TypeParam>, &unpack<TypeParam>);
+}
+
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
new file mode 100644
index 000000000000..5716799d28e9
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
@@ -0,0 +1,192 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Lane-interleaved bit-packing kernels (header-only).
+//
+// A portable port of the lane-interleaved 1024-bit container from FastLanes
+// (Afroozeh & Boncz, VLDB '23). There are no SIMD intrinsics here: the inner
+// lane loop is shaped so that every lane does identical work, which is what
+// lets the compiler auto-vectorize one source body to 4-wide NEON, 8-wide
+// AVX2 or 16-wide AVX-512 without a per-ISA variant.
+//
+// What this file is not
+// ---------------------
+// FastLanes couples two independent ideas, and only the first is here.
+//
+//   1. The interleaved container, below. It exists so that the values a
+//      register loads together are the values the unpacker needs together.
+//      This is what makes the layout fast, and it is layout-only: the values
+//      keep their input positions.
+//
+//   2. The FL_ORDER permutation (the 8x16 -> 16x8 within-sub-block transpose
+//      plus the 04261537 sub-block reorder). That exists to give a *sequential*
+//      codec -- DELTA, RLE -- one independent chain per lane, and to let one
+//      packed buffer be read at several lane widths. PFOR has no sequential
+//      dependency to break, and Parquet's decoder contract is positional, so
+//      FL_ORDER would have to be undone by a gather before any value could be
+//      handed back. It is deliberately absent: this layout returns values in
+//      input order, so nothing has to be permuted on the way out and exception
+//      positions stay meaningful without translation.
+//
+// The layout
+// ----------
+// Within a 1024-value block (32 lanes x 32 rows for uint32_t), the packed
+// buffer holds w u32 rows of 32 u32 words, where w is the bit width. Row r,
+// lane l contributes to packed[word * 32 + l] at bit shift (r*w) % 32, where
+// word = (r*w) / 32, possibly straddling into packed[word * 32 + 32 + l].
+// (word == r only when w == 32.)
+//
+// Bits are assembled exactly as sequential bit-packing assembles them: within
+// one lane, successive rows occupy successive bit positions LSB-first, and a
+// value that runs off the end of a word continues in the low bits of the next.
+// The two layouts differ only in which values land at adjacent bit positions --
+// successive rows of one lane here, successive values of the stream in
+// arrow::internal::unpack -- not in how the bits of a value are laid out. That
+// is why the shift and the straddle depend on the row and never on the lane,
+// and so why all 32 lanes do identical work.
+//
+// The payload is byte-identical in size to the sequential layout for a full
+// block: 1024 * w bits either way, or 128 * w bytes.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+#include "arrow/util/macros.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+constexpr size_t kBlockSize = 1024;
+constexpr size_t kLanes = 32;         // 1024 / sizeof(uint32_t) / 8
+constexpr size_t kRowsPerBlock = 32;  // 1024 / kLanes
+
+static_assert(kLanes * kRowsPerBlock == kBlockSize,
+              "every value of a block must land in exactly one lane and row");
+
+// ---------------------------------------------------------------------------
+// Pack: 1024 u32 inputs, in input order -> w*32 u32 packed words.
+// ---------------------------------------------------------------------------
+template <uint32_t w>
+inline void PackBlock(const uint32_t* ARROW_RESTRICT in, uint32_t* ARROW_RESTRICT out) {
+  static_assert(w >= 1 && w <= 32);
+  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+
+  if constexpr (w == 32) {
+    std::memcpy(out, in, kBlockSize * sizeof(uint32_t));
+    return;
+  }
+
+  std::memset(out, 0, w * kLanes * sizeof(uint32_t));
+
+#pragma GCC unroll 32
+  for (uint32_t row = 0; row < kRowsPerBlock; ++row) {
+    constexpr uint32_t kT = 32;
+    const uint32_t startBit = row * w;
+    const uint32_t word = startBit / kT;
+    const uint32_t shift = startBit % kT;
+    const uint32_t endBit = startBit + w;
+    const uint32_t endWord = (endBit - 1) / kT;
+
+    if (word == endWord) {
+      for (uint32_t lane = 0; lane < kLanes; ++lane) {
+        const uint32_t v = in[row * kLanes + lane] & kMask;
+        out[word * kLanes + lane] |= (v << shift);
+      }
+    } else {
+      // shift is never 0 in this branch -- a value that straddles has to start
+      // partway into its word -- so the >> below is never a shift by 32.
+      const uint32_t lowBits = kT - shift;
+      for (uint32_t lane = 0; lane < kLanes; ++lane) {
+        const uint32_t v = in[row * kLanes + lane] & kMask;
+        out[word * kLanes + lane] |= (v << shift);
+        out[endWord * kLanes + lane] |= (v >> lowBits);
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Unpack: w*32 packed u32 words -> 1024 u32 outputs in input order.
+//
+// With kHasBias, `bias` is added to every value before it is stored, so a
+// frame-of-reference decoder does not need a second pass over the output to
+// add it. That pass is not cheap: measured against the unpack it follows, it
+// costs 1.47x-2.40x, and a pass that only copies costs the same as one that
+// adds, so what is paid for is the traversal rather than the arithmetic. The
+// add is modular in uint32_t, matching the encoder's subtraction.
+//
+// kHasBias is a template parameter rather than a runtime argument so that the
+// no-bias instantiations carry no test in their inner loop.
+// ---------------------------------------------------------------------------
+template <uint32_t w, bool kHasBias = false>
+inline void UnpackBlock(const uint32_t* ARROW_RESTRICT packed,
+                        uint32_t* ARROW_RESTRICT out, uint32_t bias = 0) {
+  static_assert(w >= 1 && w <= 32);
+  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+
+  if constexpr (w == 32) {
+    if constexpr (kHasBias) {
+      // A loop, not memcpy-then-add: both pointers are restrict-qualified
+      // uint32_t*, so this vectorizes and stays a single traversal.
+      for (size_t i = 0; i < kBlockSize; ++i) {
+        out[i] = packed[i] + bias;
+      }
+    } else {
+      std::memcpy(out, packed, kBlockSize * sizeof(uint32_t));
+    }
+    return;
+  }
+
+#pragma GCC unroll 32
+  for (uint32_t row = 0; row < kRowsPerBlock; ++row) {
+    constexpr uint32_t kT = 32;
+    const uint32_t startBit = row * w;
+    const uint32_t word = startBit / kT;
+    const uint32_t shift = startBit % kT;
+    const uint32_t endBit = startBit + w;
+    const uint32_t endWord = (endBit - 1) / kT;
+
+    if (word == endWord) {
+      for (uint32_t lane = 0; lane < kLanes; ++lane) {
+        uint32_t v = (packed[word * kLanes + lane] >> shift) & kMask;
+        if constexpr (kHasBias) {
+          v += bias;
+        }
+        out[row * kLanes + lane] = v;
+      }
+    } else {
+      const uint32_t lowBits = kT - shift;
+      for (uint32_t lane = 0; lane < kLanes; ++lane) {
+        const uint32_t lo = packed[word * kLanes + lane] >> shift;
+        const uint32_t hi = packed[endWord * kLanes + lane] << lowBits;
+        uint32_t v = (lo | hi) & kMask;
+        if constexpr (kHasBias) {
+          v += bias;
+        }
+        out[row * kLanes + lane] = v;
+      }
+    }
+  }
+}
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/interleaved_pfor.h b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
new file mode 100644
index 000000000000..cb783b8f6d54
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
@@ -0,0 +1,429 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// ---------------------------------------------------------------------------
+// Plain (non-delta) PFOR through the FastLanes container, in two orders:
+//
+//   kFileOrder  per-block frame-of-reference subtract, then bit-pack with the
+//               interleaved container in input order. This is Building Block
+//               1 alone -- lane_delta.h and transposed_delta.h are Building
+//               Block 1 applied to a delta chain; this file applies it to
+//               plain PFOR, which has no chain to break. Decode returns
+//               values in file order with no permutation, matching the note
+//               in fastlanes_kernels_internal.h.
+//
+//   kFlOrder    the same, but the residuals are placed with the paper's lane
+//               assignment (reused from transposed_delta.h's Transpose32x32:
+//               lane l holds the contiguous run [32l, 32l+32)) before
+//               packing, and gathered back to file order after unpacking.
+//               PFOR has no chain for this ordering to help, so this arm
+//               exists to price the gather it forces rather than to recommend
+//               it -- see fastlanes_kernels_internal.h's header comment.
+//
+// Both orders are otherwise identical: same per-block FOR, same bit width
+// choice, same container. That makes the difference between them the value
+// ordering and nothing else, which is the one question this file answers.
+//
+// THIS CODE HAS NO EXCEPTION HANDLING. There is no patch list on the wire and
+// no patch pass in the decoder, because a bit width wide enough for the block's
+// largest residual is always chosen. Arrow's production PFOR does carry
+// exceptions and does patch them, so a ratio taken between anything here and a
+// production arm charges one side for work the other never does, and the
+// difference is not the layout. Compare kFileOrder against kFlOrder/kFlOrderRaw
+// here; for sequential against interleaved, use the two production arms that
+// differ only in PackingMode. bench_arms.sh states the rule and groups the
+// benchmark arms by it.
+//
+// The container also appears in production as PackingMode::kForBitPackInterleaved,
+// which is what a Parquet reader would use. This file is not that code and does
+// not share its wire format: the production format has no lane-assignment mode,
+// so the ordering question has nowhere else to be asked.
+//
+// A caveat on what "the same columns" means, because an earlier version of this
+// comment overstated it: the corpus in fl5_corpus/ is SYNTHETIC. Its columns are
+// generators shaped after distributions seen in ClickBench, TPC-DS, TPC-H and
+// the NYC taxi set -- they are not records loaded from those datasets, and the
+// only file the harness opens is the CSV it writes. Bit-unpacking throughput is
+// data-independent at a fixed width, so that substitution is harmless for the
+// timing arms. It is NOT harmless for any claim about how wide a column packs,
+// since the generator's autocorrelation is chosen rather than observed.
+//
+// A second caveat, on register width. UnpackBlock in
+// fastlanes_kernels_internal.h contains no intrinsics: it is portable C++ that
+// the compiler auto-vectorizes, so its register width is whatever the
+// translation unit's compile-time flags permit. It has NO runtime SIMD dispatch,
+// which means ARROW_USER_SIMD_LEVEL does not reach it and ARROW_SIMD_LEVEL
+// (default: SSE4_2 on x86) decides it. On a default build this kernel compiles
+// to XMM while the sequential comparand dispatches to a hand-written AVX2 body
+// at runtime, so a layout comparison from a default build is measuring register
+// width and not layout. Build with -DARROW_SIMD_LEVEL=AVX2 or better before
+// comparing, or give these kernels real dispatch.
+//
+// Wire layout for n values (n a multiple of 1024; any tail is stored raw):
+//
+//   [0, nblocks)                 uint8 bit width per block
+//   padded to a 4-byte boundary
+//   next 4 * nblocks bytes       int32 min (frame of reference) per block
+//   remainder                    per block, bit_width * 32 uint32 packed words
+// ---------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+#include "arrow/util/fastlanes/transposed_delta.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+// kFileOrder   pack in input order, decode straight back to input order.
+// kFlOrderRaw  pack with the paper's lane assignment and hand that order to the
+//              caller unchanged -- the arm for a consumer that does not care
+//              about value order. It runs the same PackBlock/UnpackBlock as
+//              kFileOrder against a grid that was merely filled differently at
+//              encode time, so its decode cost must come out equal to
+//              kFileOrder's; that it does is a check on the harness.
+// kFlOrder     the same wire bytes as kFlOrderRaw, but decode restores input
+//              order. This is the arm that prices FL_ORDER's permutation.
+enum class InterleavedPforOrder { kFileOrder, kFlOrderRaw, kFlOrder };
+
+inline uint32_t InterleavedPforBitsFor(uint64_t v) {
+  uint32_t bits = 0;
+  while (v != 0) {
+    ++bits;
+    v >>= 1;
+  }
+  return bits;
+}
+
+inline size_t InterleavedPforHeaderSize(size_t n) {
+  const size_t nblocks = n / kBlockSize;
+  const size_t widths = (nblocks + 3) & ~size_t(3);
+  return widths + nblocks * sizeof(int32_t);
+}
+
+inline size_t InterleavedPforMaxEncodedSize(size_t n) {
+  return InterleavedPforHeaderSize(n) + n * sizeof(uint32_t) +
+         (n % kBlockSize) * sizeof(int32_t);
+}
+
+#define ILP_PACK_CASE(W)     \
+  case W:                    \
+    PackBlock<W>(grid, dst); \
+    break;
+
+#define ILP_UNPACK_CASE(W)                \
+  case W:                                 \
+    UnpackBlock<W, true>(src, dst, bias); \
+    break;
+
+#define ILP_UNPACK_SCRATCH_CASE(W)            \
+  case W:                                     \
+    UnpackBlock<W, true>(src, scratch, bias);  \
+    break;
+
+#define ILP_UNPACK_FUSED_CASE(W)                            \
+  case W:                                                   \
+    UnpackBlockFlToFileOrder<W, true>(src, out_blk, bias);   \
+    break;
+
+#define ILP_WIDTH_CASES(M)                                                          \
+  M(1)                                                                              \
+  M(2) M(3) M(4) M(5) M(6) M(7) M(8) M(9) M(10) M(11) M(12) M(13) M(14) M(15) M(16) \
+      M(17) M(18) M(19) M(20) M(21) M(22) M(23) M(24) M(25) M(26) M(27) M(28) M(29) \
+          M(30) M(31) M(32)
+
+// ---------------------------------------------------------------------------
+// Fused FL_ORDER unpack: packed words -> file order in a single pass.
+//
+// The naive FL_ORDER decode is UnpackBlock into a 4 KiB stack grid followed by
+// Transpose32x32 out of it. That materializes the grid in memory purely to read
+// it straight back: 128 extra 32-byte stores and 128 extra loads per block, on
+// top of the 128 stores the output actually needs. The permutation itself is
+// unavoidable -- FL_ORDER exists to place values where the delta chain wants
+// them, and file order has to be restored for anyone who needs it -- but the
+// round trip through memory is not.
+//
+// Folding the transpose into the *store addressing* of the row-major kernel is
+// the other obvious idea and it is a trap: out[lane * 32 + row] means the 32
+// lanes of one row land 128 bytes apart, so each contiguous 32-byte store
+// becomes eight 4-byte scatters. That trades 128 stores per block for 1024.
+//
+// What works is doing the transpose in registers, which is what
+// Transpose32x32Avx2 already does -- it just does it on a grid that was written
+// to memory first. Here the same 8x8 register block is filled directly by the
+// unpack, so the grid never exists:
+//
+//   for each 8-lane slice lb, for each 8-row block rb:
+//     eight registers <- unpack rows rb..rb+7, lanes lb..lb+7   (8-16 loads)
+//     the unpacklo/unpackhi/permute2x128 ladder                 (24 shuffles)
+//     eight 32-byte stores across out[lb..lb+7][rb..rb+7]       (8 stores)
+//
+// Load and store counts per block are then identical to the file-order kernel's
+// (each packed word read once, each output value written once); the only thing
+// FL_ORDER pays over file order is the shuffle ladder. lb is the outer loop on
+// purpose: a fixed lb writes out[lb * 32, lb * 32 + 256), one contiguous 1 KiB
+// run, whereas rb outer would stride 128 bytes across the whole 4 KiB block.
+// ---------------------------------------------------------------------------
+#ifdef ARROW_TRANSPOSED_DELTA_AVX2
+
+namespace internal {
+
+// FlUnpackRowSlice lives in transposed_delta.h: the fused delta kernel there
+// needs it too, and that header is upstream of this one.
+
+// One 8x8 tile: unpack eight rows' worth of an 8-lane slice, transpose in
+// registers, store across eight output rows. The ladder is the same one
+// Transpose32x32Avx2 uses; only the source of r0..r7 differs.
+template <uint32_t w, bool kHasBias, uint32_t rb>
+ARROW_FORCE_INLINE void FlUnpackTile(const uint32_t* ARROW_RESTRICT packed,
+                                     int32_t* ARROW_RESTRICT out, size_t lb,
+                                     __m256i vmask, __m256i vbias) {
+  const __m256i r0 = FlUnpackRowSlice<w, kHasBias, rb + 0>(packed, lb, vmask, vbias);
+  const __m256i r1 = FlUnpackRowSlice<w, kHasBias, rb + 1>(packed, lb, vmask, vbias);
+  const __m256i r2 = FlUnpackRowSlice<w, kHasBias, rb + 2>(packed, lb, vmask, vbias);
+  const __m256i r3 = FlUnpackRowSlice<w, kHasBias, rb + 3>(packed, lb, vmask, vbias);
+  const __m256i r4 = FlUnpackRowSlice<w, kHasBias, rb + 4>(packed, lb, vmask, vbias);
+  const __m256i r5 = FlUnpackRowSlice<w, kHasBias, rb + 5>(packed, lb, vmask, vbias);
+  const __m256i r6 = FlUnpackRowSlice<w, kHasBias, rb + 6>(packed, lb, vmask, vbias);
+  const __m256i r7 = FlUnpackRowSlice<w, kHasBias, rb + 7>(packed, lb, vmask, vbias);
+
+  const __m256i t0 = _mm256_unpacklo_epi32(r0, r1);
+  const __m256i t1 = _mm256_unpackhi_epi32(r0, r1);
+  const __m256i t2 = _mm256_unpacklo_epi32(r2, r3);
+  const __m256i t3 = _mm256_unpackhi_epi32(r2, r3);
+  const __m256i t4 = _mm256_unpacklo_epi32(r4, r5);
+  const __m256i t5 = _mm256_unpackhi_epi32(r4, r5);
+  const __m256i t6 = _mm256_unpacklo_epi32(r6, r7);
+  const __m256i t7 = _mm256_unpackhi_epi32(r6, r7);
+
+  const __m256i u0 = _mm256_unpacklo_epi64(t0, t2);
+  const __m256i u1 = _mm256_unpackhi_epi64(t0, t2);
+  const __m256i u2 = _mm256_unpacklo_epi64(t1, t3);
+  const __m256i u3 = _mm256_unpackhi_epi64(t1, t3);
+  const __m256i u4 = _mm256_unpacklo_epi64(t4, t6);
+  const __m256i u5 = _mm256_unpackhi_epi64(t4, t6);
+  const __m256i u6 = _mm256_unpacklo_epi64(t5, t7);
+  const __m256i u7 = _mm256_unpackhi_epi64(t5, t7);
+
+  int32_t* dst = out + lb * kRowsPerBlock + rb;
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 0 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u0, u4, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 1 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u1, u5, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 2 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u2, u6, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 3 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u3, u7, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 4 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u0, u4, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 5 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u1, u5, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 6 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u2, u6, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 7 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u3, u7, 0x31));
+}
+
+}  // namespace internal
+
+#define ARROW_FASTLANES_FUSED_FL_UNPACK 1
+
+// Unpacks a block that was packed in FL_ORDER and writes it in file order,
+// adding `bias` on the way through. Equivalent to UnpackBlock<w, true> into a
+// scratch grid followed by Transpose32x32, without the grid.
+template <uint32_t w, bool kHasBias>
+inline void UnpackBlockFlToFileOrder(const uint32_t* ARROW_RESTRICT packed,
+                                     int32_t* ARROW_RESTRICT out, uint32_t bias = 0) {
+  static_assert(w >= 1 && w <= 32);
+  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+  const __m256i vmask = _mm256_set1_epi32(static_cast<int>(kMask));
+  const __m256i vbias = _mm256_set1_epi32(static_cast<int>(bias));
+
+  for (size_t lb = 0; lb < kLanes; lb += 8) {
+    internal::FlUnpackTile<w, kHasBias, 0>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTile<w, kHasBias, 8>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTile<w, kHasBias, 16>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTile<w, kHasBias, 24>(packed, out, lb, vmask, vbias);
+  }
+}
+
+#endif  // ARROW_TRANSPOSED_DELTA_AVX2
+
+// Returns bytes written, or 0 if some block's span exceeds 32 bits (it never
+// does for plain int32 values: max - min fits in 32 bits unconditionally).
+template <InterleavedPforOrder kOrder>
+inline size_t InterleavedPforEncode(const int32_t* in, size_t n, uint8_t* out) {
+  const size_t nblocks = n / kBlockSize;
+
+  uint8_t* widths = out;
+  int32_t* mins = reinterpret_cast<int32_t*>(out + ((nblocks + 3) & ~size_t(3)));
+  uint32_t* dst = reinterpret_cast<uint32_t*>(out + InterleavedPforHeaderSize(n));
+
+  uint32_t grid[kBlockSize];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const int32_t* blk = in + b * kBlockSize;
+
+    int64_t vmin = std::numeric_limits<int64_t>::max();
+    int64_t vmax = std::numeric_limits<int64_t>::min();
+    for (size_t t = 0; t < kBlockSize; ++t) {
+      const int64_t v = static_cast<int64_t>(blk[t]);
+      if (v < vmin) vmin = v;
+      if (v > vmax) vmax = v;
+    }
+    const uint32_t w = InterleavedPforBitsFor(static_cast<uint64_t>(vmax - vmin));
+    widths[b] = static_cast<uint8_t>(w);
+    mins[b] = static_cast<int32_t>(vmin);
+
+    if (w > 0) {
+      if constexpr (kOrder == InterleavedPforOrder::kFileOrder) {
+        for (size_t t = 0; t < kBlockSize; ++t) {
+          grid[t] = static_cast<uint32_t>(static_cast<int64_t>(blk[t]) - vmin);
+        }
+      } else {
+        // grid[row * kLanes + lane] takes the residual of the value at
+        // original position lane * kRowsPerBlock + row, the same placement
+        // TransposedDeltaEncode uses -- so lane l ends up holding the
+        // contiguous run [32l, 32l+32) once packed.
+        for (size_t lane = 0; lane < kLanes; ++lane) {
+          const size_t run = lane * kRowsPerBlock;
+          for (size_t row = 0; row < kRowsPerBlock; ++row) {
+            grid[row * kLanes + lane] =
+                static_cast<uint32_t>(static_cast<int64_t>(blk[run + row]) - vmin);
+          }
+        }
+      }
+      switch (w) {
+        ILP_WIDTH_CASES(ILP_PACK_CASE)
+        default:
+          return 0;
+      }
+      dst += w * kLanes;
+    }
+  }
+
+  for (size_t b = nblocks; b < ((nblocks + 3) & ~size_t(3)); ++b) widths[b] = 0;
+
+  uint8_t* end = reinterpret_cast<uint8_t*>(dst);
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(end, in + nblocks * kBlockSize, tail * sizeof(int32_t));
+    end += tail * sizeof(int32_t);
+  }
+  return static_cast<size_t>(end - out);
+}
+
+template <InterleavedPforOrder kOrder>
+inline void InterleavedPforDecode(const uint8_t* in, size_t n, int32_t* out) {
+  const size_t nblocks = n / kBlockSize;
+
+  const uint8_t* widths = in;
+  const int32_t* mins =
+      reinterpret_cast<const int32_t*>(in + ((nblocks + 3) & ~size_t(3)));
+  const uint32_t* src =
+      reinterpret_cast<const uint32_t*>(in + InterleavedPforHeaderSize(n));
+
+  // Only the repaired FL_ORDER arm can need a scratch grid, and only where the
+  // fused kernel is unavailable. kFileOrder owes no permutation, kFlOrderRaw
+  // hands the FastLanes order to the caller as-is, and where
+  // UnpackBlockFlToFileOrder exists the permutation happens in registers -- see
+  // its comment above for why the memory round trip this replaces was 128 extra
+  // stores and 128 extra loads per block.
+#ifdef ARROW_FASTLANES_FUSED_FL_UNPACK
+  constexpr bool kNeedsScratch = false;
+#else
+  constexpr bool kNeedsScratch = (kOrder == InterleavedPforOrder::kFlOrder);
+#endif
+  uint32_t scratch[kNeedsScratch ? kBlockSize : 1];
+  ARROW_UNUSED(scratch);
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const uint32_t w = widths[b];
+    const uint32_t bias = static_cast<uint32_t>(mins[b]);
+    int32_t* out_blk = out + b * kBlockSize;
+
+    if (w == 0) {
+      // Every value in the block is the bias, so the FL_ORDER permutation is the
+      // identity on it: a constant grid transposes to itself. All three orders
+      // fill the output directly and none touches the scratch.
+      for (size_t t = 0; t < kBlockSize; ++t) out_blk[t] = static_cast<int32_t>(bias);
+      continue;
+    }
+
+    if constexpr (kOrder == InterleavedPforOrder::kFlOrder) {
+#ifdef ARROW_FASTLANES_FUSED_FL_UNPACK
+      // Unpack and permute in one pass; no grid is ever written to memory.
+      switch (w) {
+        ILP_WIDTH_CASES(ILP_UNPACK_FUSED_CASE)
+        default:
+          break;
+      }
+#else
+      // Portable fallback: materialize the grid, then read it back out.
+      // Transpose32x32 is its own inverse for a square grid, so the same call
+      // used to build the FL_ORDER layout also reads it back into file order.
+      switch (w) {
+        ILP_WIDTH_CASES(ILP_UNPACK_SCRATCH_CASE)
+        default:
+          break;
+      }
+      Transpose32x32(scratch, out_blk);
+#endif
+    } else {
+      // kFileOrder and kFlOrderRaw both want the grid exactly as UnpackBlock
+      // produces it, so the kernel writes straight into the caller's buffer.
+      // This used to unpack into a 4 KiB stack grid and then memcpy it out,
+      // which stored every value twice and traversed the output an extra time --
+      // a width-invariant cost inside the hot loop. UnpackBlock writes
+      // out[row * kLanes + lane] contiguously, exactly once per value, with no
+      // read-modify-write and no alignment requirement, and both of its pointers
+      // are ARROW_RESTRICT, so retargeting it emits the same store sequence
+      // against a different base. Measured on Granite Rapids at -O2
+      // -march=haswell, 102400 values: w=11 27.0 -> 33.6 GiB/s (1.24x), w=3
+      // 32.1 -> 40.8 (1.27x); reproduced on gcc 11.5, gcc 15.2 and clang 21.1,
+      // and matched by an independent bandwidth probe (38.7 -> 51.3, 1.33x).
+      uint32_t* dst = reinterpret_cast<uint32_t*>(out_blk);
+      switch (w) {
+        ILP_WIDTH_CASES(ILP_UNPACK_CASE)
+        default:
+          break;
+      }
+    }
+    src += w * kLanes;
+  }
+
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(out + nblocks * kBlockSize, src, tail * sizeof(int32_t));
+  }
+}
+
+#undef ILP_PACK_CASE
+#undef ILP_UNPACK_CASE
+#undef ILP_UNPACK_SCRATCH_CASE
+#undef ILP_UNPACK_FUSED_CASE
+#undef ILP_WIDTH_CASES
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/kernel_sweep/driver.cc b/cpp/src/arrow/util/fastlanes/kernel_sweep/driver.cc
new file mode 100644
index 000000000000..47a1c95b7799
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/kernel_sweep/driver.cc
@@ -0,0 +1,155 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Three-arm kernel sweep: portable sequential unpack (arm 1, this TU) vs.
+// the in-tree interleaved kernel (arm 2, this TU) vs. Arrow's dispatched
+// unpacker (arm 3, prebuilt in libarrow, called through its real header).
+//
+// Arm 1's object code (seq_unpack.o) and arm 3's object code (libarrow.so)
+// are both fixed ahead of time and linked in unchanged. Only this TU, and
+// so only arm 2, recompiles when the driver is rebuilt at a different
+// optimization level -- matching how the sweep isolates what changes
+// between its -O2 and -O3 rows.
+//
+// Not wired into the CMake build: perf_event_open is Linux-only and needs
+// a container/host that allows self-process hardware counters (this one
+// rejects perf_event_attr.exclude_idle=1 with EOPNOTSUPP but otherwise
+// allows PERF_TYPE_HARDWARE; if counters come back unavailable elsewhere,
+// that flag is the first thing to check). Build and run from a shared
+// Arrow build directory <build> with libarrow already built there:
+//
+//   g++ -std=c++20 -O2 -DNDEBUG -march=armv8-a -ftree-vectorize \
+//       -fno-semantic-interposition -I <arrow>/cpp/src -c seq_unpack.cc \
+//       -o seq_unpack_o2.o
+//
+//   g++ -std=c++20 -O2 -DNDEBUG -march=armv8-a -ftree-vectorize \
+//       -fno-semantic-interposition -I <arrow>/cpp/src driver.cc \
+//       seq_unpack_o2.o -L <build>/release -larrow \
+//       -Wl,-rpath,<build>/release -o driver_o2
+//
+//   g++ -std=c++20 -O3 -DNDEBUG -march=armv8-a -ftree-vectorize \
+//       -fno-semantic-interposition -I <arrow>/cpp/src driver.cc \
+//       seq_unpack_o2.o -L <build>/release -larrow \
+//       -Wl,-rpath,<build>/release -o driver_o3
+//
+// seq_unpack_o2.o and libarrow stay fixed across both links; only this TU
+// (arm 2) is recompiled at each level.
+#include <algorithm>
+#include <cstdio>
+#include <cstring>
+#include <random>
+#include <utility>
+#include <vector>
+
+#include "arrow/util/bpacking_internal.h"
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+#include "perf_counters.h"
+#include "seq_unpack.h"
+
+namespace fl = arrow::util::fastlanes;
+
+static constexpr int kBlocks = 16;
+static constexpr int N = kBlocks * 1024;
+static constexpr int kIters = 200;
+static constexpr int kReps = 15;
+
+struct Sample {
+  double instr_per_value;
+  double ipc;
+};
+
+template <class Fn>
+static Sample measure(PerfCounters* perf, Fn&& fn) {
+  fn();  // warm up: fault in pages, prime branch predictors
+  std::vector<double> instr_per_value(kReps), ipc(kReps);
+  for (int r = 0; r < kReps; ++r) {
+    uint64_t instructions = 0, cycles = 0;
+    perf->start();
+    for (int it = 0; it < kIters; ++it) fn();
+    perf->stop(&instructions, &cycles);
+    instr_per_value[r] = static_cast<double>(instructions) / kIters / N;
+    ipc[r] = cycles ? static_cast<double>(instructions) / static_cast<double>(cycles) : 0.0;
+  }
+  std::sort(instr_per_value.begin(), instr_per_value.end());
+  std::sort(ipc.begin(), ipc.end());
+  return {instr_per_value[kReps / 2], ipc[kReps / 2]};
+}
+
+template <uint32_t w>
+static void run(PerfCounters* perf) {
+  std::mt19937 rng(w * 2654435761u);
+  const uint32_t mask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+  std::uniform_int_distribution<uint32_t> dist(0, mask);
+  std::vector<uint32_t> in(N);
+  for (auto& x : in) x = dist(rng);
+
+  std::vector<uint32_t> pk_seq(static_cast<size_t>(N) * w / 32 + 8, 0);
+  std::vector<uint32_t> pk_int(static_cast<size_t>(kBlocks) * w * fl::kLanes, 0);
+  kSeqPack[w](in.data(), pk_seq.data(), N);
+  for (int b = 0; b < kBlocks; ++b) {
+    fl::PackBlock<w>(in.data() + b * 1024, pk_int.data() + static_cast<size_t>(b) * w * fl::kLanes);
+  }
+
+  std::vector<uint32_t> out_seq(N), out_int(N), out_arrow(N);
+
+  auto unpack_seq_call = [&] { kSeqUnpack[w](pk_seq.data(), out_seq.data(), N); };
+  auto unpack_int_call = [&] {
+    for (int b = 0; b < kBlocks; ++b) {
+      fl::UnpackBlock<w>(pk_int.data() + static_cast<size_t>(b) * w * fl::kLanes,
+                          out_int.data() + b * 1024);
+    }
+  };
+  auto unpack_arrow_call = [&] {
+    arrow::internal::unpack<uint32_t>(reinterpret_cast<const uint8_t*>(pk_seq.data()),
+                                       out_arrow.data(),
+                                       arrow::internal::UnpackOptions{N, static_cast<int>(w), 0, -1});
+  };
+
+  // Correctness gates: each arm reproduces the input, and all three agree.
+  unpack_seq_call();
+  unpack_int_call();
+  unpack_arrow_call();
+  const bool ok_seq = std::memcmp(out_seq.data(), in.data(), N * sizeof(uint32_t)) == 0;
+  const bool ok_int = std::memcmp(out_int.data(), in.data(), N * sizeof(uint32_t)) == 0;
+  const bool ok_arrow = std::memcmp(out_arrow.data(), in.data(), N * sizeof(uint32_t)) == 0;
+  const bool ok_cross = std::memcmp(out_seq.data(), out_int.data(), N * sizeof(uint32_t)) == 0 &&
+                         std::memcmp(out_seq.data(), out_arrow.data(), N * sizeof(uint32_t)) == 0;
+
+  const Sample seq = measure(perf, unpack_seq_call);
+  const Sample intl = measure(perf, unpack_int_call);
+  const Sample arw = measure(perf, unpack_arrow_call);
+
+  printf("%2u  %6.2f %5.2f  %6.2f %5.2f  %6.2f %5.2f  %s%s%s%s\n", w, seq.instr_per_value, seq.ipc,
+         intl.instr_per_value, intl.ipc, arw.instr_per_value, arw.ipc, ok_seq ? "" : " SEQ-BAD",
+         ok_int ? "" : " INT-BAD", ok_arrow ? "" : " ARROW-BAD", ok_cross ? "" : " CROSS-BAD");
+}
+
+template <uint32_t... Ws>
+static void run_all(PerfCounters* perf, std::integer_sequence<uint32_t, Ws...>) {
+  (run<Ws + 1>(perf), ...);
+}
+
+int main() {
+  PerfCounters perf;
+  if (!perf.ok()) {
+    std::fprintf(stderr, "hardware counters unavailable, aborting\n");
+    return 1;
+  }
+  printf(" w   seq(i/v) ipc   intlv(i/v) ipc   arrow(i/v) ipc\n");
+  run_all(&perf, std::make_integer_sequence<uint32_t, 32>{});
+  return 0;
+}
diff --git a/cpp/src/arrow/util/fastlanes/kernel_sweep/perf_counters.h b/cpp/src/arrow/util/fastlanes/kernel_sweep/perf_counters.h
new file mode 100644
index 000000000000..87bc68b6706c
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/kernel_sweep/perf_counters.h
@@ -0,0 +1,89 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Self-process hardware counters (instructions, cycles) via perf_event_open.
+// Requires /proc/sys/kernel/perf_event_paranoid <= 2 for same-uid,
+// self-process monitoring (no CAP_PERFMON needed at that level).
+#pragma once
+
+#include <asm/unistd.h>
+#include <linux/perf_event.h>
+#include <sys/ioctl.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+
+inline long perf_event_open(struct perf_event_attr* attr, pid_t pid, int cpu, int group_fd,
+                             unsigned long flags) {
+  return syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags);
+}
+
+class PerfCounters {
+ public:
+  PerfCounters() {
+    fd_instructions_ = open_counter(PERF_COUNT_HW_INSTRUCTIONS, -1);
+    fd_cycles_ = open_counter(PERF_COUNT_HW_CPU_CYCLES, fd_instructions_);
+    ok_ = fd_instructions_ >= 0 && fd_cycles_ >= 0;
+    if (!ok_) {
+      std::fprintf(stderr,
+                    "perf_event_open failed (errno=%d): counters unavailable, "
+                    "check /proc/sys/kernel/perf_event_paranoid\n",
+                    errno);
+    }
+  }
+
+  ~PerfCounters() {
+    if (fd_instructions_ >= 0) close(fd_instructions_);
+    if (fd_cycles_ >= 0) close(fd_cycles_);
+  }
+
+  bool ok() const { return ok_; }
+
+  void start() {
+    ioctl(fd_cycles_, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP);
+    ioctl(fd_cycles_, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP);
+  }
+
+  void stop(uint64_t* instructions, uint64_t* cycles) {
+    ioctl(fd_cycles_, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP);
+    read(fd_instructions_, instructions, sizeof(uint64_t));
+    read(fd_cycles_, cycles, sizeof(uint64_t));
+  }
+
+ private:
+  static int open_counter(uint64_t config, int group_fd) {
+    struct perf_event_attr attr;
+    std::memset(&attr, 0, sizeof(attr));
+    attr.type = PERF_TYPE_HARDWARE;
+    attr.size = sizeof(attr);
+    attr.config = config;
+    attr.disabled = 1;
+    attr.exclude_kernel = 1;
+    attr.exclude_hv = 1;
+    // exclude_idle is left unset (0): this container's virtualized PMU
+    // returns EOPNOTSUPP for perf_event_open when it is set to 1, even
+    // though plain hardware counting works fine otherwise.
+    return static_cast<int>(perf_event_open(&attr, 0 /*self*/, -1 /*any cpu*/, group_fd, 0));
+  }
+
+  int fd_instructions_ = -1;
+  int fd_cycles_ = -1;
+  bool ok_ = false;
+};
diff --git a/cpp/src/arrow/util/fastlanes/kernel_sweep/seq_unpack.cc b/cpp/src/arrow/util/fastlanes/kernel_sweep/seq_unpack.cc
new file mode 100644
index 000000000000..aea1f41ed220
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/kernel_sweep/seq_unpack.cc
@@ -0,0 +1,84 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Portable sequential bit-pack/unpack, arm 1 of the three-arm kernel sweep.
+//
+// Plain scalar bit-packing: value i's word/shift/straddle depend on i alone,
+// with no lane structure and no vectorization hint. This is the baseline
+// that the interleaved container (arm 2) and Arrow's dispatched unpacker
+// (arm 3) are both compared against.
+//
+// Compiled once, at a fixed level, into its own object file. The driver
+// links this .o unchanged into both the -O2 and -O3 builds, so this arm's
+// machine code never varies between rows of the sweep.
+#include "seq_unpack.h"
+
+#include <cstring>
+
+SeqPackFn kSeqPack[33] = {};
+SeqUnpackFn kSeqUnpack[33] = {};
+
+namespace {
+
+template <uint32_t w>
+void pack_seq(const uint32_t* in, uint32_t* out, int n) {
+  const size_t words = ((size_t)n * w + 31) / 32 + 1;
+  std::memset(out, 0, words * 4);
+  const uint32_t mask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+  uint64_t bit = 0;
+  for (int i = 0; i < n; ++i) {
+    const uint64_t v = in[i] & mask;
+    const size_t word = static_cast<size_t>(bit / 32);
+    const uint32_t sh = static_cast<uint32_t>(bit % 32);
+    out[word] |= static_cast<uint32_t>(v << sh);
+    if (sh + w > 32) out[word + 1] |= static_cast<uint32_t>(v >> (32 - sh));
+    bit += w;
+  }
+}
+
+template <uint32_t w>
+void unpack_seq(const uint32_t* packed, uint32_t* out, int n) {
+  const uint32_t mask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+  uint64_t bit = 0;
+  for (int i = 0; i < n; ++i) {
+    const size_t word = static_cast<size_t>(bit / 32);
+    const uint32_t sh = static_cast<uint32_t>(bit % 32);
+    uint64_t v;
+    if (sh + w <= 32) {
+      v = packed[word] >> sh;
+    } else {
+      const uint64_t lo = packed[word] >> sh;
+      const uint64_t hi = static_cast<uint64_t>(packed[word + 1]) << (32 - sh);
+      v = lo | hi;
+    }
+    out[i] = static_cast<uint32_t>(v & mask);
+    bit += w;
+  }
+}
+
+template <uint32_t W>
+void register_width() {
+  kSeqPack[W] = &pack_seq<W>;
+  kSeqUnpack[W] = &unpack_seq<W>;
+  if constexpr (W < 32) register_width<W + 1>();
+}
+
+struct Installer {
+  Installer() { register_width<1>(); }
+} kInstaller;
+
+}  // namespace
diff --git a/cpp/src/arrow/util/fastlanes/kernel_sweep/seq_unpack.h b/cpp/src/arrow/util/fastlanes/kernel_sweep/seq_unpack.h
new file mode 100644
index 000000000000..2ea9b2d8eef9
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/kernel_sweep/seq_unpack.h
@@ -0,0 +1,30 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Portable sequential (non-interleaved) bit-pack/unpack reference, arm 1 of
+// the three-arm kernel sweep. Compiled once into seq_unpack.o at a fixed
+// optimization level and linked unchanged into every driver build, so this
+// arm's machine code never varies between the -O2 and -O3 rows.
+#pragma once
+#include <cstdint>
+
+using SeqPackFn = void (*)(const uint32_t* in, uint32_t* out, int n);
+using SeqUnpackFn = void (*)(const uint32_t* packed, uint32_t* out, int n);
+
+// Indexed by bit width 1..32 (index 0 unused).
+extern SeqPackFn kSeqPack[33];
+extern SeqUnpackFn kSeqUnpack[33];
diff --git a/cpp/src/arrow/util/fastlanes/lane_delta.h b/cpp/src/arrow/util/fastlanes/lane_delta.h
new file mode 100644
index 000000000000..140276c9b259
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/lane_delta.h
@@ -0,0 +1,253 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// ---------------------------------------------------------------------------
+// Lane-parallel delta, an experiment: DELTA_BINARY_PACKED's cost is dominated
+// by its prefix sum, which is one dependent add per value and therefore
+// unvectorizable. Deltaing inside a bit-packing lane instead of along the file
+// order replaces that single 1024-long chain with 32 independent chains of
+// length 32, so one vector add per row advances all 32 at once.
+//
+// Two value orders are provided, differing only in which value sits one step
+// back in a lane:
+//
+//   kInterleaved  lane l holds original indices l, 32+l, ..., 992+l, so the
+//                 in-lane step is a uniform +32 in file order. Container order
+//                 equals file order, so decode needs no permutation, and the
+//                 step from one block's last row to the next block's first row
+//                 is also +32 -- the lane seeds are written once per column.
+//
+// The kFlOrder arm this file once carried used Arrow's fromTransposed32, which
+// is not the FastLanes order and has since been deleted from the tree. The
+// paper's own lane assignment lives in transposed_delta.h.
+//
+// Wire layout for n values (n a multiple of 1024; any tail is stored raw):
+//
+//   [0, 128)                     32 uint32 lane seeds
+//   [128, 128 + nblocks)         uint8 bit width per block
+//   padded to a 4-byte boundary
+//   next 4 * nblocks bytes       int32 min delta per block
+//   remainder                    per block, bit_width * 32 uint32 packed words
+//
+// Headers are hoisted out of the payload so every block's packed words land
+// 4-byte aligned without the decoder copying them to a scratch buffer first.
+// ---------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+enum class LaneDeltaOrder { kInterleaved };
+
+// Bits needed to hold v, 0 for v == 0. Encode-side only, so a loop is fine.
+inline uint32_t LaneDeltaBitsFor(uint64_t v) {
+  uint32_t bits = 0;
+  while (v != 0) {
+    ++bits;
+    v >>= 1;
+  }
+  return bits;
+}
+
+// Original-block index held by container slot t.
+template <LaneDeltaOrder kOrder>
+inline size_t LaneDeltaSource(size_t t) {
+  return t;
+}
+
+inline size_t LaneDeltaHeaderSize(size_t n) {
+  const size_t nblocks = n / kBlockSize;
+  const size_t widths = (nblocks + 3) & ~size_t(3);
+  return kLanes * sizeof(uint32_t) + widths + nblocks * sizeof(int32_t);
+}
+
+inline size_t LaneDeltaMaxEncodedSize(size_t n) {
+  return LaneDeltaHeaderSize(n) + n * sizeof(uint32_t) + (n % kBlockSize) * sizeof(int32_t);
+}
+
+#define LANE_DELTA_PACK_CASE(W) \
+  case W:                       \
+    PackBlock<W>(grid, dst);    \
+    break;
+
+#define LANE_DELTA_UNPACK_CASE(W)                 \
+  case W:                                         \
+    UnpackBlock<W, true>(src, grid, bias);        \
+    break;
+
+#define LANE_DELTA_WIDTH_CASES(M)                                                     \
+  M(1) M(2) M(3) M(4) M(5) M(6) M(7) M(8) M(9) M(10) M(11) M(12) M(13) M(14) M(15)    \
+  M(16) M(17) M(18) M(19) M(20) M(21) M(22) M(23) M(24) M(25) M(26) M(27) M(28) M(29) \
+  M(30) M(31) M(32)
+
+// Returns bytes written, or 0 if some block's delta span exceeds 32 bits and
+// the block therefore cannot be represented. Callers must check.
+template <LaneDeltaOrder kOrder>
+inline size_t LaneDeltaEncode(const int32_t* in, size_t n, uint8_t* out) {
+  const size_t nblocks = n / kBlockSize;
+  const size_t header = LaneDeltaHeaderSize(n);
+
+  uint32_t* seeds = reinterpret_cast<uint32_t*>(out);
+  uint8_t* widths = out + kLanes * sizeof(uint32_t);
+  int32_t* mins = reinterpret_cast<int32_t*>(
+      out + kLanes * sizeof(uint32_t) + ((nblocks + 3) & ~size_t(3)));
+  uint32_t* dst = reinterpret_cast<uint32_t*>(out + header);
+
+  uint32_t carry[kLanes] = {};
+  uint32_t vals[kBlockSize];
+  int64_t deltas[kBlockSize];
+  uint32_t grid[kBlockSize];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const int32_t* blk = in + b * kBlockSize;
+    for (size_t t = 0; t < kBlockSize; ++t) {
+      vals[t] = static_cast<uint32_t>(blk[LaneDeltaSource<kOrder>(t)]);
+    }
+    if (b == 0) {
+      // The first row has no predecessor; seed each lane from it so that its
+      // delta is zero, and hand the seeds to the decoder.
+      std::memcpy(carry, vals, sizeof(carry));
+      std::memcpy(seeds, vals, sizeof(carry));
+    }
+
+    int64_t min_delta = std::numeric_limits<int64_t>::max();
+    for (size_t lane = 0; lane < kLanes; ++lane) {
+      int64_t prev = static_cast<int32_t>(carry[lane]);
+      for (size_t row = 0; row < kRowsPerBlock; ++row) {
+        const int64_t cur = static_cast<int32_t>(vals[row * kLanes + lane]);
+        const int64_t d = cur - prev;
+        deltas[row * kLanes + lane] = d;
+        if (d < min_delta) min_delta = d;
+        prev = cur;
+      }
+      carry[lane] = vals[(kRowsPerBlock - 1) * kLanes + lane];
+    }
+
+    uint64_t span = 0;
+    for (size_t t = 0; t < kBlockSize; ++t) {
+      const uint64_t adj = static_cast<uint64_t>(deltas[t] - min_delta);
+      if (adj > span) span = adj;
+    }
+    // A delta of two int32 spans up to 33 bits, so subtracting the minimum
+    // does not always fit. It does not have to: reconstruction is a chain of
+    // uint32 adds, so deltas truncated to 32 bits round-trip exactly. Pay the
+    // full width and drop the minimum in that case.
+    const bool modular = span > 0xFFFFFFFFull;
+    if (modular) min_delta = 0;
+
+    const uint32_t w = modular ? 32 : LaneDeltaBitsFor(span);
+    widths[b] = static_cast<uint8_t>(w);
+    mins[b] = static_cast<int32_t>(min_delta);
+
+    if (w > 0) {
+      for (size_t t = 0; t < kBlockSize; ++t) {
+        grid[t] = static_cast<uint32_t>(deltas[t] - min_delta);
+      }
+      switch (w) {
+        LANE_DELTA_WIDTH_CASES(LANE_DELTA_PACK_CASE)
+        default:
+          return 0;
+      }
+      dst += w * kLanes;
+    }
+  }
+
+  for (size_t b = nblocks; b < ((nblocks + 3) & ~size_t(3)); ++b) {
+    widths[b] = 0;
+  }
+
+  uint8_t* end = reinterpret_cast<uint8_t*>(dst);
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(end, in + nblocks * kBlockSize, tail * sizeof(int32_t));
+    end += tail * sizeof(int32_t);
+  }
+  return static_cast<size_t>(end - out);
+}
+
+template <LaneDeltaOrder kOrder, bool kRepair = true>
+inline void LaneDeltaDecode(const uint8_t* in, size_t n, int32_t* out) {
+  const size_t nblocks = n / kBlockSize;
+  const size_t header = LaneDeltaHeaderSize(n);
+
+  const uint32_t* seeds = reinterpret_cast<const uint32_t*>(in);
+  const uint8_t* widths = in + kLanes * sizeof(uint32_t);
+  const int32_t* mins = reinterpret_cast<const int32_t*>(
+      in + kLanes * sizeof(uint32_t) + ((nblocks + 3) & ~size_t(3)));
+  const uint32_t* src = reinterpret_cast<const uint32_t*>(in + header);
+
+  uint32_t carry[kLanes];
+  std::memcpy(carry, seeds, sizeof(carry));
+
+  uint32_t grid[kBlockSize];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const uint32_t w = widths[b];
+    const uint32_t bias = static_cast<uint32_t>(mins[b]);
+
+    if (w == 0) {
+      for (size_t t = 0; t < kBlockSize; ++t) grid[t] = bias;
+    } else {
+      switch (w) {
+        LANE_DELTA_WIDTH_CASES(LANE_DELTA_UNPACK_CASE)
+        default:
+          break;
+      }
+      src += w * kLanes;
+    }
+
+    // 32 independent prefix sums, one row at a time. Each of these inner loops
+    // is 32 lanes of pure vertical add with no carry between them, which is
+    // what the serial version cannot do.
+    for (size_t lane = 0; lane < kLanes; ++lane) {
+      grid[lane] += carry[lane];
+    }
+    for (size_t row = 1; row < kRowsPerBlock; ++row) {
+      uint32_t* cur = grid + row * kLanes;
+      const uint32_t* prev = cur - kLanes;
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        cur[lane] += prev[lane];
+      }
+    }
+    std::memcpy(carry, grid + (kRowsPerBlock - 1) * kLanes, sizeof(carry));
+
+    std::memcpy(out + b * kBlockSize, grid, sizeof(grid));
+  }
+
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(out + nblocks * kBlockSize, reinterpret_cast<const uint8_t*>(src),
+                tail * sizeof(int32_t));
+  }
+}
+
+#undef LANE_DELTA_PACK_CASE
+#undef LANE_DELTA_UNPACK_CASE
+#undef LANE_DELTA_WIDTH_CASES
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/lane_delta_wrapper_internal.h b/cpp/src/arrow/util/fastlanes/lane_delta_wrapper_internal.h
new file mode 100644
index 000000000000..c22fcf736d7d
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/lane_delta_wrapper_internal.h
@@ -0,0 +1,209 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// ---------------------------------------------------------------------------
+// Page-level framing for lane-parallel delta, so the layout can be read through
+// a Parquet decoder rather than called as a kernel. A kernel measurement skips
+// the page header, the decoder's own dispatch and the level handling, so
+// dividing one by a full decoder's rate overstates what a reader would gain.
+//
+// The framing this adds over the kernel's wire layout is a value count:
+//
+//   [0, 4)      uint32 value count, little endian
+//   [4, ...)    the payload described in lane_delta.h
+//
+// The count has to live here because the payload's own header does not carry
+// one, while decode needs it to locate every section. A page's level count
+// cannot stand in for it, since that count includes nulls.
+//
+// Two properties of the payload are the kernel's and are not fixed here. Its
+// packed words and its per-block minimums are stored in host byte order, which
+// a format specification would have to pin down before this could be written to
+// a file anyone else reads. And it is int32 only, so this wrapper is too.
+// ---------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/buffer.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/bit_util.h"
+#include "arrow/util/fastlanes/lane_delta.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+/// \brief Page-level encode and decode for the lane-parallel delta layout
+///
+/// Only int32 is implemented, because the kernel is int32 only.
+template <typename T>
+class LaneDeltaWrapper;
+
+template <>
+class LaneDeltaWrapper<int32_t> {
+ public:
+  /// Bytes the value count occupies ahead of the payload.
+  static constexpr int64_t kCountSize = sizeof(uint32_t);
+
+  /// \brief Upper bound on the bytes Encode writes for `num_values` values
+  static int64_t GetMaxCompressedSize(int32_t num_values) {
+    if (num_values <= 0) return kCountSize;
+    return kCountSize +
+           static_cast<int64_t>(LaneDeltaMaxEncodedSize(static_cast<size_t>(num_values)));
+  }
+
+  /// \brief Encode values into one page
+  ///
+  /// \param[in] values the values to encode
+  /// \param[in] num_values how many; zero writes a bare count, which is what an
+  ///            all-null page encodes to
+  /// \param[out] comp output buffer, at least GetMaxCompressedSize bytes
+  /// \param[in,out] comp_size in: bytes available; out: bytes written
+  static Status Encode(const int32_t* values, int32_t num_values, uint8_t* comp,
+                       int64_t* comp_size) {
+    if (num_values < 0) {
+      return Status::Invalid("Lane delta encode: negative value count ", num_values);
+    }
+    if (comp == nullptr || comp_size == nullptr) {
+      return Status::Invalid("Lane delta encode: null output");
+    }
+    const int64_t needed = GetMaxCompressedSize(num_values);
+    if (*comp_size < needed) {
+      return Status::Invalid("Lane delta encode: buffer holds ", *comp_size,
+                             " bytes, needs ", needed);
+    }
+    StoreCount(comp, static_cast<uint32_t>(num_values));
+    if (num_values == 0) {
+      *comp_size = kCountSize;
+      return Status::OK();
+    }
+    if (values == nullptr) {
+      return Status::Invalid("Lane delta encode: null input for ", num_values, " values");
+    }
+    const size_t written = LaneDeltaEncode<LaneDeltaOrder::kInterleaved>(
+        values, static_cast<size_t>(num_values), comp + kCountSize);
+    if (written == 0) {
+      return Status::Invalid("Lane delta encode: no block width fits ", num_values,
+                             " values");
+    }
+    *comp_size = kCountSize + static_cast<int64_t>(written);
+    return Status::OK();
+  }
+
+  /// \brief Read how many values a page holds, without decoding it
+  static Result<int32_t> DecodeElementCount(const uint8_t* comp, int64_t comp_size) {
+    if (comp == nullptr || comp_size < kCountSize) {
+      return Status::Invalid("Lane delta page is ", comp_size,
+                             " bytes, too short to hold a value count");
+    }
+    const uint32_t count = LoadCount(comp);
+    if (count > static_cast<uint32_t>(std::numeric_limits<int32_t>::max())) {
+      return Status::Invalid("Lane delta page declares ", count, " values");
+    }
+    return static_cast<int32_t>(count);
+  }
+
+  /// \brief Decode a whole page
+  ///
+  /// \param[in] comp the page
+  /// \param[in] comp_size its size
+  /// \param[in] num_values values to decode, which must equal the page's own count
+  /// \param[out] values output, sized for num_values
+  ///
+  /// The kernel reads the payload as 4-byte words, so a payload that does not
+  /// start 4-byte aligned is copied to an aligned buffer first. Page buffers are
+  /// normally aligned and the copy does not happen.
+  static Status Decode(const uint8_t* comp, int64_t comp_size, int32_t num_values,
+                       int32_t* values) {
+    ARROW_ASSIGN_OR_RAISE(const int32_t declared, DecodeElementCount(comp, comp_size));
+    if (declared != num_values) {
+      return Status::Invalid("Lane delta page declares ", declared,
+                             " values but the caller asked for ", num_values);
+    }
+    if (num_values == 0) return Status::OK();
+    if (values == nullptr) {
+      return Status::Invalid("Lane delta decode: null output");
+    }
+
+    const uint8_t* payload = comp + kCountSize;
+    const int64_t payload_size = comp_size - kCountSize;
+    ARROW_ASSIGN_OR_RAISE(
+        const int64_t expected,
+        PayloadSize(payload, payload_size, static_cast<size_t>(num_values)));
+    if (payload_size < expected) {
+      return Status::Invalid("Lane delta page holds ", payload_size,
+                             " payload bytes, needs ", expected);
+    }
+
+    if (reinterpret_cast<uintptr_t>(payload) % sizeof(uint32_t) == 0) {
+      LaneDeltaDecode<LaneDeltaOrder::kInterleaved>(
+          payload, static_cast<size_t>(num_values), values);
+      return Status::OK();
+    }
+    ARROW_ASSIGN_OR_RAISE(auto aligned, AllocateBuffer(expected));
+    std::memcpy(aligned->mutable_data(), payload, static_cast<size_t>(expected));
+    LaneDeltaDecode<LaneDeltaOrder::kInterleaved>(
+        aligned->data(), static_cast<size_t>(num_values), values);
+    return Status::OK();
+  }
+
+ private:
+  static void StoreCount(uint8_t* comp, uint32_t count) {
+    const uint32_t le = ::arrow::bit_util::ToLittleEndian(count);
+    std::memcpy(comp, &le, sizeof(le));
+  }
+
+  static uint32_t LoadCount(const uint8_t* comp) {
+    uint32_t le = 0;
+    std::memcpy(&le, comp, sizeof(le));
+    return ::arrow::bit_util::FromLittleEndian(le);
+  }
+
+  /// Bytes the payload occupies for `n` values, summed from the block widths the
+  /// payload itself carries. Reading those widths needs the header to be present,
+  /// so that much is checked first.
+  static Result<int64_t> PayloadSize(const uint8_t* payload, int64_t payload_size,
+                                     size_t n) {
+    const int64_t header = static_cast<int64_t>(LaneDeltaHeaderSize(n));
+    if (payload_size < header) {
+      return Status::Invalid("Lane delta payload is ", payload_size,
+                             " bytes, too short for a ", header, " byte header");
+    }
+    const size_t nblocks = n / kBlockSize;
+    const uint8_t* widths = payload + kLanes * sizeof(uint32_t);
+    int64_t packed_words = 0;
+    for (size_t b = 0; b < nblocks; ++b) {
+      if (widths[b] > 32) {
+        return Status::Invalid("Lane delta block ", b, " declares width ",
+                               static_cast<int>(widths[b]));
+      }
+      packed_words += static_cast<int64_t>(widths[b]) * static_cast<int64_t>(kLanes);
+    }
+    const int64_t tail = static_cast<int64_t>(n % kBlockSize);
+    return header + packed_words * static_cast<int64_t>(sizeof(uint32_t)) +
+           tail * static_cast<int64_t>(sizeof(int32_t));
+  }
+};
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/transposed_delta.h b/cpp/src/arrow/util/fastlanes/transposed_delta.h
new file mode 100644
index 000000000000..1fb81e652134
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta.h
@@ -0,0 +1,828 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// ---------------------------------------------------------------------------
+// The FastLanes paper's lane assignment for DELTA, as opposed to the +32 stride
+// in lane_delta.h.
+//
+// Both break DELTA_BINARY_PACKED's single 1024-long dependency chain into 32
+// independent chains, and both therefore decode with one vector add per row.
+// They differ in which value sits one step back in a lane, and that decides the
+// compression ratio:
+//
+//   lane_delta.h        lane l holds original indices l, 32+l, ..., 992+l. The
+//                       in-lane predecessor is 32 positions back in file order,
+//                       so the stored differences are wider than the format's.
+//                       Container order is file order, so decode writes
+//                       straight to the output.
+//
+//   this file           lane l holds the contiguous run [32l, 32l+32). The
+//                       in-lane predecessor is the immediately preceding value,
+//                       so the stored differences are exactly the ones
+//                       DELTA_BINARY_PACKED stores. Decode ends in transposed
+//                       order and owes a 32x32 transpose.
+//
+// The second is the paper's: section 2.3 states the order for its own
+// 16-value example as 0,4,8,12 | 1,5,9,13 | 2,6,10,14 | 3,7,11,15, i.e. lane
+// 0 holds 0,1,2,3, and Figure 4c shows the entry points such a chain needs.
+// Reconstructing the Unified Transposed Layout from Figure 6d's caption and
+// walking the chain as section 2.4 describes it, the in-lane distance is +1
+// for 100% of steps at all four lane widths; the 04261537 tile order is what
+// makes one stored order do that for 8, 16, 32 and 64-bit lanes at once. A
+// Parquet column has one physical type, so a 32x32 transpose reproduces the
+// property this file needs.
+//
+// The price is the entry points: 32 per vector rather than the format's one.
+// The paper charges itself "1 bit per value" for storing them plainly and about
+// 0.21 bits for delta-encoding them across vectors, and both are provided here
+// (TransposedBaseCoding).
+//
+// The base for lane l is the value *before* its run, v[32l - 1], rather than
+// v[32l]. That way all 1024 payload slots carry a real difference: without it
+// row 0 of every block would be a known zero and 1/32 of the packed words would
+// be wasted.
+//
+// Wire layout for n values (n a multiple of 1024; any tail is stored raw):
+//
+//   [0, nblocks)                 uint8 payload bit width per block
+//   padded to a 4-byte boundary
+//   next 4 * nblocks             int32 payload min delta per block
+//   next, per block              the 32 bases: 4 * 32 bytes raw, or, packed,
+//                                one uint8 width + one int32 min + the 32
+//                                base deltas bit-packed LSB-first
+//   remainder                    per block, bit_width * 32 uint32 packed words
+// ---------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#if defined(__ARM_NEON) || defined(__ARM_NEON__)
+#include <arm_neon.h>
+#define ARROW_TRANSPOSED_DELTA_NEON 1
+#endif
+
+#if defined(__AVX2__)
+#include <immintrin.h>
+#define ARROW_TRANSPOSED_DELTA_AVX2 1
+#endif
+
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+#ifdef ARROW_TRANSPOSED_DELTA_AVX2
+namespace internal {
+
+// One 8-lane slice of one row, unpacked in registers. `row` is a template
+// parameter because the word index, the shift amounts and the straddle test all
+// have to be compile-time constants -- _mm256_srli_epi32 takes an immediate.
+template <uint32_t w, bool kHasBias, uint32_t row>
+ARROW_FORCE_INLINE __m256i FlUnpackRowSlice(const uint32_t* ARROW_RESTRICT packed,
+                                            size_t lb, __m256i vmask, __m256i vbias) {
+  constexpr uint32_t kT = 32;
+  constexpr uint32_t kStartBit = row * w;
+  constexpr uint32_t kWord = kStartBit / kT;
+  constexpr uint32_t kShift = kStartBit % kT;
+  constexpr uint32_t kEndWord = (kStartBit + w - 1) / kT;
+
+  __m256i v = _mm256_loadu_si256(
+      reinterpret_cast<const __m256i*>(packed + kWord * kLanes + lb));
+  if constexpr (kShift != 0) {
+    v = _mm256_srli_epi32(v, kShift);
+  }
+  if constexpr (kWord != kEndWord) {
+    // A value that straddles two words has to start partway into the first, so
+    // kShift is nonzero here and the left shift below is never by 32.
+    const __m256i hi = _mm256_loadu_si256(
+        reinterpret_cast<const __m256i*>(packed + kEndWord * kLanes + lb));
+    v = _mm256_or_si256(v, _mm256_slli_epi32(hi, kT - kShift));
+  }
+  if constexpr (w != 32) {
+    v = _mm256_and_si256(v, vmask);
+  }
+  if constexpr (kHasBias) {
+    v = _mm256_add_epi32(v, vbias);
+  }
+  return v;
+}
+
+}  // namespace internal
+#endif
+
+enum class TransposedBaseCoding { kRaw, kPacked };
+
+// How a decoder gets back to file order. kNone is not a conforming decoder and
+// exists only to price the others. kSeparate walks the block twice, once for the
+// prefix sums and once to permute; kFused does both in one pass, which is
+// available because a lane's chain does not depend on any other lane.
+// kFusedUnpack goes one step further and folds the bit-unpack in as well, so no
+// 4 KB scratch block is written or read at all. Where no fused-unpack kernel
+// exists it degrades to kFused rather than silently to kSeparate.
+enum class TransposedRepair { kNone, kSeparate, kFused, kFusedUnpack };
+
+// The output slot that container slot (row, lane) belongs to, and its inverse.
+// Not used on the hot path -- the decoder transposes in blocks instead.
+inline size_t TransposedSource(size_t t) {
+  const size_t row = t / kLanes;
+  const size_t lane = t % kLanes;
+  return lane * kRowsPerBlock + row;
+}
+
+inline uint32_t TransposedBitsFor(uint64_t v) {
+  uint32_t bits = 0;
+  while (v != 0) {
+    ++bits;
+    v >>= 1;
+  }
+  return bits;
+}
+
+// An LSB-first bit codec for the 32 base deltas of one block. 32 values per 1024
+// is not a hot path, so it does not need the register-width container -- but it
+// does need to be word-based rather than bit-at-a-time, which costs an operation
+// per value of the block rather than per value of the base stream.
+inline void PackScalar32(const uint32_t* in, uint32_t w, uint8_t* out) {
+  if (w == 0) return;
+  uint64_t acc = 0;
+  uint32_t have = 0;
+  for (size_t i = 0; i < kLanes; ++i) {
+    acc |= static_cast<uint64_t>(in[i]) << have;
+    have += w;
+    while (have >= 8) {
+      *out++ = static_cast<uint8_t>(acc);
+      acc >>= 8;
+      have -= 8;
+    }
+  }
+  if (have > 0) *out = static_cast<uint8_t>(acc);
+}
+
+inline void UnpackScalar32(const uint8_t* in, uint32_t w, uint32_t* out) {
+  if (w == 0) {
+    std::memset(out, 0, kLanes * sizeof(uint32_t));
+    return;
+  }
+  const uint32_t mask = w == 32 ? ~uint32_t{0} : ((uint32_t{1} << w) - 1);
+  // One unaligned 64-bit load per value covers any w <= 32 at any bit offset,
+  // and the load for the last value or two reaches past the stream. That is off
+  // the end of the page when the last block of a page needs no payload words,
+  // so the stream is staged first: it is at most 128 bytes, one copy per 1024
+  // values, and it buys a loop with no bounds test and no short loads. Bytes
+  // above the stream never reach the output -- every value's bits lie inside
+  // it, and the mask keeps only those.
+  const size_t stream = (kLanes * w + 7) / 8;
+  alignas(8) uint8_t staged[kLanes * sizeof(uint32_t) + sizeof(uint64_t)];
+  std::memcpy(staged, in, stream);
+  std::memset(staged + stream, 0, sizeof(uint64_t));
+  for (size_t i = 0; i < kLanes; ++i) {
+    const size_t bit = i * w;
+    uint64_t word;
+    std::memcpy(&word, staged + (bit >> 3), sizeof(word));
+    out[i] = static_cast<uint32_t>(word >> (bit & 7)) & mask;
+  }
+}
+
+template <TransposedBaseCoding kBases>
+inline size_t TransposedBaseBytes(uint32_t base_width) {
+  if constexpr (kBases == TransposedBaseCoding::kRaw) {
+    return kLanes * sizeof(uint32_t);
+  } else {
+    return 1 + sizeof(int32_t) + (kLanes * base_width + 7) / 8;
+  }
+}
+
+inline size_t TransposedFixedHeader(size_t n) {
+  const size_t nblocks = n / kBlockSize;
+  return ((nblocks + 3) & ~size_t(3)) + nblocks * sizeof(int32_t);
+}
+
+inline size_t TransposedMaxEncodedSize(size_t n) {
+  const size_t nblocks = n / kBlockSize;
+  // Per block: the widest base stream (a uint8 width, an int32 min and 32
+  // deltas at 32 bits), up to 3 bytes of padding before the packed words, and
+  // the payload, which n * sizeof(uint32_t) covers for every block at once.
+  return TransposedFixedHeader(n) + nblocks * (kLanes * sizeof(uint32_t) + 5 + 3) +
+         n * sizeof(uint32_t) + (n % kBlockSize) * sizeof(int32_t) + 8;
+}
+
+#define TPOSE_PACK_CASE(W)   \
+  case W:                    \
+    PackBlock<W>(grid, dst); \
+    break;
+
+#define TPOSE_UNPACK_CASE(W)               \
+  case W:                                  \
+    UnpackBlock<W, true>(src, grid, bias); \
+    break;
+
+#define TPOSE_FUSED_UNPACK_CASE(W)                                                 \
+  case W:                                                                          \
+    UnpackPrefixSumAndTransposeAvx2<W>(src, bases, bias, out + b * kBlockSize);     \
+    break;
+
+#define TPOSE_WIDTH_CASES(M)                                                          \
+  M(1) M(2) M(3) M(4) M(5) M(6) M(7) M(8) M(9) M(10) M(11) M(12) M(13) M(14) M(15)    \
+  M(16) M(17) M(18) M(19) M(20) M(21) M(22) M(23) M(24) M(25) M(26) M(27) M(28) M(29) \
+  M(30) M(31) M(32)
+
+// Returns bytes written, 0 if some block cannot be represented.
+template <TransposedBaseCoding kBases>
+inline size_t TransposedDeltaEncode(const int32_t* in, size_t n, uint8_t* out) {
+  const size_t nblocks = n / kBlockSize;
+  uint8_t* widths = out;
+  int32_t* mins = reinterpret_cast<int32_t*>(out + ((nblocks + 3) & ~size_t(3)));
+  uint8_t* cur = out + TransposedFixedHeader(n);
+
+  int64_t deltas[kBlockSize];
+  uint32_t grid[kBlockSize];
+  uint32_t bases[kLanes];
+  uint32_t base_deltas[kLanes];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const int32_t* blk = in + b * kBlockSize;
+    // Previous value in file order for the block's very first element.
+    // For the first block there is no predecessor; seeding from the first value
+    // makes its delta zero rather than the value itself.
+    const int64_t before = b == 0 ? static_cast<int64_t>(in[0])
+                                  : static_cast<int64_t>(in[b * kBlockSize - 1]);
+
+    // deltas[row * kLanes + lane] is the difference between the value at
+    // output position lane * 32 + row and the one before it in file order.
+    int64_t min_delta = std::numeric_limits<int64_t>::max();
+    for (size_t lane = 0; lane < kLanes; ++lane) {
+      const size_t run = lane * kRowsPerBlock;
+      int64_t prev = run == 0 ? before : static_cast<int64_t>(blk[run - 1]);
+      bases[lane] = static_cast<uint32_t>(prev);
+      for (size_t row = 0; row < kRowsPerBlock; ++row) {
+        const int64_t v = static_cast<int64_t>(blk[run + row]);
+        const int64_t d = v - prev;
+        deltas[row * kLanes + lane] = d;
+        if (d < min_delta) min_delta = d;
+        prev = v;
+      }
+    }
+
+    uint64_t span = 0;
+    for (size_t t = 0; t < kBlockSize; ++t) {
+      const uint64_t adj = static_cast<uint64_t>(deltas[t] - min_delta);
+      if (adj > span) span = adj;
+    }
+    const bool modular = span > 0xFFFFFFFFull;
+    if (modular) min_delta = 0;
+    const uint32_t w = modular ? 32 : TransposedBitsFor(span);
+    widths[b] = static_cast<uint8_t>(w);
+    mins[b] = static_cast<int32_t>(min_delta);
+
+    if constexpr (kBases == TransposedBaseCoding::kRaw) {
+      std::memcpy(cur, bases, sizeof(bases));
+      cur += sizeof(bases);
+    } else {
+      // Bases sit 32 values apart, so their own differences are small. Chain
+      // the first one to the previous block's last base.
+      int64_t bmin = std::numeric_limits<int64_t>::max();
+      int64_t bd[kLanes];
+      const size_t last = (b - 1) * kBlockSize + (kLanes - 1) * kRowsPerBlock - 1;
+      int64_t prev_base = b == 0 ? 0 : static_cast<int64_t>(in[last]);
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        const int64_t cur_base = static_cast<int32_t>(bases[lane]);
+        bd[lane] = cur_base - prev_base;
+        if (bd[lane] < bmin) bmin = bd[lane];
+        prev_base = cur_base;
+      }
+      uint64_t bspan = 0;
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        const uint64_t adj = static_cast<uint64_t>(bd[lane] - bmin);
+        if (adj > bspan) bspan = adj;
+      }
+      const bool bmodular = bspan > 0xFFFFFFFFull;
+      if (bmodular) bmin = 0;
+      const uint32_t bw = bmodular ? 32 : TransposedBitsFor(bspan);
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        base_deltas[lane] = static_cast<uint32_t>(bd[lane] - bmin);
+      }
+      *cur++ = static_cast<uint8_t>(bw);
+      const int32_t bmin32 = static_cast<int32_t>(bmin);
+      std::memcpy(cur, &bmin32, sizeof(bmin32));
+      cur += sizeof(bmin32);
+      PackScalar32(base_deltas, bw, cur);
+      cur += (kLanes * bw + 7) / 8;
+    }
+
+    if (w > 0) {
+      for (size_t t = 0; t < kBlockSize; ++t) {
+        grid[t] = static_cast<uint32_t>(deltas[t] - min_delta);
+      }
+      // The packed words must be 4-byte aligned; the base stream keeps that
+      // for kRaw but not for kPacked, so pad.
+      const size_t pad = (4 - (static_cast<size_t>(cur - out) & 3)) & 3;
+      std::memset(cur, 0, pad);
+      cur += pad;
+      uint32_t* dst = reinterpret_cast<uint32_t*>(cur);
+      switch (w) {
+        TPOSE_WIDTH_CASES(TPOSE_PACK_CASE)
+        default:
+          return 0;
+      }
+      cur += w * kLanes * sizeof(uint32_t);
+    }
+  }
+
+  for (size_t b = nblocks; b < ((nblocks + 3) & ~size_t(3)); ++b) widths[b] = 0;
+
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(cur, in + nblocks * kBlockSize, tail * sizeof(int32_t));
+    cur += tail * sizeof(int32_t);
+  }
+  return static_cast<size_t>(cur - out);
+}
+
+// A blocked 8x8 transpose of the 32x32 grid. Reads and writes stay inside the
+// 4 KB grid and the 4 KB output block, so this is an L1-resident permutation
+// rather than the scattered stores a general gather would issue.
+inline void Transpose32x32Scalar(const uint32_t* ARROW_RESTRICT grid,
+                           int32_t* ARROW_RESTRICT out) {
+  for (size_t lb = 0; lb < kLanes; lb += 8) {
+    for (size_t rb = 0; rb < kRowsPerBlock; rb += 8) {
+      for (size_t lane = lb; lane < lb + 8; ++lane) {
+        int32_t* dst = out + lane * kRowsPerBlock + rb;
+        const uint32_t* src = grid + rb * kLanes + lane;
+        dst[0] = static_cast<int32_t>(src[0 * kLanes]);
+        dst[1] = static_cast<int32_t>(src[1 * kLanes]);
+        dst[2] = static_cast<int32_t>(src[2 * kLanes]);
+        dst[3] = static_cast<int32_t>(src[3 * kLanes]);
+        dst[4] = static_cast<int32_t>(src[4 * kLanes]);
+        dst[5] = static_cast<int32_t>(src[5 * kLanes]);
+        dst[6] = static_cast<int32_t>(src[6 * kLanes]);
+        dst[7] = static_cast<int32_t>(src[7 * kLanes]);
+      }
+    }
+  }
+}
+
+#ifdef ARROW_TRANSPOSED_DELTA_NEON
+// Four 4x4 transposes per iteration. The permuted copy is one traversal either
+// way, so what this removes is the strided access, not the traffic.
+inline void Transpose32x32Neon(const uint32_t* ARROW_RESTRICT grid,
+                               int32_t* ARROW_RESTRICT out) {
+  for (size_t lane = 0; lane < kLanes; lane += 4) {
+    for (size_t row = 0; row < kRowsPerBlock; row += 4) {
+      const uint32_t* src = grid + row * kLanes + lane;
+      const uint32x4x2_t a = vtrnq_u32(vld1q_u32(src), vld1q_u32(src + kLanes));
+      const uint32x4x2_t b =
+          vtrnq_u32(vld1q_u32(src + 2 * kLanes), vld1q_u32(src + 3 * kLanes));
+      uint32_t* dst = reinterpret_cast<uint32_t*>(out) + lane * kRowsPerBlock + row;
+      vst1q_u32(dst, vcombine_u32(vget_low_u32(a.val[0]), vget_low_u32(b.val[0])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_low_u32(a.val[1]), vget_low_u32(b.val[1])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_high_u32(a.val[0]), vget_high_u32(b.val[0])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_high_u32(a.val[1]), vget_high_u32(b.val[1])));
+    }
+  }
+}
+#endif
+
+#ifdef ARROW_TRANSPOSED_DELTA_AVX2
+// Sixteen 8x8 transposes, each done entirely in registers: eight 32-byte loads
+// down a column of the grid, an unpack ladder, eight 32-byte stores across a row
+// of the output. A permutation is the one thing in this file the autovectorizer
+// cannot do -- it is not a lane-wise operation, and GCC lowers the scalar
+// version below to 1024 four-byte loads at a 128-byte stride plus 1024 scalar
+// stores. This issues 128 loads and 128 stores instead, so the block costs
+// shuffle throughput rather than memory-op throughput. 256-bit and not 512-bit
+// on purpose: a 16x16 register block needs vpermi2d ladders to cross the extra
+// lane boundary, and on this microarchitecture 512-bit buys nothing for the
+// unpack either (INTEL_RESULTS.md section 1).
+inline void Transpose32x32Avx2(const uint32_t* ARROW_RESTRICT grid,
+                               int32_t* ARROW_RESTRICT out) {
+  for (size_t rb = 0; rb < kRowsPerBlock; rb += 8) {
+    for (size_t lb = 0; lb < kLanes; lb += 8) {
+      const uint32_t* src = grid + rb * kLanes + lb;
+      const __m256i r0 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src));
+      const __m256i r1 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 1 * kLanes));
+      const __m256i r2 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 2 * kLanes));
+      const __m256i r3 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 3 * kLanes));
+      const __m256i r4 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 4 * kLanes));
+      const __m256i r5 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 5 * kLanes));
+      const __m256i r6 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 6 * kLanes));
+      const __m256i r7 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 7 * kLanes));
+
+      // Interleave 32-bit, then 64-bit, then swap the 128-bit halves. Each step
+      // halves the distance between elements that must end up adjacent.
+      const __m256i t0 = _mm256_unpacklo_epi32(r0, r1);
+      const __m256i t1 = _mm256_unpackhi_epi32(r0, r1);
+      const __m256i t2 = _mm256_unpacklo_epi32(r2, r3);
+      const __m256i t3 = _mm256_unpackhi_epi32(r2, r3);
+      const __m256i t4 = _mm256_unpacklo_epi32(r4, r5);
+      const __m256i t5 = _mm256_unpackhi_epi32(r4, r5);
+      const __m256i t6 = _mm256_unpacklo_epi32(r6, r7);
+      const __m256i t7 = _mm256_unpackhi_epi32(r6, r7);
+
+      const __m256i u0 = _mm256_unpacklo_epi64(t0, t2);
+      const __m256i u1 = _mm256_unpackhi_epi64(t0, t2);
+      const __m256i u2 = _mm256_unpacklo_epi64(t1, t3);
+      const __m256i u3 = _mm256_unpackhi_epi64(t1, t3);
+      const __m256i u4 = _mm256_unpacklo_epi64(t4, t6);
+      const __m256i u5 = _mm256_unpackhi_epi64(t4, t6);
+      const __m256i u6 = _mm256_unpacklo_epi64(t5, t7);
+      const __m256i u7 = _mm256_unpackhi_epi64(t5, t7);
+
+      int32_t* dst = out + lb * kRowsPerBlock + rb;
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 0 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u0, u4, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 1 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u1, u5, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 2 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u2, u6, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 3 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u3, u7, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 4 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u0, u4, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 5 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u1, u5, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 6 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u2, u6, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 7 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u3, u7, 0x31));
+    }
+  }
+}
+#endif
+
+inline void Transpose32x32(const uint32_t* ARROW_RESTRICT grid,
+                           int32_t* ARROW_RESTRICT out) {
+#ifdef ARROW_TRANSPOSED_DELTA_NEON
+  Transpose32x32Neon(grid, out);
+#elif defined(ARROW_TRANSPOSED_DELTA_AVX2)
+  Transpose32x32Avx2(grid, out);
+#else
+  Transpose32x32Scalar(grid, out);
+#endif
+}
+
+#ifdef ARROW_TRANSPOSED_DELTA_NEON
+// The 32 prefix sums and the permutation in one pass. Four lanes' chains run in
+// one register, so four rows of results can be transposed and stored while they
+// are still in registers, sparing the block a second 4 KB round trip.
+inline void PrefixSumAndTransposeNeon(const uint32_t* ARROW_RESTRICT grid,
+                                  const uint32_t* ARROW_RESTRICT bases,
+                                  int32_t* ARROW_RESTRICT out) {
+  for (size_t lane = 0; lane < kLanes; lane += 4) {
+    uint32x4_t acc = vld1q_u32(bases + lane);
+    for (size_t row = 0; row < kRowsPerBlock; row += 4) {
+      const uint32_t* src = grid + row * kLanes + lane;
+      const uint32x4_t v0 = vaddq_u32(acc, vld1q_u32(src));
+      const uint32x4_t v1 = vaddq_u32(v0, vld1q_u32(src + kLanes));
+      const uint32x4_t v2 = vaddq_u32(v1, vld1q_u32(src + 2 * kLanes));
+      const uint32x4_t v3 = vaddq_u32(v2, vld1q_u32(src + 3 * kLanes));
+      acc = v3;
+      const uint32x4x2_t a = vtrnq_u32(v0, v1);
+      const uint32x4x2_t c = vtrnq_u32(v2, v3);
+      uint32_t* dst = reinterpret_cast<uint32_t*>(out) + lane * kRowsPerBlock + row;
+      vst1q_u32(dst, vcombine_u32(vget_low_u32(a.val[0]), vget_low_u32(c.val[0])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_low_u32(a.val[1]), vget_low_u32(c.val[1])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_high_u32(a.val[0]), vget_high_u32(c.val[0])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_high_u32(a.val[1]), vget_high_u32(c.val[1])));
+    }
+  }
+}
+#endif
+
+#ifdef ARROW_TRANSPOSED_DELTA_AVX2
+// The 32 prefix sums and the permutation in one pass, the x86 counterpart of the
+// NEON kernel above. Without it TransposedRepair::kFused was a silent alias for
+// kSeparate on every x86 target -- the #ifdef above guarded both the kernel and
+// its call site -- so the block paid three traversals of the 4 KB grid (the
+// unpack's write, the prefix sum's read-modify-write, then the transpose's read)
+// where NEON paid two.
+//
+// The loop nest is the transpose's, with the blocking order swapped: lane block
+// outer, row block inner, so one accumulator register carries eight lanes'
+// running sums down all 32 rows and never spills. Each 8x8 register block is
+// eight loads, eight adds along the chain, the same unpack ladder
+// Transpose32x32Avx2 uses, and eight 32-byte stores across a row of the output.
+// The adds are the only addition to the transpose's instruction stream, and they
+// sit on the load-to-shuffle path rather than after it.
+//
+// The eight chains within a register are independent, so the dependency height
+// per block is 32 vpaddd, not 1024 as the wire format's serial chain would be.
+inline void PrefixSumAndTransposeAvx2(const uint32_t* ARROW_RESTRICT grid,
+                                      const uint32_t* ARROW_RESTRICT bases,
+                                      int32_t* ARROW_RESTRICT out) {
+  for (size_t lb = 0; lb < kLanes; lb += 8) {
+    // Lanes lb..lb+7 of the value that precedes each lane's run.
+    __m256i acc = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(bases + lb));
+    for (size_t rb = 0; rb < kRowsPerBlock; rb += 8) {
+      const uint32_t* src = grid + rb * kLanes + lb;
+      const __m256i r0 = _mm256_add_epi32(
+          acc, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src)));
+      const __m256i r1 = _mm256_add_epi32(
+          r0, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 1 * kLanes)));
+      const __m256i r2 = _mm256_add_epi32(
+          r1, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 2 * kLanes)));
+      const __m256i r3 = _mm256_add_epi32(
+          r2, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 3 * kLanes)));
+      const __m256i r4 = _mm256_add_epi32(
+          r3, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 4 * kLanes)));
+      const __m256i r5 = _mm256_add_epi32(
+          r4, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 5 * kLanes)));
+      const __m256i r6 = _mm256_add_epi32(
+          r5, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 6 * kLanes)));
+      const __m256i r7 = _mm256_add_epi32(
+          r6, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 7 * kLanes)));
+      acc = r7;
+
+      const __m256i t0 = _mm256_unpacklo_epi32(r0, r1);
+      const __m256i t1 = _mm256_unpackhi_epi32(r0, r1);
+      const __m256i t2 = _mm256_unpacklo_epi32(r2, r3);
+      const __m256i t3 = _mm256_unpackhi_epi32(r2, r3);
+      const __m256i t4 = _mm256_unpacklo_epi32(r4, r5);
+      const __m256i t5 = _mm256_unpackhi_epi32(r4, r5);
+      const __m256i t6 = _mm256_unpacklo_epi32(r6, r7);
+      const __m256i t7 = _mm256_unpackhi_epi32(r6, r7);
+
+      const __m256i u0 = _mm256_unpacklo_epi64(t0, t2);
+      const __m256i u1 = _mm256_unpackhi_epi64(t0, t2);
+      const __m256i u2 = _mm256_unpacklo_epi64(t1, t3);
+      const __m256i u3 = _mm256_unpackhi_epi64(t1, t3);
+      const __m256i u4 = _mm256_unpacklo_epi64(t4, t6);
+      const __m256i u5 = _mm256_unpackhi_epi64(t4, t6);
+      const __m256i u6 = _mm256_unpacklo_epi64(t5, t7);
+      const __m256i u7 = _mm256_unpackhi_epi64(t5, t7);
+
+      int32_t* dst = out + lb * kRowsPerBlock + rb;
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 0 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u0, u4, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 1 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u1, u5, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 2 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u2, u6, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 3 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u3, u7, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 4 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u0, u4, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 5 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u1, u5, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 6 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u2, u6, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 7 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u3, u7, 0x31));
+    }
+  }
+}
+#endif
+
+#ifdef ARROW_TRANSPOSED_DELTA_AVX2
+// ---------------------------------------------------------------------------
+// The same pass again, minus the grid.
+//
+// PrefixSumAndTransposeAvx2 above still reads its input from a 4 KB scratch
+// block that a separate UnpackBlock call just wrote: 128 stores followed by 128
+// loads per block, for values that were in registers moments earlier. That is
+// the identical defect the frame-mode kernel had before
+// UnpackBlockFlToFileOrder folded the transpose into the unpack, where removing
+// it was worth 1.48x at an L2-resident working set.
+//
+// The fix is the same shape: r0..r7 come from internal::FlUnpackRowSlice instead
+// of from memory, so each packed word is read once and each output value written
+// once, and the block never exists. Nothing else changes -- the accumulator
+// still carries eight lanes' running sums down all 32 rows in one register, and
+// the ladder is still the one Transpose32x32Avx2 uses.
+//
+// kHasBias is true here rather than folded into the accumulator: the wire format
+// stores min-subtracted deltas, so every one of the 32 values in a lane's chain
+// owes the block minimum, not just the first.
+template <uint32_t w, uint32_t rb>
+ARROW_FORCE_INLINE __m256i UnpackPrefixSumTransposeTile(
+    const uint32_t* ARROW_RESTRICT packed, size_t lb, __m256i vmask, __m256i vbias,
+    __m256i acc, int32_t* ARROW_RESTRICT out) {
+  const __m256i r0 =
+      _mm256_add_epi32(acc, internal::FlUnpackRowSlice<w, true, rb + 0>(packed, lb, vmask, vbias));
+  const __m256i r1 =
+      _mm256_add_epi32(r0, internal::FlUnpackRowSlice<w, true, rb + 1>(packed, lb, vmask, vbias));
+  const __m256i r2 =
+      _mm256_add_epi32(r1, internal::FlUnpackRowSlice<w, true, rb + 2>(packed, lb, vmask, vbias));
+  const __m256i r3 =
+      _mm256_add_epi32(r2, internal::FlUnpackRowSlice<w, true, rb + 3>(packed, lb, vmask, vbias));
+  const __m256i r4 =
+      _mm256_add_epi32(r3, internal::FlUnpackRowSlice<w, true, rb + 4>(packed, lb, vmask, vbias));
+  const __m256i r5 =
+      _mm256_add_epi32(r4, internal::FlUnpackRowSlice<w, true, rb + 5>(packed, lb, vmask, vbias));
+  const __m256i r6 =
+      _mm256_add_epi32(r5, internal::FlUnpackRowSlice<w, true, rb + 6>(packed, lb, vmask, vbias));
+  const __m256i r7 =
+      _mm256_add_epi32(r6, internal::FlUnpackRowSlice<w, true, rb + 7>(packed, lb, vmask, vbias));
+
+  const __m256i t0 = _mm256_unpacklo_epi32(r0, r1);
+  const __m256i t1 = _mm256_unpackhi_epi32(r0, r1);
+  const __m256i t2 = _mm256_unpacklo_epi32(r2, r3);
+  const __m256i t3 = _mm256_unpackhi_epi32(r2, r3);
+  const __m256i t4 = _mm256_unpacklo_epi32(r4, r5);
+  const __m256i t5 = _mm256_unpackhi_epi32(r4, r5);
+  const __m256i t6 = _mm256_unpacklo_epi32(r6, r7);
+  const __m256i t7 = _mm256_unpackhi_epi32(r6, r7);
+
+  const __m256i u0 = _mm256_unpacklo_epi64(t0, t2);
+  const __m256i u1 = _mm256_unpackhi_epi64(t0, t2);
+  const __m256i u2 = _mm256_unpacklo_epi64(t1, t3);
+  const __m256i u3 = _mm256_unpackhi_epi64(t1, t3);
+  const __m256i u4 = _mm256_unpacklo_epi64(t4, t6);
+  const __m256i u5 = _mm256_unpackhi_epi64(t4, t6);
+  const __m256i u6 = _mm256_unpacklo_epi64(t5, t7);
+  const __m256i u7 = _mm256_unpackhi_epi64(t5, t7);
+
+  int32_t* dst = out + lb * kRowsPerBlock + rb;
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 0 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u0, u4, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 1 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u1, u5, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 2 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u2, u6, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 3 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u3, u7, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 4 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u0, u4, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 5 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u1, u5, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 6 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u2, u6, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 7 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u3, u7, 0x31));
+  return r7;
+}
+
+// Unpack, prefix sum and permute one 1024-value block without materializing it.
+// lb outer for the same reason as the kernel above: a fixed lb writes the
+// contiguous 1 KB run out[lb * 32, lb * 32 + 256).
+template <uint32_t w>
+inline void UnpackPrefixSumAndTransposeAvx2(const uint32_t* ARROW_RESTRICT packed,
+                                            const uint32_t* ARROW_RESTRICT bases,
+                                            uint32_t bias,
+                                            int32_t* ARROW_RESTRICT out) {
+  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+  const __m256i vmask = _mm256_set1_epi32(static_cast<int>(kMask));
+  const __m256i vbias = _mm256_set1_epi32(static_cast<int>(bias));
+  for (size_t lb = 0; lb < kLanes; lb += 8) {
+    __m256i acc = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(bases + lb));
+    acc = UnpackPrefixSumTransposeTile<w, 0>(packed, lb, vmask, vbias, acc, out);
+    acc = UnpackPrefixSumTransposeTile<w, 8>(packed, lb, vmask, vbias, acc, out);
+    acc = UnpackPrefixSumTransposeTile<w, 16>(packed, lb, vmask, vbias, acc, out);
+    acc = UnpackPrefixSumTransposeTile<w, 24>(packed, lb, vmask, vbias, acc, out);
+  }
+}
+#define ARROW_TRANSPOSED_DELTA_FUSED_UNPACK 1
+#endif  // ARROW_TRANSPOSED_DELTA_AVX2
+
+#if defined(ARROW_TRANSPOSED_DELTA_NEON) || defined(ARROW_TRANSPOSED_DELTA_AVX2)
+// Defined only when a fused kernel actually exists, so the decode below selects
+// kFused on capability rather than on architecture. A target with neither still
+// falls back to kSeparate, but now visibly.
+#define ARROW_TRANSPOSED_DELTA_FUSED_REPAIR 1
+inline void PrefixSumAndTranspose(const uint32_t* ARROW_RESTRICT grid,
+                                  const uint32_t* ARROW_RESTRICT bases,
+                                  int32_t* ARROW_RESTRICT out) {
+#ifdef ARROW_TRANSPOSED_DELTA_NEON
+  PrefixSumAndTransposeNeon(grid, bases, out);
+#else
+  PrefixSumAndTransposeAvx2(grid, bases, out);
+#endif
+}
+#endif
+
+// kRepair off leaves the block in transposed order, which isolates the cost of
+// the transpose from the rest of the decode. Only kRepair on is a conforming
+// Parquet decoder.
+template <TransposedBaseCoding kBases,
+          TransposedRepair kRepair = TransposedRepair::kFused>
+inline void TransposedDeltaDecode(const uint8_t* in, size_t n, int32_t* out) {
+  const size_t nblocks = n / kBlockSize;
+  const uint8_t* widths = in;
+  const int32_t* mins =
+      reinterpret_cast<const int32_t*>(in + ((nblocks + 3) & ~size_t(3)));
+  const uint8_t* cur = in + TransposedFixedHeader(n);
+
+  uint32_t grid[kBlockSize];
+  uint32_t bases[kLanes];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const uint32_t w = widths[b];
+    const uint32_t bias = static_cast<uint32_t>(mins[b]);
+
+    if constexpr (kBases == TransposedBaseCoding::kRaw) {
+      std::memcpy(bases, cur, sizeof(bases));
+      cur += sizeof(bases);
+    } else {
+      const uint32_t bw = *cur++;
+      int32_t bmin;
+      std::memcpy(&bmin, cur, sizeof(bmin));
+      cur += sizeof(bmin);
+      uint32_t bd[kLanes];
+      UnpackScalar32(cur, bw, bd);
+      cur += (kLanes * bw + 7) / 8;
+      // 32 serial adds per 1024 values, against the format's 1024.
+      uint32_t running = b == 0 ? 0u : bases[kLanes - 1];
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        running += bd[lane] + static_cast<uint32_t>(bmin);
+        bases[lane] = running;
+      }
+    }
+
+    if (w == 0) {
+      for (size_t t = 0; t < kBlockSize; ++t) grid[t] = bias;
+    } else {
+      cur += (4 - (static_cast<size_t>(cur - in) & 3)) & 3;
+      const uint32_t* src = reinterpret_cast<const uint32_t*>(cur);
+#ifdef ARROW_TRANSPOSED_DELTA_FUSED_UNPACK
+      if constexpr (kRepair == TransposedRepair::kFusedUnpack) {
+        switch (w) {
+          TPOSE_WIDTH_CASES(TPOSE_FUSED_UNPACK_CASE)
+          default:
+            break;
+        }
+        cur += w * kLanes * sizeof(uint32_t);
+        continue;
+      }
+#endif
+      switch (w) {
+        TPOSE_WIDTH_CASES(TPOSE_UNPACK_CASE)
+        default:
+          break;
+      }
+      cur += w * kLanes * sizeof(uint32_t);
+    }
+
+    // w == 0 falls through to here even under kFusedUnpack: the block is a
+    // constant delta, so there is no bit-unpack to fuse anything into.
+#ifdef ARROW_TRANSPOSED_DELTA_FUSED_REPAIR
+    if constexpr (kRepair == TransposedRepair::kFused ||
+                  kRepair == TransposedRepair::kFusedUnpack) {
+      PrefixSumAndTranspose(grid, bases, out + b * kBlockSize);
+      continue;
+    }
+#endif
+    // 32 independent prefix sums, one vector add per row. Row 0 starts from
+    // the base, which is the value before the lane's run.
+    for (size_t lane = 0; lane < kLanes; ++lane) {
+      grid[lane] += bases[lane];
+    }
+    for (size_t row = 1; row < kRowsPerBlock; ++row) {
+      uint32_t* c = grid + row * kLanes;
+      const uint32_t* p = c - kLanes;
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        c[lane] += p[lane];
+      }
+    }
+
+    if constexpr (kRepair == TransposedRepair::kNone) {
+      std::memcpy(out + b * kBlockSize, grid, sizeof(grid));
+    } else {
+      Transpose32x32(grid, out + b * kBlockSize);
+    }
+  }
+
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(out + nblocks * kBlockSize, cur, tail * sizeof(int32_t));
+  }
+}
+
+#undef TPOSE_PACK_CASE
+#undef TPOSE_UNPACK_CASE
+#undef TPOSE_FUSED_UNPACK_CASE
+#undef TPOSE_WIDTH_CASES
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h b/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h
new file mode 100644
index 000000000000..0e3948d48c93
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h
@@ -0,0 +1,252 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// ---------------------------------------------------------------------------
+// Page-level framing for the FastLanes paper's lane assignment, so that layout
+// can be read through a Parquet decoder rather than called as a kernel. A kernel
+// measurement skips the page header, the decoder's own dispatch and the level
+// handling, so dividing one by a full decoder's rate overstates what a reader
+// would gain.
+//
+// This is the framing counterpart of the one in lane_delta_wrapper_internal.h,
+// which frames the +32 stride instead. The two differ only in which value a
+// lane's stored difference is taken against; the framing added here is the same:
+//
+//   [0, 4)      uint32 value count, little endian
+//   [4, ...)    the payload described in transposed_delta.h
+//
+// The count has to live here because the payload's own header does not carry
+// one, while decode needs it to locate every section. A page's level count
+// cannot stand in for it, since that count includes nulls.
+//
+// Two properties of the payload are the kernel's and are not fixed here. Its
+// packed words and its per-block minimums are stored in host byte order, which
+// a format specification would have to pin down before this could be written to
+// a file anyone else reads. And it is int32 only, so this wrapper is too.
+// ---------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/buffer.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/bit_util.h"
+#include "arrow/util/fastlanes/transposed_delta.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+/// \brief Page-level encode and decode for the paper's lane assignment
+///
+/// Only int32 is implemented, because the kernel is int32 only.
+template <typename T>
+class TransposedDeltaWrapper;
+
+template <>
+class TransposedDeltaWrapper<int32_t> {
+ public:
+  /// Bytes the value count occupies ahead of the payload.
+  static constexpr int64_t kCountSize = sizeof(uint32_t);
+
+  /// The bases are delta-coded against each other, which costs about 0.2 bits
+  /// per value against 1 bit for storing them plainly.
+  static constexpr TransposedBaseCoding kBases = TransposedBaseCoding::kPacked;
+
+  /// A conforming decoder has to return file order. Doing that in the same pass
+  /// as the prefix sums and the bit-unpack means no 4 KB scratch block is ever
+  /// written or read: worth 1.23x at an L2-resident working set over kFused,
+  /// which still round-trips it.
+  static constexpr TransposedRepair kRepair = TransposedRepair::kFusedUnpack;
+
+  /// \brief Upper bound on the bytes Encode writes for `num_values` values
+  static int64_t GetMaxCompressedSize(int32_t num_values) {
+    if (num_values <= 0) return kCountSize;
+    return kCountSize + static_cast<int64_t>(
+                            TransposedMaxEncodedSize(static_cast<size_t>(num_values)));
+  }
+
+  /// \brief Encode values into one page
+  ///
+  /// \param[in] values the values to encode
+  /// \param[in] num_values how many; zero writes a bare count, which is what an
+  ///            all-null page encodes to
+  /// \param[out] comp output buffer, at least GetMaxCompressedSize bytes
+  /// \param[in,out] comp_size in: bytes available; out: bytes written
+  static Status Encode(const int32_t* values, int32_t num_values, uint8_t* comp,
+                       int64_t* comp_size) {
+    if (num_values < 0) {
+      return Status::Invalid("Transposed delta encode: negative value count ",
+                             num_values);
+    }
+    if (comp == nullptr || comp_size == nullptr) {
+      return Status::Invalid("Transposed delta encode: null output");
+    }
+    const int64_t needed = GetMaxCompressedSize(num_values);
+    if (*comp_size < needed) {
+      return Status::Invalid("Transposed delta encode: buffer holds ", *comp_size,
+                             " bytes, needs ", needed);
+    }
+    StoreCount(comp, static_cast<uint32_t>(num_values));
+    if (num_values == 0) {
+      *comp_size = kCountSize;
+      return Status::OK();
+    }
+    if (values == nullptr) {
+      return Status::Invalid("Transposed delta encode: null input for ", num_values,
+                             " values");
+    }
+    const size_t written = TransposedDeltaEncode<kBases>(
+        values, static_cast<size_t>(num_values), comp + kCountSize);
+    if (written == 0) {
+      return Status::Invalid("Transposed delta encode: no block width fits ", num_values,
+                             " values");
+    }
+    *comp_size = kCountSize + static_cast<int64_t>(written);
+    return Status::OK();
+  }
+
+  /// \brief Read how many values a page holds, without decoding it
+  static Result<int32_t> DecodeElementCount(const uint8_t* comp, int64_t comp_size) {
+    if (comp == nullptr || comp_size < kCountSize) {
+      return Status::Invalid("Transposed delta page is ", comp_size,
+                             " bytes, too short to hold a value count");
+    }
+    const uint32_t count = LoadCount(comp);
+    if (count > static_cast<uint32_t>(std::numeric_limits<int32_t>::max())) {
+      return Status::Invalid("Transposed delta page declares ", count, " values");
+    }
+    return static_cast<int32_t>(count);
+  }
+
+  /// \brief Decode a whole page
+  ///
+  /// \param[in] comp the page
+  /// \param[in] comp_size its size
+  /// \param[in] num_values values to decode, which must equal the page's own count
+  /// \param[out] values output, sized for num_values
+  ///
+  /// The kernel reads the payload as 4-byte words, so a payload that does not
+  /// start 4-byte aligned is copied to an aligned buffer first. Page buffers are
+  /// normally aligned and the copy does not happen.
+  static Status Decode(const uint8_t* comp, int64_t comp_size, int32_t num_values,
+                       int32_t* values) {
+    ARROW_ASSIGN_OR_RAISE(const int32_t declared, DecodeElementCount(comp, comp_size));
+    if (declared != num_values) {
+      return Status::Invalid("Transposed delta page declares ", declared,
+                             " values but the caller asked for ", num_values);
+    }
+    if (num_values == 0) return Status::OK();
+    if (values == nullptr) {
+      return Status::Invalid("Transposed delta decode: null output");
+    }
+
+    const uint8_t* payload = comp + kCountSize;
+    const int64_t payload_size = comp_size - kCountSize;
+    ARROW_ASSIGN_OR_RAISE(
+        const int64_t expected,
+        PayloadSize(payload, payload_size, static_cast<size_t>(num_values)));
+    if (payload_size < expected) {
+      return Status::Invalid("Transposed delta page holds ", payload_size,
+                             " payload bytes, needs ", expected);
+    }
+
+    if (reinterpret_cast<uintptr_t>(payload) % sizeof(uint32_t) == 0) {
+      TransposedDeltaDecode<kBases, kRepair>(payload, static_cast<size_t>(num_values),
+                                             values);
+      return Status::OK();
+    }
+    ARROW_ASSIGN_OR_RAISE(auto aligned, AllocateBuffer(expected));
+    std::memcpy(aligned->mutable_data(), payload, static_cast<size_t>(expected));
+    TransposedDeltaDecode<kBases, kRepair>(aligned->data(),
+                                           static_cast<size_t>(num_values), values);
+    return Status::OK();
+  }
+
+ private:
+  static void StoreCount(uint8_t* comp, uint32_t count) {
+    const uint32_t le = ::arrow::bit_util::ToLittleEndian(count);
+    std::memcpy(comp, &le, sizeof(le));
+  }
+
+  static uint32_t LoadCount(const uint8_t* comp) {
+    uint32_t le = 0;
+    std::memcpy(&le, comp, sizeof(le));
+    return ::arrow::bit_util::FromLittleEndian(le);
+  }
+
+  /// Bytes the payload occupies for `n` values.
+  ///
+  /// Unlike the +32 stride's payload, whose per-block sizes are all listed in a
+  /// header, this one carries the width of each block's base stream inside that
+  /// block. Walking a block therefore means reading it, so the walk checks the
+  /// bytes it is about to read are present before reading them, rather than
+  /// summing a header and comparing once.
+  static Result<int64_t> PayloadSize(const uint8_t* payload, int64_t payload_size,
+                                     size_t n) {
+    const int64_t header = static_cast<int64_t>(TransposedFixedHeader(n));
+    if (payload_size < header) {
+      return Status::Invalid("Transposed delta payload is ", payload_size,
+                             " bytes, too short for a ", header, " byte header");
+    }
+    const size_t nblocks = n / kBlockSize;
+    int64_t off = header;
+    for (size_t b = 0; b < nblocks; ++b) {
+      const uint8_t w = payload[b];
+      if (w > 32) {
+        return Status::Invalid("Transposed delta block ", b, " declares payload width ",
+                               static_cast<int>(w));
+      }
+      if constexpr (kBases == TransposedBaseCoding::kRaw) {
+        off += static_cast<int64_t>(kLanes * sizeof(uint32_t));
+      } else {
+        // A base width and a base minimum, then the packed base deltas.
+        if (off + 1 + static_cast<int64_t>(sizeof(int32_t)) > payload_size) {
+          return Status::Invalid("Transposed delta payload is ", payload_size,
+                                 " bytes, too short for block ", b, "'s bases");
+        }
+        const uint8_t base_width = payload[off];
+        if (base_width > 32) {
+          return Status::Invalid("Transposed delta block ", b, " declares base width ",
+                                 static_cast<int>(base_width));
+        }
+        off += static_cast<int64_t>(TransposedBaseBytes<kBases>(base_width));
+      }
+      if (off > payload_size) {
+        return Status::Invalid("Transposed delta payload is ", payload_size,
+                               " bytes, too short for block ", b, "'s bases");
+      }
+      if (w > 0) {
+        // The packed words are 4-byte aligned, which the base stream does not
+        // leave them, so the encoder pads to the next boundary.
+        off += (4 - (off & 3)) & 3;
+        off += static_cast<int64_t>(w) * static_cast<int64_t>(kLanes) *
+               static_cast<int64_t>(sizeof(uint32_t));
+      }
+    }
+    const int64_t tail = static_cast<int64_t>(n % kBlockSize);
+    return off + tail * static_cast<int64_t>(sizeof(int32_t));
+  }
+};
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/meson.build b/cpp/src/arrow/util/meson.build
index c39e09c2d030..41f306d3c7d2 100644
--- a/cpp/src/arrow/util/meson.build
+++ b/cpp/src/arrow/util/meson.build
@@ -269,6 +269,7 @@ util_tests = {
         ],
     },
     'arrow-crc32-test': {'sources': ['crc32_test.cc']},
+    'arrow-pfor-test': {'sources': ['pfor/pfor_test.cc']},
 }
 
 foreach key, val : util_tests
diff --git a/cpp/src/arrow/util/pfor/pfor.cc b/cpp/src/arrow/util/pfor/pfor.cc
new file mode 100644
index 000000000000..8791d8624afc
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -0,0 +1,521 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Core PFOR (Patched Frame of Reference) compression implementation
+//
+// Implementation notes:
+//   - Vector size: 1024
+//   - Max exceptions: PforConstants::ExceptionCountType
+//   - Exception values: original integers (not FOR offsets)
+//   - Bit packing: Arrow's BitWriter/unpack, or the lane-interleaved kernels in
+//     arrow::util::fastlanes when the page asks for that layout
+
+#include "arrow/util/pfor/pfor_internal.h"
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <limits>
+#include <span>
+#include <utility>
+
+#include "arrow/util/bit_stream_utils_internal.h"
+#include "arrow/util/bit_util.h"
+#include "arrow/util/bpacking_internal.h"
+#include "arrow/util/endian.h"
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/macros.h"
+#include "arrow/util/ubsan.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+namespace {
+
+// The PFOR wire format is little-endian, so every multi-byte field converts on the
+// way in and out. The bit-packed deltas need no conversion of their own:
+// bit_util::BitWriter writes them little-endian and arrow::internal::unpack reads
+// them back the same way, so those bytes are copied verbatim.
+//
+// On a little-endian host both helpers below are a plain memcpy.
+template <typename T>
+void StoreLittleEndianArray(const T* values, int64_t num_values, uint8_t* output) {
+  if constexpr (ARROW_LITTLE_ENDIAN == 1) {
+    std::memcpy(output, values, static_cast<size_t>(num_values) * sizeof(T));
+  } else {
+    for (int64_t i = 0; i < num_values; ++i) {
+      util::SafeStore(output + i * sizeof(T), bit_util::ToLittleEndian(values[i]));
+    }
+  }
+}
+
+}  // namespace
+
+// ----------------------------------------------------------------------
+// FindOptimalBitWidth
+
+template <typename T>
+BitWidthResult PforCompression<T>::FindOptimalBitWidth(const UnsignedT* deltas,
+                                                       int32_t num_elements) {
+  std::array<int32_t, 65> histogram{};
+  BuildOffsetHistogram<T>(deltas, num_elements, &histogram);
+  int64_t cost_bits = 0;
+  return BestWidthFromHistogram<T>(histogram, num_elements, &cost_bits);
+}
+
+namespace {
+
+static_assert(PforConstants::kPforVectorSize ==
+                  static_cast<int64_t>(fastlanes::kBlockSize),
+              "the interleaved layout is only reachable while PFOR's vector size "
+              "and the interleaved block size are the same number");
+
+// Dispatch a runtime bit width into the templated interleaved kernels. Only
+// reached when InterleavedApplies<T>() holds, so the width is in [1, 32] and
+// the block is a full 1024 values.
+//
+// A table of function pointers rather than a switch over 32 cases, because the
+// table keeps each width's body out of line. Folding all 32 into one dispatch
+// function is not free: doing exactly that to Arrow's NEON unpacker cost
+// between 1.2x and 2.1x, the compiler having lost the register allocation it
+// finds for a body it compiles on its own. One indirect call per 1024 values
+// is not measurable against that.
+using InterleavedPackFn = void (*)(const uint32_t*, uint32_t*);
+using InterleavedUnpackFn = void (*)(const uint32_t*, uint32_t*, uint32_t);
+
+// Index by bit width: entry w handles width w, and entry 0 is never called
+// because a vector of width 0 is constant and never reaches a kernel.
+template <size_t... W>
+constexpr std::array<InterleavedPackFn, 33> MakePackTable(std::index_sequence<W...>) {
+  return {nullptr, &fastlanes::PackBlock<W + 1>...};
+}
+
+template <bool kHasBias, size_t... W>
+constexpr std::array<InterleavedUnpackFn, 33> MakeUnpackTable(std::index_sequence<W...>) {
+  return {nullptr, &fastlanes::UnpackBlock<W + 1, kHasBias>...};
+}
+
+constexpr auto kPackTable = MakePackTable(std::make_index_sequence<32>{});
+constexpr auto kUnpackTable = MakeUnpackTable<false>(std::make_index_sequence<32>{});
+constexpr auto kUnpackBiasTable = MakeUnpackTable<true>(std::make_index_sequence<32>{});
+
+inline void InterleavedPackBlock(uint8_t bit_width, const uint32_t* in, uint32_t* out) {
+  ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
+  kPackTable[bit_width](in, out);
+}
+
+// The frame of reference is folded into the kernel's own store, so a non-zero
+// frame costs no second pass over the output.
+inline void InterleavedUnpackBlock(uint8_t bit_width, const uint32_t* packed,
+                                   uint32_t* out, uint32_t bias) {
+  ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
+  if (bias == 0) {
+    kUnpackTable[bit_width](packed, out, 0);
+  } else {
+    kUnpackBiasTable[bit_width](packed, out, bias);
+  }
+}
+
+}  // namespace
+
+// ----------------------------------------------------------------------
+// EncodeVector
+
+template <typename T>
+PforEncodedVector<T> PforCompression<T>::EncodeVector(const T* values,
+                                                      int32_t num_elements,
+                                                      const PforEncodeOptions& options) {
+  ARROW_DCHECK(num_elements > 0);
+
+  // One scratch buffer serves both stages. ChooseVectorPlan fills it with the
+  // differences, and if the plan takes them it is also the source the offsets
+  // are computed from -- read at index i, written at index i, so the offsets
+  // can go back into the same storage. A stack buffer for the common
+  // (<=vector-size) case avoids a per-vector heap alloc and zero-init.
+  constexpr int32_t kFull = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  T stack_scratch[kFull];
+  std::vector<T> heap_scratch;
+  T* scratch = stack_scratch;
+  if (num_elements > kFull) {
+    heap_scratch.resize(num_elements);
+    scratch = heap_scratch.data();
+  }
+
+  const PforVectorPlan<T> plan =
+      ChooseVectorPlan<T>(values, num_elements, scratch, options.delta_enabled);
+  const T* source = plan.delta ? scratch : values;
+
+  PforEncodedVector<T> result;
+  result.set_info(PforVectorInfo<T>(plan.frame_of_reference, plan.bit_width,
+                                    plan.num_exceptions, plan.delta));
+  result.set_start_value(plan.start_value);
+
+  // Step 1: reduce by the frame, collecting whatever will not fit.
+  //
+  // The comparison is against the packed mask in the unsigned domain, which is
+  // what lets the frame sit above the minimum: a source value below the frame
+  // wraps to a huge offset, fails the same test as one above the window, and is
+  // patched from the exception list like any other. No second test, no sign.
+  auto* offsets = reinterpret_cast<UnsignedT*>(scratch);
+  const auto unsigned_frame = static_cast<UnsignedT>(plan.frame_of_reference);
+  const uint8_t bit_width = plan.bit_width;
+
+  if (plan.num_exceptions > 0) {
+    result.mutable_exception_positions().reserve(plan.num_exceptions);
+    result.mutable_exception_values().reserve(plan.num_exceptions);
+
+    const UnsignedT mask = (bit_width >= PforTypeTraits<T>::kMaxBitWidth)
+                               ? static_cast<UnsignedT>(-1)
+                               : (static_cast<UnsignedT>(1) << bit_width) - 1;
+
+    for (int32_t i = 0; i < num_elements; ++i) {
+      const T value = source[i];
+      UnsignedT offset = static_cast<UnsignedT>(value) - unsigned_frame;
+      if (offset > mask) {
+        result.mutable_exception_positions().push_back(
+            static_cast<PforConstants::PositionType>(i));
+        // The exception carries whatever the packed stream carries: a value in
+        // a plain vector, a difference in a delta vector. The decoder patches
+        // it in before the running sum, so a patched difference is summed like
+        // any other.
+        result.mutable_exception_values().push_back(value);
+        offset = 0;
+      }
+      offsets[i] = offset;
+    }
+  } else {
+    for (int32_t i = 0; i < num_elements; ++i) {
+      offsets[i] = static_cast<UnsignedT>(source[i]) - unsigned_frame;
+    }
+  }
+
+  // Step 2: bit-pack the offsets
+  if (bit_width > 0) {
+    int64_t packed_size =
+        bit_util::BytesForBits(static_cast<int64_t>(num_elements) * bit_width);
+    result.mutable_packed_values().resize(static_cast<size_t>(packed_size), 0);
+
+    if (InterleavedApplies<T>(options.mode, num_elements)) {
+      // A full block of 4-byte deltas. The interleaved payload is 128 * w bytes,
+      // which is what BytesForBits computed above, so both layouts write the
+      // same number of bytes and only their arrangement differs. Values keep
+      // their input positions, so there is nothing to gather on the way in and
+      // the exception positions recorded in step 4 stay correct.
+      if constexpr (sizeof(T) == 4) {
+        InterleavedPackBlock(
+            bit_width, reinterpret_cast<const uint32_t*>(offsets),
+            reinterpret_cast<uint32_t*>(result.mutable_packed_values().data()));
+      }
+    } else {
+      bit_util::BitWriter writer(result.mutable_packed_values().data(),
+                                 static_cast<int>(packed_size));
+      for (int32_t i = 0; i < num_elements; ++i) {
+        writer.PutValue(static_cast<uint64_t>(offsets[i]), bit_width);
+      }
+      writer.Flush();
+    }
+  }
+
+  return result;
+}
+
+// ----------------------------------------------------------------------
+// DecodeVector
+
+template <typename T>
+Result<int64_t> PforCompression<T>::DecodeVector(std::span<const uint8_t> data,
+                                                 int32_t num_elements, T* values,
+                                                 PackingMode mode) {
+  // Step 1: Read vector info
+  ARROW_ASSIGN_OR_RAISE(auto info, PforVectorInfo<T>::Load(data));
+  const int64_t info_bytes = info.stored_bytes();
+  if (info_bytes > static_cast<int64_t>(data.size())) {
+    return Status::Invalid("PFOR delta vector needs ", info_bytes,
+                           " bytes of metadata but only ", data.size(), " remain");
+  }
+  const uint8_t* read_ptr = data.data() + PforVectorInfo<T>::kStoredSize;
+
+  // A delta vector stores its own first value, which is what lets it decode
+  // without the vector before it -- the property the whole mode exists for.
+  T start_value = 0;
+  if (info.is_delta()) {
+    start_value = util::SafeLoadAs<T>(read_ptr);
+    read_ptr += sizeof(T);
+  }
+
+  // `values` holds num_elements slots, and everything below is sized by fields
+  // that came off the wire, so check them against it before reading or writing.
+  if (info.num_exceptions() > num_elements) {
+    return Status::Invalid("PFOR vector has ", info.num_exceptions(),
+                           " exceptions but only ", num_elements, " elements");
+  }
+  const int64_t packed_bytes =
+      bit_util::BytesForBits(static_cast<int64_t>(num_elements) * info.bit_width());
+  const int64_t exception_bytes =
+      info.num_exceptions() *
+      (static_cast<int64_t>(sizeof(PforConstants::PositionType)) + sizeof(T));
+  if (info_bytes + packed_bytes + exception_bytes > static_cast<int64_t>(data.size())) {
+    return Status::Invalid("PFOR vector needs ",
+                           info_bytes + packed_bytes + exception_bytes,
+                           " bytes but only ", data.size(), " remain");
+  }
+
+  // Step 2: Handle constant data (bit_width == 0, no exceptions)
+  if (info.bit_width() == 0 && info.num_exceptions() == 0) {
+    if (info.is_delta()) {
+      // Every difference is the frame, so the values step by it from the start
+      // value. Slot 0 always holds a difference of zero (see ComputeDeltas), so
+      // a frame other than zero cannot occur here, but the running sum below
+      // reconstructs the sequence either way rather than assuming it.
+      const auto step = static_cast<UnsignedT>(info.frame_of_reference());
+      auto acc = static_cast<UnsignedT>(start_value);
+      for (int32_t i = 0; i < num_elements; ++i) {
+        if (i > 0) acc += step;
+        std::memcpy(&values[i], &acc, sizeof(T));
+      }
+    } else {
+      std::fill(values, values + num_elements, info.frame_of_reference());
+    }
+    return info_bytes;
+  }
+
+  // Step 3: Unpack bit-packed deltas and add FOR
+  if (info.bit_width() > 0) {
+    const auto unsigned_for = static_cast<UnsignedT>(info.frame_of_reference());
+
+    // How far past this vector's own packed bytes the sequential unpacker may
+    // read. Its vector kernels load a fixed-size window per step -- wider than
+    // the step consumes at most bit widths -- and refuse any step whose window
+    // would cross this bound, leaving the rest of the vector to their scalar
+    // epilog. The -1 default bounds them at exactly the packed bytes, so the
+    // tail of every such vector decodes scalar: passing the real bound is worth
+    // a median 1.13x on whole-page decode across a 29-column corpus, and 1.9x
+    // on the columns that pack to 3 bits, where the one refused step strands 32
+    // of the 1024 values. It is worth nothing at the widths whose window equals
+    // what a step consumes -- 1, 2, 4, 8, 16 and 31 -- which strand none.
+    //
+    // `data` runs from this vector to the end of the page, so every byte after
+    // this vector's header is inside the caller's buffer and ours to read. The
+    // bound is measured from `info_bytes` rather than the fixed metadata size,
+    // because a delta vector's header also carries its start value and
+    // `read_ptr` is already past it -- subtracting the fixed size would hand
+    // the kernels sizeof(T) bytes that belong to no one.
+    const auto readable_bytes = static_cast<int>(std::min<int64_t>(
+        static_cast<int64_t>(data.size()) - info_bytes,
+        std::numeric_limits<int>::max()));
+
+    if (InterleavedApplies<T>(mode, num_elements)) {
+      // The interleaved kernel writes values in input order, so it writes into
+      // `values` directly for the same reason the two sequential paths below do:
+      // T and UnsignedT are the same width, so the unsigned bits the kernel
+      // stores ARE the signed values. It also takes the frame of reference as a
+      // bias, so a non-zero frame costs no extra traversal -- there is no
+      // separate FOR==0 fast path to write here. Exceptions are patched in
+      // step 4, at the positions the encoder recorded, which need no
+      // translation because nothing was permuted.
+      if constexpr (sizeof(T) == 4) {
+        InterleavedUnpackBlock(
+            info.bit_width(), reinterpret_cast<const uint32_t*>(read_ptr),
+            reinterpret_cast<uint32_t*>(values), static_cast<uint32_t>(unsigned_for));
+      }
+    } else if (unsigned_for == 0) {
+      // FOR is zero: there is no bias to add, so unpack straight into the
+      // output. T and UnsignedT are the same width, so the unsigned bits the
+      // unpacker writes ARE the signed values — no scratch buffer and no
+      // second (add-FOR) pass. This is the common case (any column whose
+      // minimum is 0) and decodes at the raw unpack speed. Exceptions are
+      // still patched below in Step 4.
+      arrow::internal::unpack(read_ptr, reinterpret_cast<UnsignedT*>(values),
+                              arrow::internal::UnpackOptions{
+                                  static_cast<int>(num_elements), info.bit_width(),
+                                  /*bit_offset=*/0, readable_bytes});
+    } else {
+      // FOR is non-zero: hand it to the unpacker as a bias, so the add happens
+      // inside the kernel before its store and the output is traversed once.
+      // The obvious alternative — unpack, then a second pass adding FOR — is
+      // what this code used to do, and that pass measured 1.47x-2.40x the cost
+      // of the unpack it followed (median 1.68x). A pass that only copies costs
+      // the same as one that adds, so what is paid for is the extra traversal,
+      // not the arithmetic; keeping the scratch buffer small enough to stay in
+      // L1 (it was 4 KB on the stack) did not avoid it.
+      //
+      // The add is modular in UnsignedT, so the bits the unpacker stores ARE the
+      // signed values, exactly as in the FOR==0 case above — no cast pass, no
+      // scratch, and no aliasing question. Exceptions are patched in Step 4.
+      arrow::internal::unpack_bias(read_ptr, reinterpret_cast<UnsignedT*>(values),
+                                   arrow::internal::UnpackOptions{
+                                       static_cast<int>(num_elements), info.bit_width(),
+                                       /*bit_offset=*/0, readable_bytes},
+                                   unsigned_for);
+    }
+
+    read_ptr += packed_bytes;
+  } else {
+    // bit_width == 0 but has exceptions - fill with FOR
+    std::fill(values, values + num_elements, info.frame_of_reference());
+  }
+
+  // Step 4: Patch exceptions (stored as original values at their positions).
+  const PforConstants::ExceptionCountType num_exceptions = info.num_exceptions();
+  if (num_exceptions > 0) {
+    const uint8_t* positions_ptr = read_ptr;
+    read_ptr += num_exceptions * sizeof(PforConstants::PositionType);
+
+    const uint8_t* values_ptr = read_ptr;
+    read_ptr += num_exceptions * sizeof(T);
+
+    // Every position indexes `values`, so one past the end is an out-of-bounds
+    // write. Take the maximum first: a reduction still vectorizes, where a
+    // bounds check with an early return inside the patch loop would not.
+    PforConstants::PositionType max_position = 0;
+    for (PforConstants::ExceptionCountType i = 0; i < num_exceptions; ++i) {
+      max_position = std::max(
+          max_position,
+          bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::PositionType>(
+              positions_ptr + i * sizeof(PforConstants::PositionType))));
+    }
+    if (max_position >= num_elements) {
+      return Status::Invalid("PFOR exception position ", max_position,
+                             " is outside a vector of ", num_elements, " elements");
+    }
+
+    for (PforConstants::ExceptionCountType i = 0; i < num_exceptions; ++i) {
+      PforConstants::PositionType pos =
+          bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::PositionType>(
+              positions_ptr + i * sizeof(PforConstants::PositionType)));
+      T value =
+          bit_util::FromLittleEndian(util::SafeLoadAs<T>(values_ptr + i * sizeof(T)));
+      values[static_cast<size_t>(pos)] = value;
+    }
+  }
+
+  // Step 5: In a delta vector, everything above produced differences. Sum them.
+  //
+  // This has to come after the patch: an exception in a delta vector is a
+  // difference too, and summing before patching would carry the placeholder
+  // zero into every value that follows.
+  //
+  // The sum runs in the unsigned type. Signed overflow is undefined, and a
+  // column that spans the type's range will overflow -- the encoder took the
+  // differences the same way, so the bits round-trip exactly.
+  //
+  // TODO: fold this into the unpack kernel. The sum is one dependent add per
+  // value and uses no lanes, so it does not get faster with a narrower type the
+  // way the unpack does -- a scan across lanes plus a carry broadcast would
+  // shorten the serial chain. Only a vector with no exceptions can take that
+  // path, because patching has to happen between the frame add and the sum.
+  if (info.is_delta()) {
+    auto acc = static_cast<UnsignedT>(start_value);
+    for (int32_t i = 0; i < num_elements; ++i) {
+      acc += static_cast<UnsignedT>(values[i]);
+      std::memcpy(&values[i], &acc, sizeof(T));
+    }
+  }
+
+  return static_cast<int64_t>(read_ptr - data.data());
+}
+
+// ----------------------------------------------------------------------
+// Serialization helpers
+
+template <typename T>
+int64_t PforCompression<T>::SerializedVectorSize(const PforEncodedVector<T>& vec,
+                                                 int32_t num_elements) {
+  int64_t size = vec.info().stored_bytes();
+  if (vec.info().bit_width() > 0) {
+    size += bit_util::BytesForBits(static_cast<int64_t>(num_elements) *
+                                   vec.info().bit_width());
+  }
+  size += vec.info().num_exceptions() *
+          static_cast<int64_t>(sizeof(PforConstants::PositionType));
+  size += vec.info().num_exceptions() * static_cast<int64_t>(sizeof(T));
+  return size;
+}
+
+template <typename T>
+Result<int64_t> PforCompression<T>::SerializeVector(const PforEncodedVector<T>& vec,
+                                                    int32_t num_elements,
+                                                    std::span<uint8_t> dest) {
+  const int64_t needed = SerializedVectorSize(vec, num_elements);
+  if (static_cast<int64_t>(dest.size()) < needed) {
+    return Status::Invalid("PFOR vector needs ", needed, " bytes to serialize but only ",
+                           dest.size(), " remain");
+  }
+
+  // `needed` is computed from bit_width and num_exceptions, while the copies
+  // below take their lengths from the sections themselves, so a vector whose
+  // info disagrees with its sections would write past `needed` bytes.
+  const int64_t expected_packed_bytes =
+      vec.info().bit_width() > 0
+          ? bit_util::BytesForBits(static_cast<int64_t>(num_elements) *
+                                   vec.info().bit_width())
+          : 0;
+  if (static_cast<int64_t>(vec.packed_values().size()) != expected_packed_bytes) {
+    return Status::Invalid("PFOR vector has ", vec.packed_values().size(),
+                           " packed bytes but bit_width ",
+                           static_cast<int>(vec.info().bit_width()), " over ",
+                           num_elements, " elements needs ", expected_packed_bytes);
+  }
+  if (vec.exception_positions().size() != vec.info().num_exceptions() ||
+      vec.exception_values().size() != vec.info().num_exceptions()) {
+    return Status::Invalid("PFOR vector claims ", vec.info().num_exceptions(),
+                           " exceptions but carries ", vec.exception_positions().size(),
+                           " positions and ", vec.exception_values().size(), " values");
+  }
+
+  uint8_t* write_ptr = dest.data();
+
+  // Write vector info
+  vec.info().Store(std::span<uint8_t>(write_ptr, PforVectorInfo<T>::kStoredSize));
+  write_ptr += PforVectorInfo<T>::kStoredSize;
+
+  // Write the start value of a delta vector
+  if (vec.info().is_delta()) {
+    util::SafeStore(write_ptr, vec.start_value());
+    write_ptr += sizeof(T);
+  }
+
+  // Write packed values
+  if (vec.info().bit_width() > 0) {
+    std::memcpy(write_ptr, vec.packed_values().data(), vec.packed_values().size());
+    write_ptr += vec.packed_values().size();
+  }
+
+  // Write exception positions
+  if (vec.info().num_exceptions() > 0) {
+    StoreLittleEndianArray(vec.exception_positions().data(), vec.info().num_exceptions(),
+                           write_ptr);
+    write_ptr += vec.info().num_exceptions() * sizeof(PforConstants::PositionType);
+
+    // Write exception values (original integers)
+    StoreLittleEndianArray(vec.exception_values().data(), vec.info().num_exceptions(),
+                           write_ptr);
+    write_ptr += vec.info().num_exceptions() * sizeof(T);
+  }
+
+  return static_cast<int64_t>(write_ptr - dest.data());
+}
+
+// Explicit template instantiations
+template class PforCompression<int32_t>;
+template class PforCompression<int64_t>;
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_benchmark.cc b/cpp/src/arrow/util/pfor/pfor_benchmark.cc
new file mode 100644
index 000000000000..a9c034c00d9c
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_benchmark.cc
@@ -0,0 +1,626 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// PFOR encoding/decoding benchmarks.
+//
+// Data distributions cover the key archetypes that exercise PFOR's cost model
+// differently:
+//   - Constant: bit_width=0, best case
+//   - Sequential: small range, ideal FOR
+//   - SmallRange: clustered random, good FOR compression
+//   - HighBaseSmallRange: high absolute values, small delta range (timestamps)
+//   - WithOutliers: tests exception handling path
+//   - Random: worst case, full bit-width
+//   - TPC-DS DateSk/StoreSk/ItemSk/Quantity: realistic surrogate key distributions
+//
+// A second group covers columns with structure between neighbouring values, or
+// with a cluster the minimum is not part of. These are what separate a plan
+// that differences the values from one that packs them, and a frame of
+// reference placed by a search from one pinned to the minimum:
+//   - TrendJitter/EventMillis: timestamps, regular and bursty
+//   - Sawtooth: a climb cut by a halving, the case for patching both sides
+//   - MeasurementSeries/RandomWalk: bounded rate of change, no trend
+//   - SortedKeys/IdsWithGaps: monotonic, with and without jumps
+//   - SensorDropouts/LowSentinel: a low sentinel below the cluster
+//   - Bimodal: two clusters, so no one window covers the vector
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <numeric>
+#include <random>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+
+#include "arrow/util/logging.h"
+#include "arrow/util/pfor/pfor_internal.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+
+namespace arrow::util::pfor {
+namespace {
+
+// ======================================================================
+// Data Generators
+
+using Int32Gen = std::vector<int32_t> (*)(int64_t);
+using Int64Gen = std::vector<int64_t> (*)(int64_t);
+
+template <typename T>
+std::vector<T> GenConstant(int64_t n) {
+  return std::vector<T>(n, static_cast<T>(42));
+}
+
+template <typename T>
+std::vector<T> GenSequential(int64_t n) {
+  std::vector<T> v(n);
+  std::iota(v.begin(), v.end(), static_cast<T>(0));
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenSmallRange(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(100000, 200000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenHighBaseSmallRange(int64_t n) {
+  std::vector<T> v(n);
+  const T kBase = static_cast<T>(1704067200);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(0, 1000);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenWithOutliers(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(42);
+  std::uniform_int_distribution<T> small_dist(1000, 1255);
+  for (auto& x : v) x = small_dist(rng);
+  std::uniform_int_distribution<int64_t> pos_dist(0, n - 1);
+  int num_outliers = std::max(static_cast<int64_t>(1), n / 100);
+  for (int i = 0; i < num_outliers; ++i) {
+    v[pos_dist(rng)] = static_cast<T>(std::numeric_limits<T>::max() / 2 + i);
+  }
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenRandom(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(99);
+  std::uniform_int_distribution<T> dist(std::numeric_limits<T>::min(),
+                                        std::numeric_limits<T>::max());
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsSoldDateSk(int64_t n) {
+  std::vector<T> v(n);
+  const T kBase = 2450815;
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(0, 1820);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsStoreSk(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(1, 1000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsItemSk(int64_t n) {
+  std::vector<T> v(n);
+  const T kMax = 100000;
+  std::mt19937_64 rng(12345);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    T val = static_cast<T>(exp_dist(rng));
+    x = std::min(static_cast<T>(val + 1), kMax);
+  }
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsQuantity(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> small_dist(1, 10);
+  std::uniform_int_distribution<T> large_dist(11, 100);
+  std::uniform_int_distribution<int> chance(0, 99);
+  for (auto& x : v) {
+    x = (chance(rng) < 90) ? small_dist(rng) : large_dist(rng);
+  }
+  return v;
+}
+
+// ----------------------------------------------------------------------
+// Distributions with structure between neighbouring values, or with a
+// cluster the minimum is not part of. The generators above are all either
+// unordered or perfectly regular, so none of them separates a plan that
+// differences from one that does not, and none of them puts the frame of
+// reference anywhere but the minimum.
+
+/// A timestamp column with a fixed sampling interval and jitter: the
+/// differences cluster tightly around the interval, the values do not.
+template <typename T>
+std::vector<T> GenTrendJitter(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(7);
+  std::normal_distribution<double> jitter(0.0, 40.0);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += 3.0;
+    x = static_cast<T>(t + jitter(rng));
+  }
+  return v;
+}
+
+/// A TCP congestion window: a linear climb cut by a sharp halving. Almost
+/// every difference is the same small number and a few are large and
+/// negative, which is the shape a two-sided frame plus patching handles at
+/// close to no cost and a one-sided one cannot.
+template <typename T>
+std::vector<T> GenSawtooth(int64_t n) {
+  std::vector<T> v(n);
+  T cur = 1000;
+  for (int64_t i = 0; i < n; ++i) {
+    if (i % 200 == 199) {
+      cur /= 2;
+    } else {
+      cur += 12;
+    }
+    v[i] = cur;
+  }
+  return v;
+}
+
+/// A continuous quantity sampled over time, so the rate of change is bounded
+/// but the level wanders: differencing wins, though not by much.
+template <typename T>
+std::vector<T> GenMeasurement(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(11);
+  std::normal_distribution<double> noise(0.0, 1.0);
+  double level = 0.0;
+  double rate = 0.0;
+  for (int64_t i = 0; i < n; ++i) {
+    rate = 0.95 * rate + noise(rng);
+    level += rate;
+    v[i] = static_cast<T>(4000.0 * level / 50.0) + static_cast<T>(500000);
+  }
+  return v;
+}
+
+/// A sorted surrogate key column, which is what a clustered index or a
+/// sorted-by-key file produces.
+template <typename T>
+std::vector<T> GenSortedKeys(int64_t n) {
+  auto v = GenTpcdsItemSk<T>(n);
+  std::sort(v.begin(), v.end());
+  return v;
+}
+
+/// A measurement series punctuated by a low sentinel standing in for "no
+/// reading". The sentinel sits far below the cluster, so a frame pinned to
+/// the minimum has to widen to reach it and no value can ever be patched.
+template <typename T>
+std::vector<T> GenSensorDropouts(int64_t n) {
+  auto v = GenMeasurement<T>(n);
+  std::mt19937_64 rng(3);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-999999);
+  }
+  return v;
+}
+
+/// Monotonic ids with occasional large jumps, as a sequence shared between
+/// writers or restarted produces.
+template <typename T>
+std::vector<T> GenIdsWithGaps(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(5);
+  std::uniform_int_distribution<int> step(1, 6);
+  std::uniform_int_distribution<int> jump(0, 199);
+  T cur = 1000000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    if (jump(rng) == 0) cur += 100000;
+    x = cur;
+  }
+  return v;
+}
+
+/// Prices on a random walk: small signed steps around a high base, and no
+/// trend for the differences to line up on.
+template <typename T>
+std::vector<T> GenRandomWalk(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(13);
+  std::uniform_int_distribution<int> step(-25, 25);
+  T cur = 1500000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    x = cur;
+  }
+  return v;
+}
+
+/// Event arrival times in milliseconds since the epoch, bursty, so the gaps
+/// are skewed rather than clustered.
+template <typename T>
+std::vector<T> GenEventMillis(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(17);
+  std::exponential_distribution<double> gap(0.4);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = static_cast<T>(t);
+  }
+  return v;
+}
+
+/// A tight unordered cluster with a low "missing" sentinel: the frame cannot
+/// sit at the minimum and differencing has nothing to exploit either, so
+/// this is the column that has to come out no worse than before.
+template <typename T>
+std::vector<T> GenLowSentinel(int64_t n) {
+  auto v = GenSmallRange<T>(n);
+  std::mt19937_64 rng(23);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-1000);
+  }
+  return v;
+}
+
+/// Two interleaved clusters far apart, so no single window covers the vector
+/// and the cheaper cluster is worth framing on its own.
+template <typename T>
+std::vector<T> GenBimodal(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(19);
+  std::uniform_int_distribution<T> lo(1000, 1100);
+  std::uniform_int_distribution<T> hi(900000, 900100);
+  std::uniform_int_distribution<int> pick(0, 9);
+  for (auto& x : v) {
+    x = pick(rng) < 8 ? lo(rng) : hi(rng);
+  }
+  return v;
+}
+
+// ======================================================================
+// Benchmark Core
+
+template <typename T>
+void BM_PforEncodeImpl(benchmark::State& state, std::vector<T> (*generator)(int64_t),
+                       PackingMode mode = PackingMode::kForBitPack) {
+  const int64_t num_values = state.range(0);
+  auto values = generator(num_values);
+
+  int64_t max_size =
+      PforWrapper<T>::GetMaxCompressedSize(static_cast<int32_t>(num_values)).ValueOrDie();
+  std::vector<uint8_t> compressed(max_size);
+
+  for (auto _ : state) {
+    int64_t comp_size = max_size;
+    ARROW_CHECK_OK(PforWrapper<T>::Encode(values.data(), num_values, compressed.data(),
+                                          &comp_size, mode));
+    benchmark::DoNotOptimize(comp_size);
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * num_values *
+                          static_cast<int64_t>(sizeof(T)));
+  state.SetItemsProcessed(state.iterations() * num_values);
+
+  // Report compression ratio
+  int64_t comp_size = max_size;
+  ARROW_CHECK_OK(PforWrapper<T>::Encode(values.data(), num_values, compressed.data(),
+                                        &comp_size, mode));
+  state.counters["CompRatio%"] =
+      benchmark::Counter(100.0 * static_cast<double>(comp_size) /
+                         static_cast<double>(num_values * sizeof(T)));
+}
+
+template <typename T>
+void BM_PforDecodeImpl(benchmark::State& state, std::vector<T> (*generator)(int64_t),
+                       PackingMode mode = PackingMode::kForBitPack) {
+  const int64_t num_values = state.range(0);
+  auto values = generator(num_values);
+
+  int64_t max_size =
+      PforWrapper<T>::GetMaxCompressedSize(static_cast<int32_t>(num_values)).ValueOrDie();
+  std::vector<uint8_t> compressed(max_size);
+  int64_t comp_size = max_size;
+  ARROW_CHECK_OK(PforWrapper<T>::Encode(values.data(), num_values, compressed.data(),
+                                        &comp_size, mode));
+
+  std::vector<T> decoded(num_values);
+
+  for (auto _ : state) {
+    ARROW_CHECK_OK(
+        PforWrapper<T>::Decode(compressed.data(), comp_size, num_values, decoded.data()));
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * num_values *
+                          static_cast<int64_t>(sizeof(T)));
+  state.SetItemsProcessed(state.iterations() * num_values);
+}
+
+// ======================================================================
+// Non-template wrappers to avoid comma-in-macro issues with BENCHMARK_CAPTURE
+
+void BM_PforEncodeInt32(benchmark::State& state, Int32Gen gen) {
+  BM_PforEncodeImpl<int32_t>(state, gen);
+}
+void BM_PforDecodeInt32(benchmark::State& state, Int32Gen gen) {
+  BM_PforDecodeImpl<int32_t>(state, gen);
+}
+// The lane-interleaved layout, for a paired comparison against the two arms
+// above. Only 32-bit values reach it, so there is no int64 counterpart.
+void BM_PforEncodeInt32Interleaved(benchmark::State& state, Int32Gen gen) {
+  BM_PforEncodeImpl<int32_t>(state, gen, PackingMode::kForBitPackInterleaved);
+}
+void BM_PforDecodeInt32Interleaved(benchmark::State& state, Int32Gen gen) {
+  BM_PforDecodeImpl<int32_t>(state, gen, PackingMode::kForBitPackInterleaved);
+}
+void BM_PforEncodeInt64(benchmark::State& state, Int64Gen gen) {
+  BM_PforEncodeImpl<int64_t>(state, gen);
+}
+void BM_PforDecodeInt64(benchmark::State& state, Int64Gen gen) {
+  BM_PforDecodeImpl<int64_t>(state, gen);
+}
+
+// ======================================================================
+// Benchmark sizes: one vector, 10K, a default page (max_rows_per_page), 100K, 1M
+
+static void CustomArgs(benchmark::internal::Benchmark* b) {
+  for (int64_t n : {1024, 10240, 20000, 102400, 1048576}) {
+    b->Arg(n);
+  }
+}
+
+// ======================================================================
+// INT32 Encode
+
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, Constant, &GenConstant<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, Sequential, &GenSequential<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, SmallRange, &GenSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, HighBaseSmallRange, &GenHighBaseSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, WithOutliers, &GenWithOutliers<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, Random, &GenRandom<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, TpcdsSoldDateSk, &GenTpcdsSoldDateSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, TpcdsStoreSk, &GenTpcdsStoreSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, TpcdsItemSk, &GenTpcdsItemSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, TpcdsQuantity, &GenTpcdsQuantity<int32_t>)
+    ->Apply(CustomArgs);
+
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, TrendJitter, &GenTrendJitter<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, Sawtooth, &GenSawtooth<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, MeasurementSeries, &GenMeasurement<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, SortedKeys, &GenSortedKeys<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, SensorDropouts, &GenSensorDropouts<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, IdsWithGaps, &GenIdsWithGaps<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, RandomWalk, &GenRandomWalk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, EventMillis, &GenEventMillis<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, LowSentinel, &GenLowSentinel<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, Bimodal, &GenBimodal<int32_t>)->Apply(CustomArgs);
+
+// INT32 Decode
+
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, Constant, &GenConstant<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, Sequential, &GenSequential<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, SmallRange, &GenSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, HighBaseSmallRange, &GenHighBaseSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, WithOutliers, &GenWithOutliers<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, Random, &GenRandom<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, TpcdsSoldDateSk, &GenTpcdsSoldDateSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, TpcdsStoreSk, &GenTpcdsStoreSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, TpcdsItemSk, &GenTpcdsItemSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, TpcdsQuantity, &GenTpcdsQuantity<int32_t>)
+    ->Apply(CustomArgs);
+
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, TrendJitter, &GenTrendJitter<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, Sawtooth, &GenSawtooth<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, MeasurementSeries, &GenMeasurement<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, SortedKeys, &GenSortedKeys<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, SensorDropouts, &GenSensorDropouts<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, IdsWithGaps, &GenIdsWithGaps<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, RandomWalk, &GenRandomWalk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, EventMillis, &GenEventMillis<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, LowSentinel, &GenLowSentinel<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, Bimodal, &GenBimodal<int32_t>)->Apply(CustomArgs);
+
+// ======================================================================
+// INT64 Encode
+
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, Constant, &GenConstant<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, Sequential, &GenSequential<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, SmallRange, &GenSmallRange<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, HighBaseSmallRange, &GenHighBaseSmallRange<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, WithOutliers, &GenWithOutliers<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, Random, &GenRandom<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, TpcdsSoldDateSk, &GenTpcdsSoldDateSk<int64_t>)
+    ->Apply(CustomArgs);
+
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, TrendJitter, &GenTrendJitter<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, Sawtooth, &GenSawtooth<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, MeasurementSeries, &GenMeasurement<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, SortedKeys, &GenSortedKeys<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, SensorDropouts, &GenSensorDropouts<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, IdsWithGaps, &GenIdsWithGaps<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, RandomWalk, &GenRandomWalk<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, EventMillis, &GenEventMillis<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, LowSentinel, &GenLowSentinel<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, Bimodal, &GenBimodal<int64_t>)->Apply(CustomArgs);
+
+// INT64 Decode
+
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, Constant, &GenConstant<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, Sequential, &GenSequential<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, SmallRange, &GenSmallRange<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, HighBaseSmallRange, &GenHighBaseSmallRange<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, WithOutliers, &GenWithOutliers<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, Random, &GenRandom<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, TpcdsSoldDateSk, &GenTpcdsSoldDateSk<int64_t>)
+    ->Apply(CustomArgs);
+
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, TrendJitter, &GenTrendJitter<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, Sawtooth, &GenSawtooth<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, MeasurementSeries, &GenMeasurement<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, SortedKeys, &GenSortedKeys<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, SensorDropouts, &GenSensorDropouts<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, IdsWithGaps, &GenIdsWithGaps<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, RandomWalk, &GenRandomWalk<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, EventMillis, &GenEventMillis<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, LowSentinel, &GenLowSentinel<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, Bimodal, &GenBimodal<int64_t>)->Apply(CustomArgs);
+
+// ======================================================================
+// INT32 with the lane-interleaved bit-packing layout
+//
+// Every size here is a multiple of the 1024-value vector, so each vector is
+// packed interleaved rather than sequentially. Compare each arm against the
+// same distribution above: CompRatio% should match to the byte, because the
+// two layouts write the same number of bits.
+
+// Interleaved Encode
+
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, Constant, &GenConstant<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, Sequential, &GenSequential<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, SmallRange, &GenSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, HighBaseSmallRange,
+                  &GenHighBaseSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, WithOutliers, &GenWithOutliers<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, Random, &GenRandom<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, TpcdsSoldDateSk,
+                  &GenTpcdsSoldDateSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, TpcdsStoreSk, &GenTpcdsStoreSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, TpcdsItemSk, &GenTpcdsItemSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, TpcdsQuantity,
+                  &GenTpcdsQuantity<int32_t>)
+    ->Apply(CustomArgs);
+
+// Interleaved Decode
+
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, Constant, &GenConstant<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, Sequential, &GenSequential<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, SmallRange, &GenSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, HighBaseSmallRange,
+                  &GenHighBaseSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, WithOutliers, &GenWithOutliers<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, Random, &GenRandom<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, TpcdsSoldDateSk,
+                  &GenTpcdsSoldDateSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, TpcdsStoreSk, &GenTpcdsStoreSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, TpcdsItemSk, &GenTpcdsItemSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, TpcdsQuantity,
+                  &GenTpcdsQuantity<int32_t>)
+    ->Apply(CustomArgs);
+
+}  // namespace
+}  // namespace arrow::util::pfor
diff --git a/cpp/src/arrow/util/pfor/pfor_constants_internal.h b/cpp/src/arrow/util/pfor/pfor_constants_internal.h
new file mode 100644
index 000000000000..346c775449eb
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_constants_internal.h
@@ -0,0 +1,133 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Constants for PFOR (Patched Frame of Reference) compression
+
+#pragma once
+
+#include <bit>
+#include <cstdint>
+#include <type_traits>
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+/// \brief Constants used throughout PFOR compression
+class PforConstants {
+ public:
+  /// Number of elements compressed together as a unit.
+  static constexpr int64_t kPforVectorSize = 1024;
+
+  /// log2(kPforVectorSize)
+  static constexpr uint8_t kDefaultLogVectorSize = 10;
+
+  /// Minimum allowed log vector size
+  static constexpr uint8_t kMinLogVectorSize = 3;
+
+  /// Maximum allowed log vector size
+  static constexpr uint8_t kMaxLogVectorSize = 15;
+
+  /// Type used to store vector data offsets (supports pages up to 4GB)
+  using OffsetType = uint32_t;
+
+  /// Type used to store exception positions within a compressed vector.
+  using PositionType = uint16_t;
+
+  /// Type used to store the number of exceptions in a compressed vector.
+  ///
+  /// Unsigned: a vector holds up to 2^kMaxLogVectorSize elements and every one
+  /// of them can be an exception, so a count of 32768 has to be representable.
+  using ExceptionCountType = uint16_t;
+
+  /// Largest vector the format allows, in elements.
+  static constexpr int32_t kMaxVectorSize = 1 << kMaxLogVectorSize;
+
+  /// Page header size in bytes: packing_mode, log_vector_size and
+  /// value_byte_width one byte each, then num_elements. Derived from the field
+  /// types rather than written out, so that widening a field cannot leave the
+  /// constant behind; StoreHeader and LoadHeader are the two readers of it.
+  static constexpr int64_t kHeaderSize =
+      sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint8_t) + sizeof(int32_t);
+};
+
+/// \brief Layout of the bit-packed payload, recorded in the page header.
+///
+/// One byte per page, not per vector: a reader picks its unpacking kernel once
+/// and the choice is uniform for the page, which is also what makes a reader
+/// that does not implement a layout able to reject the page up front instead of
+/// misreading it.
+enum class PackingMode : uint8_t {
+  /// Frame of reference plus a sequential little-endian bit-packed stream --
+  /// the layout every Parquet implementation already has, expanded here by
+  /// arrow::internal::unpack. Values of a vector occupy consecutive bit
+  /// positions in stream order.
+  kForBitPack = 0,
+
+  /// Frame of reference plus the lane-interleaved container from FastLanes
+  /// (Afroozeh & Boncz, VLDB '23), packed by arrow::util::fastlanes. Same
+  /// payload size as kForBitPack and the same value order on the way out; the
+  /// bits of one vector are distributed across 32 lanes so that a register load
+  /// brings in values the unpacker needs together.
+  ///
+  /// Only legal for a page whose vector size is exactly the interleaved block
+  /// size (1024) and whose values are 4 bytes wide. A vector shorter than a
+  /// full block -- which is to say the tail vector of a page -- uses
+  /// kForBitPack, so a page mixes the two, and the decoder derives which is
+  /// which from the element count rather than reading a per-vector flag.
+  kForBitPackInterleaved = 1,
+};
+
+/// \brief Whether `mode` names a layout this build can read and write.
+inline bool IsSupportedPackingMode(uint8_t mode) {
+  return mode == static_cast<uint8_t>(PackingMode::kForBitPack) ||
+         mode == static_cast<uint8_t>(PackingMode::kForBitPackInterleaved);
+}
+
+/// \brief Type traits for PFOR integer types
+template <typename T>
+struct PforTypeTraits {};
+
+template <>
+struct PforTypeTraits<int32_t> {
+  using UnsignedType = uint32_t;
+  static constexpr uint8_t kMaxBitWidth = 32;
+  /// PforVectorInfo size: frame of reference, bit-width byte, exception count.
+  static constexpr int64_t kVectorInfoSize =
+      sizeof(int32_t) + sizeof(uint8_t) + sizeof(PforConstants::ExceptionCountType);
+
+  static uint8_t BitsRequired(uint32_t value) {
+    return static_cast<uint8_t>(std::bit_width(value));
+  }
+};
+
+template <>
+struct PforTypeTraits<int64_t> {
+  using UnsignedType = uint64_t;
+  static constexpr uint8_t kMaxBitWidth = 64;
+  /// PforVectorInfo size: frame of reference, bit-width byte, exception count.
+  static constexpr int64_t kVectorInfoSize =
+      sizeof(int64_t) + sizeof(uint8_t) + sizeof(PforConstants::ExceptionCountType);
+
+  static uint8_t BitsRequired(uint64_t value) {
+    return static_cast<uint8_t>(std::bit_width(value));
+  }
+};
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_internal.h b/cpp/src/arrow/util/pfor/pfor_internal.h
new file mode 100644
index 000000000000..5236c66b06a5
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_internal.h
@@ -0,0 +1,317 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Core PFOR (Patched Frame of Reference) compression algorithm
+//
+// PFOR compresses integer columns by:
+//   1. Subtracting the minimum value (Frame of Reference)
+//   2. Choosing an optimal bit width via a cost model
+//   3. Bit-packing the deltas at the chosen width
+//   4. Storing outlier values (exceptions) separately
+
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include <span>
+#include <vector>
+
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/endian.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/pfor/pfor_constants_internal.h"
+#include "arrow/util/pfor/pfor_plan_internal.h"
+#include "arrow/util/ubsan.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+// ----------------------------------------------------------------------
+// Layout applicability
+
+/// \brief Whether the interleaved layout covers a vector of this size and type.
+///
+/// The interleaved container is defined for one block of 1024 four-byte values.
+/// Anything else -- a 64-bit column, or the short tail vector of a page whose
+/// length is not a multiple of the vector size -- takes the sequential layout.
+/// So a page can hold both, and neither side needs a per-vector flag to say
+/// which: the element count answers it, and encoder and decoder ask the same
+/// question of the same number.
+template <typename T>
+constexpr bool InterleavedApplies(PackingMode mode, int32_t num_elements) {
+  return mode == PackingMode::kForBitPackInterleaved && sizeof(T) == 4 &&
+         num_elements == static_cast<int32_t>(PforConstants::kPforVectorSize);
+}
+
+// ----------------------------------------------------------------------
+// Per-vector metadata
+
+/// \brief PFOR vector metadata stored at the start of each compressed vector.
+///
+/// For INT32 (7 bytes): [frame_of_reference(4B)] [bit_width(1B)] [num_exceptions(2B)]
+/// For INT64 (11 bytes): [frame_of_reference(8B)] [bit_width(1B)] [num_exceptions(2B)]
+///
+/// num_exceptions is unsigned: a vector holds up to kMaxVectorSize elements,
+/// so the count has to reach 32768, which a signed 16-bit field cannot hold.
+/// Its wire type is PforConstants::ExceptionCountType.
+///
+/// The bit_width byte stores the actual bit width in bits 0..6 and the delta
+/// flag in bit 7. A vector with the flag set packs the backward differences of
+/// its values rather than the values, and carries one extra full-width field
+/// after this info block -- the vector's first value -- so that it still
+/// decodes without reading the vector before it.
+///
+/// The flag is deliberately a bit of its own rather than another code in a
+/// mode field: differencing is orthogonal to how the payload is laid out, so
+/// the two have to be able to combine.
+///
+/// Seven bits, not six: the range is 0..64 inclusive, and 64 does not fit in
+/// six. A 6-bit mask stored an INT64 vector whose deltas need the full 64 bits
+/// as width 0, and since such a vector has no exceptions either, Load reported
+/// a constant vector and the decoder filled the output with the frame of
+/// reference -- silently, with no error and no size mismatch.
+template <typename T>
+class PforVectorInfo {
+ public:
+  static constexpr uint8_t kBitWidthMask = 0x7F;
+  static constexpr uint8_t kDeltaFlag = 0x80;
+
+  PforVectorInfo() = default;
+  PforVectorInfo(T frame_of_reference, uint8_t bit_width,
+                 PforConstants::ExceptionCountType num_exceptions, bool is_delta = false)
+      : frame_of_reference_(frame_of_reference),
+        bit_width_(bit_width),
+        num_exceptions_(num_exceptions),
+        is_delta_(is_delta) {}
+
+  T frame_of_reference() const { return frame_of_reference_; }
+  uint8_t bit_width() const { return bit_width_; }
+  PforConstants::ExceptionCountType num_exceptions() const { return num_exceptions_; }
+  bool is_delta() const { return is_delta_; }
+
+  void set_frame_of_reference(T frame_of_reference) {
+    frame_of_reference_ = frame_of_reference;
+  }
+  void set_bit_width(uint8_t bit_width) { bit_width_ = bit_width; }
+  void set_num_exceptions(PforConstants::ExceptionCountType num_exceptions) {
+    num_exceptions_ = num_exceptions;
+  }
+  void set_is_delta(bool is_delta) { is_delta_ = is_delta; }
+
+  /// \brief Bytes this info occupies on the wire, start value included.
+  ///
+  /// Not a constant: the start value is only present on a delta vector. Paying
+  /// for it unconditionally would be free at a 1024-value vector and ruinous at
+  /// the smallest one the format allows (kMinLogVectorSize is 3, where eight
+  /// bytes across eight values is a byte per value).
+  int64_t stored_bytes() const {
+    return kStoredSize + (is_delta_ ? static_cast<int64_t>(sizeof(T)) : 0);
+  }
+
+  /// \brief Store this info to a byte buffer (little-endian)
+  void Store(std::span<uint8_t> dest) const {
+    // A width above the type's maximum would lose its high bits to the mask and
+    // set the delta flag on the way out, turning an encoder bug into a page that
+    // decodes to the wrong values with no error anywhere. Load rejects such a
+    // width on the way in; this catches it on the way out, where the bug is.
+    ARROW_DCHECK_LE(bit_width_, PforTypeTraits<T>::kMaxBitWidth);
+    uint8_t* ptr = dest.data();
+    util::SafeStore(ptr, bit_util::ToLittleEndian(frame_of_reference_));
+    // bits 0..6 = bit width; bit 7 = delta flag.
+    ptr[sizeof(T)] =
+        static_cast<uint8_t>((bit_width_ & kBitWidthMask) | (is_delta_ ? kDeltaFlag : 0));
+    util::SafeStore(ptr + sizeof(T) + 1, bit_util::ToLittleEndian(num_exceptions_));
+  }
+
+  /// \brief Load this info from a byte buffer (little-endian)
+  static Result<PforVectorInfo> Load(std::span<const uint8_t> src) {
+    if (src.size() < static_cast<size_t>(kStoredSize)) {
+      return Status::Invalid("PFOR vector info buffer too small: ", src.size(), " < ",
+                             kStoredSize);
+    }
+    PforVectorInfo info;
+    const uint8_t* ptr = src.data();
+    info.frame_of_reference_ = bit_util::FromLittleEndian(util::SafeLoadAs<T>(ptr));
+    const uint8_t packed_bit_width = ptr[sizeof(T)];
+    info.bit_width_ = static_cast<uint8_t>(packed_bit_width & kBitWidthMask);
+    info.is_delta_ = (packed_bit_width & kDeltaFlag) != 0;
+    info.num_exceptions_ = bit_util::FromLittleEndian(
+        util::SafeLoadAs<PforConstants::ExceptionCountType>(ptr + sizeof(T) + 1));
+    if (info.bit_width_ > PforTypeTraits<T>::kMaxBitWidth) {
+      return Status::Invalid("PFOR bit_width out of range: ",
+                             static_cast<int>(info.bit_width_));
+    }
+    if (info.num_exceptions_ > PforConstants::kMaxVectorSize) {
+      return Status::Invalid("PFOR num_exceptions exceeds the maximum vector size: ",
+                             info.num_exceptions_);
+    }
+    return info;
+  }
+
+  /// \brief Serialized size in bytes
+  static constexpr int64_t kStoredSize = PforTypeTraits<T>::kVectorInfoSize;
+
+ private:
+  T frame_of_reference_ = 0;
+  uint8_t bit_width_ = 0;
+  PforConstants::ExceptionCountType num_exceptions_ = 0;
+  bool is_delta_ = false;
+
+  // is_delta_ rides in a spare bit of the bit-width byte, so it adds nothing to
+  // the stored size.
+  static_assert(kStoredSize == sizeof(frame_of_reference_) + sizeof(bit_width_) +
+                                   sizeof(num_exceptions_),
+                "kStoredSize must match the fields Store writes and Load reads");
+};
+
+// ----------------------------------------------------------------------
+// Encoded vector representation
+
+/// \brief A PFOR-encoded vector with all its data sections
+template <typename T>
+class PforEncodedVector {
+ public:
+  PforEncodedVector() = default;
+
+  const PforVectorInfo<T>& info() const { return info_; }
+  PforVectorInfo<T>& mutable_info() { return info_; }
+  void set_info(const PforVectorInfo<T>& info) { info_ = info; }
+
+  const std::vector<uint8_t>& packed_values() const { return packed_values_; }
+  std::vector<uint8_t>& mutable_packed_values() { return packed_values_; }
+  void set_packed_values(std::vector<uint8_t> v) { packed_values_ = std::move(v); }
+
+  const std::vector<PforConstants::PositionType>& exception_positions() const {
+    return exception_positions_;
+  }
+  std::vector<PforConstants::PositionType>& mutable_exception_positions() {
+    return exception_positions_;
+  }
+  void set_exception_positions(std::vector<PforConstants::PositionType> v) {
+    exception_positions_ = std::move(v);
+  }
+
+  const std::vector<T>& exception_values() const { return exception_values_; }
+  std::vector<T>& mutable_exception_values() { return exception_values_; }
+  void set_exception_values(std::vector<T> v) { exception_values_ = std::move(v); }
+
+  /// \brief First value of the vector; stored only when info().is_delta().
+  T start_value() const { return start_value_; }
+  void set_start_value(T start_value) { start_value_ = start_value; }
+
+ private:
+  PforVectorInfo<T> info_;
+  T start_value_ = 0;
+  std::vector<uint8_t> packed_values_;
+  std::vector<PforConstants::PositionType> exception_positions_;
+  std::vector<T> exception_values_;
+};
+
+// ----------------------------------------------------------------------
+// Core compression/decompression
+
+/// \brief What the encoder is allowed to do, for one page.
+///
+/// Nothing here changes how a page is read: a decoder is told which mode each
+/// vector used by the vector's own header, so turning a mode off only narrows
+/// what the encoder will choose, and pages written either way read the same.
+struct PforEncodeOptions {
+  PforEncodeOptions() = default;
+  /// Implicit, so a caller that only cares about the layout can pass a bare
+  /// mode rather than spelling out the whole struct.
+  PforEncodeOptions(PackingMode mode) : mode(mode) {}  // NOLINT(runtime/explicit)
+  PforEncodeOptions(bool delta_enabled, PackingMode mode)
+      : delta_enabled(delta_enabled), mode(mode) {}
+
+  /// Let the planner difference a vector when its cost model prefers that.
+  bool delta_enabled = true;
+
+  /// Layout for the bit-packed payload. Advisory:
+  /// PackingMode::kForBitPackInterleaved is honoured only when
+  /// InterleavedApplies<T>() holds for this vector, and the sequential layout
+  /// is used otherwise. The caller cannot tell from the returned vector which
+  /// was used -- the page header records the request and the decoder
+  /// re-derives the same answer.
+  PackingMode mode = PackingMode::kForBitPack;
+};
+
+/// \brief PFOR compression and decompression algorithms
+///
+/// \tparam T the integer type (int32_t or int64_t)
+template <typename T>
+class PforCompression {
+ public:
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+
+  /// \brief Find the optimal bit width using the cost model
+  ///
+  /// Evaluates every candidate bit width and selects the one that
+  /// minimizes total encoded size (packing cost + exception cost).
+  ///
+  /// \param[in] deltas unsigned deltas after FOR subtraction
+  /// \param[in] num_elements number of elements
+  /// \return the optimal bit width and exception count
+  static BitWidthResult FindOptimalBitWidth(const UnsignedT* deltas,
+                                            int32_t num_elements);
+
+  /// \brief Encode a single vector of integers
+  ///
+  /// The cost model decides per vector whether to difference the values first
+  /// and where to put the frame of reference; see ChooseVectorPlan.
+  ///
+  /// \param[in] values input integer values
+  /// \param[in] num_elements number of elements (up to vector_size)
+  /// \param[in] options what the encoder is allowed to choose: whether to
+  ///            difference the vector, and which bit-packing layout to use
+  /// \pre num_elements > 0; there is no frame of reference for an empty vector
+  /// \return the encoded vector with all sections
+  static PforEncodedVector<T> EncodeVector(const T* values, int32_t num_elements,
+                                           const PforEncodeOptions& options = {});
+
+  /// \brief Decode a single vector from compressed data
+  ///
+  /// \param[in] data span over the compressed vector data
+  /// \param[in] num_elements number of elements in this vector
+  /// \param[out] values output buffer for num_elements decoded integers
+  /// \param[in] mode the layout the page header declares. Must be the mode the
+  ///            encoder was given: the two layouts produce payloads of the same
+  ///            size, so reading one as the other yields wrong values rather
+  ///            than a length error.
+  /// \return number of bytes consumed from data, or error
+  static Result<int64_t> DecodeVector(std::span<const uint8_t> data, int32_t num_elements,
+                                      T* values,
+                                      PackingMode mode = PackingMode::kForBitPack);
+
+  /// \brief Calculate the serialized size of an encoded vector
+  static int64_t SerializedVectorSize(const PforEncodedVector<T>& vec,
+                                      int32_t num_elements);
+
+  /// \brief Serialize an encoded vector to a byte buffer
+  ///
+  /// \param[in] vec the encoded vector
+  /// \param[in] num_elements number of elements
+  /// \param[out] dest output buffer, at least SerializedVectorSize() bytes
+  /// \return number of bytes written, or an error if `dest` is too small
+  static Result<int64_t> SerializeVector(const PforEncodedVector<T>& vec,
+                                         int32_t num_elements, std::span<uint8_t> dest);
+};
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_plan_internal.h b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
new file mode 100644
index 000000000000..1aa6350226d5
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
@@ -0,0 +1,559 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// PFOR encoder decision logic: what to do with one vector.
+//
+// The encoder chooses three things per vector, and this header holds the
+// search over all three:
+//
+//   1. whether to difference the values first (the delta mode),
+//   2. the frame of reference, which is not required to be the minimum,
+//   3. the bit width, from the existing histogram cost model.
+//
+// Kept apart from pfor.h, and free of every Arrow dependency, so the same
+// decision code can be linked into a standalone size study without building
+// the library. Nothing here touches bytes on the wire; pfor.cc does that.
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/util/pfor/pfor_constants_internal.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+/// \brief Result of the optimal bit width search
+struct BitWidthResult {
+  uint8_t bit_width = 0;
+  PforConstants::ExceptionCountType num_exceptions = 0;
+};
+
+/// \brief Bits an exception costs: its position plus a full-width value.
+template <typename T>
+constexpr int64_t ExceptionBits() {
+  return static_cast<int64_t>(sizeof(PforConstants::PositionType)) * 8 +
+         static_cast<int64_t>(sizeof(T)) * 8;
+}
+
+// ----------------------------------------------------------------------
+// Bit width search
+
+/// \brief Histogram of the bit widths needed by `values` reduced by `frame`.
+///
+/// out[b] counts the offsets that need exactly b bits. The subtraction is
+/// modular in the unsigned type, so a value below the frame wraps to a huge
+/// offset and lands in the top bin -- which is what makes a frame above the
+/// minimum work at all: below-frame values are counted as exceptions here and
+/// then patched on the way out, with no separate sign or direction to track.
+template <typename T>
+void BuildOffsetHistogram(const T* values, int32_t num_elements, T frame,
+                          std::array<int32_t, 65>* out) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  const auto unsigned_frame = static_cast<UnsignedT>(frame);
+
+  // Four independent accumulators so repeated bins do not serialize the
+  // read-modify-write and the load->clz->bump chains overlap. This loop is
+  // ~half of encode time; a single array runs scalar and stalls.
+  std::array<int32_t, 65> h0{}, h1{}, h2{}, h3{};
+  int32_t i = 0;
+  for (; i + 4 <= num_elements; i += 4) {
+    ++h0[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i]) -
+                                         unsigned_frame)];
+    ++h1[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i + 1]) -
+                                         unsigned_frame)];
+    ++h2[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i + 2]) -
+                                         unsigned_frame)];
+    ++h3[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i + 3]) -
+                                         unsigned_frame)];
+  }
+  for (; i < num_elements; ++i) {
+    ++h0[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i]) -
+                                         unsigned_frame)];
+  }
+  for (int b = 0; b <= 64; ++b) (*out)[b] = h0[b] + h1[b] + h2[b] + h3[b];
+}
+
+/// \brief Pick the width that minimises packed bits plus exception bits.
+///
+/// \param[in] histogram output of BuildOffsetHistogram
+/// \param[in] num_elements number of elements the histogram covers
+/// \param[out] cost_bits total cost of the winning width
+template <typename T>
+BitWidthResult BestWidthFromHistogram(const std::array<int32_t, 65>& histogram,
+                                      int32_t num_elements, int64_t* cost_bits) {
+  constexpr uint8_t max_bits = PforTypeTraits<T>::kMaxBitWidth;
+
+  int64_t best_cost = std::numeric_limits<int64_t>::max();
+  uint8_t best_bit_width = max_bits;
+  PforConstants::ExceptionCountType best_num_exceptions = 0;
+
+  int64_t exceptions_above = num_elements;
+  for (uint8_t b = 0; b <= max_bits; ++b) {
+    exceptions_above -= histogram[b];
+
+    // A vector holds at most kMaxVectorSize elements, so that is also the most
+    // exceptions one can name. Skipping the wider counts keeps the cast below
+    // exact; the full-width candidate has none at all, so a best is always
+    // found.
+    if (exceptions_above > PforConstants::kMaxVectorSize) continue;
+
+    const int64_t total_cost =
+        static_cast<int64_t>(num_elements) * b + exceptions_above * ExceptionBits<T>();
+    if (total_cost < best_cost) {
+      best_cost = total_cost;
+      best_bit_width = b;
+      best_num_exceptions =
+          static_cast<PforConstants::ExceptionCountType>(exceptions_above);
+    }
+  }
+
+  *cost_bits = best_cost;
+  return {best_bit_width, best_num_exceptions};
+}
+
+/// Bucket count used by the frame search, as a shift and as a count. 256 keeps
+/// the scan in ChooseFrameAndWidth at roughly two passes' worth of work over a
+/// 1024-value vector.
+constexpr int32_t kFrameSearchBits = 8;
+constexpr int32_t kFrameSearchBuckets = 1 << kFrameSearchBits;
+
+/// \brief One walk producing both histograms the frame search needs.
+///
+/// The bit-width histogram costs the frame it is given; the bucket counts cost
+/// every other frame. They are gathered together because each needs the same
+/// offset, and computing that offset twice was measurably the larger half of
+/// the search.
+///
+/// Bucketing is by shift rather than division: `1 << shift` values per bucket
+/// keeps the count at or below kFrameSearchBuckets without a per-element divide.
+template <typename T>
+void BuildFrameSearchHistograms(const T* values, int32_t num_elements, T frame,
+                                int32_t shift, std::array<int32_t, 65>* width_hist,
+                                std::array<int32_t, kFrameSearchBuckets + 1>* buckets) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  const auto unsigned_frame = static_cast<UnsignedT>(frame);
+
+  // Four accumulators, as in BuildOffsetHistogram: a column whose offsets share
+  // a width -- which is most of them -- sends every element to one bin, and a
+  // single accumulator turns that into a serial read-modify-write chain.
+  std::array<std::array<int32_t, 65>, 4> h{};
+  for (int32_t i = 0; i < num_elements; ++i) {
+    const UnsignedT offset = static_cast<UnsignedT>(values[i]) - unsigned_frame;
+    ++h[i & 3][PforTypeTraits<T>::BitsRequired(offset)];
+    ++(*buckets)[static_cast<size_t>(offset >> shift)];
+  }
+  for (int b = 0; b <= 64; ++b) {
+    (*width_hist)[b] = h[0][b] + h[1][b] + h[2][b] + h[3][b];
+  }
+}
+
+/// \brief Histogram over offsets that were already reduced by their frame.
+template <typename T>
+void BuildOffsetHistogram(const typename PforTypeTraits<T>::UnsignedType* offsets,
+                          int32_t num_elements, std::array<int32_t, 65>* out) {
+  // A pointer to the unsigned counterpart of T may be read as a pointer to T,
+  // and BitsRequired only looks at the bits, so a frame of zero over the same
+  // storage gives exactly the histogram of the offsets.
+  BuildOffsetHistogram<T>(reinterpret_cast<const T*>(offsets), num_elements,
+                          static_cast<T>(0), out);
+}
+
+// ----------------------------------------------------------------------
+// Frame search
+
+/// \brief The extremes of a run of values.
+template <typename T>
+struct MinMax {
+  T min = 0;
+  T max = 0;
+};
+
+/// \brief A frame of reference together with the width that suits it.
+template <typename T>
+struct FrameChoice {
+  T frame_of_reference = 0;
+  uint8_t bit_width = 0;
+  PforConstants::ExceptionCountType num_exceptions = 0;
+  int64_t cost_bits = std::numeric_limits<int64_t>::max();
+};
+
+/// \brief Choose a frame of reference and a bit width together.
+///
+/// The frame PFOR has always used is the minimum, which makes every exception
+/// an overshoot: one value far below the cluster drags the whole packed window
+/// down with it and nothing can patch it back. Treating the frame as a free
+/// parameter instead -- any lower bound, not the lowest -- lets the window sit
+/// where the values actually are and patch on both sides.
+///
+/// Storage is unaffected: the frame field already holds a full-width T, and the
+/// decoder only ever adds it. The whole cost is this search.
+///
+/// The search is approximate by design. An exact answer needs the values
+/// sorted; instead the range is bucketed with a shift, and for each candidate
+/// width a window is slid over the bucket counts. Only whole buckets count as
+/// covered, so the exception estimate is an upper bound -- never optimistic.
+/// The minimum-frame answer is always among the candidates, and it alone is
+/// costed from a real histogram, so the search can never do worse than what the
+/// old cost model would have picked.
+template <typename T>
+FrameChoice<T> ChooseFrameAndWidth(const T* values, int32_t num_elements,
+                                   MinMax<T> bounds) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr uint8_t max_bits = PforTypeTraits<T>::kMaxBitWidth;
+
+  const T min_val = bounds.min;
+  const T max_val = bounds.max;
+
+  // A constant vector is already at the floor, and min/max has just proved it
+  // constant, so it needs no histogram to find that out. Worth the special case
+  // for its own sake: a run of equal values sends every element to one
+  // histogram bin, where the read-modify-write serializes and the pass runs at
+  // a fraction of its usual rate.
+  const auto range = static_cast<UnsignedT>(max_val) - static_cast<UnsignedT>(min_val);
+  if (range == 0) {
+    FrameChoice<T> constant_choice;
+    constant_choice.frame_of_reference = min_val;
+    constant_choice.cost_bits = 0;
+    return constant_choice;
+  }
+
+  const auto range_bits = PforTypeTraits<T>::BitsRequired(range);
+  const int32_t shift = range_bits > kFrameSearchBits ? range_bits - kFrameSearchBits : 0;
+
+  // One walk serves both halves of the search: the bit-width histogram costs
+  // the minimum as a frame, the bucket counts cost every other frame.
+  std::array<int32_t, 65> histogram{};
+  std::array<int32_t, kFrameSearchBuckets + 1> counts{};
+  BuildFrameSearchHistograms<T>(values, num_elements, min_val, shift, &histogram,
+                                &counts);
+
+  // Candidate 0: the minimum, i.e. what PFOR has always done. Costed
+  // unconditionally, and from a real histogram, so the search cannot regress
+  // against it.
+  FrameChoice<T> best;
+  best.frame_of_reference = min_val;
+  int64_t cost_bits = 0;
+  BitWidthResult r = BestWidthFromHistogram<T>(histogram, num_elements, &cost_bits);
+  best.bit_width = r.bit_width;
+  best.num_exceptions = r.num_exceptions;
+  best.cost_bits = cost_bits;
+
+  // Already at width 0, with a handful of patches carrying the rest. Nothing a
+  // frame can do about it. Note this is not the same as having no exceptions:
+  // the whole point of a frame above the minimum is to trade a narrower width
+  // for a few patches, so an exception-free choice is where the search starts,
+  // not a reason to skip it. The sawtooth is the example -- its differences pack
+  // at width 12 with no exceptions, or at width 0 with five, and only the second
+  // is worth having.
+  if (best.bit_width == 0) return best;
+
+  const int32_t num_buckets = static_cast<int32_t>(range >> shift) + 1;
+  std::array<int32_t, kFrameSearchBuckets + 2> prefix{};
+  for (int32_t b = 0; b < num_buckets; ++b) prefix[b + 1] = prefix[b] + counts[b];
+
+  // Slide a 2^w-wide window over the buckets and keep the position that costs
+  // least. Widths below the bucket size cannot be resolved at this granularity,
+  // and once one window spans every bucket there are no exceptions left to
+  // remove, so the loop covers only the ~kFrameSearchBits widths in between --
+  // fixed work, and none of it touching the data again.
+  //
+  // What comes out of this is a frame, not a width. Only whole buckets count as
+  // covered, so `w` here is an upper bound on the width the frame really needs,
+  // and the exception count an upper bound too. The exact pass below is what
+  // turns the frame into a plan.
+  //
+  // Seeded with the incumbent's cost, so a window only registers if it beats
+  // the minimum as a frame. Everything after this loop -- the walk that lowers
+  // the frame onto a real value, and the exact pass that turns it into a width
+  // -- is then skipped entirely on a column the frame cannot help, which is
+  // most of them. Seeding it costs the conservative direction: the scan
+  // over-counts exceptions, so it can decline a frame whose exact cost would
+  // have won, but it cannot accept one that loses.
+  int32_t best_start = -1;
+  int32_t best_end = 0;
+  int64_t scan_cost = best.cost_bits;
+  for (int32_t w = shift; w <= max_bits; ++w) {
+    const int64_t whole_buckets = static_cast<int64_t>(1) << (w - shift);
+    if (whole_buckets <= 0) break;
+    const int32_t k =
+        static_cast<int32_t>(whole_buckets < num_buckets ? whole_buckets : num_buckets);
+    for (int32_t s = 0; s < num_buckets; ++s) {
+      const int32_t end = s + k < num_buckets ? s + k : num_buckets;
+      const int64_t exceptions = num_elements - (prefix[end] - prefix[s]);
+      if (exceptions > PforConstants::kMaxVectorSize) continue;
+      const int64_t cost =
+          static_cast<int64_t>(num_elements) * w + exceptions * ExceptionBits<T>();
+      if (cost < scan_cost) {
+        scan_cost = cost;
+        best_start = s;
+        best_end = end;
+      }
+    }
+    if (k >= num_buckets) break;  // one window already spans the data
+  }
+
+  if (best_start < 0) return best;
+
+  // Lower the frame from the boundary of the winning window onto the smallest
+  // value the window actually covers. Bucket boundaries stand 2^shift apart,
+  // which on a wide column is thousands, and a cluster sitting just above one
+  // would otherwise pay those bits for nothing.
+  //
+  // A walk of its own, rather than per-bucket minima kept by the pass above:
+  // tracking them there costs every vector a compare and a store per element,
+  // including the vectors where the scan finds nothing and the minima are
+  // discarded. Over the distributions in pfor_benchmark.cc that cost about 30%
+  // of encode throughput to improve one of them. Here only a vector the search has
+  // already won pays, and it pays one traversal.
+  const auto window_lo = static_cast<UnsignedT>(best_start) << shift;
+  // A window reaching the last bucket has no upper edge to test against: the
+  // edge would be num_buckets << shift, which is one past the representable
+  // range whenever the offsets span the whole type.
+  const bool bounded_above = best_end < num_buckets;
+  const UnsignedT window_hi =
+      bounded_above ? (static_cast<UnsignedT>(best_end) << shift) : UnsignedT{0};
+
+  const auto unsigned_min = static_cast<UnsignedT>(min_val);
+  UnsignedT frame_offset = 0;
+  bool covers_anything = false;
+  for (int32_t i = 0; i < num_elements; ++i) {
+    const UnsignedT offset = static_cast<UnsignedT>(values[i]) - unsigned_min;
+    if (offset < window_lo || (bounded_above && offset >= window_hi)) continue;
+    if (!covers_anything || offset < frame_offset) {
+      frame_offset = offset;
+      covers_anything = true;
+    }
+  }
+  if (!covers_anything) return best;
+
+  const auto scan_frame = static_cast<T>(unsigned_min + frame_offset);
+  if (scan_frame == min_val) return best;
+
+  // Cost the winning frame exactly. This pass is not bookkeeping -- it is where
+  // the width and the exception count are actually decided. The scan works at
+  // bucket granularity and so cannot see a window narrower than one bucket,
+  // which is exactly where the answers worth having tend to be: the sawtooth's
+  // differences span 12 bits, so its buckets are 16 wide, and no scan over them
+  // can resolve the 0-bit window that its five patches leave behind.
+  BuildOffsetHistogram<T>(values, num_elements, scan_frame, &histogram);
+  int64_t exact_cost = 0;
+  r = BestWidthFromHistogram<T>(histogram, num_elements, &exact_cost);
+  if (exact_cost < best.cost_bits) {
+    best.frame_of_reference = scan_frame;
+    best.bit_width = r.bit_width;
+    best.num_exceptions = r.num_exceptions;
+    best.cost_bits = exact_cost;
+  }
+  return best;
+}
+
+/// \brief Overload for callers that have not already seen the values.
+template <typename T>
+FrameChoice<T> ChooseFrameAndWidth(const T* values, int32_t num_elements) {
+  MinMax<T> bounds{values[0], values[0]};
+  for (int32_t i = 1; i < num_elements; ++i) {
+    if (values[i] < bounds.min) bounds.min = values[i];
+    if (values[i] > bounds.max) bounds.max = values[i];
+  }
+  return ChooseFrameAndWidth<T>(values, num_elements, bounds);
+}
+
+// ----------------------------------------------------------------------
+// Whole-vector plan
+
+/// \brief Everything the encoder decided about one vector.
+template <typename T>
+struct PforVectorPlan {
+  /// Difference the values before framing and packing them.
+  bool delta = false;
+  /// Subtracted from every element before packing; added back on decode.
+  T frame_of_reference = 0;
+  /// First value of the vector, stored only when `delta` is set. It is what
+  /// makes a delta vector decodable on its own, without the vector before it.
+  T start_value = 0;
+  uint8_t bit_width = 0;
+  PforConstants::ExceptionCountType num_exceptions = 0;
+  /// Packed bits, exception bits, and the start value if there is one. Excludes
+  /// the fixed per-vector info, which every plan pays equally.
+  int64_t cost_bits = 0;
+};
+
+/// \brief Map a signed value onto an unsigned one of the same magnitude.
+///
+/// Negative values interleave with positive ones instead of wrapping to the top
+/// of the range, so a small negative difference needs few bits rather than all
+/// of them. Used only by the estimate below; nothing on the wire is zigzagged.
+template <typename T>
+typename PforTypeTraits<T>::UnsignedType ZigZag(T value) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr int kBits = static_cast<int>(sizeof(T)) * 8;
+  const auto u = static_cast<UnsignedT>(value);
+  const UnsignedT sign_mask = UnsignedT{0} - (u >> (kBits - 1));
+  return static_cast<UnsignedT>((u << 1) ^ sign_mask);
+}
+
+/// \brief Fill `deltas` with the backward differences of `values`.
+///
+/// deltas[0] is 0: the first value travels in the plan's start_value, and
+/// giving slot 0 a real delta would mean either a shorter packed run or a
+/// value that is not a difference sitting in the width histogram. Zero costs
+/// bit_width bits and distorts nothing.
+///
+/// Subtraction is done unsigned and copied across, because signed overflow is
+/// undefined and a column that spans the type's range will overflow.
+/// The bounds of the differences come back with them: this walk has just seen
+/// every one, and the search needs them before it can do anything else.
+template <typename T>
+void ComputeDeltas(const T* values, int32_t num_elements, T* deltas, MinMax<T>* bounds) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  deltas[0] = 0;
+  *bounds = MinMax<T>{0, 0};
+  for (int32_t i = 1; i < num_elements; ++i) {
+    const UnsignedT d =
+        static_cast<UnsignedT>(values[i]) - static_cast<UnsignedT>(values[i - 1]);
+    T signed_delta;
+    std::memcpy(&signed_delta, &d, sizeof(T));
+    deltas[i] = signed_delta;
+    if (signed_delta < bounds->min) bounds->min = signed_delta;
+    if (signed_delta > bounds->max) bounds->max = signed_delta;
+  }
+}
+
+/// \brief Estimate what packing the differences of `values` would cost, in bits.
+///
+/// The full decision needs the differences written out and searched, which is
+/// most of what encoding a vector costs. This reaches an answer good enough to
+/// decline the mode from a strided sample, without writing anything.
+///
+/// The sample is of widths, not of a span. A gate on the span of the
+/// differences was tried first and had to go: the sawtooth is a tight cluster
+/// of small positive differences with a handful of large negative ones, so its
+/// span is as wide as its raw span while its cost is a fraction of it. Feeding
+/// widths to the same cost model the search uses keeps that shape, because the
+/// model can trade a wide bin against a patch.
+///
+/// Zigzagging is what lets a histogram stand in for a frame search that has not
+/// run. Differences in [-k, k] zigzag into [0, 2k], and a frame at -k maps them
+/// onto the same [0, 2k], so for a range that straddles zero evenly the
+/// estimated width is the width the search would find. Where the range leans
+/// one way the estimate runs a bit or two wide.
+template <typename T>
+int64_t EstimateDeltaCostBits(const T* values, int32_t num_elements) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // Enough of a sample to place a distribution across the width bins, and few
+  // enough that the pass is a fraction of the one it is deciding against.
+  constexpr int32_t kSampleTarget = 128;
+  const int32_t stride = std::max(1, num_elements / kSampleTarget);
+
+  // Four accumulators, as in the histogram passes above: most columns send
+  // nearly every difference to one bin, and one array would serialize on it.
+  std::array<std::array<int32_t, 65>, 4> h{};
+  int32_t sampled = 0;
+  for (int32_t i = stride; i < num_elements; i += stride) {
+    const UnsignedT d =
+        static_cast<UnsignedT>(values[i]) - static_cast<UnsignedT>(values[i - 1]);
+    T signed_delta;
+    std::memcpy(&signed_delta, &d, sizeof(T));
+    ++h[sampled & 3][PforTypeTraits<T>::BitsRequired(ZigZag<T>(signed_delta))];
+    ++sampled;
+  }
+  if (sampled == 0) return 0;
+
+  std::array<int32_t, 65> histogram{};
+  for (int b = 0; b <= 64; ++b) {
+    histogram[b] = h[0][b] + h[1][b] + h[2][b] + h[3][b];
+  }
+  int64_t sample_cost = 0;
+  BestWidthFromHistogram<T>(histogram, sampled, &sample_cost);
+
+  // Scale to the whole vector. Both terms of the model are per-element -- a
+  // width costs its bits every element, an exception costs its slot every time
+  // it occurs -- so the sample cost scales with the count.
+  return sample_cost * num_elements / sampled;
+}
+
+/// \brief Decide how to encode one vector.
+///
+/// \param[in] values the vector
+/// \param[in] num_elements element count, > 0
+/// \param[out] delta_scratch scratch for num_elements differences; on return it
+///             holds the differences if the plan chose the delta mode, and is
+///             clobbered either way
+/// \param[in] delta_enabled whether the delta mode may be chosen at all
+///
+/// Both transforms are costed with the same model and the cheaper one wins, so
+/// the mode is a per-vector decision. It has to be: differencing loses 6-19% on
+/// every unclustered draw, and a column is rarely all one shape.
+template <typename T>
+PforVectorPlan<T> ChooseVectorPlan(const T* values, int32_t num_elements,
+                                   T* delta_scratch, bool delta_enabled) {
+  const FrameChoice<T> raw = ChooseFrameAndWidth<T>(values, num_elements);
+
+  PforVectorPlan<T> plan;
+  plan.delta = false;
+  plan.frame_of_reference = raw.frame_of_reference;
+  plan.bit_width = raw.bit_width;
+  plan.num_exceptions = raw.num_exceptions;
+  plan.cost_bits = raw.cost_bits;
+
+  // One element has no difference to take, and a vector already packing at
+  // width 0 cannot be improved on.
+  if (!delta_enabled || num_elements < 2 || raw.bit_width == 0) return plan;
+
+  // A delta vector carries its own first value, so it starts one full-width
+  // value behind whatever its differences pack to.
+  const int64_t start_value_bits = static_cast<int64_t>(sizeof(T)) * 8;
+
+  // Estimate the mode before paying for it, and drop it here if the estimate
+  // cannot reach the incumbent. What is skipped is the whole of the rest of the
+  // mode: the pass that writes the differences out, and the frame search over
+  // them. The estimate is deliberately loose, so it declines only where the two
+  // modes are more than a sampling error apart -- which is where the choice
+  // matters least.
+  if (EstimateDeltaCostBits<T>(values, num_elements) + start_value_bits >=
+      plan.cost_bits) {
+    return plan;
+  }
+
+  MinMax<T> delta_bounds;
+  ComputeDeltas<T>(values, num_elements, delta_scratch, &delta_bounds);
+
+  const FrameChoice<T> delta =
+      ChooseFrameAndWidth<T>(delta_scratch, num_elements, delta_bounds);
+
+  const int64_t delta_cost = delta.cost_bits + start_value_bits;
+  if (delta_cost < plan.cost_bits) {
+    plan.delta = true;
+    plan.frame_of_reference = delta.frame_of_reference;
+    plan.start_value = values[0];
+    plan.bit_width = delta.bit_width;
+    plan.num_exceptions = delta.num_exceptions;
+    plan.cost_bits = delta_cost;
+  }
+  return plan;
+}
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_test.cc b/cpp/src/arrow/util/pfor/pfor_test.cc
new file mode 100644
index 000000000000..ceb38f9261a5
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_test.cc
@@ -0,0 +1,1547 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <numeric>
+#include <random>
+#include <span>
+#include <string>
+#include <vector>
+
+#include "arrow/testing/gtest_util.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/pfor/pfor_internal.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+
+namespace arrow::util::pfor {
+
+// ======================================================================
+// Test fixture
+//
+// PFOR is instantiated for int32_t and int64_t, and the two differ in the
+// widths of the frame of reference, the packed deltas and the exception values,
+// so nearly every test here belongs to both. The helpers hide the width
+// arithmetic; tests that poke at particular byte offsets derive them from
+// sizeof(T) and kStoredSize rather than writing them out.
+
+template <typename T>
+class PforTest : public ::testing::Test {
+ protected:
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+
+  /// Encode, serialize and decode a single vector, checking that it round-trips.
+  ///
+  /// \param[out] encoded_out the encoded form, for tests that assert on its
+  ///             metadata; may be null
+  void RoundTripVector(const std::vector<T>& values,
+                       PforEncodedVector<T>* encoded_out = nullptr) {
+    const auto num_elements = static_cast<int32_t>(values.size());
+    auto encoded = PforCompression<T>::EncodeVector(values.data(), num_elements);
+
+    const int64_t needed =
+        PforCompression<T>::SerializedVectorSize(encoded, num_elements);
+    std::vector<uint8_t> buffer(needed);
+    ASSERT_OK_AND_ASSIGN(const int64_t written, PforCompression<T>::SerializeVector(
+                                                    encoded, num_elements, buffer));
+    ASSERT_EQ(needed, written);
+
+    std::vector<T> decoded(values.size());
+    ASSERT_OK(PforCompression<T>::DecodeVector(buffer, num_elements, decoded.data()));
+    ASSERT_EQ(values, decoded);
+
+    if (encoded_out != nullptr) {
+      *encoded_out = std::move(encoded);
+    }
+  }
+
+  /// Encode and decode a whole page, checking that it round-trips and stays
+  /// inside the bound the encoder allocates from.
+  ///
+  /// \param[out] comp_size_out the compressed size, for tests that assert on
+  ///             the compression ratio; may be null
+  void RoundTripPage(const std::vector<T>& values, int64_t* comp_size_out = nullptr) {
+    const auto num_values = static_cast<int32_t>(values.size());
+    ASSERT_OK_AND_ASSIGN(const int64_t max_size,
+                         PforWrapper<T>::GetMaxCompressedSize(num_values));
+    std::vector<uint8_t> compressed(max_size);
+    int64_t comp_size = max_size;
+    ASSERT_OK(
+        PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+    ASSERT_GT(comp_size, 0);
+    ASSERT_LE(comp_size, max_size);
+
+    std::vector<T> decoded(values.size());
+    ASSERT_OK(
+        PforWrapper<T>::Decode(compressed.data(), comp_size, num_values, decoded.data()));
+    ASSERT_EQ(values, decoded);
+
+    if (comp_size_out != nullptr) {
+      *comp_size_out = comp_size;
+    }
+  }
+
+  /// Encode `values` and return the compressed bytes, sized exactly.
+  static std::vector<uint8_t> EncodePage(const std::vector<T>& values) {
+    const auto num_values = static_cast<int32_t>(values.size());
+    int64_t comp_size = PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> compressed(comp_size);
+    ARROW_CHECK_OK(
+        PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+    compressed.resize(comp_size);
+    return compressed;
+  }
+
+  /// Offset of the first vector in a single-vector page: header, then the
+  /// one-entry offset array.
+  static constexpr int64_t kFirstVectorOffset =
+      PforConstants::kHeaderSize +
+      static_cast<int64_t>(sizeof(PforConstants::OffsetType));
+
+  /// Offsets of the PforVectorInfo fields, relative to the start of a vector.
+  static constexpr int64_t kBitWidthOffset = static_cast<int64_t>(sizeof(T));
+  static constexpr int64_t kNumExceptionsOffset = kBitWidthOffset + 1;
+
+  static std::vector<T> RandomValues(int32_t num_values, T min, T max, uint32_t seed) {
+    std::vector<T> values(num_values);
+    std::mt19937 rng(seed);
+    std::uniform_int_distribution<T> dist(min, max);
+    for (auto& v : values) v = dist(rng);
+    return values;
+  }
+};
+
+using PforTypes = ::testing::Types<int32_t, int64_t>;
+TYPED_TEST_SUITE(PforTest, PforTypes);
+
+namespace {
+
+void StoreLE32(uint8_t* dest, uint32_t value) {
+  for (int i = 0; i < 4; ++i) {
+    dest[i] = static_cast<uint8_t>(value >> (8 * i));
+  }
+}
+
+}  // namespace
+
+// ======================================================================
+// Constants Tests
+
+TEST(PforConstantsTest, VectorSizeIsPowerOfTwo) {
+  EXPECT_EQ(PforConstants::kPforVectorSize, 1024);
+  EXPECT_EQ(1 << PforConstants::kDefaultLogVectorSize, PforConstants::kPforVectorSize);
+}
+
+TEST(PforConstantsTest, VectorInfoSizes) {
+  EXPECT_EQ(PforTypeTraits<int32_t>::kVectorInfoSize, 7);
+  EXPECT_EQ(PforTypeTraits<int64_t>::kVectorInfoSize, 11);
+}
+
+// ======================================================================
+// BitsRequired Tests
+
+TYPED_TEST(PforTest, BitsRequired) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(0), 0);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(1), 1);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(2), 2);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(3), 2);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(255), 8);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(256), 9);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(std::numeric_limits<UnsignedT>::max()),
+            PforTypeTraits<T>::kMaxBitWidth);
+}
+
+// ======================================================================
+// VectorInfo Serialization Tests
+
+TYPED_TEST(PforTest, VectorInfoRoundTrip) {
+  using T = TypeParam;
+  PforVectorInfo<T> info;
+  info.set_frame_of_reference(-42);
+  info.set_bit_width(17);
+  info.set_num_exceptions(300);
+
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize);
+  info.Store(buf);
+  ASSERT_OK_AND_ASSIGN(auto loaded, PforVectorInfo<T>::Load(buf));
+
+  EXPECT_EQ(loaded.frame_of_reference(), -42);
+  EXPECT_EQ(loaded.bit_width(), 17);
+  EXPECT_EQ(loaded.num_exceptions(), 300);
+}
+
+// The extremes of every field at once: the widest frame of reference the type
+// can hold and the full bit width. A six-bit width field could not store 64,
+// and reported such a vector as constant.
+TYPED_TEST(PforTest, VectorInfoRoundTripAtFieldExtremes) {
+  using T = TypeParam;
+  constexpr T kFrameOfReference = std::numeric_limits<T>::min();
+  PforVectorInfo<T> info(kFrameOfReference, PforTypeTraits<T>::kMaxBitWidth, 30000);
+
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize);
+  info.Store(buf);
+  ASSERT_OK_AND_ASSIGN(auto loaded, PforVectorInfo<T>::Load(buf));
+
+  EXPECT_EQ(loaded.frame_of_reference(), kFrameOfReference);
+  EXPECT_EQ(loaded.bit_width(), PforTypeTraits<T>::kMaxBitWidth);
+  EXPECT_EQ(loaded.num_exceptions(), 30000);
+}
+
+// Every element of a maximum-size vector can be an exception, so the count has
+// to reach kMaxVectorSize. A signed 16-bit field stopped one short of that.
+TYPED_TEST(PforTest, VectorInfoNumExceptionsAtMaxVectorSize) {
+  using T = TypeParam;
+  PforVectorInfo<T> info;
+  info.set_bit_width(3);
+  info.set_num_exceptions(PforConstants::kMaxVectorSize);
+
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize);
+  info.Store(buf);
+  ASSERT_OK_AND_ASSIGN(auto loaded, PforVectorInfo<T>::Load(buf));
+
+  EXPECT_EQ(loaded.num_exceptions(), PforConstants::kMaxVectorSize);
+}
+
+TYPED_TEST(PforTest, VectorInfoRejectsNumExceptionsAboveMaxVectorSize) {
+  using T = TypeParam;
+  // [FOR] [bit_width 1B] [num_exceptions 2B], with a count no vector can have.
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize, 0);
+  buf[TestFixture::kBitWidthOffset] = 3;
+  buf[TestFixture::kNumExceptionsOffset] = 0xFF;
+  buf[TestFixture::kNumExceptionsOffset + 1] = 0xFF;
+  ASSERT_RAISES(Invalid, PforVectorInfo<T>::Load(buf));
+}
+
+TYPED_TEST(PforTest, VectorInfoRejectsUndersizedBuffer) {
+  using T = TypeParam;
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize - 1, 0);
+  ASSERT_RAISES(Invalid, PforVectorInfo<T>::Load(buf));
+}
+
+// ======================================================================
+// Cost Model Tests
+
+TYPED_TEST(PforTest, CostModelAllIdentical) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // All deltas are 0 => bit_width should be 0, no exceptions
+  std::vector<UnsignedT> deltas(100, 0);
+  auto result = PforCompression<T>::FindOptimalBitWidth(deltas.data(), 100);
+  EXPECT_EQ(result.bit_width, 0);
+  EXPECT_EQ(result.num_exceptions, 0);
+}
+
+TYPED_TEST(PforTest, CostModelSingleOutlier) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // 99 values fit in 3 bits, 1 outlier needs 16 bits
+  std::vector<UnsignedT> deltas(100, 5);  // all fit in 3 bits
+  deltas[50] = 50000;                     // outlier: 16 bits
+  auto result = PforCompression<T>::FindOptimalBitWidth(deltas.data(), 100);
+  // An exception costs a 16-bit position plus a full-width value, so at
+  // bit_width=3 the vector costs 100*3 + 1*(16 + 8*sizeof(T)) bits, against
+  // 100*16 at bit_width=16. Patching the one outlier wins for both widths of T.
+  EXPECT_EQ(result.bit_width, 3);
+  EXPECT_EQ(result.num_exceptions, 1);
+}
+
+TYPED_TEST(PforTest, CostModelNoOutliers) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // All values fit in 8 bits
+  std::vector<UnsignedT> deltas(100);
+  for (int32_t i = 0; i < 100; ++i) deltas[i] = i * 2;
+  auto result = PforCompression<T>::FindOptimalBitWidth(deltas.data(), 100);
+  EXPECT_EQ(result.num_exceptions, 0);
+  EXPECT_LE(result.bit_width, 8);
+}
+
+// ======================================================================
+// Vector Encode/Decode Round-Trip Tests
+
+// An ascending run is what the delta mode is for, so this no longer measures
+// the frame of reference: the packed stream holds the differences, all of them
+// 1, and the frame belongs to those. The first value travels separately.
+TYPED_TEST(PforTest, VectorSimpleSequence) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), 100);
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_TRUE(encoded.info().is_delta());
+  EXPECT_EQ(encoded.start_value(), 100);
+}
+
+// The same shape with the differences made unpredictable, which is what leaves
+// the values themselves as the cheaper thing to pack. Here the frame is the
+// minimum and nothing is patched, as it was before there was a delta mode.
+TYPED_TEST(PforTest, VectorSimpleSequenceWithoutDelta) {
+  using T = TypeParam;
+  std::vector<T> values = this->RandomValues(64, 100, 163, 11);
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_FALSE(encoded.info().is_delta());
+  EXPECT_EQ(encoded.info().frame_of_reference(),
+            *std::min_element(values.begin(), values.end()));
+  EXPECT_EQ(encoded.info().num_exceptions(), 0);
+}
+
+TYPED_TEST(PforTest, VectorWithOutlier) {
+  using T = TypeParam;
+  std::vector<T> values = {100, 102, 101, 103, 100, 99, 50000, 104};
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_EQ(encoded.info().frame_of_reference(), 99);
+  EXPECT_GT(encoded.info().num_exceptions(), 0);
+}
+
+TYPED_TEST(PforTest, VectorAllIdentical) {
+  using T = TypeParam;
+  std::vector<T> values(100, 42);
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_EQ(encoded.info().bit_width(), 0);
+  EXPECT_EQ(encoded.info().num_exceptions(), 0);
+}
+
+TYPED_TEST(PforTest, VectorNegativeValues) {
+  using T = TypeParam;
+  std::vector<T> values = {-100, -50, -200, -1, -150};
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_EQ(encoded.info().frame_of_reference(), -200);
+}
+
+// The frame of reference is subtracted in the unsigned domain, so a vector
+// spanning the whole range of T has a delta that only wraps to the right answer.
+TYPED_TEST(PforTest, VectorMinMaxEdge) {
+  using T = TypeParam;
+  std::vector<T> values = {std::numeric_limits<T>::min(), std::numeric_limits<T>::max(),
+                           0, -1, 1};
+  this->RoundTripVector(values);
+}
+
+TYPED_TEST(PforTest, VectorSingleElement) {
+  using T = TypeParam;
+  this->RoundTripVector(std::vector<T>{42});
+}
+
+// ======================================================================
+// Page-Level Wrapper Tests
+
+TYPED_TEST(PforTest, PageSmall) { this->RoundTripPage({10, 20, 30, 40, 50}); }
+
+TYPED_TEST(PforTest, PageExactOneVector) {
+  using T = TypeParam;
+  std::vector<T> values(PforConstants::kPforVectorSize);
+  std::iota(values.begin(), values.end(), 0);
+  this->RoundTripPage(values);
+}
+
+TYPED_TEST(PforTest, PageMultipleVectors) {
+  // 2.5 vectors worth of data
+  this->RoundTripPage(TestFixture::RandomValues(2560, 0, 1000, /*seed=*/42));
+}
+
+TYPED_TEST(PforTest, PageWithOutliers) {
+  using T = TypeParam;
+  std::vector<T> values(1024, 100);
+  values[0] = -999999;
+  values[100] = 888888;
+  values[500] = 777777;
+  values[1023] = -123456;
+  this->RoundTripPage(values);
+}
+
+TYPED_TEST(PforTest, PagePartialTrailingVector) {
+  using T = TypeParam;
+  auto values = TestFixture::RandomValues(3000, 0, 100000, /*seed=*/123);
+  values[0] = std::numeric_limits<T>::max() / 2;
+  values[1500] = std::numeric_limits<T>::min() / 2;
+  this->RoundTripPage(values);
+}
+
+TYPED_TEST(PforTest, PageSingleElement) {
+  using T = TypeParam;
+  this->RoundTripPage(std::vector<T>{42});
+}
+
+TYPED_TEST(PforTest, PageAllZeros) {
+  using T = TypeParam;
+  std::vector<T> values(1024, 0);
+  int64_t comp_size = 0;
+  this->RoundTripPage(values, &comp_size);
+  // bit_width is 0, so the page is header, offset array and vector info only.
+  EXPECT_LT(comp_size, 100);
+}
+
+TYPED_TEST(PforTest, PageLargeRandom) {
+  using T = TypeParam;
+  this->RoundTripPage(TestFixture::RandomValues(10000, std::numeric_limits<T>::min(),
+                                                std::numeric_limits<T>::max(),
+                                                /*seed=*/99));
+}
+
+// Covers the FOR==0 fast path (bit_width > 0 with frame_of_reference == 0):
+// decode unpacks straight into the output, skipping the scratch buffer and the
+// add-FOR pass. Forces min == 0, a range that needs bit_width > 0, outliers to
+// exercise the exception patch on that path, and multiple vectors.
+TYPED_TEST(PforTest, PageZeroMinWithExceptions) {
+  auto values = TestFixture::RandomValues(3000, 0, 500, /*seed=*/2024);
+  values[0] = 0;            // force min == 0 -> FOR == 0
+  values[100] = 1'000'000;  // outliers -> exceptions on the FOR==0 path
+  values[1500] = 999'999;
+  values[2999] = 500'000;
+  this->RoundTripPage(values);
+}
+
+// ======================================================================
+// Encode Argument Validation
+
+TYPED_TEST(PforTest, EncodeZeroValuesWritesABareHeader) {
+  using T = TypeParam;
+  // An all-null page holds no values, and the reader still has to be able to load
+  // a header from it, so zero values encodes to the header and nothing else. The
+  // pointer is null because the buffer the values would come from is empty.
+  std::vector<uint8_t> compressed(64);
+  int64_t comp_size = 64;
+  ASSERT_OK(PforWrapper<T>::Encode(nullptr, 0, compressed.data(), &comp_size));
+  ASSERT_EQ(PforConstants::kHeaderSize, comp_size);
+
+  ASSERT_OK_AND_ASSIGN(const int32_t count,
+                       PforWrapper<T>::DecodeElementCount(compressed.data(), comp_size));
+  ASSERT_EQ(0, count);
+  ASSERT_OK(PforWrapper<T>::Decode(compressed.data(), comp_size, 0, nullptr));
+}
+
+TYPED_TEST(PforTest, EncodeRejectsNegativeCount) {
+  using T = TypeParam;
+  std::vector<T> values = {1, 2, 3};
+  std::vector<uint8_t> compressed(64);
+  int64_t comp_size = 64;
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Encode(values.data(), -1, compressed.data(), &comp_size));
+}
+
+TYPED_TEST(PforTest, EncodeRejectsNullInputWithValuesToEncode) {
+  using T = TypeParam;
+  std::vector<uint8_t> compressed(64);
+  int64_t comp_size = 64;
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Encode(nullptr, 3, compressed.data(), &comp_size));
+}
+
+TYPED_TEST(PforTest, EncodeRejectsUnrepresentableVectorSize) {
+  using T = TypeParam;
+  std::vector<T> values = {1, 2, 3};
+  std::vector<uint8_t> compressed(64);
+
+  // Not a power of two.
+  int64_t comp_size = 64;
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Encode(values.data(), 3, 1000, compressed.data(),
+                                                &comp_size));
+
+  // A power of two, but the header's log_vector_size field cannot describe it.
+  comp_size = 64;
+  ASSERT_RAISES(
+      Invalid, PforWrapper<T>::Encode(values.data(), 3, PforConstants::kMaxVectorSize * 2,
+                                      compressed.data(), &comp_size));
+}
+
+// ======================================================================
+// Compression Ratio Test
+
+TYPED_TEST(PforTest, ClusteredDataCompresses) {
+  using T = TypeParam;
+  // Data clustered around 1000 with one outlier
+  auto values = TestFixture::RandomValues(1024, 1000, 1255, /*seed=*/42);
+  values[500] = 999999;
+
+  int64_t comp_size = 0;
+  this->RoundTripPage(values, &comp_size);
+
+  const size_t plain_size = 1024 * sizeof(T);
+  EXPECT_LT(comp_size, static_cast<int64_t>(plain_size / 2));
+}
+
+// ======================================================================
+// Corrupt Page Tests
+//
+// A PFOR page can come from anywhere, so Decode has to reject a header that
+// disagrees with the buffer it arrived in rather than trusting it and reading
+// or writing out of bounds.
+
+namespace {
+
+// A tight cluster plus one far outlier, so the cost model packs narrow and
+// patches the outlier. The outlier is 31 bits out rather than 16: an exception
+// costs a position plus a full-width value, so a 16-bit outlier is cheaper to
+// pack than to patch once the values are 64 bits wide, and the tests below need
+// a vector that actually has an exception section.
+template <typename T>
+std::vector<T> ClusterWithOutlier() {
+  return {10, 20, 30, 40, 2'000'000'000};
+}
+
+}  // namespace
+
+TYPED_TEST(PforTest, DecodeElementCountReadsThePageHeader) {
+  using T = TypeParam;
+  std::vector<T> values(2048);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  ASSERT_OK_AND_ASSIGN(const int32_t count, PforWrapper<T>::DecodeElementCount(
+                                                compressed.data(), compressed.size()));
+  EXPECT_EQ(count, static_cast<int32_t>(values.size()));
+}
+
+TYPED_TEST(PforTest, DecodeElementCountRejectsMalformedInput) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  ASSERT_RAISES(Invalid, PforWrapper<T>::DecodeElementCount(
+                             compressed.data(), PforConstants::kHeaderSize - 1));
+  ASSERT_RAISES(Invalid, PforWrapper<T>::DecodeElementCount(nullptr, compressed.size()));
+  ASSERT_RAISES(Invalid, PforWrapper<T>::DecodeElementCount(compressed.data(), -1));
+}
+
+TYPED_TEST(PforTest, CorruptBufferTooSmallForHeader) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Decode(compressed.data(), PforConstants::kHeaderSize - 1,
+                                       5, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptElementCountExceedsOutputCapacity) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  // num_elements lives at header byte 3.
+  StoreLE32(compressed.data() + 3, 6);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptElementCountBelowOutputCapacity) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  // A count short of the caller's capacity would fill part of the output and
+  // leave the rest holding whatever it held before.
+  StoreLE32(compressed.data() + 3, 4);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptOffsetArrayTruncated) {
+  using T = TypeParam;
+  // Four vectors, so the offset array is 16 bytes; hand Decode a buffer with
+  // room for only two of them.
+  std::vector<T> values(4096);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Decode(compressed.data(), PforConstants::kHeaderSize + 8,
+                                       4096, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptVectorOffsetPastEndOfBuffer) {
+  using T = TypeParam;
+  std::vector<T> values(2048);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Point the second vector past the end of the buffer.
+  StoreLE32(compressed.data() + TestFixture::kFirstVectorOffset,
+            static_cast<uint32_t>(compressed.size()));
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(),
+                                                2048, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptFirstVectorOffsetSkipsTheOffsetArray) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  // One vector, so its data starts right after the four byte offset array.
+  StoreLE32(compressed.data() + PforConstants::kHeaderSize, 5);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptVectorOffsetsRunBackwards) {
+  using T = TypeParam;
+  std::vector<T> values(2048);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Point the second vector at the first one's data. Both offsets are inside the
+  // buffer, so only reading them as a chain catches it.
+  StoreLE32(compressed.data() + TestFixture::kFirstVectorOffset,
+            static_cast<uint32_t>(2 * sizeof(PforConstants::OffsetType)));
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(),
+                                                2048, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptExceptionPositionPastEndOfVector) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Locate the stored exception position: the vector info, then the packed
+  // deltas at whatever width the cost model chose.
+  const int64_t vector_start = TestFixture::kFirstVectorOffset;
+  ASSERT_GT(compressed[vector_start + TestFixture::kNumExceptionsOffset], 0)
+      << "the cost model packed this vector without exceptions, so there is no "
+         "exception position to corrupt";
+  const uint8_t bit_width = compressed[vector_start + TestFixture::kBitWidthOffset];
+  const int64_t packed_bytes = (5 * bit_width + 7) / 8;
+  const int64_t position_offset =
+      vector_start + PforVectorInfo<T>::kStoredSize + packed_bytes;
+
+  // Point the exception at index 100 of a five-element vector.
+  compressed[position_offset] = 100;
+  compressed[position_offset + 1] = 0;
+
+  std::vector<T> decoded(5);
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptExceptionCountExceedsVectorLength) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  const int64_t vector_start = TestFixture::kFirstVectorOffset;
+  compressed[vector_start + TestFixture::kNumExceptionsOffset] = 6;
+  compressed[vector_start + TestFixture::kNumExceptionsOffset + 1] = 0;
+
+  std::vector<T> decoded(5);
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptExceptionDataTruncated) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Drop the trailing exception value, leaving its position behind.
+  ASSERT_GT(
+      compressed[TestFixture::kFirstVectorOffset + TestFixture::kNumExceptionsOffset], 0);
+  std::vector<T> decoded(5);
+  ASSERT_RAISES(
+      Invalid, PforWrapper<T>::Decode(compressed.data(),
+                                      static_cast<int64_t>(compressed.size() - sizeof(T)),
+                                      5, decoded.data()));
+}
+
+// A page whose vector is sized exactly leaves no slack, so setting the delta
+// flag on a vector that was written without one makes the decoder ask for
+// sizeof(T) more bytes than the page holds. That has to be an error rather than
+// a read past the end.
+TYPED_TEST(PforTest, CorruptDeltaFlagSetOnANonDeltaVector) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  const int64_t width_byte =
+      TestFixture::kFirstVectorOffset + TestFixture::kBitWidthOffset;
+  ASSERT_EQ(compressed[width_byte] & PforVectorInfo<T>::kDeltaFlag, 0)
+      << "this page was supposed to be encoded without the delta mode";
+  compressed[width_byte] |= PforVectorInfo<T>::kDeltaFlag;
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(
+                             compressed.data(), static_cast<int64_t>(compressed.size()),
+                             static_cast<int32_t>(values.size()), decoded.data()));
+}
+
+// A delta vector's start value sits between the info block and the packed
+// payload, so a page that ends inside it has enough bytes for the info block
+// and not enough for the vector. The check that catches this is the only one
+// that reads is_delta(), so it needs its own case: the width and exception
+// fields are already valid here.
+TYPED_TEST(PforTest, CorruptDeltaVectorTruncatedInsideTheStartValue) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), static_cast<T>(1'000'000));
+  auto compressed = TestFixture::EncodePage(values);
+
+  const int64_t width_byte =
+      TestFixture::kFirstVectorOffset + TestFixture::kBitWidthOffset;
+  ASSERT_NE(compressed[width_byte] & PforVectorInfo<T>::kDeltaFlag, 0)
+      << "an arithmetic run was supposed to be encoded in the delta mode";
+
+  // One byte short of the start value, so PforVectorInfo::Load succeeds and the
+  // vector as a whole does not fit.
+  const int64_t truncated =
+      TestFixture::kFirstVectorOffset + PforVectorInfo<T>::kStoredSize + sizeof(T) - 1;
+  ASSERT_LT(truncated, static_cast<int64_t>(compressed.size()));
+
+  std::vector<T> decoded(values.size());
+  const Status status = PforWrapper<T>::Decode(
+      compressed.data(), truncated, static_cast<int32_t>(values.size()), decoded.data());
+  ASSERT_RAISES(Invalid, status);
+  EXPECT_NE(status.message().find("metadata"), std::string::npos)
+      << "a truncated start value should be reported as missing metadata, got: "
+      << status.message();
+}
+
+// ======================================================================
+// Output sizing
+
+TYPED_TEST(PforTest, MaxCompressedSizeRejectsInvalidArguments) {
+  using T = TypeParam;
+  ASSERT_RAISES(Invalid, PforWrapper<T>::GetMaxCompressedSize(-1));
+  // A zero vector_size would divide by zero on the way to the answer.
+  for (const int32_t vector_size : {0, 3, 1000, PforConstants::kMaxVectorSize * 2}) {
+    SCOPED_TRACE("vector_size=" + std::to_string(vector_size));
+    ASSERT_RAISES(Invalid, PforWrapper<T>::GetMaxCompressedSize(1024, vector_size));
+    std::vector<T> values(16, 0);
+    int64_t comp_size = 1 << 20;
+    std::vector<uint8_t> compressed(comp_size);
+    ASSERT_RAISES(Invalid, PforWrapper<T>::Encode(values.data(), 16, vector_size,
+                                                  compressed.data(), &comp_size));
+  }
+}
+
+TYPED_TEST(PforTest, EncodeRejectsUndersizedOutputBuffer) {
+  using T = TypeParam;
+  std::vector<T> values(1024);
+  std::iota(values.begin(), values.end(), 0);
+  ASSERT_OK_AND_ASSIGN(const int64_t max_size,
+                       PforWrapper<T>::GetMaxCompressedSize(1024));
+
+  std::vector<uint8_t> compressed(max_size);
+  int64_t comp_size = max_size - 1;
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Encode(values.data(), 1024, compressed.data(),
+                                                &comp_size));
+}
+
+TYPED_TEST(PforTest, SerializeVectorRejectsUndersizedDestination) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), 0);
+  const auto encoded = PforCompression<T>::EncodeVector(values.data(), 64);
+  const int64_t needed = PforCompression<T>::SerializedVectorSize(encoded, 64);
+
+  std::vector<uint8_t> buffer(needed);
+  ASSERT_OK_AND_ASSIGN(const int64_t written,
+                       PforCompression<T>::SerializeVector(encoded, 64, buffer));
+  ASSERT_EQ(needed, written);
+  ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(
+                             encoded, 64, std::span<uint8_t>(buffer).subspan(1)));
+}
+
+// SerializedVectorSize is derived from the vector info, while the copy that
+// follows it takes its lengths from the sections, so a vector whose info and
+// sections disagree has to be refused rather than written past the size the
+// caller reserved.
+TYPED_TEST(PforTest, SerializeVectorRejectsInfoInconsistentWithSections) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), 0);
+  const auto encoded = PforCompression<T>::EncodeVector(values.data(), 64);
+  std::vector<uint8_t> buffer(PforCompression<T>::SerializedVectorSize(encoded, 64) + 64);
+
+  {
+    // A bit width that does not account for the packed bytes present.
+    auto corrupted = encoded;
+    corrupted.mutable_info().set_bit_width(
+        static_cast<uint8_t>(encoded.info().bit_width() + 1));
+    ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(corrupted, 64, buffer));
+  }
+  {
+    // An exception count with nothing behind it. Taken relative to the real
+    // count, which need not be zero: the frame search buys a narrower width
+    // with patches, so even a plain ascending run can arrive with one.
+    auto corrupted = encoded;
+    corrupted.mutable_info().set_num_exceptions(
+        static_cast<PforConstants::ExceptionCountType>(encoded.info().num_exceptions() +
+                                                       1));
+    ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(corrupted, 64, buffer));
+  }
+}
+
+// GetMaxCompressedSize is what the encoder allocates, and it is derived from the
+// cost model rather than from a worst case that assumes every value is an
+// exception, so inputs that push the model in different directions all have to
+// land inside it.
+TYPED_TEST(PforTest, MaxCompressedSizeBoundHoldsForAdversarialInputs) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 3000;
+  std::mt19937 rng(7);
+  std::uniform_int_distribution<T> full_range(std::numeric_limits<T>::min(),
+                                              std::numeric_limits<T>::max());
+
+  std::vector<std::vector<T>> inputs;
+  // Incompressible: every delta needs the full width, so the model picks it.
+  inputs.emplace_back(kNumValues);
+  for (auto& v : inputs.back()) v = full_range(rng);
+  // A narrow cluster with a scatter of far-away values, which is the case that
+  // trades bit width against exception count.
+  inputs.emplace_back(kNumValues, 1000);
+  for (int32_t i = 0; i < kNumValues; i += 3) {
+    inputs.back()[i] = full_range(rng);
+  }
+  // Alternating extremes, so the frame of reference cannot help.
+  inputs.emplace_back(kNumValues);
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    inputs.back()[i] =
+        (i % 2 == 0) ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
+  }
+
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    SCOPED_TRACE("input " + std::to_string(i));
+    this->RoundTripPage(inputs[i]);
+  }
+}
+
+// ======================================================================
+// Delta Mode and Frame Search Tests
+
+// The mode has to survive every width, not just the ones a plausible column
+// produces, so this drives it through all of them: a cumulative sum whose
+// differences are exactly w bits wide leaves the encoder no cheaper option than
+// differencing, since the values themselves span 1024 times as much.
+TYPED_TEST(PforTest, DeltaRoundTripsAtEveryBitWidth) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr int32_t kNumValues = 1024;
+
+  for (uint8_t width = 0; width <= PforTypeTraits<T>::kMaxBitWidth; ++width) {
+    SCOPED_TRACE("delta width " + std::to_string(width));
+    // Differences that need exactly `width` bits, and whose top bit is set so
+    // the width cannot be mistaken for a narrower one.
+    const UnsignedT step =
+        width == 0 ? UnsignedT{0} : static_cast<UnsignedT>(UnsignedT{1} << (width - 1));
+
+    std::vector<T> values(kNumValues);
+    auto acc = static_cast<UnsignedT>(0);
+    for (int32_t i = 0; i < kNumValues; ++i) {
+      std::memcpy(&values[i], &acc, sizeof(T));
+      acc += step;
+    }
+    this->RoundTripVector(values);
+  }
+}
+
+// The negative control for the sweep above. If the encoder stopped choosing the
+// delta mode -- a cost-model change, a gate that reads the wrong thing -- every
+// round-trip test would still pass while testing nothing, so assert here that
+// the path is reached at all, and that it is not reached for data it would only
+// make bigger.
+TYPED_TEST(PforTest, DeltaIsChosenForRunsAndDeclinedForNoise) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+
+  std::vector<T> ascending(kNumValues);
+  std::iota(ascending.begin(), ascending.end(), static_cast<T>(1'000'000));
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(ascending, &encoded);
+  EXPECT_TRUE(encoded.info().is_delta());
+
+  // Independent draws from a narrow band: the values fit in 10 bits, while
+  // their differences take 11 and swing both ways.
+  const std::vector<T> noise = this->RandomValues(kNumValues, 0, 1000, 42);
+  this->RoundTripVector(noise, &encoded);
+  EXPECT_FALSE(encoded.info().is_delta());
+}
+
+// The property the mode exists for: a delta vector carries its own first value,
+// so it decodes without the vector before it. Decoding vector 1 of a page
+// straight out of the middle is what a reader doing block-level random access
+// would do, and it has to produce that vector's values and no others.
+TYPED_TEST(PforTest, DeltaVectorDecodesWithoutThePrecedingVector) {
+  using T = TypeParam;
+  constexpr int32_t kVectorSize = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  constexpr int32_t kNumValues = 3 * kVectorSize;
+
+  std::vector<T> values(kNumValues);
+  std::iota(values.begin(), values.end(), static_cast<T>(500));
+  const std::vector<uint8_t> page = this->EncodePage(values);
+
+  // The offset array follows the header, one entry per vector, each counted
+  // from the start of the array itself.
+  const uint8_t* offsets = page.data() + PforConstants::kHeaderSize;
+  const auto second = util::SafeLoadAs<PforConstants::OffsetType>(
+      offsets + sizeof(PforConstants::OffsetType));
+  const uint8_t* vector = offsets + second;
+
+  std::vector<T> decoded(kVectorSize);
+  ASSERT_OK(PforCompression<T>::DecodeVector(
+      std::span<const uint8_t>(vector, page.data() + page.size() - vector), kVectorSize,
+      decoded.data()));
+  EXPECT_EQ(
+      std::vector<T>(values.begin() + kVectorSize, values.begin() + 2 * kVectorSize),
+      decoded);
+}
+
+// Two-sided patching. A tight cluster with one value far below it is the case
+// the old frame could not handle: at the minimum, the packed window has to span
+// the whole gap and every value in the cluster pays for it. The frame belongs
+// above the low value, which then becomes an exception like any other.
+TYPED_TEST(PforTest, FrameSitsAboveTheMinimumToPatchALowOutlier) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+
+  std::vector<T> values = this->RandomValues(kNumValues, 1'000'000, 1'000'063, 5);
+  values[500] = 0;  // one value four orders of magnitude below the cluster
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_GT(encoded.info().frame_of_reference(),
+            *std::min_element(values.begin(), values.end()));
+  EXPECT_GE(encoded.info().num_exceptions(), 1);
+  // Six bits covers the cluster; spanning the gap would take twenty. The bound
+  // is loose because the search picks the frame from bucketed counts and then
+  // lowers it to the smallest value it actually covers, which lands on the
+  // cluster minimum only when the cluster falls inside one bucket.
+  EXPECT_LE(encoded.info().bit_width(), 8);
+}
+
+// The two features together, on the shape that motivated them: a counter that
+// climbs steadily and resets, whose differences are a run of small positive
+// values with a handful of large negative ones. The differences want a frame
+// above their minimum, and the drops want patching -- neither alone is enough,
+// and this is where both of the encoder's bugs showed up during development.
+TYPED_TEST(PforTest, SawtoothPacksAtNearlyNoCost) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 8192;
+
+  std::vector<T> values(kNumValues);
+  T level = 0;
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    values[i] = level;
+    level = (i % 200 == 199) ? 0 : static_cast<T>(level + 12);
+  }
+
+  int64_t comp_size = 0;
+  this->RoundTripPage(values, &comp_size);
+  // The differences pack at width 0 with one patch per reset. Anything that
+  // falls back to a width wide enough to hold the climb costs at least 12 bits
+  // a value, so a bound of one is far from the boundary.
+  const double bits_per_value = 8.0 * comp_size / kNumValues;
+  EXPECT_LT(bits_per_value, 1.0) << "compressed to " << bits_per_value << " bits/value";
+}
+
+// An exception in a delta vector is itself a difference, so the decoder has to
+// patch before it sums. Summing first would carry the placeholder zero into
+// every value after the patch, which round-trips as a plausible-looking
+// sequence rather than an obvious corruption.
+TYPED_TEST(PforTest, DeltaExceptionsArePatchedBeforeTheSum) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+
+  // A steady climb with occasional jumps far larger than the packed width can
+  // hold, so the jumps become exceptions and everything after one depends on
+  // the patch having landed.
+  std::vector<T> values(kNumValues);
+  T level = 1000;
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    values[i] = level;
+    level = static_cast<T>(level + ((i % 137 == 100) ? 1'000'000 : 3));
+  }
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_TRUE(encoded.info().is_delta());
+  EXPECT_GE(encoded.info().num_exceptions(), 1);
+}
+
+// The delta flag shares its byte with the bit width, and the width goes up to
+// 64, which needs all seven of the bits left over. A vector whose differences
+// span the type is the case that would catch the two fields overlapping.
+TYPED_TEST(PforTest, DeltaAtFullWidthRoundTrips) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+  std::mt19937_64 rng(3);
+
+  // Values whose differences are full-width, built by accumulating full-width
+  // steps, so the sequence wraps the type as it goes.
+  std::vector<T> values(kNumValues);
+  auto acc = static_cast<typename PforTypeTraits<T>::UnsignedType>(0);
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    std::memcpy(&values[i], &acc, sizeof(T));
+    acc += static_cast<typename PforTypeTraits<T>::UnsignedType>(rng());
+  }
+  this->RoundTripVector(values);
+}
+
+// The same overlap, tested at the metadata directly rather than through data
+// that happens to produce it, at every width the type allows.
+TYPED_TEST(PforTest, VectorInfoKeepsTheDeltaFlagOutOfTheWidth) {
+  using T = TypeParam;
+  std::vector<uint8_t> buffer(PforVectorInfo<T>::kStoredSize);
+
+  for (uint8_t width = 0; width <= PforTypeTraits<T>::kMaxBitWidth; ++width) {
+    for (bool is_delta : {false, true}) {
+      SCOPED_TRACE("width " + std::to_string(width) + " delta " +
+                   std::to_string(is_delta));
+      const PforVectorInfo<T> info(static_cast<T>(-7), width, 123, is_delta);
+      info.Store(buffer);
+      ASSERT_OK_AND_ASSIGN(const auto loaded, PforVectorInfo<T>::Load(buffer));
+      EXPECT_EQ(loaded.bit_width(), width);
+      EXPECT_EQ(loaded.is_delta(), is_delta);
+      EXPECT_EQ(loaded.frame_of_reference(), static_cast<T>(-7));
+      EXPECT_EQ(loaded.num_exceptions(), 123);
+      EXPECT_EQ(loaded.stored_bytes(),
+                PforVectorInfo<T>::kStoredSize +
+                    (is_delta ? static_cast<int64_t>(sizeof(T)) : 0));
+    }
+  }
+}
+
+// Differencing is done in the unsigned domain because signed overflow is
+// undefined, and a column spanning the type's range will overflow. The bits
+// have to round-trip anyway.
+TYPED_TEST(PforTest, DeltaRoundTripsAcrossTheTypeExtremes) {
+  using T = TypeParam;
+  const T lo = std::numeric_limits<T>::min();
+  const T hi = std::numeric_limits<T>::max();
+
+  std::vector<std::vector<T>> inputs = {
+      {lo, hi, lo, hi, lo, hi, lo, hi},
+      {lo, static_cast<T>(lo + 1), static_cast<T>(lo + 2), hi, static_cast<T>(hi - 1)},
+      {hi, static_cast<T>(hi - 1), static_cast<T>(hi - 2), lo, static_cast<T>(lo + 1)},
+  };
+  // A ramp from the bottom of the type that runs off the top of it.
+  inputs.emplace_back(1024);
+  auto acc = static_cast<typename PforTypeTraits<T>::UnsignedType>(lo);
+  for (auto& v : inputs.back()) {
+    std::memcpy(&v, &acc, sizeof(T));
+    acc += static_cast<typename PforTypeTraits<T>::UnsignedType>(hi / 100);
+  }
+
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    SCOPED_TRACE("input " + std::to_string(i));
+    this->RoundTripVector(inputs[i]);
+  }
+}
+
+// Small vectors are where the start value is expensive: the format allows eight
+// values to a vector, and eight bytes across eight of them is a byte each. The
+// cost model has to account for it rather than differencing whenever the
+// differences happen to be narrower.
+TYPED_TEST(PforTest, StartValueIsPaidForAtEveryVectorSize) {
+  using T = TypeParam;
+  for (int32_t log_size = PforConstants::kMinLogVectorSize;
+       log_size <= PforConstants::kMaxLogVectorSize; ++log_size) {
+    const int32_t vector_size = 1 << log_size;
+    SCOPED_TRACE("vector size " + std::to_string(vector_size));
+
+    std::vector<T> values(static_cast<size_t>(vector_size) * 3);
+    std::iota(values.begin(), values.end(), static_cast<T>(77));
+
+    const auto num_values = static_cast<int32_t>(values.size());
+    ASSERT_OK_AND_ASSIGN(const int64_t max_size,
+                         PforWrapper<T>::GetMaxCompressedSize(num_values, vector_size));
+    std::vector<uint8_t> compressed(max_size);
+    int64_t comp_size = max_size;
+    ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, vector_size,
+                                     compressed.data(), &comp_size));
+    ASSERT_LE(comp_size, max_size);
+
+    std::vector<T> decoded(values.size());
+    ASSERT_OK(
+        PforWrapper<T>::Decode(compressed.data(), comp_size, num_values, decoded.data()));
+    EXPECT_EQ(values, decoded);
+  }
+}
+
+// A one-element vector has no difference to take, and a two-element one has
+// exactly one. Both are inside the range the format allows for a trailing
+// partial vector.
+TYPED_TEST(PforTest, DeltaHandlesVectorsTooShortToDifference) {
+  using T = TypeParam;
+  this->RoundTripVector(std::vector<T>{42});
+  this->RoundTripVector(std::vector<T>{42, 43});
+  this->RoundTripVector(std::vector<T>{std::numeric_limits<T>::max()});
+  this->RoundTripVector(
+      std::vector<T>{std::numeric_limits<T>::max(), std::numeric_limits<T>::min()});
+}
+
+namespace {
+
+/// A named column shape, for the gate test below.
+template <typename T>
+struct NamedColumn {
+  std::string name;
+  std::vector<T> values;
+};
+
+/// The distributions in pfor_benchmark.cc, plus the extremes, as one battery.
+/// Anything that changes the encoder's mind about differencing has to be seen
+/// on one of these or it is not being tested.
+template <typename T>
+std::vector<NamedColumn<T>> DeltaDecisionColumns() {
+  constexpr int32_t kN = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  std::vector<NamedColumn<T>> columns;
+  auto add = [&columns](std::string name, std::vector<T> values) {
+    columns.push_back({std::move(name), std::move(values)});
+  };
+  auto make = [](auto fn) {
+    std::vector<T> v(kN);
+    for (int32_t i = 0; i < kN; ++i) v[i] = fn(i);
+    return v;
+  };
+
+  add("constant", std::vector<T>(kN, static_cast<T>(-7)));
+  add("ascending", make([](int32_t i) { return static_cast<T>(1'000'000 + i); }));
+  add("descending", make([](int32_t i) { return static_cast<T>(1'000'000 - i); }));
+  add("monotonic_with_gaps", make([](int32_t i) {
+        return static_cast<T>(500'000 + i * 3 + (i % 64 == 0 ? 4096 : 0));
+      }));
+  add("timestamps",
+      make([](int32_t i) { return static_cast<T>(1'700'000'000 + i * 17 + (i % 7)); }));
+  // A ramp that resets: small positive differences with a handful of large
+  // negative ones. The shape the two-sided frame exists for.
+  add("sawtooth",
+      make([](int32_t i) { return static_cast<T>((i % 200) * 13 + 100'000); }));
+  add("cluster_far_from_zero",
+      make([](int32_t i) { return static_cast<T>(1'000'000 + (i % 37)); }));
+  add("two_clusters", make([](int32_t i) {
+        return static_cast<T>(i % 2 == 0 ? 100 + (i % 8) : 900'000 + (i % 8));
+      }));
+  add("cluster_with_outliers", make([](int32_t i) {
+        return static_cast<T>(i % 97 == 0 ? 1'000'000 + i : 500 + (i % 11));
+      }));
+  add("type_extremes", make([](int32_t i) {
+        return i % 2 == 0 ? std::numeric_limits<T>::lowest() + static_cast<T>(i)
+                          : std::numeric_limits<T>::max() - static_cast<T>(i);
+      }));
+  // A random walk, and independent draws at several spreads. The walk is where
+  // differencing pays; the draws are where it must be declined.
+  for (uint32_t seed : {1u, 7u, 42u, 1234u}) {
+    std::mt19937 rng(seed);
+    std::uniform_int_distribution<int32_t> step(-40, 40);
+    auto walk = static_cast<UnsignedT>(0);
+    std::vector<T> values(kN);
+    for (int32_t i = 0; i < kN; ++i) {
+      walk += static_cast<UnsignedT>(static_cast<T>(step(rng)));
+      std::memcpy(&values[i], &walk, sizeof(T));
+    }
+    add("random_walk_" + std::to_string(seed), std::move(values));
+  }
+  for (T spread : {static_cast<T>(1), static_cast<T>(1000), static_cast<T>(1'000'000)}) {
+    for (uint32_t seed : {3u, 99u}) {
+      std::vector<T> values(kN);
+      std::mt19937 rng(seed);
+      std::uniform_int_distribution<T> dist(static_cast<T>(0), spread);
+      for (auto& v : values) v = dist(rng);
+      add("noise_" + std::to_string(static_cast<int64_t>(spread)) + "_" +
+              std::to_string(seed),
+          std::move(values));
+    }
+  }
+  return columns;
+}
+
+/// What ChooseVectorPlan would decide with no gate in front of the delta
+/// search: cost both modes properly and keep the cheaper.
+template <typename T>
+PforVectorPlan<T> ChooseVectorPlanUngated(const T* values, int32_t num_elements,
+                                          T* delta_scratch) {
+  const FrameChoice<T> raw = ChooseFrameAndWidth<T>(values, num_elements);
+  PforVectorPlan<T> plan;
+  plan.frame_of_reference = raw.frame_of_reference;
+  plan.bit_width = raw.bit_width;
+  plan.num_exceptions = raw.num_exceptions;
+  plan.cost_bits = raw.cost_bits;
+  if (num_elements < 2 || raw.bit_width == 0) return plan;
+
+  MinMax<T> delta_bounds;
+  ComputeDeltas<T>(values, num_elements, delta_scratch, &delta_bounds);
+  const FrameChoice<T> delta =
+      ChooseFrameAndWidth<T>(delta_scratch, num_elements, delta_bounds);
+  const int64_t delta_cost = delta.cost_bits + static_cast<int64_t>(sizeof(T)) * 8;
+  if (delta_cost < plan.cost_bits) {
+    plan.delta = true;
+    plan.frame_of_reference = delta.frame_of_reference;
+    plan.start_value = values[0];
+    plan.bit_width = delta.bit_width;
+    plan.num_exceptions = delta.num_exceptions;
+    plan.cost_bits = delta_cost;
+  }
+  return plan;
+}
+
+}  // namespace
+
+// The gate in front of the delta search is an estimate, so it can in principle
+// decline a vector the search would have won. Pin that it does not, on every
+// shape the encoder is meant to handle: same mode, same width, same cost as the
+// ungated chooser. A change that makes the estimate too pessimistic shows up
+// here as a lost delta rather than as a silent ratio regression.
+TYPED_TEST(PforTest, DeltaGateAgreesWithTheUngatedChooser) {
+  using T = TypeParam;
+  int delta_chosen = 0;
+  for (const auto& column : DeltaDecisionColumns<T>()) {
+    SCOPED_TRACE(column.name);
+    const auto n = static_cast<int32_t>(column.values.size());
+    std::vector<T> scratch(n);
+    const PforVectorPlan<T> gated =
+        ChooseVectorPlan<T>(column.values.data(), n, scratch.data(),
+                            /*delta_enabled=*/true);
+    const PforVectorPlan<T> ungated =
+        ChooseVectorPlanUngated<T>(column.values.data(), n, scratch.data());
+
+    EXPECT_EQ(ungated.delta, gated.delta);
+    EXPECT_EQ(ungated.cost_bits, gated.cost_bits);
+    EXPECT_EQ(ungated.bit_width, gated.bit_width);
+    EXPECT_EQ(ungated.frame_of_reference, gated.frame_of_reference);
+    EXPECT_EQ(ungated.num_exceptions, gated.num_exceptions);
+    if (gated.delta) ++delta_chosen;
+  }
+  // The battery has to exercise both answers, or the agreement above is only
+  // evidence that the gate declines everything.
+  EXPECT_GT(delta_chosen, 0);
+}
+
+// The estimate is the point of the gate, so check it reaches the shape it was
+// built for. A gate reading the spread of the differences rather than their
+// distribution declines the sawtooth, whose differences are as widely spread as
+// its values and far cheaper to pack.
+TYPED_TEST(PforTest, DeltaGateAdmitsTheSawtooth) {
+  using T = TypeParam;
+  constexpr int32_t kN = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  std::vector<T> values(kN);
+  for (int32_t i = 0; i < kN; ++i) {
+    values[i] = static_cast<T>((i % 200) * 13 + 100'000);
+  }
+  std::vector<T> scratch(kN);
+  const PforVectorPlan<T> plan =
+      ChooseVectorPlan<T>(values.data(), kN, scratch.data(), /*delta_enabled=*/true);
+  EXPECT_TRUE(plan.delta);
+  // Five resets in 1024 values, patched, leaving a very narrow packed window.
+  EXPECT_LE(plan.bit_width, 5);
+}
+
+// Interleaved bit-packing layout
+//
+// The interleaved layout writes the same number of bytes as the sequential one,
+// so a wrong-layout decode returns wrong values rather than running out of
+// input. That makes these round trips the only thing standing between the two
+// layouts, and it is why the tests below also assert that the two payloads are
+// genuinely different bytes: without that, a silent fallback on both sides
+// would pass every round trip here.
+
+namespace {
+
+/// The packing_mode byte a page recorded, which is the first byte of the header.
+uint8_t PackingModeOf(const std::vector<uint8_t>& page) { return page[0]; }
+
+/// Build a vector whose deltas need exactly `width` bits, so that a loop over
+/// widths reaches every one of the packing kernels.
+///
+/// A frame of reference of zero exercises the plain unpack; a non-zero one the
+/// unpack that folds the frame into its own store. At the full width of the type
+/// there is no choice between them: deltas that wide only fit under the type's
+/// minimum, so that width is always framed.
+template <typename T>
+std::vector<T> ValuesForWidth(int width, bool zero_frame, int32_t num_values,
+                              uint32_t seed) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr int kBits = 8 * static_cast<int>(sizeof(T));
+
+  const T base =
+      width == kBits ? std::numeric_limits<T>::min() : (zero_frame ? T{0} : T{-1000});
+  std::vector<T> values(num_values, base);
+  if (width == 0) {
+    return values;
+  }
+
+  const UnsignedT mask = width == kBits
+                             ? ~UnsignedT{0}
+                             : static_cast<UnsignedT>((UnsignedT{1} << width) - 1);
+  std::mt19937_64 rng(seed);
+  for (int32_t i = 0; i < num_values; ++i) {
+    values[i] = static_cast<T>(static_cast<UnsignedT>(base) +
+                               (static_cast<UnsignedT>(rng()) & mask));
+  }
+  // Pin the two ends, so the vector cannot land on a narrower width by chance.
+  values[0] = base;
+  values[1] = static_cast<T>(static_cast<UnsignedT>(base) + mask);
+  return values;
+}
+
+}  // namespace
+
+/// Every bit width round-trips through the interleaved layout, with and without
+/// a frame of reference to fold into the unpack.
+///
+/// For int64 this exercises the other side of the same request: the layout does
+/// not apply, so the page must come back correct in the sequential layout.
+TYPED_TEST(PforTest, InterleavedAllBitWidths) {
+  using T = TypeParam;
+  constexpr auto kInterleaved = PackingMode::kForBitPackInterleaved;
+  const auto num_values = static_cast<int32_t>(PforConstants::kPforVectorSize);
+
+  for (int width = 0; width <= 32; ++width) {
+    for (const bool zero_frame : {true, false}) {
+      // A 32-bit delta only fits under the minimum of a 32-bit type, so there is
+      // no unframed form of that width to test.
+      if (zero_frame && width == 8 * static_cast<int>(sizeof(T))) continue;
+      const auto values =
+          ValuesForWidth<T>(width, zero_frame, num_values, static_cast<uint32_t>(width));
+
+      int64_t comp_size = PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+      std::vector<uint8_t> page(comp_size);
+      ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, page.data(), &comp_size,
+                                       kInterleaved));
+      page.resize(comp_size);
+
+      std::vector<T> decoded(num_values);
+      ASSERT_OK(
+          PforWrapper<T>::Decode(page.data(), comp_size, num_values, decoded.data()))
+          << "width " << width << " zero_frame " << zero_frame;
+      ASSERT_EQ(values, decoded) << "width " << width << " zero_frame " << zero_frame;
+
+      const uint8_t expected_mode =
+          static_cast<uint8_t>(sizeof(T) == 4 ? kInterleaved : PackingMode::kForBitPack);
+      ASSERT_EQ(expected_mode, PackingModeOf(page)) << "width " << width;
+    }
+  }
+}
+
+/// Exceptions are stored at the positions the encoder recorded, and the
+/// interleaved layout does not move values between positions, so those
+/// positions need no translation.
+TYPED_TEST(PforTest, InterleavedWithExceptions) {
+  using T = TypeParam;
+  const auto num_values = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  auto values = TestFixture::RandomValues(num_values, T{100}, T{140}, /*seed=*/7);
+  // First, middle and last position, so an off-by-one in either direction shows.
+  values[0] = std::numeric_limits<T>::max() / 2;
+  values[num_values / 2] = std::numeric_limits<T>::max() / 2;
+  values[num_values - 1] = std::numeric_limits<T>::max() / 2;
+
+  int64_t comp_size = PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+  std::vector<uint8_t> page(comp_size);
+  ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, page.data(), &comp_size,
+                                   PackingMode::kForBitPackInterleaved));
+
+  std::vector<T> decoded(num_values);
+  ASSERT_OK(PforWrapper<T>::Decode(page.data(), comp_size, num_values, decoded.data()));
+  ASSERT_EQ(values, decoded);
+}
+
+/// A page whose length is not a multiple of the vector size ends in a short
+/// vector, which the interleaved layout cannot hold. Both sides derive that from
+/// the element count, so it round-trips without a per-vector flag.
+TYPED_TEST(PforTest, InterleavedShortTailVector) {
+  using T = TypeParam;
+  for (const int32_t num_values : {1, 1023, 1025, 2048, 3000, 4096}) {
+    auto values = TestFixture::RandomValues(num_values, T{0}, T{5000},
+                                            static_cast<uint32_t>(num_values));
+    int64_t comp_size = PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> page(comp_size);
+    ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, page.data(), &comp_size,
+                                     PackingMode::kForBitPackInterleaved));
+
+    std::vector<T> decoded(num_values);
+    ASSERT_OK(PforWrapper<T>::Decode(page.data(), comp_size, num_values, decoded.data()))
+        << "num_values " << num_values;
+    ASSERT_EQ(values, decoded) << "num_values " << num_values;
+  }
+}
+
+/// The two layouts write the same number of bytes, so choosing one costs no
+/// space.
+TYPED_TEST(PforTest, InterleavedCostsNoSpace) {
+  using T = TypeParam;
+  for (const int32_t num_values : {1024, 2048, 3000}) {
+    auto values = TestFixture::RandomValues(num_values, T{0}, T{5000}, /*seed=*/11);
+
+    int64_t sequential_size =
+        PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> sequential(sequential_size);
+    ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, sequential.data(),
+                                     &sequential_size));
+
+    int64_t interleaved_size =
+        PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> interleaved(interleaved_size);
+    ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, interleaved.data(),
+                                     &interleaved_size,
+                                     PackingMode::kForBitPackInterleaved));
+
+    ASSERT_EQ(sequential_size, interleaved_size) << "num_values " << num_values;
+  }
+}
+
+/// The two layouts really are different bytes, which is what keeps the round
+/// trips above honest: if a mode request quietly fell back to sequential on both
+/// the encode and the decode side, every one of them would still pass.
+///
+/// At 32 bits the layouts coincide -- the sequential layout puts value i in word
+/// i, and so does the interleaved one -- so the payloads are identical there by
+/// construction, not by accident.
+TEST(PforInterleavedTest, LayoutsDifferBelowThirtyTwoBits) {
+  using T = int32_t;
+  const auto num_values = static_cast<int32_t>(PforConstants::kPforVectorSize);
+
+  for (int width = 1; width <= 32; ++width) {
+    const auto values = ValuesForWidth<T>(width, /*zero_frame=*/width < 32, num_values,
+                                          static_cast<uint32_t>(width));
+
+    int64_t sequential_size =
+        PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> sequential(sequential_size);
+    ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, sequential.data(),
+                                     &sequential_size));
+    sequential.resize(sequential_size);
+
+    int64_t interleaved_size =
+        PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> interleaved(interleaved_size);
+    ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, interleaved.data(),
+                                     &interleaved_size,
+                                     PackingMode::kForBitPackInterleaved));
+    interleaved.resize(interleaved_size);
+
+    ASSERT_EQ(sequential.size(), interleaved.size()) << "width " << width;
+
+    // The cost model is free to choose a narrower width and pay for exceptions,
+    // which would leave this loop testing one width many times over. Read the
+    // width it settled on out of the vector's own metadata: header, then the
+    // one-entry offset array, then the frame of reference.
+    const int64_t bit_width_offset =
+        PforConstants::kHeaderSize +
+        static_cast<int64_t>(sizeof(PforConstants::OffsetType)) +
+        static_cast<int64_t>(sizeof(T));
+    ASSERT_EQ(width, sequential[bit_width_offset]) << "requested width " << width;
+
+    // Skip the header, whose packing_mode byte differs on purpose.
+    const bool payload_differs =
+        !std::equal(sequential.begin() + PforConstants::kHeaderSize, sequential.end(),
+                    interleaved.begin() + PforConstants::kHeaderSize);
+    if (width == 32) {
+      ASSERT_FALSE(payload_differs) << "the layouts coincide at 32 bits";
+    } else {
+      ASSERT_TRUE(payload_differs) << "width " << width;
+    }
+  }
+}
+
+/// A request the page cannot satisfy is recorded as the sequential layout rather
+/// than refused, so one writer-side setting can cover a file whose columns are
+/// not all eligible.
+TEST(PforInterleavedTest, UnsatisfiableRequestRecordsSequential) {
+  const auto num_values = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  constexpr auto kInterleaved = PackingMode::kForBitPackInterleaved;
+
+  // Eight bytes per element.
+  {
+    std::vector<int64_t> values(num_values);
+    std::iota(values.begin(), values.end(), int64_t{1} << 40);
+    int64_t comp_size =
+        PforWrapper<int64_t>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> page(comp_size);
+    ASSERT_OK(PforWrapper<int64_t>::Encode(values.data(), num_values, page.data(),
+                                           &comp_size, kInterleaved));
+    ASSERT_EQ(static_cast<uint8_t>(PackingMode::kForBitPack), PackingModeOf(page));
+
+    std::vector<int64_t> decoded(num_values);
+    ASSERT_OK(
+        PforWrapper<int64_t>::Decode(page.data(), comp_size, num_values, decoded.data()));
+    ASSERT_EQ(values, decoded);
+  }
+
+  // A vector size other than 1024.
+  {
+    std::vector<int32_t> values(num_values);
+    std::iota(values.begin(), values.end(), 0);
+    constexpr int32_t kVectorSize = 512;
+    int64_t comp_size =
+        PforWrapper<int32_t>::GetMaxCompressedSize(num_values, kVectorSize).ValueOrDie();
+    std::vector<uint8_t> page(comp_size);
+    ASSERT_OK(PforWrapper<int32_t>::Encode(values.data(), num_values, kVectorSize,
+                                           page.data(), &comp_size, kInterleaved));
+    ASSERT_EQ(static_cast<uint8_t>(PackingMode::kForBitPack), PackingModeOf(page));
+
+    std::vector<int32_t> decoded(num_values);
+    ASSERT_OK(
+        PforWrapper<int32_t>::Decode(page.data(), comp_size, num_values, decoded.data()));
+    ASSERT_EQ(values, decoded);
+  }
+}
+
+/// A page that declares the interleaved layout alongside a vector size or an
+/// element width that cannot support it is rejected, rather than decoded into
+/// wrong values.
+TEST(PforInterleavedTest, ForgedHeaderIsRejected) {
+  const auto num_values = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  std::vector<int32_t> values(num_values);
+  std::iota(values.begin(), values.end(), 0);
+  constexpr int32_t kVectorSize = 512;
+
+  int64_t comp_size =
+      PforWrapper<int32_t>::GetMaxCompressedSize(num_values, kVectorSize).ValueOrDie();
+  std::vector<uint8_t> page(comp_size);
+  ASSERT_OK(PforWrapper<int32_t>::Encode(values.data(), num_values, kVectorSize,
+                                         page.data(), &comp_size));
+
+  std::vector<int32_t> decoded(num_values);
+  page[0] = static_cast<uint8_t>(PackingMode::kForBitPackInterleaved);
+  ASSERT_RAISES(Invalid, PforWrapper<int32_t>::Decode(page.data(), comp_size, num_values,
+                                                      decoded.data()));
+
+  // An unknown layout is an error too, so a page written by a later encoder is
+  // refused instead of misread. The two layouts are the same size, so a reader
+  // that guessed would not run short.
+  page[0] = 2;
+  ASSERT_RAISES(Invalid, PforWrapper<int32_t>::Decode(page.data(), comp_size, num_values,
+                                                      decoded.data()));
+}
+
+}  // namespace arrow::util::pfor
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper.cc b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
new file mode 100644
index 000000000000..ee3cef2cff98
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
@@ -0,0 +1,397 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// PFOR page-level wrapper implementation
+//
+// Page layout:
+//   [Header 7B] [Offset Array: numVectors * 4B] [Vector 0] [Vector 1] ...
+//
+// Each vector:
+//   [PforVectorInfo] [PackedValues] [ExceptionPositions] [ExceptionValues]
+
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+
+#include <algorithm>
+#include <bit>
+#include <cstring>
+#include <span>
+#include <vector>
+
+#include "arrow/util/bit_util.h"
+#include "arrow/util/endian.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/ubsan.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+namespace {
+
+/// Width of one entry in the per-page offset array.
+constexpr int64_t kOffsetSize = sizeof(PforConstants::OffsetType);
+
+/// \brief Accept only the vector sizes the page header can describe
+///
+/// A size outside this range would encode a page that Decode then rejects, so
+/// refuse it up front.
+Status ValidateVectorSize(int32_t vector_size) {
+  if (!std::has_single_bit(static_cast<uint32_t>(vector_size)) ||
+      vector_size < (1 << PforConstants::kMinLogVectorSize) ||
+      vector_size > PforConstants::kMaxVectorSize) {
+    return Status::Invalid("PFOR vector_size must be a power of two in [",
+                           1 << PforConstants::kMinLogVectorSize, ", ",
+                           PforConstants::kMaxVectorSize, "]: ", vector_size);
+  }
+  return Status::OK();
+}
+
+/// \brief Check the offset array before any of it steers a read
+///
+/// The offsets are byte counts from the start of the offset array, and the
+/// vectors they point at were written back to back in order, so a well-formed
+/// page has the first offset landing just past the array and the rest strictly
+/// increasing. Checking the chain as a whole, before decoding any of it, keeps a
+/// page whose offsets overlap or run backwards from decoding part-way and
+/// emitting values built out of the wrong bytes.
+Status ValidateOffsets(const uint8_t* offset_array_start, int32_t num_vectors,
+                       int64_t offset_array_size, int64_t payload_size) {
+  int64_t previous = -1;
+  for (int32_t v = 0; v < num_vectors; ++v) {
+    const int64_t offset =
+        bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::OffsetType>(
+            offset_array_start + v * kOffsetSize));
+    if (v == 0) {
+      if (offset != offset_array_size) {
+        return Status::Invalid("PFOR first vector offset ", offset,
+                               " does not follow the ", offset_array_size,
+                               " byte offset array");
+      }
+    } else if (offset <= previous) {
+      return Status::Invalid("PFOR vector ", v, " offset ", offset,
+                             " does not follow offset ", previous,
+                             " of the vector before it");
+    }
+    if (offset >= payload_size) {
+      return Status::Invalid("PFOR vector ", v, " offset ", offset,
+                             " is past the end of the ", payload_size, " byte payload");
+    }
+    previous = offset;
+  }
+  return Status::OK();
+}
+
+}  // namespace
+
+// ----------------------------------------------------------------------
+// Header serialization
+
+template <typename T>
+void PforWrapper<T>::StoreHeader(std::span<uint8_t> dest, const PforHeader& header) {
+  static_assert(PforConstants::kHeaderSize == sizeof(PforHeader::packing_mode) +
+                                                  sizeof(PforHeader::log_vector_size) +
+                                                  sizeof(PforHeader::value_byte_width) +
+                                                  sizeof(PforHeader::num_elements),
+                "kHeaderSize must match the fields StoreHeader and LoadHeader move");
+  uint8_t* ptr = dest.data();
+  util::SafeStore(ptr + 0, header.packing_mode);
+  util::SafeStore(ptr + 1, header.log_vector_size);
+  util::SafeStore(ptr + 2, header.value_byte_width);
+  util::SafeStore(ptr + 3, bit_util::ToLittleEndian(header.num_elements));
+}
+
+template <typename T>
+Result<typename PforWrapper<T>::PforHeader> PforWrapper<T>::LoadHeader(
+    std::span<const uint8_t> src) {
+  if (src.size() < static_cast<size_t>(PforConstants::kHeaderSize)) {
+    return Status::Invalid("PFOR compressed buffer too small for header: ", src.size(),
+                           " < ", PforConstants::kHeaderSize);
+  }
+  PforHeader header;
+  const uint8_t* ptr = src.data();
+  header.packing_mode = util::SafeLoadAs<uint8_t>(ptr + 0);
+  header.log_vector_size = util::SafeLoadAs<uint8_t>(ptr + 1);
+  header.value_byte_width = util::SafeLoadAs<uint8_t>(ptr + 2);
+  header.num_elements = bit_util::FromLittleEndian(util::SafeLoadAs<int32_t>(ptr + 3));
+
+  if (!IsSupportedPackingMode(header.packing_mode)) {
+    return Status::Invalid("PFOR unsupported packing mode: ",
+                           static_cast<int>(header.packing_mode));
+  }
+  if (header.value_byte_width != sizeof(T)) {
+    return Status::Invalid(
+        "PFOR value_byte_width mismatch: ", static_cast<int>(header.value_byte_width),
+        " vs expected ", sizeof(T));
+  }
+  if (header.log_vector_size < PforConstants::kMinLogVectorSize ||
+      header.log_vector_size > PforConstants::kMaxLogVectorSize) {
+    return Status::Invalid("PFOR invalid log_vector_size: ",
+                           static_cast<int>(header.log_vector_size));
+  }
+  if (header.num_elements < 0) {
+    return Status::Invalid("PFOR invalid num_elements: ", header.num_elements);
+  }
+  // The interleaved layout is defined for one block of 1024 four-byte values, so
+  // a page that declares it and then declares a vector size or a value width it
+  // can never apply to is self-contradictory. Rejecting it here means the decode
+  // loop never has to ask whether the mode it was handed is reachable.
+  if (header.packing_mode == static_cast<uint8_t>(PackingMode::kForBitPackInterleaved)) {
+    if (header.log_vector_size != PforConstants::kDefaultLogVectorSize) {
+      return Status::Invalid("PFOR interleaved layout needs a vector size of ",
+                             PforConstants::kPforVectorSize,
+                             " but the page declares log_vector_size ",
+                             static_cast<int>(header.log_vector_size));
+    }
+    if (header.value_byte_width != 4) {
+      return Status::Invalid(
+          "PFOR interleaved layout needs 4-byte values but the page declares ",
+          static_cast<int>(header.value_byte_width));
+    }
+  }
+  return header;
+}
+
+// ----------------------------------------------------------------------
+// Encode
+
+template <typename T>
+Status PforWrapper<T>::Encode(const T* values, int32_t num_values, int32_t vector_size,
+                              uint8_t* comp, int64_t* comp_size,
+                              const PforEncodeOptions& options) {
+  if (num_values < 0) {
+    return Status::Invalid("PFOR num_values must be non-negative: ", num_values);
+  }
+  // An all-null page holds no values and is still written, and a reader loads the
+  // header before it knows how many values a page has, so zero values encodes to a
+  // bare header rather than to nothing at all. The buffer it comes from is empty in
+  // that case, and an empty container is entitled to a null data pointer.
+  if (values == nullptr && num_values > 0) {
+    return Status::Invalid("PFOR input pointer is null");
+  }
+  if (comp == nullptr) {
+    return Status::Invalid("PFOR output pointer is null");
+  }
+  if (comp_size == nullptr) {
+    return Status::Invalid("PFOR output size pointer is null");
+  }
+  RETURN_NOT_OK(ValidateVectorSize(vector_size));
+
+  // Everything below writes into `comp` without re-checking, including the
+  // header and the offset array, so confirm once that the caller gave us the
+  // buffer the API asks for.
+  ARROW_ASSIGN_OR_RAISE(const int64_t max_size,
+                        GetMaxCompressedSize(num_values, vector_size));
+  if (*comp_size < max_size) {
+    return Status::Invalid("PFOR output buffer of ", *comp_size,
+                           " bytes is smaller than the ", max_size, " bytes ", num_values,
+                           " values may need");
+  }
+
+  const int32_t num_vectors =
+      static_cast<int32_t>(bit_util::CeilDiv(num_values, vector_size));
+
+  // ValidateVectorSize has already established that vector_size is a power of
+  // two, so its trailing-zero count is log2 of it.
+  const auto log_vector_size =
+      static_cast<uint8_t>(std::countr_zero(static_cast<uint32_t>(vector_size)));
+
+  uint8_t* dest = comp;
+
+  // A page's layout is one byte in its header, so a request the page cannot
+  // satisfy is answered by writing the layout actually used rather than by
+  // failing: a writer sets the option once for a file and every column type and
+  // vector size then has to encode under it. LoadHeader rejects the combination
+  // this drops, so the downgrade is what keeps the header honest.
+  const PackingMode effective_mode =
+      (options.mode == PackingMode::kForBitPackInterleaved && sizeof(T) == 4 &&
+       vector_size == static_cast<int32_t>(PforConstants::kPforVectorSize))
+          ? PackingMode::kForBitPackInterleaved
+          : PackingMode::kForBitPack;
+
+  // Step 1: Write header
+  PforHeader header;
+  header.packing_mode = static_cast<uint8_t>(effective_mode);
+  header.log_vector_size = log_vector_size;
+  header.value_byte_width = sizeof(T);
+  header.num_elements = num_values;
+  StoreHeader(std::span<uint8_t>(dest, PforConstants::kHeaderSize), header);
+  uint8_t* write_ptr = dest + PforConstants::kHeaderSize;
+
+  // Step 2: Reserve space for offset array
+  uint8_t* offset_array_start = write_ptr;
+  write_ptr += num_vectors * kOffsetSize;
+
+  // Step 3: Encode each vector and build offset array
+  const uint8_t* data_start = offset_array_start;
+
+  for (int32_t v = 0; v < num_vectors; ++v) {
+    // Record offset (from start of offset array)
+    const auto offset = static_cast<PforConstants::OffsetType>(write_ptr - data_start);
+    util::SafeStore(offset_array_start + v * kOffsetSize,
+                    bit_util::ToLittleEndian(offset));
+
+    // Determine elements in this vector
+    int32_t start_idx = v * vector_size;
+    int32_t elements_in_vector = std::min(vector_size, num_values - start_idx);
+
+    // EncodeVector applies the interleaved layout only to a full block, so the
+    // short tail vector of a page falls back on its own; the decoder derives the
+    // same split from the same element count.
+    auto encoded = PforCompression<T>::EncodeVector(
+        values + start_idx, elements_in_vector,
+        PforEncodeOptions{options.delta_enabled, effective_mode});
+
+    // Serialize to output
+    ARROW_ASSIGN_OR_RAISE(
+        const int64_t bytes_written,
+        PforCompression<T>::SerializeVector(
+            encoded, elements_in_vector,
+            std::span<uint8_t>(write_ptr, dest + *comp_size - write_ptr)));
+    write_ptr += bytes_written;
+  }
+
+  *comp_size = static_cast<int64_t>(write_ptr - dest);
+  return Status::OK();
+}
+
+template <typename T>
+Status PforWrapper<T>::Encode(const T* values, int32_t num_values, uint8_t* comp,
+                              int64_t* comp_size, const PforEncodeOptions& options) {
+  return Encode(values, num_values, kVectorSize, comp, comp_size, options);
+}
+
+// ----------------------------------------------------------------------
+// Decode
+
+template <typename T>
+Status PforWrapper<T>::Decode(const uint8_t* comp, int64_t comp_size, int32_t num_values,
+                              T* values) {
+  if (num_values < 0) {
+    return Status::Invalid("PFOR num_values must be non-negative: ", num_values);
+  }
+  if (comp == nullptr) {
+    return Status::Invalid("PFOR compressed data pointer is null");
+  }
+  // Every bound below is expressed against `comp_size`, and it also becomes the
+  // size of a std::span, where a negative value would convert to a huge size_t
+  // and read past the end of the buffer.
+  if (comp_size < PforConstants::kHeaderSize) {
+    return Status::Invalid("PFOR compressed buffer too small for header: ", comp_size,
+                           " < ", PforConstants::kHeaderSize);
+  }
+
+  const uint8_t* src = comp;
+
+  // Step 1: Read header
+  ARROW_ASSIGN_OR_RAISE(PforHeader header,
+                        LoadHeader(std::span<const uint8_t>(src, comp_size)));
+
+  // The loop below sizes its work from the header's count while `values` is only
+  // as large as `num_values`, so a header claiming more would write past the end
+  // of the output and one claiming fewer would fill part of it and still return
+  // OK, leaving the rest whatever it held before. Require the two to agree.
+  if (header.num_elements != num_values) {
+    return Status::Invalid("PFOR header element count ", header.num_elements,
+                           " does not match the expected value count ", num_values);
+  }
+
+  const int32_t vector_size = 1 << header.log_vector_size;
+  const int32_t num_vectors =
+      static_cast<int32_t>(bit_util::CeilDiv(header.num_elements, vector_size));
+
+  // Step 2: Read and check the offset array
+  const uint8_t* offset_array_start = src + PforConstants::kHeaderSize;
+  const int64_t offset_array_size = num_vectors * kOffsetSize;
+  if (PforConstants::kHeaderSize + offset_array_size > comp_size) {
+    return Status::Invalid("PFOR offset array for ", num_vectors,
+                           " vectors does not fit in ", comp_size, " bytes");
+  }
+  const int64_t payload_size = comp_size - PforConstants::kHeaderSize;
+  ARROW_RETURN_NOT_OK(
+      ValidateOffsets(offset_array_start, num_vectors, offset_array_size, payload_size));
+
+  // Step 3: Decode each vector
+  for (int32_t v = 0; v < num_vectors; ++v) {
+    const auto offset =
+        bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::OffsetType>(
+            offset_array_start + v * kOffsetSize));
+    const uint8_t* vector_data = offset_array_start + offset;
+
+    int32_t start_idx = v * vector_size;
+    int32_t elements_in_vector = std::min(vector_size, header.num_elements - start_idx);
+
+    ARROW_RETURN_NOT_OK(PforCompression<T>::DecodeVector(
+        std::span<const uint8_t>(vector_data, src + comp_size - vector_data),
+        elements_in_vector, values + start_idx,
+        static_cast<PackingMode>(header.packing_mode)));
+  }
+
+  return Status::OK();
+}
+
+// ----------------------------------------------------------------------
+// DecodeElementCount
+
+template <typename T>
+Result<int32_t> PforWrapper<T>::DecodeElementCount(const uint8_t* comp,
+                                                   int64_t comp_size) {
+  if (comp == nullptr) {
+    return Status::Invalid("PFOR compressed data pointer is null");
+  }
+  if (comp_size < 0) {
+    return Status::Invalid("PFOR compressed size must be non-negative: ", comp_size);
+  }
+  ARROW_ASSIGN_OR_RAISE(const PforHeader header,
+                        LoadHeader(std::span<const uint8_t>(comp, comp_size)));
+  return header.num_elements;
+}
+
+// ----------------------------------------------------------------------
+// GetMaxCompressedSize
+
+template <typename T>
+Result<int64_t> PforWrapper<T>::GetMaxCompressedSize(int32_t num_values,
+                                                     int32_t vector_size) {
+  if (num_values < 0) {
+    return Status::Invalid("PFOR num_values must be non-negative: ", num_values);
+  }
+  RETURN_NOT_OK(ValidateVectorSize(vector_size));
+
+  const int64_t num_vectors = bit_util::CeilDiv(num_values, vector_size);
+
+  // A vector never serializes to more than its values occupy unpacked. The cost
+  // model minimises `num_elements * bit_width + num_exceptions * (16 +
+  // 8 * sizeof(T))` bits, and the full-width candidate scores
+  // `num_elements * 8 * sizeof(T)` bits with no exceptions at all, so whatever
+  // width it does pick costs no more than that. Bit packing rounds the packed
+  // section up to a whole byte, hence the trailing byte. The delta mode adds
+  // one full-width start value, and the model only chooses it when doing so
+  // still comes out cheaper, but the bound has to hold for either outcome.
+  const int64_t max_vector_size = PforVectorInfo<T>::kStoredSize +
+                                  static_cast<int64_t>(sizeof(T)) +
+                                  vector_size * static_cast<int64_t>(sizeof(T)) + 1;
+
+  return PforConstants::kHeaderSize + num_vectors * (kOffsetSize + max_vector_size);
+}
+
+// Explicit template instantiations
+template class PforWrapper<int32_t>;
+template class PforWrapper<int64_t>;
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
new file mode 100644
index 000000000000..ef8b44aa05c1
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
@@ -0,0 +1,131 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// High-level wrapper interface for PFOR compression
+//
+// Handles page-level serialization: header, offset array, and vectors.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <span>
+
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/pfor/pfor_internal.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+/// \class PforWrapper
+/// \brief High-level interface for PFOR page-level compression
+///
+/// Manages the page layout: [Header 7B] [Offset Array] [Vector 0] [Vector 1] ...
+///
+/// \tparam T the integer type (int32_t or int64_t)
+template <typename T>
+class PforWrapper {
+ public:
+  /// \brief Encode integer values into a PFOR-compressed page
+  ///
+  /// \param[in] values pointer to input integers
+  /// \param[in] num_values total number of values; zero writes a bare header,
+  ///            which is what an all-null page encodes to
+  /// \param[in] vector_size number of elements per vector (must be a power of 2,
+  ///            in [2^kMinLogVectorSize, 2^kMaxLogVectorSize])
+  /// \param[out] comp pointer to output buffer, at least
+  ///             GetMaxCompressedSize(num_values, vector_size) bytes
+  /// \param[in,out] comp_size input: available buffer size, which must be at
+  ///                least GetMaxCompressedSize(num_values, vector_size);
+  ///                output: bytes written
+  /// \param[in] options what the encoder is allowed to choose: whether to
+  ///            difference the vector, and which bit-packing layout to use.
+  ///            A request for PackingMode::kForBitPackInterleaved that this
+  ///            page cannot satisfy -- a 64-bit column, or a vector size
+  ///            other than kPforVectorSize -- is written as
+  ///            PackingMode::kForBitPack instead of refused, so that one
+  ///            writer-level setting can cover a file of mixed column types.
+  ///            Either way the page says which layout it holds.
+  /// \return Status::OK on success, or an error if the arguments are invalid
+  static Status Encode(const T* values, int32_t num_values, int32_t vector_size,
+                       uint8_t* comp, int64_t* comp_size,
+                       const PforEncodeOptions& options = {});
+
+  /// Convenience overload with default vector_size = kPforVectorSize
+  static Status Encode(const T* values, int32_t num_values, uint8_t* comp,
+                       int64_t* comp_size, const PforEncodeOptions& options = {});
+
+  /// \brief Decode a PFOR-compressed page
+  ///
+  /// \param[in] comp pointer to compressed data
+  /// \param[in] comp_size size of compressed data
+  /// \param[in] num_values number of values the page holds, which must equal the
+  ///            count in its header; DecodeElementCount reads that count. Zero is
+  ///            valid: an all-null page is a bare header.
+  /// \param[out] values pointer to output buffer, sized for num_values
+  /// \return Status::OK on success, or an error if the data is malformed
+  ///
+  /// The payload layout is not a parameter: it comes from the page's own header,
+  /// so a reader does not have to be told which one a page holds, and a page
+  /// written under a layout this build does not implement is rejected by
+  /// LoadHeader rather than misread.
+  static Status Decode(const uint8_t* comp, int64_t comp_size, int32_t num_values,
+                       T* values);
+
+  /// \brief Read the value count a page declares in its own header
+  ///
+  /// The parquet page header counts nulls, which a PFOR page does not store, so
+  /// a caller holding a page needs this to learn how many values are in it.
+  ///
+  /// \param[in] comp pointer to compressed data
+  /// \param[in] comp_size size of compressed data
+  /// \return the number of values the page holds, or an error if the header is
+  ///         malformed
+  static Result<int32_t> DecodeElementCount(const uint8_t* comp, int64_t comp_size);
+
+  /// \brief Get the maximum compressed size for a given number of values
+  ///
+  /// \param[in] num_values number of integer values
+  /// \param[in] vector_size number of elements per vector (must be a power of 2,
+  ///            in [2^kMinLogVectorSize, 2^kMaxLogVectorSize])
+  /// \return maximum possible compressed page size in bytes, or an error if the
+  ///         arguments are invalid
+  static Result<int64_t> GetMaxCompressedSize(
+      int32_t num_values,
+      int32_t vector_size = static_cast<int32_t>(PforConstants::kPforVectorSize));
+
+ private:
+  /// \brief Page header structure (7 bytes)
+  struct PforHeader {
+    uint8_t packing_mode;      // PackingMode: sequential or interleaved
+    uint8_t log_vector_size;   // log2(vector_size)
+    uint8_t value_byte_width;  // sizeof(T): 4 or 8
+    int32_t num_elements;      // total element count
+  };
+
+  static constexpr int32_t kVectorSize =
+      static_cast<int32_t>(PforConstants::kPforVectorSize);
+
+  static void StoreHeader(std::span<uint8_t> dest, const PforHeader& header);
+  static Result<PforHeader> LoadHeader(std::span<const uint8_t> src);
+};
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/parquet/CMakeLists.txt b/cpp/src/parquet/CMakeLists.txt
index f8a42b5b96bf..b97df02726cb 100644
--- a/cpp/src/parquet/CMakeLists.txt
+++ b/cpp/src/parquet/CMakeLists.txt
@@ -407,6 +407,7 @@ add_parquet_test(chunker-test SOURCES chunker_internal_test.cc)
 
 add_parquet_test(arrow-reader-writer-test
                  SOURCES
+                 arrow/arrow_encoding_test.cc
                  arrow/arrow_reader_writer_test.cc
                  arrow/arrow_statistics_test.cc
                  arrow/variant_test.cc)
@@ -452,5 +453,6 @@ add_parquet_benchmark(level_conversion_benchmark)
 add_parquet_benchmark(metadata_benchmark)
 add_parquet_benchmark(page_index_benchmark SOURCES page_index_benchmark.cc
                       benchmark_util.cc)
+add_parquet_benchmark(pfor_comparison_benchmark)
 add_parquet_benchmark(arrow/reader_writer_benchmark PREFIX "parquet-arrow")
 add_parquet_benchmark(arrow/size_stats_benchmark PREFIX "parquet-arrow")
diff --git a/cpp/src/parquet/PFOR_LAYOUT_RERUN.md b/cpp/src/parquet/PFOR_LAYOUT_RERUN.md
new file mode 100644
index 000000000000..66d62ba21c92
--- /dev/null
+++ b/cpp/src/parquet/PFOR_LAYOUT_RERUN.md
@@ -0,0 +1,188 @@
+# PFOR layout re-run: build and run instructions
+
+The first run of this sweep could not answer the layout question, for two
+reasons that are both fixed in this branch. Neither was your fault; both were
+defects in what you were handed.
+
+## What was wrong, and why the numbers came out the way they did
+
+**1. The candidate arm was never compiled.** The fused FL_ORDER-to-file-order
+transpose — `UnpackBlockFlToFileOrder` in
+`arrow/util/fastlanes/interleaved_pfor.h` — is hand-written `__m256i`
+intrinsics behind this gate chain:
+
+```
+transposed_delta.h:82   #if defined(__AVX2__)
+                        #define ARROW_TRANSPOSED_DELTA_AVX2 1
+interleaved_pfor.h:235  #define ARROW_FASTLANES_FUSED_FL_UNPACK 1   (inside that block)
+```
+
+`-DARROW_SIMD_LEVEL` defaults to `SSE4_2` on x86. At that level `__AVX2__` is
+never defined, so `ARROW_FASTLANES_FUSED_FL_UNPACK` does not exist, and the
+decoder takes a different path entirely: it materialises a 4 KiB
+`uint32_t scratch[1024]` grid, then calls `Transpose32x32(scratch, out)` to read
+it back in file order. That is 128 extra vector stores plus 128 extra vector
+loads per 1024-value block that the fused kernel does entirely in registers.
+
+So the arm you measured at ~0.55x was the scratch fallback, not the candidate.
+Reproduced here: at your footprint the fallback costs 2.35x and the fused
+kernel costs 1.08x. Your 0.551 sits squarely in the fallback regime.
+
+`-DARROW_SIMD_LEVEL=AVX2` is what fixes it. Verified in
+`cmake_modules/SetupCxxFlags.cmake:505-511`: that level appends
+`-march=haswell -mavx2` to `CXX_COMMON_FLAGS` for the whole build, which is what
+defines `__AVX2__` and switches the fused kernel on. It is not optional and it
+is not a tuning flag — without it the candidate arm is absent from the binary.
+
+The same flag independently un-handicaps the *grid unpack*, which is a separate
+issue with the same cause: `fastlanes::UnpackBlock` contains zero intrinsics and
+has no dispatch table (`MakeUnpackTable` in `util/pfor/pfor.cc` is indexed by bit
+width 1..32, with no CPU-feature dimension), so its register width is frozen at
+compile time and `ARROW_USER_SIMD_LEVEL` cannot reach it. Meanwhile the
+sequential arm it is being compared against *does* dispatch at runtime, all the
+way to AVX2. A default build therefore races a 256-bit sequential kernel against
+a 128-bit grid kernel and reports the ratio as a layout result.
+
+**2. One control arm was missing, and one working-set size is not enough.**
+Details in the next section — this is the part that changes what the run can
+conclude, not just how fast the arms are.
+
+## The four arms, and why all four are required
+
+| arm | benchmark | what it is |
+|---|---|---|
+| `seq` | `BM_PforPlainSeqDecode` | continuous layout, delta declined — **the baseline** |
+| `intlv` | `BM_InterleavedPforDecode` | grid filled in file order — **control, unshippable** |
+| `fl_unpk` | `BM_InterleavedPforFlOrderRawDecode` | grid filled the paper's way, handed back unpermuted — **control, violates Parquet's positional contract** |
+| `fl_tpos` | `BM_InterleavedPforFlOrderDecode` | same grid, permuted back to file order by the fused transpose — **the candidate, and the only arm whose ratio is a verdict** |
+
+`fl_unpk` was absent from the first run, and it is the arm that makes the result
+readable. A flat `fl_tpos/seq` has two completely different explanations —
+"the grid's bit-unpacking is no cheaper" and "the grid's bit-unpacking is much
+cheaper but the permutation spends the entire win" — and they are
+indistinguishable from the candidate's number alone. They point at different
+fixes, so the difference matters.
+
+Measured here at 16 KiB, that is exactly what separates: the grid wins 1.75x and
+the permutation charges 1.77x. Same size, opposite signs. You cannot see either
+of those numbers without `fl_unpk`.
+
+The four arms now also sweep five working-set sizes (`LayoutArgs` in
+`pfor_comparison_benchmark.cc`) instead of the single 400 KiB point:
+
+| values | decoded output | why this point |
+|---|---|---|
+| 4096 | 16 KiB | L1-resident — where the grid's compute advantage is visible at all |
+| 102400 | 400 KiB | the historical point; low end of a realistic column chunk |
+| 393216 | 1.5 MiB | still inside a 2 MiB L2; top of realistic |
+| 1048576 | 4 MiB | spilled L2 |
+| 8388608 | 32 MiB | L3-resident, deliberately not DRAM |
+
+The grid's advantage is a compute effect, so it converts to time only while
+stores are not the limit. It is 1.76x at 16 KiB and gone by 1.5 MiB. A single
+mid-size point can show neither the size of the win nor the size of the tax.
+
+## Build
+
+Two builds, one per register width. **The AVX2 one is the one that matters** —
+do it first and stop there if you only have time for one.
+
+```bash
+git fetch origin
+git checkout pgaur_interleavedPlusFastLanesDelta
+git pull
+
+for LEVEL in AVX2 SSE4_2; do
+  cmake -S cpp -B build-x86-$LEVEL \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DARROW_SIMD_LEVEL=$LEVEL \
+    -DARROW_PARQUET=ON \
+    -DARROW_BUILD_BENCHMARKS=ON \
+    -DARROW_WITH_ZSTD=ON -DARROW_WITH_LZ4=ON \
+    -DARROW_BUILD_TESTS=OFF
+  cmake --build build-x86-$LEVEL --target parquet-pfor-comparison-benchmark -j
+done
+```
+
+The `SSE4_2` leg is not a throwaway: it is the control that shows how much of
+the result is register width rather than layout, and it is also what a
+default-configured Arrow actually ships today. Expect the candidate to collapse
+in it. That collapse is a finding, not a failed run.
+
+## Verify the binary before spending time running it
+
+This is the check whose absence cost the first run. It takes one second.
+
+```bash
+nm -C build-x86-AVX2/release/parquet-pfor-comparison-benchmark \
+  | grep -c UnpackBlockFlToFileOrder
+```
+
+- **non-zero** → the fused candidate kernel is in the binary. Good.
+- **zero** → `ARROW_SIMD_LEVEL` did not take. Do not run it; the candidate arm
+  will silently measure the scratch fallback again.
+
+The sweep script also emits a per-binary `objdump` register census into
+`machine.txt`, so the width ends up evidenced in the tarball rather than
+asserted. For reference, what a correct AVX2 build looks like here:
+
+```
+InterleavedPforDecode:        ymm=2543  zmm=0
+UnpackBlockFlToFileOrder<12>: ymm=2311        <- present at all = fused kernel exists
+```
+
+`UnpackBlockFlToFileOrder` is `__m256i` by hand, so it stays `ymm` even in a
+512-bit build. That asymmetry is why a 512 leg is not a like-for-like widening
+and is not part of the headline.
+
+## Run
+
+```bash
+./cpp/src/parquet/x86_register_width_sweep.sh \
+  AVX2=build-x86-AVX2/release/parquet-pfor-comparison-benchmark \
+  SSE4_2=build-x86-SSE4_2/release/parquet-pfor-comparison-benchmark
+```
+
+Send back the single `x86_register_width_sweep_<host>_<date>.tar.gz` it writes.
+
+This run is longer than the first — the four layout arms now cover five sizes
+each. The extra points are the answer, not overhead.
+
+If your CPU has a mobile/boost power profile, the largest footprints are the
+ones most likely to drift thermally. `machine.txt` records the governor, and the
+per-column tables print the worst per-arm CV alongside every ratio, so drift is
+visible rather than baked in.
+
+## Read your own results before sending them
+
+```bash
+tar xzf x86_register_width_sweep_*.tar.gz
+python3 cpp/src/parquet/pfor_layout_tables.py combined_results.json
+```
+
+That prints, per build width: the four arms across all five footprints and all
+43 columns, the geomean over columns, and two self-checks. It fails loudly if an
+arm or the ladder is missing, so it will tell you immediately if the build did
+not take.
+
+Two things worth checking in the output yourself:
+
+- **`fl_unpk/intlv` must be ~1.000** at every footprint. Those two arms run the
+  identical `PackBlock`/`UnpackBlock` pair over the same number of wire bytes
+  against a grid that was merely *filled* differently at encode time. If they
+  disagree by more than a few percent, something is wrong with the run and the
+  gap bounds what every other ratio can mean. The script prints this check
+  explicitly at the end of each width.
+- **`tax` = `fl_unpk/fl_tpos`** is the permutation cost. Near 1.0 means the
+  fused kernel is working; near 2.3 means you are in the scratch fallback and
+  the binary was mis-built.
+
+## What is being asked of the data
+
+Not "is FastLanes faster". Specifically: **at what working-set size, if any,
+does `fl_tpos/seq` exceed 1.0 on your silicon, and how does the `fl_unpk` win
+compare to the `tax` that collects it?** The claim under test on this branch is
+that the grid's unpacking is genuinely much cheaper in L1, that the positional
+permutation costs about the same as the win, and that both vanish once stores
+are the limit — which would mean the layout does not pay for Parquet as
+specified. A second machine either reproduces that shape or breaks it.
diff --git a/cpp/src/parquet/arrow/arrow_encoding_test.cc b/cpp/src/parquet/arrow/arrow_encoding_test.cc
new file mode 100644
index 000000000000..dba45ccd3c39
--- /dev/null
+++ b/cpp/src/parquet/arrow/arrow_encoding_test.cc
@@ -0,0 +1,616 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// End-to-end tests for the column encodings, driven through the Arrow reader
+// and writer rather than through the encoder classes directly.
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "arrow/chunked_array.h"
+#include "arrow/io/memory.h"
+#include "arrow/table.h"
+#include "arrow/testing/builder.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/testing/random.h"
+#include "arrow/type.h"
+#include "arrow/util/config.h"
+
+#include "parquet/arrow/reader.h"
+#include "parquet/arrow/writer.h"
+#include "parquet/file_reader.h"
+#include "parquet/metadata.h"
+#include "parquet/platform.h"
+#include "parquet/properties.h"
+#include "parquet/test_util.h"
+#include "parquet/types.h"
+
+using arrow::ChunkedArray;
+using arrow::Table;
+using arrow::io::BufferReader;
+
+namespace parquet {
+namespace arrow {
+namespace {
+
+// Write `table` with `writer_properties` and read it straight back, handing back
+// the file's bytes as well so a caller can check what the writer chose.
+void DoRoundtrip(const std::shared_ptr<Table>& table, int64_t row_group_size,
+                 std::shared_ptr<Table>* out,
+                 const std::shared_ptr<WriterProperties>& writer_properties,
+                 std::shared_ptr<Buffer>* out_file = nullptr) {
+  auto sink = CreateOutputStream();
+  ASSERT_OK_NO_THROW(WriteTable(*table, ::arrow::default_memory_pool(), sink,
+                                row_group_size, writer_properties));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+  if (out_file != nullptr) {
+    *out_file = buffer;
+  }
+
+  std::unique_ptr<FileReader> reader;
+  FileReaderBuilder builder;
+  ASSERT_OK_NO_THROW(builder.Open(std::make_shared<BufferReader>(buffer)));
+  ASSERT_OK(builder.Build(&reader));
+  ASSERT_OK_AND_ASSIGN(*out, reader->ReadTable());
+}
+
+// Fail unless every column chunk of `file` was written with `encoding`. Without
+// this a round trip still passes when the writer quietly chose something else,
+// and the test would be checking the default encoding instead.
+void AssertAllColumnsUse(const std::shared_ptr<Buffer>& file, Encoding::type encoding) {
+  auto metadata =
+      ParquetFileReader::Open(std::make_shared<BufferReader>(file))->metadata();
+  ASSERT_GT(metadata->num_row_groups(), 0);
+  for (int rg = 0; rg < metadata->num_row_groups(); ++rg) {
+    auto row_group = metadata->RowGroup(rg);
+    for (int col = 0; col < row_group->num_columns(); ++col) {
+      EXPECT_THAT(row_group->ColumnChunk(col)->encodings(), ::testing::Contains(encoding))
+          << "row group " << rg << " column " << col << " does not use "
+          << EncodingToString(encoding);
+    }
+  }
+}
+
+// ============================================================================
+// PFOR encoding file-level integration tests
+// ============================================================================
+
+class ParquetPforEncodingTest : public ::testing::Test {
+ public:
+  void TestPforRoundTrip(const std::shared_ptr<Table>& table,
+                         int64_t row_group_size = -1) {
+    auto writer_props = WriterProperties::Builder()
+                            .disable_dictionary()
+                            ->enable_pfor_encoding()
+                            ->encoding(Encoding::PFOR)
+                            ->build();
+
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, row_group_size < 0 ? table->num_rows() : row_group_size, &result,
+                writer_props, &file);
+
+    ASSERT_NO_FATAL_FAILURE(AssertAllColumnsUse(file, Encoding::PFOR));
+    ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+  }
+
+  void TestPforWithCompression(const std::shared_ptr<Table>& table,
+                               Compression::type compression) {
+    auto writer_props = WriterProperties::Builder()
+                            .disable_dictionary()
+                            ->enable_pfor_encoding()
+                            ->encoding(Encoding::PFOR)
+                            ->compression(compression)
+                            ->build();
+
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, table->num_rows(), &result, writer_props, &file);
+
+    ASSERT_NO_FATAL_FAILURE(AssertAllColumnsUse(file, Encoding::PFOR));
+    ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+  }
+
+  // A table of one column named "values" holding `values`.
+  template <typename ArrowType, typename C>
+  static std::shared_ptr<Table> TableOf(const std::shared_ptr<::arrow::DataType>& type,
+                                        const C& values) {
+    std::shared_ptr<::arrow::Array> array;
+    ::arrow::ArrayFromVector<ArrowType>(values, &array);
+    return Table::Make(::arrow::schema({::arrow::field("values", type)}),
+                       {std::make_shared<ChunkedArray>(array)});
+  }
+};
+
+TEST_F(ParquetPforEncodingTest, SimpleInt32Table) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])"});
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, SimpleInt64Table) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[-100], [0], [100], [200], [300], [400], [500], [600], [700]])"});
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, MixedTypesWithInt32Int64) {
+  auto schema = ::arrow::schema({::arrow::field("id", ::arrow::int32()),
+                                 ::arrow::field("count", ::arrow::int64()),
+                                 ::arrow::field("ratio", ::arrow::float64()),
+                                 ::arrow::field("name", ::arrow::utf8())});
+  auto table = ::arrow::TableFromJSON(schema, {R"([[1, 1000, 1.5, "a"],
+                                          [2, 1001, 2.5, "b"],
+                                          [3, 1002, 3.5, "c"],
+                                          [4, 1003, 4.5, "d"],
+                                          [5, 1004, 5.5, "e"]])"});
+  // PFOR takes only the two integer columns; the rest keep their defaults.
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->enable_pfor_encoding()
+                          ->encoding("id", Encoding::PFOR)
+                          ->encoding("count", Encoding::PFOR)
+                          ->build();
+
+  std::shared_ptr<Table> result;
+  DoRoundtrip(table, table->num_rows(), &result, writer_props);
+
+  ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+}
+
+TEST_F(ParquetPforEncodingTest, LargeInt32Dataset) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int32(10000, -1000000, 1000000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, LargeInt64Dataset) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int64(10000, -1000000000LL, 1000000000LL);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table);
+}
+
+// EXPERIMENTAL: the lane-interleaved bit-packing layout is off unless a writer
+// asks for it, and when it is on it reaches the page and costs no space.
+//
+// The two layouts write the same number of bytes, so a flag that never reached
+// the encoder would still round-trip. Writing the same table both ways and
+// comparing the files is what shows it arrived: same length, different bytes.
+TEST_F(ParquetPforEncodingTest, InterleavedBitPackingLayout) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  // Several full vectors and a short tail, which is written in the layout PFOR
+  // has always used whatever the writer asked for.
+  auto array = rag.Int32(3000, -1000000, 1000000);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  auto build = [](bool interleaved) {
+    auto builder = WriterProperties::Builder();
+    builder.disable_dictionary()->enable_pfor_encoding()->encoding(Encoding::PFOR);
+    if (interleaved) {
+      builder.enable_pfor_interleaved_bit_packing();
+    }
+    return builder.build();
+  };
+
+  std::shared_ptr<Table> sequential_result, interleaved_result;
+  std::shared_ptr<Buffer> sequential_file, interleaved_file;
+  DoRoundtrip(table, table->num_rows(), &sequential_result, build(false),
+              &sequential_file);
+  DoRoundtrip(table, table->num_rows(), &interleaved_result, build(true),
+              &interleaved_file);
+
+  ASSERT_NO_FATAL_FAILURE(AssertAllColumnsUse(interleaved_file, Encoding::PFOR));
+  ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *interleaved_result));
+  ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *sequential_result));
+
+  ASSERT_EQ(sequential_file->size(), interleaved_file->size());
+  ASSERT_FALSE(sequential_file->Equals(*interleaved_file));
+}
+
+// An int64 column cannot use the interleaved layout, and asking for it is not an
+// error: the writer records the layout PFOR has always used, so one setting can
+// cover a file whose columns are not all eligible.
+TEST_F(ParquetPforEncodingTest, InterleavedRequestIgnoredForInt64) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int64(3000, -1000000000LL, 1000000000LL);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  auto with_flag = WriterProperties::Builder()
+                       .disable_dictionary()
+                       ->enable_pfor_encoding()
+                       ->encoding(Encoding::PFOR)
+                       ->enable_pfor_interleaved_bit_packing()
+                       ->build();
+  auto without_flag = WriterProperties::Builder()
+                           .disable_dictionary()
+                           ->enable_pfor_encoding()
+                           ->encoding(Encoding::PFOR)
+                           ->build();
+
+  std::shared_ptr<Table> flagged_result, plain_result;
+  std::shared_ptr<Buffer> flagged_file, plain_file;
+  DoRoundtrip(table, table->num_rows(), &flagged_result, with_flag, &flagged_file);
+  DoRoundtrip(table, table->num_rows(), &plain_result, without_flag, &plain_file);
+
+  ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *flagged_result));
+  // Byte for byte the same file, because the request could not be honoured.
+  ASSERT_TRUE(plain_file->Equals(*flagged_file));
+}
+
+// The distribution PFOR is built for: a tight cluster sitting a long way from
+// zero, so the frame of reference carries the magnitude and the bit-packed
+// payload carries only the spread.
+TEST_F(ParquetPforEncodingTest, ClusteredValuesFarFromZero) {
+  std::vector<int64_t> values(4000);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 1'000'000'000'000LL + static_cast<int64_t>(i % 37);
+  }
+  TestPforRoundTrip(TableOf<::arrow::Int64Type>(::arrow::int64(), values));
+}
+
+// One vector of a constant, which encodes at bit width 0 and so has an empty
+// bit-packed payload.
+TEST_F(ParquetPforEncodingTest, ConstantColumn) {
+  std::vector<int32_t> values(2048, -7);
+  TestPforRoundTrip(TableOf<::arrow::Int32Type>(::arrow::int32(), values));
+}
+
+// A cluster with a few values far above it, which is what the exception path
+// exists to hold.
+TEST_F(ParquetPforEncodingTest, ClusterWithOutliers) {
+  std::vector<int32_t> values(3000);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 500 + static_cast<int32_t>(i % 11);
+    if (i % 97 == 0) {
+      values[i] = 1'000'000 + static_cast<int32_t>(i);
+    }
+  }
+  TestPforRoundTrip(TableOf<::arrow::Int32Type>(::arrow::int32(), values));
+}
+
+// The extremes of each type in one vector, where the span between the smallest
+// and largest value does not fit in the type and the encoder has to fall back
+// to storing full-width values.
+TEST_F(ParquetPforEncodingTest, Int32AtTypeBounds) {
+  std::vector<int32_t> values = {std::numeric_limits<int32_t>::lowest(),
+                                 std::numeric_limits<int32_t>::max(),
+                                 0,
+                                 -1,
+                                 1,
+                                 std::numeric_limits<int32_t>::lowest() + 1,
+                                 std::numeric_limits<int32_t>::max() - 1};
+  TestPforRoundTrip(TableOf<::arrow::Int32Type>(::arrow::int32(), values));
+}
+
+TEST_F(ParquetPforEncodingTest, Int64AtTypeBounds) {
+  std::vector<int64_t> values = {std::numeric_limits<int64_t>::lowest(),
+                                 std::numeric_limits<int64_t>::max(),
+                                 0,
+                                 -1,
+                                 1,
+                                 std::numeric_limits<int64_t>::lowest() + 1,
+                                 std::numeric_limits<int64_t>::max() - 1};
+  TestPforRoundTrip(TableOf<::arrow::Int64Type>(::arrow::int64(), values));
+}
+
+TEST_F(ParquetPforEncodingTest, Int32WithNulls) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[1], [null], [3], [null], [5], [6], [null], [8]])"});
+  TestPforRoundTrip(table);
+}
+
+// A PFOR page holds no nulls, so an all-null page carries no values at all and
+// has to survive the round trip as a header with an empty payload.
+TEST_F(ParquetPforEncodingTest, AllNullColumn) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[null], [null], [null], [null], [null], [null]])"});
+  TestPforRoundTrip(table);
+}
+
+// Nulls ahead of the first value, which makes the level count and the value
+// count differ from the very first batch a reader sees.
+TEST_F(ParquetPforEncodingTest, LeadingNulls) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[null], [null], [null], [7], [8], [9], [null], [11]])"});
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, MultipleRowGroups) {
+  ::arrow::random::RandomArrayGenerator rag(123);
+  auto array = rag.Int64(5000, -100, 100);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table, /*row_group_size=*/1000);
+}
+
+// Row groups that do not divide the vector size, so most pages end on a partial
+// vector.
+TEST_F(ParquetPforEncodingTest, RowGroupsEndOnPartialVectors) {
+  ::arrow::random::RandomArrayGenerator rag(7);
+  auto array = rag.Int32(5000, -50000, 50000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table, /*row_group_size=*/1500);
+}
+
+#ifdef ARROW_WITH_ZSTD
+TEST_F(ParquetPforEncodingTest, PforWithZstdCompression) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int64(5000, -1000, 1000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforWithCompression(table, Compression::ZSTD);
+}
+#endif
+
+#ifdef ARROW_WITH_SNAPPY
+TEST_F(ParquetPforEncodingTest, PforWithSnappyCompression) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int32(5000, -1000, 1000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforWithCompression(table, Compression::SNAPPY);
+}
+#endif
+
+TEST_F(ParquetPforEncodingTest, VerifyPforEncodingUsed) {
+  std::vector<int64_t> values(1000);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 5'000'000 + static_cast<int64_t>(i);
+  }
+  auto table = TableOf<::arrow::Int64Type>(::arrow::int64(), values);
+
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->enable_pfor_encoding()
+                          ->encoding(Encoding::PFOR)
+                          ->build();
+
+  auto sink = CreateOutputStream();
+  ASSERT_OK(WriteTable(*table, ::arrow::default_memory_pool(), sink, table->num_rows(),
+                       writer_props));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+
+  auto reader = ParquetFileReader::Open(std::make_shared<BufferReader>(buffer));
+  auto metadata = reader->metadata();
+
+  ASSERT_EQ(metadata->num_row_groups(), 1);
+  auto row_group = metadata->RowGroup(0);
+  ASSERT_EQ(row_group->num_columns(), 1);
+
+  auto encodings = row_group->ColumnChunk(0)->encodings();
+  EXPECT_THAT(encodings, ::testing::Contains(Encoding::PFOR))
+      << "PFOR encoding not found in column encodings";
+}
+
+// A reader that asks for fewer values than the page holds is served the rest on
+// later calls, so batches smaller than a page must reassemble exactly.
+TEST_F(ParquetPforEncodingTest, ReadInSmallBatches) {
+  ::arrow::random::RandomArrayGenerator rag(99);
+  auto array = rag.Int32(4096, -30000, 30000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->enable_pfor_encoding()
+                          ->encoding(Encoding::PFOR)
+                          ->build();
+
+  auto sink = CreateOutputStream();
+  ASSERT_OK(WriteTable(*table, ::arrow::default_memory_pool(), sink, table->num_rows(),
+                       writer_props));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+
+  std::unique_ptr<FileReader> reader;
+  FileReaderBuilder builder;
+  ASSERT_OK_NO_THROW(builder.Open(std::make_shared<BufferReader>(buffer)));
+  ASSERT_OK(builder.properties(default_arrow_reader_properties())->Build(&reader));
+  reader->set_batch_size(97);
+
+  ASSERT_OK_AND_ASSIGN(auto batch_reader, reader->GetRecordBatchReader());
+  ASSERT_OK_AND_ASSIGN(auto result, batch_reader->ToTable());
+
+  ASSERT_NO_FATAL_FAILURE(
+      ::arrow::AssertTablesEqual(*table, *result, /*same_chunk_layout=*/false));
+}
+
+// The delta mode is a per-column writer option, so a column it clearly helps
+// must come out smaller with the mode left on than with it turned off, and both
+// files must read back the same values.
+TEST_F(ParquetPforEncodingTest, DeltaModeCanBeTurnedOffPerColumn) {
+  // A long arithmetic run: undifferenced it needs enough bits to cover the whole
+  // span, differenced it is a constant and needs none.
+  std::vector<int64_t> values(4096);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 3'000'000'000'000LL + static_cast<int64_t>(i) * 7;
+  }
+  auto table = TableOf<::arrow::Int64Type>(::arrow::int64(), values);
+
+  auto size_of = [&](bool delta_enabled) {
+    auto builder = WriterProperties::Builder();
+    builder.disable_dictionary()
+        ->enable_pfor_encoding()
+        ->encoding(Encoding::PFOR)
+        ->disable_statistics();
+    if (!delta_enabled) {
+      builder.disable_pfor_delta_encoding("values");
+    }
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, table->num_rows(), &result, builder.build(), &file);
+    ::arrow::AssertTablesEqual(*table, *result);
+
+    auto metadata =
+        ParquetFileReader::Open(std::make_shared<BufferReader>(file))->metadata();
+    return metadata->RowGroup(0)->ColumnChunk(0)->total_uncompressed_size();
+  };
+
+  const int64_t with_delta = size_of(/*delta_enabled=*/true);
+  const int64_t without_delta = size_of(/*delta_enabled=*/false);
+  EXPECT_LT(with_delta, without_delta)
+      << "disable_pfor_delta_encoding did not reach the encoder: " << with_delta
+      << " bytes with the mode on, " << without_delta << " with it off";
+}
+
+// ============================================================================
+// Lane-parallel delta encoding file-level integration tests
+// ============================================================================
+
+// INT32 only, so a table mixing types leaves its other columns on their
+// defaults rather than failing the write.
+class ParquetLaneDeltaEncodingTest : public ::testing::Test {
+ public:
+  void TestRoundTrip(const std::shared_ptr<Table>& table, int64_t row_group_size = -1,
+                     Compression::type compression = Compression::UNCOMPRESSED) {
+    auto writer_props = WriterProperties::Builder()
+                            .disable_dictionary()
+                            ->encoding(Encoding::LANE_DELTA)
+                            ->compression(compression)
+                            ->build();
+
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, row_group_size < 0 ? table->num_rows() : row_group_size, &result,
+                writer_props, &file);
+
+    ASSERT_NO_FATAL_FAILURE(AssertAllColumnsUse(file, Encoding::LANE_DELTA));
+    ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+  }
+};
+
+TEST_F(ParquetLaneDeltaEncodingTest, SimpleInt32Table) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])"});
+  TestRoundTrip(table);
+}
+
+// Blocks are 1024 values, so a column longer than one block exercises the carry
+// from one block's last row into the next block's first.
+TEST_F(ParquetLaneDeltaEncodingTest, ManyBlocksAndATail) {
+  ::arrow::random::RandomArrayGenerator rag(1234);
+  auto array = rag.Int32(5000, -1'000'000, 1'000'000, /*null_probability=*/0.0);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  TestRoundTrip(Table::Make(schema, {std::make_shared<ChunkedArray>(array)}));
+}
+
+TEST_F(ParquetLaneDeltaEncodingTest, WithNulls) {
+  ::arrow::random::RandomArrayGenerator rag(4321);
+  auto array = rag.Int32(5000, -50'000, 50'000, /*null_probability=*/0.3);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32(),
+                                                /*nullable=*/true)});
+  TestRoundTrip(Table::Make(schema, {std::make_shared<ChunkedArray>(array)}));
+}
+
+TEST_F(ParquetLaneDeltaEncodingTest, MultipleRowGroups) {
+  ::arrow::random::RandomArrayGenerator rag(555);
+  auto array = rag.Int32(4000, 0, 1'000'000, /*null_probability=*/0.0);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  TestRoundTrip(Table::Make(schema, {std::make_shared<ChunkedArray>(array)}),
+                /*row_group_size=*/1500);
+}
+
+#ifdef ARROW_WITH_ZSTD
+TEST_F(ParquetLaneDeltaEncodingTest, WithCompression) {
+  ::arrow::random::RandomArrayGenerator rag(777);
+  auto array = rag.Int32(3000, -2000, 2000, /*null_probability=*/0.0);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  TestRoundTrip(Table::Make(schema, {std::make_shared<ChunkedArray>(array)}),
+                /*row_group_size=*/-1, Compression::ZSTD);
+}
+#endif
+
+// A reader that asks for fewer values than the page holds is served the rest on
+// later calls, so batches smaller than a page must reassemble exactly.
+TEST_F(ParquetLaneDeltaEncodingTest, ReadInSmallBatches) {
+  ::arrow::random::RandomArrayGenerator rag(99);
+  auto array = rag.Int32(4096, -30000, 30000, /*null_probability=*/0.0);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->encoding(Encoding::LANE_DELTA)
+                          ->build();
+
+  auto sink = CreateOutputStream();
+  ASSERT_OK(WriteTable(*table, ::arrow::default_memory_pool(), sink, table->num_rows(),
+                       writer_props));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+
+  std::unique_ptr<FileReader> reader;
+  FileReaderBuilder builder;
+  ASSERT_OK_NO_THROW(builder.Open(std::make_shared<BufferReader>(buffer)));
+  ASSERT_OK(builder.properties(default_arrow_reader_properties())->Build(&reader));
+  reader->set_batch_size(97);
+
+  ASSERT_OK_AND_ASSIGN(auto batch_reader, reader->GetRecordBatchReader());
+  ASSERT_OK_AND_ASSIGN(auto result, batch_reader->ToTable());
+
+  ASSERT_NO_FATAL_FAILURE(
+      ::arrow::AssertTablesEqual(*table, *result, /*same_chunk_layout=*/false));
+}
+
+// An INT64 column cannot be written in this encoding, and the writer has to say
+// so rather than fall back silently.
+TEST_F(ParquetLaneDeltaEncodingTest, Int64Rejected) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = ::arrow::TableFromJSON(schema, {R"([[1], [2], [3]])"});
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->encoding(Encoding::LANE_DELTA)
+                          ->build();
+  auto sink = CreateOutputStream();
+  ASSERT_RAISES(IOError, WriteTable(*table, ::arrow::default_memory_pool(), sink,
+                                    table->num_rows(), writer_props));
+}
+
+}  // namespace
+}  // namespace arrow
+}  // namespace parquet
diff --git a/cpp/src/parquet/column_reader.cc b/cpp/src/parquet/column_reader.cc
index 162a72bd1576..4ae17c6dbd7b 100644
--- a/cpp/src/parquet/column_reader.cc
+++ b/cpp/src/parquet/column_reader.cc
@@ -971,7 +971,9 @@ class ColumnReaderImplBase {
         case Encoding::RLE:
         case Encoding::DELTA_BINARY_PACKED:
         case Encoding::DELTA_BYTE_ARRAY:
-        case Encoding::DELTA_LENGTH_BYTE_ARRAY: {
+        case Encoding::DELTA_LENGTH_BYTE_ARRAY:
+        case Encoding::PFOR:
+        case Encoding::LANE_DELTA: {
           auto decoder = MakeTypedDecoder<DType>(encoding, descr_, pool_);
           current_decoder_.SetDecoder(decoder.get());
           decoders_[static_cast<int>(encoding)] = std::move(decoder);
diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index 653f28f64bde..d17949659ef5 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -1290,7 +1290,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl,
       : ColumnWriterImpl(metadata, std::move(pager), use_dictionary, encoding,
                          properties) {
     current_encoder_ = MakeEncoder(ParquetType::type_num, encoding, use_dictionary,
-                                   descr_, properties->memory_pool());
+                                   descr_, properties->memory_pool(), properties);
     // We have to dynamic_cast as some compilers don't want to static_cast
     // through virtual inheritance.
     current_value_encoder_ =
diff --git a/cpp/src/parquet/column_writer_test.cc b/cpp/src/parquet/column_writer_test.cc
index 69ec07c1b78f..dd8e5198b89a 100644
--- a/cpp/src/parquet/column_writer_test.cc
+++ b/cpp/src/parquet/column_writer_test.cc
@@ -122,6 +122,10 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
       wp_builder.dictionary_pagesize_limit(DICTIONARY_PAGE_SIZE);
     } else {
       wp_builder.disable_dictionary();
+      if (column_properties.encoding() == Encoding::PFOR) {
+        // PFOR is opt-in because it is a Preview feature in the format.
+        wp_builder.enable_pfor_encoding();
+      }
       wp_builder.encoding(column_properties.encoding());
     }
     if (enable_checksum) {
@@ -178,6 +182,40 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
     ASSERT_NO_FATAL_FAILURE(this->ReadAndCompare(compression, num_rows, enable_checksum));
   }
 
+  // Round-trip an optional PFOR column through a DataPageV2 page. Optional pages
+  // carry definition levels, and when every value is null the encoder is flushed
+  // with no values at all.
+  void TestPforOptionalDataPageV2(int num_nulls) {
+    ASSERT_LE(num_nulls, SMALL_SIZE);
+    this->SetUpSchema(Repetition::OPTIONAL);
+    this->descr_ = this->schema_.Column(0);
+    this->GenerateData(SMALL_SIZE);
+
+    // The nulls come first, so the values the writer consumes are the leading
+    // SMALL_SIZE - num_nulls entries of `values_`.
+    std::vector<int16_t> definition_levels(SMALL_SIZE, 1);
+    for (int i = 0; i < num_nulls; ++i) {
+      definition_levels[i] = 0;
+    }
+
+    ColumnProperties column_properties;
+    column_properties.set_encoding(Encoding::PFOR);
+    auto writer =
+        this->BuildWriter(SMALL_SIZE, column_properties, ParquetVersion::PARQUET_2_LATEST,
+                          ParquetDataPageVersion::V2);
+    writer->WriteBatch(SMALL_SIZE, definition_levels.data(), nullptr, this->values_ptr_);
+    writer->Close();
+
+    ASSERT_EQ(SMALL_SIZE, this->metadata_num_values());
+
+    this->ReadColumn();
+    const int64_t num_expected = SMALL_SIZE - num_nulls;
+    ASSERT_EQ(num_expected, this->values_read_);
+    this->values_out_.resize(num_expected);
+    this->values_.resize(num_expected);
+    ASSERT_EQ(this->values_, this->values_out_);
+  }
+
   void TestRequiredWithCodecOptions(Encoding::type encoding,
                                     Compression::type compression, bool enable_dictionary,
                                     bool enable_statistics, int64_t num_rows = SMALL_SIZE,
@@ -2475,5 +2513,23 @@ TYPED_TEST(TestBloomFilterWriter, Basic) {
   }
 }
 
+// PFOR on an optional column with DataPageV2 pages
+TEST_F(TestValuesWriterInt32Type, PforOptionalDataPageV2) {
+  this->TestPforOptionalDataPageV2(/*num_nulls=*/3);
+}
+
+TEST_F(TestValuesWriterInt64Type, PforOptionalDataPageV2) {
+  this->TestPforOptionalDataPageV2(/*num_nulls=*/3);
+}
+
+// An all-null page holds no values, so its PFOR payload is a bare header
+TEST_F(TestValuesWriterInt32Type, PforAllNullDataPageV2) {
+  this->TestPforOptionalDataPageV2(/*num_nulls=*/SMALL_SIZE);
+}
+
+TEST_F(TestValuesWriterInt64Type, PforAllNullDataPageV2) {
+  this->TestPforOptionalDataPageV2(/*num_nulls=*/SMALL_SIZE);
+}
+
 }  // namespace test
 }  // namespace parquet
diff --git a/cpp/src/parquet/decoder.cc b/cpp/src/parquet/decoder.cc
index c4d3fe5a8a5a..afc76edcc944 100644
--- a/cpp/src/parquet/decoder.cc
+++ b/cpp/src/parquet/decoder.cc
@@ -42,8 +42,10 @@
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/byte_stream_split_internal.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/fastlanes/transposed_delta_wrapper_internal.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging_internal.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
 #include "arrow/util/rle_encoding_internal.h"
 #include "arrow/util/spaced_internal.h"
 #include "arrow/util/ubsan.h"
@@ -2372,6 +2374,331 @@ class ByteStreamSplitDecoder<FLBAType> : public ByteStreamSplitDecoderBase<FLBAT
   }
 };
 
+// ----------------------------------------------------------------------
+// PFOR Decoder
+
+// TODO: support incremental decode. Partial reads currently decode the
+// entire page into `decoded_values_` on first call and copy out the
+// requested range; a future revision should decode only the requested
+// values, with state tracking for cross-call resumption. This is deferred
+// to a follow-up change; the encoder carries the matching TODO.
+template <typename DType>
+class PforDecoder : public TypedDecoderImpl<DType> {
+ public:
+  using Base = TypedDecoderImpl<DType>;
+  using T = typename DType::c_type;
+
+  // TODO: decode a vector at a time. PforWrapper::Decode keeps no resumption
+  // state, so a caller that reads a page in batches decodes the whole page into
+  // `decoded_values_` on the first batch and is served from it afterwards, which
+  // costs a page-sized allocation. The page layout is already addressed by
+  // vector: its offset array locates any vector in constant time, so a batched
+  // read could decode the vectors it needs into a scratch buffer of one vector
+  // and leave the rest of the page untouched.
+  explicit PforDecoder(const ColumnDescriptor* descr,
+                       MemoryPool* pool = ::arrow::default_memory_pool())
+      : Base(descr, Encoding::PFOR),
+        pool_(pool),
+        decoded_values_(AllocateBuffer(pool, 0)) {}
+
+  void SetData(int num_values, const uint8_t* data, int len) override {
+    Base::SetData(num_values, data, len);
+    if (num_values > 0 && len <= 0) {
+      throw ParquetException("PFOR SetData: num_values=" + std::to_string(num_values) +
+                             " but len=" + std::to_string(len));
+    }
+    // A decoder is cached per encoding and reused across the data pages of a
+    // column chunk, so every piece of state describing the previous page has to
+    // be dropped along with the page itself.
+    scratch_filled_ = false;
+    // `num_values` is the page's level count, which includes nulls, while a PFOR
+    // page stores only the non-null values. Its own header is the authority on
+    // how many, so take the count from there.
+    if (len > 0) {
+      PARQUET_ASSIGN_OR_THROW(total_values_,
+                              ::arrow::util::pfor::PforWrapper<T>::DecodeElementCount(
+                                  this->data_, this->len_));
+      if (total_values_ > num_values) {
+        throw ParquetException("PFOR page declares " + std::to_string(total_values_) +
+                               " values but the page header allows at most " +
+                               std::to_string(num_values));
+      }
+    } else {
+      total_values_ = 0;
+    }
+    this->num_values_ = total_values_;
+  }
+
+  int Decode(T* buffer, int max_values) override {
+    max_values = std::min(max_values, this->num_values_);
+    if (max_values == 0) return 0;
+
+    // The caller asked for the whole page and none of it has been served yet, so
+    // decode straight into its buffer -- no page-sized scratch and no copy. This
+    // is the path a full column read takes.
+    if (CanDecodeWholePage(max_values)) {
+      PARQUET_THROW_NOT_OK(::arrow::util::pfor::PforWrapper<T>::Decode(
+          this->data_, this->len_, total_values_, buffer));
+    } else {
+      std::memcpy(buffer, NextDecoded(), static_cast<size_t>(max_values) * sizeof(T));
+    }
+    this->num_values_ -= max_values;
+    return max_values;
+  }
+
+  // `num_values` counts output slots; only the non-null ones are backed by
+  // encoded values, so decode that many and spread them over the valid runs.
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<DType>::Accumulator* builder) override {
+    const int values_to_decode = num_values - null_count;
+    if (ARROW_PREDICT_FALSE(this->num_values_ < values_to_decode)) {
+      ParquetException::EofException(
+          "PFOR DecodeArrow: not enough values available. "
+          "Available: " +
+          std::to_string(this->num_values_) +
+          ", requested: " + std::to_string(values_to_decode));
+    }
+
+    PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+
+    // 1. Land the values in the builder's storage packed to the right, so step 2
+    //    can expand them in place into their final positions. An all-null run
+    //    asks for no values, and a page carrying none has nothing to decode.
+    if (values_to_decode > 0) {
+      T* decode_out = builder->GetMutableValue(builder->length() + null_count);
+      if (CanDecodeWholePage(values_to_decode)) {
+        PARQUET_THROW_NOT_OK(::arrow::util::pfor::PforWrapper<T>::Decode(
+            this->data_, this->len_, total_values_, decode_out));
+      } else {
+        std::memcpy(decode_out, NextDecoded(),
+                    static_cast<size_t>(values_to_decode) * sizeof(T));
+      }
+    }
+
+    // 2. Expand the values into their final positions.
+    if (null_count == 0) {
+      builder->UnsafeAdvance(num_values);
+    } else {
+      ::arrow::util::internal::SpacedExpandLeftward(
+          reinterpret_cast<uint8_t*>(builder->GetMutableValue(builder->length())),
+          static_cast<int>(sizeof(T)), num_values, null_count, valid_bits,
+          valid_bits_offset);
+      builder->UnsafeAdvance(num_values, valid_bits, valid_bits_offset);
+    }
+    this->num_values_ -= values_to_decode;
+    return values_to_decode;
+  }
+
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<DType>::DictAccumulator* out) override {
+    const int values_decoded = num_values - null_count;
+    std::vector<T> values(values_decoded);
+    if (Decode(values.data(), values_decoded) != values_decoded) {
+      ParquetException::EofException();
+    }
+
+    const T* data = values.data();
+    PARQUET_THROW_NOT_OK(out->Reserve(num_values));
+    VisitNullBitmapInline(
+        valid_bits, valid_bits_offset, num_values, null_count,
+        [&]() { PARQUET_THROW_NOT_OK(out->Append(*data++)); },
+        [&]() { PARQUET_THROW_NOT_OK(out->AppendNull()); });
+    return values_decoded;
+  }
+
+ private:
+  /// \brief Whether `count` values can be decoded straight to the caller
+  ///
+  /// PforWrapper::Decode only decodes a page from its start, so this holds when
+  /// the caller wants the whole page and nothing has been served from it yet.
+  bool CanDecodeWholePage(int count) const {
+    return !scratch_filled_ && count == total_values_;
+  }
+
+  /// \brief Pointer to the next undelivered value, decoding the page if needed
+  const T* NextDecoded() {
+    if (!scratch_filled_) {
+      PARQUET_THROW_NOT_OK(
+          decoded_values_->Resize(static_cast<int64_t>(total_values_) * sizeof(T),
+                                  /*shrink_to_fit=*/false));
+      PARQUET_THROW_NOT_OK(::arrow::util::pfor::PforWrapper<T>::Decode(
+          this->data_, this->len_, total_values_, decoded_values_->mutable_data_as<T>()));
+      scratch_filled_ = true;
+    }
+    return decoded_values_->data_as<T>() + (total_values_ - this->num_values_);
+  }
+
+  MemoryPool* pool_;
+  /// Values the page's PFOR header declares. The inherited `num_values_` counts
+  /// down from this as values are served and is the only record of progress, so
+  /// the next value sits at index `total_values_ - num_values_`.
+  int32_t total_values_ = 0;
+  // Whole-page scratch, used only by partial reads. Pool-backed so the
+  // allocation is accounted for like the other decoders' scratch space.
+  std::shared_ptr<ResizableBuffer> decoded_values_;
+  bool scratch_filled_ = false;
+};
+
+// ----------------------------------------------------------------------
+// Lane-parallel delta decoder
+
+// The mirror of the lane-parallel delta encoder. Its reconstruction advances 32
+// independent chains with one vector add per row, in place of the single chain
+// of dependent adds that DELTA_BINARY_PACKED walks, and returns file order in
+// the same pass. INT32 only.
+//
+// Partial reads take the same route as PFOR's: the kernel keeps no resumption
+// state, so a caller reading a page in batches decodes the whole page into
+// scratch on the first batch and is served from it afterwards.
+class LaneDeltaDecoder : public TypedDecoderImpl<Int32Type> {
+ public:
+  using Base = TypedDecoderImpl<Int32Type>;
+  using T = int32_t;
+  using Wrapper = ::arrow::util::fastlanes::TransposedDeltaWrapper<T>;
+
+  explicit LaneDeltaDecoder(const ColumnDescriptor* descr,
+                            MemoryPool* pool = ::arrow::default_memory_pool())
+      : Base(descr, Encoding::LANE_DELTA),
+        pool_(pool),
+        decoded_values_(AllocateBuffer(pool, 0)) {}
+
+  void SetData(int num_values, const uint8_t* data, int len) override {
+    Base::SetData(num_values, data, len);
+    if (num_values > 0 && len <= 0) {
+      throw ParquetException(
+          "LANE_DELTA SetData: num_values=" + std::to_string(num_values) +
+          " but len=" + std::to_string(len));
+    }
+    // A decoder is cached per encoding and reused across the data pages of a
+    // column chunk, so state describing the previous page has to be dropped
+    // with the page.
+    scratch_filled_ = false;
+    // `num_values` is the page's level count, which includes nulls, while the
+    // page stores only the non-null values. Its own count is the authority.
+    if (len > 0) {
+      PARQUET_ASSIGN_OR_THROW(total_values_,
+                              Wrapper::DecodeElementCount(this->data_, this->len_));
+      if (total_values_ > num_values) {
+        throw ParquetException(
+            "LANE_DELTA page declares " + std::to_string(total_values_) +
+            " values but the page header allows at most " + std::to_string(num_values));
+      }
+    } else {
+      total_values_ = 0;
+    }
+    this->num_values_ = total_values_;
+  }
+
+  int Decode(T* buffer, int max_values) override {
+    max_values = std::min(max_values, this->num_values_);
+    if (max_values == 0) return 0;
+
+    // The caller asked for the whole page and none of it has been served yet,
+    // so decode straight into its buffer -- no page-sized scratch and no copy.
+    if (CanDecodeWholePage(max_values)) {
+      PARQUET_THROW_NOT_OK(
+          Wrapper::Decode(this->data_, this->len_, total_values_, buffer));
+    } else {
+      std::memcpy(buffer, NextDecoded(), static_cast<size_t>(max_values) * sizeof(T));
+    }
+    this->num_values_ -= max_values;
+    return max_values;
+  }
+
+  // `num_values` counts output slots; only the non-null ones are backed by
+  // encoded values, so decode that many and spread them over the valid runs.
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<Int32Type>::Accumulator* builder) override {
+    const int values_to_decode = num_values - null_count;
+    if (ARROW_PREDICT_FALSE(this->num_values_ < values_to_decode)) {
+      ParquetException::EofException(
+          "LANE_DELTA DecodeArrow: not enough values available. "
+          "Available: " +
+          std::to_string(this->num_values_) +
+          ", requested: " + std::to_string(values_to_decode));
+    }
+
+    PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+
+    // 1. Land the values in the builder's storage packed to the right, so step
+    //    2 can expand them in place into their final positions.
+    if (values_to_decode > 0) {
+      T* decode_out = builder->GetMutableValue(builder->length() + null_count);
+      if (CanDecodeWholePage(values_to_decode)) {
+        PARQUET_THROW_NOT_OK(
+            Wrapper::Decode(this->data_, this->len_, total_values_, decode_out));
+      } else {
+        std::memcpy(decode_out, NextDecoded(),
+                    static_cast<size_t>(values_to_decode) * sizeof(T));
+      }
+    }
+
+    // 2. Expand the values into their final positions.
+    if (null_count == 0) {
+      builder->UnsafeAdvance(num_values);
+    } else {
+      ::arrow::util::internal::SpacedExpandLeftward(
+          reinterpret_cast<uint8_t*>(builder->GetMutableValue(builder->length())),
+          static_cast<int>(sizeof(T)), num_values, null_count, valid_bits,
+          valid_bits_offset);
+      builder->UnsafeAdvance(num_values, valid_bits, valid_bits_offset);
+    }
+    this->num_values_ -= values_to_decode;
+    return values_to_decode;
+  }
+
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<Int32Type>::DictAccumulator* out) override {
+    const int values_decoded = num_values - null_count;
+    std::vector<T> values(values_decoded);
+    if (Decode(values.data(), values_decoded) != values_decoded) {
+      ParquetException::EofException();
+    }
+    const T* data = values.data();
+    PARQUET_THROW_NOT_OK(out->Reserve(num_values));
+    VisitNullBitmapInline(
+        valid_bits, valid_bits_offset, num_values, null_count,
+        [&]() { PARQUET_THROW_NOT_OK(out->Append(*data++)); },
+        [&]() { PARQUET_THROW_NOT_OK(out->AppendNull()); });
+    return values_decoded;
+  }
+
+ private:
+  /// \brief Whether `count` values can be decoded straight to the caller
+  ///
+  /// The kernel only decodes a page from its start, so this holds when the
+  /// caller wants the whole page and nothing has been served from it yet.
+  bool CanDecodeWholePage(int count) const {
+    return !scratch_filled_ && count == total_values_;
+  }
+
+  /// \brief Pointer to the next undelivered value, decoding the page if needed
+  const T* NextDecoded() {
+    if (!scratch_filled_) {
+      PARQUET_THROW_NOT_OK(
+          decoded_values_->Resize(static_cast<int64_t>(total_values_) * sizeof(T),
+                                  /*shrink_to_fit=*/false));
+      PARQUET_THROW_NOT_OK(Wrapper::Decode(this->data_, this->len_, total_values_,
+                                           decoded_values_->mutable_data_as<T>()));
+      scratch_filled_ = true;
+    }
+    return decoded_values_->data_as<T>() + (total_values_ - this->num_values_);
+  }
+
+  MemoryPool* pool_;
+  /// Values the page's own count declares. The inherited `num_values_` counts
+  /// down from this as values are served and is the only record of progress, so
+  /// the next value sits at index `total_values_ - num_values_`.
+  int32_t total_values_ = 0;
+  // Whole-page scratch, used only by partial reads.
+  std::shared_ptr<ResizableBuffer> decoded_values_;
+  bool scratch_filled_ = false;
+};
+
 }  // namespace
 
 // ----------------------------------------------------------------------
@@ -2448,6 +2775,22 @@ std::unique_ptr<Decoder> MakeDecoder(Type::type type_num, Encoding::type encodin
       return std::make_unique<RleBooleanDecoder>(descr);
     }
     throw ParquetException("RLE encoding only supports BOOLEAN");
+  } else if (encoding == Encoding::PFOR) {
+    switch (type_num) {
+      case Type::INT32:
+        return std::make_unique<PforDecoder<Int32Type>>(descr, pool);
+      case Type::INT64:
+        return std::make_unique<PforDecoder<Int64Type>>(descr, pool);
+      default:
+        throw ParquetException("PFOR decoder only supports INT32 and INT64");
+    }
+  } else if (encoding == Encoding::LANE_DELTA) {
+    switch (type_num) {
+      case Type::INT32:
+        return std::make_unique<LaneDeltaDecoder>(descr, pool);
+      default:
+        throw ParquetException("LANE_DELTA decoder only supports INT32");
+    }
   } else {
     ParquetException::NYI("Selected encoding is not supported");
   }
@@ -2490,9 +2833,11 @@ std::vector<Encoding::type> SupportedEncodings(Type::type physical_type) {
     case Type::BOOLEAN:
       return {Encoding::PLAIN, Encoding::RLE};
     case Type::INT32:
+      return {Encoding::PLAIN, Encoding::DELTA_BINARY_PACKED, Encoding::BYTE_STREAM_SPLIT,
+              Encoding::PFOR, Encoding::LANE_DELTA};
     case Type::INT64:
-      return {Encoding::PLAIN, Encoding::DELTA_BINARY_PACKED,
-              Encoding::BYTE_STREAM_SPLIT};
+      return {Encoding::PLAIN, Encoding::DELTA_BINARY_PACKED, Encoding::BYTE_STREAM_SPLIT,
+              Encoding::PFOR};
     case Type::INT96:
       return {Encoding::PLAIN};
     case Type::FLOAT:
diff --git a/cpp/src/parquet/encoder.cc b/cpp/src/parquet/encoder.cc
index 3e469df277b8..40555196c519 100644
--- a/cpp/src/parquet/encoder.cc
+++ b/cpp/src/parquet/encoder.cc
@@ -37,9 +37,11 @@
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/byte_stream_split_internal.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/fastlanes/transposed_delta_wrapper_internal.h"
 #include "arrow/util/hashing.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging_internal.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
 #include "arrow/util/rle_encoding_internal.h"
 #include "arrow/util/spaced_internal.h"
 #include "arrow/util/ubsan.h"
@@ -47,6 +49,7 @@
 
 #include "parquet/exception.h"
 #include "parquet/platform.h"
+#include "parquet/properties.h"
 #include "parquet/schema.h"
 #include "parquet/types.h"
 
@@ -1763,12 +1766,191 @@ std::shared_ptr<Buffer> RleBooleanEncoder::FlushValues() {
 
 }  // namespace
 
+// ----------------------------------------------------------------------
+// PFOR Encoder
+
+// TODO: support incremental encoding. Today `Put` only appends raw input
+// to `values_`, and `FlushValues` runs the entire PFOR pipeline on the
+// whole buffer in one shot. A future revision should encode complete
+// vectors as `Put` calls fill them, holding only a partial-vector tail
+// across calls, so the encoder can produce output progressively and use
+// bounded memory. This is deferred to a follow-up change; the decoder
+// carries the matching TODO.
+//
+// TODO: fall back to PLAIN when PFOR is not paying for itself. This encoder
+// always emits a PFOR page, and the cost model's worst case is the full width
+// with no exceptions, so a column whose deltas never narrow (random values, or
+// a low null sentinel that becomes the frame of reference and can never be an
+// exception) encodes to its plain size plus the page header, the offset array
+// and one PforVectorInfo per vector.
+//
+// The decision belongs in ColumnWriterImpl, not here: `encoding_` is const, so
+// this encoder cannot relabel its own page, and the choice depends on the page
+// compressor, which this layer knows nothing about. The mechanism already
+// exists -- mirror `FallbackToPlainEncoding()` in column_writer.cc, which swaps
+// `current_encoder_` for a PLAIN encoder and updates `encoding_`. Parquet
+// records the encoding per page, so mixing PLAIN and PFOR pages in one column
+// chunk needs no format change.
+//
+// What is missing on this side is a way for the writer to know the ratio
+// before paying for the encode. FindOptimalBitWidth already computes the cost
+// of a vector in bits, so a sampled estimate over the first few vectors would
+// answer the question without encoding the page twice.
+template <typename DType>
+class PforEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
+ public:
+  using T = typename DType::c_type;
+  using TypedEncoder<DType>::Put;
+
+  PforEncoder(const ColumnDescriptor* descr, MemoryPool* pool,
+              const ::arrow::util::pfor::PforEncodeOptions& options)
+      : EncoderImpl(descr, Encoding::PFOR, pool), pool_(pool), options_(options) {}
+
+  std::shared_ptr<Buffer> FlushValues() override {
+    // An all-null optional page adds no values and is still written, so an empty
+    // buffer has to encode to a header-only page rather than to zero bytes, which
+    // the reader would reject for having no header to load.
+    const int32_t num_values = static_cast<int32_t>(values_.size());
+    PARQUET_ASSIGN_OR_THROW(
+        int64_t max_size,
+        ::arrow::util::pfor::PforWrapper<T>::GetMaxCompressedSize(num_values));
+    PARQUET_ASSIGN_OR_THROW(auto buffer,
+                            ::arrow::AllocateResizableBuffer(max_size, pool_));
+
+    int64_t comp_size = max_size;
+    PARQUET_THROW_NOT_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
+        values_.data(), num_values, buffer->mutable_data(), &comp_size, options_));
+
+    PARQUET_THROW_NOT_OK(buffer->Resize(comp_size));
+    values_.clear();
+    return buffer;
+  }
+
+  int64_t EstimatedDataEncodedSize() override {
+    return static_cast<int64_t>(values_.size() * sizeof(T));
+  }
+
+  void Put(const ::arrow::Array& values) override {
+    const auto& data = *values.data();
+    if (data.length > std::numeric_limits<int32_t>::max()) {
+      throw ParquetException("Array cannot be longer than ",
+                             std::numeric_limits<int32_t>::max());
+    }
+    if (values.null_count() == 0) {
+      Put(data.template GetValues<T>(1), static_cast<int>(data.length));
+    } else {
+      PutSpaced(data.template GetValues<T>(1), static_cast<int>(data.length),
+                data.GetValues<uint8_t>(0, 0), data.offset);
+    }
+  }
+
+  void Put(const T* buffer, int num_values) override {
+    values_.insert(values_.end(), buffer, buffer + num_values);
+  }
+
+  void PutSpaced(const T* src, int num_values, const uint8_t* valid_bits,
+                 int64_t valid_bits_offset) override {
+    if (valid_bits != NULLPTR) {
+      PARQUET_ASSIGN_OR_THROW(auto buffer,
+                              ::arrow::AllocateBuffer(num_values * sizeof(T), pool_));
+      T* dest = reinterpret_cast<T*>(buffer->mutable_data());
+      int num_valid = ::arrow::util::internal::SpacedCompress<T>(
+          src, num_values, valid_bits, valid_bits_offset, dest);
+      Put(dest, num_valid);
+    } else {
+      Put(src, num_values);
+    }
+  }
+
+ private:
+  MemoryPool* pool_;
+  ::arrow::util::pfor::PforEncodeOptions options_;
+  std::vector<T> values_;
+};
+
+// ----------------------------------------------------------------------
+// Lane-parallel delta encoder
+
+// Splits a page into 32 independent difference chains, one per lane, so the
+// decoder advances all 32 with one vector add per row instead of walking the
+// single chain of dependent adds DELTA_BINARY_PACKED stores. A lane holds a
+// contiguous run of 32 values, so the differences stored are the ones the format
+// already stores, and the 32 entry points that arrangement needs are themselves
+// delta-coded. INT32 only: the kernel packs 32-bit lanes.
+class LaneDeltaEncoder : public EncoderImpl, virtual public TypedEncoder<Int32Type> {
+ public:
+  using T = int32_t;
+  using Wrapper = ::arrow::util::fastlanes::TransposedDeltaWrapper<T>;
+  using TypedEncoder<Int32Type>::Put;
+
+  LaneDeltaEncoder(const ColumnDescriptor* descr, MemoryPool* pool)
+      : EncoderImpl(descr, Encoding::LANE_DELTA, pool), pool_(pool) {}
+
+  std::shared_ptr<Buffer> FlushValues() override {
+    // An all-null optional page carries no values and is still written, so it
+    // has to encode to a bare value count rather than to zero bytes.
+    const int32_t num_values = static_cast<int32_t>(values_.size());
+    const int64_t max_size = Wrapper::GetMaxCompressedSize(num_values);
+    PARQUET_ASSIGN_OR_THROW(auto buffer,
+                            ::arrow::AllocateResizableBuffer(max_size, pool_));
+
+    int64_t comp_size = max_size;
+    PARQUET_THROW_NOT_OK(
+        Wrapper::Encode(values_.data(), num_values, buffer->mutable_data(), &comp_size));
+
+    PARQUET_THROW_NOT_OK(buffer->Resize(comp_size));
+    values_.clear();
+    return buffer;
+  }
+
+  int64_t EstimatedDataEncodedSize() override {
+    return static_cast<int64_t>(values_.size() * sizeof(T));
+  }
+
+  void Put(const ::arrow::Array& values) override {
+    const auto& data = *values.data();
+    if (data.length > std::numeric_limits<int32_t>::max()) {
+      throw ParquetException("Array cannot be longer than ",
+                             std::numeric_limits<int32_t>::max());
+    }
+    if (values.null_count() == 0) {
+      Put(data.GetValues<T>(1), static_cast<int>(data.length));
+    } else {
+      PutSpaced(data.GetValues<T>(1), static_cast<int>(data.length),
+                data.GetValues<uint8_t>(0, 0), data.offset);
+    }
+  }
+
+  void Put(const T* buffer, int num_values) override {
+    values_.insert(values_.end(), buffer, buffer + num_values);
+  }
+
+  void PutSpaced(const T* src, int num_values, const uint8_t* valid_bits,
+                 int64_t valid_bits_offset) override {
+    if (valid_bits != NULLPTR) {
+      PARQUET_ASSIGN_OR_THROW(auto buffer,
+                              ::arrow::AllocateBuffer(num_values * sizeof(T), pool_));
+      T* dest = reinterpret_cast<T*>(buffer->mutable_data());
+      int num_valid = ::arrow::util::internal::SpacedCompress<T>(
+          src, num_values, valid_bits, valid_bits_offset, dest);
+      Put(dest, num_valid);
+    } else {
+      Put(src, num_values);
+    }
+  }
+
+ private:
+  MemoryPool* pool_;
+  std::vector<T> values_;
+};
+
 // ----------------------------------------------------------------------
 // Factory function
 
 std::unique_ptr<Encoder> MakeEncoder(Type::type type_num, Encoding::type encoding,
                                      bool use_dictionary, const ColumnDescriptor* descr,
-                                     MemoryPool* pool) {
+                                     MemoryPool* pool,
+                                     const WriterProperties* properties) {
   if (use_dictionary) {
     switch (type_num) {
       case Type::INT32:
@@ -1862,6 +2044,38 @@ std::unique_ptr<Encoder> MakeEncoder(Type::type type_num, Encoding::type encodin
         throw ParquetException(
             "DELTA_BYTE_ARRAY only supports BYTE_ARRAY and FIXED_LEN_BYTE_ARRAY");
     }
+  } else if (encoding == Encoding::PFOR) {
+    // The delta mode and the bit-packing layout are both per-writer options, so
+    // they are read off the properties rather than baked into the encoder. A
+    // caller with no properties to hand -- the encoding tests, and
+    // MakeTypedEncoder's default -- gets the default for both.
+    ::arrow::util::pfor::PforEncodeOptions options;
+    if (properties != nullptr) {
+      if (descr != nullptr) {
+        options.delta_enabled = properties->pfor_delta_enabled(descr->path());
+      }
+      // The encoder treats the layout as a request: a column it cannot apply to
+      // records the layout PFOR has always used, so one writer-side setting can
+      // cover a file whose columns are not all eligible.
+      options.mode = properties->pfor_interleaved_bit_packing()
+                         ? ::arrow::util::pfor::PackingMode::kForBitPackInterleaved
+                         : ::arrow::util::pfor::PackingMode::kForBitPack;
+    }
+    switch (type_num) {
+      case Type::INT32:
+        return std::make_unique<PforEncoder<Int32Type>>(descr, pool, options);
+      case Type::INT64:
+        return std::make_unique<PforEncoder<Int64Type>>(descr, pool, options);
+      default:
+        throw ParquetException("PFOR encoder only supports INT32 and INT64");
+    }
+  } else if (encoding == Encoding::LANE_DELTA) {
+    switch (type_num) {
+      case Type::INT32:
+        return std::make_unique<LaneDeltaEncoder>(descr, pool);
+      default:
+        throw ParquetException("LANE_DELTA encoder only supports INT32");
+    }
   } else {
     ParquetException::NYI("Selected encoding is not supported");
   }
diff --git a/cpp/src/parquet/encoding.h b/cpp/src/parquet/encoding.h
index e3de4f2aa60b..f51454a8b310 100644
--- a/cpp/src/parquet/encoding.h
+++ b/cpp/src/parquet/encoding.h
@@ -35,6 +35,8 @@ class Dictionary32Builder;
 
 namespace parquet {
 
+class WriterProperties;
+
 template <typename DType>
 class TypedEncoder;
 
@@ -418,20 +420,30 @@ class FLBADecoder : virtual public TypedDecoder<FLBAType> {
   // then perhaps not
 };
 
+/// \brief Construct an encoder.
+///
+/// \param[in] properties the writer properties, consulted for the options an
+///            encoding offers per column. May be null, in which case every such
+///            option takes its default -- including PFOR's EXPERIMENTAL
+///            lane-interleaved bit-packing layout, ignored by every other
+///            encoding and by PFOR itself where the layout cannot apply. See
+///            WriterProperties::Builder::enable_pfor_interleaved_bit_packing.
 PARQUET_EXPORT
 std::unique_ptr<Encoder> MakeEncoder(
     Type::type type_num, Encoding::type encoding, bool use_dictionary = false,
     const ColumnDescriptor* descr = NULLPTR,
-    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
+    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
+    const WriterProperties* properties = NULLPTR);
 
 template <typename DType>
 std::unique_ptr<typename EncodingTraits<DType>::Encoder> MakeTypedEncoder(
     Encoding::type encoding, bool use_dictionary = false,
     const ColumnDescriptor* descr = NULLPTR,
-    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool()) {
+    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
+    const WriterProperties* properties = NULLPTR) {
   using OutType = typename EncodingTraits<DType>::Encoder;
   std::unique_ptr<Encoder> base =
-      MakeEncoder(DType::type_num, encoding, use_dictionary, descr, pool);
+      MakeEncoder(DType::type_num, encoding, use_dictionary, descr, pool, properties);
   return std::unique_ptr<OutType>(dynamic_cast<OutType*>(base.release()));
 }
 
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index 831829e4a210..fe8c22cc0946 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -1044,6 +1044,71 @@ class EncodingAdHocTyped : public ::testing::Test {
     ::arrow::AssertArraysEqual(*values, *result);
   }
 
+  void Pfor(int seed) {
+    if (!std::is_same<ParquetType, Int32Type>::value &&
+        !std::is_same<ParquetType, Int64Type>::value) {
+      return;
+    }
+    auto values = GetValues(seed);
+    auto encoder =
+        MakeTypedEncoder<ParquetType>(Encoding::PFOR,
+                                      /*use_dictionary=*/false, column_descr());
+    auto decoder = MakeTypedDecoder<ParquetType>(Encoding::PFOR, column_descr());
+
+    ASSERT_NO_THROW(encoder->Put(*values));
+    auto buf = encoder->FlushValues();
+
+    int num_values = static_cast<int>(values->length() - values->null_count());
+    decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
+
+    BuilderType acc(arrow_type(), ::arrow::default_memory_pool());
+    ASSERT_EQ(num_values,
+              decoder->DecodeArrow(static_cast<int>(values->length()),
+                                   static_cast<int>(values->null_count()),
+                                   values->null_bitmap_data(), values->offset(), &acc));
+
+    std::shared_ptr<::arrow::Array> result;
+    ASSERT_OK(acc.Finish(&result));
+    ASSERT_OK(result->ValidateFull());
+    ASSERT_EQ(size_, result->length());
+    ::arrow::AssertArraysEqual(*values, *result, /*verbose=*/true);
+  }
+
+  void PforDict(int seed) {
+    if constexpr (!std::is_same_v<ParquetType, Int32Type> &&
+                  !std::is_same_v<ParquetType, Int64Type>) {
+      return;
+    } else {
+      auto values = GetValues(seed);
+      auto encoder =
+          MakeTypedEncoder<ParquetType>(Encoding::PFOR,
+                                        /*use_dictionary=*/false, column_descr());
+      auto decoder = MakeTypedDecoder<ParquetType>(Encoding::PFOR, column_descr());
+
+      ASSERT_NO_THROW(encoder->Put(*values));
+      auto buf = encoder->FlushValues();
+
+      int num_values = static_cast<int>(values->length() - values->null_count());
+      decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
+
+      DictBuilderType acc(arrow_type(), ::arrow::default_memory_pool());
+      ASSERT_EQ(num_values,
+                decoder->DecodeArrow(static_cast<int>(values->length()),
+                                     static_cast<int>(values->null_count()),
+                                     values->null_bitmap_data(), values->offset(), &acc));
+
+      std::shared_ptr<::arrow::Array> result;
+      ASSERT_OK(acc.Finish(&result));
+      ASSERT_OK(result->ValidateFull());
+      ASSERT_EQ(size_, result->length());
+
+      // The accumulator produced a DictionaryArray; compare it densely.
+      ASSERT_OK_AND_ASSIGN(auto dense_datum,
+                           ::arrow::compute::Cast(::arrow::Datum(result), arrow_type()));
+      ::arrow::AssertArraysEqual(*values, *dense_datum.make_array(), /*verbose=*/true);
+    }
+  }
+
   void Dict(int seed) {
     if (std::is_same<ParquetType, BooleanType>::value) {
       return;
@@ -1228,6 +1293,27 @@ TYPED_TEST(EncodingAdHocTyped, DeltaBitPackArrowDirectPut) {
   }
 }
 
+TYPED_TEST(EncodingAdHocTyped, PforArrowDirectPut) {
+  for (auto seed : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) {
+    this->Pfor(seed);
+  }
+  // Same, but without nulls (this could trigger different code paths)
+  this->null_probability_ = 0.0;
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->Pfor(seed);
+  }
+}
+
+TYPED_TEST(EncodingAdHocTyped, PforArrowDirectPutDictBuilder) {
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->PforDict(seed);
+  }
+  this->null_probability_ = 0.0;
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->PforDict(seed);
+  }
+}
+
 TYPED_TEST(EncodingAdHocTyped, DictArrowDirectPut) { this->Dict(0); }
 
 TYPED_TEST(EncodingAdHocTyped, DictArrowDirectPutIndices) { this->DictPutIndices(); }
@@ -2034,6 +2120,420 @@ TYPED_TEST(TestDeltaBitPackEncoding, ZeroDeltaBitWidth) {
   this->CheckRoundtripWithValues(int_values);
 }
 
+// ----------------------------------------------------------------------
+// PFOR encode/decode tests.
+
+template <typename Type>
+class TestPforEncoding : public TestEncodingBase<Type> {
+ public:
+  using c_type = typename Type::c_type;
+  static constexpr int TYPE = Type::type_num;
+
+  void CheckDecoding(int read_batch_size) {
+    auto decoder = MakeTypedDecoder<Type>(Encoding::PFOR, descr_.get());
+    decoder->SetData(num_values_, encode_buffer_->data(),
+                     static_cast<int>(encode_buffer_->size()));
+
+    std::vector<c_type> decoded(num_values_);
+    int values_decoded = 0;
+    while (values_decoded < num_values_) {
+      const int decoded_now =
+          decoder->Decode(decoded.data() + values_decoded, read_batch_size);
+      ASSERT_GT(decoded_now, 0);
+      values_decoded += decoded_now;
+    }
+    ASSERT_EQ(num_values_, values_decoded);
+    ASSERT_NO_FATAL_FAILURE(VerifyResults<c_type>(decoded.data(), draws_, num_values_));
+  }
+
+  void CheckRoundtrip() override {
+    auto encoder = MakeTypedEncoder<Type>(Encoding::PFOR,
+                                          /*use_dictionary=*/false, descr_.get());
+    encoder->Put(draws_, num_values_);
+    encode_buffer_ = encoder->FlushValues();
+
+    // A reader asks for whatever its batch size is, so the page has to come out
+    // the same whether it is drained in one call or in many.
+    for (const int read_batch_size : {1, 11, num_values_}) {
+      if (read_batch_size > 0) {
+        ASSERT_NO_FATAL_FAILURE(CheckDecoding(read_batch_size));
+      }
+    }
+  }
+
+ protected:
+  USING_BASE_MEMBERS();
+};
+
+using TestPforEncodingTypes = ::testing::Types<Int32Type, Int64Type>;
+TYPED_TEST_SUITE(TestPforEncoding, TestPforEncodingTypes);
+
+TYPED_TEST(TestPforEncoding, BasicRoundTrip) {
+  // The default vector size is 1024, so cover an empty page, a single value, a
+  // partial vector, an exact multiple, and a partial trailing vector.
+  ASSERT_NO_FATAL_FAILURE(this->Execute(0, 0));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(100, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1024, 4));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1025, 3));
+}
+
+TYPED_TEST(TestPforEncoding, DecoderReusedAcrossPages) {
+  using c_type = typename TypeParam::c_type;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::PFOR,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::PFOR, this->descr_.get());
+
+  // A column chunk reuses one decoder for all of its data pages, with only
+  // SetData between them. The second page is the longer one, so a decoder that
+  // kept the first page's values would also read past the end of them.
+  const std::vector<std::vector<c_type>> pages = {
+      {10, 11, 12, 13}, {900, 901, 902, 903, 904, 905, 906, 907}};
+
+  for (const auto& page : pages) {
+    const int page_values = static_cast<int>(page.size());
+    encoder->Put(page.data(), page_values);
+    auto buffer = encoder->FlushValues();
+    decoder->SetData(page_values, buffer->data(), static_cast<int>(buffer->size()));
+
+    std::vector<c_type> decoded(page.size());
+    ASSERT_EQ(page_values, decoder->Decode(decoded.data(), page_values));
+    ASSERT_EQ(page, decoded);
+  }
+}
+
+TYPED_TEST(TestPforEncoding, AllNullPage) {
+  constexpr int kNumValues = 40;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::PFOR,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto buffer = encoder->FlushValues();
+
+  // A reader hands the decoder the page's level count, which counts the nulls, so
+  // the page and its bare header have to survive being handed the full count.
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::PFOR, this->descr_.get());
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+
+  // All slots are null, so the page carries no encoded values at all.
+  std::vector<uint8_t> valid_bits(bit_util::BytesForBits(kNumValues), 0);
+  typename EncodingTraits<TypeParam>::Accumulator acc;
+  ASSERT_EQ(0, decoder->DecodeArrow(kNumValues, /*null_count=*/kNumValues,
+                                    valid_bits.data(), /*valid_bits_offset=*/0, &acc));
+
+  std::shared_ptr<::arrow::Array> result;
+  ASSERT_OK(acc.Finish(&result));
+  ASSERT_OK(result->ValidateFull());
+  ASSERT_EQ(kNumValues, result->length());
+  ASSERT_EQ(kNumValues, result->null_count());
+}
+
+// ----------------------------------------------------------------------
+// Lane-parallel delta encode/decode tests.
+
+template <typename Type>
+class TestLaneDeltaEncoding : public TestEncodingBase<Type> {
+ public:
+  using c_type = typename Type::c_type;
+  static constexpr int TYPE = Type::type_num;
+
+  void CheckDecoding(int read_batch_size) {
+    auto decoder = MakeTypedDecoder<Type>(Encoding::LANE_DELTA, descr_.get());
+    decoder->SetData(num_values_, encode_buffer_->data(),
+                     static_cast<int>(encode_buffer_->size()));
+
+    std::vector<c_type> decoded(num_values_);
+    int values_decoded = 0;
+    while (values_decoded < num_values_) {
+      const int decoded_now =
+          decoder->Decode(decoded.data() + values_decoded, read_batch_size);
+      ASSERT_GT(decoded_now, 0);
+      values_decoded += decoded_now;
+    }
+    ASSERT_EQ(num_values_, values_decoded);
+    ASSERT_NO_FATAL_FAILURE(VerifyResults<c_type>(decoded.data(), draws_, num_values_));
+  }
+
+  void CheckRoundtrip() override {
+    auto encoder = MakeTypedEncoder<Type>(Encoding::LANE_DELTA,
+                                          /*use_dictionary=*/false, descr_.get());
+    encoder->Put(draws_, num_values_);
+    encode_buffer_ = encoder->FlushValues();
+
+    // A reader asks for whatever its batch size is, so the page has to come out
+    // the same whether it is drained in one call or in many.
+    for (const int read_batch_size : {1, 11, num_values_}) {
+      if (read_batch_size > 0) {
+        ASSERT_NO_FATAL_FAILURE(CheckDecoding(read_batch_size));
+      }
+    }
+  }
+
+ protected:
+  USING_BASE_MEMBERS();
+};
+
+// INT32 only: the packing kernel works on 32-bit lanes.
+using TestLaneDeltaEncodingTypes = ::testing::Types<Int32Type>;
+TYPED_TEST_SUITE(TestLaneDeltaEncoding, TestLaneDeltaEncodingTypes);
+
+TYPED_TEST(TestLaneDeltaEncoding, BasicRoundTrip) {
+  // Blocks are 1024 values and any tail is stored raw, so cover an empty page, a
+  // page shorter than one block, an exact multiple, and both sides of a boundary.
+  ASSERT_NO_FATAL_FAILURE(this->Execute(0, 0));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(100, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1023, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1024, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1025, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1024, 4));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(4099, 1));
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, WideDeltas) {
+  using c_type = typename TypeParam::c_type;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+
+  // Alternating extremes make an in-lane delta span 33 bits, which does not fit
+  // a 32-bit width after subtracting the minimum. Reconstruction wraps, so the
+  // block is stored at full width with no minimum and still round-trips.
+  constexpr int kNumValues = 2048;
+  std::vector<c_type> values(kNumValues);
+  for (int i = 0; i < kNumValues; ++i) {
+    values[i] = (i % 2 == 0) ? std::numeric_limits<c_type>::min()
+                             : std::numeric_limits<c_type>::max();
+  }
+
+  encoder->Put(values.data(), kNumValues);
+  auto buffer = encoder->FlushValues();
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+
+  std::vector<c_type> decoded(kNumValues);
+  ASSERT_EQ(kNumValues, decoder->Decode(decoded.data(), kNumValues));
+  ASSERT_EQ(values, decoded);
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, PageEndsOnEntryPoints) {
+  using c_type = typename TypeParam::c_type;
+  // A block whose values all advance by the same amount packs to width zero and
+  // so contributes nothing after its entry points. When such a block ends a page
+  // whose length is an exact multiple of the block size, those entry points are
+  // the last bytes of the page, and a decoder that reads them a machine word at
+  // a time reads past the page unless it stops short. Two strides are needed to
+  // get there: the entry points only need a width of their own if the step into
+  // a block differs from the steps inside it.
+  for (const int num_values : {2048, 3072}) {
+    std::vector<c_type> values(num_values);
+    for (int i = 0; i < num_values; ++i) {
+      values[i] = i < 1024 ? static_cast<c_type>(i * 5)
+                           : static_cast<c_type>(1023 * 5 + (i - 1023) * 3);
+    }
+    auto encoder =
+        MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                    /*use_dictionary=*/false, this->descr_.get());
+    encoder->Put(values.data(), num_values);
+    auto buffer = encoder->FlushValues();
+
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    decoder->SetData(num_values, buffer->data(), static_cast<int>(buffer->size()));
+    std::vector<c_type> decoded(num_values);
+    ASSERT_EQ(num_values, decoder->Decode(decoded.data(), num_values));
+    ASSERT_EQ(values, decoded);
+  }
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, EntryPointsFarApart) {
+  using c_type = typename TypeParam::c_type;
+  // The 32 entry points a block needs are delta-coded against each other and
+  // against the previous block's last one. Values that jump by half the type's
+  // range make those differences as wide as they can be, over several blocks.
+  constexpr int kNumValues = 4096;
+  std::vector<c_type> values(kNumValues);
+  const c_type step = std::numeric_limits<c_type>::max() / 2;
+  for (int i = 0; i < kNumValues; ++i) {
+    values[i] = static_cast<c_type>((i % 2 == 0) ? 0 : step);
+  }
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  encoder->Put(values.data(), kNumValues);
+  auto buffer = encoder->FlushValues();
+
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+  std::vector<c_type> decoded(kNumValues);
+  ASSERT_EQ(kNumValues, decoder->Decode(decoded.data(), kNumValues));
+  ASSERT_EQ(values, decoded);
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, DecoderReusedAcrossPages) {
+  using c_type = typename TypeParam::c_type;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+
+  // A column chunk reuses one decoder for all of its data pages, with only
+  // SetData between them. The second page is the longer one, so a decoder that
+  // kept the first page's values would also read past the end of them.
+  std::vector<std::vector<c_type>> pages = {{10, 11, 12, 13}, {}};
+  pages[1].resize(1100);
+  for (int i = 0; i < 1100; ++i) {
+    pages[1][i] = 900 + i * 3;
+  }
+
+  for (const auto& page : pages) {
+    const int page_values = static_cast<int>(page.size());
+    encoder->Put(page.data(), page_values);
+    auto buffer = encoder->FlushValues();
+    decoder->SetData(page_values, buffer->data(), static_cast<int>(buffer->size()));
+
+    std::vector<c_type> decoded(page.size());
+    ASSERT_EQ(page_values, decoder->Decode(decoded.data(), page_values));
+    ASSERT_EQ(page, decoded);
+  }
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, AllNullPage) {
+  constexpr int kNumValues = 40;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto buffer = encoder->FlushValues();
+
+  // A reader hands the decoder the page's level count, which counts the nulls, so
+  // the page and its bare value count have to survive being handed the full count.
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+
+  // All slots are null, so the page carries no encoded values at all.
+  std::vector<uint8_t> valid_bits(bit_util::BytesForBits(kNumValues), 0);
+  typename EncodingTraits<TypeParam>::Accumulator acc;
+  ASSERT_EQ(0, decoder->DecodeArrow(kNumValues, /*null_count=*/kNumValues,
+                                    valid_bits.data(), /*valid_bits_offset=*/0, &acc));
+
+  std::shared_ptr<::arrow::Array> result;
+  ASSERT_OK(acc.Finish(&result));
+  ASSERT_OK(result->ValidateFull());
+  ASSERT_EQ(kNumValues, result->length());
+  ASSERT_EQ(kNumValues, result->null_count());
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, SpacedRoundTrip) {
+  using c_type = typename TypeParam::c_type;
+  // Nulls are dropped on the way in and re-spread on the way out, so the values
+  // the page carries are fewer than the slots the reader asks for.
+  constexpr int kNumValues = 3000;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+
+  std::vector<c_type> values(kNumValues);
+  std::vector<uint8_t> valid_bits(bit_util::BytesForBits(kNumValues), 0);
+  int null_count = 0;
+  for (int i = 0; i < kNumValues; ++i) {
+    values[i] = i * 7 - 100;
+    // Every fifth slot is null.
+    if (i % 5 == 4) {
+      ++null_count;
+    } else {
+      bit_util::SetBit(valid_bits.data(), i);
+    }
+  }
+
+  encoder->PutSpaced(values.data(), kNumValues, valid_bits.data(),
+                     /*valid_bits_offset=*/0);
+  auto buffer = encoder->FlushValues();
+
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+
+  typename EncodingTraits<TypeParam>::Accumulator acc;
+  ASSERT_EQ(kNumValues - null_count,
+            decoder->DecodeArrow(kNumValues, null_count, valid_bits.data(),
+                                 /*valid_bits_offset=*/0, &acc));
+
+  std::shared_ptr<::arrow::Array> result;
+  ASSERT_OK(acc.Finish(&result));
+  ASSERT_OK(result->ValidateFull());
+  ASSERT_EQ(kNumValues, result->length());
+  ASSERT_EQ(null_count, result->null_count());
+  const auto& typed = checked_cast<const ::arrow::Int32Array&>(*result);
+  for (int i = 0; i < kNumValues; ++i) {
+    if (bit_util::GetBit(valid_bits.data(), i)) {
+      ASSERT_EQ(values[i], typed.Value(i)) << "at " << i;
+    }
+  }
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, RejectsCorruptPages) {
+  using c_type = typename TypeParam::c_type;
+  // The fuzzer reaches every registered encoding, so a page that does not
+  // describe itself consistently has to be refused rather than read past.
+  constexpr int kNumValues = 2048;
+  std::vector<c_type> values(kNumValues);
+  // Vary the stride so the blocks carry packed words: a constant stride packs
+  // to width zero, and then a truncation test never reaches the width bytes.
+  for (int i = 0; i < kNumValues; ++i) {
+    values[i] = i * 3 + (i % 7);
+  }
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  encoder->Put(values.data(), kNumValues);
+  auto page = encoder->FlushValues();
+  std::vector<c_type> decoded(kNumValues);
+
+  // A page shorter than its own value count.
+  {
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    decoder->SetData(kNumValues, page->data(),
+                     static_cast<int>(page->size()) - static_cast<int>(sizeof(c_type)));
+    EXPECT_THROW(decoder->Decode(decoded.data(), kNumValues), ParquetException);
+  }
+
+  // A page too short to hold even a value count.
+  {
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    EXPECT_THROW(decoder->SetData(kNumValues, page->data(), 2), ParquetException);
+  }
+
+  // A page whose declared count exceeds what the level count allows.
+  {
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    EXPECT_THROW(
+        decoder->SetData(kNumValues - 1, page->data(), static_cast<int>(page->size())),
+        ParquetException);
+  }
+
+  // A block claiming a payload width no 32-bit lane can hold. One width byte per
+  // block opens the payload, so block zero's follows the value count.
+  {
+    std::vector<uint8_t> corrupt(page->data(), page->data() + page->size());
+    constexpr int kWidthsOffset = 4;
+    corrupt[kWidthsOffset] = 33;
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    decoder->SetData(kNumValues, corrupt.data(), static_cast<int>(corrupt.size()));
+    EXPECT_THROW(decoder->Decode(decoded.data(), kNumValues), ParquetException);
+  }
+
+  // A block claiming an entry-point width no 32-bit lane can hold. That width
+  // lives inside the block rather than in the header, so reaching it means
+  // walking past the two blocks' widths, rounded up to a 4-byte boundary, and
+  // their two minimums.
+  {
+    std::vector<uint8_t> corrupt(page->data(), page->data() + page->size());
+    constexpr int kBasesOffset = 4 + 4 + 2 * static_cast<int>(sizeof(int32_t));
+    corrupt[kBasesOffset] = 33;
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    decoder->SetData(kNumValues, corrupt.data(), static_cast<int>(corrupt.size()));
+    EXPECT_THROW(decoder->Decode(decoded.data(), kNumValues), ParquetException);
+  }
+}
+
 // ----------------------------------------------------------------------
 // Rle for Boolean encode/decode tests.
 
diff --git a/cpp/src/parquet/meson.build b/cpp/src/parquet/meson.build
index 9069ccb5fd1a..1200427fe2f7 100644
--- a/cpp/src/parquet/meson.build
+++ b/cpp/src/parquet/meson.build
@@ -226,6 +226,7 @@ parquet_tests = {
     'chunker-test': {'sources': files('chunker_internal_test.cc')},
     'arrow-reader-writer-test': {
         'sources': files(
+            'arrow/arrow_encoding_test.cc',
             'arrow/arrow_reader_writer_test.cc',
             'arrow/arrow_statistics_test.cc',
             'arrow/variant_test.cc',
diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
new file mode 100644
index 000000000000..2507962cf2b0
--- /dev/null
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -0,0 +1,2254 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Comparison benchmark: PFOR vs DeltaBitPack vs ZSTD vs RleBitPackHybrid
+//                       vs ByteStreamSplit+ZSTD vs ByteStreamSplit+LZ4
+//
+// All throughput is reported as uncompressed_size / time (MB/s).
+// Data generators mimic ClickBench and TPC-DS column distributions. A second
+// group covers columns with structure between neighbouring values, or with a
+// cluster the minimum is not part of; those are the ones on which PFOR's delta
+// mode and DELTA_BINARY_PACKED make different choices.
+
+#include <algorithm>
+#include <bit>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+#include <numeric>
+#include <random>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+
+#include "arrow/util/bit_stream_utils_internal.h"
+#include "arrow/util/bpacking_internal.h"
+#include "arrow/util/fastlanes/interleaved_pfor.h"
+#include "arrow/util/fastlanes/lane_delta.h"
+#include "arrow/util/fastlanes/transposed_delta.h"
+#include "arrow/util/compression.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+#include "arrow/util/rle_encoding_internal.h"
+
+#include "parquet/encoding.h"
+#include "parquet/platform.h"
+#include "parquet/schema.h"
+#include "parquet/types.h"
+
+using ::arrow::Compression;
+using ::arrow::util::Codec;
+
+namespace parquet {
+namespace {
+
+// ============================================================================
+// Data Generators — ClickBench-inspired
+// ============================================================================
+
+// Generator pointer type, parameterized on the column value type.
+template <typename T>
+using GenT = std::vector<T> (*)(int64_t);
+using Gen32 = GenT<int32_t>;
+using Gen64 = GenT<int64_t>;
+
+// Map the C++ value type to its Parquet physical type + descriptor type.
+template <typename T>
+struct PqTraits;
+template <>
+struct PqTraits<int32_t> {
+  using PType = Int32Type;
+  static constexpr Type::type kPhysicalType = Type::INT32;
+};
+template <>
+struct PqTraits<int64_t> {
+  using PType = Int64Type;
+  static constexpr Type::type kPhysicalType = Type::INT64;
+};
+
+std::vector<int32_t> GenClientIP(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(101);
+  std::uniform_int_distribution<uint32_t> dist(0x0A000000, 0xDFFFFFFF);
+  for (auto& x : v) x = static_cast<int32_t>(dist(rng));
+  return v;
+}
+
+std::vector<int32_t> GenUrlRegionID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(102);
+  // Zipf-like over ~1000 values
+  std::uniform_real_distribution<double> uni(0.0, 1.0);
+  for (auto& x : v) {
+    double u = uni(rng);
+    x = static_cast<int32_t>(std::pow(u, 2.0) * 1000) + 1;
+  }
+  return v;
+}
+
+std::vector<int32_t> GenCounterID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(103);
+  std::uniform_int_distribution<int32_t> jitter(0, 3);
+  int32_t counter = 100000;
+  for (auto& x : v) {
+    counter += 1 + jitter(rng);
+    x = counter;
+  }
+  return v;
+}
+
+std::vector<int32_t> GenEventDate(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(104);
+  const int32_t dates[] = {19691, 19692, 19693, 19694, 19695};
+  std::uniform_int_distribution<int> idx(0, 4);
+  for (auto& x : v) x = dates[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenEventTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(105);
+  const int32_t base = 1704067200;  // 2024-01-01
+  std::uniform_int_distribution<int32_t> offset(0, 86399);
+  for (auto& x : v) x = base + offset(rng);
+  return v;
+}
+
+std::vector<int32_t> GenGoodEvent(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(106);
+  std::uniform_int_distribution<int> dist(0, 99);
+  for (auto& x : v) x = (dist(rng) < 95) ? 1 : 0;
+  return v;
+}
+
+std::vector<int32_t> GenHID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(107);
+  std::uniform_int_distribution<int32_t> dist(std::numeric_limits<int32_t>::min(),
+                                              std::numeric_limits<int32_t>::max());
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenHitColor(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(108);
+  const int32_t colors[] = {1, 2, 3, 4, 5};
+  std::uniform_int_distribution<int> idx(0, 4);
+  for (auto& x : v) x = colors[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenIPNetworkID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(109);
+  std::uniform_int_distribution<int32_t> dist(1, 10000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenJavaEnable(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(110);
+  std::uniform_int_distribution<int> dist(0, 99);
+  for (auto& x : v) x = (dist(rng) < 85) ? 1 : 0;
+  return v;
+}
+
+std::vector<int32_t> GenOS(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(111);
+  std::uniform_int_distribution<int32_t> dist(1, 20);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenResolution(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(112);
+  const int32_t resolutions[] = {360,  480,  600,  720,  768,  800,  900,
+                                 1024, 1050, 1080, 1200, 1440, 1600, 2160};
+  std::uniform_int_distribution<int> idx(0, 13);
+  for (auto& x : v) x = resolutions[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenTrafficSourceID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(113);
+  std::uniform_int_distribution<int32_t> dist(0, 10);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenUserAgent(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(114);
+  // Zipf-like over ~100 user agents
+  std::uniform_real_distribution<double> uni(0.0, 1.0);
+  for (auto& x : v) {
+    double u = uni(rng);
+    x = static_cast<int32_t>(std::pow(u, 1.5) * 100) + 1;
+  }
+  return v;
+}
+
+// ============================================================================
+// Data Generators — TPC-DS (4 most queried columns from store_sales)
+// ============================================================================
+
+std::vector<int32_t> GenTpcdsSoldDateSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 2450815;
+  std::mt19937 rng(201);
+  std::uniform_int_distribution<int32_t> dist(0, 1820);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsStoreSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(202);
+  std::uniform_int_distribution<int32_t> dist(1, 1000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsItemSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMax = 100000;
+  std::mt19937 rng(203);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    int32_t val = static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val + 1, kMax);
+  }
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsQuantity(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(204);
+  std::uniform_int_distribution<int32_t> small_dist(1, 10);
+  std::uniform_int_distribution<int32_t> large_dist(11, 100);
+  std::uniform_int_distribution<int> chance(0, 99);
+  for (auto& x : v) {
+    x = (chance(rng) < 90) ? small_dist(rng) : large_dist(rng);
+  }
+  return v;
+}
+
+// --- TPC-H (lineitem) top-queried numeric columns (Q1/Q3/Q5/Q6) ------------
+// l_quantity: integer [1, 50], uniform. Small range, min 1.
+std::vector<int32_t> GenTpchLQuantity(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(301);
+  std::uniform_int_distribution<int32_t> dist(1, 50);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// l_extendedprice (cents): l_quantity * p_retailprice. p_retailprice spans
+// ~$900.00..$2099.00, so cents in [90000, 10495000]. Wide range, nonzero min.
+std::vector<int32_t> GenTpchLExtendedPrice(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(302);
+  std::uniform_int_distribution<int32_t> qty(1, 50);
+  std::uniform_int_distribution<int32_t> retail_cents(90000, 209900);
+  for (auto& x : v) x = qty(rng) * retail_cents(rng);
+  return v;
+}
+
+// l_discount (x100): integer [0, 10] i.e. 0.00..0.10. Genuinely includes 0
+// (0% discount is a real value), so this one legitimately starts at 0.
+std::vector<int32_t> GenTpchLDiscount(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(303);
+  std::uniform_int_distribution<int32_t> dist(0, 10);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// l_shipdate (days since 1970-01-01): 1992-01-01..1998-12 span. Base 8036,
+// range ~7 years. Large nonzero min -> exercises frame-of-reference.
+std::vector<int32_t> GenTpchLShipDate(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 8036;  // days since epoch for 1992-01-01
+  std::mt19937 rng(304);
+  std::uniform_int_distribution<int32_t> dist(0, 2557);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+// --- TPC-DS (store_sales / date_dim) further top-queried numeric columns ---
+// ss_customer_sk: surrogate key, uniform [1, 2,000,000]. Big range, min 1.
+std::vector<int32_t> GenTpcdsCustomerSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(311);
+  std::uniform_int_distribution<int32_t> dist(1, 2000000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// ss_ext_sales_price (cents): skewed price, exponential mean ~$50, floored at
+// $1.00 (a sale has a nonzero price), capped at $20,000. Long tail -> patches.
+std::vector<int32_t> GenTpcdsExtSalesPrice(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMin = 100, kMax = 2000000;
+  std::mt19937 rng(312);
+  std::exponential_distribution<double> exp_dist(1.0 / 5000.0);
+  for (auto& x : v) {
+    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ss_net_profit (cents): usually a small profit, sometimes a loss -> negative
+// values, so the frame of reference is negative (not zero).
+std::vector<int32_t> GenTpcdsNetProfit(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(313);
+  std::uniform_int_distribution<int32_t> dist(-10000, 300000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// d_year: queried date_dim year range [1998, 2003]. Low cardinality, min 1998.
+std::vector<int32_t> GenTpcdsDYear(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(314);
+  std::uniform_int_distribution<int32_t> dist(1998, 2003);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// --- NYC yellow-taxi trip numeric columns ----------------------------------
+// pickup timestamp (unix seconds): 2015-01, base 1,420,070,400 + ~31 days.
+// Very large min -> frame-of-reference is essential.
+std::vector<int32_t> GenTaxiPickupUnixTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 1420070400;  // 2015-01-01 UTC
+  std::mt19937 rng(321);
+  std::uniform_int_distribution<int32_t> dist(0, 2678400);  // ~31 days
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+// trip_distance (x100 miles): exponential mean ~1.8 mi, floored at 0.10 mi
+// (no zero-distance trips), capped at 100 mi. Long tail -> patches.
+std::vector<int32_t> GenTaxiTripDistanceX100(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMin = 10, kMax = 10000;
+  std::mt19937 rng(322);
+  std::exponential_distribution<double> exp_dist(1.0 / 180.0);
+  for (auto& x : v) {
+    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// fare_amount (cents): $2.50 base + exponential mean ~$10, capped at $150.
+// Nonzero floor at the base fare, skewed with a long tail.
+std::vector<int32_t> GenTaxiFareCents(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 250, kMax = 15000;
+  std::mt19937 rng(323);
+  std::exponential_distribution<double> exp_dist(1.0 / 1000.0);
+  for (auto& x : v) {
+    int32_t val = kBase + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ============================================================================
+// Data Generators — int64 / BIGINT columns (values that require 8 bytes,
+// i.e. exceed the int32 range). Covers the common 64-bit analytic cases:
+// nanosecond timestamps, large surrogate keys, scaled-decimal money, monotone
+// IDs, and wide counters.
+// ============================================================================
+
+// Nanosecond epoch timestamp (Parquet TIMESTAMP(NANOS)): 2024-01-01 base plus
+// up to ~1 day of jitter. Min ~1.70e18 -> very large frame of reference; raw
+// values need ~61 bits.
+std::vector<int64_t> GenTsNanos(int64_t n) {
+  std::vector<int64_t> v(n);
+  const int64_t kBase = 1704067200000000000LL;  // 2024-01-01T00:00:00Z in ns
+  std::mt19937_64 rng(401);
+  std::uniform_int_distribution<int64_t> off(0, 86399999999999LL);  // ~1 day
+  for (auto& x : v) x = kBase + off(rng);
+  return v;
+}
+
+// BIGINT surrogate / order key, uniform over [1, 10 billion] (exceeds 2^32).
+std::vector<int64_t> GenOrderKey(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(402);
+  std::uniform_int_distribution<int64_t> dist(1, 10000000000LL);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// Money as int64 scaled decimal (micro-units): $0.01 .. ~$100k, skewed, with a
+// nonzero floor at one cent.
+std::vector<int64_t> GenPriceMicros(int64_t n) {
+  std::vector<int64_t> v(n);
+  const int64_t kMin = 10000, kMax = 100000000000LL;  // $0.01 .. $100,000
+  std::mt19937_64 rng(403);
+  std::exponential_distribution<double> exp_dist(1.0 / 5000000.0);  // mean ~$5
+  for (auto& x : v) {
+    int64_t val = kMin + static_cast<int64_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ============================================================================
+// Data Generators — sorted and near-sorted
+//
+// The generators above draw independently around a base, which is the case
+// delta encoding is not for: subtracting two i.i.d. values spans the whole
+// range whichever two you pick, so the distance between them does not matter
+// and every delta variant lands within a bit or two of frame of reference.
+// Comparing delta schemes needs columns whose value depends on the previous
+// one. These cover the shapes that occur in practice: a clustered timestamp
+// column, a sorted key with duplicates, an exact counter, and a column that
+// is sorted apart from a few late arrivals.
+// ============================================================================
+
+// Event timestamps in seconds, arriving a few seconds apart. The common case
+// for a table clustered or sorted on time.
+std::vector<int32_t> GenSortedUnixTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(401);
+  std::uniform_int_distribution<int32_t> gap(0, 7);
+  int32_t t = 1700000000;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = t;
+  }
+  return v;
+}
+
+// A sorted surrogate key with runs of duplicates, as produced by a join key or
+// a dictionary-sorted column: most steps are 0, some are 1.
+std::vector<int32_t> GenSortedKeyDups(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(402);
+  std::uniform_int_distribution<int32_t> step(0, 1);
+  int32_t k = 5000000;
+  for (auto& x : v) {
+    k += step(rng);
+    x = k;
+  }
+  return v;
+}
+
+// An exact +1 row id. The best case for any delta scheme, and the case where
+// stride-1 and lane-parallel delta differ most.
+std::vector<int32_t> GenMonotoneRowId(int64_t n) {
+  std::vector<int32_t> v(n);
+  int32_t k = 1;
+  for (auto& x : v) x = k++;
+  return v;
+}
+
+// Sorted except that 2% of rows arrive late, so a few deltas are large and
+// negative. Tests whether one bit width per block survives outliers.
+std::vector<int32_t> GenNearSortedUnixTime(int64_t n) {
+  std::vector<int32_t> v = GenSortedUnixTime(n);
+  std::mt19937 rng(403);
+  std::uniform_int_distribution<int> pick(0, 49);
+  std::uniform_int_distribution<int32_t> late(1, 3600);
+  for (auto& x : v) {
+    if (pick(rng) == 0) x -= late(rng);
+  }
+  return v;
+}
+
+// Snowflake-style monotone ID: large base + jittered per-row increments.
+// Monotone -> ideal for DELTA_BINARY_PACKED; huge min -> ideal for PFOR's FOR.
+std::vector<int64_t> GenSnowflakeId(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(404);
+  std::uniform_int_distribution<int64_t> step(1, 4096);
+  int64_t id = 1500000000000000000LL;
+  for (auto& x : v) {
+    id += step(rng);
+    x = id;
+  }
+  return v;
+}
+
+// Wide cumulative byte counts, uniform [1024, 5 trillion] (wide 64-bit range).
+std::vector<int64_t> GenByteCount(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(405);
+  std::uniform_int_distribution<int64_t> dist(1024, 5000000000000LL);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// ============================================================================
+// Data Generators — structure between neighbouring values
+// ============================================================================
+
+// The generators above are all either unordered or perfectly regular, so none
+// of them separates an encoding that differences neighbouring values from one
+// that packs them, and none of them puts a frame of reference anywhere but the
+// minimum. These do. They are the columns on which PFOR's delta mode and
+// DELTA_BINARY_PACKED make different choices, so they are what this file needs
+// in order to compare the two.
+//
+// Unlike the generators above, these are templates rather than a pair of
+// per-width functions: it keeps the int32 and int64 arms of every REGISTER
+// below on provably the same distribution, which two hand-written copies would
+// not. They live in their own namespace because two of them build on base
+// distributions whose names are already taken in this file by columns drawn
+// from different seeds -- keeping them separate is what makes these figures
+// comparable with pfor_benchmark.cc, which uses the same shapes.
+namespace delta_shapes {
+
+template <typename T>
+std::vector<T> GenSmallRange(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(100000, 200000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsItemSk(int64_t n) {
+  std::vector<T> v(n);
+  const T kMax = 100000;
+  std::mt19937_64 rng(12345);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    T val = static_cast<T>(exp_dist(rng));
+    x = std::min(static_cast<T>(val + 1), kMax);
+  }
+  return v;
+}
+
+/// A timestamp column with a fixed sampling interval and jitter: the
+/// differences cluster tightly around the interval, the values do not.
+template <typename T>
+std::vector<T> GenTrendJitter(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(7);
+  std::normal_distribution<double> jitter(0.0, 40.0);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += 3.0;
+    x = static_cast<T>(t + jitter(rng));
+  }
+  return v;
+}
+
+/// A TCP congestion window: a linear climb cut by a sharp halving. Almost
+/// every difference is the same small number and a few are large and
+/// negative, which is the shape a two-sided frame plus patching handles at
+/// close to no cost and a one-sided one cannot.
+template <typename T>
+std::vector<T> GenSawtooth(int64_t n) {
+  std::vector<T> v(n);
+  T cur = 1000;
+  for (int64_t i = 0; i < n; ++i) {
+    if (i % 200 == 199) {
+      cur /= 2;
+    } else {
+      cur += 12;
+    }
+    v[i] = cur;
+  }
+  return v;
+}
+
+/// A continuous quantity sampled over time, so the rate of change is bounded
+/// but the level wanders: differencing wins, though not by much.
+template <typename T>
+std::vector<T> GenMeasurement(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(11);
+  std::normal_distribution<double> noise(0.0, 1.0);
+  double level = 0.0;
+  double rate = 0.0;
+  for (int64_t i = 0; i < n; ++i) {
+    rate = 0.95 * rate + noise(rng);
+    level += rate;
+    v[i] = static_cast<T>(4000.0 * level / 50.0) + static_cast<T>(500000);
+  }
+  return v;
+}
+
+/// A sorted surrogate key column, which is what a clustered index or a
+/// sorted-by-key file produces.
+template <typename T>
+std::vector<T> GenSortedKeys(int64_t n) {
+  auto v = GenTpcdsItemSk<T>(n);
+  std::sort(v.begin(), v.end());
+  return v;
+}
+
+/// A measurement series punctuated by a low sentinel standing in for "no
+/// reading". The sentinel sits far below the cluster, so a frame pinned to
+/// the minimum has to widen to reach it and no value can ever be patched.
+template <typename T>
+std::vector<T> GenSensorDropouts(int64_t n) {
+  auto v = GenMeasurement<T>(n);
+  std::mt19937_64 rng(3);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-999999);
+  }
+  return v;
+}
+
+/// Monotonic ids with occasional large jumps, as a sequence shared between
+/// writers or restarted produces.
+template <typename T>
+std::vector<T> GenIdsWithGaps(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(5);
+  std::uniform_int_distribution<int> step(1, 6);
+  std::uniform_int_distribution<int> jump(0, 199);
+  T cur = 1000000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    if (jump(rng) == 0) cur += 100000;
+    x = cur;
+  }
+  return v;
+}
+
+/// Prices on a random walk: small signed steps around a high base, and no
+/// trend for the differences to line up on.
+template <typename T>
+std::vector<T> GenRandomWalk(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(13);
+  std::uniform_int_distribution<int> step(-25, 25);
+  T cur = 1500000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    x = cur;
+  }
+  return v;
+}
+
+/// Event arrival times in milliseconds since the epoch, bursty, so the gaps
+/// are skewed rather than clustered.
+template <typename T>
+std::vector<T> GenEventMillis(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(17);
+  std::exponential_distribution<double> gap(0.4);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = static_cast<T>(t);
+  }
+  return v;
+}
+
+/// A tight unordered cluster with a low "missing" sentinel: the frame cannot
+/// sit at the minimum and differencing has nothing to exploit either, so
+/// this is the column that has to come out no worse than before.
+template <typename T>
+std::vector<T> GenLowSentinel(int64_t n) {
+  auto v = GenSmallRange<T>(n);
+  std::mt19937_64 rng(23);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-1000);
+  }
+  return v;
+}
+
+/// Two interleaved clusters far apart, so no single window covers the vector
+/// and the cheaper cluster is worth framing on its own.
+template <typename T>
+std::vector<T> GenBimodal(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(19);
+  std::uniform_int_distribution<T> lo(1000, 1100);
+  std::uniform_int_distribution<T> hi(900000, 900100);
+  std::uniform_int_distribution<int> pick(0, 9);
+  for (auto& x : v) {
+    x = pick(rng) < 8 ? lo(rng) : hi(rng);
+  }
+  return v;
+}
+
+}  // namespace delta_shapes
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+template <typename T>
+static int32_t ComputeBitWidth(const std::vector<T>& values) {
+  using U = std::make_unsigned_t<T>;
+  U max_val = 0;
+  for (T v : values) {
+    max_val = std::max(max_val, static_cast<U>(v));
+  }
+  if (max_val == 0) return 1;
+  if constexpr (sizeof(T) == 8) {
+    return static_cast<int32_t>(std::bit_width(static_cast<uint64_t>(max_val)));
+  } else {
+    return static_cast<int32_t>(std::bit_width(static_cast<uint32_t>(max_val)));
+  }
+}
+
+template <typename T>
+static std::shared_ptr<ColumnDescriptor> MakeDescriptor() {
+  auto node = schema::PrimitiveNode::Make("col", Repetition::REQUIRED,
+                                          PqTraits<T>::kPhysicalType);
+  return std::make_shared<ColumnDescriptor>(node, /*max_def_level=*/0,
+                                            /*max_rep_level=*/0);
+}
+
+// ============================================================================
+// PFOR Encode/Decode
+// ============================================================================
+
+template <typename T>
+static void PforEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int64_t max_size = ::arrow::util::pfor::PforWrapper<T>::GetMaxCompressedSize(
+                         static_cast<int32_t>(num_values))
+                         .ValueOrDie();
+  std::vector<uint8_t> compressed(max_size);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size = max_size;
+  ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
+      values.data(), static_cast<int32_t>(num_values), compressed.data(), &comp_size));
+
+  for (auto _ : state) {
+    int64_t sz = max_size;
+    ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
+        values.data(), static_cast<int32_t>(num_values), compressed.data(), &sz));
+    benchmark::DoNotOptimize(sz);
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+// ---------------------------------------------------------------------------
+// One process-wide, 4096-aligned output buffer shared by every decode arm.
+//
+// A same-binary A/B of two decoders is otherwise confounded by where malloc
+// happened to put each arm's output vector. Measured on this box, changing only
+// which arms were in the --benchmark_filter set -- and so what each arm's output
+// address was mod 4096 -- moved the interleaved arm's throughput by 1.4x while
+// barely touching the sequential arm's. That is larger than any layout effect
+// being measured here, and it produced the physically impossible reading that
+// FL_ORDER-with-order-restored decoded *faster* than the same unpack without the
+// permutation. Sharing one buffer makes every arm write identical addresses, so
+// the only thing left varying between arms is their code.
+//
+// Safe to share: benchmarks in a process run one at a time, and every arm
+// overwrites the whole buffer before reading it back.
+// ---------------------------------------------------------------------------
+template <typename T>
+T* SharedDecodeBuffer(int64_t num_values) {
+  static void* raw = nullptr;
+  static size_t cap = 0;
+  const size_t want = static_cast<size_t>(num_values) * sizeof(T);
+  if (want > cap) {
+    std::free(raw);
+    raw = nullptr;
+    if (posix_memalign(&raw, 4096, want + 4096) != 0) std::abort();
+    cap = want;
+  }
+  std::memset(raw, 0, want);
+  return static_cast<T*>(raw);
+}
+
+static void BM_PforEncode(benchmark::State& state, Gen32 gen) {
+  PforEncodeImpl<int32_t>(state, gen);
+}
+static void BM_Pfor64Encode(benchmark::State& state, Gen64 gen) {
+  PforEncodeImpl<int64_t>(state, gen);
+}
+
+template <typename T>
+static void PforDecodeImpl(benchmark::State& state, GenT<T> gen,
+                           ::arrow::util::pfor::PforEncodeOptions options = {}) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int64_t max_size = ::arrow::util::pfor::PforWrapper<T>::GetMaxCompressedSize(
+                         static_cast<int32_t>(num_values))
+                         .ValueOrDie();
+  std::vector<uint8_t> compressed(max_size);
+  int64_t comp_size = max_size;
+  ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
+      values.data(), static_cast<int32_t>(num_values), compressed.data(), &comp_size,
+      options));
+
+  T* decoded = SharedDecodeBuffer<T>(num_values);
+  for (auto _ : state) {
+    auto status = ::arrow::util::pfor::PforWrapper<T>::Decode(
+        compressed.data(), comp_size, static_cast<int32_t>(num_values), decoded);
+    ARROW_CHECK_OK(status);
+    benchmark::ClobberMemory();
+  }
+  // The interleaved arms assert their round trip; this one did not, so a plan
+  // change silently producing wrong values would have read as a speedup.
+  ARROW_CHECK(std::equal(decoded, decoded + num_values, values.begin()))
+      << "pfor round trip failed";
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_PforDecode(benchmark::State& state, Gen32 gen) {
+  PforDecodeImpl<int32_t>(state, gen);
+}
+static void BM_Pfor64Decode(benchmark::State& state, Gen64 gen) {
+  PforDecodeImpl<int64_t>(state, gen);
+}
+
+// The two arms below hold the delta decision fixed so that the bit-packed
+// layout is the only thing separating them. BM_PforDecode above is the shipping
+// default, which lets the planner difference a vector whenever its cost model
+// prefers that; on a sorted or correlated column it does, and the decode then
+// also pays a serial prefix sum. A ratio taken against a layout arm that never
+// deltas therefore measures two decisions at once, not the layout. These two
+// decline delta on both sides, so the ratio between them is a layout result,
+// and it is valid on every column rather than only the ones the planner leaves
+// alone.
+static void BM_PforPlainSeqDecode(benchmark::State& state, Gen32 gen) {
+  PforDecodeImpl<int32_t>(
+      state, gen,
+      {/*delta_enabled=*/false, ::arrow::util::pfor::PackingMode::kForBitPack});
+}
+static void BM_PforPlainInterleavedDecode(benchmark::State& state, Gen32 gen) {
+  PforDecodeImpl<int32_t>(
+      state, gen,
+      {/*delta_enabled=*/false,
+       ::arrow::util::pfor::PackingMode::kForBitPackInterleaved});
+}
+
+// ============================================================================
+// DeltaBitPack Encode/Decode
+// ============================================================================
+
+template <typename T>
+static void DeltaBitPackEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  using PType = typename PqTraits<T>::PType;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto encoder = MakeTypedEncoder<PType>(Encoding::DELTA_BINARY_PACKED);
+
+  // Compute comp_size once for the counter
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto pre_buf = encoder->FlushValues();
+  int64_t comp_size = pre_buf->size();
+
+  for (auto _ : state) {
+    encoder->Put(values.data(), static_cast<int>(num_values));
+    auto buf = encoder->FlushValues();
+    benchmark::DoNotOptimize(buf);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_DeltaBitPackEncode(benchmark::State& state, Gen32 gen) {
+  DeltaBitPackEncodeImpl<int32_t>(state, gen);
+}
+static void BM_DeltaBitPack64Encode(benchmark::State& state, Gen64 gen) {
+  DeltaBitPackEncodeImpl<int64_t>(state, gen);
+}
+
+template <typename T>
+static void DeltaBitPackDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  using PType = typename PqTraits<T>::PType;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto encoder = MakeTypedEncoder<PType>(Encoding::DELTA_BINARY_PACKED);
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto buf = encoder->FlushValues();
+  int64_t comp_size = buf->size();
+
+  T* decoded = SharedDecodeBuffer<T>(num_values);
+  auto decoder = MakeTypedDecoder<PType>(Encoding::DELTA_BINARY_PACKED);
+
+  for (auto _ : state) {
+    decoder->SetData(static_cast<int>(num_values), buf->data(),
+                     static_cast<int>(buf->size()));
+    decoder->Decode(decoded, static_cast<int>(num_values));
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_DeltaBitPackDecode(benchmark::State& state, Gen32 gen) {
+  DeltaBitPackDecodeImpl<int32_t>(state, gen);
+}
+static void BM_DeltaBitPack64Decode(benchmark::State& state, Gen64 gen) {
+  DeltaBitPackDecodeImpl<int64_t>(state, gen);
+}
+
+// ============================================================================
+// Plain + ZSTD Encode/Decode
+// ============================================================================
+
+template <typename T>
+static void PlainCodecEncodeImpl(benchmark::State& state, GenT<T> gen,
+                                 Compression::type codec_type) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+  const uint8_t* raw = reinterpret_cast<const uint8_t*>(values.data());
+
+  auto codec = *Codec::Create(codec_type);
+  int64_t max_comp = codec->MaxCompressedLen(uncompressed_size, raw);
+  std::vector<uint8_t> compressed(max_comp);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size =
+      *codec->Compress(uncompressed_size, raw, max_comp, compressed.data());
+
+  for (auto _ : state) {
+    auto sz = *codec->Compress(uncompressed_size, raw, max_comp, compressed.data());
+    benchmark::DoNotOptimize(sz);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+template <typename T>
+static void PlainCodecDecodeImpl(benchmark::State& state, GenT<T> gen,
+                                 Compression::type codec_type) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+  const uint8_t* raw = reinterpret_cast<const uint8_t*>(values.data());
+
+  auto codec = *Codec::Create(codec_type);
+  int64_t max_comp = codec->MaxCompressedLen(uncompressed_size, raw);
+  std::vector<uint8_t> compressed(max_comp);
+  int64_t comp_size =
+      *codec->Compress(uncompressed_size, raw, max_comp, compressed.data());
+
+  std::vector<uint8_t> decompressed(uncompressed_size);
+  for (auto _ : state) {
+    auto result = codec->Decompress(comp_size, compressed.data(), uncompressed_size,
+                                    decompressed.data());
+    ARROW_CHECK_OK(result.status());
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_PlainZstdEncode(benchmark::State& state, Gen32 gen) {
+  PlainCodecEncodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_PlainZstd64Encode(benchmark::State& state, Gen64 gen) {
+  PlainCodecEncodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+static void BM_PlainZstdDecode(benchmark::State& state, Gen32 gen) {
+  PlainCodecDecodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_PlainZstd64Decode(benchmark::State& state, Gen64 gen) {
+  PlainCodecDecodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+
+// ============================================================================
+// Plain + LZ4 Encode/Decode
+// ============================================================================
+
+static void BM_PlainLz4Encode(benchmark::State& state, Gen32 gen) {
+  PlainCodecEncodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_PlainLz464Encode(benchmark::State& state, Gen64 gen) {
+  PlainCodecEncodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_PlainLz4Decode(benchmark::State& state, Gen32 gen) {
+  PlainCodecDecodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_PlainLz464Decode(benchmark::State& state, Gen64 gen) {
+  PlainCodecDecodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+
+// ============================================================================
+// RleBitPackHybrid Encode/Decode
+// ============================================================================
+
+template <typename T>
+static void RleBitPackEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  using U = std::make_unsigned_t<T>;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int32_t bit_width = ComputeBitWidth<T>(values);
+  int64_t max_buf =
+      ::arrow::util::RleBitPackedEncoder::MaxBufferSize(bit_width, num_values) +
+      ::arrow::util::RleBitPackedEncoder::MinBufferSize(bit_width);
+  std::vector<uint8_t> buffer(max_buf);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size;
+  {
+    ::arrow::util::RleBitPackedEncoder enc(buffer.data(), static_cast<int>(max_buf),
+                                           bit_width);
+    for (int64_t i = 0; i < num_values; ++i) {
+      enc.Put(static_cast<uint64_t>(static_cast<U>(values[i])));
+    }
+    comp_size = enc.Flush();
+  }
+
+  for (auto _ : state) {
+    ::arrow::util::RleBitPackedEncoder encoder(buffer.data(), static_cast<int>(max_buf),
+                                               bit_width);
+    for (int64_t i = 0; i < num_values; ++i) {
+      encoder.Put(static_cast<uint64_t>(static_cast<U>(values[i])));
+    }
+    auto sz = encoder.Flush();
+    benchmark::DoNotOptimize(sz);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_RleBitPackEncode(benchmark::State& state, Gen32 gen) {
+  RleBitPackEncodeImpl<int32_t>(state, gen);
+}
+static void BM_RleBitPack64Encode(benchmark::State& state, Gen64 gen) {
+  RleBitPackEncodeImpl<int64_t>(state, gen);
+}
+
+template <typename T>
+static void RleBitPackDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  using U = std::make_unsigned_t<T>;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int32_t bit_width = ComputeBitWidth<T>(values);
+  int64_t max_buf =
+      ::arrow::util::RleBitPackedEncoder::MaxBufferSize(bit_width, num_values) +
+      ::arrow::util::RleBitPackedEncoder::MinBufferSize(bit_width);
+  std::vector<uint8_t> buffer(max_buf);
+
+  ::arrow::util::RleBitPackedEncoder encoder(buffer.data(), static_cast<int>(max_buf),
+                                             bit_width);
+  for (int64_t i = 0; i < num_values; ++i) {
+    encoder.Put(static_cast<uint64_t>(static_cast<U>(values[i])));
+  }
+  int comp_size = encoder.Flush();
+
+  std::vector<T> decoded(num_values);
+  for (auto _ : state) {
+    ::arrow::util::RleBitPackedParser parser(buffer.data(), comp_size, bit_width);
+    int64_t out_idx = 0;
+    struct Handler {
+      T* output;
+      int64_t* idx;
+      int64_t max_values;
+      int32_t bw;
+      ::arrow::util::RleBitPackedParser::ControlFlow OnRleRun(::arrow::util::RleRun run) {
+        ::arrow::util::RleRunDecoder<T> dec(run, bw);
+        auto want = static_cast<int32_t>(
+            std::min(static_cast<int64_t>(run.values_count()), max_values - *idx));
+        auto count = dec.GetBatch(output + *idx, want, bw);
+        *idx += count;
+        return *idx >= max_values
+                   ? ::arrow::util::RleBitPackedParser::ControlFlow::Break
+                   : ::arrow::util::RleBitPackedParser::ControlFlow::Continue;
+      }
+      ::arrow::util::RleBitPackedParser::ControlFlow OnBitPackedRun(
+          ::arrow::util::BitPackedRun run) {
+        ::arrow::util::BitPackedRunDecoder<T> dec(run, bw);
+        auto want = static_cast<int32_t>(
+            std::min(static_cast<int64_t>(dec.remaining()), max_values - *idx));
+        auto count = dec.GetBatch(output + *idx, want, bw);
+        *idx += count;
+        return *idx >= max_values
+                   ? ::arrow::util::RleBitPackedParser::ControlFlow::Break
+                   : ::arrow::util::RleBitPackedParser::ControlFlow::Continue;
+      }
+    };
+    Handler handler{decoded.data(), &out_idx, num_values, bit_width};
+    parser.Parse(handler);
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_RleBitPackDecode(benchmark::State& state, Gen32 gen) {
+  RleBitPackDecodeImpl<int32_t>(state, gen);
+}
+static void BM_RleBitPack64Decode(benchmark::State& state, Gen64 gen) {
+  RleBitPackDecodeImpl<int64_t>(state, gen);
+}
+
+// ============================================================================
+// ByteStreamSplit + Codec (ZSTD or LZ4)
+// ============================================================================
+
+template <typename T>
+static void BssCodecEncodeImpl(benchmark::State& state, GenT<T> gen,
+                               Compression::type codec_type) {
+  using PType = typename PqTraits<T>::PType;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto descr = MakeDescriptor<T>();
+  auto encoder = MakeTypedEncoder<PType>(Encoding::BYTE_STREAM_SPLIT,
+                                         /*use_dictionary=*/false, descr.get());
+  auto codec = *Codec::Create(codec_type);
+
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto encoded_buf = encoder->FlushValues();
+  int64_t encoded_size = encoded_buf->size();
+
+  int64_t max_comp = codec->MaxCompressedLen(encoded_size, encoded_buf->data());
+  std::vector<uint8_t> compressed(max_comp);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size =
+      *codec->Compress(encoded_size, encoded_buf->data(), max_comp, compressed.data());
+
+  for (auto _ : state) {
+    encoder->Put(values.data(), static_cast<int>(num_values));
+    auto buf = encoder->FlushValues();
+    auto sz = *codec->Compress(buf->size(), buf->data(), max_comp, compressed.data());
+    benchmark::DoNotOptimize(sz);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+template <typename T>
+static void BssCodecDecodeImpl(benchmark::State& state, GenT<T> gen,
+                               Compression::type codec_type) {
+  using PType = typename PqTraits<T>::PType;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto descr = MakeDescriptor<T>();
+  auto encoder = MakeTypedEncoder<PType>(Encoding::BYTE_STREAM_SPLIT,
+                                         /*use_dictionary=*/false, descr.get());
+  auto codec = *Codec::Create(codec_type);
+
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto encoded_buf = encoder->FlushValues();
+  int64_t encoded_size = encoded_buf->size();
+
+  int64_t max_comp = codec->MaxCompressedLen(encoded_size, encoded_buf->data());
+  std::vector<uint8_t> compressed(max_comp);
+  int64_t comp_size =
+      *codec->Compress(encoded_size, encoded_buf->data(), max_comp, compressed.data());
+
+  std::vector<uint8_t> decompressed(encoded_size);
+  std::vector<T> decoded(num_values);
+  auto decoder = MakeTypedDecoder<PType>(Encoding::BYTE_STREAM_SPLIT, descr.get());
+
+  for (auto _ : state) {
+    auto result = codec->Decompress(comp_size, compressed.data(), encoded_size,
+                                    decompressed.data());
+    ARROW_CHECK_OK(result.status());
+    decoder->SetData(static_cast<int>(num_values), decompressed.data(),
+                     static_cast<int>(encoded_size));
+    decoder->Decode(decoded.data(), static_cast<int>(num_values));
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+// Wrappers for BSS+ZSTD
+static void BM_BssZstdEncode(benchmark::State& state, Gen32 gen) {
+  BssCodecEncodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_BssZstd64Encode(benchmark::State& state, Gen64 gen) {
+  BssCodecEncodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+static void BM_BssZstdDecode(benchmark::State& state, Gen32 gen) {
+  BssCodecDecodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_BssZstd64Decode(benchmark::State& state, Gen64 gen) {
+  BssCodecDecodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+
+// Wrappers for BSS+LZ4
+static void BM_BssLz4Encode(benchmark::State& state, Gen32 gen) {
+  BssCodecEncodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_BssLz464Encode(benchmark::State& state, Gen64 gen) {
+  BssCodecEncodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_BssLz4Decode(benchmark::State& state, Gen32 gen) {
+  BssCodecDecodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_BssLz464Decode(benchmark::State& state, Gen64 gen) {
+  BssCodecDecodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+
+
+// ============================================================================
+// DELTA_BINARY_PACKED cost decomposition
+// ============================================================================
+//
+// Splits the cost of decoding a DELTA_BINARY_PACKED page into three parts:
+// per-block header parsing, the call into the bit unpacker, and the serial
+// prefix sum. Each ablated arm reads the same stream and calls the same
+// out-of-line `arrow::internal::unpack` in libarrow, so only the surrounding
+// loop is recompiled here. `kFull` exists to be cross-checked against the
+// in-tree BM_DeltaBitPackDecode arm; if the two disagree, none of the ablated
+// arms mean anything.
+
+enum class DbpAblate {
+  kFull,        // headers + unpack + prefix sum
+  kNoSum,       // headers + unpack
+  kNoUnpack,    // headers + prefix sum, bit reader advanced instead of unpacked
+  kHeaderOnly,  // headers only
+  // Reader-side variants. Both read a byte-identical stream and are available
+  // to any conforming reader with no format change.
+  kCoalesce,  // one unpack call per run of miniblocks sharing a bit width
+  kBlockSum,  // one prefix-sum loop per block instead of one per miniblock
+  kBoth,      // both of the above
+  kDirect,    // kBoth, plus unpack_bias called directly with min_delta as bias
+};
+
+constexpr bool DbpIsReaderSide(DbpAblate a) {
+  return a == DbpAblate::kCoalesce || a == DbpAblate::kBlockSum ||
+         a == DbpAblate::kBoth || a == DbpAblate::kDirect;
+}
+constexpr bool DbpDoesCoalesce(DbpAblate a) {
+  return a == DbpAblate::kCoalesce || a == DbpAblate::kBoth ||
+         a == DbpAblate::kDirect;
+}
+constexpr bool DbpDoesBlockSum(DbpAblate a) {
+  return a == DbpAblate::kBlockSum || a == DbpAblate::kBoth ||
+         a == DbpAblate::kDirect;
+}
+// kDirect skips BitReader::GetBatch and calls the unpacker itself. Legal here
+// because every miniblock boundary is byte-aligned: the block header is read
+// with byte-aligned primitives, and a miniblock of v values at width w occupies
+// exactly v*w/8 bytes with v a multiple of 32, so w*v is always a multiple of 8.
+// Folding min_delta in as the unpacker's bias also removes one add per value
+// from the prefix-sum loop body.
+constexpr bool DbpDoesDirectUnpack(DbpAblate a) { return a == DbpAblate::kDirect; }
+
+// A DELTA_BINARY_PACKED writer with configurable block geometry. The format
+// carries values_per_block and mini_blocks_per_block as varints at the front of
+// every stream, constrained only to multiples of 128 and 32 respectively.
+// Arrow's own encoder takes both as constructor arguments but is declared in an
+// anonymous namespace, so sweeping the geometry needs a writer here.
+template <typename T>
+std::shared_ptr<::arrow::Buffer> WriteDbpStream(const std::vector<T>& values,
+                                               uint32_t values_per_block,
+                                               uint32_t mini_blocks_per_block) {
+  using UT = std::make_unsigned_t<T>;
+  const uint32_t values_per_mini_block = values_per_block / mini_blocks_per_block;
+  ARROW_CHECK_EQ(values_per_block % 128, 0u);
+  ARROW_CHECK_EQ(values_per_mini_block % 32, 0u);
+
+  const size_t n = values.size();
+  // Deltas are v[i] - v[i-1]; the first value travels in the header.
+  std::vector<UT> deltas(n > 0 ? n - 1 : 0);
+  for (size_t i = 1; i < n; ++i) {
+    deltas[i - 1] = static_cast<UT>(values[i]) - static_cast<UT>(values[i - 1]);
+  }
+
+  auto buf = AllocateBuffer(::arrow::default_memory_pool(),
+                            static_cast<int64_t>(n * sizeof(T) * 2 + 1024));
+  ::arrow::bit_util::BitWriter writer(buf->mutable_data(),
+                                      static_cast<int>(buf->size()));
+  ARROW_CHECK(writer.PutVlqInt(values_per_block));
+  ARROW_CHECK(writer.PutVlqInt(mini_blocks_per_block));
+  ARROW_CHECK(writer.PutVlqInt(static_cast<uint32_t>(n)));
+  ARROW_CHECK(writer.PutZigZagVlqInt(n > 0 ? values[0] : T{0}));
+
+  std::vector<UT> residuals(values_per_block);
+  std::vector<uint8_t> widths(mini_blocks_per_block);
+  for (size_t base = 0; base < deltas.size(); base += values_per_block) {
+    const size_t present = std::min<size_t>(values_per_block, deltas.size() - base);
+    // min_delta is signed-minimum over the deltas actually present.
+    T min_delta = static_cast<T>(deltas[base]);
+    for (size_t k = 1; k < present; ++k) {
+      min_delta = std::min(min_delta, static_cast<T>(deltas[base + k]));
+    }
+    for (size_t k = 0; k < present; ++k) {
+      residuals[k] = deltas[base + k] - static_cast<UT>(min_delta);
+    }
+    // Pad the block out with zero residuals, i.e. with a delta of min_delta.
+    std::fill(residuals.begin() + present, residuals.end(), UT{0});
+
+    for (uint32_t m = 0; m < mini_blocks_per_block; ++m) {
+      UT max_res = 0;
+      for (uint32_t k = 0; k < values_per_mini_block; ++k) {
+        max_res = std::max(max_res, residuals[m * values_per_mini_block + k]);
+      }
+      widths[m] = static_cast<uint8_t>(std::bit_width(max_res));
+    }
+    ARROW_CHECK(writer.PutZigZagVlqInt(min_delta));
+    uint8_t* wp = writer.GetNextBytePtr(static_cast<int>(mini_blocks_per_block));
+    ARROW_CHECK(wp != nullptr);
+    memcpy(wp, widths.data(), mini_blocks_per_block);
+    for (uint32_t m = 0; m < mini_blocks_per_block; ++m) {
+      if (widths[m] == 0) continue;
+      for (uint32_t k = 0; k < values_per_mini_block; ++k) {
+        ARROW_CHECK(writer.PutValue(residuals[m * values_per_mini_block + k], widths[m]));
+      }
+    }
+  }
+  writer.Flush();
+  return SliceBuffer(buf, 0, writer.bytes_written());
+}
+
+// Shadow of DeltaBitPackDecoder::GetInternal with the same stream handling and
+// the same call into libarrow's unpacker, minus whichever part is ablated.
+template <typename T, DbpAblate kAblate, bool kHeapReader = false>
+int DbpAblatedDecode(const uint8_t* data, int len, T* out) {
+  using UT = std::make_unsigned_t<T>;
+  // The shipping decoder holds its BitReader behind a shared_ptr, so its bit
+  // position lives in heap memory reached through a load rather than in a
+  // stack slot the compiler can keep in registers. kHeapReader reproduces that
+  // placement so the shadow can be compared with the real thing.
+  std::shared_ptr<::arrow::bit_util::BitReader> heap_reader;
+  if constexpr (kHeapReader) {
+    heap_reader = std::make_shared<::arrow::bit_util::BitReader>(data, len);
+  }
+  ::arrow::bit_util::BitReader stack_reader(data, len);
+  ::arrow::bit_util::BitReader& reader =
+      kHeapReader ? *heap_reader : stack_reader;
+  uint32_t values_per_block = 0, mini_blocks_per_block = 0, total_count = 0;
+  T first_value = 0;
+  ARROW_CHECK(reader.GetVlqInt(&values_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&mini_blocks_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&total_count));
+  ARROW_CHECK(reader.GetZigZagVlqInt(&first_value));
+  const uint32_t values_per_mini_block = values_per_block / mini_blocks_per_block;
+
+  int i = 0;
+  out[i++] = first_value;
+  UT last = static_cast<UT>(first_value);
+  uint32_t remaining = total_count - 1;
+  std::vector<uint8_t> widths(mini_blocks_per_block);
+
+  while (remaining > 0) {
+    T min_delta = 0;
+    ARROW_CHECK(reader.GetZigZagVlqInt(&min_delta));
+    for (uint32_t m = 0; m < mini_blocks_per_block; ++m) {
+      ARROW_CHECK(reader.GetAligned<uint8_t>(1, widths.data() + m));
+    }
+    for (uint32_t m = 0; m < mini_blocks_per_block && remaining > 0; ++m) {
+      const uint32_t count = std::min(values_per_mini_block, remaining);
+      const int w = widths[m];
+      if (w == 0) {
+        // Same zero-width shortcut the in-tree decoder takes.
+        if constexpr (kAblate == DbpAblate::kFull || kAblate == DbpAblate::kNoUnpack) {
+          for (uint32_t k = 0; k < count; ++k) {
+            out[i + k] = static_cast<T>(last + static_cast<UT>(k + 1) *
+                                                   static_cast<UT>(min_delta));
+          }
+          last += static_cast<UT>(count) * static_cast<UT>(min_delta);
+        }
+      } else {
+        if constexpr (kAblate == DbpAblate::kFull || kAblate == DbpAblate::kNoSum) {
+          ARROW_CHECK_EQ(reader.GetBatch(w, out + i, static_cast<int>(count)),
+                         static_cast<int>(count));
+        } else {
+          ARROW_CHECK(reader.Advance(static_cast<int64_t>(w) * count));
+        }
+        if constexpr (kAblate == DbpAblate::kFull || kAblate == DbpAblate::kNoUnpack) {
+          const UT md = static_cast<UT>(min_delta);
+          for (uint32_t k = 0; k < count; ++k) {
+            last += md + static_cast<UT>(out[i + k]);
+            out[i + k] = static_cast<T>(last);
+          }
+        }
+      }
+      i += static_cast<int>(count);
+      remaining -= count;
+    }
+  }
+  return i;
+}
+
+// Reader-side variants, reading a byte-identical stream.
+//
+// Coalescing: the payload is one sequential LSB-first bit run with no padding
+// between miniblocks, so two adjacent miniblocks that share a bit width are
+// bit-identical to a single run of twice the length at that width. Unpacking
+// them in one call raises the values-per-call the unpacker sees without
+// touching the stream. Nothing in the format has to change; the reader just
+// stops asking for 32 values at a time when it could ask for 128.
+//
+// Block sum: min_delta is a per-block quantity, so the serial prefix sum need
+// not restart at every miniblock boundary.
+template <typename T, DbpAblate kAblate>
+int DbpReaderSideDecode(const uint8_t* data, int len, T* out) {
+  using UT = std::make_unsigned_t<T>;
+  ::arrow::bit_util::BitReader reader(data, len);
+  uint32_t values_per_block = 0, mini_blocks_per_block = 0, total_count = 0;
+  T first_value = 0;
+  ARROW_CHECK(reader.GetVlqInt(&values_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&mini_blocks_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&total_count));
+  ARROW_CHECK(reader.GetZigZagVlqInt(&first_value));
+  const uint32_t values_per_mini_block = values_per_block / mini_blocks_per_block;
+
+  int i = 0;
+  out[i++] = first_value;
+  UT last = static_cast<UT>(first_value);
+  uint32_t remaining = total_count - 1;
+  std::vector<uint8_t> widths(mini_blocks_per_block);
+
+  while (remaining > 0) {
+    T min_delta = 0;
+    ARROW_CHECK(reader.GetZigZagVlqInt(&min_delta));
+    for (uint32_t m = 0; m < mini_blocks_per_block; ++m) {
+      ARROW_CHECK(reader.GetAligned<uint8_t>(1, widths.data() + m));
+    }
+    const UT md = static_cast<UT>(min_delta);
+    const int block_start = i;
+    uint32_t block_values = 0;
+
+    for (uint32_t m = 0; m < mini_blocks_per_block && remaining > 0;) {
+      uint32_t run = 1;
+      if constexpr (DbpDoesCoalesce(kAblate)) {
+        // Extend the run while the next miniblock shares this width and is
+        // fully present, so the coalesced call never crosses the tail.
+        while (m + run < mini_blocks_per_block && widths[m + run] == widths[m] &&
+               remaining > run * values_per_mini_block) {
+          ++run;
+        }
+      }
+      const uint32_t count = std::min(run * values_per_mini_block, remaining);
+      const int w = widths[m];
+      if (w == 0) {
+        if constexpr (DbpDoesBlockSum(kAblate)) {
+          // Leave a residual of zero for the block-wide pass below.
+          std::fill(out + i, out + i + count, T{0});
+        } else {
+          for (uint32_t k = 0; k < count; ++k) {
+            out[i + k] = static_cast<T>(last + static_cast<UT>(k + 1) * md);
+          }
+          last += static_cast<UT>(count) * md;
+        }
+      } else {
+        ARROW_CHECK_EQ(reader.GetBatch(w, out + i, static_cast<int>(count)),
+                       static_cast<int>(count));
+        if constexpr (!DbpDoesBlockSum(kAblate)) {
+          for (uint32_t k = 0; k < count; ++k) {
+            last += md + static_cast<UT>(out[i + k]);
+            out[i + k] = static_cast<T>(last);
+          }
+        }
+      }
+      i += static_cast<int>(count);
+      remaining -= count;
+      block_values += count;
+      m += run;
+    }
+
+    if constexpr (DbpDoesBlockSum(kAblate)) {
+      // One serial pass over the whole block, once every miniblock in it has
+      // been unpacked. With a direct biased unpack min_delta is already folded
+      // into each residual, so the chain is a bare running sum.
+      for (uint32_t k = 0; k < block_values; ++k) {
+        last += md + static_cast<UT>(out[block_start + k]);
+        out[block_start + k] = static_cast<T>(last);
+      }
+    }
+  }
+  return i;
+}
+
+// The most optimized reader this format admits, as a lower bound on what is
+// available without a spec change. Three things beyond the shipping decoder:
+// coalescing equal-width miniblocks into one unpack call, one prefix-sum pass
+// per block instead of per miniblock, and calling unpack_bias directly with
+// min_delta as the bias, which both skips BitReader::GetBatch's per-call
+// bookkeeping and removes one add per value from the sum loop.
+//
+// A byte cursor is enough because every position this walks is byte-aligned:
+// the stream header and block headers are byte-aligned varints and width bytes,
+// and a miniblock of v values at width w occupies exactly v*w/8 bytes with v a
+// multiple of 32, so v*w is always a multiple of 8.
+template <typename T>
+int DbpDirectDecode(const uint8_t* data, int len, T* out) {
+  using UT = std::make_unsigned_t<T>;
+  int pos = 0;
+  auto get_vlq = [&](uint32_t* v) {
+    uint32_t r = 0;
+    int shift = 0;
+    while (true) {
+      ARROW_CHECK_LT(pos, len);
+      const uint8_t b = data[pos++];
+      r |= static_cast<uint32_t>(b & 0x7F) << shift;
+      if ((b & 0x80) == 0) break;
+      shift += 7;
+      ARROW_CHECK_LE(shift, 28);
+    }
+    *v = r;
+  };
+  auto get_zigzag = [&](T* v) {
+    uint32_t u = 0;
+    get_vlq(&u);
+    *v = static_cast<T>((u >> 1) ^ (~(u & 1) + 1));
+  };
+
+  uint32_t values_per_block = 0, mini_blocks_per_block = 0, total_count = 0;
+  T first_value = 0;
+  get_vlq(&values_per_block);
+  get_vlq(&mini_blocks_per_block);
+  get_vlq(&total_count);
+  get_zigzag(&first_value);
+  const uint32_t values_per_mini_block = values_per_block / mini_blocks_per_block;
+
+  int i = 0;
+  out[i++] = first_value;
+  UT last = static_cast<UT>(first_value);
+  uint32_t remaining = total_count - 1;
+
+  while (remaining > 0) {
+    T min_delta = 0;
+    get_zigzag(&min_delta);
+    const uint8_t* widths = data + pos;
+    pos += static_cast<int>(mini_blocks_per_block);
+    ARROW_CHECK_LE(pos, len);
+    const UT md = static_cast<UT>(min_delta);
+    const int block_start = i;
+    uint32_t block_values = 0;
+
+    for (uint32_t m = 0; m < mini_blocks_per_block && remaining > 0;) {
+      uint32_t run = 1;
+      while (m + run < mini_blocks_per_block && widths[m + run] == widths[m] &&
+             remaining > run * values_per_mini_block) {
+        ++run;
+      }
+      const uint32_t count = std::min(run * values_per_mini_block, remaining);
+      const int w = widths[m];
+      if (w == 0) {
+        // No payload; the residual is min_delta itself, which the biased
+        // unpack would otherwise have supplied.
+        std::fill(out + i, out + i + count, static_cast<T>(md));
+      } else {
+        const ::arrow::internal::UnpackOptions opts{
+            .batch_size = static_cast<int>(count),
+            .bit_width = w,
+            .bit_offset = 0,
+            .max_read_bytes = len - pos,
+        };
+        ::arrow::internal::unpack_bias(data + pos, reinterpret_cast<UT*>(out + i),
+                                       opts, md);
+        pos += static_cast<int>((static_cast<int64_t>(w) * count) / 8);
+        ARROW_CHECK_LE(pos, len);
+      }
+      i += static_cast<int>(count);
+      remaining -= count;
+      block_values += count;
+      m += run;
+    }
+    // min_delta is already folded into every residual, so this is a bare
+    // running sum: one dependent add per value and nothing else.
+    for (uint32_t k = 0; k < block_values; ++k) {
+      last += static_cast<UT>(out[block_start + k]);
+      out[block_start + k] = static_cast<T>(last);
+    }
+  }
+  return i;
+}
+
+// Mean values per unpack call a coalescing reader achieves on this stream.
+// Without coalescing it is always values_per_mini_block, so the ratio of the two
+// is the granularity gain available on this column, and it bounds what the
+// kCoalesce arm can show.
+template <typename T>
+double DbpMeanValuesPerUnpackCall(const uint8_t* data, int len) {
+  ::arrow::bit_util::BitReader reader(data, len);
+  uint32_t values_per_block = 0, mini_blocks_per_block = 0, total_count = 0;
+  T first_value = 0;
+  ARROW_CHECK(reader.GetVlqInt(&values_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&mini_blocks_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&total_count));
+  ARROW_CHECK(reader.GetZigZagVlqInt(&first_value));
+  const uint32_t values_per_mini_block = values_per_block / mini_blocks_per_block;
+
+  uint32_t remaining = total_count - 1;
+  int64_t calls = 0, values_unpacked = 0;
+  std::vector<uint8_t> widths(mini_blocks_per_block);
+  while (remaining > 0) {
+    T min_delta = 0;
+    ARROW_CHECK(reader.GetZigZagVlqInt(&min_delta));
+    for (uint32_t m = 0; m < mini_blocks_per_block; ++m) {
+      ARROW_CHECK(reader.GetAligned<uint8_t>(1, widths.data() + m));
+    }
+    for (uint32_t m = 0; m < mini_blocks_per_block && remaining > 0;) {
+      uint32_t run = 1;
+      while (m + run < mini_blocks_per_block && widths[m + run] == widths[m] &&
+             remaining > run * values_per_mini_block) {
+        ++run;
+      }
+      const uint32_t count = std::min(run * values_per_mini_block, remaining);
+      if (widths[m] != 0) {
+        ++calls;
+        values_unpacked += count;
+        ARROW_CHECK(reader.Advance(static_cast<int64_t>(widths[m]) * count));
+      }
+      remaining -= count;
+      m += run;
+    }
+  }
+  return calls == 0 ? 0.0 : static_cast<double>(values_unpacked) / static_cast<double>(calls);
+}
+
+template <typename T, DbpAblate kAblate, bool kHeapReader = false>
+static void DbpAblateImpl(benchmark::State& state, GenT<T> gen, uint32_t values_per_block,
+                          uint32_t mini_blocks_per_block) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+  auto buf = WriteDbpStream<T>(values, values_per_block, mini_blocks_per_block);
+
+  std::vector<T> decoded(num_values);
+  // Correctness gate: the unablated path must round-trip this stream exactly.
+  {
+    std::vector<T> check(num_values);
+    const int n = DbpAblatedDecode<T, DbpAblate::kFull>(
+        buf->data(), static_cast<int>(buf->size()), check.data());
+    ARROW_CHECK_EQ(n, static_cast<int>(num_values));
+    ARROW_CHECK(check == values) << "hand-built DBP stream does not round-trip";
+    // A reader-side variant must produce an identical result, or its speed
+    // means nothing.
+    if constexpr (DbpIsReaderSide(kAblate)) {
+      std::vector<T> rs(num_values);
+      const int m = kAblate == DbpAblate::kDirect
+                        ? DbpDirectDecode<T>(buf->data(), static_cast<int>(buf->size()),
+                                             rs.data())
+                        : DbpReaderSideDecode<T, kAblate>(
+                              buf->data(), static_cast<int>(buf->size()), rs.data());
+      ARROW_CHECK_EQ(m, static_cast<int>(num_values));
+      ARROW_CHECK(rs == values) << "reader-side DBP variant disagrees";
+    }
+  }
+
+  for (auto _ : state) {
+    if constexpr (kAblate == DbpAblate::kDirect) {
+      DbpDirectDecode<T>(buf->data(), static_cast<int>(buf->size()), decoded.data());
+    } else if constexpr (DbpIsReaderSide(kAblate)) {
+      DbpReaderSideDecode<T, kAblate>(buf->data(), static_cast<int>(buf->size()),
+                                      decoded.data());
+    } else {
+      DbpAblatedDecode<T, kAblate, kHeapReader>(
+          buf->data(), static_cast<int>(buf->size()), decoded.data());
+    }
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(buf->size());
+  if constexpr (DbpDoesCoalesce(kAblate)) {
+    state.counters["values_per_unpack_call"] =
+        DbpMeanValuesPerUnpackCall<T>(buf->data(), static_cast<int>(buf->size()));
+    state.counters["values_per_unpack_call_plain"] =
+        static_cast<double>(values_per_block / mini_blocks_per_block);
+  }
+}
+
+// Ablation arms, all at Arrow's default int32 geometry (128 values per block,
+// 4 miniblocks, so 32 values per unpack call).
+static void BM_DbpAbFull(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 128, 4);
+}
+static void BM_DbpAbNoSum(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kNoSum>(state, gen, 128, 4);
+}
+static void BM_DbpAbNoUnpack(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kNoUnpack>(state, gen, 128, 4);
+}
+static void BM_DbpAbHeaderOnly(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kHeaderOnly>(state, gen, 128, 4);
+}
+
+// Same work as BM_DbpAbFull with the bit reader placed on the heap, isolating
+// how much of the shadow-versus-shipping gap that placement accounts for.
+static void BM_DbpAbFullHeapReader(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull, /*kHeapReader=*/true>(state, gen, 128, 4);
+}
+
+// Reader-side arms, at Arrow's default 128/4 geometry so they are directly
+// comparable with BM_DbpAbFull.
+static void BM_DbpRsCoalesce(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kCoalesce>(state, gen, 128, 4);
+}
+static void BM_DbpRsBlockSum(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kBlockSum>(state, gen, 128, 4);
+}
+static void BM_DbpRsBoth(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kBoth>(state, gen, 128, 4);
+}
+static void BM_DbpRsDirect(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kDirect>(state, gen, 128, 4);
+}
+
+// Geometry sweep, full decode each time. 128/4 is Arrow's default and the
+// control; the rest vary how many values one unpack call covers and how often a
+// block header is parsed.
+static void BM_DbpGeom128x4(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 128, 4);
+}
+static void BM_DbpGeom128x1(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 128, 1);
+}
+static void BM_DbpGeom1024x32(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 1024, 32);
+}
+static void BM_DbpGeom1024x8(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 1024, 8);
+}
+static void BM_DbpGeom1024x1(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 1024, 1);
+}
+
+// ============================================================================
+// Lane-parallel delta: the +32 stride against the paper's lane assignment
+// ============================================================================
+//
+// Both replace DELTA_BINARY_PACKED's 1024-long dependency chain with 32
+// independent chains of 32. They differ only in which value a lane's chain
+// steps back to, and that is what decides the compression ratio:
+//
+//   LaneDelta   lane l holds l, 32+l, ..., 992+l -- the in-lane predecessor is
+//               32 positions back, so the differences are wider than the
+//               format's. Container order is file order, so no permutation.
+//   Tpose       lane l holds the contiguous run [32l, 32l+32) -- the in-lane
+//               predecessor is the immediately preceding value, so the
+//               differences are exactly the format's. Decode ends transposed.
+//
+// Tpose comes in two base codings (32 entry points per block stored raw, or
+// delta-coded across lanes) and, for the decode side, with and without the
+// transpose back to file order. Only the repairing arm is a conforming decoder;
+// the other one isolates what the transpose costs.
+
+using ::arrow::util::fastlanes::TransposedBaseCoding;
+using ::arrow::util::fastlanes::TransposedRepair;
+
+static void BM_LaneDeltaDecode(benchmark::State& state, Gen32 gen) {
+  namespace fl = ::arrow::util::fastlanes;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(int32_t);
+
+  std::vector<uint8_t> buf(fl::LaneDeltaMaxEncodedSize(num_values));
+  const size_t comp_size = fl::LaneDeltaEncode<fl::LaneDeltaOrder::kInterleaved>(
+      values.data(), num_values, buf.data());
+  ARROW_CHECK_GT(comp_size, 0);
+
+  int32_t* decoded = SharedDecodeBuffer<int32_t>(num_values);
+  fl::LaneDeltaDecode<fl::LaneDeltaOrder::kInterleaved>(buf.data(), num_values,
+                                                        decoded);
+  ARROW_CHECK(std::equal(decoded, decoded + num_values, values.begin())) << "lane delta round trip failed";
+
+  for (auto _ : state) {
+    fl::LaneDeltaDecode<fl::LaneDeltaOrder::kInterleaved>(buf.data(), num_values,
+                                                          decoded);
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+// ============================================================================
+// Lane-parallel delta through the decoder interface
+// ============================================================================
+//
+// BM_TposeFusedDecode below measures the kernel: it is handed a payload and told
+// how many values it holds. These two arms go through the encoder and decoder
+// the library registers for the encoding, which is the same layout, base coding
+// and repair that arm uses, so they pay for page framing, for SetData, and for
+// reading the value count out of the page. That makes them comparable with
+// BM_DeltaBitPackEncode / BM_DeltaBitPackDecode, which is the pair libparquet
+// ships, and it is the comparison a margin should be quoted over -- decoder
+// against decoder rather than kernel against decoder. Dividing one by the other
+// prices the framing.
+
+static void BM_TposeApiDecode(benchmark::State& state, Gen32 gen) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(int32_t);
+
+  auto encoder = MakeTypedEncoder<Int32Type>(Encoding::LANE_DELTA);
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto buf = encoder->FlushValues();
+  const int64_t comp_size = buf->size();
+
+  int32_t* decoded = SharedDecodeBuffer<int32_t>(num_values);
+  auto decoder = MakeTypedDecoder<Int32Type>(Encoding::LANE_DELTA);
+  decoder->SetData(static_cast<int>(num_values), buf->data(),
+                   static_cast<int>(buf->size()));
+  ARROW_CHECK_EQ(decoder->Decode(decoded, static_cast<int>(num_values)),
+                 static_cast<int>(num_values));
+  ARROW_CHECK(std::equal(decoded, decoded + num_values, values.begin())) << "lane delta decoder round trip failed";
+
+  for (auto _ : state) {
+    decoder->SetData(static_cast<int>(num_values), buf->data(),
+                     static_cast<int>(buf->size()));
+    decoder->Decode(decoded, static_cast<int>(num_values));
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+static void BM_TposeApiEncode(benchmark::State& state, Gen32 gen) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(int32_t);
+
+  int64_t comp_size = 0;
+  auto encoder = MakeTypedEncoder<Int32Type>(Encoding::LANE_DELTA);
+  for (auto _ : state) {
+    encoder->Put(values.data(), static_cast<int>(num_values));
+    auto buf = encoder->FlushValues();
+    comp_size = buf->size();
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+// The values a decoder that stops in transposed order should produce.
+static std::vector<int32_t> TransposeReference(const std::vector<int32_t>& in) {
+  namespace fl = ::arrow::util::fastlanes;
+  std::vector<int32_t> out(in.size());
+  const size_t nblocks = in.size() / fl::kBlockSize;
+  for (size_t b = 0; b < nblocks; ++b) {
+    for (size_t t = 0; t < fl::kBlockSize; ++t) {
+      out[b * fl::kBlockSize + t] = in[b * fl::kBlockSize + fl::TransposedSource(t)];
+    }
+  }
+  return out;
+}
+
+template <TransposedBaseCoding kBases, TransposedRepair kRepair>
+static void TposeDecodeImpl(benchmark::State& state, Gen32 gen) {
+  namespace fl = ::arrow::util::fastlanes;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(int32_t);
+
+  std::vector<uint8_t> buf(fl::TransposedMaxEncodedSize(num_values));
+  const size_t comp_size =
+      fl::TransposedDeltaEncode<kBases>(values.data(), num_values, buf.data());
+  ARROW_CHECK_GT(comp_size, 0);
+
+  int32_t* decoded = SharedDecodeBuffer<int32_t>(num_values);
+  fl::TransposedDeltaDecode<kBases, kRepair>(buf.data(), num_values, decoded);
+  if constexpr (kRepair != TransposedRepair::kNone) {
+    ARROW_CHECK(std::equal(decoded, decoded + num_values, values.begin())) << "transposed delta round trip failed";
+  } else {
+    ARROW_CHECK(std::equal(decoded, decoded + num_values,
+                            TransposeReference(values).begin()))
+        << "transposed delta round trip failed in transposed order";
+  }
+
+  for (auto _ : state) {
+    fl::TransposedDeltaDecode<kBases, kRepair>(buf.data(), num_values, decoded);
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+static void BM_TposeRawDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kRaw, TransposedRepair::kSeparate>(state, gen);
+}
+static void BM_TposePackedDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kPacked, TransposedRepair::kSeparate>(state, gen);
+}
+// The conforming decoder: adjacent deltas, file order out, one pass over the block.
+static void BM_TposeFusedDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kPacked, TransposedRepair::kFused>(state, gen);
+}
+// Also conforming, and the one the wrapper ships: the bit-unpack is folded in
+// too, so the 4 KB scratch block kFused still round-trips never exists.
+static void BM_TposeFusedUnpackDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kPacked, TransposedRepair::kFusedUnpack>(state,
+                                                                                gen);
+}
+// Neither of these is a conforming decoder: they leave the block transposed.
+// Raw-vs-Packed at fixed repair isolates the base stream, and NoRepair-vs-not at
+// fixed base coding isolates the 32x32 transpose.
+static void BM_TposeNoRepairDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kPacked, TransposedRepair::kNone>(state, gen);
+}
+static void BM_TposeRawNoRepairDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kRaw, TransposedRepair::kNone>(state, gen);
+}
+
+// ============================================================================
+// Interleaved-layout PFOR (no delta chain to break)
+// ============================================================================
+//
+// BM_PforDecode is Arrow's shipped sequential decoder -- the layout the
+// format specifies today. These two swap only the bit-unpack kernel for the
+// FastLanes container, keeping the same per-block frame-of-reference and the
+// same real dataset columns, so the margin against BM_PforDecode isolates
+// the layout question on data instead of on synthetic per-width residuals.
+// The second arm adds the paper's lane assignment and the gather needed to
+// undo it, which fastlanes_kernels_internal.h's header comment argues plain
+// PFOR has nothing to buy with -- this prices that argument on real columns.
+
+using ::arrow::util::fastlanes::InterleavedPforOrder;
+
+template <InterleavedPforOrder kOrder>
+static void InterleavedPforDecodeImpl(benchmark::State& state, Gen32 gen) {
+  namespace fl = ::arrow::util::fastlanes;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(int32_t);
+
+  std::vector<uint8_t> buf(fl::InterleavedPforMaxEncodedSize(num_values));
+  const size_t comp_size =
+      fl::InterleavedPforEncode<kOrder>(values.data(), num_values, buf.data());
+  ARROW_CHECK_GT(comp_size, 0);
+
+  // kFlOrderRaw deliberately returns the FastLanes order, so its expectation is
+  // the permuted input rather than the input. Checking it against the same
+  // permutation the encoder applied is what keeps this arm honest: without it,
+  // an arm that skipped work entirely would also "pass".
+  std::vector<int32_t> expect = values;
+  if constexpr (kOrder == InterleavedPforOrder::kFlOrderRaw) {
+    const int64_t nblocks = num_values / 1024;
+    for (int64_t b = 0; b < nblocks; ++b) {
+      const int32_t* src = values.data() + b * 1024;
+      int32_t* dst = expect.data() + b * 1024;
+      for (int64_t lane = 0; lane < 32; ++lane) {
+        for (int64_t row = 0; row < 32; ++row) {
+          dst[row * 32 + lane] = src[lane * 32 + row];
+        }
+      }
+    }
+  }
+
+  int32_t* decoded = SharedDecodeBuffer<int32_t>(num_values);
+  fl::InterleavedPforDecode<kOrder>(buf.data(), num_values, decoded);
+  ARROW_CHECK(std::equal(decoded, decoded + num_values, expect.begin()))
+      << "interleaved pfor round trip failed";
+
+  for (auto _ : state) {
+    fl::InterleavedPforDecode<kOrder>(buf.data(), num_values, decoded);
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+// The three arms below answer the value-ordering question and only that one.
+// They run arrow/util/fastlanes/interleaved_pfor.h, which has no exception
+// handling: no patch list on the wire, no patch pass in the decoder. Dividing
+// one of them by a production arm therefore charges the production side for work
+// these never do, and the quotient is not the layout. The layout question has
+// its own pair above -- BM_PforPlainSeqDecode and BM_PforPlainInterleavedDecode,
+// same production encoder and decoder, differing only in PackingMode.
+// BM_InterleavedPforDecode is the file-order control the other two are read
+// against; it is not a second interleaved-layout arm.
+static void BM_InterleavedPforDecode(benchmark::State& state, Gen32 gen) {
+  InterleavedPforDecodeImpl<InterleavedPforOrder::kFileOrder>(state, gen);
+}
+// Same wire bytes as BM_InterleavedPforFlOrderDecode, but the FastLanes order is
+// handed to the caller unchanged. It runs the identical PackBlock/UnpackBlock
+// pair as BM_InterleavedPforDecode against a grid that was merely filled
+// differently at encode time, so it must measure equal to it -- the arm exists
+// to separate "FL_ORDER's bit-packing is cheaper" (it is not, it is identical)
+// from "FL_ORDER's permutation costs something" (it does).
+static void BM_InterleavedPforFlOrderRawDecode(benchmark::State& state, Gen32 gen) {
+  InterleavedPforDecodeImpl<InterleavedPforOrder::kFlOrderRaw>(state, gen);
+}
+static void BM_InterleavedPforFlOrderDecode(benchmark::State& state, Gen32 gen) {
+  InterleavedPforDecodeImpl<InterleavedPforOrder::kFlOrder>(state, gen);
+}
+
+static void BM_LaneDeltaEncode(benchmark::State& state, Gen32 gen) {
+  namespace fl = ::arrow::util::fastlanes;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  std::vector<uint8_t> buf(fl::LaneDeltaMaxEncodedSize(num_values));
+  size_t comp_size = 0;
+  for (auto _ : state) {
+    comp_size = fl::LaneDeltaEncode<fl::LaneDeltaOrder::kInterleaved>(
+        values.data(), num_values, buf.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * num_values * sizeof(int32_t));
+  state.SetItemsProcessed(state.iterations() * num_values);
+  const double raw = static_cast<double>(num_values * sizeof(int32_t));
+  state.counters["compression_ratio"] = raw / static_cast<double>(comp_size);
+}
+
+static void BM_TposePackedEncode(benchmark::State& state, Gen32 gen) {
+  namespace fl = ::arrow::util::fastlanes;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  std::vector<uint8_t> buf(fl::TransposedMaxEncodedSize(num_values));
+  size_t comp_size = 0;
+  for (auto _ : state) {
+    comp_size = fl::TransposedDeltaEncode<TransposedBaseCoding::kPacked>(
+        values.data(), num_values, buf.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * num_values * sizeof(int32_t));
+  state.SetItemsProcessed(state.iterations() * num_values);
+  const double raw = static_cast<double>(num_values * sizeof(int32_t));
+  state.counters["compression_ratio"] = raw / static_cast<double>(comp_size);
+}
+
+// ============================================================================
+// Benchmark Registration
+// ============================================================================
+
+static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
+
+// The four layout-comparison arms sweep the working set; everything else stays
+// at the single 102400 point so the suite does not get five times longer for no
+// gain. The four that sweep are the ones a layout verdict is read from:
+//
+//   BM_PforPlainSeqDecode              continuous layout, delta declined
+//                                        -- THE BASELINE
+//   BM_InterleavedPforDecode           interleaved grid, file order out
+//                                        -- CONTROL, not shippable
+//   BM_InterleavedPforFlOrderRawDecode FL_ORDER grid, permutation not charged
+//                                        -- CONTROL, not shippable
+//   BM_InterleavedPforFlOrderDecode    FL_ORDER grid -> file order, fused
+//                                        -- THE CANDIDATE
+//
+// All four must sweep together or the comparison is unreadable. Measured at one
+// working-set size the two controls and the candidate cannot be separated: the
+// grid's advantage is a compute effect that only exists while the working set is
+// small enough that stores are not the limit, so a single mid-size point shows a
+// grid that looks barely better than continuous and hides both the size of the
+// win and the size of the permutation tax that cancels it.
+//
+// The ladder is sized against a real cache hierarchy and against what a decoder
+// actually holds. Unpacking expands packed bytes by 32/W, so a ~300 KB integer
+// column chunk decodes to 300 KB at W=32 and 2.4 MB at W=4: the realistic span
+// is ~300 KB to ~2.4 MB, which 102400 alone (400 KiB) sits at the bottom of. On
+// a machine with 2 MiB of L2 per core and 480 MiB of shared L3 the decay in the
+// layout advantage begins inside L2, well before any memory boundary, so points
+// either side of the L2 capacity are the ones that carry information.
+static void LayoutArgs(benchmark::internal::Benchmark* b) {
+  b->Arg(4096)        //  16 KiB out -- L1-resident
+      ->Arg(102400)   // 400 KiB out -- the historical point; low end of realistic
+      ->Arg(393216)   // 1.5 MiB out -- still inside a 2 MiB L2; top of realistic
+      ->Arg(1048576)  //   4 MiB out -- spilled L2
+      ->Arg(8388608); //  32 MiB out -- L3-resident on a 480 MiB L3, NOT DRAM
+}
+
+// Macro to register all algorithms for a given dataset
+#define REGISTER_DATASET(Name, GenFunc)                                            \
+  BENCHMARK_CAPTURE(BM_PforEncode, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_PforDecode, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_PforPlainSeqDecode, Name, &GenFunc)->Apply(LayoutArgs);     \
+  BENCHMARK_CAPTURE(BM_PforPlainInterleavedDecode, Name, &GenFunc)                 \
+      ->Apply(LayoutArgs);                                                         \
+  BENCHMARK_CAPTURE(BM_DeltaBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_DeltaBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_DbpAbFull, Name, &GenFunc)->Apply(CustomArgs);              \
+  BENCHMARK_CAPTURE(BM_DbpAbNoSum, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_DbpAbNoUnpack, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_DbpAbHeaderOnly, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_DbpAbFullHeapReader, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_DbpRsCoalesce, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_DbpRsBlockSum, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_DbpRsBoth, Name, &GenFunc)->Apply(CustomArgs);              \
+  BENCHMARK_CAPTURE(BM_DbpRsDirect, Name, &GenFunc)->Apply(CustomArgs);            \
+  BENCHMARK_CAPTURE(BM_DbpGeom128x1, Name, &GenFunc)->Apply(CustomArgs);           \
+  BENCHMARK_CAPTURE(BM_DbpGeom1024x32, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_DbpGeom1024x8, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_DbpGeom1024x1, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_InterleavedPforDecode, Name, &GenFunc)->Apply(LayoutArgs);  \
+  BENCHMARK_CAPTURE(BM_InterleavedPforFlOrderRawDecode, Name, &GenFunc)            \
+      ->Apply(LayoutArgs);                                                         \
+  BENCHMARK_CAPTURE(BM_InterleavedPforFlOrderDecode, Name, &GenFunc)               \
+      ->Apply(LayoutArgs);                                                         \
+  BENCHMARK_CAPTURE(BM_LaneDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_TposeApiDecode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_TposeApiEncode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_TposeRawDecode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_TposePackedDecode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_TposeFusedDecode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_TposeFusedUnpackDecode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_TposeNoRepairDecode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_TposeRawNoRepairDecode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_LaneDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_TposePackedEncode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_PlainZstdEncode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_PlainZstdDecode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_PlainLz4Encode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_PlainLz4Decode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_RleBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_RleBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_BssZstdEncode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_BssZstdDecode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_BssLz4Encode, Name, &GenFunc)->Apply(CustomArgs);           \
+  BENCHMARK_CAPTURE(BM_BssLz4Decode, Name, &GenFunc)->Apply(CustomArgs);
+
+// Same as REGISTER_DATASET but for int64 (BIGINT) columns; benchmark names get
+// the "64" codec suffix (e.g. BM_Pfor64Encode) to distinguish them.
+#define REGISTER_DATASET64(Name, GenFunc)                                        \
+  BENCHMARK_CAPTURE(BM_Pfor64Encode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_Pfor64Decode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_DeltaBitPack64Encode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_DeltaBitPack64Decode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PlainZstd64Encode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_PlainZstd64Decode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_PlainLz464Encode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PlainLz464Decode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_RleBitPack64Encode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_RleBitPack64Decode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_BssZstd64Encode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_BssZstd64Decode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_BssLz464Encode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_BssLz464Decode, Name, &GenFunc)->Apply(CustomArgs);
+
+// ClickBench datasets
+REGISTER_DATASET(ClientIP, GenClientIP)
+REGISTER_DATASET(UrlRegionID, GenUrlRegionID)
+REGISTER_DATASET(CounterID, GenCounterID)
+REGISTER_DATASET(EventDate, GenEventDate)
+REGISTER_DATASET(EventTime, GenEventTime)
+REGISTER_DATASET(GoodEvent, GenGoodEvent)
+REGISTER_DATASET(HID, GenHID)
+REGISTER_DATASET(HitColor, GenHitColor)
+REGISTER_DATASET(IPNetworkID, GenIPNetworkID)
+REGISTER_DATASET(JavaEnable, GenJavaEnable)
+REGISTER_DATASET(OS, GenOS)
+REGISTER_DATASET(Resolution, GenResolution)
+REGISTER_DATASET(TrafficSourceID, GenTrafficSourceID)
+REGISTER_DATASET(UserAgent, GenUserAgent)
+
+// TPC-DS datasets
+REGISTER_DATASET(TpcdsSoldDateSk, GenTpcdsSoldDateSk)
+REGISTER_DATASET(TpcdsStoreSk, GenTpcdsStoreSk)
+REGISTER_DATASET(TpcdsItemSk, GenTpcdsItemSk)
+REGISTER_DATASET(TpcdsQuantity, GenTpcdsQuantity)
+REGISTER_DATASET(TpcdsCustomerSk, GenTpcdsCustomerSk)
+REGISTER_DATASET(TpcdsExtSalesPrice, GenTpcdsExtSalesPrice)
+REGISTER_DATASET(TpcdsNetProfit, GenTpcdsNetProfit)
+REGISTER_DATASET(TpcdsDYear, GenTpcdsDYear)
+// TPC-H datasets
+REGISTER_DATASET(TpchLQuantity, GenTpchLQuantity)
+REGISTER_DATASET(TpchLExtendedPrice, GenTpchLExtendedPrice)
+REGISTER_DATASET(TpchLDiscount, GenTpchLDiscount)
+REGISTER_DATASET(TpchLShipDate, GenTpchLShipDate)
+// NYC taxi datasets
+REGISTER_DATASET(TaxiPickupUnixTime, GenTaxiPickupUnixTime)
+REGISTER_DATASET(TaxiTripDistanceX100, GenTaxiTripDistanceX100)
+REGISTER_DATASET(TaxiFareCents, GenTaxiFareCents)
+
+// Correlated columns. DELTA_BINARY_PACKED is only used on data of this shape,
+// so any claim about its decode cost has to be measured here and not only on
+// the independently-drawn columns above.
+REGISTER_DATASET(SortedUnixTime, GenSortedUnixTime)
+REGISTER_DATASET(SortedKeyDups, GenSortedKeyDups)
+REGISTER_DATASET(MonotoneRowId, GenMonotoneRowId)
+REGISTER_DATASET(NearSortedUnixTime, GenNearSortedUnixTime)
+// int64 / BIGINT datasets (8-byte signed values)
+REGISTER_DATASET64(TsNanos, GenTsNanos)
+REGISTER_DATASET64(OrderKey, GenOrderKey)
+REGISTER_DATASET64(PriceMicros, GenPriceMicros)
+REGISTER_DATASET64(SnowflakeId, GenSnowflakeId)
+REGISTER_DATASET64(ByteCount, GenByteCount)
+
+// Columns with structure between neighbouring values (see delta_shapes above),
+// registered at both widths from the same distribution.
+#define REGISTER_DELTA_SHAPE(Name, GenFunc) \
+  REGISTER_DATASET(Name, GenFunc<int32_t>)  \
+  REGISTER_DATASET64(Name, GenFunc<int64_t>)
+
+REGISTER_DELTA_SHAPE(TrendJitter, delta_shapes::GenTrendJitter)
+REGISTER_DELTA_SHAPE(Sawtooth, delta_shapes::GenSawtooth)
+REGISTER_DELTA_SHAPE(MeasurementSeries, delta_shapes::GenMeasurement)
+REGISTER_DELTA_SHAPE(SortedKeys, delta_shapes::GenSortedKeys)
+REGISTER_DELTA_SHAPE(SensorDropouts, delta_shapes::GenSensorDropouts)
+REGISTER_DELTA_SHAPE(IdsWithGaps, delta_shapes::GenIdsWithGaps)
+REGISTER_DELTA_SHAPE(RandomWalk, delta_shapes::GenRandomWalk)
+REGISTER_DELTA_SHAPE(EventMillis, delta_shapes::GenEventMillis)
+REGISTER_DELTA_SHAPE(LowSentinel, delta_shapes::GenLowSentinel)
+REGISTER_DELTA_SHAPE(Bimodal, delta_shapes::GenBimodal)
+
+}  // namespace
+}  // namespace parquet
diff --git a/cpp/src/parquet/pfor_layout_tables.py b/cpp/src/parquet/pfor_layout_tables.py
new file mode 100644
index 000000000000..23e1cd879ef3
--- /dev/null
+++ b/cpp/src/parquet/pfor_layout_tables.py
@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""Turn a register-width sweep tarball into the four-arm layout tables.
+
+Reads the combined_results.json produced by x86_register_width_sweep.sh and
+prints, per build register width, the comparison the layout decision actually
+rests on: one baseline and three grid arms, across every working-set size and
+every column, plus the geomean over columns.
+
+    python3 pfor_layout_tables.py combined_results.json [--stat median]
+
+The four arms, and why all four are needed:
+
+    seq       BM_PforPlainSeqDecode               continuous layout, delta
+                                                  declined.  THE BASELINE.
+    intlv     BM_InterleavedPforDecode            grid filled in file order.
+                                                  CONTROL -- unshippable, it
+                                                  prices the grid's unpacking
+                                                  with no permutation to pay.
+    fl_unpk   BM_InterleavedPforFlOrderRawDecode  grid filled the paper's way,
+                                                  handed back unpermuted.
+                                                  CONTROL -- violates the
+                                                  positional contract.
+    fl_tpos   BM_InterleavedPforFlOrderDecode     same grid, permuted back to
+                                                  file order by the fused
+                                                  in-register transpose.
+                                                  THE CANDIDATE, and the only
+                                                  arm whose ratio is a verdict.
+
+Read the columns in this order.  fl_unpk/seq is what the layout wins.  The tax
+column, fl_unpk/fl_tpos, is what the positional contract charges to collect it.
+fl_tpos/seq is the product of the two and is the only number that decides
+anything.  A flat fl_tpos/seq with a tax near 1.0 means the grid is no cheaper;
+a flat fl_tpos/seq with a large tax means the grid is much cheaper and the
+permutation spends the whole win.  Those are different findings with different
+fixes, and they are indistinguishable without fl_unpk.
+"""
+import argparse
+import collections
+import json
+import math
+import re
+import sys
+
+ARMS = [
+    ("seq", "BM_PforPlainSeqDecode"),
+    ("intlv", "BM_InterleavedPforDecode"),
+    ("fl_unpk", "BM_InterleavedPforFlOrderRawDecode"),
+    ("fl_tpos", "BM_InterleavedPforFlOrderDecode"),
+]
+ARM_FOR = {bench: arm for arm, bench in ARMS}
+
+# Decoded output bytes = 4 * num_values.  Labels are what the ladder was chosen
+# against, not what any particular machine has; a run on a different cache
+# hierarchy should be read against its own lscpu.
+FOOTPRINT = {
+    4096: "16 KiB",
+    102400: "400 KiB",
+    393216: "1.5 MiB",
+    1048576: "4 MiB",
+    8388608: "32 MiB",
+}
+
+NAME_RE = re.compile(r"^(BM_[A-Za-z0-9]+)/([^/]+)/(\d+)(?:_(\w+))?$")
+
+
+def geomean(xs):
+    xs = [x for x in xs if x > 0]
+    return math.exp(sum(math.log(x) for x in xs) / len(xs)) if xs else float("nan")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("json_path")
+    ap.add_argument(
+        "--stat",
+        default="median",
+        help="aggregate to read: median (default) or mean. median is less "
+        "sensitive to a single thermally-throttled repetition.",
+    )
+    args = ap.parse_args()
+
+    with open(args.json_path) as f:
+        data = json.load(f)
+
+    # (level, arm, dataset, nvalues) -> GiB/s ; and the CV alongside, because a
+    # ratio built out of two noisy cells is not evidence.
+    gbps = {}
+    cv = {}
+    for b in data.get("benchmarks", []):
+        m = NAME_RE.match(b.get("run_name") or b.get("name", ""))
+        if not m:
+            continue
+        bench, dataset, n, _ = m.groups()
+        arm = ARM_FOR.get(bench)
+        if arm is None:
+            continue
+        level = b.get("build_simd_level", b.get("simd_level", "?"))
+        key = (level, arm, dataset, int(n))
+        agg = b.get("aggregate_name")
+        if agg == args.stat:
+            bps = b.get("bytes_per_second")
+            if bps:
+                gbps[key] = bps / (1 << 30)
+        elif agg == "cv":
+            cv[key] = b.get("bytes_per_second", 0.0)
+
+    if not gbps:
+        sys.exit(
+            "no layout-arm records found. If this tarball predates the "
+            "footprint ladder it has only the 102400 point, and the arm\n"
+            "BM_InterleavedPforFlOrderRawDecode will be missing entirely -- "
+            "that run cannot produce these tables."
+        )
+
+    # A missing arm is the single most likely thing to be wrong with a returned
+    # tarball, and it is silent: every ratio involving it just prints nan. Say
+    # so once, loudly, at the top.
+    present = {k[1] for k in gbps}
+    missing = [arm for arm, _ in ARMS if arm not in present]
+    if missing:
+        bench_for = dict(ARMS)
+        print("!" * 104)
+        print("INCOMPLETE RUN -- missing arm(s): " + ", ".join(missing))
+        for arm in missing:
+            print(f"    {arm:<9} ({bench_for[arm]})")
+        print()
+        print("  Every ratio involving a missing arm below is nan. If fl_unpk is")
+        print("  the missing one, this tarball predates the control arm and cannot")
+        print("  separate 'the grid is no cheaper' from 'the grid is much cheaper")
+        print("  and the permutation spends the win' -- rebuild and re-run.")
+        print("!" * 104)
+        print()
+
+    sizes_seen = {k[3] for k in gbps}
+    if len(sizes_seen) == 1:
+        print("!" * 104)
+        print(f"SINGLE WORKING-SET SIZE ONLY ({sorted(sizes_seen)[0]} values). This")
+        print("  tarball predates the footprint ladder. The grid's advantage is a")
+        print("  compute effect that only survives while stores are not the limit,")
+        print("  so one size cannot show it -- rebuild and re-run.")
+        print("!" * 104)
+        print()
+
+    levels = sorted({k[0] for k in gbps})
+    for level in levels:
+        sizes = sorted({k[3] for k in gbps if k[0] == level})
+        datasets = []
+        for k in gbps:
+            if k[0] == level and k[2] not in datasets:
+                datasets.append(k[2])
+        datasets.sort()
+
+        print("=" * 104)
+        print(f"BUILD REGISTER WIDTH: {level}")
+        print("=" * 104)
+        if level == "AVX512":
+            print(
+                "  NOTE: not like-for-like. The sequential arm is capped at "
+                "AVX2 in bpacking.cc, so this\n"
+                "  column widens the grid arms only -- except the candidate, "
+                "pinned at 256 by its own __m256i."
+            )
+        print(
+            "  seq = continuous [BASELINE] | intlv, fl_unpk = CONTROLS, not "
+            "shippable | fl_tpos = CANDIDATE"
+        )
+        print("  tax = fl_unpk/fl_tpos = what the positional contract charges")
+        print()
+
+        def cell(arm, ds, n):
+            return gbps.get((level, arm, ds, n))
+
+        hdr = (
+            f"{'footprint':<10} | {'seq':>8} {'intlv':>8} {'fl_unpk':>8} "
+            f"{'fl_tpos':>8} | {'int/seq':>8} {'unpk/seq':>8} "
+            f"{'tpos/seq':>8} {'tax':>6}"
+        )
+        print("-" * 104)
+        print("PER-FOOTPRINT GEOMEAN OVER {} COLUMNS".format(len(datasets)))
+        print("-" * 104)
+        print(hdr)
+        print("-" * 104)
+        gm = {}
+        for n in sizes:
+            g = {}
+            for arm, _ in ARMS:
+                vals = [cell(arm, ds, n) for ds in datasets]
+                vals = [v for v in vals if v]
+                g[arm] = geomean(vals) if vals else float("nan")
+            gm[n] = g
+            print(
+                f"{FOOTPRINT.get(n, str(n)):<10} | {g['seq']:>8.1f} "
+                f"{g['intlv']:>8.1f} {g['fl_unpk']:>8.1f} {g['fl_tpos']:>8.1f} | "
+                f"{g['intlv'] / g['seq']:>8.3f} {g['fl_unpk'] / g['seq']:>8.3f} "
+                f"{g['fl_tpos'] / g['seq']:>8.3f} "
+                f"{g['fl_unpk'] / g['fl_tpos']:>6.3f}"
+            )
+        print()
+
+        for n in sizes:
+            print("-" * 104)
+            print(f"PER-COLUMN  @  {FOOTPRINT.get(n, str(n))}  ({n} values)")
+            print("-" * 104)
+            print(
+                f"{'column':<24} | {'seq':>8} {'intlv':>8} {'fl_unpk':>8} "
+                f"{'fl_tpos':>8} | {'int/seq':>8} {'unpk/seq':>8} "
+                f"{'tpos/seq':>8} {'tax':>6} {'maxCV':>6}"
+            )
+            print("-" * 104)
+            for ds in datasets:
+                v = {arm: cell(arm, ds, n) for arm, _ in ARMS}
+                if not v["seq"]:
+                    continue
+                # Missing arms print as nan rather than dropping the row: a row
+                # that vanishes looks like a column that was not run.
+                v = {a: (x if x else float("nan")) for a, x in v.items()}
+                worst = max(
+                    (cv.get((level, arm, ds, n), 0.0) for arm, _ in ARMS),
+                    default=0.0,
+                )
+                print(
+                    f"{ds:<24} | {v['seq']:>8.1f} {v['intlv']:>8.1f} "
+                    f"{v['fl_unpk']:>8.1f} {v['fl_tpos']:>8.1f} | "
+                    f"{v['intlv'] / v['seq']:>8.3f} "
+                    f"{v['fl_unpk'] / v['seq']:>8.3f} "
+                    f"{v['fl_tpos'] / v['seq']:>8.3f} "
+                    f"{v['fl_unpk'] / v['fl_tpos']:>6.3f} "
+                    f"{worst * 100:>5.1f}%"
+                )
+            g = gm[n]
+            print("-" * 104)
+            print(
+                f"{'GEOMEAN':<24} | {g['seq']:>8.1f} {g['intlv']:>8.1f} "
+                f"{g['fl_unpk']:>8.1f} {g['fl_tpos']:>8.1f} | "
+                f"{g['intlv'] / g['seq']:>8.3f} {g['fl_unpk'] / g['seq']:>8.3f} "
+                f"{g['fl_tpos'] / g['seq']:>8.3f} "
+                f"{g['fl_unpk'] / g['fl_tpos']:>6.3f}"
+            )
+            print()
+
+        # The controls must agree with each other: same kernel, same wire
+        # bytes, only the grid fill differs. A gap between them is a bug or a
+        # noise floor, and either way it bounds what the other ratios can mean.
+        print("-" * 104)
+        print("CONTROL CHECK: intlv vs fl_unpk must be equal (same kernel, "
+              "same bytes, different fill)")
+        print("-" * 104)
+        for n in sizes:
+            g = gm[n]
+            r = g["fl_unpk"] / g["intlv"]
+            flag = "" if 0.97 <= r <= 1.03 else "   <-- OFF BY >3%, investigate"
+            print(f"  {FOOTPRINT.get(n, str(n)):<10} fl_unpk/intlv = {r:.4f}{flag}")
+        print()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/cpp/src/parquet/properties.cc b/cpp/src/parquet/properties.cc
index 6e3cfddd7bb8..06e7da4acf90 100644
--- a/cpp/src/parquet/properties.cc
+++ b/cpp/src/parquet/properties.cc
@@ -91,6 +91,23 @@ void WriterProperties::Builder::CopyColumnSpecificProperties(
       }
     }
 
+    if (col_props.pfor_enabled() != default_column_properties_.pfor_enabled()) {
+      if (col_props.pfor_enabled()) {
+        this->enable_pfor_encoding(col_path);
+      } else {
+        this->disable_pfor_encoding(col_path);
+      }
+    }
+
+    if (col_props.pfor_delta_enabled() !=
+        default_column_properties_.pfor_delta_enabled()) {
+      if (col_props.pfor_delta_enabled()) {
+        this->enable_pfor_delta_encoding(col_path);
+      } else {
+        this->disable_pfor_delta_encoding(col_path);
+      }
+    }
+
     if (col_props.compression() != default_column_properties_.compression()) {
       this->compression(col_path, col_props.compression());
     }
diff --git a/cpp/src/parquet/properties.h b/cpp/src/parquet/properties.h
index e2244a1176e3..852717f49983 100644
--- a/cpp/src/parquet/properties.h
+++ b/cpp/src/parquet/properties.h
@@ -168,6 +168,17 @@ static constexpr Encoding::type DEFAULT_ENCODING = Encoding::UNKNOWN;
 static const char DEFAULT_CREATED_BY[] = CREATED_BY_VERSION;
 static constexpr Compression::type DEFAULT_COMPRESSION_TYPE = Compression::UNCOMPRESSED;
 static constexpr bool DEFAULT_IS_PAGE_INDEX_ENABLED = true;
+
+/// PFOR is a Preview feature in the Parquet format, so writers must not emit it
+/// unless the user has explicitly asked for it. See the PFOR section of
+/// `Encodings.md` in apache/parquet-format.
+static constexpr bool DEFAULT_IS_PFOR_ENABLED = false;
+
+/// The delta mode is part of PFOR, not a separate encoding: every PFOR reader
+/// has to handle it, because each vector says in its own header which mode it
+/// used. It is on wherever PFOR is, and this exists to turn it off for a column
+/// whose writer would rather spend nothing deciding.
+static constexpr bool DEFAULT_IS_PFOR_DELTA_ENABLED = true;
 static constexpr SizeStatisticsLevel DEFAULT_SIZE_STATISTICS_LEVEL =
     SizeStatisticsLevel::PageAndColumnChunk;
 
@@ -230,13 +241,17 @@ class PARQUET_EXPORT ColumnProperties {
                    bool dictionary_enabled = DEFAULT_IS_DICTIONARY_ENABLED,
                    bool statistics_enabled = DEFAULT_ARE_STATISTICS_ENABLED,
                    size_t max_stats_size = DEFAULT_MAX_STATISTICS_SIZE,
-                   bool page_index_enabled = DEFAULT_IS_PAGE_INDEX_ENABLED)
+                   bool page_index_enabled = DEFAULT_IS_PAGE_INDEX_ENABLED,
+                   bool pfor_enabled = DEFAULT_IS_PFOR_ENABLED,
+                   bool pfor_delta_enabled = DEFAULT_IS_PFOR_DELTA_ENABLED)
       : encoding_(encoding),
         codec_(codec),
         dictionary_enabled_(dictionary_enabled),
         statistics_enabled_(statistics_enabled),
         max_stats_size_(max_stats_size),
-        page_index_enabled_(page_index_enabled) {}
+        page_index_enabled_(page_index_enabled),
+        pfor_enabled_(pfor_enabled),
+        pfor_delta_enabled_(pfor_delta_enabled) {}
 
   void set_encoding(Encoding::type encoding) { encoding_ = encoding; }
 
@@ -269,6 +284,12 @@ class PARQUET_EXPORT ColumnProperties {
     page_index_enabled_ = page_index_enabled;
   }
 
+  void set_pfor_enabled(bool pfor_enabled) { pfor_enabled_ = pfor_enabled; }
+
+  void set_pfor_delta_enabled(bool pfor_delta_enabled) {
+    pfor_delta_enabled_ = pfor_delta_enabled;
+  }
+
   void set_bloom_filter_options(const BloomFilterOptions& bloom_filter_options) {
     if (!(bloom_filter_options.fpp > 0.0 && bloom_filter_options.fpp < 1.0)) {
       throw ParquetException(
@@ -303,6 +324,10 @@ class PARQUET_EXPORT ColumnProperties {
 
   bool page_index_enabled() const { return page_index_enabled_; }
 
+  bool pfor_enabled() const { return pfor_enabled_; }
+
+  bool pfor_delta_enabled() const { return pfor_delta_enabled_; }
+
   std::optional<BloomFilterOptions> bloom_filter_options() const {
     return bloom_filter_options_;
   }
@@ -317,6 +342,8 @@ class PARQUET_EXPORT ColumnProperties {
   size_t max_stats_size_;
   std::shared_ptr<CodecOptions> codec_options_;
   bool page_index_enabled_;
+  bool pfor_enabled_;
+  bool pfor_delta_enabled_;
   std::optional<BloomFilterOptions> bloom_filter_options_;
 };
 
@@ -374,6 +401,7 @@ class PARQUET_EXPORT WriterProperties {
           created_by_(DEFAULT_CREATED_BY),
           store_decimal_as_integer_(false),
           page_checksum_enabled_(false),
+          pfor_interleaved_bit_packing_(false),
           size_statistics_level_(DEFAULT_SIZE_STATISTICS_LEVEL),
           content_defined_chunking_enabled_(false),
           content_defined_chunking_options_({}) {}
@@ -390,6 +418,7 @@ class PARQUET_EXPORT WriterProperties {
           created_by_(properties.created_by()),
           store_decimal_as_integer_(properties.store_decimal_as_integer()),
           page_checksum_enabled_(properties.page_checksum_enabled()),
+          pfor_interleaved_bit_packing_(properties.pfor_interleaved_bit_packing()),
           size_statistics_level_(properties.size_statistics_level()),
           sorting_columns_(properties.sorting_columns()),
           default_column_properties_(properties.default_column_properties()),
@@ -810,6 +839,33 @@ class PARQUET_EXPORT WriterProperties {
       return this;
     }
 
+    /// EXPERIMENTAL: Ask the PFOR encoder for the lane-interleaved bit-packing
+    /// layout, which takes the same number of bytes and decodes faster where the
+    /// compiler vectorizes its kernels: about 1.08x on a page-sized destination
+    /// at -O3, a tie at the -O2 an Arrow Release build uses, and no advantage
+    /// once a reader decodes into a destination of several MB at a time.
+    ///
+    /// Default disabled. The layout is not yet in the Parquet specification, so
+    /// a file written with it can only be read by an implementation that knows
+    /// it; a reader that does not will reject the page rather than misread it.
+    ///
+    /// This applies to 4-byte columns only, and only to pages whose vectors are
+    /// full. Anything it cannot apply to is written in the layout PFOR has
+    /// always used, so this can be set for a file whose columns are not all
+    /// eligible.
+    Builder* enable_pfor_interleaved_bit_packing() {
+      pfor_interleaved_bit_packing_ = true;
+      return this;
+    }
+
+    /// Write PFOR pages in the bit-packing layout that needs no reader opt-in.
+    ///
+    /// This is the default.
+    Builder* disable_pfor_interleaved_bit_packing() {
+      pfor_interleaved_bit_packing_ = false;
+      return this;
+    }
+
     /// Enable writing page index in general for all columns. Default enabled.
     ///
     /// Writing statistics to the page index disables the old method of writing
@@ -853,6 +909,102 @@ class PARQUET_EXPORT WriterProperties {
       return this->disable_write_page_index(path->ToDotString());
     }
 
+    /// \brief Allow PFOR encoding to be written for all columns. Default disabled.
+    ///
+    /// PFOR is a Preview feature in the Parquet format: the specification is
+    /// stable, but readers across the ecosystem may not implement it yet, and a
+    /// reader that does not implement it must fail rather than return wrong
+    /// values. parquet-format therefore asks writers to keep PFOR behind an
+    /// opt-in flag, which is what this method is.
+    ///
+    /// This flag only grants permission; it does not select PFOR. To write PFOR,
+    /// enable the flag *and* select the encoding, for example:
+    ///
+    ///     builder.enable_pfor_encoding()->encoding(Encoding::PFOR);
+    ///
+    /// Selecting Encoding::PFOR for a column that has not been granted
+    /// permission makes `build()` throw.
+    ///
+    /// Please check the link below for more details:
+    /// https://github.com/apache/parquet-format/blob/master/Encodings.md#patched-frame-of-reference-pfor--11
+    Builder* enable_pfor_encoding() {
+      default_column_properties_.set_pfor_enabled(true);
+      return this;
+    }
+
+    /// Disallow PFOR encoding for all columns. Default disabled.
+    Builder* disable_pfor_encoding() {
+      default_column_properties_.set_pfor_enabled(false);
+      return this;
+    }
+
+    /// Allow PFOR encoding for the column specified by `path`. Default disabled.
+    Builder* enable_pfor_encoding(const std::string& path) {
+      pfor_enabled_[path] = true;
+      return this;
+    }
+
+    /// Allow PFOR encoding for the column specified by `path`. Default disabled.
+    Builder* enable_pfor_encoding(const std::shared_ptr<schema::ColumnPath>& path) {
+      return this->enable_pfor_encoding(path->ToDotString());
+    }
+
+    /// Disallow PFOR encoding for the column specified by `path`. Default disabled.
+    Builder* disable_pfor_encoding(const std::string& path) {
+      pfor_enabled_[path] = false;
+      return this;
+    }
+
+    /// Disallow PFOR encoding for the column specified by `path`. Default disabled.
+    Builder* disable_pfor_encoding(const std::shared_ptr<schema::ColumnPath>& path) {
+      return this->disable_pfor_encoding(path->ToDotString());
+    }
+
+    /// \brief Let PFOR difference a vector before packing it. Default enabled.
+    ///
+    /// PFOR decides per vector whether to pack the values or their differences,
+    /// whichever its cost model makes smaller, and records the choice in the
+    /// vector's own header. Turning this off narrows the encoder to packing
+    /// values; it does not change how a page is read, and it has no effect on a
+    /// column that is not written with PFOR.
+    ///
+    /// Deciding is not free -- a vector that ends up declining the mode still
+    /// pays for an estimate -- so a writer that knows a column has no structure
+    /// between neighbouring values can turn it off and keep that.
+    Builder* enable_pfor_delta_encoding() {
+      default_column_properties_.set_pfor_delta_enabled(true);
+      return this;
+    }
+
+    /// Stop PFOR from differencing any column. Default enabled.
+    Builder* disable_pfor_delta_encoding() {
+      default_column_properties_.set_pfor_delta_enabled(false);
+      return this;
+    }
+
+    /// Let PFOR difference the column specified by `path`. Default enabled.
+    Builder* enable_pfor_delta_encoding(const std::string& path) {
+      pfor_delta_enabled_[path] = true;
+      return this;
+    }
+
+    /// Let PFOR difference the column specified by `path`. Default enabled.
+    Builder* enable_pfor_delta_encoding(const std::shared_ptr<schema::ColumnPath>& path) {
+      return this->enable_pfor_delta_encoding(path->ToDotString());
+    }
+
+    /// Stop PFOR from differencing the column specified by `path`. Default enabled.
+    Builder* disable_pfor_delta_encoding(const std::string& path) {
+      pfor_delta_enabled_[path] = false;
+      return this;
+    }
+
+    /// Stop PFOR from differencing the column specified by `path`. Default enabled.
+    Builder* disable_pfor_delta_encoding(
+        const std::shared_ptr<schema::ColumnPath>& path) {
+      return this->disable_pfor_delta_encoding(path->ToDotString());
+    }
+
     /// \brief Set the level to write size statistics for all columns. Default is
     /// PageAndColumnChunk.
     ///
@@ -886,6 +1038,10 @@ class PARQUET_EXPORT WriterProperties {
         get(item.first).set_statistics_enabled(item.second);
       for (const auto& item : page_index_enabled_)
         get(item.first).set_page_index_enabled(item.second);
+      for (const auto& item : pfor_enabled_)
+        get(item.first).set_pfor_enabled(item.second);
+      for (const auto& item : pfor_delta_enabled_)
+        get(item.first).set_pfor_delta_enabled(item.second);
       for (const auto& item : bloom_filter_options_) {
         const auto& bloom_filter_options = item.second;
         if (bloom_filter_options.ndv.has_value()) {
@@ -897,18 +1053,42 @@ class PARQUET_EXPORT WriterProperties {
         }
       }
 
+      // PFOR is a Preview feature in the Parquet format, so it must never be
+      // written by accident. Refuse to build properties that select PFOR for a
+      // column without also granting permission for it. `default_column_properties_`
+      // covers every column not named in one of the maps above; the map covers
+      // the rest.
+      CheckPforEnabled(default_column_properties_, "the default column properties");
+      for (const auto& item : column_properties) {
+        CheckPforEnabled(item.second, "column '" + item.first + "'");
+      }
+
       return std::shared_ptr<WriterProperties>(new WriterProperties(
           pool_, dictionary_pagesize_limit_, write_batch_size_, max_row_group_length_,
           pagesize_, max_rows_per_page_, version_, created_by_, page_checksum_enabled_,
           size_statistics_level_, std::move(file_encryption_properties_),
           default_column_properties_, column_properties, data_page_version_,
           store_decimal_as_integer_, std::move(sorting_columns_),
-          content_defined_chunking_enabled_, content_defined_chunking_options_));
+          content_defined_chunking_enabled_, content_defined_chunking_options_,
+          pfor_interleaved_bit_packing_));
     }
 
    private:
     void CopyColumnSpecificProperties(const WriterProperties& properties);
 
+    static void CheckPforEnabled(const ColumnProperties& properties,
+                                 const std::string& what) {
+      if (properties.encoding() == Encoding::PFOR && !properties.pfor_enabled()) {
+        throw ParquetException(
+            "PFOR is a Preview feature in the Parquet format and is disabled by "
+            "default, but " +
+            what +
+            " selected Encoding::PFOR. Call "
+            "WriterProperties::Builder::enable_pfor_encoding(), optionally with a "
+            "column path, to allow it.");
+      }
+    }
+
     MemoryPool* pool_;
     int64_t dictionary_pagesize_limit_;
     int64_t write_batch_size_;
@@ -920,6 +1100,7 @@ class PARQUET_EXPORT WriterProperties {
     std::string created_by_;
     bool store_decimal_as_integer_;
     bool page_checksum_enabled_;
+    bool pfor_interleaved_bit_packing_;
     SizeStatisticsLevel size_statistics_level_;
 
     std::shared_ptr<FileEncryptionProperties> file_encryption_properties_;
@@ -935,6 +1116,8 @@ class PARQUET_EXPORT WriterProperties {
     std::unordered_map<std::string, bool> dictionary_enabled_;
     std::unordered_map<std::string, bool> statistics_enabled_;
     std::unordered_map<std::string, bool> page_index_enabled_;
+    std::unordered_map<std::string, bool> pfor_enabled_;
+    std::unordered_map<std::string, bool> pfor_delta_enabled_;
     std::unordered_map<std::string, BloomFilterOptions> bloom_filter_options_;
 
     bool content_defined_chunking_enabled_;
@@ -965,6 +1148,12 @@ class PARQUET_EXPORT WriterProperties {
 
   inline bool page_checksum_enabled() const { return page_checksum_enabled_; }
 
+  /// EXPERIMENTAL: whether PFOR pages use the lane-interleaved bit-packing
+  /// layout. See WriterProperties::Builder::enable_pfor_interleaved_bit_packing.
+  inline bool pfor_interleaved_bit_packing() const {
+    return pfor_interleaved_bit_packing_;
+  }
+
   inline bool content_defined_chunking_enabled() const {
     return content_defined_chunking_enabled_;
   }
@@ -1046,6 +1235,32 @@ class PARQUET_EXPORT WriterProperties {
     return false;
   }
 
+  /// \brief Whether PFOR encoding is allowed for the column at `path`.
+  ///
+  /// PFOR is a Preview feature in the Parquet format, so this is false unless the
+  /// writer opted in through WriterProperties::Builder::enable_pfor_encoding().
+  bool pfor_enabled(const std::shared_ptr<schema::ColumnPath>& path) const {
+    return column_properties(path).pfor_enabled();
+  }
+
+  /// \brief Whether PFOR encoding is allowed for any column.
+  bool pfor_enabled() const {
+    if (default_column_properties_.pfor_enabled()) {
+      return true;
+    }
+    for (const auto& item : column_properties_) {
+      if (item.second.pfor_enabled()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /// \brief Whether PFOR may difference the column at `path` before packing it.
+  bool pfor_delta_enabled(const std::shared_ptr<schema::ColumnPath>& path) const {
+    return column_properties(path).pfor_delta_enabled();
+  }
+
   // Return whether bloom filter is enabled for any column.
   bool bloom_filter_enabled() const {
     return std::any_of(column_properties_.cbegin(), column_properties_.cend(),
@@ -1086,7 +1301,7 @@ class PARQUET_EXPORT WriterProperties {
       const std::unordered_map<std::string, ColumnProperties>& column_properties,
       ParquetDataPageVersion data_page_version, bool store_short_decimal_as_integer,
       std::vector<SortingColumn> sorting_columns, bool content_defined_chunking_enabled,
-      CdcOptions content_defined_chunking_options)
+      CdcOptions content_defined_chunking_options, bool pfor_interleaved_bit_packing)
       : pool_(pool),
         dictionary_pagesize_limit_(dictionary_pagesize_limit),
         write_batch_size_(write_batch_size),
@@ -1098,6 +1313,7 @@ class PARQUET_EXPORT WriterProperties {
         parquet_created_by_(created_by),
         store_decimal_as_integer_(store_short_decimal_as_integer),
         page_checksum_enabled_(page_write_checksum_enabled),
+        pfor_interleaved_bit_packing_(pfor_interleaved_bit_packing),
         size_statistics_level_(size_statistics_level),
         file_encryption_properties_(file_encryption_properties),
         sorting_columns_(std::move(sorting_columns)),
@@ -1117,6 +1333,7 @@ class PARQUET_EXPORT WriterProperties {
   std::string parquet_created_by_;
   bool store_decimal_as_integer_;
   bool page_checksum_enabled_;
+  bool pfor_interleaved_bit_packing_;
   SizeStatisticsLevel size_statistics_level_;
 
   std::shared_ptr<FileEncryptionProperties> file_encryption_properties_;
diff --git a/cpp/src/parquet/properties_test.cc b/cpp/src/parquet/properties_test.cc
index 324ea2026a9e..ecfbb944dc7d 100644
--- a/cpp/src/parquet/properties_test.cc
+++ b/cpp/src/parquet/properties_test.cc
@@ -254,6 +254,148 @@ TEST(TestReaderProperties, GetStreamInsufficientData) {
   }
 }
 
+TEST(TestWriterProperties, PforDisabledByDefault) {
+  auto props = WriterProperties::Builder().build();
+
+  ASSERT_FALSE(props->pfor_enabled());
+  ASSERT_FALSE(props->pfor_enabled(ColumnPath::FromDotString("a")));
+}
+
+TEST(TestWriterProperties, PforRejectedWithoutOptIn) {
+  EXPECT_THROW_THAT(
+      [&]() { WriterProperties::Builder().encoding(Encoding::PFOR)->build(); },
+      ParquetException,
+      ::testing::Property(&ParquetException::what,
+                          ::testing::HasSubstr("enable_pfor_encoding")));
+}
+
+TEST(TestWriterProperties, PforRejectedForColumnWithoutOptIn) {
+  EXPECT_THROW_THAT(
+      [&]() { WriterProperties::Builder().encoding("a", Encoding::PFOR)->build(); },
+      ParquetException,
+      ::testing::Property(&ParquetException::what, ::testing::HasSubstr("column 'a'")));
+}
+
+// Enabling PFOR for one column does not grant permission to another.
+TEST(TestWriterProperties, PforRejectedForColumnEnabledElsewhere) {
+  EXPECT_THROW_THAT(
+      [&]() {
+        WriterProperties::Builder()
+            .enable_pfor_encoding("a")
+            ->encoding("b", Encoding::PFOR)
+            ->build();
+      },
+      ParquetException,
+      ::testing::Property(&ParquetException::what, ::testing::HasSubstr("column 'b'")));
+}
+
+// A global PFOR selection reaches every column, including one that opted out.
+TEST(TestWriterProperties, PforRejectedWhenDisabledForColumnUnderGlobalEncoding) {
+  EXPECT_THROW_THAT(
+      [&]() {
+        WriterProperties::Builder()
+            .enable_pfor_encoding()
+            ->disable_pfor_encoding("a")
+            ->encoding(Encoding::PFOR)
+            ->build();
+      },
+      ParquetException,
+      ::testing::Property(&ParquetException::what, ::testing::HasSubstr("column 'a'")));
+}
+
+// A per-column disable overrides a global enable, so the column must be rejected.
+TEST(TestWriterProperties, PforRejectedWhenDisabledForColumn) {
+  EXPECT_THROW_THAT(
+      [&]() {
+        WriterProperties::Builder()
+            .enable_pfor_encoding()
+            ->disable_pfor_encoding("a")
+            ->encoding("a", Encoding::PFOR)
+            ->build();
+      },
+      ParquetException,
+      ::testing::Property(&ParquetException::what, ::testing::HasSubstr("column 'a'")));
+}
+
+TEST(TestWriterProperties, PforAcceptedWhenEnabledForAllColumns) {
+  auto props = WriterProperties::Builder()
+                   .enable_pfor_encoding()
+                   ->encoding(Encoding::PFOR)
+                   ->build();
+
+  ASSERT_TRUE(props->pfor_enabled());
+  ASSERT_TRUE(props->pfor_enabled(ColumnPath::FromDotString("a")));
+  ASSERT_EQ(Encoding::PFOR, props->encoding(ColumnPath::FromDotString("a")));
+}
+
+TEST(TestWriterProperties, PforAcceptedWhenEnabledForOneColumn) {
+  auto props = WriterProperties::Builder()
+                   .enable_pfor_encoding("a")
+                   ->encoding("a", Encoding::PFOR)
+                   ->build();
+
+  // pfor_enabled() with no argument answers "any column", so it is true here even
+  // though only one column opted in.
+  ASSERT_TRUE(props->pfor_enabled());
+  ASSERT_TRUE(props->pfor_enabled(ColumnPath::FromDotString("a")));
+  ASSERT_FALSE(props->pfor_enabled(ColumnPath::FromDotString("b")));
+}
+
+// The flag grants permission; it does not select the encoding.
+TEST(TestWriterProperties, PforEnabledDoesNotSelectPfor) {
+  auto props = WriterProperties::Builder().enable_pfor_encoding()->build();
+
+  ASSERT_TRUE(props->pfor_enabled());
+  ASSERT_EQ(DEFAULT_ENCODING, props->encoding(ColumnPath::FromDotString("a")));
+}
+
+// The delta mode is part of PFOR rather than a Preview feature of its own, so it
+// is on by default and needs no opt-in.
+TEST(TestWriterProperties, PforDeltaEnabledByDefault) {
+  auto props = WriterProperties::Builder().build();
+
+  ASSERT_TRUE(props->pfor_delta_enabled(ColumnPath::FromDotString("a")));
+}
+
+TEST(TestWriterProperties, PforDeltaCanBeDisabledForAllColumns) {
+  auto props = WriterProperties::Builder().disable_pfor_delta_encoding()->build();
+
+  ASSERT_FALSE(props->pfor_delta_enabled(ColumnPath::FromDotString("a")));
+  ASSERT_FALSE(props->pfor_delta_enabled(ColumnPath::FromDotString("b")));
+}
+
+TEST(TestWriterProperties, PforDeltaCanBeDisabledForOneColumn) {
+  auto props = WriterProperties::Builder().disable_pfor_delta_encoding("a")->build();
+
+  ASSERT_FALSE(props->pfor_delta_enabled(ColumnPath::FromDotString("a")));
+  ASSERT_TRUE(props->pfor_delta_enabled(ColumnPath::FromDotString("b")));
+}
+
+// A per-column enable survives a global disable, so a writer can turn the mode
+// off broadly and keep it for the one column that benefits.
+TEST(TestWriterProperties, PforDeltaPerColumnEnableOverridesGlobalDisable) {
+  auto props = WriterProperties::Builder()
+                   .disable_pfor_delta_encoding()
+                   ->enable_pfor_delta_encoding("a")
+                   ->build();
+
+  ASSERT_TRUE(props->pfor_delta_enabled(ColumnPath::FromDotString("a")));
+  ASSERT_FALSE(props->pfor_delta_enabled(ColumnPath::FromDotString("b")));
+}
+
+// The delta mode is not a permission, so turning it off never makes build()
+// throw the way a missing PFOR opt-in does.
+TEST(TestWriterProperties, PforDeltaDisabledStillBuildsWithPfor) {
+  auto props = WriterProperties::Builder()
+                   .enable_pfor_encoding()
+                   ->disable_pfor_delta_encoding()
+                   ->encoding(Encoding::PFOR)
+                   ->build();
+
+  ASSERT_EQ(Encoding::PFOR, props->encoding(ColumnPath::FromDotString("a")));
+  ASSERT_FALSE(props->pfor_delta_enabled(ColumnPath::FromDotString("a")));
+}
+
 struct WriterPropertiesTestCase {
   WriterPropertiesTestCase(std::shared_ptr<WriterProperties> props, std::string label)
       : properties(std::move(props)), label(std::move(label)) {}
diff --git a/cpp/src/parquet/types.cc b/cpp/src/parquet/types.cc
index 9d7604faec30..99cd5d3e35e9 100644
--- a/cpp/src/parquet/types.cc
+++ b/cpp/src/parquet/types.cc
@@ -270,6 +270,10 @@ std::string EncodingToString(Encoding::type t) {
       return "RLE_DICTIONARY";
     case Encoding::BYTE_STREAM_SPLIT:
       return "BYTE_STREAM_SPLIT";
+    case Encoding::PFOR:
+      return "PFOR";
+    case Encoding::LANE_DELTA:
+      return "LANE_DELTA";
     default:
       return "UNKNOWN";
   }
diff --git a/cpp/src/parquet/types.h b/cpp/src/parquet/types.h
index 687353aa9bcb..bba5931eb3ac 100644
--- a/cpp/src/parquet/types.h
+++ b/cpp/src/parquet/types.h
@@ -539,8 +539,10 @@ struct Encoding {
     DELTA_BYTE_ARRAY = 7,
     RLE_DICTIONARY = 8,
     BYTE_STREAM_SPLIT = 9,
+    PFOR = 11,
+    LANE_DELTA = 12,
     // Should always be last element (except UNKNOWN)
-    UNDEFINED = 10,
+    UNDEFINED = 13,
     UNKNOWN = 999
   };
 };
diff --git a/cpp/src/parquet/x86_register_width_sweep.sh b/cpp/src/parquet/x86_register_width_sweep.sh
new file mode 100755
index 000000000000..18d2bae3e887
--- /dev/null
+++ b/cpp/src/parquet/x86_register_width_sweep.sh
@@ -0,0 +1,359 @@
+#!/usr/bin/env bash
+#
+# One-shot benchmark sweep for the register-width question on x86.
+#
+# WHAT THIS ANSWERS
+#   Does the sequential-vs-interleaved PFOR decode ratio widen as the SIMD
+#   register gets wider? We don't have x86 hardware here, so this script is
+#   meant to be handed to someone who does, run once, and the resulting
+#   tarball sent back.
+#
+# READ THIS FIRST -- THE PREVIOUS REVISION OF THIS SCRIPT WAS WRONG
+#   It claimed the sweep could get every register width out of ONE build by
+#   re-running it under ARROW_USER_SIMD_LEVEL, and told the runner to leave
+#   ARROW_SIMD_LEVEL at its default. That is invalid, and it silently
+#   handicapped the interleaved side of the very comparison this script exists
+#   to make. Kosta caught it on the first run. The mechanism:
+#
+#     - The SEQUENTIAL arm (bpacking.cc, unpack_bias) has real runtime
+#       dispatch: hand-written per-target translation units selected by CPUID
+#       and capped by ARROW_USER_SIMD_LEVEL. It responds to the env var.
+#
+#     - The INTERLEAVED / FL_ORDER arms go through
+#       fastlanes::UnpackBlock in fastlanes_kernels_internal.h, which contains
+#       ZERO intrinsics -- it is portable C++ that the compiler
+#       auto-vectorizes. It has no target attribute and no dispatch table
+#       (see MakeUnpackTable in util/pfor/pfor.cc: the table is indexed by BIT
+#       WIDTH, 1..32, with no CPU-feature dimension at all). So its register
+#       width is fixed at compile time by the TU's flags -- i.e. by
+#       ARROW_SIMD_LEVEL, which defaults to SSE4_2 on x86 -- and
+#       ARROW_USER_SIMD_LEVEL cannot reach it.
+#
+#   Net effect of the old instructions: the AVX2 leg compared a hand-written
+#   AVX2 sequential kernel against a 128-bit interleaved kernel and presented
+#   the ratio as a layout result. It was partly a register-width result.
+#
+#   Hence this revision. Register width is now set per BUILD, at compile time,
+#   and the script takes one binary per level. ARROW_USER_SIMD_LEVEL is still
+#   pinned, but only to hold the sequential arm at the same width as the
+#   interleaved one rather than letting it run ahead to its CPUID maximum.
+#
+#   Verified on Granite Rapids by objdump of the same source at three flag
+#   settings (InterleavedPforDecode, width 12):
+#       -march=haswell      -mprefer-vector-width=256   ymm, no zmm
+#       -march=sapphirerapids -mprefer-vector-width=256  ymm, no zmm
+#       -march=sapphirerapids -mprefer-vector-width=512  1409 zmm, no ymm
+#   Same source, three widths, no code change. That is the knob.
+#
+# ONE ARM CANNOT BE WIDENED AT ALL, AND IT IS THE CANDIDATE ARM
+#   UnpackBlockFlToFileOrder in util/fastlanes/interleaved_pfor.h -- the fused
+#   FL_ORDER-to-file-order transpose, which is the only variant that satisfies
+#   Parquet's positional contract -- IS hand-written intrinsics, and they are
+#   __m256i. It compiles to an identical 2324 ymm / 0 zmm body whether or not
+#   the TU is allowed 512-bit registers. So a 512-bit leg widens the CONTROL
+#   arms (plain interleaved, FL_ORDER-raw) and leaves the CANDIDATE arm at 256
+#   regardless. Read any 512 column with that asymmetry in mind; it is not a
+#   like-for-like widening of both sides.
+#
+# WHY 512 IS OPTIONAL AND SEPARATELY LABELLED
+#   On the sequential side, 512 is not a data point at all:
+#   bpacking_simd_avx512.cc is still driven by the legacy generated kernels,
+#   which build their input register from a list of scalar loads. Measured at
+#   0.16x of the AVX2 kernel and 0.67x of the SCALAR one, so dispatch is capped
+#   at 256 bits in bpacking.cc and a 512 request resolves back to AVX2.
+#   Do not read a 512 sequential column as a 512-bit sequential kernel; it is
+#   the AVX2 one. The interleaved side has no such defect -- its 512 column is
+#   genuine zmm -- which is exactly why the two must not be compared at "512".
+#   AVX2 is the level at which both sides are honest, so AVX2 is the headline.
+#
+# PREREQUISITE -- ONE BUILD PER REGISTER WIDTH
+#   The AVX2 build is the one that matters; do that one first, and stop there
+#   if you only have time for one.
+#
+#     for LEVEL in AVX2 SSE4_2; do
+#       cmake -S cpp -B build-x86-$LEVEL \
+#         -DCMAKE_BUILD_TYPE=Release \
+#         -DARROW_SIMD_LEVEL=$LEVEL \
+#         -DARROW_PARQUET=ON \
+#         -DARROW_BUILD_BENCHMARKS=ON \
+#         -DARROW_WITH_ZSTD=ON -DARROW_WITH_LZ4=ON \
+#         -DARROW_BUILD_TESTS=OFF
+#       cmake --build build-x86-$LEVEL --target parquet-pfor-comparison-benchmark -j
+#     done
+#
+#   -DARROW_SIMD_LEVEL is REQUIRED and is the whole point. Its default
+#   (SSE4_2) is what produced the handicapped first run. Note that this does
+#   change the compile baseline for the whole binary, so these numbers are not
+#   directly comparable to a default-Release ARM run; that is a real cost and
+#   is the correct trade, because the alternative is comparing two layouts at
+#   two different register widths and calling it a layout result.
+#
+# USAGE
+#   ./x86_register_width_sweep.sh AVX2=/path/to/build-x86-AVX2/release/parquet-pfor-comparison-benchmark \
+#                                 [SSE4_2=/path/to/build-x86-SSE4_2/release/...]
+#
+#   Levels may be given in any order and any subset. One LEVEL=PATH pair per
+#   build. A single AVX2 pair is a complete, valid run.
+#
+# OUTPUT
+#   x86_register_width_sweep_<hostname>_<date>.tar.gz in the current
+#   directory, containing:
+#     - combined_results.json   (all register widths, one file, each record
+#                                 tagged with the level it was BUILT at)
+#     - machine.txt             (lscpu, cpuinfo flags, governor, arrow commit,
+#                                 plus an objdump register census per binary so
+#                                 the width is evidenced rather than asserted)
+#     - results_<LEVEL>.json    (the raw per-level benchmark output, kept
+#                                 alongside the combined file for the record)
+#   Send that one tarball back -- nothing else is needed from this run.
+
+set -euo pipefail
+
+if [[ $# -eq 0 ]]; then
+  echo "usage: $0 LEVEL=/path/to/parquet-pfor-comparison-benchmark [LEVEL=/path ...]" >&2
+  echo "       e.g. $0 AVX2=build-x86-AVX2/release/parquet-pfor-comparison-benchmark" >&2
+  echo "(one build per level -- see the header comment; AVX2 alone is a valid run)" >&2
+  exit 1
+fi
+
+declare -A BIN_FOR=()
+ORDER=()
+for pair in "$@"; do
+  if [[ "${pair}" != *=* ]]; then
+    echo "error: expected LEVEL=/path/to/binary, got '${pair}'" >&2
+    echo "(the old single-binary form is gone on purpose -- see the header)" >&2
+    exit 1
+  fi
+  LEVEL="${pair%%=*}"
+  BIN="${pair#*=}"
+  case "${LEVEL}" in
+    SSE4_2 | AVX2 | AVX512) ;;
+    *)
+      echo "error: unknown level '${LEVEL}' (want SSE4_2, AVX2 or AVX512)" >&2
+      exit 1
+      ;;
+  esac
+  if [[ ! -x "${BIN}" ]]; then
+    echo "error: ${LEVEL}: not an executable: ${BIN}" >&2
+    exit 1
+  fi
+  BIN_FOR["${LEVEL}"]="${BIN}"
+  ORDER+=("${LEVEL}")
+done
+
+if [[ -z "${BIN_FOR[AVX2]:-}" ]]; then
+  echo "warning: no AVX2 build given. AVX2 is the level at which both layouts" >&2
+  echo "         are honest and is the one the report quotes." >&2
+fi
+
+OUTDIR="$(mktemp -d)"
+STAMP="$(date -u +%Y%m%dT%H%M%SZ 2>/dev/null || echo unknown-date)"
+HOST="$(hostname -s 2>/dev/null || echo unknown-host)"
+TARBALL="x86_register_width_sweep_${HOST}_${STAMP}.tar.gz"
+
+REPS=7
+# The four layout arms now sweep five working-set sizes (16 KiB / 400 KiB /
+# 1.5 MiB / 4 MiB / 32 MiB of decoded output) instead of the single 400 KiB
+# point the first run used -- see LayoutArgs in pfor_comparison_benchmark.cc.
+# The grid's advantage is a compute effect that only survives while stores are
+# not the limit, so one mid-size point cannot show either its size or the size
+# of the permutation tax. Expect this run to take longer than the first for
+# that reason; the extra points are the answer, not overhead.
+# Only the arms this question is about, across every registered column --
+# typical columns and the delta-shaped ones alike, so delta-mode-relevant
+# columns are covered by column choice, not a separate flag:
+#   - BM_Pfor(64)?Decode           sequential layout, Arrow's shipped decoder
+#                                  with its default options, so the planner may
+#                                  pick a delta representation per vector
+#   - BM_PforPlainSeqDecode / BM_PforPlainInterleavedDecode
+#                                  the same production encoder with delta
+#                                  declined on both sides, so the ratio between
+#                                  these two is the layout on its own. This is
+#                                  the pair to quote for the layout question;
+#                                  BM_PforDecode against an interleaved arm mixes
+#                                  the layout with the prefix sum delta forces.
+#   - BM_InterleavedPforDecode     interleaved layout, plain PFOR, file order.
+#                                  A CONTROL: no encoder can ship this, because
+#                                  filling the grid in file order is what the
+#                                  paper's lane assignment exists to avoid. It
+#                                  is here to price the grid's bit-unpacking on
+#                                  its own.
+#   - BM_InterleavedPforFlOrderRawDecode  the same grid filled the paper's way
+#                                  and handed back WITHOUT the permutation that
+#                                  Parquet's positional contract requires. Also
+#                                  a CONTROL, and the one that was missing from
+#                                  the first run. Without it the two competing
+#                                  explanations for a flat result cannot be
+#                                  separated: "the grid's unpacking is no
+#                                  cheaper" and "the grid's unpacking is much
+#                                  cheaper but the permutation eats all of it"
+#                                  look identical in the candidate's number.
+#   - BM_InterleavedPforFlOrderDecode  THE CANDIDATE. Same grid, permuted back
+#                                  to file order by the fused in-register
+#                                  transpose, so it is the only arm here that
+#                                  satisfies the positional contract and the
+#                                  only one whose number is a verdict.
+#                                  All three interleaved arms above carry no
+#                                  exception handling at all: no patch list on
+#                                  the wire, no patch pass in the decoder. Read
+#                                  them against each other and never against a
+#                                  production arm -- the quotient would charge
+#                                  one side for patching the other never does.
+#                                  They answer the ordering question, not the
+#                                  layout one, which is the pair above.
+#   - BM_TposeApiDecode / TposeFusedDecode / TposeRawDecode / LaneDeltaDecode
+#                                  interleaved layout applied to a delta chain
+# Encode arms and the other codecs (DBP/zstd/lz4/RLE/BSS) are outside this
+# question and are left out to keep the run and the output short.
+FILTER='BM_(Pfor(64)?Decode|PforPlainSeqDecode|PforPlainInterleavedDecode|InterleavedPforDecode|InterleavedPforFlOrderRawDecode|InterleavedPforFlOrderDecode|TposeApiDecode|TposeFusedDecode|TposeRawDecode|LaneDeltaDecode)/'
+
+echo "== machine identification ==" | tee "${OUTDIR}/machine.txt"
+{
+  echo "--- hostname/date ---"
+  echo "host: ${HOST}"
+  echo "utc:  ${STAMP}"
+  echo
+  echo "--- lscpu ---"
+  lscpu 2>/dev/null || echo "(lscpu not available)"
+  echo
+  echo "--- relevant /proc/cpuinfo flags (cpu0) ---"
+  grep -m1 '^flags' /proc/cpuinfo 2>/dev/null | tr ' ' '\n' | grep -E '^(sse4_2|avx2?|avx512[a-z]*|bmi[12])$' || echo "(not on Linux / flags unavailable)"
+  echo
+  echo "--- governor ---"
+  cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor 2>/dev/null || echo "(not exposed)"
+  echo
+  echo "--- repetitions used at every register width ---"
+  echo "${REPS}"
+} | tee -a "${OUTDIR}/machine.txt"
+
+# Evidence, not assertion: show what register width each binary's interleaved
+# kernel actually got. If a "AVX2" binary reports no ymm here, it was built
+# without -DARROW_SIMD_LEVEL=AVX2 and its interleaved numbers are invalid.
+{
+  echo
+  echo "--- objdump register census per binary (interleaved kernel) ---"
+  echo "    a build whose interleaved kernel shows only xmm was NOT built with"
+  echo "    -DARROW_SIMD_LEVEL set, and its interleaved arms are handicapped."
+  for LEVEL in "${ORDER[@]}"; do
+    BIN="${BIN_FOR[${LEVEL}]}"
+    echo
+    echo "  [${LEVEL}] ${BIN}"
+    sha256sum "${BIN}" 2>/dev/null | sed 's/^/    sha256: /' || true
+    if ! command -v objdump >/dev/null 2>&1 || ! command -v nm >/dev/null 2>&1; then
+      echo "    (objdump/nm unavailable -- cannot evidence register width)"
+      continue
+    fi
+    ADDR="$(nm -C "${BIN}" 2>/dev/null \
+      | grep -F 'fastlanes::InterleavedPforDecode' | head -1 | awk '{print $1}')" || true
+    if [[ -z "${ADDR:-}" ]]; then
+      echo "    (InterleavedPforDecode not found in symbol table -- stripped?)"
+    else
+      objdump -d --no-show-raw-insn \
+        --start-address="0x${ADDR}" \
+        --stop-address="$((0x${ADDR} + 0x2000))" "${BIN}" 2>/dev/null > "${OUTDIR}/.dis" || true
+      printf '    InterleavedPforDecode: zmm=%s ymm=%s xmm=%s\n' \
+        "$(grep -co zmm "${OUTDIR}/.dis" || true)" \
+        "$(grep -co ymm "${OUTDIR}/.dis" || true)" \
+        "$(grep -co xmm "${OUTDIR}/.dis" || true)"
+    fi
+    # The candidate arm, which is pinned at 256 by its own __m256i intrinsics.
+    TADDR="$(nm -C "${BIN}" 2>/dev/null \
+      | grep -F 'UnpackBlockFlToFileOrder<12u' | head -1 | awk '{print $1}')" || true
+    if [[ -n "${TADDR:-}" ]]; then
+      objdump -d --no-show-raw-insn \
+        --start-address="0x${TADDR}" \
+        --stop-address="$((0x${TADDR} + 0x1400))" "${BIN}" 2>/dev/null > "${OUTDIR}/.dis" || true
+      printf '    UnpackBlockFlToFileOrder<12>: zmm=%s ymm=%s xmm=%s (expect ymm at every level)\n' \
+        "$(grep -co zmm "${OUTDIR}/.dis" || true)" \
+        "$(grep -co ymm "${OUTDIR}/.dis" || true)" \
+        "$(grep -co xmm "${OUTDIR}/.dis" || true)"
+    fi
+  done
+  rm -f "${OUTDIR}/.dis"
+} | tee -a "${OUTDIR}/machine.txt"
+
+CPU_FLAGS="$(grep -m1 '^flags' /proc/cpuinfo 2>/dev/null || true)"
+have_flag() { echo "${CPU_FLAGS}" | grep -qw "$1"; }
+
+RUNNER=()
+if command -v taskset >/dev/null 2>&1; then
+  RUNNER=(taskset -c 2)
+fi
+
+declare -A LEVEL_SUPPORTED=(
+  [SSE4_2]=sse4_2
+  [AVX2]=avx2
+  [AVX512]=avx512f
+)
+
+RESULT_FILES=()
+for LEVEL in "${ORDER[@]}"; do
+  BIN="${BIN_FOR[${LEVEL}]}"
+  NEEDED_FLAG="${LEVEL_SUPPORTED[${LEVEL}]}"
+  if [[ -n "${CPU_FLAGS}" ]] && ! have_flag "${NEEDED_FLAG}"; then
+    echo "skipping ${LEVEL}: cpu does not report ${NEEDED_FLAG}" | tee -a "${OUTDIR}/machine.txt"
+    continue
+  fi
+  OUT="${OUTDIR}/results_${LEVEL}.json"
+  echo
+  echo "== running the ${LEVEL} BUILD (ARROW_USER_SIMD_LEVEL pinned to ${LEVEL}) =="
+  if [[ "${LEVEL}" == AVX512 ]]; then
+    echo "   note: the sequential arm resolves back to AVX2 here (capped in"
+    echo "   bpacking.cc); the interleaved arm is genuine zmm. Not like-for-like."
+  fi
+  # Pinning the env var holds the SEQUENTIAL arm at the same width the binary
+  # was compiled for, instead of letting CPUID take it to the machine maximum
+  # while the interleaved arm stays at its compile-time width.
+  ARROW_USER_SIMD_LEVEL="${LEVEL}" "${RUNNER[@]}" "${BIN}" \
+    --benchmark_filter="${FILTER}" \
+    --benchmark_repetitions="${REPS}" \
+    --benchmark_report_aggregates_only=true \
+    --benchmark_out="${OUT}" \
+    --benchmark_out_format=json
+  RESULT_FILES+=("${LEVEL}:${OUT}")
+done
+
+if [[ ${#RESULT_FILES[@]} -eq 0 ]]; then
+  echo "no register width ran -- nothing to combine" >&2
+  exit 1
+fi
+
+python3 - "${OUTDIR}/combined_results.json" "${RESULT_FILES[@]}" <<'PYEOF'
+import json
+import sys
+
+out_path = sys.argv[1]
+combined = []
+for pair in sys.argv[2:]:
+    level, path = pair.split(":", 1)
+    with open(path) as f:
+        data = json.load(f)
+    for bench in data.get("benchmarks", []):
+        bench = dict(bench)
+        # The level the binary was COMPILED at -- this is what sets the
+        # interleaved kernel's register width. Named to avoid the old
+        # implication that one build was re-dispatched at runtime.
+        bench["build_simd_level"] = level
+        combined.append(bench)
+
+with open(out_path, "w") as f:
+    json.dump({"benchmarks": combined}, f, indent=2)
+
+print(f"combined {len(combined)} benchmark results across {len(sys.argv) - 2} builds")
+PYEOF
+
+if command -v git >/dev/null 2>&1 && git -C "$(dirname "${BASH_SOURCE[0]}")" rev-parse HEAD >/dev/null 2>&1; then
+  {
+    echo
+    echo "--- arrow commit these binaries should have been built from ---"
+    git -C "$(dirname "${BASH_SOURCE[0]}")" rev-parse HEAD
+    git -C "$(dirname "${BASH_SOURCE[0]}")" status --short
+  } | tee -a "${OUTDIR}/machine.txt"
+fi
+
+tar -czf "${TARBALL}" -C "${OUTDIR}" .
+rm -rf "${OUTDIR}"
+
+echo
+echo "done: ${TARBALL}"
+echo "send this one file back -- it has the combined results and the machine record."
diff --git a/fl5_corpus/.gitignore b/fl5_corpus/.gitignore
new file mode 100644
index 000000000000..b57921790b2c
--- /dev/null
+++ b/fl5_corpus/.gitignore
@@ -0,0 +1,4 @@
+# build products, not sources
+fl5_corpus
+seq_granularity
+*.o
diff --git a/fl5_corpus/README.md b/fl5_corpus/README.md
new file mode 100644
index 000000000000..51a855ebc14e
--- /dev/null
+++ b/fl5_corpus/README.md
@@ -0,0 +1,124 @@
+# fl5_corpus — 5-arm layout benchmark, portable to aarch64
+
+Two binaries. Build both with `./build.sh`, run both, hand back the four output
+files. Nothing here is x86-specific; `build.sh` picks `-march` from `uname -m`.
+
+## Read this first: the working-set ladder is about to change
+
+**Please build and smoke-test now, but hold the full production run.** Two
+problems with the current three points were found after this harness was written,
+and both are being fixed:
+
+1. **The point labelled `DRAM` is not DRAM.** The x86 reference numbers were
+   taken on a Xeon 6975P-C (Granite Rapids) with **2 MiB of L2 per core and
+   480 MiB of shared L3**. A 32 MiB working set is comfortably L3-resident, so
+   that row measures L3 bandwidth, not memory. Reaching DRAM on that machine
+   needs roughly a gigabyte. Wherever you see `DRAM` in output or in the x86
+   reference files, read it as **L3**, and do not describe those figures as
+   memory-bound in anything you write up.
+2. **The three points bracket the realistic range instead of covering it.** A
+   120 MB file with 100 columns gives ~1.2 MB per column chunk, and integer
+   columns run well under that average — call it 300 KB. Unpacking expands
+   packed bytes by `32/W`, so a 300 KB integer chunk decodes to 300 KB at
+   *W*=32, 600 KB at *W*=16, 1.2 MB at *W*=8 and 2.4 MB at *W*=4. The realistic
+   span is therefore ~300 KB to 2.4 MB, and there is no measurement between
+   400 KiB and 32 MiB.
+
+Points near 1.5 MiB, 4 MiB and ≥1 GiB are being added, plus a concurrency sweep
+(the single-thread numbers give one core the entire L3 and memory controller,
+which a real parallel scan does not). Building and smoke-testing now is still
+worth doing — whether this compiles at all on aarch64 is the open risk, and it is
+independent of which points get measured. **Smoke test with a single dataset**
+(`./fl5_corpus ClientIP /tmp/smoke.csv`) rather than the full corpus, and report
+whether it builds, runs, and exits zero.
+
+## Build
+
+The harness now lives in-tree at `<arrow>/fl5_corpus/`, so `build.sh` finds the
+checkout itself. Only the build directory needs pointing at:
+
+```bash
+export ARROW_BUILD=/path/to/your/arrow/build   # has src/arrow/util/config.h and
+                                               # release/libarrow.so
+export XSIMD=$ARROW_BUILD/_deps/xsimd-src/include   # optional; this is the default
+./build.sh
+```
+
+`build.sh` preflights the three headers it needs and fails with a specific
+message naming the missing one, rather than emitting a wall of compiler errors.
+The checkout must be on the branch carrying
+`cpp/src/arrow/util/fastlanes/interleaved_pfor.h` — the harness includes it
+directly.
+
+## Run
+
+```bash
+# usage: ./fl5_corpus [dataset-filter] [csv-path]
+#   filter "all" (or omitted) runs all 43; any other string is a substring match
+taskset -c 2 ./fl5_corpus all fl5_corpus_arm.csv > fl5_corpus_arm.txt 2> fl5_corpus_arm.err
+taskset -c 2 ./seq_granularity > seq_granularity_arm.txt
+echo "exit=$?"
+```
+
+One run produces both the human table (stdout) and the CSV. Pin to a core and
+keep the machine otherwise idle; the whole thing takes a few minutes.
+
+`fl5_corpus` exits non-zero if the `fl_unpk`-vs-`intlv` identity check fails, so
+a clean exit is meaningful — please report the exit status. Its header also
+prints which `fl_tpos` implementation was compiled in; on aarch64 expect to see
+the `UNFUSED fallback` banner, which confirms caveat 1 below rather than
+indicating a build problem.
+
+## What the two binaries are for
+
+`fl5_corpus` runs five arms over 43 generated columns at three working sets
+(16 KiB / 400 KiB / 32 MiB of output — labelled L1 / L2 / `DRAM`, but see the
+correction at the top: the third is L3):
+
+| arm | layout | order out |
+|---|---|---|
+| `seq_scal` | continuous LSB-first | file |
+| `seq_simd` | continuous LSB-first | file |
+| `intlv` | interleaved 32×32 | file |
+| `fl_unpk` | interleaved, FL_ORDER | FL_ORDER |
+| `fl_tpos` | interleaved, FL_ORDER | file |
+
+`intlv` and `fl_unpk` run identical kernel code against grids that were merely
+*filled* differently at encode time, so their speeds must agree — that is the
+harness's self-check, and it should read 1.00x.
+
+`seq_granularity` is the calibration probe, and it is **not optional**. On x86 it
+showed that calling Arrow's exported `unpack_bias` once per 1024-value block
+rather than once per buffer costs **1.27x at L1 and L2** — a handicap the
+`seq_simd` arm pays and the header-inlined interleaved arms do not. Without it,
+`intlv/seq_simd` reads 1.43x at L2 when the layout-only effect is ~1.13x. The
+aarch64 ratios need the same correction with a locally-measured divisor; do not
+reuse the x86 1.27x.
+
+## Two things to know before interpreting aarch64 results
+
+1. **`fl_tpos` is the unfused fallback on aarch64.** The fused
+   FL_ORDER-to-file-order kernel (`UnpackBlockFlToFileOrder`) is guarded by
+   `ARROW_TRANSPOSED_DELTA_AVX2` and depends on the
+   `vpunpckldq`/`vperm2i128` ladder. On aarch64 the decoder falls back to
+   unpack-into-a-4-KiB-scratch-grid then `Transpose32x32`. On x86 that path
+   measures ~21.6 GiB/s against the fused kernel's 31.30, so **any aarch64
+   `fl_tpos` number is a lower bound**, and it must not be compared against the
+   x86 `fl_tpos` figure as though the same kernel ran. `intlv` and `fl_unpk` are
+   fully portable and carry no such caveat.
+2. **aarch64 never had the AVX-512 dispatch bug.** Arrow's
+   `bpacking_simd_avx512.cc` is 6.26x slower than its AVX2 kernel and 0.67x of
+   scalar, and `ARROW_RUNTIME_SIMD_LEVEL` defaults to `MAX`, so x86 machines
+   preferred it. That is the whole explanation for "PFOR is 30 GB/s on ARM and
+   6 GiB/s on x86" — it is a bug on one side, not an architecture difference.
+   The x86 numbers here were taken with that dispatch capped at 256 bits.
+
+## Files to hand back
+
+`fl5_corpus_arm.txt`, `fl5_corpus_arm.csv`, `fl5_corpus_arm.err`,
+`seq_granularity_arm.txt`. The `.csv` is what generates the document tables
+(`gen_tables.py` consumes it; columns are
+`dataset,point,n,avg_bit_width,cr,seq_scal,seq_simd,intlv,fl_unpk,fl_tpos`).
+
+x86 reference outputs for comparison are checked in alongside:
+`fl5_corpus_x86.{txt,csv}` and `seq_granularity.txt`.
diff --git a/fl5_corpus/build.sh b/fl5_corpus/build.sh
new file mode 100755
index 000000000000..db8ef76a1e99
--- /dev/null
+++ b/fl5_corpus/build.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+# Builds fl5_corpus (the 5-arm corpus harness) and seq_granularity (the per-block
+# call-overhead probe that calibrates the sequential arm). Works on x86-64 and
+# aarch64; the only difference is -march.
+#
+#   ARROW=/path/to/arrow           source checkout (has cpp/src)
+#   ARROW_BUILD=/path/to/build     configured+built Arrow (has src/arrow/util/config.h
+#                                  and release/libarrow.so)
+#   XSIMD=/path/to/xsimd/include   xsimd headers (Arrow vendors them under
+#                                  <build>/_deps/xsimd-src/include)
+set -euo pipefail
+# This script lives at <arrow>/fl5_corpus/, so the checkout is one level up and
+# needs no configuring. ARROW_BUILD and XSIMD do: point them at your own build.
+HERE=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
+ARROW=${ARROW:-$(dirname "$HERE")}
+ARROW_BUILD=${ARROW_BUILD:?set ARROW_BUILD to a configured+built Arrow dir (has src/arrow/util/config.h)}
+# Arrow vendors xsimd under the build tree; fall back to a sibling build if the
+# caller did not say.
+XSIMD=${XSIMD:-$ARROW_BUILD/_deps/xsimd-src/include}
+LIBDIR=${LIBDIR:-$ARROW_BUILD/release}
+
+for f in "$ARROW/cpp/src/arrow/util/fastlanes/interleaved_pfor.h" \
+         "$ARROW_BUILD/src/arrow/util/config.h" \
+         "$XSIMD/xsimd/xsimd.hpp"; do
+  [ -f "$f" ] || { echo "build.sh: missing $f" >&2; exit 1; }
+done
+
+case "$(uname -m)" in
+  x86_64)  ARCH_FLAGS=${ARCH_FLAGS:-"-march=haswell -mprefer-vector-width=256"} ;;
+  aarch64) ARCH_FLAGS=${ARCH_FLAGS:-"-march=armv8-a+simd"} ;;
+  *)       ARCH_FLAGS=${ARCH_FLAGS:-""} ;;
+esac
+
+set -x
+for SRC in fl5_corpus fl5_delta_corpus seq_granularity; do
+  ${CXX:-g++} -std=c++20 -O3 $ARCH_FLAGS -DNDEBUG \
+    -I"$ARROW/cpp/src" -I"$ARROW_BUILD/src" -I"$ARROW/cpp/build-support" -I"$XSIMD" \
+    "$SRC.cpp" -o "$SRC" \
+    -L"$LIBDIR" -larrow -Wl,-rpath,"$LIBDIR"
+done
diff --git a/fl5_corpus/corpus_generators.h b/fl5_corpus/corpus_generators.h
new file mode 100644
index 000000000000..97635b55361a
--- /dev/null
+++ b/fl5_corpus/corpus_generators.h
@@ -0,0 +1,642 @@
+// corpus_generators.h -- EXTRACTED VERBATIM, do not hand-edit.
+//
+// Lines 87..707 of arrow/cpp/src/parquet/pfor_comparison_benchmark.cc, which is
+// where the 43-column int32 corpus is defined. Copied rather than included
+// because that file is a google-benchmark TU that pulls in all of Parquet; the
+// generators themselves depend on nothing but the standard library.
+//
+// Regenerate with:
+//   sed -n '87,707p' $ARROW/cpp/src/parquet/pfor_comparison_benchmark.cc
+#pragma once
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <random>
+#include <vector>
+
+namespace corpus {
+
+std::vector<int32_t> GenClientIP(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(101);
+  std::uniform_int_distribution<uint32_t> dist(0x0A000000, 0xDFFFFFFF);
+  for (auto& x : v) x = static_cast<int32_t>(dist(rng));
+  return v;
+}
+
+std::vector<int32_t> GenUrlRegionID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(102);
+  // Zipf-like over ~1000 values
+  std::uniform_real_distribution<double> uni(0.0, 1.0);
+  for (auto& x : v) {
+    double u = uni(rng);
+    x = static_cast<int32_t>(std::pow(u, 2.0) * 1000) + 1;
+  }
+  return v;
+}
+
+std::vector<int32_t> GenCounterID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(103);
+  std::uniform_int_distribution<int32_t> jitter(0, 3);
+  int32_t counter = 100000;
+  for (auto& x : v) {
+    counter += 1 + jitter(rng);
+    x = counter;
+  }
+  return v;
+}
+
+std::vector<int32_t> GenEventDate(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(104);
+  const int32_t dates[] = {19691, 19692, 19693, 19694, 19695};
+  std::uniform_int_distribution<int> idx(0, 4);
+  for (auto& x : v) x = dates[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenEventTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(105);
+  const int32_t base = 1704067200;  // 2024-01-01
+  std::uniform_int_distribution<int32_t> offset(0, 86399);
+  for (auto& x : v) x = base + offset(rng);
+  return v;
+}
+
+std::vector<int32_t> GenGoodEvent(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(106);
+  std::uniform_int_distribution<int> dist(0, 99);
+  for (auto& x : v) x = (dist(rng) < 95) ? 1 : 0;
+  return v;
+}
+
+std::vector<int32_t> GenHID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(107);
+  std::uniform_int_distribution<int32_t> dist(std::numeric_limits<int32_t>::min(),
+                                              std::numeric_limits<int32_t>::max());
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenHitColor(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(108);
+  const int32_t colors[] = {1, 2, 3, 4, 5};
+  std::uniform_int_distribution<int> idx(0, 4);
+  for (auto& x : v) x = colors[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenIPNetworkID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(109);
+  std::uniform_int_distribution<int32_t> dist(1, 10000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenJavaEnable(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(110);
+  std::uniform_int_distribution<int> dist(0, 99);
+  for (auto& x : v) x = (dist(rng) < 85) ? 1 : 0;
+  return v;
+}
+
+std::vector<int32_t> GenOS(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(111);
+  std::uniform_int_distribution<int32_t> dist(1, 20);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenResolution(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(112);
+  const int32_t resolutions[] = {360,  480,  600,  720,  768,  800,  900,
+                                 1024, 1050, 1080, 1200, 1440, 1600, 2160};
+  std::uniform_int_distribution<int> idx(0, 13);
+  for (auto& x : v) x = resolutions[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenTrafficSourceID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(113);
+  std::uniform_int_distribution<int32_t> dist(0, 10);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenUserAgent(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(114);
+  // Zipf-like over ~100 user agents
+  std::uniform_real_distribution<double> uni(0.0, 1.0);
+  for (auto& x : v) {
+    double u = uni(rng);
+    x = static_cast<int32_t>(std::pow(u, 1.5) * 100) + 1;
+  }
+  return v;
+}
+
+// ============================================================================
+// Data Generators — TPC-DS (4 most queried columns from store_sales)
+// ============================================================================
+
+std::vector<int32_t> GenTpcdsSoldDateSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 2450815;
+  std::mt19937 rng(201);
+  std::uniform_int_distribution<int32_t> dist(0, 1820);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsStoreSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(202);
+  std::uniform_int_distribution<int32_t> dist(1, 1000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsItemSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMax = 100000;
+  std::mt19937 rng(203);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    int32_t val = static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val + 1, kMax);
+  }
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsQuantity(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(204);
+  std::uniform_int_distribution<int32_t> small_dist(1, 10);
+  std::uniform_int_distribution<int32_t> large_dist(11, 100);
+  std::uniform_int_distribution<int> chance(0, 99);
+  for (auto& x : v) {
+    x = (chance(rng) < 90) ? small_dist(rng) : large_dist(rng);
+  }
+  return v;
+}
+
+// --- TPC-H (lineitem) top-queried numeric columns (Q1/Q3/Q5/Q6) ------------
+// l_quantity: integer [1, 50], uniform. Small range, min 1.
+std::vector<int32_t> GenTpchLQuantity(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(301);
+  std::uniform_int_distribution<int32_t> dist(1, 50);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// l_extendedprice (cents): l_quantity * p_retailprice. p_retailprice spans
+// ~$900.00..$2099.00, so cents in [90000, 10495000]. Wide range, nonzero min.
+std::vector<int32_t> GenTpchLExtendedPrice(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(302);
+  std::uniform_int_distribution<int32_t> qty(1, 50);
+  std::uniform_int_distribution<int32_t> retail_cents(90000, 209900);
+  for (auto& x : v) x = qty(rng) * retail_cents(rng);
+  return v;
+}
+
+// l_discount (x100): integer [0, 10] i.e. 0.00..0.10. Genuinely includes 0
+// (0% discount is a real value), so this one legitimately starts at 0.
+std::vector<int32_t> GenTpchLDiscount(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(303);
+  std::uniform_int_distribution<int32_t> dist(0, 10);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// l_shipdate (days since 1970-01-01): 1992-01-01..1998-12 span. Base 8036,
+// range ~7 years. Large nonzero min -> exercises frame-of-reference.
+std::vector<int32_t> GenTpchLShipDate(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 8036;  // days since epoch for 1992-01-01
+  std::mt19937 rng(304);
+  std::uniform_int_distribution<int32_t> dist(0, 2557);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+// --- TPC-DS (store_sales / date_dim) further top-queried numeric columns ---
+// ss_customer_sk: surrogate key, uniform [1, 2,000,000]. Big range, min 1.
+std::vector<int32_t> GenTpcdsCustomerSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(311);
+  std::uniform_int_distribution<int32_t> dist(1, 2000000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// ss_ext_sales_price (cents): skewed price, exponential mean ~$50, floored at
+// $1.00 (a sale has a nonzero price), capped at $20,000. Long tail -> patches.
+std::vector<int32_t> GenTpcdsExtSalesPrice(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMin = 100, kMax = 2000000;
+  std::mt19937 rng(312);
+  std::exponential_distribution<double> exp_dist(1.0 / 5000.0);
+  for (auto& x : v) {
+    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ss_net_profit (cents): usually a small profit, sometimes a loss -> negative
+// values, so the frame of reference is negative (not zero).
+std::vector<int32_t> GenTpcdsNetProfit(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(313);
+  std::uniform_int_distribution<int32_t> dist(-10000, 300000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// d_year: queried date_dim year range [1998, 2003]. Low cardinality, min 1998.
+std::vector<int32_t> GenTpcdsDYear(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(314);
+  std::uniform_int_distribution<int32_t> dist(1998, 2003);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// --- NYC yellow-taxi trip numeric columns ----------------------------------
+// pickup timestamp (unix seconds): 2015-01, base 1,420,070,400 + ~31 days.
+// Very large min -> frame-of-reference is essential.
+std::vector<int32_t> GenTaxiPickupUnixTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 1420070400;  // 2015-01-01 UTC
+  std::mt19937 rng(321);
+  std::uniform_int_distribution<int32_t> dist(0, 2678400);  // ~31 days
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+// trip_distance (x100 miles): exponential mean ~1.8 mi, floored at 0.10 mi
+// (no zero-distance trips), capped at 100 mi. Long tail -> patches.
+std::vector<int32_t> GenTaxiTripDistanceX100(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMin = 10, kMax = 10000;
+  std::mt19937 rng(322);
+  std::exponential_distribution<double> exp_dist(1.0 / 180.0);
+  for (auto& x : v) {
+    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// fare_amount (cents): $2.50 base + exponential mean ~$10, capped at $150.
+// Nonzero floor at the base fare, skewed with a long tail.
+std::vector<int32_t> GenTaxiFareCents(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 250, kMax = 15000;
+  std::mt19937 rng(323);
+  std::exponential_distribution<double> exp_dist(1.0 / 1000.0);
+  for (auto& x : v) {
+    int32_t val = kBase + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ============================================================================
+// Data Generators — int64 / BIGINT columns (values that require 8 bytes,
+// i.e. exceed the int32 range). Covers the common 64-bit analytic cases:
+// nanosecond timestamps, large surrogate keys, scaled-decimal money, monotone
+// IDs, and wide counters.
+// ============================================================================
+
+// Nanosecond epoch timestamp (Parquet TIMESTAMP(NANOS)): 2024-01-01 base plus
+// up to ~1 day of jitter. Min ~1.70e18 -> very large frame of reference; raw
+// values need ~61 bits.
+std::vector<int64_t> GenTsNanos(int64_t n) {
+  std::vector<int64_t> v(n);
+  const int64_t kBase = 1704067200000000000LL;  // 2024-01-01T00:00:00Z in ns
+  std::mt19937_64 rng(401);
+  std::uniform_int_distribution<int64_t> off(0, 86399999999999LL);  // ~1 day
+  for (auto& x : v) x = kBase + off(rng);
+  return v;
+}
+
+// BIGINT surrogate / order key, uniform over [1, 10 billion] (exceeds 2^32).
+std::vector<int64_t> GenOrderKey(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(402);
+  std::uniform_int_distribution<int64_t> dist(1, 10000000000LL);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// Money as int64 scaled decimal (micro-units): $0.01 .. ~$100k, skewed, with a
+// nonzero floor at one cent.
+std::vector<int64_t> GenPriceMicros(int64_t n) {
+  std::vector<int64_t> v(n);
+  const int64_t kMin = 10000, kMax = 100000000000LL;  // $0.01 .. $100,000
+  std::mt19937_64 rng(403);
+  std::exponential_distribution<double> exp_dist(1.0 / 5000000.0);  // mean ~$5
+  for (auto& x : v) {
+    int64_t val = kMin + static_cast<int64_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ============================================================================
+// Data Generators — sorted and near-sorted
+//
+// The generators above draw independently around a base, which is the case
+// delta encoding is not for: subtracting two i.i.d. values spans the whole
+// range whichever two you pick, so the distance between them does not matter
+// and every delta variant lands within a bit or two of frame of reference.
+// Comparing delta schemes needs columns whose value depends on the previous
+// one. These cover the shapes that occur in practice: a clustered timestamp
+// column, a sorted key with duplicates, an exact counter, and a column that
+// is sorted apart from a few late arrivals.
+// ============================================================================
+
+// Event timestamps in seconds, arriving a few seconds apart. The common case
+// for a table clustered or sorted on time.
+std::vector<int32_t> GenSortedUnixTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(401);
+  std::uniform_int_distribution<int32_t> gap(0, 7);
+  int32_t t = 1700000000;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = t;
+  }
+  return v;
+}
+
+// A sorted surrogate key with runs of duplicates, as produced by a join key or
+// a dictionary-sorted column: most steps are 0, some are 1.
+std::vector<int32_t> GenSortedKeyDups(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(402);
+  std::uniform_int_distribution<int32_t> step(0, 1);
+  int32_t k = 5000000;
+  for (auto& x : v) {
+    k += step(rng);
+    x = k;
+  }
+  return v;
+}
+
+// An exact +1 row id. The best case for any delta scheme, and the case where
+// stride-1 and lane-parallel delta differ most.
+std::vector<int32_t> GenMonotoneRowId(int64_t n) {
+  std::vector<int32_t> v(n);
+  int32_t k = 1;
+  for (auto& x : v) x = k++;
+  return v;
+}
+
+// Sorted except that 2% of rows arrive late, so a few deltas are large and
+// negative. Tests whether one bit width per block survives outliers.
+std::vector<int32_t> GenNearSortedUnixTime(int64_t n) {
+  std::vector<int32_t> v = GenSortedUnixTime(n);
+  std::mt19937 rng(403);
+  std::uniform_int_distribution<int> pick(0, 49);
+  std::uniform_int_distribution<int32_t> late(1, 3600);
+  for (auto& x : v) {
+    if (pick(rng) == 0) x -= late(rng);
+  }
+  return v;
+}
+
+// Snowflake-style monotone ID: large base + jittered per-row increments.
+// Monotone -> ideal for DELTA_BINARY_PACKED; huge min -> ideal for PFOR's FOR.
+std::vector<int64_t> GenSnowflakeId(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(404);
+  std::uniform_int_distribution<int64_t> step(1, 4096);
+  int64_t id = 1500000000000000000LL;
+  for (auto& x : v) {
+    id += step(rng);
+    x = id;
+  }
+  return v;
+}
+
+// Wide cumulative byte counts, uniform [1024, 5 trillion] (wide 64-bit range).
+std::vector<int64_t> GenByteCount(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(405);
+  std::uniform_int_distribution<int64_t> dist(1024, 5000000000000LL);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// ============================================================================
+// Data Generators — structure between neighbouring values
+// ============================================================================
+
+// The generators above are all either unordered or perfectly regular, so none
+// of them separates an encoding that differences neighbouring values from one
+// that packs them, and none of them puts a frame of reference anywhere but the
+// minimum. These do. They are the columns on which PFOR's delta mode and
+// DELTA_BINARY_PACKED make different choices, so they are what this file needs
+// in order to compare the two.
+//
+// Unlike the generators above, these are templates rather than a pair of
+// per-width functions: it keeps the int32 and int64 arms of every REGISTER
+// below on provably the same distribution, which two hand-written copies would
+// not. They live in their own namespace because two of them build on base
+// distributions whose names are already taken in this file by columns drawn
+// from different seeds -- keeping them separate is what makes these figures
+// comparable with pfor_benchmark.cc, which uses the same shapes.
+namespace delta_shapes {
+
+template <typename T>
+std::vector<T> GenSmallRange(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(100000, 200000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsItemSk(int64_t n) {
+  std::vector<T> v(n);
+  const T kMax = 100000;
+  std::mt19937_64 rng(12345);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    T val = static_cast<T>(exp_dist(rng));
+    x = std::min(static_cast<T>(val + 1), kMax);
+  }
+  return v;
+}
+
+/// A timestamp column with a fixed sampling interval and jitter: the
+/// differences cluster tightly around the interval, the values do not.
+template <typename T>
+std::vector<T> GenTrendJitter(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(7);
+  std::normal_distribution<double> jitter(0.0, 40.0);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += 3.0;
+    x = static_cast<T>(t + jitter(rng));
+  }
+  return v;
+}
+
+/// A TCP congestion window: a linear climb cut by a sharp halving. Almost
+/// every difference is the same small number and a few are large and
+/// negative, which is the shape a two-sided frame plus patching handles at
+/// close to no cost and a one-sided one cannot.
+template <typename T>
+std::vector<T> GenSawtooth(int64_t n) {
+  std::vector<T> v(n);
+  T cur = 1000;
+  for (int64_t i = 0; i < n; ++i) {
+    if (i % 200 == 199) {
+      cur /= 2;
+    } else {
+      cur += 12;
+    }
+    v[i] = cur;
+  }
+  return v;
+}
+
+/// A continuous quantity sampled over time, so the rate of change is bounded
+/// but the level wanders: differencing wins, though not by much.
+template <typename T>
+std::vector<T> GenMeasurement(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(11);
+  std::normal_distribution<double> noise(0.0, 1.0);
+  double level = 0.0;
+  double rate = 0.0;
+  for (int64_t i = 0; i < n; ++i) {
+    rate = 0.95 * rate + noise(rng);
+    level += rate;
+    v[i] = static_cast<T>(4000.0 * level / 50.0) + static_cast<T>(500000);
+  }
+  return v;
+}
+
+/// A sorted surrogate key column, which is what a clustered index or a
+/// sorted-by-key file produces.
+template <typename T>
+std::vector<T> GenSortedKeys(int64_t n) {
+  auto v = GenTpcdsItemSk<T>(n);
+  std::sort(v.begin(), v.end());
+  return v;
+}
+
+/// A measurement series punctuated by a low sentinel standing in for "no
+/// reading". The sentinel sits far below the cluster, so a frame pinned to
+/// the minimum has to widen to reach it and no value can ever be patched.
+template <typename T>
+std::vector<T> GenSensorDropouts(int64_t n) {
+  auto v = GenMeasurement<T>(n);
+  std::mt19937_64 rng(3);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-999999);
+  }
+  return v;
+}
+
+/// Monotonic ids with occasional large jumps, as a sequence shared between
+/// writers or restarted produces.
+template <typename T>
+std::vector<T> GenIdsWithGaps(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(5);
+  std::uniform_int_distribution<int> step(1, 6);
+  std::uniform_int_distribution<int> jump(0, 199);
+  T cur = 1000000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    if (jump(rng) == 0) cur += 100000;
+    x = cur;
+  }
+  return v;
+}
+
+/// Prices on a random walk: small signed steps around a high base, and no
+/// trend for the differences to line up on.
+template <typename T>
+std::vector<T> GenRandomWalk(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(13);
+  std::uniform_int_distribution<int> step(-25, 25);
+  T cur = 1500000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    x = cur;
+  }
+  return v;
+}
+
+/// Event arrival times in milliseconds since the epoch, bursty, so the gaps
+/// are skewed rather than clustered.
+template <typename T>
+std::vector<T> GenEventMillis(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(17);
+  std::exponential_distribution<double> gap(0.4);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = static_cast<T>(t);
+  }
+  return v;
+}
+
+/// A tight unordered cluster with a low "missing" sentinel: the frame cannot
+/// sit at the minimum and differencing has nothing to exploit either, so
+/// this is the column that has to come out no worse than before.
+template <typename T>
+std::vector<T> GenLowSentinel(int64_t n) {
+  auto v = GenSmallRange<T>(n);
+  std::mt19937_64 rng(23);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-1000);
+  }
+  return v;
+}
+
+/// Two interleaved clusters far apart, so no single window covers the vector
+/// and the cheaper cluster is worth framing on its own.
+template <typename T>
+std::vector<T> GenBimodal(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(19);
+  std::uniform_int_distribution<T> lo(1000, 1100);
+  std::uniform_int_distribution<T> hi(900000, 900100);
+  std::uniform_int_distribution<int> pick(0, 9);
+  for (auto& x : v) {
+    x = pick(rng) < 8 ? lo(rng) : hi(rng);
+  }
+  return v;
+}
+
+}  // namespace delta_shapes
+
+}  // namespace corpus
diff --git a/fl5_corpus/fl5_corpus.cpp b/fl5_corpus/fl5_corpus.cpp
new file mode 100644
index 000000000000..ad79045a26bd
--- /dev/null
+++ b/fl5_corpus/fl5_corpus.cpp
@@ -0,0 +1,585 @@
+// fl5_corpus -- five bit-unpacking arms, 43 real-shaped columns, three working sets.
+//
+// This measures BIT-UNPACKING ONLY. Frame-of-reference addition is present in
+// every arm (it is one broadcast add fused into the unpack, and all five decode
+// arms do
+// it), but there is no delta / prefix sum anywhere in this file. The question is
+// exactly: for the same 1024-value blocks at the same bit widths, which physical
+// bit-packing layout decodes fastest?
+//
+//   seq_scal  Parquet's layout (one continuous LSB-first stream per block),
+//             decoded by Arrow's GENERATED SCALAR unpacker. This is the "naive
+//             sequential bit-packing" baseline the FastLanes paper quotes its
+//             order-of-magnitude against, so it is a column and not a footnote.
+//   seq_simd  Identical bytes, decoded by Arrow's SHIPPED SIMD unpacker
+//             (arrow::internal::unpack_bias, runtime-dispatched). This is what
+//             Parquet actually runs today, and the only honest baseline for
+//             "should Parquet change its layout".
+//   intlv     FastLanes interleaved container: 1024 values as a 32x32 grid,
+//             row-major across 32 lanes. Values come out in file order. No
+//             permutation anywhere.
+//   fl_unpk   Same container, but encode applied FL_ORDER's lane permutation.
+//             Decoded to FL order and handed to the caller as-is -- the
+//             order-agnostic consumer (scan / filter / aggregate). This arm
+//             exists because the transpose has a cost and the layout deserves to
+//             be priced without it.
+//   fl_tpos   Byte-identical wire format to fl_unpk, decoded back to FILE order.
+//             This is what a positional Parquet decoder must return.
+//
+// Two invariants this harness enforces rather than assumes:
+//   1. All five decode arms are verified bit-exact against the generated
+//      values before anything is timed. A fast wrong answer is not a result.
+//   2. intlv, fl_unpk and fl_tpos call the SAME PackBlock<W>/UnpackBlock<W>.
+//      They differ only in how encode filled the grid, which is offline and
+//      free. So fl_unpk/intlv MUST measure 1.00x. If it does not, the harness is
+//      broken and every other number in the run is suspect. It is printed on
+//      every line for exactly that reason.
+//
+// All arms write into ONE process-wide 4096-aligned buffer. Letting each arm
+// own a std::vector makes output-address-mod-4096 a bigger effect than any
+// layout difference being measured, which cost this project several days of
+// wrong conclusions.
+
+#include <cinttypes>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <functional>
+#include <string>
+#include <vector>
+
+#include <arrow/util/bpacking_internal.h>
+#include "arrow/util/bpacking_dispatch_internal.h"
+#include "arrow/util/bpacking_scalar_generated_internal.h"
+#include "arrow/util/fastlanes/interleaved_pfor.h"
+
+#include "corpus_generators.h"
+
+namespace fl = arrow::util::fastlanes;
+namespace bp = arrow::internal::bpacking;
+using fl::InterleavedPforOrder;
+using Clock = std::chrono::steady_clock;
+
+// The generated scalar kernel family, named as bpacking_dispatch expects.
+template <typename U, int W>
+using KernelScalar = arrow::internal::ScalarUnpackerForWidth<U, W>;
+
+constexpr size_t kBlk = 1024;
+constexpr int kReps = 5;
+constexpr size_t kBytesPerRun = 1024u * 1024 * 1024;  // output bytes per timed run
+
+// ---------------------------------------------------------------------------
+// The sequential (Parquet-shaped) payload.
+//
+// Per 1024-value block: the block minimum, the bit width needed for
+// (value - min), and the residuals as one continuous LSB-first stream. That is
+// the frame-of-reference PFOR layout Parquet's bit-packed pages use, and it is
+// deliberately the SAME per-block min and SAME per-block width the FastLanes
+// container picks, so the sequential and container arms decode the same values
+// at the same widths and the only difference is the physical layout.
+// ---------------------------------------------------------------------------
+struct SeqPayload {
+  std::vector<uint8_t> bytes;      // packed residuals, block-aligned
+  std::vector<uint32_t> offsets;   // byte offset of each block's residuals
+  std::vector<uint8_t> widths;
+  std::vector<int32_t> mins;
+};
+
+static uint32_t WidthFor(uint32_t span) {
+  uint32_t w = 0;
+  while (w < 32 && (w == 32 || (span >> w) != 0)) ++w;
+  return w;
+}
+
+static SeqPayload EncodeSequential(const std::vector<int32_t>& v) {
+  const size_t nblocks = v.size() / kBlk;
+  SeqPayload p;
+  p.widths.resize(nblocks);
+  p.mins.resize(nblocks);
+  p.offsets.resize(nblocks);
+  // Blocks are byte-aligned so each block can be handed to unpack_bias
+  // independently -- which is also how a real page decoder walks them.
+  size_t off = 0;
+  for (size_t b = 0; b < nblocks; ++b) {
+    int32_t mn = v[b * kBlk], mx = v[b * kBlk];
+    for (size_t t = 1; t < kBlk; ++t) {
+      mn = std::min(mn, v[b * kBlk + t]);
+      mx = std::max(mx, v[b * kBlk + t]);
+    }
+    const uint32_t span = static_cast<uint32_t>(mx) - static_cast<uint32_t>(mn);
+    const uint32_t w = WidthFor(span);
+    p.widths[b] = static_cast<uint8_t>(w);
+    p.mins[b] = mn;
+    p.offsets[b] = static_cast<uint32_t>(off);
+    off += w * kBlk / 8;
+  }
+  p.bytes.assign(off + 64, 0);
+  for (size_t b = 0; b < nblocks; ++b) {
+    const uint32_t w = p.widths[b];
+    if (w == 0) continue;
+    uint8_t* out = p.bytes.data() + p.offsets[b];
+    uint64_t acc = 0;
+    int bits = 0;
+    for (size_t t = 0; t < kBlk; ++t) {
+      const uint32_t r = static_cast<uint32_t>(v[b * kBlk + t]) -
+                         static_cast<uint32_t>(p.mins[b]);
+      acc |= static_cast<uint64_t>(r) << bits;
+      bits += static_cast<int>(w);
+      while (bits >= 8) {
+        *out++ = static_cast<uint8_t>(acc);
+        acc >>= 8;
+        bits -= 8;
+      }
+    }
+    if (bits) *out = static_cast<uint8_t>(acc);
+  }
+  return p;
+}
+
+// One process-wide, 4096-aligned arena. EVERY buffer this harness touches --
+// all three input payloads and all output slices -- is carved out of it at a
+// 4096-byte-aligned offset.
+//
+// The earlier version shared only the OUTPUT buffer and let each arm's input be
+// its own std::vector. That left input-address-mod-4096 free to vary between
+// arms and, worse, to vary with working set, because the allocator returns
+// differently-placed blocks as the request grows. It produced a ratio that
+// swung from 1.36x to 0.47x between two ADJACENT bit widths (11 vs 12) on
+// datasets of identical shape, at the largest point and nowhere else -- an
+// address artifact reported as a memory-hierarchy result.
+static uint8_t* Arena(size_t bytes) {
+  static uint8_t* buf = nullptr;
+  static size_t cap = 0;
+  if (bytes > cap) {
+    free(buf);
+    void* raw = nullptr;
+    if (posix_memalign(&raw, 4096, bytes + 4096) != 0) abort();
+    memset(raw, 0, bytes + 4096);
+    buf = static_cast<uint8_t*>(raw);
+    cap = bytes;
+  }
+  return buf;
+}
+static constexpr size_t RoundUpPage(size_t n) { return (n + 4095) & ~size_t(4095); }
+
+// ---------------------------------------------------------------------------
+// Arms
+// ---------------------------------------------------------------------------
+template <bool kScalar>
+static void DecodeSeq(const SeqPayload& p, const uint8_t* base, size_t n, int32_t* out) {
+  arrow::internal::UnpackOptions o;
+  o.batch_size = static_cast<int>(kBlk);
+  const size_t nblocks = n / kBlk;
+  for (size_t b = 0; b < nblocks; ++b) {
+    const uint32_t w = p.widths[b];
+    uint32_t* dst = reinterpret_cast<uint32_t*>(out) + b * kBlk;
+    const uint32_t bias = static_cast<uint32_t>(p.mins[b]);
+    if (w == 0) {
+      for (size_t t = 0; t < kBlk; ++t) dst[t] = bias;
+      continue;
+    }
+    o.bit_width = static_cast<int>(w);
+    // The vectorized kernel over-reads by design and stops short of any byte it
+    // has not been told is readable, so leaving max_read_bytes at its -1 default
+    // pushes the tail of EVERY vector onto a one-value-at-a-time scalar epilog.
+    // A block needs exactly 128*w bytes, which is what -1 deduces, so quoting
+    // 128*w here would change nothing: the bound has to name bytes PAST the
+    // block for the last vector step to be allowed. A real reader can, and does
+    // -- the packed stream continues to the end of the page -- so what is passed
+    // is the distance from this block to the end of the payload, the same
+    // quantity the production decoder derives from its page span.
+    const size_t readable = p.bytes.size() - p.offsets[b];
+    o.max_read_bytes = static_cast<int>(
+        std::min<size_t>(readable, static_cast<size_t>(std::numeric_limits<int>::max())));
+    if (kScalar) {
+      bp::unpack_jump<KernelScalar, /*kHasBias=*/true>(
+          base + p.offsets[b], dst, o, bias);
+    } else {
+      arrow::internal::unpack_bias<uint32_t>(base + p.offsets[b], dst, o, bias);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Reporting
+// ---------------------------------------------------------------------------
+struct Row {
+  std::string dataset;
+  const char* point;
+  size_t n;
+  double gibs[6];
+  double cr;       // 32 / mean bits per value, from the container encoding
+  double avg_w;
+  double src_mib;  // distinct packed bytes streamed
+  double dst_mib;  // distinct output bytes written
+};
+
+static constexpr int kArms = 6;
+static const char* kArm[kArms] = {"seq_scal", "seq_simd", "intlv",
+                                  "fl_unpk", "fl_tpos", "pure_st"};
+
+struct Dataset {
+  const char* name;
+  std::vector<int32_t> (*gen)(int64_t);
+};
+
+#define D(Name) {#Name, corpus::Gen##Name}
+#define DS(Name) {#Name, corpus::delta_shapes::Gen##Name<int32_t>}
+static const Dataset kDatasets[] = {
+    // ClickBench-inspired
+    D(ClientIP), D(UrlRegionID), D(CounterID), D(EventDate), D(EventTime),
+    D(GoodEvent), D(HID), D(HitColor), D(IPNetworkID), D(JavaEnable), D(OS),
+    D(Resolution), D(TrafficSourceID), D(UserAgent),
+    // TPC-DS
+    D(TpcdsSoldDateSk), D(TpcdsStoreSk), D(TpcdsItemSk), D(TpcdsQuantity),
+    D(TpcdsCustomerSk), D(TpcdsExtSalesPrice), D(TpcdsNetProfit), D(TpcdsDYear),
+    // TPC-H
+    D(TpchLQuantity), D(TpchLExtendedPrice), D(TpchLDiscount), D(TpchLShipDate),
+    // NYC taxi
+    D(TaxiPickupUnixTime), D(TaxiTripDistanceX100), D(TaxiFareCents),
+    // correlated / sorted
+    D(SortedUnixTime), D(SortedKeyDups), D(MonotoneRowId), D(NearSortedUnixTime),
+    // shapes with structure between neighbouring values
+    DS(TrendJitter), DS(Sawtooth), {"MeasurementSeries", corpus::delta_shapes::GenMeasurement<int32_t>},
+    DS(SortedKeys), DS(SensorDropouts), DS(IdsWithGaps), DS(RandomWalk),
+    DS(EventMillis), DS(LowSentinel), DS(Bimodal),
+};
+#undef D
+#undef DS
+static constexpr size_t kNumDatasets = sizeof(kDatasets) / sizeof(kDatasets[0]);
+
+int main(int argc, char** argv) {
+  // The ladder is built around the unit a Parquet reader actually decodes: one
+  // data page, which defaults to 1 MiB of ENCODED bytes and is therefore always
+  // small. A 32-MiB decode call does not occur in any reader, so growing `n` to
+  // 32 MiB does not model "out of cache" -- it models nothing.
+  //
+  // What genuinely does leave cache is the STREAM: a scan walks page after page
+  // and never revisits one, so every page's input is cold however small the page
+  // is. So this ladder holds the decode call at page scale and grows the stream
+  // instead, by rotating over `src_copies` distinct copies of the payload. It
+  // also names both footprints on every line, because labelling a row by its
+  // output size while the input moves too is how the previous ladder produced a
+  // number nobody could attribute.
+  struct Point {
+    const char* name;
+    size_t n;           // values per decode call -- the page-scale decode unit
+    size_t src_target;  // bytes of DISTINCT packed input to rotate over (0 = one copy)
+    size_t dst_target;  // bytes of DISTINCT output to rotate over (0 = one copy)
+  };
+  const Point kPoints[] = {
+      {"page16k", 4 * kBlk, 0, 0},
+      {"page256k", 64 * kBlk, 0, 0},
+      {"page1m", 256 * kBlk, 0, 0},               // ~1 MiB out: a full default page
+      {"scan4m", 256 * kBlk, 4ull << 20, 0},      // same page, 4 MiB of cold source
+      {"scan48m", 256 * kBlk, 48ull << 20, 0},    // same page, source past this L3
+      {"batch48m", 256 * kBlk, 0, 48ull << 20},   // same page, destination past L3
+  };
+
+  const char* only = (argc > 1) ? argv[1] : nullptr;
+  const char* csv_path = (argc > 2) ? argv[2] : nullptr;
+  FILE* csv = csv_path ? fopen(csv_path, "w") : nullptr;
+  if (csv)
+    fprintf(csv,
+            "dataset,point,n,avg_bit_width,cr,src_mib,dst_mib,seq_scal,seq_simd,"
+            "intlv,fl_unpk,fl_tpos,pure_st\n");
+
+  printf("# fl5_corpus -- bit-unpacking only, no delta anywhere\n");
+  printf("# five decode arms plus a store ceiling, best-of-%d\n", kReps);
+  printf("# pure_st writes the same bytes to the same place with no unpacking,\n"
+         "# so it is the ceiling the other five are read against.\n");
+#ifdef ARROW_FASTLANES_FUSED_FL_UNPACK
+  printf("# fl_tpos: FUSED in-register transpose (UnpackBlockFlToFileOrder)\n");
+#else
+  printf("# fl_tpos: UNFUSED fallback -- UnpackBlock into a 4 KiB scratch grid,\n"
+         "#          then Transpose32x32 out of it. No fused kernel on this target,\n"
+         "#          so this arm is a LOWER BOUND and not the layout's real cost.\n");
+#endif
+  printf("# %zu datasets x %zu working sets\n#\n", kNumDatasets,
+         sizeof(kPoints) / sizeof(kPoints[0]));
+
+  const char* hdr_fmt =
+      "%-22s %-9s %5s %5s %8s %8s | %8s %8s %8s %8s %8s %8s |"
+      " %8s %8s %8s %8s %8s %8s\n";
+  printf(hdr_fmt, "dataset", "point", "W", "cr", "srcMiB", "dstMiB", kArm[0], kArm[1],
+         kArm[2], kArm[3], kArm[4], kArm[5], "unpk/sc", "unpk/sd", "unpk/int",
+         "tpos/sd", "sd/ceil", "int/ceil");
+  std::string dashes(184, '-');
+  printf("%s\n", dashes.c_str());
+
+  std::vector<Row> rows;
+  for (size_t d = 0; d < kNumDatasets; ++d) {
+    const Dataset& ds = kDatasets[d];
+    if (only && *only && strcmp(only, "all") != 0 && strstr(ds.name, only) == nullptr)
+      continue;
+
+    for (const Point& pt : kPoints) {
+      const size_t n = pt.n;
+      const std::vector<int32_t> values = ds.gen(static_cast<int64_t>(n));
+      if (values.size() != n) {
+        fprintf(stderr, "generator %s returned %zu for n=%zu\n", ds.name,
+                values.size(), n);
+        return 1;
+      }
+
+      const SeqPayload seq = EncodeSequential(values);
+      std::vector<uint8_t> ib(fl::InterleavedPforMaxEncodedSize(n));
+      std::vector<uint8_t> fb(fl::InterleavedPforMaxEncodedSize(n));
+      const size_t ib_len =
+          fl::InterleavedPforEncode<InterleavedPforOrder::kFileOrder>(values.data(), n,
+                                                                     ib.data());
+      const size_t fb_len =
+          fl::InterleavedPforEncode<InterleavedPforOrder::kFlOrder>(values.data(), n,
+                                                                   fb.data());
+      if (ib_len == 0 || fb_len == 0) {
+        fprintf(stderr, "encode failed for %s\n", ds.name);
+        return 1;
+      }
+      if (ib_len != fb_len) {
+        fprintf(stderr, "WARNING %s: interleaved and FL_ORDER wire sizes differ "
+                        "(%zu vs %zu) -- these arms are not decoding the same "
+                        "number of bytes\n", ds.name, ib_len, fb_len);
+      }
+
+      double avg_w = 0;
+      for (uint8_t w : seq.widths) avg_w += w;
+      avg_w /= static_cast<double>(seq.widths.size());
+
+      // --- one arena, every buffer page-aligned inside it ---------------------
+      // All three payload strides are page-rounded, so copy k of each arm's
+      // input sits at the same offset mod 4096. Input placement is therefore
+      // held fixed across arms and across working sets instead of being left to
+      // the allocator.
+      // Strides are page-rounded and then SKEWED by one page. Without the skew a
+      // 1 MiB output slice stride is an exact power of two, so every slice maps
+      // onto the same cache sets and the largest point measures set conflicts
+      // rather than bandwidth -- it read 0.36x on one column and 1.55x on
+      // another of the same width. One page of skew walks the set index forward
+      // per slice and costs 0.4% of footprint.
+      const size_t kSkew = 4096;
+      const size_t seq_stride = RoundUpPage(seq.bytes.size()) + kSkew;
+      const size_t ib_stride = RoundUpPage(ib_len) + kSkew;
+      const size_t fb_stride = RoundUpPage(fb_len) + kSkew;
+      const size_t out_stride = RoundUpPage(n * sizeof(int32_t)) + kSkew;
+      auto copies_for = [](size_t target, size_t unit) {
+        return (target == 0 || unit == 0) ? size_t{1}
+                                          : std::max<size_t>(1, (target + unit - 1) / unit);
+      };
+      // The source footprint is set by the largest of the three payloads so all
+      // three arms stream the same number of distinct bytes.
+      const size_t src_unit = std::max(seq_stride, std::max(ib_stride, fb_stride));
+      const size_t src_copies = copies_for(pt.src_target, src_unit);
+      const size_t dst_copies = copies_for(pt.dst_target, out_stride);
+
+      uint8_t* arena = Arena(src_copies * (seq_stride + ib_stride + fb_stride) +
+                             dst_copies * out_stride);
+      // The output goes first, so out_base is the same address for every dataset
+      // and every point. Placing it after the payloads made its offset a
+      // function of the payload sizes, which is a per-dataset variable in a
+      // measurement that is supposed to hold placement fixed.
+      int32_t* out_base = reinterpret_cast<int32_t*>(arena);
+      uint8_t* seq_base = arena + dst_copies * out_stride;
+      uint8_t* ib_base = seq_base + src_copies * seq_stride;
+      uint8_t* fb_base = ib_base + src_copies * ib_stride;
+      for (size_t k = 0; k < src_copies; ++k) {
+        memcpy(seq_base + k * seq_stride, seq.bytes.data(), seq.bytes.size());
+        memcpy(ib_base + k * ib_stride, ib.data(), ib_len);
+        memcpy(fb_base + k * fb_stride, fb.data(), fb_len);
+      }
+      const double src_mib =
+          static_cast<double>(src_copies * src_unit) / (1024.0 * 1024);
+      const double dst_mib =
+          static_cast<double>(dst_copies * out_stride) / (1024.0 * 1024);
+
+      // Each arm decodes copy (it % src_copies) into slice (it % dst_copies), so
+      // a "scan" point really does touch distinct cold bytes every iteration.
+      auto slot_out = [&](size_t it) {
+        return reinterpret_cast<int32_t*>(reinterpret_cast<uint8_t*>(out_base) +
+                                         (it % dst_copies) * out_stride);
+      };
+      auto a_seq_scal = [&](size_t it) {
+        DecodeSeq<true>(seq, seq_base + (it % src_copies) * seq_stride, n, slot_out(it));
+      };
+      auto a_seq_simd = [&](size_t it) {
+        DecodeSeq<false>(seq, seq_base + (it % src_copies) * seq_stride, n, slot_out(it));
+      };
+      auto a_intlv = [&](size_t it) {
+        fl::InterleavedPforDecode<InterleavedPforOrder::kFileOrder>(
+            ib_base + (it % src_copies) * ib_stride, n, slot_out(it));
+      };
+      auto a_fl_unpk = [&](size_t it) {
+        fl::InterleavedPforDecode<InterleavedPforOrder::kFlOrderRaw>(
+            fb_base + (it % src_copies) * fb_stride, n, slot_out(it));
+      };
+      auto a_fl_tpos = [&](size_t it) {
+        fl::InterleavedPforDecode<InterleavedPforOrder::kFlOrder>(
+            fb_base + (it % src_copies) * fb_stride, n, slot_out(it));
+      };
+      // Speed of light. Writes the same n int32s to the same rotating destination
+      // slice with no unpacking whatsoever, so it is the ceiling every other arm
+      // is measured against. It reads nothing from the packed source, which is
+      // exactly why it is a ceiling and not a sixth decoder: at the scan points
+      // the other arms are also paying for a cold source stream this arm never
+      // touches. `bias + t` varies per element on purpose -- a constant store
+      // would let the compiler call memset, which may pick rep-stos or a
+      // non-temporal path, and non-temporal stores measured 0.85x of ordinary
+      // ones here. The loop is one add per vector of stores, negligible against
+      // the store stream itself.
+      auto a_pure_st = [&](size_t it) {
+        uint32_t* dst = reinterpret_cast<uint32_t*>(slot_out(it));
+        for (size_t b = 0; b < n / kBlk; ++b) {
+          const uint32_t bias = static_cast<uint32_t>(seq.mins[b]);
+          uint32_t* q = dst + b * kBlk;
+          for (size_t t = 0; t < kBlk; ++t) q[t] = bias + static_cast<uint32_t>(t);
+        }
+      };
+      std::function<void(size_t)> arms[kArms] = {a_seq_scal, a_seq_simd, a_intlv,
+                                                a_fl_unpk,  a_fl_tpos,  a_pure_st};
+      int32_t* out = out_base;
+
+      // --- correctness before speed -----------------------------------------
+      // Four of the five decode arms must reproduce `values` exactly. fl_unpk
+      // returns FL order on purpose, so it is checked against the FL_ORDER
+      // permutation of `values` instead. pure_st is a store ceiling, not a
+      // decoder, and is exempt.
+      for (int a = 0; a < kArms; ++a) {
+        memset(out, 0xCD, n * sizeof(int32_t));
+        arms[a](0);
+        if (a == 3) continue;  // fl_unpk: order-agnostic, checked below
+        if (a == 5) continue;  // pure_st: a ceiling, not a decoder -- writes no
+                               //          meaningful values by construction
+        if (memcmp(out, values.data(), n * sizeof(int32_t)) != 0) {
+          size_t bad = 0;
+          while (bad < n && out[bad] == values[bad]) ++bad;
+          fprintf(stderr, "MISMATCH %s/%s arm=%s at %zu: got %d want %d\n", ds.name,
+                  pt.name, kArm[a], bad, out[bad], values[bad]);
+          return 1;
+        }
+      }
+      {
+        // fl_unpk must equal the FL_ORDER permutation of the input: for each
+        // block, lane l holds the contiguous run [32l, 32l+32).
+        memset(out, 0xCD, n * sizeof(int32_t));
+        a_fl_unpk(0);
+        for (size_t b = 0; b < n / kBlk; ++b) {
+          for (size_t lane = 0; lane < 32; ++lane) {
+            for (size_t r = 0; r < 32; ++r) {
+              const int32_t got = out[b * kBlk + r * 32 + lane];
+              const int32_t want = values[b * kBlk + lane * 32 + r];
+              if (got != want) {
+                fprintf(stderr, "MISMATCH %s/%s arm=fl_unpk blk=%zu lane=%zu row=%zu: "
+                                "got %d want %d\n", ds.name, pt.name, b, lane, r, got,
+                        want);
+                return 1;
+              }
+            }
+          }
+        }
+      }
+
+      // --- timing -----------------------------------------------------------
+      // Every timed run moves ~1 GiB of output regardless of working set, so the
+      // shortest run (L1, fastest arm) is still ~10 ms. The arms alternate
+      // within each repetition, so drift or thermal effects hit all of them alike.
+      // Enough iterations to move ~1 GiB and to visit every distinct copy.
+      const size_t iters = std::max(std::max(src_copies, dst_copies),
+                                    std::max<size_t>(3, kBytesPerRun / (n * 4)));
+      double best[kArms] = {0, 0, 0, 0, 0, 0};
+      for (int rep = 0; rep < kReps; ++rep) {
+        for (int a = 0; a < kArms; ++a) {
+          for (size_t k = 0; k < std::max(src_copies, dst_copies); ++k) arms[a](k);  // warm
+          const auto t0 = Clock::now();
+          for (size_t it = 0; it < iters; ++it) arms[a](it);
+          const auto t1 = Clock::now();
+          const double secs = std::chrono::duration<double>(t1 - t0).count();
+          const double gibs =
+              static_cast<double>(iters) * n * 4 / secs / (1024.0 * 1024 * 1024);
+          best[a] = std::max(best[a], gibs);
+        }
+      }
+
+      Row row;
+      row.dataset = ds.name;
+      row.point = pt.name;
+      row.n = n;
+      for (int a = 0; a < kArms; ++a) row.gibs[a] = best[a];
+      row.avg_w = avg_w;
+      row.src_mib = src_mib;
+      row.dst_mib = dst_mib;
+      row.cr = static_cast<double>(n) * 4 / static_cast<double>(fb_len);
+      rows.push_back(row);
+
+      printf("%-22s %-9s %5.1f %5.2f %8.2f %8.2f | %8.1f %8.1f %8.1f %8.1f %8.1f"
+             " %8.1f | %7.2fx %7.2fx %7.2fx %7.2fx %7.0f%% %7.0f%%\n",
+             ds.name, pt.name, avg_w, row.cr, src_mib, dst_mib, best[0], best[1],
+             best[2], best[3], best[4], best[5], best[3] / best[0], best[3] / best[1],
+             best[3] / best[2], best[4] / best[1], 100 * best[1] / best[5],
+             100 * best[2] / best[5]);
+      fflush(stdout);
+      if (csv) {
+        fprintf(csv,
+                "%s,%s,%zu,%.2f,%.4f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n",
+                ds.name, pt.name, n, avg_w, row.cr, src_mib, dst_mib, best[0], best[1],
+                best[2], best[3], best[4], best[5]);
+        fflush(csv);
+      }
+    }
+  }
+
+  // --- geomeans per working set --------------------------------------------
+  printf("%s\n", dashes.c_str());
+  for (const Point& pt : kPoints) {
+    double g[kArms] = {1, 1, 1, 1, 1, 1};
+    int cnt = 0;
+    for (const Row& r : rows) {
+      if (strcmp(r.point, pt.name) != 0) continue;
+      for (int a = 0; a < kArms; ++a) g[a] *= r.gibs[a];
+      ++cnt;
+    }
+    if (cnt == 0) continue;
+    double m[kArms];
+    for (int a = 0; a < kArms; ++a) m[a] = std::pow(g[a], 1.0 / cnt);
+    printf("%-22s %-9s %5s %5s %8s %8s | %8.1f %8.1f %8.1f %8.1f %8.1f %8.1f |"
+           " %7.2fx %7.2fx %7.2fx %7.2fx %7.0f%% %7.0f%%   (n=%d)\n",
+           "GEOMEAN", pt.name, "", "", "", "", m[0], m[1], m[2], m[3], m[4], m[5],
+           m[3] / m[0], m[3] / m[1], m[3] / m[2], m[4] / m[1], 100 * m[1] / m[5],
+           100 * m[2] / m[5], cnt);
+  }
+
+  // The validity check, stated as a pass/fail rather than left to the reader.
+  printf("\nvalidity: fl_unpk/intlv must be 1.00x (same PackBlock/UnpackBlock)\n");
+  bool validity_failed = false;
+  for (const Point& pt : kPoints) {
+    double worst = 1.0;
+    std::string worst_ds;
+    int cnt = 0;
+    double lg = 0;
+    for (const Row& r : rows) {
+      if (strcmp(r.point, pt.name) != 0) continue;
+      const double q = r.gibs[3] / r.gibs[2];
+      lg += std::log(q);
+      ++cnt;
+      if (std::fabs(std::log(q)) > std::fabs(std::log(worst))) {
+        worst = q;
+        worst_ds = r.dataset;
+      }
+    }
+    if (cnt == 0) continue;
+    const double gm = std::exp(lg / cnt);
+    const bool pass = std::fabs(std::log(worst)) < std::log(1.05);
+    printf("  %-9s geomean %.3fx   worst %.3fx on %-20s  %s\n", pt.name, gm, worst,
+           worst_ds.c_str(), pass ? "PASS" : "FAIL");
+    if (!pass) validity_failed = true;
+  }
+  if (validity_failed) {
+    printf("\nVALIDITY FAILED: fl_unpk and intlv run the same kernel over the same\n"
+           "byte count and must tie within 5%%. A point where they do not is\n"
+           "measuring its own buffer placement, not the layout. Do not quote it.\n");
+  }
+  if (csv) fclose(csv);
+  return validity_failed ? 2 : 0;
+}
diff --git a/fl5_corpus/fl5_corpus_x86.csv b/fl5_corpus/fl5_corpus_x86.csv
new file mode 100644
index 000000000000..33141e63e652
--- /dev/null
+++ b/fl5_corpus/fl5_corpus_x86.csv
@@ -0,0 +1,130 @@
+dataset,point,n,avg_bit_width,cr,seq_scal,seq_simd,intlv,fl_unpk,fl_tpos
+ClientIP,L1,4096,32.00,0.9988,82.750,71.179,77.774,77.578,66.613
+ClientIP,L2,102400,32.00,0.9988,45.884,45.854,47.412,47.407,38.271
+ClientIP,DRAM,8388608,32.00,0.9988,13.870,13.991,13.847,13.847,13.920
+UrlRegionID,L1,4096,10.00,3.1875,11.006,38.592,94.236,94.346,51.676
+UrlRegionID,L2,102400,10.00,3.1875,11.004,36.124,51.015,50.937,47.988
+UrlRegionID,DRAM,8388608,10.00,3.1875,10.458,21.190,21.200,21.188,20.633
+CounterID,L1,4096,12.00,2.6580,12.551,40.266,98.778,98.905,51.843
+CounterID,L2,102400,12.00,2.6580,12.573,37.024,49.235,49.499,42.820
+CounterID,DRAM,8388608,12.00,2.6580,12.258,20.225,20.183,20.171,19.826
+EventDate,L1,4096,3.00,10.5296,16.092,18.464,106.186,107.274,54.482
+EventDate,L2,102400,3.00,10.5296,16.045,17.980,54.810,54.908,53.807
+EventDate,DRAM,8388608,3.00,10.5296,14.482,15.719,25.475,25.452,23.831
+EventTime,L1,4096,17.00,1.8780,12.619,35.171,80.593,80.547,47.760
+EventTime,L2,102400,17.00,1.8780,12.793,34.998,47.122,47.334,43.273
+EventTime,DRAM,8388608,17.00,1.8780,11.903,18.279,18.216,18.221,17.915
+GoodEvent,L1,4096,1.00,30.7970,16.378,85.728,112.049,112.155,55.808
+GoodEvent,L2,102400,1.00,30.7970,16.328,56.177,56.812,56.916,55.676
+GoodEvent,DRAM,8388608,1.00,30.7970,14.553,26.637,26.947,26.961,25.345
+HID,L1,4096,32.00,0.9988,85.963,72.173,77.883,77.548,68.559
+HID,L2,102400,32.00,0.9988,46.535,46.460,44.870,45.729,34.796
+HID,DRAM,8388608,32.00,0.9988,13.810,13.971,13.781,13.804,13.918
+HitColor,L1,4096,3.00,10.5296,16.230,18.361,106.526,107.143,54.523
+HitColor,L2,102400,3.00,10.5296,16.046,18.030,54.799,55.005,53.787
+HitColor,DRAM,8388608,3.00,10.5296,14.487,15.778,25.450,25.461,23.866
+IPNetworkID,L1,4096,14.00,2.2794,10.201,36.477,88.628,88.631,49.821
+IPNetworkID,L2,102400,14.00,2.2794,10.211,35.848,49.982,49.930,42.974
+IPNetworkID,DRAM,8388608,14.00,2.2794,9.762,19.379,19.363,19.368,18.919
+JavaEnable,L1,4096,1.00,30.7970,16.384,85.802,111.766,112.297,55.823
+JavaEnable,L2,102400,1.00,30.7970,16.317,56.227,56.870,56.930,55.663
+JavaEnable,DRAM,8388608,1.00,30.7970,14.772,26.631,26.967,26.963,25.339
+OS,L1,4096,5.00,6.3504,14.610,28.302,102.607,102.149,53.341
+OS,L2,102400,5.00,6.3504,14.623,26.906,53.327,53.139,51.433
+OS,DRAM,8388608,5.00,6.3504,13.564,20.757,24.124,24.134,22.765
+Resolution,L1,4096,11.00,2.8988,13.695,34.064,88.013,88.643,50.357
+Resolution,L2,102400,11.00,2.8988,14.049,34.284,50.371,50.222,47.482
+Resolution,DRAM,8388608,11.00,2.8988,13.089,20.618,20.753,20.764,20.214
+TrafficSourceID,L1,4096,4.00,7.9226,12.685,47.504,101.525,101.551,56.136
+TrafficSourceID,L2,102400,4.00,7.9226,12.726,41.759,53.044,53.048,52.387
+TrafficSourceID,DRAM,8388608,4.00,7.9226,12.692,23.904,24.493,24.489,23.332
+UserAgent,L1,4096,7.00,4.5461,14.819,31.829,97.971,97.917,52.041
+UserAgent,L2,102400,7.00,4.5461,14.802,30.797,52.066,51.930,48.455
+UserAgent,DRAM,8388608,7.00,4.5461,13.489,22.726,22.867,22.858,21.793
+TpcdsSoldDateSk,L1,4096,11.00,2.8988,13.927,34.510,87.248,89.041,50.337
+TpcdsSoldDateSk,L2,102400,11.00,2.8988,13.866,34.275,50.396,50.548,47.765
+TpcdsSoldDateSk,DRAM,8388608,11.00,2.8988,12.907,20.609,20.746,20.757,20.216
+TpcdsStoreSk,L1,4096,10.00,3.1875,11.024,39.114,91.648,92.860,50.883
+TpcdsStoreSk,L2,102400,10.00,3.1875,11.016,36.420,51.149,50.951,47.983
+TpcdsStoreSk,DRAM,8388608,10.00,3.1875,10.181,21.142,21.171,21.163,20.619
+TpcdsItemSk,L1,4096,17.00,1.8780,12.583,34.926,80.962,80.864,47.686
+TpcdsItemSk,L2,102400,17.00,1.8780,12.686,34.930,47.218,47.357,43.296
+TpcdsItemSk,DRAM,8388608,17.00,1.8780,11.651,18.229,18.168,18.161,17.915
+TpcdsQuantity,L1,4096,7.00,4.5461,14.841,32.693,98.365,98.324,52.171
+TpcdsQuantity,L2,102400,7.00,4.5461,14.654,30.786,52.117,51.966,48.464
+TpcdsQuantity,DRAM,8388608,7.00,4.5461,13.570,22.752,22.871,22.869,21.833
+TpcdsCustomerSk,L1,4096,21.00,1.5210,11.810,34.244,71.354,71.653,46.452
+TpcdsCustomerSk,L2,102400,21.00,1.5210,11.791,32.638,45.722,45.925,39.180
+TpcdsCustomerSk,DRAM,8388608,21.00,1.5210,10.822,16.884,16.784,16.788,16.637
+TpcdsExtSalesPrice,L1,4096,15.75,2.0267,12.997,50.362,95.292,95.353,53.939
+TpcdsExtSalesPrice,L2,102400,15.75,2.0267,12.994,44.630,50.604,50.491,42.357
+TpcdsExtSalesPrice,DRAM,8388608,15.76,2.0250,12.318,18.707,18.656,18.721,18.271
+TpcdsNetProfit,L1,4096,19.00,1.6808,11.777,34.699,74.227,75.526,46.941
+TpcdsNetProfit,L2,102400,19.00,1.6808,11.983,33.827,46.564,46.539,39.945
+TpcdsNetProfit,DRAM,8388608,19.00,1.6808,11.184,17.557,17.473,17.478,17.293
+TpcdsDYear,L1,4096,3.00,10.5296,16.188,18.405,106.444,107.280,54.529
+TpcdsDYear,L2,102400,3.00,10.5296,16.088,18.029,54.764,54.915,53.802
+TpcdsDYear,DRAM,8388608,3.00,10.5296,14.487,15.781,25.471,25.461,23.874
+TpchLQuantity,L1,4096,6.00,5.2988,11.754,30.931,100.080,101.240,53.484
+TpchLQuantity,L2,102400,6.00,5.2988,11.684,28.822,52.082,52.223,50.715
+TpchLQuantity,DRAM,8388608,6.00,5.2988,11.020,23.351,23.392,23.395,22.289
+TpchLExtendedPrice,L1,4096,24.00,1.3312,11.097,38.661,65.712,65.391,45.891
+TpchLExtendedPrice,L2,102400,24.00,1.3312,11.057,37.035,43.199,45.179,39.696
+TpchLExtendedPrice,DRAM,8388608,24.00,1.3312,10.772,15.980,15.917,15.923,15.789
+TpchLDiscount,L1,4096,4.00,7.9226,12.694,47.688,101.694,101.611,56.227
+TpchLDiscount,L2,102400,4.00,7.9226,12.730,42.685,53.129,52.740,52.118
+TpchLDiscount,DRAM,8388608,4.00,7.9226,12.697,23.913,24.490,24.498,23.318
+TpchLShipDate,L1,4096,12.00,2.6580,12.534,40.234,98.886,99.008,51.835
+TpchLShipDate,L2,102400,12.00,2.6580,12.573,36.950,49.263,49.557,42.717
+TpchLShipDate,DRAM,8388608,12.00,2.6580,12.388,20.241,20.208,20.202,19.838
+TaxiPickupUnixTime,L1,4096,22.00,1.4520,9.712,36.056,68.333,66.917,46.041
+TaxiPickupUnixTime,L2,102400,22.00,1.4520,9.613,33.307,45.901,45.821,39.172
+TaxiPickupUnixTime,DRAM,8388608,22.00,1.4520,8.892,16.569,16.461,16.466,16.313
+TaxiTripDistanceX100,L1,4096,11.00,2.8988,13.849,34.093,88.262,88.761,50.351
+TaxiTripDistanceX100,L2,102400,10.97,2.9067,14.645,34.289,50.190,50.399,47.603
+TaxiTripDistanceX100,DRAM,8388608,10.98,2.9039,13.080,20.640,20.772,20.780,20.207
+TaxiFareCents,L1,4096,13.25,2.4080,13.320,36.645,85.261,85.537,49.058
+TaxiFareCents,L2,102400,13.22,2.4134,13.398,34.996,49.655,49.479,42.429
+TaxiFareCents,DRAM,8388608,13.24,2.4094,11.943,19.692,19.636,19.713,19.319
+SortedUnixTime,L1,4096,12.00,2.6580,12.532,40.283,98.678,98.900,51.784
+SortedUnixTime,L2,102400,12.00,2.6580,12.579,37.123,49.272,49.556,42.714
+SortedUnixTime,DRAM,8388608,12.00,2.6580,12.384,20.230,20.222,20.234,19.834
+SortedKeyDups,L1,4096,9.75,3.2690,11.805,38.491,93.719,94.184,50.902
+SortedKeyDups,L2,102400,9.50,3.3546,12.636,35.019,51.220,51.201,46.984
+SortedKeyDups,DRAM,8388608,9.50,3.3556,11.809,21.436,21.371,21.402,20.817
+MonotoneRowId,L1,4096,10.00,3.1875,11.003,38.792,92.818,93.917,50.199
+MonotoneRowId,L2,102400,10.00,3.1875,10.984,36.047,50.973,50.783,48.070
+MonotoneRowId,DRAM,8388608,10.00,3.1875,10.386,21.207,21.174,21.178,20.621
+NearSortedUnixTime,L1,4096,13.00,2.4542,14.322,36.481,86.379,85.224,48.572
+NearSortedUnixTime,L2,102400,13.00,2.4542,14.179,36.595,49.883,49.833,42.503
+NearSortedUnixTime,DRAM,8388608,13.00,2.4542,12.620,19.834,19.858,19.863,19.419
+TrendJitter,L1,4096,12.00,2.6580,12.557,39.887,99.089,99.143,50.698
+TrendJitter,L2,102400,12.00,2.6580,12.590,37.132,49.255,49.573,42.751
+TrendJitter,DRAM,8388608,12.00,2.6580,12.434,20.243,20.233,20.237,19.834
+Sawtooth,L1,4096,12.00,2.6580,12.544,40.351,98.876,99.368,51.490
+Sawtooth,L2,102400,12.00,2.6580,12.586,37.271,49.293,49.650,42.756
+Sawtooth,DRAM,8388608,12.00,2.6580,12.431,20.234,20.215,20.226,19.828
+MeasurementSeries,L1,4096,16.50,1.9348,12.907,43.902,90.179,90.014,52.180
+MeasurementSeries,L2,102400,16.44,1.9419,12.886,40.123,49.845,48.830,42.026
+MeasurementSeries,DRAM,8388608,16.47,1.9378,11.656,18.444,18.276,18.265,18.044
+SortedKeys,L1,4096,14.25,2.2395,13.149,36.455,83.295,83.375,49.104
+SortedKeys,L2,102400,9.54,3.3406,13.098,37.829,50.395,50.210,46.243
+SortedKeys,DRAM,8388608,3.27,9.6764,13.110,19.603,25.183,25.187,23.815
+SensorDropouts,L1,4096,21.00,1.5210,11.801,34.406,71.379,71.216,46.111
+SensorDropouts,L2,102400,21.00,1.5210,11.747,32.637,45.498,45.701,39.141
+SensorDropouts,DRAM,8388608,21.52,1.4844,9.584,16.690,16.570,16.559,16.464
+IdsWithGaps,L1,4096,19.25,1.6590,12.066,34.871,79.298,79.367,46.841
+IdsWithGaps,L2,102400,19.32,1.6530,11.763,33.243,47.414,47.146,39.762
+IdsWithGaps,DRAM,8388608,19.24,1.6595,10.818,17.452,17.194,17.216,17.218
+RandomWalk,L1,4096,10.00,3.1875,12.690,37.053,91.519,92.555,50.777
+RandomWalk,L2,102400,10.02,3.1812,11.604,36.021,51.038,50.594,47.613
+RandomWalk,DRAM,8388608,9.96,3.1997,11.123,21.193,21.139,21.140,20.627
+EventMillis,L1,4096,12.00,2.6580,12.483,39.808,99.020,99.159,51.104
+EventMillis,L2,102400,12.00,2.6580,12.581,36.947,49.248,49.541,42.672
+EventMillis,DRAM,8388608,12.00,2.6580,12.385,20.249,20.224,20.213,19.837
+LowSentinel,L1,4096,18.00,1.7739,9.846,34.766,82.678,77.940,47.167
+LowSentinel,L2,102400,17.99,1.7749,9.725,34.333,47.592,47.692,41.107
+LowSentinel,DRAM,8388608,17.99,1.7745,8.681,17.794,17.794,17.794,17.564
+Bimodal,L1,4096,20.00,1.5969,11.639,35.065,74.407,73.846,47.926
+Bimodal,L2,102400,20.00,1.5969,11.655,33.377,46.523,46.724,39.317
+Bimodal,DRAM,8388608,20.00,1.5969,10.851,17.105,17.100,17.095,16.961
diff --git a/fl5_corpus/fl5_corpus_x86.txt b/fl5_corpus/fl5_corpus_x86.txt
new file mode 100644
index 000000000000..a7dbe527f7e0
--- /dev/null
+++ b/fl5_corpus/fl5_corpus_x86.txt
@@ -0,0 +1,146 @@
+# fl5_corpus -- bit-unpacking only, no delta anywhere
+# five arms, one shared 4096-aligned output buffer, best-of-5
+# fl_tpos: FUSED in-register transpose (UnpackBlockFlToFileOrder)
+# 43 datasets x 3 working sets
+#
+dataset                point     W    cr | seq_scal seq_simd    intlv  fl_unpk  fl_tpos |  unpk/sc  unpk/sd unpk/int  tpos/sd
+--------------------------------------------------------------------------------------------------------------------------------------------
+ClientIP               L1     32.0  1.00 |     82.7     71.2     77.8     77.6     66.6 |    0.94x    1.09x    1.00x    0.94x
+ClientIP               L2     32.0  1.00 |     45.9     45.9     47.4     47.4     38.3 |    1.03x    1.03x    1.00x    0.83x
+ClientIP               DRAM   32.0  1.00 |     13.9     14.0     13.8     13.8     13.9 |    1.00x    0.99x    1.00x    0.99x
+UrlRegionID            L1     10.0  3.19 |     11.0     38.6     94.2     94.3     51.7 |    8.57x    2.44x    1.00x    1.34x
+UrlRegionID            L2     10.0  3.19 |     11.0     36.1     51.0     50.9     48.0 |    4.63x    1.41x    1.00x    1.33x
+UrlRegionID            DRAM   10.0  3.19 |     10.5     21.2     21.2     21.2     20.6 |    2.03x    1.00x    1.00x    0.97x
+CounterID              L1     12.0  2.66 |     12.6     40.3     98.8     98.9     51.8 |    7.88x    2.46x    1.00x    1.29x
+CounterID              L2     12.0  2.66 |     12.6     37.0     49.2     49.5     42.8 |    3.94x    1.34x    1.01x    1.16x
+CounterID              DRAM   12.0  2.66 |     12.3     20.2     20.2     20.2     19.8 |    1.65x    1.00x    1.00x    0.98x
+EventDate              L1      3.0 10.53 |     16.1     18.5    106.2    107.3     54.5 |    6.67x    5.81x    1.01x    2.95x
+EventDate              L2      3.0 10.53 |     16.0     18.0     54.8     54.9     53.8 |    3.42x    3.05x    1.00x    2.99x
+EventDate              DRAM    3.0 10.53 |     14.5     15.7     25.5     25.5     23.8 |    1.76x    1.62x    1.00x    1.52x
+EventTime              L1     17.0  1.88 |     12.6     35.2     80.6     80.5     47.8 |    6.38x    2.29x    1.00x    1.36x
+EventTime              L2     17.0  1.88 |     12.8     35.0     47.1     47.3     43.3 |    3.70x    1.35x    1.00x    1.24x
+EventTime              DRAM   17.0  1.88 |     11.9     18.3     18.2     18.2     17.9 |    1.53x    1.00x    1.00x    0.98x
+GoodEvent              L1      1.0 30.80 |     16.4     85.7    112.0    112.2     55.8 |    6.85x    1.31x    1.00x    0.65x
+GoodEvent              L2      1.0 30.80 |     16.3     56.2     56.8     56.9     55.7 |    3.49x    1.01x    1.00x    0.99x
+GoodEvent              DRAM    1.0 30.80 |     14.6     26.6     26.9     27.0     25.3 |    1.85x    1.01x    1.00x    0.95x
+HID                    L1     32.0  1.00 |     86.0     72.2     77.9     77.5     68.6 |    0.90x    1.07x    1.00x    0.95x
+HID                    L2     32.0  1.00 |     46.5     46.5     44.9     45.7     34.8 |    0.98x    0.98x    1.02x    0.75x
+HID                    DRAM   32.0  1.00 |     13.8     14.0     13.8     13.8     13.9 |    1.00x    0.99x    1.00x    1.00x
+HitColor               L1      3.0 10.53 |     16.2     18.4    106.5    107.1     54.5 |    6.60x    5.84x    1.01x    2.97x
+HitColor               L2      3.0 10.53 |     16.0     18.0     54.8     55.0     53.8 |    3.43x    3.05x    1.00x    2.98x
+HitColor               DRAM    3.0 10.53 |     14.5     15.8     25.4     25.5     23.9 |    1.76x    1.61x    1.00x    1.51x
+IPNetworkID            L1     14.0  2.28 |     10.2     36.5     88.6     88.6     49.8 |    8.69x    2.43x    1.00x    1.37x
+IPNetworkID            L2     14.0  2.28 |     10.2     35.8     50.0     49.9     43.0 |    4.89x    1.39x    1.00x    1.20x
+IPNetworkID            DRAM   14.0  2.28 |      9.8     19.4     19.4     19.4     18.9 |    1.98x    1.00x    1.00x    0.98x
+JavaEnable             L1      1.0 30.80 |     16.4     85.8    111.8    112.3     55.8 |    6.85x    1.31x    1.00x    0.65x
+JavaEnable             L2      1.0 30.80 |     16.3     56.2     56.9     56.9     55.7 |    3.49x    1.01x    1.00x    0.99x
+JavaEnable             DRAM    1.0 30.80 |     14.8     26.6     27.0     27.0     25.3 |    1.83x    1.01x    1.00x    0.95x
+OS                     L1      5.0  6.35 |     14.6     28.3    102.6    102.1     53.3 |    6.99x    3.61x    1.00x    1.88x
+OS                     L2      5.0  6.35 |     14.6     26.9     53.3     53.1     51.4 |    3.63x    1.97x    1.00x    1.91x
+OS                     DRAM    5.0  6.35 |     13.6     20.8     24.1     24.1     22.8 |    1.78x    1.16x    1.00x    1.10x
+Resolution             L1     11.0  2.90 |     13.7     34.1     88.0     88.6     50.4 |    6.47x    2.60x    1.01x    1.48x
+Resolution             L2     11.0  2.90 |     14.0     34.3     50.4     50.2     47.5 |    3.57x    1.46x    1.00x    1.38x
+Resolution             DRAM   11.0  2.90 |     13.1     20.6     20.8     20.8     20.2 |    1.59x    1.01x    1.00x    0.98x
+TrafficSourceID        L1      4.0  7.92 |     12.7     47.5    101.5    101.6     56.1 |    8.01x    2.14x    1.00x    1.18x
+TrafficSourceID        L2      4.0  7.92 |     12.7     41.8     53.0     53.0     52.4 |    4.17x    1.27x    1.00x    1.25x
+TrafficSourceID        DRAM    4.0  7.92 |     12.7     23.9     24.5     24.5     23.3 |    1.93x    1.02x    1.00x    0.98x
+UserAgent              L1      7.0  4.55 |     14.8     31.8     98.0     97.9     52.0 |    6.61x    3.08x    1.00x    1.64x
+UserAgent              L2      7.0  4.55 |     14.8     30.8     52.1     51.9     48.5 |    3.51x    1.69x    1.00x    1.57x
+UserAgent              DRAM    7.0  4.55 |     13.5     22.7     22.9     22.9     21.8 |    1.69x    1.01x    1.00x    0.96x
+TpcdsSoldDateSk        L1     11.0  2.90 |     13.9     34.5     87.2     89.0     50.3 |    6.39x    2.58x    1.02x    1.46x
+TpcdsSoldDateSk        L2     11.0  2.90 |     13.9     34.3     50.4     50.5     47.8 |    3.65x    1.47x    1.00x    1.39x
+TpcdsSoldDateSk        DRAM   11.0  2.90 |     12.9     20.6     20.7     20.8     20.2 |    1.61x    1.01x    1.00x    0.98x
+TpcdsStoreSk           L1     10.0  3.19 |     11.0     39.1     91.6     92.9     50.9 |    8.42x    2.37x    1.01x    1.30x
+TpcdsStoreSk           L2     10.0  3.19 |     11.0     36.4     51.1     51.0     48.0 |    4.63x    1.40x    1.00x    1.32x
+TpcdsStoreSk           DRAM   10.0  3.19 |     10.2     21.1     21.2     21.2     20.6 |    2.08x    1.00x    1.00x    0.98x
+TpcdsItemSk            L1     17.0  1.88 |     12.6     34.9     81.0     80.9     47.7 |    6.43x    2.32x    1.00x    1.37x
+TpcdsItemSk            L2     17.0  1.88 |     12.7     34.9     47.2     47.4     43.3 |    3.73x    1.36x    1.00x    1.24x
+TpcdsItemSk            DRAM   17.0  1.88 |     11.7     18.2     18.2     18.2     17.9 |    1.56x    1.00x    1.00x    0.98x
+TpcdsQuantity          L1      7.0  4.55 |     14.8     32.7     98.4     98.3     52.2 |    6.63x    3.01x    1.00x    1.60x
+TpcdsQuantity          L2      7.0  4.55 |     14.7     30.8     52.1     52.0     48.5 |    3.55x    1.69x    1.00x    1.57x
+TpcdsQuantity          DRAM    7.0  4.55 |     13.6     22.8     22.9     22.9     21.8 |    1.69x    1.01x    1.00x    0.96x
+TpcdsCustomerSk        L1     21.0  1.52 |     11.8     34.2     71.4     71.7     46.5 |    6.07x    2.09x    1.00x    1.36x
+TpcdsCustomerSk        L2     21.0  1.52 |     11.8     32.6     45.7     45.9     39.2 |    3.89x    1.41x    1.00x    1.20x
+TpcdsCustomerSk        DRAM   21.0  1.52 |     10.8     16.9     16.8     16.8     16.6 |    1.55x    0.99x    1.00x    0.99x
+TpcdsExtSalesPrice     L1     15.8  2.03 |     13.0     50.4     95.3     95.4     53.9 |    7.34x    1.89x    1.00x    1.07x
+TpcdsExtSalesPrice     L2     15.8  2.03 |     13.0     44.6     50.6     50.5     42.4 |    3.89x    1.13x    1.00x    0.95x
+TpcdsExtSalesPrice     DRAM   15.8  2.02 |     12.3     18.7     18.7     18.7     18.3 |    1.52x    1.00x    1.00x    0.98x
+TpcdsNetProfit         L1     19.0  1.68 |     11.8     34.7     74.2     75.5     46.9 |    6.41x    2.18x    1.02x    1.35x
+TpcdsNetProfit         L2     19.0  1.68 |     12.0     33.8     46.6     46.5     39.9 |    3.88x    1.38x    1.00x    1.18x
+TpcdsNetProfit         DRAM   19.0  1.68 |     11.2     17.6     17.5     17.5     17.3 |    1.56x    1.00x    1.00x    0.99x
+TpcdsDYear             L1      3.0 10.53 |     16.2     18.4    106.4    107.3     54.5 |    6.63x    5.83x    1.01x    2.96x
+TpcdsDYear             L2      3.0 10.53 |     16.1     18.0     54.8     54.9     53.8 |    3.41x    3.05x    1.00x    2.98x
+TpcdsDYear             DRAM    3.0 10.53 |     14.5     15.8     25.5     25.5     23.9 |    1.76x    1.61x    1.00x    1.51x
+TpchLQuantity          L1      6.0  5.30 |     11.8     30.9    100.1    101.2     53.5 |    8.61x    3.27x    1.01x    1.73x
+TpchLQuantity          L2      6.0  5.30 |     11.7     28.8     52.1     52.2     50.7 |    4.47x    1.81x    1.00x    1.76x
+TpchLQuantity          DRAM    6.0  5.30 |     11.0     23.4     23.4     23.4     22.3 |    2.12x    1.00x    1.00x    0.95x
+TpchLExtendedPrice     L1     24.0  1.33 |     11.1     38.7     65.7     65.4     45.9 |    5.89x    1.69x    1.00x    1.19x
+TpchLExtendedPrice     L2     24.0  1.33 |     11.1     37.0     43.2     45.2     39.7 |    4.09x    1.22x    1.05x    1.07x
+TpchLExtendedPrice     DRAM   24.0  1.33 |     10.8     16.0     15.9     15.9     15.8 |    1.48x    1.00x    1.00x    0.99x
+TpchLDiscount          L1      4.0  7.92 |     12.7     47.7    101.7    101.6     56.2 |    8.00x    2.13x    1.00x    1.18x
+TpchLDiscount          L2      4.0  7.92 |     12.7     42.7     53.1     52.7     52.1 |    4.14x    1.24x    0.99x    1.22x
+TpchLDiscount          DRAM    4.0  7.92 |     12.7     23.9     24.5     24.5     23.3 |    1.93x    1.02x    1.00x    0.98x
+TpchLShipDate          L1     12.0  2.66 |     12.5     40.2     98.9     99.0     51.8 |    7.90x    2.46x    1.00x    1.29x
+TpchLShipDate          L2     12.0  2.66 |     12.6     36.9     49.3     49.6     42.7 |    3.94x    1.34x    1.01x    1.16x
+TpchLShipDate          DRAM   12.0  2.66 |     12.4     20.2     20.2     20.2     19.8 |    1.63x    1.00x    1.00x    0.98x
+TaxiPickupUnixTime     L1     22.0  1.45 |      9.7     36.1     68.3     66.9     46.0 |    6.89x    1.86x    0.98x    1.28x
+TaxiPickupUnixTime     L2     22.0  1.45 |      9.6     33.3     45.9     45.8     39.2 |    4.77x    1.38x    1.00x    1.18x
+TaxiPickupUnixTime     DRAM   22.0  1.45 |      8.9     16.6     16.5     16.5     16.3 |    1.85x    0.99x    1.00x    0.98x
+TaxiTripDistanceX100   L1     11.0  2.90 |     13.8     34.1     88.3     88.8     50.4 |    6.41x    2.60x    1.01x    1.48x
+TaxiTripDistanceX100   L2     11.0  2.91 |     14.6     34.3     50.2     50.4     47.6 |    3.44x    1.47x    1.00x    1.39x
+TaxiTripDistanceX100   DRAM   11.0  2.90 |     13.1     20.6     20.8     20.8     20.2 |    1.59x    1.01x    1.00x    0.98x
+TaxiFareCents          L1     13.2  2.41 |     13.3     36.6     85.3     85.5     49.1 |    6.42x    2.33x    1.00x    1.34x
+TaxiFareCents          L2     13.2  2.41 |     13.4     35.0     49.7     49.5     42.4 |    3.69x    1.41x    1.00x    1.21x
+TaxiFareCents          DRAM   13.2  2.41 |     11.9     19.7     19.6     19.7     19.3 |    1.65x    1.00x    1.00x    0.98x
+SortedUnixTime         L1     12.0  2.66 |     12.5     40.3     98.7     98.9     51.8 |    7.89x    2.46x    1.00x    1.29x
+SortedUnixTime         L2     12.0  2.66 |     12.6     37.1     49.3     49.6     42.7 |    3.94x    1.33x    1.01x    1.15x
+SortedUnixTime         DRAM   12.0  2.66 |     12.4     20.2     20.2     20.2     19.8 |    1.63x    1.00x    1.00x    0.98x
+SortedKeyDups          L1      9.8  3.27 |     11.8     38.5     93.7     94.2     50.9 |    7.98x    2.45x    1.00x    1.32x
+SortedKeyDups          L2      9.5  3.35 |     12.6     35.0     51.2     51.2     47.0 |    4.05x    1.46x    1.00x    1.34x
+SortedKeyDups          DRAM    9.5  3.36 |     11.8     21.4     21.4     21.4     20.8 |    1.81x    1.00x    1.00x    0.97x
+MonotoneRowId          L1     10.0  3.19 |     11.0     38.8     92.8     93.9     50.2 |    8.54x    2.42x    1.01x    1.29x
+MonotoneRowId          L2     10.0  3.19 |     11.0     36.0     51.0     50.8     48.1 |    4.62x    1.41x    1.00x    1.33x
+MonotoneRowId          DRAM   10.0  3.19 |     10.4     21.2     21.2     21.2     20.6 |    2.04x    1.00x    1.00x    0.97x
+NearSortedUnixTime     L1     13.0  2.45 |     14.3     36.5     86.4     85.2     48.6 |    5.95x    2.34x    0.99x    1.33x
+NearSortedUnixTime     L2     13.0  2.45 |     14.2     36.6     49.9     49.8     42.5 |    3.51x    1.36x    1.00x    1.16x
+NearSortedUnixTime     DRAM   13.0  2.45 |     12.6     19.8     19.9     19.9     19.4 |    1.57x    1.00x    1.00x    0.98x
+TrendJitter            L1     12.0  2.66 |     12.6     39.9     99.1     99.1     50.7 |    7.90x    2.49x    1.00x    1.27x
+TrendJitter            L2     12.0  2.66 |     12.6     37.1     49.3     49.6     42.8 |    3.94x    1.34x    1.01x    1.15x
+TrendJitter            DRAM   12.0  2.66 |     12.4     20.2     20.2     20.2     19.8 |    1.63x    1.00x    1.00x    0.98x
+Sawtooth               L1     12.0  2.66 |     12.5     40.4     98.9     99.4     51.5 |    7.92x    2.46x    1.00x    1.28x
+Sawtooth               L2     12.0  2.66 |     12.6     37.3     49.3     49.6     42.8 |    3.94x    1.33x    1.01x    1.15x
+Sawtooth               DRAM   12.0  2.66 |     12.4     20.2     20.2     20.2     19.8 |    1.63x    1.00x    1.00x    0.98x
+MeasurementSeries      L1     16.5  1.93 |     12.9     43.9     90.2     90.0     52.2 |    6.97x    2.05x    1.00x    1.19x
+MeasurementSeries      L2     16.4  1.94 |     12.9     40.1     49.8     48.8     42.0 |    3.79x    1.22x    0.98x    1.05x
+MeasurementSeries      DRAM   16.5  1.94 |     11.7     18.4     18.3     18.3     18.0 |    1.57x    0.99x    1.00x    0.98x
+SortedKeys             L1     14.2  2.24 |     13.1     36.5     83.3     83.4     49.1 |    6.34x    2.29x    1.00x    1.35x
+SortedKeys             L2      9.5  3.34 |     13.1     37.8     50.4     50.2     46.2 |    3.83x    1.33x    1.00x    1.22x
+SortedKeys             DRAM    3.3  9.68 |     13.1     19.6     25.2     25.2     23.8 |    1.92x    1.28x    1.00x    1.21x
+SensorDropouts         L1     21.0  1.52 |     11.8     34.4     71.4     71.2     46.1 |    6.03x    2.07x    1.00x    1.34x
+SensorDropouts         L2     21.0  1.52 |     11.7     32.6     45.5     45.7     39.1 |    3.89x    1.40x    1.00x    1.20x
+SensorDropouts         DRAM   21.5  1.48 |      9.6     16.7     16.6     16.6     16.5 |    1.73x    0.99x    1.00x    0.99x
+IdsWithGaps            L1     19.2  1.66 |     12.1     34.9     79.3     79.4     46.8 |    6.58x    2.28x    1.00x    1.34x
+IdsWithGaps            L2     19.3  1.65 |     11.8     33.2     47.4     47.1     39.8 |    4.01x    1.42x    0.99x    1.20x
+IdsWithGaps            DRAM   19.2  1.66 |     10.8     17.5     17.2     17.2     17.2 |    1.59x    0.99x    1.00x    0.99x
+RandomWalk             L1     10.0  3.19 |     12.7     37.1     91.5     92.6     50.8 |    7.29x    2.50x    1.01x    1.37x
+RandomWalk             L2     10.0  3.18 |     11.6     36.0     51.0     50.6     47.6 |    4.36x    1.40x    0.99x    1.32x
+RandomWalk             DRAM   10.0  3.20 |     11.1     21.2     21.1     21.1     20.6 |    1.90x    1.00x    1.00x    0.97x
+EventMillis            L1     12.0  2.66 |     12.5     39.8     99.0     99.2     51.1 |    7.94x    2.49x    1.00x    1.28x
+EventMillis            L2     12.0  2.66 |     12.6     36.9     49.2     49.5     42.7 |    3.94x    1.34x    1.01x    1.15x
+EventMillis            DRAM   12.0  2.66 |     12.4     20.2     20.2     20.2     19.8 |    1.63x    1.00x    1.00x    0.98x
+LowSentinel            L1     18.0  1.77 |      9.8     34.8     82.7     77.9     47.2 |    7.92x    2.24x    0.94x    1.36x
+LowSentinel            L2     18.0  1.77 |      9.7     34.3     47.6     47.7     41.1 |    4.90x    1.39x    1.00x    1.20x
+LowSentinel            DRAM   18.0  1.77 |      8.7     17.8     17.8     17.8     17.6 |    2.05x    1.00x    1.00x    0.99x
+Bimodal                L1     20.0  1.60 |     11.6     35.1     74.4     73.8     47.9 |    6.34x    2.11x    0.99x    1.37x
+Bimodal                L2     20.0  1.60 |     11.7     33.4     46.5     46.7     39.3 |    4.01x    1.40x    1.00x    1.18x
+Bimodal                DRAM   20.0  1.60 |     10.9     17.1     17.1     17.1     17.0 |    1.58x    1.00x    1.00x    0.99x
+--------------------------------------------------------------------------------------------------------------------------------------------
+GEOMEAN                L1                |     14.0     37.9     89.9     90.0     51.4 |    6.45x    2.37x    1.00x    1.36x   (n=43)
+GEOMEAN                L2                |     13.6     34.9     49.9     50.0     45.0 |    3.68x    1.43x    1.00x    1.29x   (n=43)
+GEOMEAN                DRAM              |     12.0     19.4     20.3     20.3     19.7 |    1.68x    1.04x    1.00x    1.02x   (n=43)
+
+validity: fl_unpk/intlv must be 1.00x (same PackBlock/UnpackBlock)
+  L1    geomean 1.001x   worst 0.943x on LowSentinel
+  L2    geomean 1.002x   worst 1.046x on TpchLExtendedPrice
+  DRAM  geomean 1.000x   worst 1.004x on TaxiFareCents
+EXIT=0
diff --git a/fl5_corpus/gen_tables.py b/fl5_corpus/gen_tables.py
new file mode 100644
index 000000000000..2ee94bd9bc74
--- /dev/null
+++ b/fl5_corpus/gen_tables.py
@@ -0,0 +1,126 @@
+import csv, math, sys
+from collections import OrderedDict
+
+OUT = sys.argv[1]
+rows = list(csv.DictReader(open("fl5_corpus_x86.csv")))
+ARMS = ["seq_scal", "seq_simd", "intlv", "fl_unpk", "fl_tpos"]
+POINTS = ["L1", "L2", "DRAM"]
+
+by_ds = OrderedDict()
+for r in rows:
+    by_ds.setdefault(r["dataset"], {})[r["point"]] = r
+
+def gm(vals):
+    return math.exp(sum(math.log(v) for v in vals) / len(vals))
+
+# ---- geomeans per point ----
+G = {}
+for p in POINTS:
+    sel = [by_ds[d][p] for d in by_ds if p in by_ds[d]]
+    G[p] = {a: gm([float(r[a]) for r in sel]) for a in ARMS}
+    G[p]["n"] = len(sel)
+    # sign counts: how many datasets have the ratio above 1.0
+    G[p]["win_intlv"] = sum(1 for r in sel if float(r["intlv"]) > float(r["seq_simd"]))
+    G[p]["win_tpos"]  = sum(1 for r in sel if float(r["fl_tpos"]) > float(r["seq_simd"]))
+    G[p]["min_intlv"] = min(float(r["intlv"]) / float(r["seq_simd"]) for r in sel)
+    G[p]["max_intlv"] = max(float(r["intlv"]) / float(r["seq_simd"]) for r in sel)
+
+NDS = G["L2"]["n"]
+CAL = {"L1": 1.27, "L2": 1.27, "DRAM": 1.00}
+
+out = []
+w = out.append
+
+w('\n<h2 id="s8">8. Results: the geomeans</h2>\n')
+w('<p>Geometric mean across %d real columns, GiB/s measured on <em>output</em> bytes (4 bytes per\n'
+  'value decoded), higher is better. Ratios are against <code>seq_simd</code>, the arm that\n'
+  'represents what Parquet decodes at today.</p>\n' % NDS)
+w('<div class="tablewrap">\n<table>\n')
+w('<caption>Table 2. Geometric mean over %d columns. The <code>fl_unpk/intlv</code> column is the\n'
+  'self-check described in Table 1: two arms running identical kernel code on identically-shaped\n'
+  'grids, which must and do agree. <b>The ratios in this table are raw and the L1/L2 rows are\n'
+  'inflated &mdash; see &sect;10 before quoting them.</b></caption>\n' % NDS)
+w('<thead>\n<tr><th>Working set</th>')
+for a in ARMS: w('<th class="num">%s</th>' % a)
+w('<th class="num">intlv<br>/seq_simd</th><th class="num">fl_tpos<br>/seq_simd</th>'
+  '<th class="num">fl_unpk<br>/intlv</th></tr>\n</thead>\n<tbody>\n')
+LBL = {"L1": "L1 &mdash; 16 KiB", "L2": "L2 &mdash; 400 KiB", "DRAM": "DRAM &mdash; 32 MiB"}
+for p in POINTS:
+    g = G[p]
+    w('<tr><td>%s</td>' % LBL[p])
+    for a in ARMS: w('<td class="num">%.1f</td>' % g[a])
+    w('<td class="num"><b>%.2fx</b></td><td class="num">%.2fx</td><td class="num">%.3fx</td></tr>\n'
+      % (g["intlv"]/g["seq_simd"], g["fl_tpos"]/g["seq_simd"], g["fl_unpk"]/g["intlv"]))
+w('</tbody>\n</table>\n</div>\n')
+
+w('<p>Two things in that table matter more than the headline ratios.</p>\n')
+w('<p><b>First, the DRAM row.</b> At a 32 MiB working set every layout converges: %.1f, %.1f, %.1f,\n'
+  '%.1f, %.1f GiB/s across the five arms, a spread of %.0f%% between the fastest and slowest of the\n'
+  'four SIMD arms. The kernel is no longer instruction-bound, it is waiting on memory, and no\n'
+  'arrangement of bits changes how fast DRAM delivers them. Any claim about layout is implicitly a\n'
+  'claim about cache-resident decoding.</p>\n'
+  % (G["DRAM"]["seq_scal"], G["DRAM"]["seq_simd"], G["DRAM"]["intlv"], G["DRAM"]["fl_unpk"],
+     G["DRAM"]["fl_tpos"],
+     100 * (max(G["DRAM"][a] for a in ARMS[1:]) / min(G["DRAM"][a] for a in ARMS[1:]) - 1)))
+w('<p><b>Second, the scalar column.</b> <code>seq_simd</code> beats <code>seq_scal</code> by\n'
+  '%.2fx at L1 and %.2fx at L2. That gap is the one the FastLanes paper\'s "order of magnitude" is\n'
+  'largely measuring &mdash; it is the cost of not vectorising at all, and Arrow already collected\n'
+  'it years ago. The layout question is what remains <em>after</em> that, and it is a much smaller\n'
+  'number.</p>\n' % (G["L1"]["seq_simd"]/G["L1"]["seq_scal"], G["L2"]["seq_simd"]/G["L2"]["seq_scal"]))
+
+w('<h3>How consistent is it across columns?</h3>\n')
+w('<div class="tablewrap">\n<table>\n')
+w('<caption>Table 3. Per-column consistency of the layout effect, raw. "Wins" counts columns where\n'
+  'the arm is strictly faster than <code>seq_simd</code>.</caption>\n')
+w('<thead>\n<tr><th>Working set</th><th class="num">intlv wins</th><th class="num">fl_tpos wins</th>'
+  '<th class="num">min intlv/seq_simd</th><th class="num">max intlv/seq_simd</th></tr>\n</thead>\n<tbody>\n')
+for p in POINTS:
+    g = G[p]
+    w('<tr><td>%s</td><td class="num">%d / %d</td><td class="num">%d / %d</td>'
+      '<td class="num">%.2fx</td><td class="num">%.2fx</td></tr>\n'
+      % (LBL[p], g["win_intlv"], g["n"], g["win_tpos"], g["n"], g["min_intlv"], g["max_intlv"]))
+w('</tbody>\n</table>\n</div>\n')
+w('<p>At L1 the interleaved container is faster on every single column; at L2 on all but one; at\n'
+  'DRAM on barely half, which is what "bandwidth-bound" looks like in a sign test. The direction of\n'
+  'the effect is not in doubt at L1 and L2. Its magnitude is what &sect;10 corrects.</p>\n')
+
+# ---- big per-dataset table ----
+w('\n<h2 id="s9">9. Results: %d columns &times; L1 / L2 / DRAM</h2>\n' % NDS)
+w('<p>Every measurement, unaggregated. <code>W</code> is the mean per-block bit width the encoder\n'
+  'chose for that column and <code>CR</code> its compression ratio &mdash; together they explain most\n'
+  'of the variation between rows. Speeds are GiB/s on output bytes; the best of the four SIMD arms in\n'
+  'each row is shown in bold. Ratios are raw; see &sect;10.</p>\n')
+w('<div class="tablewrap">\n<table>\n')
+w('<caption>Table 4. All %d columns at all three working sets. Sources: ClickBench, TPC-H, and the\n'
+  'Public BI benchmark corpus. Rows are ordered by mean bit width, because that is the variable the\n'
+  'effect tracks (&sect;11).</caption>\n' % NDS)
+w('<thead>\n<tr><th>Column</th><th class="num">W</th><th class="num">CR</th><th>Set</th>')
+for a in ARMS: w('<th class="num">%s</th>' % a)
+w('<th class="num">intlv<br>/seq_simd</th><th class="num">fl_tpos<br>/seq_simd</th></tr>\n</thead>\n<tbody>\n')
+
+order = sorted(by_ds, key=lambda d: (float(by_ds[d]["L2"]["avg_bit_width"]), d))
+for d in order:
+    pts = by_ds[d]
+    ref = pts["L2"]
+    for k, p in enumerate(POINTS):
+        if p not in pts: continue
+        r = pts[p]
+        w('<tr>')
+        if k == 0:
+            w('<td rowspan="3">%s</td><td class="num" rowspan="3">%.1f</td>'
+              '<td class="num" rowspan="3">%.2f</td>'
+              % (d, float(ref["avg_bit_width"]), float(ref["cr"])))
+        w('<td>%s</td>' % p)
+        vals = {a: float(r[a]) for a in ARMS}
+        best = max(vals[a] for a in ARMS[1:])
+        for a in ARMS:
+            v = vals[a]
+            cell = '%.1f' % v
+            if a != "seq_scal" and v == best: cell = '<b>%s</b>' % cell
+            w('<td class="num">%s</td>' % cell)
+        w('<td class="num">%.2fx</td><td class="num">%.2fx</td></tr>\n'
+          % (vals["intlv"]/vals["seq_simd"], vals["fl_tpos"]/vals["seq_simd"]))
+w('</tbody>\n</table>\n</div>\n')
+
+open(OUT, "a").write("".join(out))
+print("appended %d bytes; %d datasets" % (sum(len(x) for x in out), NDS))
diff --git a/fl5_corpus/seq_granularity.cpp b/fl5_corpus/seq_granularity.cpp
new file mode 100644
index 000000000000..7c871fa348d4
--- /dev/null
+++ b/fl5_corpus/seq_granularity.cpp
@@ -0,0 +1,101 @@
+// Does calling unpack_bias once per 1024-value block handicap the sequential arm?
+//
+// fl5_corpus calls it per block, because with real data every block picks its own
+// width and its own frame-of-reference minimum, so a page decoder has no choice.
+// But Arrow's own pfor.cc measures faster than that, and if the difference is
+// per-call overhead rather than the layout, then fl5's sequential column is unfair
+// and its headline ratio is inflated. Three arms, same bytes, same width:
+//
+//   per_block   one unpack_bias call per 1024 values, runtime width  (= fl5)
+//   whole_buf   one unpack_bias call for the entire buffer, runtime width
+//   per_blk_ct  one call per block but width a compile-time constant via
+//               unpack_jump<KernelDefault>, isolating dispatch from granularity
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <random>
+#include <vector>
+#include <functional>
+#include <xsimd/xsimd.hpp>
+#include <arrow/util/bpacking_internal.h>
+#include "arrow/util/bpacking_dispatch_internal.h"
+#include "arrow/util/bpacking_simd_internal.h"
+#include "arrow/util/bpacking_simd_kernel_internal.h"
+
+namespace bp = arrow::internal::bpacking;
+using Clock = std::chrono::steady_clock;
+template <typename U, int W>
+using KernelDefault = bp::Kernel<U, W, xsimd::default_arch>;
+
+template <uint32_t W>
+static void Run(size_t n, double* a, double* b, double* c) {
+  std::mt19937 rng(7 + W);
+  const uint32_t span = (W == 32) ? 0xFFFFFFFFu : ((1u << W) - 1);
+  std::vector<uint32_t> vals(n);
+  for (auto& v : vals) v = rng() & span;
+  std::vector<uint8_t> packed(n * W / 8 + 64, 0);
+  {
+    uint64_t acc = 0; int bits = 0; uint8_t* p = packed.data();
+    for (size_t i = 0; i < n; ++i) {
+      acc |= static_cast<uint64_t>(vals[i]) << bits; bits += W;
+      while (bits >= 8) { *p++ = static_cast<uint8_t>(acc); acc >>= 8; bits -= 8; }
+    }
+    if (bits) *p = static_cast<uint8_t>(acc);
+  }
+  void* raw; if (posix_memalign(&raw, 4096, n * 4 + 4096) != 0) abort();
+  uint32_t* out = static_cast<uint32_t*>(raw);
+
+  arrow::internal::UnpackOptions blk, all;
+  blk.batch_size = 1024; blk.bit_width = W;
+  all.batch_size = static_cast<int64_t>(n); all.bit_width = W;
+
+  auto per_block = [&] {
+    for (size_t i = 0; i < n; i += 1024)
+      arrow::internal::unpack_bias<uint32_t>(packed.data() + i * W / 8, out + i, blk, 5u);
+  };
+  auto whole_buf = [&] {
+    arrow::internal::unpack_bias<uint32_t>(packed.data(), out, all, 5u);
+  };
+  auto per_blk_ct = [&] {
+    for (size_t i = 0; i < n; i += 1024)
+      bp::unpack_jump<KernelDefault, true>(packed.data() + i * W / 8, out + i, blk, 5u);
+  };
+
+  const size_t iters = std::max<size_t>(3, (1024u * 1024 * 1024) / (n * 4));
+  double best[3] = {0, 0, 0};
+  for (int rep = 0; rep < 5; ++rep) {
+    int k = 0;
+    for (auto fn : {std::function<void()>(per_block), std::function<void()>(whole_buf),
+                    std::function<void()>(per_blk_ct)}) {
+      fn();
+      auto t0 = Clock::now();
+      for (size_t it = 0; it < iters; ++it) fn();
+      double s = std::chrono::duration<double>(Clock::now() - t0).count();
+      best[k] = std::max(best[k], (double)iters * n * 4 / s / (1 << 30));
+      ++k;
+    }
+  }
+  free(raw);
+  *a = best[0]; *b = best[1]; *c = best[2];
+}
+
+int main() {
+  struct P { const char* nm; size_t n; };
+  const P pts[] = {{"L1", 4096}, {"L2", 102400}, {"DRAM", 8u << 20}};
+  printf("%-5s %2s | %9s %9s %10s | %8s %8s\n", "point", "W", "per_block", "whole_buf",
+         "per_blk_ct", "whole/blk", "ct/blk");
+  for (const P& p : pts) {
+    double g[3] = {1, 1, 1}; int n = 0; double a, b, c;
+#define R(W) Run<W>(p.n, &a, &b, &c); \
+    printf("%-5s %2d | %9.1f %9.1f %10.1f | %7.2fx %7.2fx\n", p.nm, W, a, b, c, b/a, c/a); \
+    g[0]*=a; g[1]*=b; g[2]*=c; ++n;
+    R(1) R(4) R(7) R(11) R(12) R(18) R(20) R(24) R(31)
+#undef R
+    double m0=std::pow(g[0],1.0/n), m1=std::pow(g[1],1.0/n), m2=std::pow(g[2],1.0/n);
+    printf("%-5s gm | %9.1f %9.1f %10.1f | %7.2fx %7.2fx\n\n", p.nm, m0, m1, m2,
+           m1/m0, m2/m0);
+  }
+  return 0;
+}
diff --git a/fl5_corpus/seq_granularity.txt b/fl5_corpus/seq_granularity.txt
new file mode 100644
index 000000000000..a2ec05635c7e
--- /dev/null
+++ b/fl5_corpus/seq_granularity.txt
@@ -0,0 +1,34 @@
+point  W | per_block whole_buf per_blk_ct | whole/blk   ct/blk
+L1     1 |      82.7      90.6       77.1 |    1.10x    0.93x
+L1     4 |      47.5      72.5       50.0 |    1.53x    1.05x
+L1     7 |      32.2      54.0       31.4 |    1.67x    0.97x
+L1    11 |      34.1      44.6       35.1 |    1.31x    1.03x
+L1    12 |      40.1      55.6       40.7 |    1.39x    1.01x
+L1    18 |      34.8      39.4       35.2 |    1.13x    1.01x
+L1    20 |      35.1      39.6       35.5 |    1.13x    1.01x
+L1    24 |      38.7      46.5       39.1 |    1.20x    1.01x
+L1    31 |      27.3      30.9       27.8 |    1.13x    1.02x
+L1    gm |      39.3      50.1       39.5 |    1.27x    1.01x
+
+L2     1 |      57.9      57.0       56.8 |    0.99x    0.98x
+L2     4 |      42.3      54.7       43.3 |    1.29x    1.02x
+L2     7 |      30.4      53.0       30.2 |    1.74x    1.00x
+L2    11 |      34.0      49.1       34.6 |    1.44x    1.02x
+L2    12 |      37.1      50.5       37.2 |    1.36x    1.00x
+L2    18 |      34.1      41.5       34.4 |    1.22x    1.01x
+L2    20 |      33.1      41.1       33.1 |    1.24x    1.00x
+L2    24 |      37.2      43.1       38.0 |    1.16x    1.02x
+L2    31 |      26.7      31.0       27.2 |    1.16x    1.02x
+L2    gm |      36.1      46.1       36.4 |    1.27x    1.01x
+
+DRAM   1 |      27.0      26.9       26.7 |    1.00x    0.99x
+DRAM   4 |      24.1      24.8       24.2 |    1.03x    1.00x
+DRAM   7 |      22.9      22.9       22.8 |    1.00x    1.00x
+DRAM  11 |      20.7      20.9       20.8 |    1.01x    1.00x
+DRAM  12 |      20.3      20.4       20.3 |    1.00x    1.00x
+DRAM  18 |      17.9      17.9       17.9 |    1.00x    1.00x
+DRAM  20 |      17.3      17.2       17.3 |    1.00x    1.00x
+DRAM  24 |      16.0      16.0       16.0 |    1.00x    1.00x
+DRAM  31 |      14.2      14.2       14.2 |    1.00x    1.00x
+DRAM  gm |      19.7      19.8       19.7 |    1.00x    1.00x
+
diff --git a/run_transpose_ab.sh b/run_transpose_ab.sh
new file mode 100755
index 000000000000..a639840c6d3b
--- /dev/null
+++ b/run_transpose_ab.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# Wait for a quiet box, then run the AVX2-transpose A/B in ONE batch.
+# Four variants alternating so all of them see the same placement mode
+# (INTEL_RESULTS.md section 10b); cap pinned to AVX2 so the sequential control is
+# on Arrow's good kernel and not its AVX-512 pathology (section 10a).
+set -uo pipefail
+cd "$(dirname "${BASH_SOURCE[0]}")"
+./wait_quiet.sh || { echo "GAVE_UP_BUSY"; exit 1; }
+rm -rf /tmp/ab_tr; mkdir -p /tmp/ab_tr
+ROUNDS=3 REPS=3 CORE=2 OUT=/tmp/ab_tr ./ab_compare.sh \
+  fix_O2_256:AVX2 bench_tr_O2_256:AVX2 fix_O3_256:AVX2 bench_tr_O3_256:AVX2
+echo "TR_AB_DONE files=$(ls /tmp/ab_tr | wc -l)"
diff --git a/wait_quiet.sh b/wait_quiet.sh
new file mode 100755
index 000000000000..4bf4d4dcc013
--- /dev/null
+++ b/wait_quiet.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Block until the box is quiet enough to time on.
+#
+# Three conditions, because loadavg alone is not enough: it is a 1-minute
+# average and lags, and a benchmark that has just started shows a low load while
+# already owning a core. A parallel session shares this box, so "no compiler
+# running" and "no benchmark running" both have to hold.
+#
+# NOTE on pgrep: `pgrep -c` prints 0 AND exits 1 when nothing matches, so the
+# idiom `$(pgrep -c x || echo 0)` yields the two-line string "0\n0" and every
+# later [ -eq ] test dies with "integer expression expected". Assign, then
+# default.
+set -uo pipefail
+MAX=${MAX:-60}          # attempts
+SLEEP=${SLEEP:-30}
+for i in $(seq 1 "$MAX"); do
+  L=$(awk '{print $1}' /proc/loadavg); LI=${L%.*}
+  C=$(pgrep -c cc1plus 2>/dev/null); C=${C:-0}
+  B=$(pgrep -fc pfor-comparison-benchmark 2>/dev/null); B=${B:-0}
+  if [ "${LI:-9}" -lt 2 ] && [ "$C" -eq 0 ] && [ "$B" -eq 0 ]; then
+    echo "QUIET after $((i-1)) waits: load=$L cc1plus=$C bench=$B"; exit 0
+  fi
+  [ $((i % 4)) -eq 1 ] && echo "  waiting: load=$L cc1plus=$C bench=$B"
+  sleep "$SLEEP"
+done
+echo "STILL_BUSY: load=$(awk '{print $1}' /proc/loadavg)"; exit 1