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/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake
index c372f9f19898..49d1e3b1708d 100644
--- a/cpp/cmake_modules/DefineOptions.cmake
+++ b/cpp/cmake_modules/DefineOptions.cmake
@@ -194,6 +194,9 @@ takes precedence over ccache if a storage backend is configured" ON)
 
   define_option(ARROW_GGDB_DEBUG "Pass -ggdb flag to debug builds" ON)
 
+  define_option(ARROW_RELEASE_O3
+                "Keep CMake's default -O3 in Release builds instead of -O2" OFF)
+
   define_option(ARROW_WITH_MUSL "Whether the system libc is musl or not" OFF)
 
   define_option(ARROW_ENABLE_THREADING "Enable threading in Arrow core" ON)
diff --git a/cpp/cmake_modules/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake
index 21341167fe99..34baad5f55af 100644
--- a/cpp/cmake_modules/SetupCxxFlags.cmake
+++ b/cpp/cmake_modules/SetupCxxFlags.cmake
@@ -632,20 +632,25 @@ endif()
 #   Same as Release, except with debug symbols enabled.
 
 if(NOT MSVC)
+  # CMake's default Release flags are "-O3 -DNDEBUG"; the appends below
+  # downgrade them to -O2, since the last -O flag wins in GCC. Set
+  # ARROW_RELEASE_O3 to skip the downgrade: the bit-packing kernels are
+  # built around the inlining and unrolling -O3 enables, and the
+  # throughput figures quoted for them were measured with it in effect.
   set(C_RELEASE_FLAGS "")
-  if(CMAKE_C_FLAGS_RELEASE MATCHES "-O3")
+  if(CMAKE_C_FLAGS_RELEASE MATCHES "-O3" AND NOT ARROW_RELEASE_O3)
     string(APPEND C_RELEASE_FLAGS " -O2")
   endif()
   set(CXX_RELEASE_FLAGS "")
-  if(CMAKE_CXX_FLAGS_RELEASE MATCHES "-O3")
+  if(CMAKE_CXX_FLAGS_RELEASE MATCHES "-O3" AND NOT ARROW_RELEASE_O3)
     string(APPEND CXX_RELEASE_FLAGS " -O2")
   endif()
   set(C_RELWITHDEBINFO_FLAGS "")
-  if(CMAKE_C_FLAGS_RELWITHDEBINFO MATCHES "-O3")
+  if(CMAKE_C_FLAGS_RELWITHDEBINFO MATCHES "-O3" AND NOT ARROW_RELEASE_O3)
     string(APPEND C_RELWITHDEBINFO_FLAGS " -O2")
   endif()
   set(CXX_RELWITHDEBINFO_FLAGS "")
-  if(CMAKE_CXX_FLAGS_RELWITHDEBINFO MATCHES "-O3")
+  if(CMAKE_CXX_FLAGS_RELWITHDEBINFO MATCHES "-O3" AND NOT ARROW_RELEASE_O3)
     string(APPEND CXX_RELWITHDEBINFO_FLAGS " -O2")
   endif()
   if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 8750598f6c3b..6e4e90973456 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -551,6 +551,7 @@ set(ARROW_UTIL_SRCS
     util/decimal.cc
     util/delimiting.cc
     util/dict_util.cc
+    util/fastlanes/interleaved_pfor_baseline.cc
     util/fixed_width_internal.cc
     util/float16.cc
     util/formatting.cc
@@ -566,6 +567,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
@@ -591,6 +594,28 @@ append_runtime_avx512_src(ARROW_UTIL_SRCS util/bpacking_simd_avx512.cc)
 append_runtime_sve128_src(ARROW_UTIL_SRCS util/bpacking_simd_128_alt.cc)
 append_runtime_sve256_src(ARROW_UTIL_SRCS util/bpacking_simd_256.cc)
 
+# One source compiled once per instruction set, the way bpacking_simd_256.cc is
+# registered for both AVX2 and SVE256 above: the file forks on the platform
+# macros, and only one of them is ever defined on a given target.
+append_runtime_avx2_src(ARROW_UTIL_SRCS util/fastlanes/interleaved_pfor_simd.cc)
+append_runtime_sve128_src(ARROW_UTIL_SRCS util/fastlanes/interleaved_pfor_simd.cc)
+
+# The interleaved kernels are portable C++ with no intrinsics, so what they
+# compile to is decided by the optimizer, not by the source. At width 16 gcc 11.5
+# emits 289 instructions and no vector operations at -O2, 322 with 81 vector
+# operations at Release's -O2 -ftree-vectorize, and 849 with 513 at -O3; the
+# published throughput figures for this layout were all taken at the last of
+# those. APPEND rather than a plain set, because the two calls above have already
+# put the instruction-set flags in this property. Release only -- Debug and the
+# sanitizer builds want their own level, and MSVC spells this differently.
+if(NOT MSVC)
+  set_property(SOURCE util/fastlanes/interleaved_pfor_baseline.cc
+                      util/fastlanes/interleaved_pfor_simd.cc
+               APPEND
+               PROPERTY COMPILE_OPTIONS
+                        "$<$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>>:-O3>")
+endif()
+
 if(ARROW_WITH_BROTLI)
   list(APPEND ARROW_UTIL_SRCS util/compression_brotli.cc)
 endif()
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..0e1a8020678c 100644
--- a/cpp/src/arrow/util/bpacking.cc
+++ b/cpp/src/arrow/util/bpacking.cc
@@ -38,7 +38,29 @@ 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 bit-unpack dispatch at 256 bits. The generated AVX-512 kernels
+        // assemble vectors from scalar loads and use out-of-line calls, making
+        // them slower than the AVX2 path. Re-enable this target when its kernels
+        // use vector loads directly.
+        // 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 +79,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..e89ccc9e8083 100644
--- a/cpp/src/arrow/util/bpacking_dispatch_internal.h
+++ b/cpp/src/arrow/util/bpacking_dispatch_internal.h
@@ -31,23 +31,52 @@
 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 details let this loop approach memcpy speed:
+      //   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 +125,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 +197,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 +222,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 +238,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 +250,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 +261,29 @@ 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
+        // Some generated kernels do not accept a bias. Apply it in a fallback
+        // pass for correctness on those targets.
+        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 +297,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..33cddfe0ef79 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 bias is added before the store, so the output needs no second
+      // pass 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..ae531e04edf2
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
@@ -0,0 +1,190 @@
+// 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.
+//
+// FastLanes couples two independent ideas, and only the container is here. The
+// other is the FL_ORDER permutation (the 8x16 -> 16x8 within-sub-block
+// transpose plus the 04261537 sub-block reorder), which 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.
+//
+// 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: 128 * w bytes.
+//
+// Both kernels take an Arch type parameter their bodies never mention, so that
+// this one source compiled at two different instruction sets yields two
+// distinct symbols. Without it, PackBlock<16> compiled with NEON flags and
+// PackBlock<16> compiled with SVE flags share a mangled name, the linker keeps
+// one definition, and every caller silently gets whichever copy it kept --
+// undoing the per-instruction-set translation units of
+// interleaved_dispatch_internal.h with no diagnostic.
+// arrow::internal::bpacking carries the parameter for the same reason. A caller
+// that compiles exactly one copy of these kernels leaves it at its default and
+// is unaffected.
+
+#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, typename Arch = void>
+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 costs 1.47x-2.40x of the unpack it follows, 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 the no-bias instantiations carry no test in their
+// inner loop.
+// ---------------------------------------------------------------------------
+template <uint32_t w, bool kHasBias = false, typename Arch = void>
+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_dispatch_internal.h b/cpp/src/arrow/util/fastlanes/interleaved_dispatch_internal.h
new file mode 100644
index 000000000000..c4000f9ada6e
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_dispatch_internal.h
@@ -0,0 +1,69 @@
+// 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.
+
+// Runtime bit-width dispatch for the lane-interleaved kernels.
+//
+// The kernels in fastlanes_kernels_internal.h are intrinsic-free C++ templated
+// on the bit width, so one compiled copy is pinned to the instruction set of
+// the translation unit that compiled it. They are therefore compiled once per
+// instruction set, and this file declares the entry point each of those units
+// exports. arrow::internal::DynamicDispatch in pfor/pfor.cc picks between them,
+// so ARROW_USER_SIMD_LEVEL reaches these kernels like it reaches the rest of
+// Arrow's SIMD code; before this existed, ARROW_SIMD_LEVEL alone fixed their
+// width, and a default x86 build ran the interleaved kernel in XMM registers
+// while the sequential unpacker it is compared against dispatched to AVX2.
+//
+// Each entry point takes the bit width as a runtime argument and resolves it
+// against a table its own translation unit builds; see
+// interleaved_kernel_table_internal.h.
+
+#pragma once
+
+#include <cstdint>
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+// What the per-width tables hold.
+using InterleavedPackFn = void (*)(const uint32_t*, uint32_t*);
+using InterleavedUnpackFn = void (*)(const uint32_t*, uint32_t*, uint32_t);
+
+// Compiled at whatever instruction set the build's own flags name. This is the
+// dispatch fallback and the only leg guaranteed to exist, since a build can be
+// configured with no SIMD level at all.
+void InterleavedPackBlockBaseline(uint8_t bit_width, const uint32_t* in, uint32_t* out);
+void InterleavedUnpackBlockBaseline(uint8_t bit_width, const uint32_t* packed,
+                                    uint32_t* out, uint32_t bias);
+
+// The vector legs, each declared under exactly the condition CMake uses to
+// compile it: a build that never compiles a leg must not name one either.
+#if defined(ARROW_HAVE_RUNTIME_SVE128)
+void InterleavedPackBlockSve128(uint8_t bit_width, const uint32_t* in, uint32_t* out);
+void InterleavedUnpackBlockSve128(uint8_t bit_width, const uint32_t* packed,
+                                  uint32_t* out, uint32_t bias);
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
+void InterleavedPackBlockAvx2(uint8_t bit_width, const uint32_t* in, uint32_t* out);
+void InterleavedUnpackBlockAvx2(uint8_t bit_width, const uint32_t* packed, uint32_t* out,
+                                uint32_t bias);
+#endif
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h b/cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h
new file mode 100644
index 000000000000..5cceb32093b5
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h
@@ -0,0 +1,92 @@
+// 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 per-width dispatch tables, and the body each per-instruction-set
+// translation unit wraps under its own name. Included only by those translation
+// units, never by a caller: these contents are meant to be compiled more than
+// once, at different flags.
+
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <utility>
+
+#include <xsimd/xsimd.hpp>
+
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+#include "arrow/util/fastlanes/interleaved_dispatch_internal.h"
+#include "arrow/util/logging.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+// A table of function pointers rather than a switch over 32 cases, to keep each
+// width's body out of line. Folding all 32 into one dispatch function cost
+// between 1.2x and 2.1x when tried on Arrow's NEON unpacker, the compiler
+// having lost the register allocation it finds for a body it compiles on its
+// own; two indirect calls per 1024 values do not measure against that.
+//
+// Entry w handles width w. Entry 0 is never called: a vector of width 0 is
+// constant and never reaches a kernel.
+template <typename Arch, size_t... W>
+constexpr std::array<InterleavedPackFn, 33> MakePackTable(std::index_sequence<W...>) {
+  return {nullptr, &PackBlock<W + 1, Arch>...};
+}
+
+template <typename Arch, bool kHasBias, size_t... W>
+constexpr std::array<InterleavedUnpackFn, 33> MakeUnpackTable(std::index_sequence<W...>) {
+  return {nullptr, &UnpackBlock<W + 1, kHasBias, Arch>...};
+}
+
+// Arch defaults to the architecture xsimd derives from the including
+// translation unit's own flags, so each leg instantiates a distinct
+// specialization of these templates and of every kernel their tables point at,
+// which is what stops the linker from merging two legs into one. xsimd is used
+// for the type and nothing else. The types were checked to differ:
+// xsimd::neon64 at the aarch64 baseline against xsimd::detail::sve<128> under
+// -march=armv8-a+sve -msve-vector-bits=128.
+template <typename Arch = xsimd::default_arch>
+void PackLeg(uint8_t bit_width, const uint32_t* in, uint32_t* out) {
+  static constexpr auto kTable = MakePackTable<Arch>(std::make_index_sequence<32>{});
+  ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
+  kTable[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. The table choice is made here
+// rather than inside the kernel so the no-bias instantiations carry no test in
+// their inner loop.
+template <typename Arch = xsimd::default_arch>
+void UnpackLeg(uint8_t bit_width, const uint32_t* packed, uint32_t* out, uint32_t bias) {
+  static constexpr auto kUnpack =
+      MakeUnpackTable<Arch, /*kHasBias=*/false>(std::make_index_sequence<32>{});
+  static constexpr auto kUnpackBias =
+      MakeUnpackTable<Arch, /*kHasBias=*/true>(std::make_index_sequence<32>{});
+  ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
+  if (bias == 0) {
+    kUnpack[bit_width](packed, out, 0);
+  } else {
+    kUnpackBias[bit_width](packed, out, bias);
+  }
+}
+
+}  // 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..0f047bfc9048
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
@@ -0,0 +1,472 @@
+// 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 value orders:
+// input order, and the paper's lane assignment. Everything else is held equal
+// -- same per-block frame of reference, same bit width choice, same container
+// -- so the difference between them is the ordering and nothing else, which is
+// the one question this file answers. lane_delta.h and transposed_delta.h ask
+// that question of a delta chain; plain PFOR has no chain for the ordering to
+// help, so what is priced here is the permutation FL_ORDER forces. See
+// InterleavedPforOrder below for the three variants.
+//
+// There is no exception handling here: 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 decoder 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 paths that
+// differ only in PackingMode.
+//
+// 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.
+//
+// On register width: UnpackBlock in fastlanes_kernels_internal.h contains no
+// intrinsics, so its register width and its optimization level are whatever the
+// translation unit that compiled it was given. The production path in
+// pfor/pfor.cc picks its instruction set at runtime; the code here deliberately
+// does not, instantiating the template into the benchmark's own translation
+// unit so that every measurement is built at one known set of flags. The cost
+// is that it answers to ARROW_SIMD_LEVEL rather than ARROW_USER_SIMD_LEVEL, and
+// that a default x86 build (SSE4_2) runs it in XMM registers. Build with
+// -DARROW_SIMD_LEVEL=AVX2 or better before comparing against a dispatched
+// decoder, and state the level with the figure.
+//
+// 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 -- lane l holds the
+//              contiguous run [32l, 32l+32), reusing transposed_delta.h's
+//              Transpose32x32 -- and hand that order to the caller unchanged,
+//              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 what 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 addresses of the row-major kernel is
+// inefficient: 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 sequence               (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 shuffles. 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 shuffle sequence 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
+
+#if !defined(ARROW_FASTLANES_FUSED_FL_UNPACK) && defined(ARROW_TRANSPOSED_DELTA_NEON)
+
+namespace internal {
+
+// One 4x4 tile, the NEON counterpart of FlUnpackTile: unpack four rows' worth of
+// a 4-lane slice, transpose in registers, store across four output rows. The
+// shuffle sequence is the one Transpose32x32Neon uses; only the source of
+// r0..r3 differs.
+// Four-wide rather than eight-wide because that is the register width, which
+// costs four times as many tiles per block but the same number of loads and
+// stores -- a 16-byte store of four output values either way.
+template <uint32_t w, bool kHasBias, uint32_t rb>
+ARROW_FORCE_INLINE void FlUnpackTileNeon(const uint32_t* ARROW_RESTRICT packed,
+                                         int32_t* ARROW_RESTRICT out, size_t lb,
+                                         uint32x4_t vmask, uint32x4_t vbias) {
+  const uint32x4_t r0 =
+      FlUnpackRowSliceNeon<w, kHasBias, rb + 0>(packed, lb, vmask, vbias);
+  const uint32x4_t r1 =
+      FlUnpackRowSliceNeon<w, kHasBias, rb + 1>(packed, lb, vmask, vbias);
+  const uint32x4_t r2 =
+      FlUnpackRowSliceNeon<w, kHasBias, rb + 2>(packed, lb, vmask, vbias);
+  const uint32x4_t r3 =
+      FlUnpackRowSliceNeon<w, kHasBias, rb + 3>(packed, lb, vmask, vbias);
+
+  const uint32x4x2_t a = vtrnq_u32(r0, r1);
+  const uint32x4x2_t c = vtrnq_u32(r2, r3);
+
+  uint32_t* dst = reinterpret_cast<uint32_t*>(out) + lb * kRowsPerBlock + rb;
+  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])));
+}
+
+}  // 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 uint32x4_t vmask = vdupq_n_u32(kMask);
+  const uint32x4_t vbias = vdupq_n_u32(bias);
+
+  // lb outer for the same reason as the x86 kernel: a fixed lb writes one
+  // contiguous 512-byte run of the output, where rb outer would stride 128 bytes
+  // across the whole 4 KiB block.
+  for (size_t lb = 0; lb < kLanes; lb += 4) {
+    internal::FlUnpackTileNeon<w, kHasBias, 0>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 4>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 8>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 12>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 16>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 20>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 24>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 28>(packed, out, lb, vmask, vbias);
+  }
+}
+
+#endif  // NEON fused FL_ORDER unpack
+
+// 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 kFlOrder 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.
+#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.
+      // Write directly to the caller's buffer to avoid an intermediate 4 KiB
+      // grid and a second traversal. 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 preserves the store sequence with
+      // a different destination base.
+      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/interleaved_pfor_baseline.cc b/cpp/src/arrow/util/fastlanes/interleaved_pfor_baseline.cc
new file mode 100644
index 000000000000..caee977cc63f
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor_baseline.cc
@@ -0,0 +1,41 @@
+// 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 baseline leg of the interleaved kernel dispatch. This translation unit
+// carries no instruction-set flags of its own, so it compiles at whatever the
+// build's flags name; DynamicDispatch falls back to it when no vector leg is
+// available.
+
+#include "arrow/util/fastlanes/interleaved_dispatch_internal.h"
+#include "arrow/util/fastlanes/interleaved_kernel_table_internal.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+void InterleavedPackBlockBaseline(uint8_t bit_width, const uint32_t* in, uint32_t* out) {
+  return PackLeg<>(bit_width, in, out);
+}
+
+void InterleavedUnpackBlockBaseline(uint8_t bit_width, const uint32_t* packed,
+                                    uint32_t* out, uint32_t bias) {
+  return UnpackLeg<>(bit_width, packed, out, bias);
+}
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/interleaved_pfor_simd.cc b/cpp/src/arrow/util/fastlanes/interleaved_pfor_simd.cc
new file mode 100644
index 000000000000..15303952c38c
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor_simd.cc
@@ -0,0 +1,57 @@
+// 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.
+
+// A vector leg of the interleaved kernel dispatch, compiled once per
+// instruction set the build can target with that set's flags applied per-file
+// by CMake. The names below are selected by the same condition CMake tests
+// before adding the file, so only one branch is ever live in a given build.
+// util/bpacking_simd_256.cc is registered twice the same way.
+
+#if defined(ARROW_HAVE_RUNTIME_SVE128)
+#  define ILV_PACK_PLATFORM InterleavedPackBlockSve128
+#  define ILV_UNPACK_PLATFORM InterleavedUnpackBlockSve128
+#elif defined(ARROW_HAVE_RUNTIME_AVX2)
+#  define ILV_PACK_PLATFORM InterleavedPackBlockAvx2
+#  define ILV_UNPACK_PLATFORM InterleavedUnpackBlockAvx2
+#endif
+
+#if !defined(ILV_PACK_PLATFORM)
+#  error "This file must be compiled with a known SIMD micro architecture"
+#endif
+
+#include "arrow/util/fastlanes/interleaved_dispatch_internal.h"
+#include "arrow/util/fastlanes/interleaved_kernel_table_internal.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+void ILV_PACK_PLATFORM(uint8_t bit_width, const uint32_t* in, uint32_t* out) {
+  return PackLeg<>(bit_width, in, out);
+}
+
+void ILV_UNPACK_PLATFORM(uint8_t bit_width, const uint32_t* packed, uint32_t* out,
+                         uint32_t bias) {
+  return UnpackLeg<>(bit_width, packed, out, bias);
+}
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
+
+#undef ILV_PACK_PLATFORM
+#undef ILV_UNPACK_PLATFORM
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..67419268d088
--- /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 path 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..6a2555f092bb
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta.h
@@ -0,0 +1,864 @@
+// 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
+
+#ifdef ARROW_TRANSPOSED_DELTA_NEON
+namespace internal {
+
+// One 4-lane slice of one row, unpacked in registers: the NEON counterpart of
+// FlUnpackRowSlice above, and the same reason for `row` being a template
+// parameter -- vshrq_n_u32 takes an immediate, so the word index, the shift
+// amounts and the straddle test all have to be compile-time constants.
+template <uint32_t w, bool kHasBias, uint32_t row>
+ARROW_FORCE_INLINE uint32x4_t FlUnpackRowSliceNeon(const uint32_t* ARROW_RESTRICT packed,
+                                                   size_t lb, uint32x4_t vmask,
+                                                   uint32x4_t 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;
+
+  uint32x4_t v = vld1q_u32(packed + kWord * kLanes + lb);
+  if constexpr (kShift != 0) {
+    v = vshrq_n_u32(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 uint32x4_t hi = vld1q_u32(packed + kEndWord * kLanes + lb);
+    v = vorrq_u32(v, vshlq_n_u32(hi, kT - kShift));
+  }
+  if constexpr (w != 32) {
+    v = vandq_u32(v, vmask);
+  }
+  if constexpr (kHasBias) {
+    v = vaddq_u32(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, a shuffle sequence, 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 shuffles to cross the extra
+// lane boundary, and on this microarchitecture 512-bit buys nothing for the
+// unpack either.
+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 shuffle sequence
+// 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 reads a 4 KiB scratch block written by a separate
+// UnpackBlock call. Fuse the operations to avoid the intermediate stores and
+// loads.
+//
+// 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 shuffle sequence 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..2788bbb46240
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h
@@ -0,0 +1,250 @@
+// 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;
+
+  /// Restore file order in the same pass as the prefix sums and bit unpacking
+  /// to avoid writing and reading a 4 KiB scratch block.
+  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..fb9b5f16090f
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -0,0 +1,517 @@
+// 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 "arrow/util/bit_stream_utils_internal.h"
+#include "arrow/util/bit_util.h"
+#include "arrow/util/bpacking_internal.h"
+#include "arrow/util/dispatch_internal.h"
+#include "arrow/util/endian.h"
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+#include "arrow/util/fastlanes/interleaved_dispatch_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.
+//
+// The kernels contain no intrinsics: they are portable C++ whose register width
+// is fixed by the flags of the translation unit that compiled them. So the
+// choice of instruction set is a choice of translation unit, made here at
+// runtime the same way every other Arrow SIMD kernel makes it. Each leg named
+// below is one compilation of the same kernel source at one instruction set;
+// interleaved_dispatch_internal.h says which legs exist and why, and
+// interleaved_kernel_table_internal.h holds the per-width table each one builds.
+//
+// Without this the kernels had no dispatch at all, and ARROW_SIMD_LEVEL alone
+// decided their width -- which on a default x86 build is SSE4_2, so the
+// interleaved kernel ran in XMM registers while the sequential unpacker it is
+// compared against dispatched to AVX2 at runtime.
+struct InterleavedPackDynamicFunction {
+  using FunctionType = decltype(&fastlanes::InterleavedPackBlockBaseline);
+
+  static constexpr auto targets() {
+    return std::array{
+        ARROW_DISPATCH_TARGET_NONE(&fastlanes::InterleavedPackBlockBaseline)  //
+        ARROW_DISPATCH_TARGET_SVE128(&fastlanes::InterleavedPackBlockSve128)  //
+        ARROW_DISPATCH_TARGET_AVX2(&fastlanes::InterleavedPackBlockAvx2)      //
+    };
+  }
+};
+
+struct InterleavedUnpackDynamicFunction {
+  using FunctionType = decltype(&fastlanes::InterleavedUnpackBlockBaseline);
+
+  static constexpr auto targets() {
+    return std::array{
+        ARROW_DISPATCH_TARGET_NONE(&fastlanes::InterleavedUnpackBlockBaseline)  //
+        ARROW_DISPATCH_TARGET_SVE128(&fastlanes::InterleavedUnpackBlockSve128)  //
+        ARROW_DISPATCH_TARGET_AVX2(&fastlanes::InterleavedUnpackBlockAvx2)      //
+    };
+  }
+};
+
+inline void InterleavedPackBlock(uint8_t bit_width, const uint32_t* in, uint32_t* out) {
+  ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
+  static const arrow::internal::DynamicDispatch<InterleavedPackDynamicFunction> dispatch;
+  return dispatch(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);
+  static const arrow::internal::DynamicDispatch<InterleavedUnpackDynamicFunction>
+      dispatch;
+  return dispatch(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, options.force_delta);
+  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());
+
+    // The sequential vector kernels load a fixed-size window per step. Use the
+    // remaining page bytes as the read bound so a kernel can process the final
+    // step when its load extends beyond this vector's packed payload.
+    //
+    // `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 {
+      // Fold the non-zero frame into the unpacker's store to avoid a second
+      // traversal of the output.
+      //
+      // 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. A scan across lanes with a carry
+  // broadcast would shorten the dependency chain. This applies only to vectors
+  // without exceptions because patching occurs before the prefix 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..4092e2c1801b
--- /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, PforEncodeOptions{.mode = 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, PforEncodeOptions{.mode = 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, PforEncodeOptions{.mode = 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 decoders
+// 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 decoder 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..cbe9d14174f9
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_internal.h
@@ -0,0 +1,312 @@
+// 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 {
+  /// Let the planner difference a vector when its cost model prefers that.
+  bool delta_enabled = true;
+  /// Require the delta representation even when the raw representation is cheaper.
+  /// Off by default; set it only to exercise or measure the delta path directly.
+  bool force_delta = false;
+  /// 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..543ebd12332d
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
@@ -0,0 +1,557 @@
+// 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. Gather both in one pass because they use the same offset.
+///
+/// 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 approximate search cannot produce a
+/// higher estimated cost.
+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;
+
+  // A width-zero plan cannot be improved by moving the frame. Do not apply this
+  // shortcut merely because a plan has no exceptions: another frame may trade
+  // a narrower width for a small patch list.
+  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 therefore cannot see a window narrower than one
+  // bucket. Such windows can be optimal: 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
+/// \param[in] force_delta choose delta regardless of its estimated or exact cost
+///
+/// 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,
+                                   bool force_delta = false) {
+  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 || (!force_delta && (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 (!force_delta && 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 (force_delta || 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..7eb5d174f618
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_test.cc
@@ -0,0 +1,1615 @@
+// 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);
+}
+
+// The planner correctly chooses raw PFOR for this data, so the flag is the only
+// way to reach the delta round trip on it.
+TYPED_TEST(PforTest, ForceDeltaBypassesThePlannerChoice) {
+  using T = TypeParam;
+  std::vector<T> values = this->RandomValues(64, 100, 163, 11);
+  const PforEncodeOptions options{.delta_enabled = true, .force_delta = true};
+  auto encoded = PforCompression<T>::EncodeVector(
+      values.data(), static_cast<int32_t>(values.size()), options);
+  ASSERT_TRUE(encoded.info().is_delta());
+
+  const int64_t size = PforCompression<T>::SerializedVectorSize(encoded, values.size());
+  std::vector<uint8_t> buffer(size);
+  ASSERT_OK(PforCompression<T>::SerializeVector(encoded, values.size(), buffer));
+  std::vector<T> decoded(values.size());
+  ASSERT_OK(PforCompression<T>::DecodeVector(buffer, values.size(), decoded.data()));
+  ASSERT_EQ(values, decoded);
+}
+
+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 a
+// frame pinned to the minimum cannot handle: the packed window then 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,
+                                       PforEncodeOptions{.mode = 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,
+                                   PforEncodeOptions{.mode = 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,
+                                     PforEncodeOptions{.mode = 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,
+                                     PforEncodeOptions{.mode = 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,
+                                     PforEncodeOptions{.mode = 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, PforEncodeOptions{.mode = 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, PforEncodeOptions{.mode = 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()));
+}
+
+/// A column reader does not hand a whole page to the decoder: it opens the page
+/// once and asks for one vector at a time, which is a second decode path over
+/// the same bytes. The layout a page declares has to reach that path too, or
+/// every full interleaved vector read through a Parquet file expands as though
+/// it were sequential -- wrong values, and no error to say so.
+///
+/// The page here is three vectors and a short tail, so it covers both rules the
+/// path has to get right: the full vectors are interleaved, and the tail, which
+/// is too short for a block, is sequential on the same page.
+TEST(PforInterleavedTest, VectorAtATimeReadMatchesWholePage) {
+  using T = int32_t;
+  const auto vector_size = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  const int32_t num_values = 3 * vector_size + 300;
+
+  for (int width : {1, 3, 7, 8, 13, 16, 24, 31}) {
+    const auto values = ValuesForWidth<T>(width, /*zero_frame=*/true, 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,
+        PforEncodeOptions{.mode = PackingMode::kForBitPackInterleaved}));
+    ASSERT_EQ(static_cast<uint8_t>(PackingMode::kForBitPackInterleaved),
+              PackingModeOf(page))
+        << "width " << width;
+
+    ASSERT_OK_AND_ASSIGN(auto reader, PforWrapper<T>::VectorReader::Open(
+                                          {page.data(), static_cast<size_t>(comp_size)}));
+    ASSERT_EQ(num_values, reader.num_elements()) << "width " << width;
+    ASSERT_EQ(4, reader.num_vectors()) << "width " << width;
+
+    std::vector<T> streamed;
+    streamed.reserve(num_values);
+    for (int32_t v = 0; v < reader.num_vectors(); ++v) {
+      ASSERT_OK_AND_ASSIGN(const int32_t length, reader.VectorLength(v));
+      std::vector<T> one(length);
+      ASSERT_OK(reader.DecodeVector(v, one)) << "width " << width << " vector " << v;
+      streamed.insert(streamed.end(), one.begin(), one.end());
+    }
+    ASSERT_EQ(values, streamed) << "width " << width;
+
+    // The whole-page decoder is the reference the two paths have to agree on.
+    std::vector<T> whole(num_values);
+    ASSERT_OK(PforWrapper<T>::Decode(page.data(), comp_size, num_values, whole.data()));
+    ASSERT_EQ(whole, streamed) << "width " << width;
+  }
+}
+
+}  // 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..c45accdc5419
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
@@ -0,0 +1,456 @@
+// 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{.delta_enabled = options.delta_enabled,
+                          .force_delta = options.force_delta,
+                          .mode = 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;
+}
+
+// ----------------------------------------------------------------------
+// VectorReader
+
+template <typename T>
+Result<typename PforWrapper<T>::VectorReader> PforWrapper<T>::VectorReader::Open(
+    std::span<const uint8_t> input) {
+  ARROW_ASSIGN_OR_RAISE(const PforHeader header, PforWrapper<T>::LoadHeader(input));
+
+  VectorReader reader;
+  reader.input_ = input;
+  reader.num_elements_ = header.num_elements;
+  reader.vector_size_ = 1 << header.log_vector_size;
+  reader.num_vectors_ =
+      static_cast<int32_t>(bit_util::CeilDiv(reader.num_elements_, reader.vector_size_));
+  reader.packing_mode_ = static_cast<PackingMode>(header.packing_mode);
+  reader.offset_array_start_ = input.data() + PforConstants::kHeaderSize;
+  const int64_t offset_array_size =
+      static_cast<int64_t>(reader.num_vectors_) * kOffsetSize;
+  if (PforConstants::kHeaderSize + offset_array_size >
+      static_cast<int64_t>(input.size())) {
+    return Status::Invalid("PFOR offset array for ", reader.num_vectors_,
+                           " vectors does not fit in ", input.size(), " bytes");
+  }
+  reader.payload_size_ = static_cast<int64_t>(input.size()) - PforConstants::kHeaderSize;
+  RETURN_NOT_OK(ValidateOffsets(reader.offset_array_start_, reader.num_vectors_,
+                                offset_array_size, reader.payload_size_));
+  return reader;
+}
+
+template <typename T>
+Result<int32_t> PforWrapper<T>::VectorReader::VectorLength(int32_t vector_index) const {
+  if (vector_index < 0 || vector_index >= num_vectors_) {
+    return Status::Invalid("PFOR vector index ", vector_index, " is outside [0, ",
+                           num_vectors_, ")");
+  }
+  return std::min(vector_size_, num_elements_ - vector_index * vector_size_);
+}
+
+template <typename T>
+Status PforWrapper<T>::VectorReader::DecodeVector(int32_t vector_index,
+                                                  std::span<T> output) const {
+  ARROW_ASSIGN_OR_RAISE(const int32_t vector_length, VectorLength(vector_index));
+  if (output.size() < static_cast<size_t>(vector_length)) {
+    return Status::Invalid("PFOR vector output has ", output.size(), " slots but needs ",
+                           vector_length);
+  }
+  const auto offset =
+      bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::OffsetType>(
+          offset_array_start_ + vector_index * kOffsetSize));
+  const uint8_t* vector_data = offset_array_start_ + offset;
+  return PforCompression<T>::DecodeVector(
+             std::span<const uint8_t>(vector_data,
+                                      input_.data() + input_.size() - vector_data),
+             vector_length, output.data(), packing_mode_)
+      .status();
+}
+
+// ----------------------------------------------------------------------
+// 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..4a90f8b0d75c
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
@@ -0,0 +1,175 @@
+// 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 this page layout (offsets are relative to the offset array):
+///
+///   +---------------------------------------------------------------+
+///   | PFOR header (7 bytes)                                         |
+///   | Offset 0 | Offset 1 | ... | Offset n-1      (4 bytes each)    |
+///   | Vector 0 | Vector 1 | ... | Vector n-1                         |
+///   +---------------------------------------------------------------+
+///
+/// Header fields:
+///
+///   +--------+--------------------+---------------------+
+///   | Offset | Field              | Size                |
+///   +--------+--------------------+---------------------+
+///   |      0 | packing_mode       | 1 byte (uint8)      |
+///   |      1 | log_vector_size    | 1 byte (uint8)      |
+///   |      2 | value_byte_width   | 1 byte (uint8)      |
+///   |      3 | num_elements       | 4 bytes (int32)     |
+///   +--------+--------------------+---------------------+
+///
+/// \tparam T the integer type (int32_t or int64_t)
+template <typename T>
+class PforWrapper {
+ public:
+  /// A validated view of one encoded page.  It keeps no decoded values and can
+  /// therefore serve arbitrary vectors without materializing the whole page.
+  class VectorReader {
+   public:
+    static Result<VectorReader> Open(std::span<const uint8_t> input);
+
+    int32_t num_elements() const { return num_elements_; }
+    int32_t vector_size() const { return vector_size_; }
+    int32_t num_vectors() const { return num_vectors_; }
+
+    Result<int32_t> VectorLength(int32_t vector_index) const;
+    Status DecodeVector(int32_t vector_index, std::span<T> output) const;
+
+   private:
+    std::span<const uint8_t> input_;
+    const uint8_t* offset_array_start_ = nullptr;
+    int64_t payload_size_ = 0;
+    int32_t num_elements_ = 0;
+    int32_t vector_size_ = 0;
+    int32_t num_vectors_ = 0;
+    // Which bit-packing layout the page declares. A vector shorter than a full
+    // interleaved block is written as kForBitPack even on an interleaved page,
+    // and DecodeVector derives that from the element count the way the
+    // whole-page decoder does.
+    PackingMode packing_mode_ = PackingMode::kForBitPack;
+  };
+
+  /// \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/arrow/arrow_encoding_test.cc b/cpp/src/parquet/arrow/arrow_encoding_test.cc
new file mode 100644
index 000000000000..86a273fb998d
--- /dev/null
+++ b/cpp/src/parquet/arrow/arrow_encoding_test.cc
@@ -0,0 +1,620 @@
+// 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;
+  std::shared_ptr<Buffer> file;
+  DoRoundtrip(table, table->num_rows(), &result, writer_props, &file);
+
+  auto metadata =
+      ParquetFileReader::Open(std::make_shared<BufferReader>(file))->metadata();
+  ASSERT_THAT(metadata->RowGroup(0)->ColumnChunk(0)->encodings(),
+              ::testing::Contains(Encoding::PFOR));
+  ASSERT_THAT(metadata->RowGroup(0)->ColumnChunk(1)->encodings(),
+              ::testing::Contains(Encoding::PFOR));
+  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));
+}
+
+// Verify that the per-column delta option reduces this column's encoded size
+// without changing its 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..01fa503b4a1c 100644
--- a/cpp/src/parquet/decoder.cc
+++ b/cpp/src/parquet/decoder.cc
@@ -24,12 +24,18 @@
 #include <cstring>
 #include <limits>
 #include <memory>
+#include <optional>
+#include <span>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
+#if defined(ARROW_HAVE_NEON) || defined(ARROW_HAVE_SSE4_2)
+#  include <xsimd/xsimd.hpp>
+#endif
+
 #include "arrow/array.h"
 #include "arrow/array/builder_binary.h"
 #include "arrow/array/builder_dict.h"
@@ -42,8 +48,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"
@@ -1434,6 +1442,71 @@ class DictByteArrayDecoderImpl : public DictDecoderImpl<ByteArrayType> {
 // ----------------------------------------------------------------------
 // DELTA_BINARY_PACKED decoder
 
+namespace {
+
+#if defined(ARROW_HAVE_NEON) || defined(ARROW_HAVE_SSE4_2)
+// One step of an inclusive scan, recursed at compile time over powers of two. Each step
+// adds the vector to a copy of itself slid up by kShift lanes, zero-filling the lanes
+// it vacates, so after the last step lane k holds the sum of lanes 0 through k.
+template <std::size_t kShift, typename Batch>
+Batch InclusiveScanSteps(Batch v) {
+  if constexpr (kShift < Batch::size) {
+    v += xsimd::slide_left<kShift * sizeof(typename Batch::value_type)>(v);
+    return InclusiveScanSteps<kShift * 2>(v);
+  } else {
+    return v;
+  }
+}
+#endif
+
+// Turns a run of deltas into the values they encode, in place: on return element k holds
+// `last + (k + 1) * min_delta + sum of deltas 0..k`, and the return value is the last
+// element. Every term is unsigned, so the wrapping matches the loop this replaces.
+template <typename T>
+std::make_unsigned_t<T> PrefixSumDeltas(T* values, int num_values,
+                                        std::make_unsigned_t<T> min_delta,
+                                        std::make_unsigned_t<T> last) {
+  using UT = std::make_unsigned_t<T>;
+  int i = 0;
+
+#if defined(ARROW_HAVE_NEON) || defined(ARROW_HAVE_SSE4_2)
+  using Batch = xsimd::batch<UT>;
+  constexpr int kLanes = static_cast<int>(Batch::size);
+  // At two lanes the scan loses to the additions it replaces, so it is compiled only
+  // where a register holds four or more values; narrower ones use the loop below.
+  if constexpr (kLanes >= 4) {
+    // Broadcast pattern for the last lane, which carries the running value into the
+    // next vector without a round trip through a general-purpose register.
+    struct LastLane {
+      static constexpr unsigned get(unsigned /*index*/, unsigned size) {
+        return size - 1;
+      }
+    };
+    const auto last_lane =
+        xsimd::make_batch_constant<UT, LastLane, xsimd::default_arch>();
+    const Batch min_delta_v(min_delta);
+    Batch carry(last);
+    for (; i + kLanes <= num_values; i += kLanes) {
+      // Adding the frame before the scan turns its running multiple into a term the
+      // scan produces, rather than a multiply per lane.
+      Batch v = xsimd::bitwise_cast<UT>(xsimd::batch<T>::load_unaligned(values + i));
+      v = InclusiveScanSteps<1>(v + min_delta_v) + carry;
+      xsimd::bitwise_cast<T>(v).store_unaligned(values + i);
+      carry = xsimd::swizzle(v, last_lane);
+    }
+    last = carry.get(0);
+  }
+#endif
+
+  for (; i < num_values; ++i) {
+    last += min_delta + static_cast<UT>(values[i]);
+    values[i] = static_cast<T>(last);
+  }
+  return last;
+}
+
+}  // namespace
+
 template <typename DType>
 class DeltaBitPackDecoder : public TypedDecoderImpl<DType> {
  public:
@@ -1601,6 +1674,28 @@ class DeltaBitPackDecoder : public TypedDecoderImpl<DType> {
     values_remaining_current_mini_block_ = values_per_mini_block_;
   }
 
+  // Returns how many whole miniblocks after the current one can be unpacked in the
+  // same call. Miniblocks are packed back to back with no padding and hold a multiple
+  // of 32 values, so at a fixed bit width a run of them is bit-identical to one longer
+  // run. A miniblock only joins the run when its width equals delta_bit_width_, which
+  // InitMiniBlock has validated, so an unchecked width is never used.
+  uint32_t CoalescibleMiniBlocks(uint32_t values_available) const {
+    // A run can only start once there is room for the rest of the current miniblock.
+    if (values_available < values_remaining_current_mini_block_) {
+      return 0;
+    }
+    const uint8_t* bit_widths = delta_bit_widths_->data();
+    uint32_t values_needed = values_remaining_current_mini_block_;
+    uint32_t count = 0;
+    while (mini_block_idx_ + count + 1 < mini_blocks_per_block_ &&
+           bit_widths[mini_block_idx_ + count + 1] == delta_bit_width_ &&
+           values_available - values_needed >= values_per_mini_block_) {
+      values_needed += values_per_mini_block_;
+      ++count;
+    }
+    return count;
+  }
+
   int GetInternal(T* buffer, int max_values) {
     max_values = static_cast<int>(std::min<int64_t>(max_values, total_values_remaining_));
     if (max_values == 0) {
@@ -1642,8 +1737,19 @@ class DeltaBitPackDecoder : public TypedDecoderImpl<DType> {
         }
       }
 
-      int values_decode = std::min(values_remaining_current_mini_block_,
-                                   static_cast<uint32_t>(max_values - i));
+      const uint32_t values_available = static_cast<uint32_t>(max_values - i);
+      const uint32_t values_this_mini_block =
+          std::min(values_remaining_current_mini_block_, values_available);
+      // The zero-bit-width path does not call the unpacker, so do not include
+      // adjacent zero-width miniblocks in a coalesced run.
+      const uint32_t mini_blocks_coalesced =
+          delta_bit_width_ == 0 ? 0 : CoalescibleMiniBlocks(values_available);
+      // A non-empty run implies the current miniblock is fully drained, which the
+      // cursor update below relies on.
+      DCHECK(mini_blocks_coalesced == 0 ||
+             values_this_mini_block == values_remaining_current_mini_block_);
+      const int values_decode = static_cast<int>(
+          values_this_mini_block + mini_blocks_coalesced * values_per_mini_block_);
       if (delta_bit_width_ == 0) {
         // Fast path that avoids a back-to-back dependency between two consecutive
         // computations: we know all deltas decode to zero. We actually don't
@@ -1658,15 +1764,13 @@ class DeltaBitPackDecoder : public TypedDecoderImpl<DType> {
             values_decode) {
           ParquetException::EofException();
         }
-        for (int j = 0; j < values_decode; ++j) {
-          // Addition between min_delta, packed int and last_value should be treated as
-          // unsigned addition. Overflow is as expected.
-          buffer[i + j] = static_cast<UT>(min_delta_) + static_cast<UT>(buffer[i + j]) +
-                          static_cast<UT>(last_value_);
-          last_value_ = buffer[i + j];
-        }
+        last_value_ = static_cast<T>(PrefixSumDeltas(buffer + i, values_decode,
+                                                     static_cast<UT>(min_delta_),
+                                                     static_cast<UT>(last_value_)));
       }
-      values_remaining_current_mini_block_ -= values_decode;
+      // The last miniblock of a coalesced run becomes the current one, fully drained.
+      mini_block_idx_ += mini_blocks_coalesced;
+      values_remaining_current_mini_block_ -= values_this_mini_block;
       i += values_decode;
     }
     total_values_remaining_ -= max_values;
@@ -2372,6 +2476,341 @@ class ByteStreamSplitDecoder<FLBAType> : public ByteStreamSplitDecoderBase<FLBAT
   }
 };
 
+// ----------------------------------------------------------------------
+// PFOR Decoder
+
+template <typename DType>
+class PforDecoder : public TypedDecoderImpl<DType> {
+ public:
+  using Base = TypedDecoderImpl<DType>;
+  using T = typename DType::c_type;
+  using VectorReader = typename ::arrow::util::pfor::PforWrapper<T>::VectorReader;
+
+  explicit PforDecoder(const ColumnDescriptor* descr,
+                       MemoryPool* pool = ::arrow::default_memory_pool())
+      : Base(descr, Encoding::PFOR), cached_vector_(AllocateBuffer(pool, 0)) {}
+
+  void SetData(int num_values, const uint8_t* data, int len) override {
+    if (num_values < 0 || len < 0) {
+      throw ParquetException("PFOR SetData: num_values=" + std::to_string(num_values) +
+                             " len=" + std::to_string(len));
+    }
+    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.
+    cached_vector_index_ = -1;
+    // `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(
+          reader_, VectorReader::Open({this->data_, static_cast<size_t>(this->len_)}));
+      const int32_t encoded_values = reader_->num_elements();
+      if (encoded_values > num_values) {
+        throw ParquetException("PFOR page declares " + std::to_string(encoded_values) +
+                               " values but the page header allows at most " +
+                               std::to_string(num_values));
+      }
+      this->num_values_ = encoded_values;
+    } else {
+      reader_.reset();
+      this->num_values_ = 0;
+    }
+    levels_remaining_ = num_values;
+  }
+
+  int Decode(T* buffer, int max_values) override {
+    if (ARROW_PREDICT_FALSE(max_values < 0)) {
+      throw ParquetException("PFOR Decode: max_values must be non-negative");
+    }
+    max_values = std::min(max_values, this->num_values_);
+    if (max_values == 0) return 0;
+    DecodeInternal(buffer, max_values);
+    this->num_values_ -= max_values;
+    levels_remaining_ -= max_values;
+    CheckPageConsumed();
+    return max_values;
+  }
+
+  int DecodeSpaced(T* buffer, int num_values, int null_count, const uint8_t* valid_bits,
+                   int64_t valid_bits_offset) override {
+    const int decoded =
+        Base::DecodeSpaced(buffer, num_values, null_count, valid_bits, valid_bits_offset);
+    levels_remaining_ -= null_count;
+    CheckPageConsumed();
+    return decoded;
+  }
+
+  // `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);
+      DecodeInternal(decode_out, values_to_decode);
+    }
+
+    // 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;
+    levels_remaining_ -= num_values;
+    CheckPageConsumed();
+    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();
+    }
+    levels_remaining_ -= null_count;
+    CheckPageConsumed();
+
+    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:
+  void CheckPageConsumed() const {
+    ARROW_DCHECK_GE(levels_remaining_, 0) << "PFOR decoder consumed too many levels";
+    if (ARROW_PREDICT_FALSE(levels_remaining_ <= 0 && this->num_values_ > 0)) {
+      throw ParquetException("PFOR page has " + std::to_string(this->num_values_) +
+                             " unconsumed values after all levels were read");
+    }
+  }
+
+  void DecodeInternal(T* output, int count) {
+    const int32_t vector_size = reader_->vector_size();
+    int32_t processed = reader_->num_elements() - this->num_values_;
+    for (int32_t remaining = count; remaining > 0;) {
+      const int32_t vector_index = processed / vector_size;
+      const int32_t position = processed % vector_size;
+      PARQUET_ASSIGN_OR_THROW(const int32_t vector_length,
+                              reader_->VectorLength(vector_index));
+      const int32_t take = std::min(remaining, vector_length - position);
+      if (position == 0 && take == vector_length) {
+        PARQUET_THROW_NOT_OK(reader_->DecodeVector(
+            vector_index, {output, static_cast<size_t>(vector_length)}));
+      } else {
+        if (cached_vector_index_ != vector_index) {
+          PARQUET_THROW_NOT_OK(
+              cached_vector_->Resize(static_cast<int64_t>(vector_length) * sizeof(T),
+                                     /*shrink_to_fit=*/false));
+          PARQUET_THROW_NOT_OK(
+              reader_->DecodeVector(vector_index, {cached_vector_->mutable_data_as<T>(),
+                                                   static_cast<size_t>(vector_length)}));
+          cached_vector_index_ = vector_index;
+        }
+        std::memcpy(output, cached_vector_->data_as<T>() + position,
+                    static_cast<size_t>(take) * sizeof(T));
+      }
+      output += take;
+      processed += take;
+      remaining -= take;
+    }
+  }
+
+  std::optional<VectorReader> reader_;
+  // One vector of pool-backed scratch, reused when a batch begins or ends inside it.
+  std::shared_ptr<ResizableBuffer> cached_vector_;
+  int32_t cached_vector_index_ = -1;
+  int64_t levels_remaining_ = 0;
+};
+
+// ----------------------------------------------------------------------
+// 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 +2887,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 +2945,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_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc
index bea1a5807a2a..6bcce1a2c6e6 100644
--- a/cpp/src/parquet/encoding_benchmark.cc
+++ b/cpp/src/parquet/encoding_benchmark.cc
@@ -675,6 +675,22 @@ static auto MakeDeltaBitPackingInputNarrow(size_t length) {
   return numbers;
 }
 
+// Non-decreasing values, the shape this encoding is usually chosen for. The deltas come
+// from the same 1000-wide range as Narrow, so the two inputs differ in the order of the
+// values and not in the width a delta is packed into.
+template <typename DType>
+static auto MakeDeltaBitPackingInputNarrowSorted(size_t length) {
+  using T = typename DType::c_type;
+  auto numbers = std::vector<T>(length);
+  ::arrow::randint<T, T>(length, 0, 1000, &numbers);
+  T value = 0;
+  for (auto& number : numbers) {
+    value = static_cast<T>(value + number);
+    number = value;
+  }
+  return numbers;
+}
+
 template <typename DType>
 static auto MakeDeltaBitPackingInputWide(size_t length) {
   using T = typename DType::c_type;
@@ -713,6 +729,16 @@ static void BM_DeltaBitPackingEncode_Int64_Narrow(benchmark::State& state) {
   BM_DeltaBitPackingEncode<Int64Type>(state, MakeDeltaBitPackingInputNarrow<Int64Type>);
 }
 
+static void BM_DeltaBitPackingEncode_Int32_NarrowSorted(benchmark::State& state) {
+  BM_DeltaBitPackingEncode<Int32Type>(state,
+                                      MakeDeltaBitPackingInputNarrowSorted<Int32Type>);
+}
+
+static void BM_DeltaBitPackingEncode_Int64_NarrowSorted(benchmark::State& state) {
+  BM_DeltaBitPackingEncode<Int64Type>(state,
+                                      MakeDeltaBitPackingInputNarrowSorted<Int64Type>);
+}
+
 static void BM_DeltaBitPackingEncode_Int32_Wide(benchmark::State& state) {
   BM_DeltaBitPackingEncode<Int32Type>(state, MakeDeltaBitPackingInputWide<Int32Type>);
 }
@@ -725,6 +751,8 @@ BENCHMARK(BM_DeltaBitPackingEncode_Int32_Fixed)->Range(MIN_RANGE, MAX_RANGE);
 BENCHMARK(BM_DeltaBitPackingEncode_Int64_Fixed)->Range(MIN_RANGE, MAX_RANGE);
 BENCHMARK(BM_DeltaBitPackingEncode_Int32_Narrow)->Range(MIN_RANGE, MAX_RANGE);
 BENCHMARK(BM_DeltaBitPackingEncode_Int64_Narrow)->Range(MIN_RANGE, MAX_RANGE);
+BENCHMARK(BM_DeltaBitPackingEncode_Int32_NarrowSorted)->Range(MIN_RANGE, MAX_RANGE);
+BENCHMARK(BM_DeltaBitPackingEncode_Int64_NarrowSorted)->Range(MIN_RANGE, MAX_RANGE);
 BENCHMARK(BM_DeltaBitPackingEncode_Int32_Wide)->Range(MIN_RANGE, MAX_RANGE);
 BENCHMARK(BM_DeltaBitPackingEncode_Int64_Wide)->Range(MIN_RANGE, MAX_RANGE);
 
@@ -762,6 +790,16 @@ static void BM_DeltaBitPackingDecode_Int64_Narrow(benchmark::State& state) {
   BM_DeltaBitPackingDecode<Int64Type>(state, MakeDeltaBitPackingInputNarrow<Int64Type>);
 }
 
+static void BM_DeltaBitPackingDecode_Int32_NarrowSorted(benchmark::State& state) {
+  BM_DeltaBitPackingDecode<Int32Type>(state,
+                                      MakeDeltaBitPackingInputNarrowSorted<Int32Type>);
+}
+
+static void BM_DeltaBitPackingDecode_Int64_NarrowSorted(benchmark::State& state) {
+  BM_DeltaBitPackingDecode<Int64Type>(state,
+                                      MakeDeltaBitPackingInputNarrowSorted<Int64Type>);
+}
+
 static void BM_DeltaBitPackingDecode_Int32_Wide(benchmark::State& state) {
   BM_DeltaBitPackingDecode<Int32Type>(state, MakeDeltaBitPackingInputWide<Int32Type>);
 }
@@ -774,6 +812,8 @@ BENCHMARK(BM_DeltaBitPackingDecode_Int32_Fixed)->Range(MIN_RANGE, MAX_RANGE);
 BENCHMARK(BM_DeltaBitPackingDecode_Int64_Fixed)->Range(MIN_RANGE, MAX_RANGE);
 BENCHMARK(BM_DeltaBitPackingDecode_Int32_Narrow)->Range(MIN_RANGE, MAX_RANGE);
 BENCHMARK(BM_DeltaBitPackingDecode_Int64_Narrow)->Range(MIN_RANGE, MAX_RANGE);
+BENCHMARK(BM_DeltaBitPackingDecode_Int32_NarrowSorted)->Range(MIN_RANGE, MAX_RANGE);
+BENCHMARK(BM_DeltaBitPackingDecode_Int64_NarrowSorted)->Range(MIN_RANGE, MAX_RANGE);
 BENCHMARK(BM_DeltaBitPackingDecode_Int32_Wide)->Range(MIN_RANGE, MAX_RANGE);
 BENCHMARK(BM_DeltaBitPackingDecode_Int64_Wide)->Range(MIN_RANGE, MAX_RANGE);
 
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index 831829e4a210..f96405877249 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -22,7 +22,9 @@
 #include <cstring>
 #include <functional>
 #include <limits>
+#include <numeric>
 #include <span>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -1044,6 +1046,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 +1295,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(); }
@@ -1752,7 +1840,8 @@ class TestDeltaBitPackEncoding : public TestEncodingBase<Type> {
   using c_type = typename Type::c_type;
   static constexpr int TYPE = Type::type_num;
   static constexpr size_t kNumRoundTrips = 3;
-  const std::vector<int> kReadBatchSizes = {1, 11};
+  // 100 spans several miniblocks but still ends inside one.
+  const std::vector<int> kReadBatchSizes = {1, 11, 100};
 
   void InitBoundData(int nvalues, int repeats, c_type half_range) {
     num_values_ = nvalues * repeats;
@@ -2034,6 +2123,568 @@ TYPED_TEST(TestDeltaBitPackEncoding, ZeroDeltaBitWidth) {
   this->CheckRoundtripWithValues(int_values);
 }
 
+TYPED_TEST(TestDeltaBitPackEncoding, MiniblockBitWidthRuns) {
+  // A decoder may unpack a run of miniblocks sharing a bit width in one call. Cover
+  // the width patterns that decide where such a run starts and stops.
+  using T = typename TypeParam::c_type;
+
+  // Same values as in DeltaBitPackEncoder
+  constexpr int kValuesPerBlock =
+      std::is_same_v<int32_t, typename TypeParam::c_type> ? 128 : 256;
+  constexpr int kMiniBlocksPerBlock = 4;
+  constexpr int kValuesPerMiniBlock = kValuesPerBlock / kMiniBlocksPerBlock;
+
+  // Gives miniblock i the bit width widths[i]: alternating deltas of `frame` and
+  // `frame + 2^(w-1)` make w the smallest width holding the residual, and `frame` the
+  // smallest delta, so it is the frame the encoder stores.
+  auto make_values = [](const std::vector<int>& widths, T frame, int trailing_values) {
+    std::vector<T> values;
+    values.reserve(widths.size() * kValuesPerMiniBlock + trailing_values + 1);
+    // The first value travels in the header and contributes no delta.
+    T current = 0;
+    values.push_back(current);
+    for (const int width : widths) {
+      const T spread = width == 0 ? T{0} : static_cast<T>(T{1} << (width - 1));
+      for (int i = 0; i < kValuesPerMiniBlock; ++i) {
+        current = static_cast<T>(current + frame + (i % 2 == 0 ? T{0} : spread));
+        values.push_back(current);
+      }
+    }
+    // A tail shorter than a miniblock makes a run stop at the end of the values.
+    for (int i = 0; i < trailing_values; ++i) {
+      current = static_cast<T>(current + frame);
+      values.push_back(current);
+    }
+    return values;
+  };
+
+  struct Case {
+    const char* name;
+    std::vector<int> widths;
+    int trailing_values;
+  };
+  const std::vector<Case> cases = {
+      // One run covering every miniblock of the block.
+      {"uniform widths", {4, 4, 4, 4}, 0},
+      // No two neighbours share a width, so no run forms.
+      {"no repeated width", {1, 8, 3, 16}, 0},
+      // Runs that end partway through the block.
+      {"two runs of two", {1, 1, 8, 8}, 0},
+      {"run then a change", {4, 4, 4, 16}, 0},
+      // Zero-width miniblocks beside a run.
+      {"zero widths first", {0, 0, 3, 3}, 0},
+      {"zero widths last", {3, 3, 0, 0}, 0},
+      {"zero width inside a run", {3, 0, 3, 3}, 0},
+      // Widths match across a block boundary, where a run must still stop.
+      {"across a block boundary", {4, 4, 4, 4, 4, 4, 4, 4}, 0},
+      // A final block that ends in the middle of a miniblock.
+      {"partial last block", {4, 4, 4, 4}, 5},
+  };
+
+  for (const auto& c : cases) {
+    for (const T frame : {T{0}, static_cast<T>(-5)}) {
+      ARROW_SCOPED_TRACE("case = ", c.name, ", frame = ", static_cast<int64_t>(frame));
+      this->CheckRoundtripWithValues(make_values(c.widths, frame, c.trailing_values));
+    }
+  }
+}
+
+TYPED_TEST(TestDeltaBitPackEncoding, PrefixSumVectorAndTail) {
+  // A decoder may accumulate the running total several deltas at a time and finish the
+  // remainder one at a time. Walk every residual bit width at enough lengths to leave
+  // every remainder such a group can leave, so each width is decoded through the
+  // grouped path, through the remainder, and across the hand-off between them. A
+  // non-zero frame checks the running multiple, and wrapping the total checks that no
+  // term is signed.
+  using T = typename TypeParam::c_type;
+  using UT = std::make_unsigned_t<T>;
+  constexpr int kBits = static_cast<int>(sizeof(T) * 8);
+
+  auto make_values = [](int width, T frame, int num_deltas) {
+    std::vector<T> values;
+    values.reserve(num_deltas + 1);
+    const UT spread = width == kBits ? ~UT{0} : static_cast<UT>((UT{1} << width) - 1);
+    // Two deltas in three sit at the frame, so it is the smallest in every miniblock.
+    UT current = 0;
+    values.push_back(static_cast<T>(current));
+    for (int i = 0; i < num_deltas; ++i) {
+      current = static_cast<UT>(current + static_cast<UT>(frame) +
+                                (i % 3 == 0 ? spread : UT{0}));
+      values.push_back(static_cast<T>(current));
+    }
+    return values;
+  };
+
+  for (int width = 0; width <= kBits; ++width) {
+    for (const T frame : {T{0}, static_cast<T>(-5), T{7}}) {
+      // 16-23 leaves every remainder for group sizes up to eight; 201 crosses a block
+      // boundary with a remainder left.
+      for (const int num_deltas : {16, 17, 18, 19, 20, 21, 22, 23, 201}) {
+        ARROW_SCOPED_TRACE("width = ", width, ", frame = ", static_cast<int64_t>(frame),
+                           ", num_deltas = ", num_deltas);
+        this->CheckRoundtripWithValues(make_values(width, frame, num_deltas));
+      }
+    }
+  }
+}
+
+// ----------------------------------------------------------------------
+// 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());
+}
+
+TYPED_TEST(TestPforEncoding, RejectsPageWithUnreadValues) {
+  using c_type = typename TypeParam::c_type;
+  constexpr int kNumValues = 200;
+  constexpr int kNullCount = 30;
+
+  std::vector<c_type> values(kNumValues);
+  std::iota(values.begin(), values.end(), static_cast<c_type>(0));
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::PFOR,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  encoder->Put(values.data(), kNumValues);
+  auto encoded = encoder->FlushValues();
+
+  std::vector<uint8_t> valid_bits(bit_util::BytesForBits(kNumValues), 0);
+  for (int i = 0; i < kNumValues - kNullCount; ++i) {
+    bit_util::SetBit(valid_bits.data(), i);
+  }
+  std::vector<c_type> output(kNumValues);
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::PFOR, this->descr_.get());
+  decoder->SetData(kNumValues, encoded->data(), static_cast<int>(encoded->size()));
+  ASSERT_THROW(decoder->DecodeSpaced(output.data(), kNumValues, kNullCount,
+                                     valid_bits.data(), /*valid_bits_offset=*/0),
+               ParquetException);
+}
+
+TYPED_TEST(TestPforEncoding, RejectsNegativeArguments) {
+  using c_type = typename TypeParam::c_type;
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::PFOR, this->descr_.get());
+  uint8_t byte = 0;
+  ASSERT_THROW(decoder->SetData(-1, &byte, 1), ParquetException);
+  ASSERT_THROW(decoder->SetData(0, &byte, -1), ParquetException);
+
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::PFOR,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  const c_type value = 7;
+  encoder->Put(&value, 1);
+  auto encoded = encoder->FlushValues();
+  decoder->SetData(1, encoded->data(), static_cast<int>(encoded->size()));
+  c_type output{};
+  ASSERT_THROW(decoder->Decode(&output, -1), ParquetException);
+}
+
+// ----------------------------------------------------------------------
+// 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..c4a6fc55d19b
--- /dev/null
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -0,0 +1,1784 @@
+// 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). The columns are
+// generated by pfor_corpus_internal.h, which also says what they are and are
+// not.
+
+#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/bit_util.h"
+#include "arrow/util/bpacking_internal.h"
+#include "arrow/util/compression.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/logging.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+#include "arrow/util/rle_encoding_internal.h"
+
+#include "parquet/encoding.h"
+#include "parquet/pfor_corpus_internal.h"
+#include "parquet/platform.h"
+#include "parquet/schema.h"
+#include "parquet/types.h"
+
+using ::arrow::Compression;
+using ::arrow::util::Codec;
+
+namespace parquet {
+namespace {
+
+// The columns themselves are in pfor_corpus_internal.h.
+namespace delta_shapes = corpus::delta_shapes;
+
+// 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>;
+
+// Payload used when a PFOR vector is placed in delta mode. Both layouts are
+// independently restarted at every 1024-value PFOR vector boundary.
+enum class PforDeltaLayout {
+  kPatchedDelta,
+  kDeltaBinaryPacked,
+};
+
+// 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;
+};
+
+// ----------------------------------------------------------------------
+// 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 ::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);
+
+  // 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,
+      options));
+
+  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,
+        options));
+    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 benchmark.
+//
+// Output-buffer placement can affect decoder measurements. Sharing one aligned
+// buffer ensures that every variant writes to the same addresses, isolating
+// differences in decoder code.
+//
+// Safe to share: benchmarks in a process run one at a time, and each one
+// 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);
+}
+static void BM_PforRawEncode(benchmark::State& state, Gen32 gen) {
+  PforEncodeImpl<int32_t>(state, gen, {.delta_enabled = false, .force_delta = false});
+}
+static void BM_PforRaw64Encode(benchmark::State& state, Gen64 gen) {
+  PforEncodeImpl<int64_t>(state, gen, {.delta_enabled = false, .force_delta = false});
+}
+
+template <typename T>
+static void PforDecodeImpl(benchmark::State& state, GenT<T> gen,
+                           const ::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 benchmarks 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);
+}
+
+// ----------------------------------------------------------------------
+// PFOR-DBPDelta Encode/Decode
+
+// Model the alternative wire layout directly: the outer PFOR page keeps its
+// seven-byte header and one four-byte offset per vector, while each vector body
+// is an independently decodable DELTA_BINARY_PACKED stream. Consequently DBP's
+// first value and block header restart at every PFOR vector boundary.
+template <typename T>
+static int64_t PforDbpOuterBytes(int64_t num_values) {
+  constexpr int64_t kVectorSize = ::arrow::util::pfor::PforConstants::kPforVectorSize;
+  const int64_t num_vectors = ::arrow::bit_util::CeilDiv(num_values, kVectorSize);
+  return ::arrow::util::pfor::PforConstants::kHeaderSize +
+         num_vectors * sizeof(::arrow::util::pfor::PforConstants::OffsetType);
+}
+
+template <typename T>
+static void PforDbpDeltaEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  using PType = typename PqTraits<T>::PType;
+  constexpr int64_t kVectorSize = ::arrow::util::pfor::PforConstants::kPforVectorSize;
+  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);
+
+  int64_t comp_size = PforDbpOuterBytes<T>(num_values);
+  for (int64_t start = 0; start < num_values; start += kVectorSize) {
+    const int count = static_cast<int>(std::min(kVectorSize, num_values - start));
+    encoder->Put(values.data() + start, count);
+    comp_size += encoder->FlushValues()->size();
+  }
+
+  for (auto _ : state) {
+    int64_t encoded_bytes = PforDbpOuterBytes<T>(num_values);
+    for (int64_t start = 0; start < num_values; start += kVectorSize) {
+      const int count = static_cast<int>(std::min(kVectorSize, num_values - start));
+      encoder->Put(values.data() + start, count);
+      encoded_bytes += encoder->FlushValues()->size();
+    }
+    benchmark::DoNotOptimize(encoded_bytes);
+  }
+
+  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 PforDbpDeltaDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  using PType = typename PqTraits<T>::PType;
+  constexpr int64_t kVectorSize = ::arrow::util::pfor::PforConstants::kPforVectorSize;
+  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);
+  std::vector<std::shared_ptr<Buffer>> vectors;
+  int64_t comp_size = PforDbpOuterBytes<T>(num_values);
+  for (int64_t start = 0; start < num_values; start += kVectorSize) {
+    const int count = static_cast<int>(std::min(kVectorSize, num_values - start));
+    encoder->Put(values.data() + start, count);
+    vectors.push_back(encoder->FlushValues());
+    comp_size += vectors.back()->size();
+  }
+
+  auto decoder = MakeTypedDecoder<PType>(Encoding::DELTA_BINARY_PACKED);
+  std::vector<T> decoded(num_values);
+  for (auto _ : state) {
+    int64_t start = 0;
+    for (const auto& vector : vectors) {
+      const int count = static_cast<int>(std::min(kVectorSize, num_values - start));
+      decoder->SetData(count, vector->data(), static_cast<int>(vector->size()));
+      ARROW_CHECK_EQ(decoder->Decode(decoded.data() + start, count), count);
+      start += count;
+    }
+    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);
+}
+
+template <PforDeltaLayout Layout, typename T>
+static void PforDeltaLayoutEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  if constexpr (Layout == PforDeltaLayout::kPatchedDelta) {
+    PforEncodeImpl<T>(state, gen, {.delta_enabled = true, .force_delta = true});
+  } else {
+    PforDbpDeltaEncodeImpl<T>(state, gen);
+  }
+}
+
+template <PforDeltaLayout Layout, typename T>
+static void PforDeltaLayoutDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  if constexpr (Layout == PforDeltaLayout::kPatchedDelta) {
+    PforDecodeImpl<T>(state, gen, {.delta_enabled = true, .force_delta = true});
+  } else {
+    PforDbpDeltaDecodeImpl<T>(state, gen);
+  }
+}
+
+static void BM_PforPatchedDeltaEncode(benchmark::State& state, Gen32 gen) {
+  PforDeltaLayoutEncodeImpl<PforDeltaLayout::kPatchedDelta, int32_t>(state, gen);
+}
+static void BM_PforPatchedDelta64Encode(benchmark::State& state, Gen64 gen) {
+  PforDeltaLayoutEncodeImpl<PforDeltaLayout::kPatchedDelta, int64_t>(state, gen);
+}
+static void BM_PforPatchedDeltaDecode(benchmark::State& state, Gen32 gen) {
+  PforDeltaLayoutDecodeImpl<PforDeltaLayout::kPatchedDelta, int32_t>(state, gen);
+}
+static void BM_PforPatchedDelta64Decode(benchmark::State& state, Gen64 gen) {
+  PforDeltaLayoutDecodeImpl<PforDeltaLayout::kPatchedDelta, int64_t>(state, gen);
+}
+
+static void BM_PforDbpDeltaEncode(benchmark::State& state, Gen32 gen) {
+  PforDeltaLayoutEncodeImpl<PforDeltaLayout::kDeltaBinaryPacked, int32_t>(state, gen);
+}
+static void BM_PforDbpDelta64Encode(benchmark::State& state, Gen64 gen) {
+  PforDeltaLayoutEncodeImpl<PforDeltaLayout::kDeltaBinaryPacked, int64_t>(state, gen);
+}
+static void BM_PforDbpDeltaDecode(benchmark::State& state, Gen32 gen) {
+  PforDeltaLayoutDecodeImpl<PforDeltaLayout::kDeltaBinaryPacked, int32_t>(state, gen);
+}
+static void BM_PforDbpDelta64Decode(benchmark::State& state, Gen64 gen) {
+  PforDeltaLayoutDecodeImpl<PforDeltaLayout::kDeltaBinaryPacked, int64_t>(state, gen);
+}
+
+// ----------------------------------------------------------------------
+
+// The two benchmarks 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 benchmark 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, .mode = ::arrow::util::pfor::PackingMode::kForBitPack});
+}
+static void BM_PforPlainInterleavedDecode(benchmark::State& state, Gen32 gen) {
+  PforDecodeImpl<int32_t>(
+      state, gen,
+      {.delta_enabled = false,
+       .mode = ::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
+
+// Codec::Create returns NotImplemented for a codec the build did not enable, and
+// dereferencing that Result aborts the process -- one unbuilt dependency would take
+// down every other benchmark registered in this binary. Report it as a skip instead.
+static std::unique_ptr<Codec> CodecOrSkip(benchmark::State& state,
+                                          Compression::type codec_type) {
+  auto maybe_codec = Codec::Create(codec_type);
+  if (!maybe_codec.ok()) {
+    state.SkipWithError(maybe_codec.status().ToString().c_str());
+    return nullptr;
+  }
+  return std::move(maybe_codec).ValueUnsafe();
+}
+
+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 = CodecOrSkip(state, codec_type);
+  if (codec == nullptr) return;
+  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 = CodecOrSkip(state, codec_type);
+  if (codec == nullptr) return;
+  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 = CodecOrSkip(state, codec_type);
+  if (codec == nullptr) return;
+
+  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 = CodecOrSkip(state, codec_type);
+  if (codec == nullptr) return;
+
+  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 ablation 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; if the two disagree, none of the ablations
+// 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 benchmark 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);
+  }
+}
+
+// Ablations, 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 benchmarks, 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. The 128/4 control is Arrow's default and
+// is registered as BM_DbpAbFull above; these vary how many values one unpack call
+// covers and how often a block header is parsed.
+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 one is a conforming decoder;
+// the other 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 go through the encoder and decoder the
+// library registers for the encoding, which is the same layout, base coding and
+// repair the kernel benchmark 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 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 it honest: without that, a
+  // benchmark that skipped the 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 benchmarks below answer the value-ordering question and only that.
+// 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 benchmark therefore charges the production side
+// 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 result.
+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 -- it 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 comparisons 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 the layout question 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 sizes are chosen 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 36 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 -- at shared L3 capacity, 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_PforRawEncode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_PforPatchedDeltaEncode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PforPatchedDeltaDecode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PforDbpDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PforDbpDeltaDecode, 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_PforRaw64Encode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_PforPatchedDelta64Encode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PforPatchedDelta64Decode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PforDbpDelta64Encode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PforDbpDelta64Decode, 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, corpus::GenClientIP)
+REGISTER_DATASET(UrlRegionID, corpus::GenUrlRegionID)
+REGISTER_DATASET(CounterID, corpus::GenCounterID)
+REGISTER_DATASET(EventDate, corpus::GenEventDate)
+REGISTER_DATASET(EventTime, corpus::GenEventTime)
+REGISTER_DATASET(GoodEvent, corpus::GenGoodEvent)
+REGISTER_DATASET(HID, corpus::GenHID)
+REGISTER_DATASET(HitColor, corpus::GenHitColor)
+REGISTER_DATASET(IPNetworkID, corpus::GenIPNetworkID)
+REGISTER_DATASET(JavaEnable, corpus::GenJavaEnable)
+REGISTER_DATASET(OS, corpus::GenOS)
+REGISTER_DATASET(Resolution, corpus::GenResolution)
+REGISTER_DATASET(TrafficSourceID, corpus::GenTrafficSourceID)
+REGISTER_DATASET(UserAgent, corpus::GenUserAgent)
+
+// TPC-DS datasets
+REGISTER_DATASET(TpcdsSoldDateSk, corpus::GenTpcdsSoldDateSk)
+REGISTER_DATASET(TpcdsStoreSk, corpus::GenTpcdsStoreSk)
+REGISTER_DATASET(TpcdsItemSk, corpus::GenTpcdsItemSk)
+REGISTER_DATASET(TpcdsQuantity, corpus::GenTpcdsQuantity)
+REGISTER_DATASET(TpcdsCustomerSk, corpus::GenTpcdsCustomerSk)
+REGISTER_DATASET(TpcdsExtSalesPrice, corpus::GenTpcdsExtSalesPrice)
+REGISTER_DATASET(TpcdsNetProfit, corpus::GenTpcdsNetProfit)
+REGISTER_DATASET(TpcdsDYear, corpus::GenTpcdsDYear)
+// TPC-H datasets
+REGISTER_DATASET(TpchLQuantity, corpus::GenTpchLQuantity)
+REGISTER_DATASET(TpchLExtendedPrice, corpus::GenTpchLExtendedPrice)
+REGISTER_DATASET(TpchLDiscount, corpus::GenTpchLDiscount)
+REGISTER_DATASET(TpchLShipDate, corpus::GenTpchLShipDate)
+// NYC taxi datasets
+REGISTER_DATASET(TaxiPickupUnixTime, corpus::GenTaxiPickupUnixTime)
+REGISTER_DATASET(TaxiTripDistanceX100, corpus::GenTaxiTripDistanceX100)
+REGISTER_DATASET(TaxiFareCents, corpus::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, corpus::GenSortedUnixTime)
+REGISTER_DATASET(SortedKeyDups, corpus::GenSortedKeyDups)
+REGISTER_DATASET(MonotoneRowId, corpus::GenMonotoneRowId)
+REGISTER_DATASET(NearSortedUnixTime, corpus::GenNearSortedUnixTime)
+// int64 / BIGINT datasets (8-byte signed values)
+REGISTER_DATASET64(TsNanos, corpus::GenTsNanos)
+REGISTER_DATASET64(OrderKey, corpus::GenOrderKey)
+REGISTER_DATASET64(PriceMicros, corpus::GenPriceMicros)
+REGISTER_DATASET64(SnowflakeId, corpus::GenSnowflakeId)
+REGISTER_DATASET64(ByteCount, corpus::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_corpus_internal.h b/cpp/src/parquet/pfor_corpus_internal.h
new file mode 100644
index 000000000000..206389669c31
--- /dev/null
+++ b/cpp/src/parquet/pfor_corpus_internal.h
@@ -0,0 +1,662 @@
+// 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 integer column corpus the PFOR comparison benchmarks generate: 43 int32
+// columns, a few int64 ones, and a group whose neighbouring values carry
+// structure. It lives in its own header so that every harness measuring
+// these columns reads one definition of them, rather than the benchmark file
+// carrying five hundred lines of generators inline. Nothing here
+// depends on anything but the standard library, so a harness that wants the
+// corpus does not have to pull in Parquet.
+//
+// The columns are synthetic. Each generator is shaped after a distribution seen
+// in ClickBench, TPC-DS, TPC-H or the NYC taxi set; none of them loads a record
+// from those datasets. Bit-unpacking throughput is data-independent at a fixed
+// width, so that substitution is harmless for a timing figure. It is not
+// harmless for any claim about how wide a column packs, since the generator's
+// autocorrelation is chosen rather than observed.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <random>
+#include <vector>
+
+namespace parquet {
+namespace corpus {
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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)
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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;
+}
+
+inline 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.
+inline 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.
+inline 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.
+inline 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.
+inline 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.
+inline 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.
+inline 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).
+inline 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.
+inline 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.
+inline 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.
+inline 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.
+inline 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.
+inline 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).
+inline 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.
+inline 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.
+inline 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.
+inline 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.
+inline 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.
+inline 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.
+inline 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).
+inline 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.
+//
+// They are templates rather than a pair of per-width functions, which keeps a
+// column's int32 and int64 registration on provably the same distribution. They
+// live in their own namespace because two of them build on base distributions
+// whose names are already taken above 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
+}  // namespace parquet
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..d098c0cde91b 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,29 @@ class PARQUET_EXPORT WriterProperties {
       return this;
     }
 
+    /// EXPERIMENTAL: Ask the PFOR encoder to use lane-interleaved bit packing.
+    ///
+    /// 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 +905,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 +1034,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 +1049,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 +1096,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 +1112,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 +1144,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 +1231,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 +1297,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 +1309,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 +1329,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
   };
 };