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/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake
index 21341167fe99..8887a1ed9294 100644
--- a/cpp/cmake_modules/SetupCxxFlags.cmake
+++ b/cpp/cmake_modules/SetupCxxFlags.cmake
@@ -633,21 +633,12 @@ endif()
 
 if(NOT MSVC)
   set(C_RELEASE_FLAGS "")
-  if(CMAKE_C_FLAGS_RELEASE MATCHES "-O3")
-    string(APPEND C_RELEASE_FLAGS " -O2")
-  endif()
+  # Local override: keep -O3 from CMake's default Release flags for the
+  # pfor benchmark — the bench is sensitive to inlining/unrolling that
+  # -O3 enables. Upstream Arrow downgrades to -O2 here; we skip that.
   set(CXX_RELEASE_FLAGS "")
-  if(CMAKE_CXX_FLAGS_RELEASE MATCHES "-O3")
-    string(APPEND CXX_RELEASE_FLAGS " -O2")
-  endif()
   set(C_RELWITHDEBINFO_FLAGS "")
-  if(CMAKE_C_FLAGS_RELWITHDEBINFO MATCHES "-O3")
-    string(APPEND C_RELWITHDEBINFO_FLAGS " -O2")
-  endif()
   set(CXX_RELWITHDEBINFO_FLAGS "")
-  if(CMAKE_CXX_FLAGS_RELWITHDEBINFO MATCHES "-O3")
-    string(APPEND CXX_RELWITHDEBINFO_FLAGS " -O2")
-  endif()
   if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     string(APPEND C_RELEASE_FLAGS " -ftree-vectorize")
     string(APPEND CXX_RELEASE_FLAGS " -ftree-vectorize")
diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 8750598f6c3b..0a239e893258 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -566,6 +566,8 @@ set(ARROW_UTIL_SRCS
     util/math_internal.cc
     util/memory.cc
     util/mutex.cc
+    util/pfor/pfor.cc
+    util/pfor/pfor_wrapper.cc
     util/ree_util.cc
     util/secure_string.cc
     util/string.cc
diff --git a/cpp/src/arrow/meson.build b/cpp/src/arrow/meson.build
index 831bc1218083..ebba2cd22fbb 100644
--- a/cpp/src/arrow/meson.build
+++ b/cpp/src/arrow/meson.build
@@ -204,6 +204,8 @@ arrow_util_srcs = [
     'util/math_internal.cc',
     'util/memory.cc',
     'util/mutex.cc',
+    'util/pfor/pfor.cc',
+    'util/pfor/pfor_wrapper.cc',
     'util/ree_util.cc',
     'util/secure_string.cc',
     'util/string.cc',
diff --git a/cpp/src/arrow/util/CMakeLists.txt b/cpp/src/arrow/util/CMakeLists.txt
index 628e9a4d1c7e..9be9dbfa7188 100644
--- a/cpp/src/arrow/util/CMakeLists.txt
+++ b/cpp/src/arrow/util/CMakeLists.txt
@@ -118,6 +118,10 @@ add_arrow_test(threading-utility-test
                test_common.cc
                thread_pool_test.cc)
 
+add_arrow_test(pfor-test SOURCES pfor/pfor_test.cc)
+
+add_arrow_benchmark(pfor/pfor_benchmark)
+
 add_arrow_benchmark(bit_block_counter_benchmark)
 add_arrow_benchmark(bit_util_benchmark)
 add_arrow_benchmark(bitmap_reader_benchmark)
diff --git a/cpp/src/arrow/util/bpacking.cc b/cpp/src/arrow/util/bpacking.cc
index 1bf81df4f28f..4a2ec0f9c059 100644
--- a/cpp/src/arrow/util/bpacking.cc
+++ b/cpp/src/arrow/util/bpacking.cc
@@ -43,6 +43,23 @@ struct UnpackDynamicFunction {
   }
 };
 
+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>)      //
+        ARROW_DISPATCH_TARGET_AVX512(&bpacking::unpack_bias_avx512<Uint>)  //
+    };
+  }
+};
+
 }  // namespace
 
 template <typename Uint>
@@ -57,4 +74,19 @@ template void unpack<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&);
 template void unpack<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void unpack<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void unpack_bias(const uint8_t* in, Uint* out, const UnpackOptions& opts, Uint bias) {
+  static const DynamicDispatch<UnpackBiasDynamicFunction<Uint>> dispatch;
+  return dispatch(in, out, opts, bias);
+}
+
+template void unpack_bias<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&,
+                                   uint8_t);
+template void unpack_bias<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&,
+                                    uint16_t);
+template void unpack_bias<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&,
+                                    uint32_t);
+template void unpack_bias<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&,
+                                    uint64_t);
+
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_dispatch_internal.h b/cpp/src/arrow/util/bpacking_dispatch_internal.h
index 6ea6adee1800..a2f344009233 100644
--- a/cpp/src/arrow/util/bpacking_dispatch_internal.h
+++ b/cpp/src/arrow/util/bpacking_dispatch_internal.h
@@ -31,23 +31,54 @@
 namespace arrow::internal::bpacking {
 
 /// Unpack a zero bit packed array.
-template <typename Uint>
-ARROW_FORCE_INLINE void unpack_null(const uint8_t* in, Uint* out, int batch_size) {
-  std::memset(out, 0, batch_size * sizeof(Uint));
+template <bool kHasBias = false, typename Uint>
+ARROW_FORCE_INLINE void unpack_null(const uint8_t* in, Uint* out, int batch_size,
+                                    Uint bias = Uint{}) {
+  if constexpr (kHasBias) {
+    // Every unpacked value is zero, so every output value is the bias.
+    std::fill(out, out + batch_size, bias);
+  } else {
+    std::memset(out, 0, batch_size * sizeof(Uint));
+  }
 }
 
 /// Unpack a packed array where packed and unpacked values have exactly the same number of
 /// bits.
-template <typename Uint>
-ARROW_FORCE_INLINE void unpack_full(const uint8_t* in, Uint* out, int batch_size) {
+template <bool kHasBias = false, typename Uint>
+ARROW_FORCE_INLINE void unpack_full(const uint8_t* in, Uint* out, int batch_size,
+                                    Uint bias = Uint{}) {
   if constexpr (ARROW_LITTLE_ENDIAN == 1) {
-    std::memcpy(out, in, batch_size * sizeof(Uint));
+    if constexpr (kHasBias) {
+      // Two things are needed for this loop to reach memcpy speed, and it is
+      // 10.8x slower than the memcpy below without them -- far worse than the
+      // second add pass the bias exists to remove.
+      //   1. A constant-size memcpy for the load, not SafeLoadAs: SafeLoadAs
+      //      builds an AlignedStorage per element and the vectorizer refuses it,
+      //      while a fixed-size memcpy is just an unaligned load.
+      //   2. A restrict qualifier: `in` is a uint8_t*, so it may alias
+      //      anything, including `out`. Without restating that they are
+      //      distinct the compiler has to assume overlap and emits a scalar
+      //      loop.
+      const uint8_t* ARROW_RESTRICT src = in;
+      Uint* ARROW_RESTRICT dst = out;
+      for (int k = 0; k < batch_size; k += 1) {
+        Uint val;
+        std::memcpy(&val, src + (k * sizeof(Uint)), sizeof(Uint));
+        dst[k] = static_cast<Uint>(val + bias);
+      }
+    } else {
+      std::memcpy(out, in, batch_size * sizeof(Uint));
+    }
   } else {
     using bit_util::FromLittleEndian;
     using util::SafeLoadAs;
 
     for (int k = 0; k < batch_size; k += 1) {
-      out[k] = FromLittleEndian(SafeLoadAs<Uint>(in + (k * sizeof(Uint))));
+      Uint val = FromLittleEndian(SafeLoadAs<Uint>(in + (k * sizeof(Uint))));
+      if constexpr (kHasBias) {
+        val = static_cast<Uint>(val + bias);
+      }
+      out[k] = val;
     }
   }
 }
@@ -96,9 +127,9 @@ using SpreadBufferUint = std::conditional_t<
 /// This function works for all input batch sizes but is not the fastest.
 /// In prolog mode, instead of unpacking all required element, the function will
 /// stop if it finds a byte aligned value start.
-template <int kPackedBitWidth, bool kIsProlog, typename Uint>
+template <int kPackedBitWidth, bool kIsProlog, bool kHasBias = false, typename Uint>
 ARROW_FORCE_INLINE int unpack_exact(const uint8_t* in, const uint8_t* in_end, Uint* out,
-                                    int batch_size, int bit_offset) {
+                                    int batch_size, int bit_offset, Uint bias = Uint{}) {
   static_assert(kPackedBitWidth > 0);
 
   // For the epilog we adapt the max spread since better alignment give shorter spreads
@@ -168,6 +199,9 @@ ARROW_FORCE_INLINE int unpack_exact(const uint8_t* in, const uint8_t* in_end, Ui
       }
     }
 
+    if constexpr (kHasBias) {
+      val = static_cast<Uint>(val + bias);
+    }
     *out = val;
     out++;
     start_bit += kPackedBitWidth;
@@ -190,12 +224,12 @@ ARROW_FORCE_INLINE int unpack_exact(const uint8_t* in, const uint8_t* in_end, Ui
 ///                       This is used to safely overread.
 ///                       Negative value to deduce from batch_size.
 template <int kPackedBitWidth, template <typename, int> typename Unpacker,
-          typename UnpackedUInt>
+          bool kHasBias = false, typename UnpackedUInt>
 void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_offset,
-                  int max_read_bytes) {
+                  int max_read_bytes, UnpackedUInt bias = UnpackedUInt{}) {
   if constexpr (kPackedBitWidth == 0) {
     // Easy case to handle, simply setting memory to zero.
-    return unpack_null(in, out, batch_size);
+    return unpack_null<kHasBias>(in, out, batch_size, bias);
   } else {
     // Number of bytes to read according to batch_size.
     const int bytes_batch = static_cast<int>(
@@ -206,8 +240,8 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
     const uint8_t* in_end = in + (max_read_bytes >= 0 ? max_read_bytes : bytes_batch);
 
     // In case of misalignment, we need to run the prolog until aligned.
-    int extracted =
-        unpack_exact<kPackedBitWidth, true>(in, in_end, out, batch_size, bit_offset);
+    int extracted = unpack_exact<kPackedBitWidth, true, kHasBias>(
+        in, in_end, out, batch_size, bit_offset, bias);
     // We either extracted everything or found a alignment
     const int start_bit = extracted * kPackedBitWidth + bit_offset;
     ARROW_DCHECK((extracted == batch_size) || ((start_bit) % 8 == 0));
@@ -218,7 +252,7 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
 
     if constexpr (kPackedBitWidth == 8 * sizeof(UnpackedUInt)) {
       // Only memcpy / static_cast
-      return unpack_full(in, out, batch_size);
+      return unpack_full<kHasBias>(in, out, batch_size, bias);
     } else {
       using UnpackerForWidth = Unpacker<UnpackedUInt, kPackedBitWidth>;
       // Number of values extracted by one iteration of the kernel
@@ -229,9 +263,30 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
 
       if constexpr (kValuesUnpacked > 0) {
         const uint8_t* in_last = in_end - kBytesRead;
+        // Whether this unpacker family folds the bias into its own stores. The
+        // xsimd kernels do; the generated scalar and AVX-512 families do not, so
+        // they get a second pass over the values the kernel just wrote. That
+        // pass is over kValuesUnpacked elements still in L1, not over the whole
+        // output, but it is a second pass all the same and the measured cost of
+        // one is 1.47-2.40x the unpack -- so the fallback is for correctness on
+        // those targets, not a substitute for folding it in.
+        constexpr bool kUnpackerTakesBias =
+            requires(const uint8_t* i, UnpackedUInt* o, UnpackedUInt b) {
+              UnpackerForWidth::unpack(i, o, b);
+            };  // NOLINT(readability/braces)
+
         // Running the optimized kernel for batch extraction
         while ((batch_size >= kValuesUnpacked) && (in <= in_last)) {
-          in = UnpackerForWidth::unpack(in, out);
+          if constexpr (kHasBias && kUnpackerTakesBias) {
+            in = UnpackerForWidth::unpack(in, out, bias);
+          } else {
+            in = UnpackerForWidth::unpack(in, out);
+            if constexpr (kHasBias) {
+              for (int k = 0; k < kValuesUnpacked; ++k) {
+                out[k] = static_cast<UnpackedUInt>(out[k] + bias);
+              }
+            }
+          }
           out += kValuesUnpacked;
           batch_size -= kValuesUnpacked;
         }
@@ -245,406 +300,412 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
       // Running the epilog for the remaining values that don't fit in a kernel
       ARROW_DCHECK_GE(batch_size, 0);
       ARROW_COMPILER_ASSUME(batch_size >= 0);
-      unpack_exact<kPackedBitWidth, false>(in, in_end, out, batch_size,
-                                           /* bit_offset= */ 0);
+      unpack_exact<kPackedBitWidth, false, kHasBias>(in, in_end, out, batch_size,
+                                                     /* bit_offset= */ 0, bias);
     }
   }
 }
 
-template <template <typename, int> typename Unpacker, typename UnpackedUint>
-static void unpack_jump(const uint8_t* in, UnpackedUint* out, const UnpackOptions& opt) {
+template <template <typename, int> typename Unpacker, bool kHasBias = false,
+          typename UnpackedUint>
+static void unpack_jump(const uint8_t* in, UnpackedUint* out, const UnpackOptions& opt,
+                        UnpackedUint bias = UnpackedUint{}) {
+  // A bias on a bool output would have to saturate rather than add, which is not
+  // what any caller means by it.
+  static_assert(!(kHasBias && std::is_same_v<UnpackedUint, bool>),
+                "unpack with a bias is not defined for bool output");
   if constexpr (std::is_same_v<UnpackedUint, bool>) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 1) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 2) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<9, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<10, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<11, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<12, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<13, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<14, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<15, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<16, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 4) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<9, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<10, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<11, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<12, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<13, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<14, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<15, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<16, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 17:
-        return unpack_width<17, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<17, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 18:
-        return unpack_width<18, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<18, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 19:
-        return unpack_width<19, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<19, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 20:
-        return unpack_width<20, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<20, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 21:
-        return unpack_width<21, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<21, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 22:
-        return unpack_width<22, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<22, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 23:
-        return unpack_width<23, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<23, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 24:
-        return unpack_width<24, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<24, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 25:
-        return unpack_width<25, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<25, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 26:
-        return unpack_width<26, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<26, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 27:
-        return unpack_width<27, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<27, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 28:
-        return unpack_width<28, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<28, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 29:
-        return unpack_width<29, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<29, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 30:
-        return unpack_width<30, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<30, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 31:
-        return unpack_width<31, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<31, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 32:
-        return unpack_width<32, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<32, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 8) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<9, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<10, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<11, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<12, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<13, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<14, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<15, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<16, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 17:
-        return unpack_width<17, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<17, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 18:
-        return unpack_width<18, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<18, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 19:
-        return unpack_width<19, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<19, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 20:
-        return unpack_width<20, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<20, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 21:
-        return unpack_width<21, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<21, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 22:
-        return unpack_width<22, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<22, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 23:
-        return unpack_width<23, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<23, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 24:
-        return unpack_width<24, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<24, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 25:
-        return unpack_width<25, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<25, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 26:
-        return unpack_width<26, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<26, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 27:
-        return unpack_width<27, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<27, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 28:
-        return unpack_width<28, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<28, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 29:
-        return unpack_width<29, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<29, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 30:
-        return unpack_width<30, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<30, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 31:
-        return unpack_width<31, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<31, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 32:
-        return unpack_width<32, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<32, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 33:
-        return unpack_width<33, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<33, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 34:
-        return unpack_width<34, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<34, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 35:
-        return unpack_width<35, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<35, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 36:
-        return unpack_width<36, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<36, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 37:
-        return unpack_width<37, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<37, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 38:
-        return unpack_width<38, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<38, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 39:
-        return unpack_width<39, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<39, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 40:
-        return unpack_width<40, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<40, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 41:
-        return unpack_width<41, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<41, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 42:
-        return unpack_width<42, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<42, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 43:
-        return unpack_width<43, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<43, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 44:
-        return unpack_width<44, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<44, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 45:
-        return unpack_width<45, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<45, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 46:
-        return unpack_width<46, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<46, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 47:
-        return unpack_width<47, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<47, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 48:
-        return unpack_width<48, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<48, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 49:
-        return unpack_width<49, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<49, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 50:
-        return unpack_width<50, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<50, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 51:
-        return unpack_width<51, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<51, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 52:
-        return unpack_width<52, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<52, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 53:
-        return unpack_width<53, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<53, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 54:
-        return unpack_width<54, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<54, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 55:
-        return unpack_width<55, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<55, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 56:
-        return unpack_width<56, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<56, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 57:
-        return unpack_width<57, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<57, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 58:
-        return unpack_width<58, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<58, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 59:
-        return unpack_width<59, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<59, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 60:
-        return unpack_width<60, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<60, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 61:
-        return unpack_width<61, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<61, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 62:
-        return unpack_width<62, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<62, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 63:
-        return unpack_width<63, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<63, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 64:
-        return unpack_width<64, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<64, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   }
   ARROW_DCHECK(false) << "Unsupported num_bits " << opt.bit_width;
diff --git a/cpp/src/arrow/util/bpacking_internal.h b/cpp/src/arrow/util/bpacking_internal.h
index 329a1ae959b5..dbdad2082c6b 100644
--- a/cpp/src/arrow/util/bpacking_internal.h
+++ b/cpp/src/arrow/util/bpacking_internal.h
@@ -48,4 +48,29 @@ extern template ARROW_TEMPLATE_EXPORT void unpack<uint32_t>(  //
 extern template ARROW_TEMPLATE_EXPORT void unpack<uint64_t>(  //
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+/// \brief Unpack, adding `bias` to every value.
+///
+/// Equivalent to `unpack()` followed by a loop adding `bias`, but the addition
+/// happens inside the unpacker before its store, so the output is traversed
+/// once instead of twice. Frame-of-reference decoders are the motivating
+/// caller: the separate add pass costs as much as the unpack it follows.
+///
+/// `bias + value` is computed in `Uint`, so it wraps rather than saturating.
+/// Not defined for `bool` output, where an add has no meaning.
+template <typename Uint>
+ARROW_EXPORT void unpack_bias(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                              Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint8_t>(  //
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint16_t>(  //
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint32_t>(  //
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint64_t>(  //
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_scalar.cc b/cpp/src/arrow/util/bpacking_scalar.cc
index 5226ad55cd3e..be3c9ded3462 100644
--- a/cpp/src/arrow/util/bpacking_scalar.cc
+++ b/cpp/src/arrow/util/bpacking_scalar.cc
@@ -33,4 +33,19 @@ template void unpack_scalar<uint16_t>(const uint8_t*, uint16_t*, const UnpackOpt
 template void unpack_scalar<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void unpack_scalar<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void unpack_bias_scalar(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                        Uint bias) {
+  return unpack_jump<ScalarUnpackerForWidth, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void unpack_bias_scalar<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&,
+                                          uint8_t);
+template void unpack_bias_scalar<uint16_t>(const uint8_t*, uint16_t*,
+                                           const UnpackOptions&, uint16_t);
+template void unpack_bias_scalar<uint32_t>(const uint8_t*, uint32_t*,
+                                           const UnpackOptions&, uint32_t);
+template void unpack_bias_scalar<uint64_t>(const uint8_t*, uint64_t*,
+                                           const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_scalar_internal.h b/cpp/src/arrow/util/bpacking_scalar_internal.h
index 2f62174f5f3f..c6a52a82e3b7 100644
--- a/cpp/src/arrow/util/bpacking_scalar_internal.h
+++ b/cpp/src/arrow/util/bpacking_scalar_internal.h
@@ -42,4 +42,20 @@ extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void unpack_bias_scalar(const uint8_t* in, Uint* out,
+                                     const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_simd_128.cc b/cpp/src/arrow/util/bpacking_simd_128.cc
index 1bc756b2aa7d..ee90d22a37f5 100644
--- a/cpp/src/arrow/util/bpacking_simd_128.cc
+++ b/cpp/src/arrow/util/bpacking_simd_128.cc
@@ -17,9 +17,11 @@
 
 #if defined(ARROW_HAVE_NEON)
 #  define UNPACK_PLATFORM unpack_neon
+#  define UNPACK_BIAS_PLATFORM unpack_bias_neon
 #  define KERNEL_PLATFORM KernelNeon
 #elif defined(ARROW_HAVE_SSE4_2)
 #  define UNPACK_PLATFORM unpack_sse4_2
+#  define UNPACK_BIAS_PLATFORM unpack_bias_sse4_2
 #  define KERNEL_PLATFORM KernelSse42
 #endif
 
@@ -45,7 +47,23 @@ template void UNPACK_PLATFORM<uint16_t>(const uint8_t*, uint16_t*, const UnpackO
 template void UNPACK_PLATFORM<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void UNPACK_PLATFORM<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void UNPACK_BIAS_PLATFORM(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                          Uint bias) {
+  return unpack_jump<KERNEL_PLATFORM, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void UNPACK_BIAS_PLATFORM<uint8_t>(const uint8_t*, uint8_t*,
+                                            const UnpackOptions&, uint8_t);
+template void UNPACK_BIAS_PLATFORM<uint16_t>(const uint8_t*, uint16_t*,
+                                             const UnpackOptions&, uint16_t);
+template void UNPACK_BIAS_PLATFORM<uint32_t>(const uint8_t*, uint32_t*,
+                                             const UnpackOptions&, uint32_t);
+template void UNPACK_BIAS_PLATFORM<uint64_t>(const uint8_t*, uint64_t*,
+                                             const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
 
 #  undef UNPACK_PLATFORM
+#  undef UNPACK_BIAS_PLATFORM
 #endif  // UNPACK_PLATFORM
diff --git a/cpp/src/arrow/util/bpacking_simd_128_alt.cc b/cpp/src/arrow/util/bpacking_simd_128_alt.cc
index bd4799d3cd31..9ffaec4899b5 100644
--- a/cpp/src/arrow/util/bpacking_simd_128_alt.cc
+++ b/cpp/src/arrow/util/bpacking_simd_128_alt.cc
@@ -17,6 +17,7 @@
 
 #if defined(ARROW_HAVE_RUNTIME_SVE128)
 #  define UNPACK_PLATFORM unpack_sve128
+#  define UNPACK_BIAS_PLATFORM unpack_bias_sve128
 #  define KERNEL_PLATFORM KernelSve128
 #endif
 
@@ -46,6 +47,22 @@ template void UNPACK_PLATFORM<uint16_t>(const uint8_t*, uint16_t*, const UnpackO
 template void UNPACK_PLATFORM<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void UNPACK_PLATFORM<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void UNPACK_BIAS_PLATFORM(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                          Uint bias) {
+  return unpack_jump<KERNEL_PLATFORM, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void UNPACK_BIAS_PLATFORM<uint8_t>(const uint8_t*, uint8_t*,
+                                            const UnpackOptions&, uint8_t);
+template void UNPACK_BIAS_PLATFORM<uint16_t>(const uint8_t*, uint16_t*,
+                                             const UnpackOptions&, uint16_t);
+template void UNPACK_BIAS_PLATFORM<uint32_t>(const uint8_t*, uint32_t*,
+                                             const UnpackOptions&, uint32_t);
+template void UNPACK_BIAS_PLATFORM<uint64_t>(const uint8_t*, uint64_t*,
+                                             const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
 
 #undef UNPACK_PLATFORM
+#undef UNPACK_BIAS_PLATFORM
diff --git a/cpp/src/arrow/util/bpacking_simd_256.cc b/cpp/src/arrow/util/bpacking_simd_256.cc
index 8c5ce4dc7d06..98f7d210fb94 100644
--- a/cpp/src/arrow/util/bpacking_simd_256.cc
+++ b/cpp/src/arrow/util/bpacking_simd_256.cc
@@ -17,9 +17,11 @@
 
 #if defined(ARROW_HAVE_SVE256) || defined(ARROW_HAVE_RUNTIME_SVE256)
 #  define UNPACK_PLATFORM unpack_sve256
+#  define UNPACK_BIAS_PLATFORM unpack_bias_sve256
 #  define KERNEL_PLATFORM KernelSve256
 #elif defined(ARROW_HAVE_RUNTIME_AVX2)
 #  define UNPACK_PLATFORM unpack_avx2
+#  define UNPACK_BIAS_PLATFORM unpack_bias_avx2
 #  define KERNEL_PLATFORM KernelAvx2
 #endif
 
@@ -48,6 +50,22 @@ template void UNPACK_PLATFORM<uint16_t>(const uint8_t*, uint16_t*, const UnpackO
 template void UNPACK_PLATFORM<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void UNPACK_PLATFORM<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void UNPACK_BIAS_PLATFORM(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                          Uint bias) {
+  return unpack_jump<KERNEL_PLATFORM, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void UNPACK_BIAS_PLATFORM<uint8_t>(const uint8_t*, uint8_t*,
+                                            const UnpackOptions&, uint8_t);
+template void UNPACK_BIAS_PLATFORM<uint16_t>(const uint8_t*, uint16_t*,
+                                             const UnpackOptions&, uint16_t);
+template void UNPACK_BIAS_PLATFORM<uint32_t>(const uint8_t*, uint32_t*,
+                                             const UnpackOptions&, uint32_t);
+template void UNPACK_BIAS_PLATFORM<uint64_t>(const uint8_t*, uint64_t*,
+                                             const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
 
 #undef UNPACK_PLATFORM
+#undef UNPACK_BIAS_PLATFORM
diff --git a/cpp/src/arrow/util/bpacking_simd_avx512.cc b/cpp/src/arrow/util/bpacking_simd_avx512.cc
index bef7aebe175e..408ee5f3df19 100644
--- a/cpp/src/arrow/util/bpacking_simd_avx512.cc
+++ b/cpp/src/arrow/util/bpacking_simd_avx512.cc
@@ -33,4 +33,19 @@ template void unpack_avx512<uint16_t>(const uint8_t*, uint16_t*, const UnpackOpt
 template void unpack_avx512<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void unpack_avx512<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void unpack_bias_avx512(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                        Uint bias) {
+  return unpack_jump<Simd512UnpackerForWidth, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void unpack_bias_avx512<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&,
+                                          uint8_t);
+template void unpack_bias_avx512<uint16_t>(const uint8_t*, uint16_t*,
+                                           const UnpackOptions&, uint16_t);
+template void unpack_bias_avx512<uint32_t>(const uint8_t*, uint32_t*,
+                                           const UnpackOptions&, uint32_t);
+template void unpack_bias_avx512<uint64_t>(const uint8_t*, uint64_t*,
+                                           const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_simd_internal.h b/cpp/src/arrow/util/bpacking_simd_internal.h
index d5a81baaec09..3fbdaa8a237a 100644
--- a/cpp/src/arrow/util/bpacking_simd_internal.h
+++ b/cpp/src/arrow/util/bpacking_simd_internal.h
@@ -26,8 +26,10 @@ namespace arrow::internal::bpacking {
 
 #if defined(ARROW_HAVE_NEON)
 #  define UNPACK_ARCH128 unpack_neon
+#  define UNPACK_BIAS_ARCH128 unpack_bias_neon
 #elif defined(ARROW_HAVE_SSE4_2)
 #  define UNPACK_ARCH128 unpack_sse4_2
+#  define UNPACK_BIAS_ARCH128 unpack_bias_sse4_2
 #endif
 
 #if defined(UNPACK_ARCH128)
@@ -50,11 +52,29 @@ extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void UNPACK_BIAS_ARCH128(const uint8_t* in, Uint* out,
+                                      const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif  // UNPACK_ARCH128
 #undef UNPACK_ARCH128
+#undef UNPACK_BIAS_ARCH128
 
 #if defined(ARROW_HAVE_RUNTIME_SVE128)
 #  define UNPACK_ARCH128_ALT unpack_sve128
+#  define UNPACK_BIAS_ARCH128_ALT unpack_bias_sve128
 #endif
 
 #if defined(UNPACK_ARCH128_ALT)
@@ -78,13 +98,32 @@ extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128_ALT<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128_ALT<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void UNPACK_BIAS_ARCH128_ALT(const uint8_t* in, Uint* out,
+                                          const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif  // UNPACK_ARCH128_ALT
 #undef UNPACK_ARCH128_ALT
+#undef UNPACK_BIAS_ARCH128_ALT
 
 #if defined(ARROW_HAVE_SVE256) || defined(ARROW_HAVE_RUNTIME_SVE256)
 #  define UNPACK_ARCH256 unpack_sve256
+#  define UNPACK_BIAS_ARCH256 unpack_bias_sve256
 #elif defined(UNPACK_ARCH256) || defined(ARROW_HAVE_RUNTIME_AVX2)
 #  define UNPACK_ARCH256 unpack_avx2
+#  define UNPACK_BIAS_ARCH256 unpack_bias_avx2
 #endif
 
 #if defined(UNPACK_ARCH256)
@@ -107,8 +146,25 @@ extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH256<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH256<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void UNPACK_BIAS_ARCH256(const uint8_t* in, Uint* out,
+                                      const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif  // UNPACK_ARCH256
 #undef UNPACK_ARCH256
+#undef UNPACK_BIAS_ARCH256
 
 #if defined(ARROW_HAVE_AVX512) || defined(ARROW_HAVE_RUNTIME_AVX512)
 
@@ -130,6 +186,22 @@ extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void unpack_bias_avx512(const uint8_t* in, Uint* out,
+                                     const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif
 
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
index 83a969cca643..a9c36a8f4c1a 100644
--- a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
+++ b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
@@ -645,9 +645,10 @@ struct MediumKernel {
   static constexpr int kValuesUnpacked = kPlan.unpacked_per_kernel();
   static constexpr int kBytesRead = kPlan.total_bytes_read();
 
-  template <int kReadIdx, int kSwizzleIdx, int kShiftIdx>
+  template <bool kHasBias, int kReadIdx, int kSwizzleIdx, int kShiftIdx>
   ARROW_FORCE_INLINE static void unpack_one_shift_impl(const simd_batch& words,
-                                                       unpacked_type* out) {
+                                                       unpacked_type* out,
+                                                       const simd_batch& bias) {
     constexpr auto kRightShiftsArr =
         kPlan.shifts.at(kReadIdx).at(kSwizzleIdx).at(kShiftIdx);
     constexpr auto kRightShifts = array_to_batch_constant<kRightShiftsArr, arch_type>();
@@ -662,44 +663,62 @@ struct MediumKernel {
     const auto shifted = right_shift_by_excess(words, kRightShifts);
     const auto vals = shifted & kMask;
     if constexpr (std::is_same_v<unpacked_type, bool>) {
+      static_assert(!kHasBias, "no bias on bool output");
       const xsimd::batch_bool<uint_type, arch_type> bools = vals != 0;
       bools.store_unaligned(out + kOutOffset);
+    } else if constexpr (kHasBias) {
+      // The whole point: the bias lands before the store, so there is no second
+      // pass over the output to add it.
+      (vals + bias).store_unaligned(out + kOutOffset);
     } else {
       vals.store_unaligned(out + kOutOffset);
     }
   }
 
-  template <int kReadIdx, int kSwizzleIdx, int... kShiftIds>
+  template <bool kHasBias, int kReadIdx, int kSwizzleIdx, int... kShiftIds>
   ARROW_FORCE_INLINE static void unpack_one_swizzle_impl(
-      const simd_bytes& bytes, unpacked_type* out,
+      const simd_bytes& bytes, unpacked_type* out, const simd_batch& bias,
       std::integer_sequence<int, kShiftIds...>) {
     constexpr auto kSwizzlesArr = kPlan.swizzles.at(kReadIdx).at(kSwizzleIdx);
     constexpr auto kSwizzles = array_to_batch_constant<kSwizzlesArr, arch_type>();
 
     const auto swizzled = xsimd::swizzle(bytes, kSwizzles);
     const auto words = xsimd::bitwise_cast<uint_type>(swizzled);
-    (unpack_one_shift_impl<kReadIdx, kSwizzleIdx, kShiftIds>(words, out), ...);
+    (unpack_one_shift_impl<kHasBias, kReadIdx, kSwizzleIdx, kShiftIds>(words, out, bias),
+     ...);
   }
 
-  template <int kReadIdx, int... kSwizzleIds>
+  template <bool kHasBias, int kReadIdx, int... kSwizzleIds>
   ARROW_FORCE_INLINE static void unpack_one_read_impl(
-      const uint8_t* in, unpacked_type* out, std::integer_sequence<int, kSwizzleIds...>) {
+      const uint8_t* in, unpacked_type* out, const simd_batch& bias,
+      std::integer_sequence<int, kSwizzleIds...>) {
     using ShiftSeq = std::make_integer_sequence<int, kPlanSize.shifts_per_swizzle()>;
     const auto bytes =
         safe_load_bytes<kPlan.bytes_per_read(), arch_type>(in + kPlan.reads.at(kReadIdx));
-    (unpack_one_swizzle_impl<kReadIdx, kSwizzleIds>(bytes, out, ShiftSeq{}), ...);
+    (unpack_one_swizzle_impl<kHasBias, kReadIdx, kSwizzleIds>(bytes, out, bias,
+                                                              ShiftSeq{}),
+     ...);
   }
 
-  template <int... kReadIds>
+  template <bool kHasBias, int... kReadIds>
   ARROW_FORCE_INLINE static void unpack_all_impl(
-      const uint8_t* in, unpacked_type* out, std::integer_sequence<int, kReadIds...>) {
+      const uint8_t* in, unpacked_type* out, const simd_batch& bias,
+      std::integer_sequence<int, kReadIds...>) {
     using SwizzleSeq = std::make_integer_sequence<int, kPlanSize.swizzles_per_read()>;
-    (unpack_one_read_impl<kReadIds>(in, out, SwizzleSeq{}), ...);
+    (unpack_one_read_impl<kHasBias, kReadIds>(in, out, bias, SwizzleSeq{}), ...);
   }
 
   ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out) {
     using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
-    unpack_all_impl(in, out, ReadSeq{});
+    unpack_all_impl<false>(in, out, simd_batch{}, ReadSeq{});
+    return in + (kPlan.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
+  }
+
+  /// Same, with `bias` added to every value before it is stored.
+  ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out,
+                                                  unpacked_type bias) {
+    using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
+    unpack_all_impl<true>(in, out, simd_batch(static_cast<uint_type>(bias)), ReadSeq{});
     return in + (kPlan.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
   }
 };
@@ -934,9 +953,10 @@ struct LargeKernel {
   static constexpr int kValuesUnpacked = kPlanSize.unpacked_per_kernel();
   static constexpr int kBytesRead = kPlan.total_bytes_read();
 
-  template <int kReadIdx>
+  template <bool kHasBias, int kReadIdx>
   ARROW_FORCE_INLINE static void unpack_one_read_impl(const uint8_t* in,
-                                                      unpacked_type* out) {
+                                                      unpacked_type* out,
+                                                      const simd_batch& bias) {
     constexpr auto kLowSwizzles =
         array_to_batch_constant<kPlan.low_swizzles.at(kReadIdx), arch_type>();
     constexpr auto kLowRShifts =
@@ -967,18 +987,34 @@ struct LargeKernel {
     // We can have a single mask and apply it after OR because the shifts will ensure that
     // there are zeros where the high/low values are incomplete.
     const auto vals = (low_shifted | high_shifted) & kPlan.mask;
-    xsimd::store_unaligned(out + kReadIdx * kShape.unpacked_per_simd(), vals);
+    if constexpr (kHasBias) {
+      // As in MediumKernel: fold the bias into this store rather than sweeping
+      // the output again afterwards.
+      xsimd::store_unaligned(out + kReadIdx * kShape.unpacked_per_simd(), vals + bias);
+    } else {
+      xsimd::store_unaligned(out + kReadIdx * kShape.unpacked_per_simd(), vals);
+    }
   }
 
-  template <int... kReadIds>
+  template <bool kHasBias, int... kReadIds>
   ARROW_FORCE_INLINE static void unpack_all_impl(
-      const uint8_t* in, unpacked_type* out, std::integer_sequence<int, kReadIds...>) {
-    (unpack_one_read_impl<kReadIds>(in, out), ...);
+      const uint8_t* in, unpacked_type* out, const simd_batch& bias,
+      std::integer_sequence<int, kReadIds...>) {
+    (unpack_one_read_impl<kHasBias, kReadIds>(in, out, bias), ...);
   }
 
   ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out) {
     using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
-    unpack_all_impl(in, out, ReadSeq{});
+    unpack_all_impl<false>(in, out, simd_batch{}, ReadSeq{});
+    return in + (kPlan.kPlanSize.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
+  }
+
+  /// Same, with `bias` added to every value before it is stored.
+  ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out,
+                                                  unpacked_type bias) {
+    using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
+    unpack_all_impl<true>(
+        in, out, simd_batch(static_cast<typename Traits::uint_type>(bias)), ReadSeq{});
     return in + (kPlan.kPlanSize.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
   }
 };
@@ -1016,6 +1052,26 @@ struct CastingKernel : WorkingKernel {
     }
     return in;
   }
+
+  /// Same, with `bias` added to every value.
+  ///
+  /// The add goes in the cast loop, not in the working kernel's stores. The
+  /// working kernel can be *narrower* than `unpacked_type` (uint32 working /
+  /// uint64 unpacked on SSE4.2), and adding there would compute the bias modulo
+  /// the working width before widening -- wrong for any bias that does not fit.
+  /// Adding after the widening is correct for both directions, and the cast loop
+  /// was going to run anyway.
+  ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out,
+                                                  unpacked_type bias) {
+    using working_type = typename WorkingKernel::unpacked_type;
+
+    working_type buffer[kValuesUnpacked] = {};
+    in = WorkingKernel::unpack(in, buffer);
+    for (int k = 0; k < kValuesUnpacked; ++k) {
+      out[k] = static_cast<unpacked_type>(static_cast<unpacked_type>(buffer[k]) + bias);
+    }
+    return in;
+  }
 };
 
 /*******************************
diff --git a/cpp/src/arrow/util/bpacking_test.cc b/cpp/src/arrow/util/bpacking_test.cc
index d4d588228e7e..87e4570f4de8 100644
--- a/cpp/src/arrow/util/bpacking_test.cc
+++ b/cpp/src/arrow/util/bpacking_test.cc
@@ -321,4 +321,161 @@ TYPED_TEST(TestUnpack, UnpackSve256) {
 
 TYPED_TEST(TestUnpack, Unpack) { this->TestAll(&unpack<TypeParam>); }
 
+// ----------------------------------------------------------------------
+// unpack_bias
+
+template <typename Uint>
+using UnpackBiasFunc = void (*)(const uint8_t*, Uint*, const UnpackOptions&, Uint);
+
+template <typename Uint>
+class TestUnpackBias : public ::testing::Test {
+ protected:
+  /// `unpack_bias` must agree with `unpack` followed by an add, elementwise.
+  ///
+  /// This is a differential test against the plain unpacker on the same target,
+  /// which TestUnpack already covers, so it needs no second reference
+  /// implementation -- and it catches the failure mode that matters most here: a
+  /// kernel that folds the bias into some of its stores but not all of them.
+  void TestOne(UnpackBiasFunc<Uint> unpack_bias, UnpackFunc<Uint> unpack,
+               const UnpackOptions& opts, Uint bias) {
+    SCOPED_TRACE(::testing::Message() << "Testing bias=" << static_cast<uint64_t>(bias));
+
+    const auto original =
+        GenerateRandomValuesForPacking<Uint>(opts.batch_size, opts.bit_width);
+    const auto packed =
+        PackValues(original, opts.batch_size, opts.bit_width, opts.bit_offset);
+
+    std::vector<Uint> expected(opts.batch_size);
+    unpack(packed.data(), expected.data(), opts);
+    for (auto& v : expected) {
+      v = static_cast<Uint>(v + bias);
+    }
+
+    // Prefilled with a value the unpacker should never leave behind, so a store
+    // the kernel skips shows up as a mismatch rather than a lucky zero.
+    std::vector<Uint> actual(opts.batch_size, static_cast<Uint>(~Uint{0}));
+    unpack_bias(packed.data(), actual.data(), opts, bias);
+
+    ASSERT_EQ(expected, actual);
+  }
+
+  void TestAll(UnpackBiasFunc<Uint> unpack_bias, UnpackFunc<Uint> unpack) {
+    constexpr int kMaxBitWidth = 8 * sizeof(Uint);
+
+    // 0 must reproduce plain unpack. The top two force the add to wrap, which is
+    // the documented behaviour (the add is modular in Uint) and is what
+    // frame-of-reference callers rely on when they reinterpret the result as
+    // signed.
+    const std::vector<Uint> kBiases = {Uint{0}, Uint{1}, static_cast<Uint>(~Uint{0}),
+                                       static_cast<Uint>(Uint{1} << (kMaxBitWidth - 1))};
+
+    for (int num_values_base : {64, 128, 2048}) {
+      SCOPED_TRACE(::testing::Message() << "Testing num_values=" << num_values_base);
+
+      for (int bit_width = 0; bit_width <= kMaxBitWidth; ++bit_width) {
+        SCOPED_TRACE(::testing::Message() << "Testing bit_width=" << bit_width);
+
+        // Every misalignment, to reach the prolog with a bias.
+        for (int bit_offset = 0; bit_offset < 8; ++bit_offset) {
+          SCOPED_TRACE(::testing::Message() << "Testing bit_offset=" << bit_offset);
+          const UnpackOptions opts{
+              .batch_size = num_values_base,
+              .bit_width = bit_width,
+              .bit_offset = bit_offset,
+              .max_read_bytes = -1,  // No over-reading in testing (strict ASAN)
+          };
+          for (Uint bias : kBiases) {
+            TestOne(unpack_bias, unpack, opts, bias);
+            if (testing::Test::HasFailure()) return;
+          }
+        }
+
+        // Every epilog size, to reach the tail with a bias.
+        for (int epilogue_size = 0; epilogue_size <= kMaxBitWidth; ++epilogue_size) {
+          SCOPED_TRACE(::testing::Message() << "Testing epilog_size=" << epilogue_size);
+          const UnpackOptions opts{
+              .batch_size = num_values_base + epilogue_size,
+              .bit_width = bit_width,
+              .bit_offset = 0,
+              .max_read_bytes = -1,  // No over-reading in testing (strict ASAN)
+          };
+          for (Uint bias : kBiases) {
+            TestOne(unpack_bias, unpack, opts, bias);
+            if (testing::Test::HasFailure()) return;
+          }
+        }
+      }
+    }
+  }
+};
+
+// No bool: an add has no meaning on a bool output and unpack_bias is not
+// instantiated for it.
+using UnpackBiasTypes = ::testing::Types<uint8_t, uint16_t, uint32_t, uint64_t>;
+
+TYPED_TEST_SUITE(TestUnpackBias, UnpackBiasTypes, UnpackTypeNames);
+
+TYPED_TEST(TestUnpackBias, UnpackBiasScalar) {
+  this->TestAll(&bpacking::unpack_bias_scalar<TypeParam>,
+                &bpacking::unpack_scalar<TypeParam>);
+}
+
+#if defined(ARROW_HAVE_SSE4_2)
+TYPED_TEST(TestUnpackBias, UnpackBiasSse4_2) {
+  this->TestAll(&bpacking::unpack_bias_sse4_2<TypeParam>,
+                &bpacking::unpack_sse4_2<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
+TYPED_TEST(TestUnpackBias, UnpackBiasAvx2) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX2)) {
+    GTEST_SKIP() << "Test requires AVX2";
+  }
+  this->TestAll(&bpacking::unpack_bias_avx2<TypeParam>,
+                &bpacking::unpack_avx2<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_AVX512)
+TYPED_TEST(TestUnpackBias, UnpackBiasAvx512) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX512)) {
+    GTEST_SKIP() << "Test requires AVX512";
+  }
+  this->TestAll(&bpacking::unpack_bias_avx512<TypeParam>,
+                &bpacking::unpack_avx512<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_NEON)
+TYPED_TEST(TestUnpackBias, UnpackBiasNeon) {
+  this->TestAll(&bpacking::unpack_bias_neon<TypeParam>,
+                &bpacking::unpack_neon<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_SVE128)
+TYPED_TEST(TestUnpackBias, UnpackBiasSve128) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::SVE128)) {
+    GTEST_SKIP() << "Test requires SVE128";
+  }
+  this->TestAll(&bpacking::unpack_bias_sve128<TypeParam>,
+                &bpacking::unpack_sve128<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_SVE256)
+TYPED_TEST(TestUnpackBias, UnpackBiasSve256) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::SVE256)) {
+    GTEST_SKIP() << "Test requires SVE256";
+  }
+  this->TestAll(&bpacking::unpack_bias_sve256<TypeParam>,
+                &bpacking::unpack_sve256<TypeParam>);
+}
+#endif
+
+TYPED_TEST(TestUnpackBias, UnpackBias) {
+  this->TestAll(&unpack_bias<TypeParam>, &unpack<TypeParam>);
+}
+
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/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..f05162cc17f2
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -0,0 +1,412 @@
+// 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
+
+#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/endian.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);
+}
+
+// ----------------------------------------------------------------------
+// EncodeVector
+
+template <typename T>
+PforEncodedVector<T> PforCompression<T>::EncodeVector(const T* values,
+                                                      int32_t num_elements,
+                                                      const PforEncodeOptions& options) {
+  ARROW_DCHECK(num_elements > 0);
+
+  // One scratch buffer serves both stages. ChooseVectorPlan fills it with the
+  // differences, and if the plan takes them it is also the source the offsets
+  // are computed from -- read at index i, written at index i, so the offsets
+  // can go back into the same storage. A stack buffer for the common
+  // (<=vector-size) case avoids a per-vector heap alloc and zero-init.
+  constexpr int32_t kFull = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  T stack_scratch[kFull];
+  std::vector<T> heap_scratch;
+  T* scratch = stack_scratch;
+  if (num_elements > kFull) {
+    heap_scratch.resize(num_elements);
+    scratch = heap_scratch.data();
+  }
+
+  const PforVectorPlan<T> plan =
+      ChooseVectorPlan<T>(values, num_elements, scratch, options.delta_enabled);
+  const T* source = plan.delta ? scratch : values;
+
+  PforEncodedVector<T> result;
+  result.set_info(PforVectorInfo<T>(plan.frame_of_reference, plan.bit_width,
+                                    plan.num_exceptions, plan.delta));
+  result.set_start_value(plan.start_value);
+
+  // Step 1: reduce by the frame, collecting whatever will not fit.
+  //
+  // The comparison is against the packed mask in the unsigned domain, which is
+  // what lets the frame sit above the minimum: a source value below the frame
+  // wraps to a huge offset, fails the same test as one above the window, and is
+  // patched from the exception list like any other. No second test, no sign.
+  auto* offsets = reinterpret_cast<UnsignedT*>(scratch);
+  const auto unsigned_frame = static_cast<UnsignedT>(plan.frame_of_reference);
+  const uint8_t bit_width = plan.bit_width;
+
+  if (plan.num_exceptions > 0) {
+    result.mutable_exception_positions().reserve(plan.num_exceptions);
+    result.mutable_exception_values().reserve(plan.num_exceptions);
+
+    const UnsignedT mask = (bit_width >= PforTypeTraits<T>::kMaxBitWidth)
+                               ? static_cast<UnsignedT>(-1)
+                               : (static_cast<UnsignedT>(1) << bit_width) - 1;
+
+    for (int32_t i = 0; i < num_elements; ++i) {
+      const T value = source[i];
+      UnsignedT offset = static_cast<UnsignedT>(value) - unsigned_frame;
+      if (offset > mask) {
+        result.mutable_exception_positions().push_back(
+            static_cast<PforConstants::PositionType>(i));
+        // The exception carries whatever the packed stream carries: a value in
+        // a plain vector, a difference in a delta vector. The decoder patches
+        // it in before the running sum, so a patched difference is summed like
+        // any other.
+        result.mutable_exception_values().push_back(value);
+        offset = 0;
+      }
+      offsets[i] = offset;
+    }
+  } else {
+    for (int32_t i = 0; i < num_elements; ++i) {
+      offsets[i] = static_cast<UnsignedT>(source[i]) - unsigned_frame;
+    }
+  }
+
+  // Step 2: bit-pack the offsets
+  if (bit_width > 0) {
+    int64_t packed_size =
+        bit_util::BytesForBits(static_cast<int64_t>(num_elements) * bit_width);
+    result.mutable_packed_values().resize(static_cast<size_t>(packed_size), 0);
+
+    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) {
+  // 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());
+
+    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()});
+    } else {
+      // FOR is non-zero: hand it to the unpacker as a bias, so the add happens
+      // inside the kernel before its store and the output is traversed once.
+      // The obvious alternative — unpack, then a second pass adding FOR — is
+      // what this code used to do, and that pass measured 1.47x-2.40x the cost
+      // of the unpack it followed (median 1.68x). A pass that only copies costs
+      // the same as one that adds, so what is paid for is the extra traversal,
+      // not the arithmetic; keeping the scratch buffer small enough to stay in
+      // L1 (it was 4 KB on the stack) did not avoid it.
+      //
+      // The add is modular in UnsignedT, so the bits the unpacker stores ARE the
+      // signed values, exactly as in the FOR==0 case above — no cast pass, no
+      // scratch, and no aliasing question. Exceptions are patched in Step 4.
+      arrow::internal::unpack_bias(read_ptr, reinterpret_cast<UnsignedT*>(values),
+                                   arrow::internal::UnpackOptions{
+                                       static_cast<int>(num_elements), info.bit_width()},
+                                   unsigned_for);
+    }
+
+    read_ptr += packed_bytes;
+  } else {
+    // bit_width == 0 but has exceptions - fill with FOR
+    std::fill(values, values + num_elements, info.frame_of_reference());
+  }
+
+  // Step 4: Patch exceptions (stored as original values at their positions).
+  const PforConstants::ExceptionCountType num_exceptions = info.num_exceptions();
+  if (num_exceptions > 0) {
+    const uint8_t* positions_ptr = read_ptr;
+    read_ptr += num_exceptions * sizeof(PforConstants::PositionType);
+
+    const uint8_t* values_ptr = read_ptr;
+    read_ptr += num_exceptions * sizeof(T);
+
+    // Every position indexes `values`, so one past the end is an out-of-bounds
+    // write. Take the maximum first: a reduction still vectorizes, where a
+    // bounds check with an early return inside the patch loop would not.
+    PforConstants::PositionType max_position = 0;
+    for (PforConstants::ExceptionCountType i = 0; i < num_exceptions; ++i) {
+      max_position = std::max(
+          max_position,
+          bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::PositionType>(
+              positions_ptr + i * sizeof(PforConstants::PositionType))));
+    }
+    if (max_position >= num_elements) {
+      return Status::Invalid("PFOR exception position ", max_position,
+                             " is outside a vector of ", num_elements, " elements");
+    }
+
+    for (PforConstants::ExceptionCountType i = 0; i < num_exceptions; ++i) {
+      PforConstants::PositionType pos =
+          bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::PositionType>(
+              positions_ptr + i * sizeof(PforConstants::PositionType)));
+      T value =
+          bit_util::FromLittleEndian(util::SafeLoadAs<T>(values_ptr + i * sizeof(T)));
+      values[static_cast<size_t>(pos)] = value;
+    }
+  }
+
+  // Step 5: In a delta vector, everything above produced differences. Sum them.
+  //
+  // This has to come after the patch: an exception in a delta vector is a
+  // difference too, and summing before patching would carry the placeholder
+  // zero into every value that follows.
+  //
+  // The sum runs in the unsigned type. Signed overflow is undefined, and a
+  // column that spans the type's range will overflow -- the encoder took the
+  // differences the same way, so the bits round-trip exactly.
+  //
+  // TODO: fold this into the unpack kernel. The sum is one dependent add per
+  // value and uses no lanes, so it does not get faster with a narrower type the
+  // way the unpack does -- a scan across lanes plus a carry broadcast would
+  // shorten the serial chain. Only a vector with no exceptions can take that
+  // path, because patching has to happen between the frame add and the sum.
+  if (info.is_delta()) {
+    auto acc = static_cast<UnsignedT>(start_value);
+    for (int32_t i = 0; i < num_elements; ++i) {
+      acc += static_cast<UnsignedT>(values[i]);
+      std::memcpy(&values[i], &acc, sizeof(T));
+    }
+  }
+
+  return static_cast<int64_t>(read_ptr - data.data());
+}
+
+// ----------------------------------------------------------------------
+// Serialization helpers
+
+template <typename T>
+int64_t PforCompression<T>::SerializedVectorSize(const PforEncodedVector<T>& vec,
+                                                 int32_t num_elements) {
+  int64_t size = vec.info().stored_bytes();
+  if (vec.info().bit_width() > 0) {
+    size += bit_util::BytesForBits(static_cast<int64_t>(num_elements) *
+                                   vec.info().bit_width());
+  }
+  size += vec.info().num_exceptions() *
+          static_cast<int64_t>(sizeof(PforConstants::PositionType));
+  size += vec.info().num_exceptions() * static_cast<int64_t>(sizeof(T));
+  return size;
+}
+
+template <typename T>
+Result<int64_t> PforCompression<T>::SerializeVector(const PforEncodedVector<T>& vec,
+                                                    int32_t num_elements,
+                                                    std::span<uint8_t> dest) {
+  const int64_t needed = SerializedVectorSize(vec, num_elements);
+  if (static_cast<int64_t>(dest.size()) < needed) {
+    return Status::Invalid("PFOR vector needs ", needed, " bytes to serialize but only ",
+                           dest.size(), " remain");
+  }
+
+  // `needed` is computed from bit_width and num_exceptions, while the copies
+  // below take their lengths from the sections themselves, so a vector whose
+  // info disagrees with its sections would write past `needed` bytes.
+  const int64_t expected_packed_bytes =
+      vec.info().bit_width() > 0
+          ? bit_util::BytesForBits(static_cast<int64_t>(num_elements) *
+                                   vec.info().bit_width())
+          : 0;
+  if (static_cast<int64_t>(vec.packed_values().size()) != expected_packed_bytes) {
+    return Status::Invalid("PFOR vector has ", vec.packed_values().size(),
+                           " packed bytes but bit_width ",
+                           static_cast<int>(vec.info().bit_width()), " over ",
+                           num_elements, " elements needs ", expected_packed_bytes);
+  }
+  if (vec.exception_positions().size() != vec.info().num_exceptions() ||
+      vec.exception_values().size() != vec.info().num_exceptions()) {
+    return Status::Invalid("PFOR vector claims ", vec.info().num_exceptions(),
+                           " exceptions but carries ", vec.exception_positions().size(),
+                           " positions and ", vec.exception_values().size(), " values");
+  }
+
+  uint8_t* write_ptr = dest.data();
+
+  // Write vector info
+  vec.info().Store(std::span<uint8_t>(write_ptr, PforVectorInfo<T>::kStoredSize));
+  write_ptr += PforVectorInfo<T>::kStoredSize;
+
+  // Write the start value of a delta vector
+  if (vec.info().is_delta()) {
+    util::SafeStore(write_ptr, vec.start_value());
+    write_ptr += sizeof(T);
+  }
+
+  // Write packed values
+  if (vec.info().bit_width() > 0) {
+    std::memcpy(write_ptr, vec.packed_values().data(), vec.packed_values().size());
+    write_ptr += vec.packed_values().size();
+  }
+
+  // Write exception positions
+  if (vec.info().num_exceptions() > 0) {
+    StoreLittleEndianArray(vec.exception_positions().data(), vec.info().num_exceptions(),
+                           write_ptr);
+    write_ptr += vec.info().num_exceptions() * sizeof(PforConstants::PositionType);
+
+    // Write exception values (original integers)
+    StoreLittleEndianArray(vec.exception_values().data(), vec.info().num_exceptions(),
+                           write_ptr);
+    write_ptr += vec.info().num_exceptions() * sizeof(T);
+  }
+
+  return static_cast<int64_t>(write_ptr - dest.data());
+}
+
+// Explicit template instantiations
+template class PforCompression<int32_t>;
+template class PforCompression<int64_t>;
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_benchmark.cc b/cpp/src/arrow/util/pfor/pfor_benchmark.cc
new file mode 100644
index 000000000000..67793f880b2d
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_benchmark.cc
@@ -0,0 +1,556 @@
+// 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)) {
+  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));
+    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));
+  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)) {
+  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));
+
+  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);
+}
+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: 1K, 10K, 100K, 1M
+
+static void CustomArgs(benchmark::internal::Benchmark* b) {
+  for (int64_t n : {1024, 10240, 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);
+
+}  // 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..863ffa5a7343
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_constants_internal.h
@@ -0,0 +1,103 @@
+// 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);
+
+  /// Packing mode: FOR + bit-packing (currently the only mode).
+  static constexpr uint8_t kPackingModeForBitPack = 0;
+};
+
+/// \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..df0daec00b91
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_internal.h
@@ -0,0 +1,279 @@
+// 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 {
+
+// ----------------------------------------------------------------------
+// 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;
+};
+
+/// \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
+  /// \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
+  /// \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);
+
+  /// \brief Calculate the serialized size of an encoded vector
+  static int64_t SerializedVectorSize(const PforEncodedVector<T>& vec,
+                                      int32_t num_elements);
+
+  /// \brief Serialize an encoded vector to a byte buffer
+  ///
+  /// \param[in] vec the encoded vector
+  /// \param[in] num_elements number of elements
+  /// \param[out] dest output buffer, at least SerializedVectorSize() bytes
+  /// \return number of bytes written, or an error if `dest` is too small
+  static Result<int64_t> SerializeVector(const PforEncodedVector<T>& vec,
+                                         int32_t num_elements, std::span<uint8_t> dest);
+};
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_plan_internal.h b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
new file mode 100644
index 000000000000..1aa6350226d5
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
@@ -0,0 +1,559 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// PFOR encoder decision logic: what to do with one vector.
+//
+// The encoder chooses three things per vector, and this header holds the
+// search over all three:
+//
+//   1. whether to difference the values first (the delta mode),
+//   2. the frame of reference, which is not required to be the minimum,
+//   3. the bit width, from the existing histogram cost model.
+//
+// Kept apart from pfor.h, and free of every Arrow dependency, so the same
+// decision code can be linked into a standalone size study without building
+// the library. Nothing here touches bytes on the wire; pfor.cc does that.
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/util/pfor/pfor_constants_internal.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+/// \brief Result of the optimal bit width search
+struct BitWidthResult {
+  uint8_t bit_width = 0;
+  PforConstants::ExceptionCountType num_exceptions = 0;
+};
+
+/// \brief Bits an exception costs: its position plus a full-width value.
+template <typename T>
+constexpr int64_t ExceptionBits() {
+  return static_cast<int64_t>(sizeof(PforConstants::PositionType)) * 8 +
+         static_cast<int64_t>(sizeof(T)) * 8;
+}
+
+// ----------------------------------------------------------------------
+// Bit width search
+
+/// \brief Histogram of the bit widths needed by `values` reduced by `frame`.
+///
+/// out[b] counts the offsets that need exactly b bits. The subtraction is
+/// modular in the unsigned type, so a value below the frame wraps to a huge
+/// offset and lands in the top bin -- which is what makes a frame above the
+/// minimum work at all: below-frame values are counted as exceptions here and
+/// then patched on the way out, with no separate sign or direction to track.
+template <typename T>
+void BuildOffsetHistogram(const T* values, int32_t num_elements, T frame,
+                          std::array<int32_t, 65>* out) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  const auto unsigned_frame = static_cast<UnsignedT>(frame);
+
+  // Four independent accumulators so repeated bins do not serialize the
+  // read-modify-write and the load->clz->bump chains overlap. This loop is
+  // ~half of encode time; a single array runs scalar and stalls.
+  std::array<int32_t, 65> h0{}, h1{}, h2{}, h3{};
+  int32_t i = 0;
+  for (; i + 4 <= num_elements; i += 4) {
+    ++h0[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i]) -
+                                         unsigned_frame)];
+    ++h1[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i + 1]) -
+                                         unsigned_frame)];
+    ++h2[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i + 2]) -
+                                         unsigned_frame)];
+    ++h3[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i + 3]) -
+                                         unsigned_frame)];
+  }
+  for (; i < num_elements; ++i) {
+    ++h0[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i]) -
+                                         unsigned_frame)];
+  }
+  for (int b = 0; b <= 64; ++b) (*out)[b] = h0[b] + h1[b] + h2[b] + h3[b];
+}
+
+/// \brief Pick the width that minimises packed bits plus exception bits.
+///
+/// \param[in] histogram output of BuildOffsetHistogram
+/// \param[in] num_elements number of elements the histogram covers
+/// \param[out] cost_bits total cost of the winning width
+template <typename T>
+BitWidthResult BestWidthFromHistogram(const std::array<int32_t, 65>& histogram,
+                                      int32_t num_elements, int64_t* cost_bits) {
+  constexpr uint8_t max_bits = PforTypeTraits<T>::kMaxBitWidth;
+
+  int64_t best_cost = std::numeric_limits<int64_t>::max();
+  uint8_t best_bit_width = max_bits;
+  PforConstants::ExceptionCountType best_num_exceptions = 0;
+
+  int64_t exceptions_above = num_elements;
+  for (uint8_t b = 0; b <= max_bits; ++b) {
+    exceptions_above -= histogram[b];
+
+    // A vector holds at most kMaxVectorSize elements, so that is also the most
+    // exceptions one can name. Skipping the wider counts keeps the cast below
+    // exact; the full-width candidate has none at all, so a best is always
+    // found.
+    if (exceptions_above > PforConstants::kMaxVectorSize) continue;
+
+    const int64_t total_cost =
+        static_cast<int64_t>(num_elements) * b + exceptions_above * ExceptionBits<T>();
+    if (total_cost < best_cost) {
+      best_cost = total_cost;
+      best_bit_width = b;
+      best_num_exceptions =
+          static_cast<PforConstants::ExceptionCountType>(exceptions_above);
+    }
+  }
+
+  *cost_bits = best_cost;
+  return {best_bit_width, best_num_exceptions};
+}
+
+/// Bucket count used by the frame search, as a shift and as a count. 256 keeps
+/// the scan in ChooseFrameAndWidth at roughly two passes' worth of work over a
+/// 1024-value vector.
+constexpr int32_t kFrameSearchBits = 8;
+constexpr int32_t kFrameSearchBuckets = 1 << kFrameSearchBits;
+
+/// \brief One walk producing both histograms the frame search needs.
+///
+/// The bit-width histogram costs the frame it is given; the bucket counts cost
+/// every other frame. They are gathered together because each needs the same
+/// offset, and computing that offset twice was measurably the larger half of
+/// the search.
+///
+/// Bucketing is by shift rather than division: `1 << shift` values per bucket
+/// keeps the count at or below kFrameSearchBuckets without a per-element divide.
+template <typename T>
+void BuildFrameSearchHistograms(const T* values, int32_t num_elements, T frame,
+                                int32_t shift, std::array<int32_t, 65>* width_hist,
+                                std::array<int32_t, kFrameSearchBuckets + 1>* buckets) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  const auto unsigned_frame = static_cast<UnsignedT>(frame);
+
+  // Four accumulators, as in BuildOffsetHistogram: a column whose offsets share
+  // a width -- which is most of them -- sends every element to one bin, and a
+  // single accumulator turns that into a serial read-modify-write chain.
+  std::array<std::array<int32_t, 65>, 4> h{};
+  for (int32_t i = 0; i < num_elements; ++i) {
+    const UnsignedT offset = static_cast<UnsignedT>(values[i]) - unsigned_frame;
+    ++h[i & 3][PforTypeTraits<T>::BitsRequired(offset)];
+    ++(*buckets)[static_cast<size_t>(offset >> shift)];
+  }
+  for (int b = 0; b <= 64; ++b) {
+    (*width_hist)[b] = h[0][b] + h[1][b] + h[2][b] + h[3][b];
+  }
+}
+
+/// \brief Histogram over offsets that were already reduced by their frame.
+template <typename T>
+void BuildOffsetHistogram(const typename PforTypeTraits<T>::UnsignedType* offsets,
+                          int32_t num_elements, std::array<int32_t, 65>* out) {
+  // A pointer to the unsigned counterpart of T may be read as a pointer to T,
+  // and BitsRequired only looks at the bits, so a frame of zero over the same
+  // storage gives exactly the histogram of the offsets.
+  BuildOffsetHistogram<T>(reinterpret_cast<const T*>(offsets), num_elements,
+                          static_cast<T>(0), out);
+}
+
+// ----------------------------------------------------------------------
+// Frame search
+
+/// \brief The extremes of a run of values.
+template <typename T>
+struct MinMax {
+  T min = 0;
+  T max = 0;
+};
+
+/// \brief A frame of reference together with the width that suits it.
+template <typename T>
+struct FrameChoice {
+  T frame_of_reference = 0;
+  uint8_t bit_width = 0;
+  PforConstants::ExceptionCountType num_exceptions = 0;
+  int64_t cost_bits = std::numeric_limits<int64_t>::max();
+};
+
+/// \brief Choose a frame of reference and a bit width together.
+///
+/// The frame PFOR has always used is the minimum, which makes every exception
+/// an overshoot: one value far below the cluster drags the whole packed window
+/// down with it and nothing can patch it back. Treating the frame as a free
+/// parameter instead -- any lower bound, not the lowest -- lets the window sit
+/// where the values actually are and patch on both sides.
+///
+/// Storage is unaffected: the frame field already holds a full-width T, and the
+/// decoder only ever adds it. The whole cost is this search.
+///
+/// The search is approximate by design. An exact answer needs the values
+/// sorted; instead the range is bucketed with a shift, and for each candidate
+/// width a window is slid over the bucket counts. Only whole buckets count as
+/// covered, so the exception estimate is an upper bound -- never optimistic.
+/// The minimum-frame answer is always among the candidates, and it alone is
+/// costed from a real histogram, so the search can never do worse than what the
+/// old cost model would have picked.
+template <typename T>
+FrameChoice<T> ChooseFrameAndWidth(const T* values, int32_t num_elements,
+                                   MinMax<T> bounds) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr uint8_t max_bits = PforTypeTraits<T>::kMaxBitWidth;
+
+  const T min_val = bounds.min;
+  const T max_val = bounds.max;
+
+  // A constant vector is already at the floor, and min/max has just proved it
+  // constant, so it needs no histogram to find that out. Worth the special case
+  // for its own sake: a run of equal values sends every element to one
+  // histogram bin, where the read-modify-write serializes and the pass runs at
+  // a fraction of its usual rate.
+  const auto range = static_cast<UnsignedT>(max_val) - static_cast<UnsignedT>(min_val);
+  if (range == 0) {
+    FrameChoice<T> constant_choice;
+    constant_choice.frame_of_reference = min_val;
+    constant_choice.cost_bits = 0;
+    return constant_choice;
+  }
+
+  const auto range_bits = PforTypeTraits<T>::BitsRequired(range);
+  const int32_t shift = range_bits > kFrameSearchBits ? range_bits - kFrameSearchBits : 0;
+
+  // One walk serves both halves of the search: the bit-width histogram costs
+  // the minimum as a frame, the bucket counts cost every other frame.
+  std::array<int32_t, 65> histogram{};
+  std::array<int32_t, kFrameSearchBuckets + 1> counts{};
+  BuildFrameSearchHistograms<T>(values, num_elements, min_val, shift, &histogram,
+                                &counts);
+
+  // Candidate 0: the minimum, i.e. what PFOR has always done. Costed
+  // unconditionally, and from a real histogram, so the search cannot regress
+  // against it.
+  FrameChoice<T> best;
+  best.frame_of_reference = min_val;
+  int64_t cost_bits = 0;
+  BitWidthResult r = BestWidthFromHistogram<T>(histogram, num_elements, &cost_bits);
+  best.bit_width = r.bit_width;
+  best.num_exceptions = r.num_exceptions;
+  best.cost_bits = cost_bits;
+
+  // Already at width 0, with a handful of patches carrying the rest. Nothing a
+  // frame can do about it. Note this is not the same as having no exceptions:
+  // the whole point of a frame above the minimum is to trade a narrower width
+  // for a few patches, so an exception-free choice is where the search starts,
+  // not a reason to skip it. The sawtooth is the example -- its differences pack
+  // at width 12 with no exceptions, or at width 0 with five, and only the second
+  // is worth having.
+  if (best.bit_width == 0) return best;
+
+  const int32_t num_buckets = static_cast<int32_t>(range >> shift) + 1;
+  std::array<int32_t, kFrameSearchBuckets + 2> prefix{};
+  for (int32_t b = 0; b < num_buckets; ++b) prefix[b + 1] = prefix[b] + counts[b];
+
+  // Slide a 2^w-wide window over the buckets and keep the position that costs
+  // least. Widths below the bucket size cannot be resolved at this granularity,
+  // and once one window spans every bucket there are no exceptions left to
+  // remove, so the loop covers only the ~kFrameSearchBits widths in between --
+  // fixed work, and none of it touching the data again.
+  //
+  // What comes out of this is a frame, not a width. Only whole buckets count as
+  // covered, so `w` here is an upper bound on the width the frame really needs,
+  // and the exception count an upper bound too. The exact pass below is what
+  // turns the frame into a plan.
+  //
+  // Seeded with the incumbent's cost, so a window only registers if it beats
+  // the minimum as a frame. Everything after this loop -- the walk that lowers
+  // the frame onto a real value, and the exact pass that turns it into a width
+  // -- is then skipped entirely on a column the frame cannot help, which is
+  // most of them. Seeding it costs the conservative direction: the scan
+  // over-counts exceptions, so it can decline a frame whose exact cost would
+  // have won, but it cannot accept one that loses.
+  int32_t best_start = -1;
+  int32_t best_end = 0;
+  int64_t scan_cost = best.cost_bits;
+  for (int32_t w = shift; w <= max_bits; ++w) {
+    const int64_t whole_buckets = static_cast<int64_t>(1) << (w - shift);
+    if (whole_buckets <= 0) break;
+    const int32_t k =
+        static_cast<int32_t>(whole_buckets < num_buckets ? whole_buckets : num_buckets);
+    for (int32_t s = 0; s < num_buckets; ++s) {
+      const int32_t end = s + k < num_buckets ? s + k : num_buckets;
+      const int64_t exceptions = num_elements - (prefix[end] - prefix[s]);
+      if (exceptions > PforConstants::kMaxVectorSize) continue;
+      const int64_t cost =
+          static_cast<int64_t>(num_elements) * w + exceptions * ExceptionBits<T>();
+      if (cost < scan_cost) {
+        scan_cost = cost;
+        best_start = s;
+        best_end = end;
+      }
+    }
+    if (k >= num_buckets) break;  // one window already spans the data
+  }
+
+  if (best_start < 0) return best;
+
+  // Lower the frame from the boundary of the winning window onto the smallest
+  // value the window actually covers. Bucket boundaries stand 2^shift apart,
+  // which on a wide column is thousands, and a cluster sitting just above one
+  // would otherwise pay those bits for nothing.
+  //
+  // A walk of its own, rather than per-bucket minima kept by the pass above:
+  // tracking them there costs every vector a compare and a store per element,
+  // including the vectors where the scan finds nothing and the minima are
+  // discarded. Over the distributions in pfor_benchmark.cc that cost about 30%
+  // of encode throughput to improve one of them. Here only a vector the search has
+  // already won pays, and it pays one traversal.
+  const auto window_lo = static_cast<UnsignedT>(best_start) << shift;
+  // A window reaching the last bucket has no upper edge to test against: the
+  // edge would be num_buckets << shift, which is one past the representable
+  // range whenever the offsets span the whole type.
+  const bool bounded_above = best_end < num_buckets;
+  const UnsignedT window_hi =
+      bounded_above ? (static_cast<UnsignedT>(best_end) << shift) : UnsignedT{0};
+
+  const auto unsigned_min = static_cast<UnsignedT>(min_val);
+  UnsignedT frame_offset = 0;
+  bool covers_anything = false;
+  for (int32_t i = 0; i < num_elements; ++i) {
+    const UnsignedT offset = static_cast<UnsignedT>(values[i]) - unsigned_min;
+    if (offset < window_lo || (bounded_above && offset >= window_hi)) continue;
+    if (!covers_anything || offset < frame_offset) {
+      frame_offset = offset;
+      covers_anything = true;
+    }
+  }
+  if (!covers_anything) return best;
+
+  const auto scan_frame = static_cast<T>(unsigned_min + frame_offset);
+  if (scan_frame == min_val) return best;
+
+  // Cost the winning frame exactly. This pass is not bookkeeping -- it is where
+  // the width and the exception count are actually decided. The scan works at
+  // bucket granularity and so cannot see a window narrower than one bucket,
+  // which is exactly where the answers worth having tend to be: the sawtooth's
+  // differences span 12 bits, so its buckets are 16 wide, and no scan over them
+  // can resolve the 0-bit window that its five patches leave behind.
+  BuildOffsetHistogram<T>(values, num_elements, scan_frame, &histogram);
+  int64_t exact_cost = 0;
+  r = BestWidthFromHistogram<T>(histogram, num_elements, &exact_cost);
+  if (exact_cost < best.cost_bits) {
+    best.frame_of_reference = scan_frame;
+    best.bit_width = r.bit_width;
+    best.num_exceptions = r.num_exceptions;
+    best.cost_bits = exact_cost;
+  }
+  return best;
+}
+
+/// \brief Overload for callers that have not already seen the values.
+template <typename T>
+FrameChoice<T> ChooseFrameAndWidth(const T* values, int32_t num_elements) {
+  MinMax<T> bounds{values[0], values[0]};
+  for (int32_t i = 1; i < num_elements; ++i) {
+    if (values[i] < bounds.min) bounds.min = values[i];
+    if (values[i] > bounds.max) bounds.max = values[i];
+  }
+  return ChooseFrameAndWidth<T>(values, num_elements, bounds);
+}
+
+// ----------------------------------------------------------------------
+// Whole-vector plan
+
+/// \brief Everything the encoder decided about one vector.
+template <typename T>
+struct PforVectorPlan {
+  /// Difference the values before framing and packing them.
+  bool delta = false;
+  /// Subtracted from every element before packing; added back on decode.
+  T frame_of_reference = 0;
+  /// First value of the vector, stored only when `delta` is set. It is what
+  /// makes a delta vector decodable on its own, without the vector before it.
+  T start_value = 0;
+  uint8_t bit_width = 0;
+  PforConstants::ExceptionCountType num_exceptions = 0;
+  /// Packed bits, exception bits, and the start value if there is one. Excludes
+  /// the fixed per-vector info, which every plan pays equally.
+  int64_t cost_bits = 0;
+};
+
+/// \brief Map a signed value onto an unsigned one of the same magnitude.
+///
+/// Negative values interleave with positive ones instead of wrapping to the top
+/// of the range, so a small negative difference needs few bits rather than all
+/// of them. Used only by the estimate below; nothing on the wire is zigzagged.
+template <typename T>
+typename PforTypeTraits<T>::UnsignedType ZigZag(T value) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr int kBits = static_cast<int>(sizeof(T)) * 8;
+  const auto u = static_cast<UnsignedT>(value);
+  const UnsignedT sign_mask = UnsignedT{0} - (u >> (kBits - 1));
+  return static_cast<UnsignedT>((u << 1) ^ sign_mask);
+}
+
+/// \brief Fill `deltas` with the backward differences of `values`.
+///
+/// deltas[0] is 0: the first value travels in the plan's start_value, and
+/// giving slot 0 a real delta would mean either a shorter packed run or a
+/// value that is not a difference sitting in the width histogram. Zero costs
+/// bit_width bits and distorts nothing.
+///
+/// Subtraction is done unsigned and copied across, because signed overflow is
+/// undefined and a column that spans the type's range will overflow.
+/// The bounds of the differences come back with them: this walk has just seen
+/// every one, and the search needs them before it can do anything else.
+template <typename T>
+void ComputeDeltas(const T* values, int32_t num_elements, T* deltas, MinMax<T>* bounds) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  deltas[0] = 0;
+  *bounds = MinMax<T>{0, 0};
+  for (int32_t i = 1; i < num_elements; ++i) {
+    const UnsignedT d =
+        static_cast<UnsignedT>(values[i]) - static_cast<UnsignedT>(values[i - 1]);
+    T signed_delta;
+    std::memcpy(&signed_delta, &d, sizeof(T));
+    deltas[i] = signed_delta;
+    if (signed_delta < bounds->min) bounds->min = signed_delta;
+    if (signed_delta > bounds->max) bounds->max = signed_delta;
+  }
+}
+
+/// \brief Estimate what packing the differences of `values` would cost, in bits.
+///
+/// The full decision needs the differences written out and searched, which is
+/// most of what encoding a vector costs. This reaches an answer good enough to
+/// decline the mode from a strided sample, without writing anything.
+///
+/// The sample is of widths, not of a span. A gate on the span of the
+/// differences was tried first and had to go: the sawtooth is a tight cluster
+/// of small positive differences with a handful of large negative ones, so its
+/// span is as wide as its raw span while its cost is a fraction of it. Feeding
+/// widths to the same cost model the search uses keeps that shape, because the
+/// model can trade a wide bin against a patch.
+///
+/// Zigzagging is what lets a histogram stand in for a frame search that has not
+/// run. Differences in [-k, k] zigzag into [0, 2k], and a frame at -k maps them
+/// onto the same [0, 2k], so for a range that straddles zero evenly the
+/// estimated width is the width the search would find. Where the range leans
+/// one way the estimate runs a bit or two wide.
+template <typename T>
+int64_t EstimateDeltaCostBits(const T* values, int32_t num_elements) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // Enough of a sample to place a distribution across the width bins, and few
+  // enough that the pass is a fraction of the one it is deciding against.
+  constexpr int32_t kSampleTarget = 128;
+  const int32_t stride = std::max(1, num_elements / kSampleTarget);
+
+  // Four accumulators, as in the histogram passes above: most columns send
+  // nearly every difference to one bin, and one array would serialize on it.
+  std::array<std::array<int32_t, 65>, 4> h{};
+  int32_t sampled = 0;
+  for (int32_t i = stride; i < num_elements; i += stride) {
+    const UnsignedT d =
+        static_cast<UnsignedT>(values[i]) - static_cast<UnsignedT>(values[i - 1]);
+    T signed_delta;
+    std::memcpy(&signed_delta, &d, sizeof(T));
+    ++h[sampled & 3][PforTypeTraits<T>::BitsRequired(ZigZag<T>(signed_delta))];
+    ++sampled;
+  }
+  if (sampled == 0) return 0;
+
+  std::array<int32_t, 65> histogram{};
+  for (int b = 0; b <= 64; ++b) {
+    histogram[b] = h[0][b] + h[1][b] + h[2][b] + h[3][b];
+  }
+  int64_t sample_cost = 0;
+  BestWidthFromHistogram<T>(histogram, sampled, &sample_cost);
+
+  // Scale to the whole vector. Both terms of the model are per-element -- a
+  // width costs its bits every element, an exception costs its slot every time
+  // it occurs -- so the sample cost scales with the count.
+  return sample_cost * num_elements / sampled;
+}
+
+/// \brief Decide how to encode one vector.
+///
+/// \param[in] values the vector
+/// \param[in] num_elements element count, > 0
+/// \param[out] delta_scratch scratch for num_elements differences; on return it
+///             holds the differences if the plan chose the delta mode, and is
+///             clobbered either way
+/// \param[in] delta_enabled whether the delta mode may be chosen at all
+///
+/// Both transforms are costed with the same model and the cheaper one wins, so
+/// the mode is a per-vector decision. It has to be: differencing loses 6-19% on
+/// every unclustered draw, and a column is rarely all one shape.
+template <typename T>
+PforVectorPlan<T> ChooseVectorPlan(const T* values, int32_t num_elements,
+                                   T* delta_scratch, bool delta_enabled) {
+  const FrameChoice<T> raw = ChooseFrameAndWidth<T>(values, num_elements);
+
+  PforVectorPlan<T> plan;
+  plan.delta = false;
+  plan.frame_of_reference = raw.frame_of_reference;
+  plan.bit_width = raw.bit_width;
+  plan.num_exceptions = raw.num_exceptions;
+  plan.cost_bits = raw.cost_bits;
+
+  // One element has no difference to take, and a vector already packing at
+  // width 0 cannot be improved on.
+  if (!delta_enabled || num_elements < 2 || raw.bit_width == 0) return plan;
+
+  // A delta vector carries its own first value, so it starts one full-width
+  // value behind whatever its differences pack to.
+  const int64_t start_value_bits = static_cast<int64_t>(sizeof(T)) * 8;
+
+  // Estimate the mode before paying for it, and drop it here if the estimate
+  // cannot reach the incumbent. What is skipped is the whole of the rest of the
+  // mode: the pass that writes the differences out, and the frame search over
+  // them. The estimate is deliberately loose, so it declines only where the two
+  // modes are more than a sampling error apart -- which is where the choice
+  // matters least.
+  if (EstimateDeltaCostBits<T>(values, num_elements) + start_value_bits >=
+      plan.cost_bits) {
+    return plan;
+  }
+
+  MinMax<T> delta_bounds;
+  ComputeDeltas<T>(values, num_elements, delta_scratch, &delta_bounds);
+
+  const FrameChoice<T> delta =
+      ChooseFrameAndWidth<T>(delta_scratch, num_elements, delta_bounds);
+
+  const int64_t delta_cost = delta.cost_bits + start_value_bits;
+  if (delta_cost < plan.cost_bits) {
+    plan.delta = true;
+    plan.frame_of_reference = delta.frame_of_reference;
+    plan.start_value = values[0];
+    plan.bit_width = delta.bit_width;
+    plan.num_exceptions = delta.num_exceptions;
+    plan.cost_bits = delta_cost;
+  }
+  return plan;
+}
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_test.cc b/cpp/src/arrow/util/pfor/pfor_test.cc
new file mode 100644
index 000000000000..18fde6f314dc
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_test.cc
@@ -0,0 +1,1269 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <numeric>
+#include <random>
+#include <span>
+#include <string>
+#include <vector>
+
+#include "arrow/testing/gtest_util.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/pfor/pfor_internal.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+
+namespace arrow::util::pfor {
+
+// ======================================================================
+// Test fixture
+//
+// PFOR is instantiated for int32_t and int64_t, and the two differ in the
+// widths of the frame of reference, the packed deltas and the exception values,
+// so nearly every test here belongs to both. The helpers hide the width
+// arithmetic; tests that poke at particular byte offsets derive them from
+// sizeof(T) and kStoredSize rather than writing them out.
+
+template <typename T>
+class PforTest : public ::testing::Test {
+ protected:
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+
+  /// Encode, serialize and decode a single vector, checking that it round-trips.
+  ///
+  /// \param[out] encoded_out the encoded form, for tests that assert on its
+  ///             metadata; may be null
+  void RoundTripVector(const std::vector<T>& values,
+                       PforEncodedVector<T>* encoded_out = nullptr) {
+    const auto num_elements = static_cast<int32_t>(values.size());
+    auto encoded = PforCompression<T>::EncodeVector(values.data(), num_elements);
+
+    const int64_t needed =
+        PforCompression<T>::SerializedVectorSize(encoded, num_elements);
+    std::vector<uint8_t> buffer(needed);
+    ASSERT_OK_AND_ASSIGN(const int64_t written, PforCompression<T>::SerializeVector(
+                                                    encoded, num_elements, buffer));
+    ASSERT_EQ(needed, written);
+
+    std::vector<T> decoded(values.size());
+    ASSERT_OK(PforCompression<T>::DecodeVector(buffer, num_elements, decoded.data()));
+    ASSERT_EQ(values, decoded);
+
+    if (encoded_out != nullptr) {
+      *encoded_out = std::move(encoded);
+    }
+  }
+
+  /// Encode and decode a whole page, checking that it round-trips and stays
+  /// inside the bound the encoder allocates from.
+  ///
+  /// \param[out] comp_size_out the compressed size, for tests that assert on
+  ///             the compression ratio; may be null
+  void RoundTripPage(const std::vector<T>& values, int64_t* comp_size_out = nullptr) {
+    const auto num_values = static_cast<int32_t>(values.size());
+    ASSERT_OK_AND_ASSIGN(const int64_t max_size,
+                         PforWrapper<T>::GetMaxCompressedSize(num_values));
+    std::vector<uint8_t> compressed(max_size);
+    int64_t comp_size = max_size;
+    ASSERT_OK(
+        PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+    ASSERT_GT(comp_size, 0);
+    ASSERT_LE(comp_size, max_size);
+
+    std::vector<T> decoded(values.size());
+    ASSERT_OK(
+        PforWrapper<T>::Decode(compressed.data(), comp_size, num_values, decoded.data()));
+    ASSERT_EQ(values, decoded);
+
+    if (comp_size_out != nullptr) {
+      *comp_size_out = comp_size;
+    }
+  }
+
+  /// Encode `values` and return the compressed bytes, sized exactly.
+  static std::vector<uint8_t> EncodePage(const std::vector<T>& values) {
+    const auto num_values = static_cast<int32_t>(values.size());
+    int64_t comp_size = PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> compressed(comp_size);
+    ARROW_CHECK_OK(
+        PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+    compressed.resize(comp_size);
+    return compressed;
+  }
+
+  /// Offset of the first vector in a single-vector page: header, then the
+  /// one-entry offset array.
+  static constexpr int64_t kFirstVectorOffset =
+      PforConstants::kHeaderSize +
+      static_cast<int64_t>(sizeof(PforConstants::OffsetType));
+
+  /// Offsets of the PforVectorInfo fields, relative to the start of a vector.
+  static constexpr int64_t kBitWidthOffset = static_cast<int64_t>(sizeof(T));
+  static constexpr int64_t kNumExceptionsOffset = kBitWidthOffset + 1;
+
+  static std::vector<T> RandomValues(int32_t num_values, T min, T max, uint32_t seed) {
+    std::vector<T> values(num_values);
+    std::mt19937 rng(seed);
+    std::uniform_int_distribution<T> dist(min, max);
+    for (auto& v : values) v = dist(rng);
+    return values;
+  }
+};
+
+using PforTypes = ::testing::Types<int32_t, int64_t>;
+TYPED_TEST_SUITE(PforTest, PforTypes);
+
+namespace {
+
+void StoreLE32(uint8_t* dest, uint32_t value) {
+  for (int i = 0; i < 4; ++i) {
+    dest[i] = static_cast<uint8_t>(value >> (8 * i));
+  }
+}
+
+}  // namespace
+
+// ======================================================================
+// Constants Tests
+
+TEST(PforConstantsTest, VectorSizeIsPowerOfTwo) {
+  EXPECT_EQ(PforConstants::kPforVectorSize, 1024);
+  EXPECT_EQ(1 << PforConstants::kDefaultLogVectorSize, PforConstants::kPforVectorSize);
+}
+
+TEST(PforConstantsTest, VectorInfoSizes) {
+  EXPECT_EQ(PforTypeTraits<int32_t>::kVectorInfoSize, 7);
+  EXPECT_EQ(PforTypeTraits<int64_t>::kVectorInfoSize, 11);
+}
+
+// ======================================================================
+// BitsRequired Tests
+
+TYPED_TEST(PforTest, BitsRequired) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(0), 0);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(1), 1);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(2), 2);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(3), 2);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(255), 8);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(256), 9);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(std::numeric_limits<UnsignedT>::max()),
+            PforTypeTraits<T>::kMaxBitWidth);
+}
+
+// ======================================================================
+// VectorInfo Serialization Tests
+
+TYPED_TEST(PforTest, VectorInfoRoundTrip) {
+  using T = TypeParam;
+  PforVectorInfo<T> info;
+  info.set_frame_of_reference(-42);
+  info.set_bit_width(17);
+  info.set_num_exceptions(300);
+
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize);
+  info.Store(buf);
+  ASSERT_OK_AND_ASSIGN(auto loaded, PforVectorInfo<T>::Load(buf));
+
+  EXPECT_EQ(loaded.frame_of_reference(), -42);
+  EXPECT_EQ(loaded.bit_width(), 17);
+  EXPECT_EQ(loaded.num_exceptions(), 300);
+}
+
+// The extremes of every field at once: the widest frame of reference the type
+// can hold and the full bit width. A six-bit width field could not store 64,
+// and reported such a vector as constant.
+TYPED_TEST(PforTest, VectorInfoRoundTripAtFieldExtremes) {
+  using T = TypeParam;
+  constexpr T kFrameOfReference = std::numeric_limits<T>::min();
+  PforVectorInfo<T> info(kFrameOfReference, PforTypeTraits<T>::kMaxBitWidth, 30000);
+
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize);
+  info.Store(buf);
+  ASSERT_OK_AND_ASSIGN(auto loaded, PforVectorInfo<T>::Load(buf));
+
+  EXPECT_EQ(loaded.frame_of_reference(), kFrameOfReference);
+  EXPECT_EQ(loaded.bit_width(), PforTypeTraits<T>::kMaxBitWidth);
+  EXPECT_EQ(loaded.num_exceptions(), 30000);
+}
+
+// Every element of a maximum-size vector can be an exception, so the count has
+// to reach kMaxVectorSize. A signed 16-bit field stopped one short of that.
+TYPED_TEST(PforTest, VectorInfoNumExceptionsAtMaxVectorSize) {
+  using T = TypeParam;
+  PforVectorInfo<T> info;
+  info.set_bit_width(3);
+  info.set_num_exceptions(PforConstants::kMaxVectorSize);
+
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize);
+  info.Store(buf);
+  ASSERT_OK_AND_ASSIGN(auto loaded, PforVectorInfo<T>::Load(buf));
+
+  EXPECT_EQ(loaded.num_exceptions(), PforConstants::kMaxVectorSize);
+}
+
+TYPED_TEST(PforTest, VectorInfoRejectsNumExceptionsAboveMaxVectorSize) {
+  using T = TypeParam;
+  // [FOR] [bit_width 1B] [num_exceptions 2B], with a count no vector can have.
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize, 0);
+  buf[TestFixture::kBitWidthOffset] = 3;
+  buf[TestFixture::kNumExceptionsOffset] = 0xFF;
+  buf[TestFixture::kNumExceptionsOffset + 1] = 0xFF;
+  ASSERT_RAISES(Invalid, PforVectorInfo<T>::Load(buf));
+}
+
+TYPED_TEST(PforTest, VectorInfoRejectsUndersizedBuffer) {
+  using T = TypeParam;
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize - 1, 0);
+  ASSERT_RAISES(Invalid, PforVectorInfo<T>::Load(buf));
+}
+
+// ======================================================================
+// Cost Model Tests
+
+TYPED_TEST(PforTest, CostModelAllIdentical) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // All deltas are 0 => bit_width should be 0, no exceptions
+  std::vector<UnsignedT> deltas(100, 0);
+  auto result = PforCompression<T>::FindOptimalBitWidth(deltas.data(), 100);
+  EXPECT_EQ(result.bit_width, 0);
+  EXPECT_EQ(result.num_exceptions, 0);
+}
+
+TYPED_TEST(PforTest, CostModelSingleOutlier) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // 99 values fit in 3 bits, 1 outlier needs 16 bits
+  std::vector<UnsignedT> deltas(100, 5);  // all fit in 3 bits
+  deltas[50] = 50000;                     // outlier: 16 bits
+  auto result = PforCompression<T>::FindOptimalBitWidth(deltas.data(), 100);
+  // An exception costs a 16-bit position plus a full-width value, so at
+  // bit_width=3 the vector costs 100*3 + 1*(16 + 8*sizeof(T)) bits, against
+  // 100*16 at bit_width=16. Patching the one outlier wins for both widths of T.
+  EXPECT_EQ(result.bit_width, 3);
+  EXPECT_EQ(result.num_exceptions, 1);
+}
+
+TYPED_TEST(PforTest, CostModelNoOutliers) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // All values fit in 8 bits
+  std::vector<UnsignedT> deltas(100);
+  for (int32_t i = 0; i < 100; ++i) deltas[i] = i * 2;
+  auto result = PforCompression<T>::FindOptimalBitWidth(deltas.data(), 100);
+  EXPECT_EQ(result.num_exceptions, 0);
+  EXPECT_LE(result.bit_width, 8);
+}
+
+// ======================================================================
+// Vector Encode/Decode Round-Trip Tests
+
+// An ascending run is what the delta mode is for, so this no longer measures
+// the frame of reference: the packed stream holds the differences, all of them
+// 1, and the frame belongs to those. The first value travels separately.
+TYPED_TEST(PforTest, VectorSimpleSequence) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), 100);
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_TRUE(encoded.info().is_delta());
+  EXPECT_EQ(encoded.start_value(), 100);
+}
+
+// The same shape with the differences made unpredictable, which is what leaves
+// the values themselves as the cheaper thing to pack. Here the frame is the
+// minimum and nothing is patched, as it was before there was a delta mode.
+TYPED_TEST(PforTest, VectorSimpleSequenceWithoutDelta) {
+  using T = TypeParam;
+  std::vector<T> values = this->RandomValues(64, 100, 163, 11);
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_FALSE(encoded.info().is_delta());
+  EXPECT_EQ(encoded.info().frame_of_reference(),
+            *std::min_element(values.begin(), values.end()));
+  EXPECT_EQ(encoded.info().num_exceptions(), 0);
+}
+
+TYPED_TEST(PforTest, VectorWithOutlier) {
+  using T = TypeParam;
+  std::vector<T> values = {100, 102, 101, 103, 100, 99, 50000, 104};
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_EQ(encoded.info().frame_of_reference(), 99);
+  EXPECT_GT(encoded.info().num_exceptions(), 0);
+}
+
+TYPED_TEST(PforTest, VectorAllIdentical) {
+  using T = TypeParam;
+  std::vector<T> values(100, 42);
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_EQ(encoded.info().bit_width(), 0);
+  EXPECT_EQ(encoded.info().num_exceptions(), 0);
+}
+
+TYPED_TEST(PforTest, VectorNegativeValues) {
+  using T = TypeParam;
+  std::vector<T> values = {-100, -50, -200, -1, -150};
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_EQ(encoded.info().frame_of_reference(), -200);
+}
+
+// The frame of reference is subtracted in the unsigned domain, so a vector
+// spanning the whole range of T has a delta that only wraps to the right answer.
+TYPED_TEST(PforTest, VectorMinMaxEdge) {
+  using T = TypeParam;
+  std::vector<T> values = {std::numeric_limits<T>::min(), std::numeric_limits<T>::max(),
+                           0, -1, 1};
+  this->RoundTripVector(values);
+}
+
+TYPED_TEST(PforTest, VectorSingleElement) {
+  using T = TypeParam;
+  this->RoundTripVector(std::vector<T>{42});
+}
+
+// ======================================================================
+// Page-Level Wrapper Tests
+
+TYPED_TEST(PforTest, PageSmall) { this->RoundTripPage({10, 20, 30, 40, 50}); }
+
+TYPED_TEST(PforTest, PageExactOneVector) {
+  using T = TypeParam;
+  std::vector<T> values(PforConstants::kPforVectorSize);
+  std::iota(values.begin(), values.end(), 0);
+  this->RoundTripPage(values);
+}
+
+TYPED_TEST(PforTest, PageMultipleVectors) {
+  // 2.5 vectors worth of data
+  this->RoundTripPage(TestFixture::RandomValues(2560, 0, 1000, /*seed=*/42));
+}
+
+TYPED_TEST(PforTest, PageWithOutliers) {
+  using T = TypeParam;
+  std::vector<T> values(1024, 100);
+  values[0] = -999999;
+  values[100] = 888888;
+  values[500] = 777777;
+  values[1023] = -123456;
+  this->RoundTripPage(values);
+}
+
+TYPED_TEST(PforTest, PagePartialTrailingVector) {
+  using T = TypeParam;
+  auto values = TestFixture::RandomValues(3000, 0, 100000, /*seed=*/123);
+  values[0] = std::numeric_limits<T>::max() / 2;
+  values[1500] = std::numeric_limits<T>::min() / 2;
+  this->RoundTripPage(values);
+}
+
+TYPED_TEST(PforTest, PageSingleElement) {
+  using T = TypeParam;
+  this->RoundTripPage(std::vector<T>{42});
+}
+
+TYPED_TEST(PforTest, PageAllZeros) {
+  using T = TypeParam;
+  std::vector<T> values(1024, 0);
+  int64_t comp_size = 0;
+  this->RoundTripPage(values, &comp_size);
+  // bit_width is 0, so the page is header, offset array and vector info only.
+  EXPECT_LT(comp_size, 100);
+}
+
+TYPED_TEST(PforTest, PageLargeRandom) {
+  using T = TypeParam;
+  this->RoundTripPage(TestFixture::RandomValues(10000, std::numeric_limits<T>::min(),
+                                                std::numeric_limits<T>::max(),
+                                                /*seed=*/99));
+}
+
+// Covers the FOR==0 fast path (bit_width > 0 with frame_of_reference == 0):
+// decode unpacks straight into the output, skipping the scratch buffer and the
+// add-FOR pass. Forces min == 0, a range that needs bit_width > 0, outliers to
+// exercise the exception patch on that path, and multiple vectors.
+TYPED_TEST(PforTest, PageZeroMinWithExceptions) {
+  auto values = TestFixture::RandomValues(3000, 0, 500, /*seed=*/2024);
+  values[0] = 0;            // force min == 0 -> FOR == 0
+  values[100] = 1'000'000;  // outliers -> exceptions on the FOR==0 path
+  values[1500] = 999'999;
+  values[2999] = 500'000;
+  this->RoundTripPage(values);
+}
+
+// ======================================================================
+// Encode Argument Validation
+
+TYPED_TEST(PforTest, EncodeZeroValuesWritesABareHeader) {
+  using T = TypeParam;
+  // An all-null page holds no values, and the reader still has to be able to load
+  // a header from it, so zero values encodes to the header and nothing else. The
+  // pointer is null because the buffer the values would come from is empty.
+  std::vector<uint8_t> compressed(64);
+  int64_t comp_size = 64;
+  ASSERT_OK(PforWrapper<T>::Encode(nullptr, 0, compressed.data(), &comp_size));
+  ASSERT_EQ(PforConstants::kHeaderSize, comp_size);
+
+  ASSERT_OK_AND_ASSIGN(const int32_t count,
+                       PforWrapper<T>::DecodeElementCount(compressed.data(), comp_size));
+  ASSERT_EQ(0, count);
+  ASSERT_OK(PforWrapper<T>::Decode(compressed.data(), comp_size, 0, nullptr));
+}
+
+TYPED_TEST(PforTest, EncodeRejectsNegativeCount) {
+  using T = TypeParam;
+  std::vector<T> values = {1, 2, 3};
+  std::vector<uint8_t> compressed(64);
+  int64_t comp_size = 64;
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Encode(values.data(), -1, compressed.data(), &comp_size));
+}
+
+TYPED_TEST(PforTest, EncodeRejectsNullInputWithValuesToEncode) {
+  using T = TypeParam;
+  std::vector<uint8_t> compressed(64);
+  int64_t comp_size = 64;
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Encode(nullptr, 3, compressed.data(), &comp_size));
+}
+
+TYPED_TEST(PforTest, EncodeRejectsUnrepresentableVectorSize) {
+  using T = TypeParam;
+  std::vector<T> values = {1, 2, 3};
+  std::vector<uint8_t> compressed(64);
+
+  // Not a power of two.
+  int64_t comp_size = 64;
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Encode(values.data(), 3, 1000, compressed.data(),
+                                                &comp_size));
+
+  // A power of two, but the header's log_vector_size field cannot describe it.
+  comp_size = 64;
+  ASSERT_RAISES(
+      Invalid, PforWrapper<T>::Encode(values.data(), 3, PforConstants::kMaxVectorSize * 2,
+                                      compressed.data(), &comp_size));
+}
+
+// ======================================================================
+// Compression Ratio Test
+
+TYPED_TEST(PforTest, ClusteredDataCompresses) {
+  using T = TypeParam;
+  // Data clustered around 1000 with one outlier
+  auto values = TestFixture::RandomValues(1024, 1000, 1255, /*seed=*/42);
+  values[500] = 999999;
+
+  int64_t comp_size = 0;
+  this->RoundTripPage(values, &comp_size);
+
+  const size_t plain_size = 1024 * sizeof(T);
+  EXPECT_LT(comp_size, static_cast<int64_t>(plain_size / 2));
+}
+
+// ======================================================================
+// Corrupt Page Tests
+//
+// A PFOR page can come from anywhere, so Decode has to reject a header that
+// disagrees with the buffer it arrived in rather than trusting it and reading
+// or writing out of bounds.
+
+namespace {
+
+// A tight cluster plus one far outlier, so the cost model packs narrow and
+// patches the outlier. The outlier is 31 bits out rather than 16: an exception
+// costs a position plus a full-width value, so a 16-bit outlier is cheaper to
+// pack than to patch once the values are 64 bits wide, and the tests below need
+// a vector that actually has an exception section.
+template <typename T>
+std::vector<T> ClusterWithOutlier() {
+  return {10, 20, 30, 40, 2'000'000'000};
+}
+
+}  // namespace
+
+TYPED_TEST(PforTest, DecodeElementCountReadsThePageHeader) {
+  using T = TypeParam;
+  std::vector<T> values(2048);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  ASSERT_OK_AND_ASSIGN(const int32_t count, PforWrapper<T>::DecodeElementCount(
+                                                compressed.data(), compressed.size()));
+  EXPECT_EQ(count, static_cast<int32_t>(values.size()));
+}
+
+TYPED_TEST(PforTest, DecodeElementCountRejectsMalformedInput) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  ASSERT_RAISES(Invalid, PforWrapper<T>::DecodeElementCount(
+                             compressed.data(), PforConstants::kHeaderSize - 1));
+  ASSERT_RAISES(Invalid, PforWrapper<T>::DecodeElementCount(nullptr, compressed.size()));
+  ASSERT_RAISES(Invalid, PforWrapper<T>::DecodeElementCount(compressed.data(), -1));
+}
+
+TYPED_TEST(PforTest, CorruptBufferTooSmallForHeader) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Decode(compressed.data(), PforConstants::kHeaderSize - 1,
+                                       5, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptElementCountExceedsOutputCapacity) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  // num_elements lives at header byte 3.
+  StoreLE32(compressed.data() + 3, 6);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptElementCountBelowOutputCapacity) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  // A count short of the caller's capacity would fill part of the output and
+  // leave the rest holding whatever it held before.
+  StoreLE32(compressed.data() + 3, 4);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptOffsetArrayTruncated) {
+  using T = TypeParam;
+  // Four vectors, so the offset array is 16 bytes; hand Decode a buffer with
+  // room for only two of them.
+  std::vector<T> values(4096);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Decode(compressed.data(), PforConstants::kHeaderSize + 8,
+                                       4096, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptVectorOffsetPastEndOfBuffer) {
+  using T = TypeParam;
+  std::vector<T> values(2048);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Point the second vector past the end of the buffer.
+  StoreLE32(compressed.data() + TestFixture::kFirstVectorOffset,
+            static_cast<uint32_t>(compressed.size()));
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(),
+                                                2048, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptFirstVectorOffsetSkipsTheOffsetArray) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  // One vector, so its data starts right after the four byte offset array.
+  StoreLE32(compressed.data() + PforConstants::kHeaderSize, 5);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptVectorOffsetsRunBackwards) {
+  using T = TypeParam;
+  std::vector<T> values(2048);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Point the second vector at the first one's data. Both offsets are inside the
+  // buffer, so only reading them as a chain catches it.
+  StoreLE32(compressed.data() + TestFixture::kFirstVectorOffset,
+            static_cast<uint32_t>(2 * sizeof(PforConstants::OffsetType)));
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(),
+                                                2048, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptExceptionPositionPastEndOfVector) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Locate the stored exception position: the vector info, then the packed
+  // deltas at whatever width the cost model chose.
+  const int64_t vector_start = TestFixture::kFirstVectorOffset;
+  ASSERT_GT(compressed[vector_start + TestFixture::kNumExceptionsOffset], 0)
+      << "the cost model packed this vector without exceptions, so there is no "
+         "exception position to corrupt";
+  const uint8_t bit_width = compressed[vector_start + TestFixture::kBitWidthOffset];
+  const int64_t packed_bytes = (5 * bit_width + 7) / 8;
+  const int64_t position_offset =
+      vector_start + PforVectorInfo<T>::kStoredSize + packed_bytes;
+
+  // Point the exception at index 100 of a five-element vector.
+  compressed[position_offset] = 100;
+  compressed[position_offset + 1] = 0;
+
+  std::vector<T> decoded(5);
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptExceptionCountExceedsVectorLength) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  const int64_t vector_start = TestFixture::kFirstVectorOffset;
+  compressed[vector_start + TestFixture::kNumExceptionsOffset] = 6;
+  compressed[vector_start + TestFixture::kNumExceptionsOffset + 1] = 0;
+
+  std::vector<T> decoded(5);
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptExceptionDataTruncated) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Drop the trailing exception value, leaving its position behind.
+  ASSERT_GT(
+      compressed[TestFixture::kFirstVectorOffset + TestFixture::kNumExceptionsOffset], 0);
+  std::vector<T> decoded(5);
+  ASSERT_RAISES(
+      Invalid, PforWrapper<T>::Decode(compressed.data(),
+                                      static_cast<int64_t>(compressed.size() - sizeof(T)),
+                                      5, decoded.data()));
+}
+
+// A page whose vector is sized exactly leaves no slack, so setting the delta
+// flag on a vector that was written without one makes the decoder ask for
+// sizeof(T) more bytes than the page holds. That has to be an error rather than
+// a read past the end.
+TYPED_TEST(PforTest, CorruptDeltaFlagSetOnANonDeltaVector) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  const int64_t width_byte =
+      TestFixture::kFirstVectorOffset + TestFixture::kBitWidthOffset;
+  ASSERT_EQ(compressed[width_byte] & PforVectorInfo<T>::kDeltaFlag, 0)
+      << "this page was supposed to be encoded without the delta mode";
+  compressed[width_byte] |= PforVectorInfo<T>::kDeltaFlag;
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(
+                             compressed.data(), static_cast<int64_t>(compressed.size()),
+                             static_cast<int32_t>(values.size()), decoded.data()));
+}
+
+// A delta vector's start value sits between the info block and the packed
+// payload, so a page that ends inside it has enough bytes for the info block
+// and not enough for the vector. The check that catches this is the only one
+// that reads is_delta(), so it needs its own case: the width and exception
+// fields are already valid here.
+TYPED_TEST(PforTest, CorruptDeltaVectorTruncatedInsideTheStartValue) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), static_cast<T>(1'000'000));
+  auto compressed = TestFixture::EncodePage(values);
+
+  const int64_t width_byte =
+      TestFixture::kFirstVectorOffset + TestFixture::kBitWidthOffset;
+  ASSERT_NE(compressed[width_byte] & PforVectorInfo<T>::kDeltaFlag, 0)
+      << "an arithmetic run was supposed to be encoded in the delta mode";
+
+  // One byte short of the start value, so PforVectorInfo::Load succeeds and the
+  // vector as a whole does not fit.
+  const int64_t truncated =
+      TestFixture::kFirstVectorOffset + PforVectorInfo<T>::kStoredSize + sizeof(T) - 1;
+  ASSERT_LT(truncated, static_cast<int64_t>(compressed.size()));
+
+  std::vector<T> decoded(values.size());
+  const Status status = PforWrapper<T>::Decode(
+      compressed.data(), truncated, static_cast<int32_t>(values.size()), decoded.data());
+  ASSERT_RAISES(Invalid, status);
+  EXPECT_NE(status.message().find("metadata"), std::string::npos)
+      << "a truncated start value should be reported as missing metadata, got: "
+      << status.message();
+}
+
+// ======================================================================
+// Output sizing
+
+TYPED_TEST(PforTest, MaxCompressedSizeRejectsInvalidArguments) {
+  using T = TypeParam;
+  ASSERT_RAISES(Invalid, PforWrapper<T>::GetMaxCompressedSize(-1));
+  // A zero vector_size would divide by zero on the way to the answer.
+  for (const int32_t vector_size : {0, 3, 1000, PforConstants::kMaxVectorSize * 2}) {
+    SCOPED_TRACE("vector_size=" + std::to_string(vector_size));
+    ASSERT_RAISES(Invalid, PforWrapper<T>::GetMaxCompressedSize(1024, vector_size));
+    std::vector<T> values(16, 0);
+    int64_t comp_size = 1 << 20;
+    std::vector<uint8_t> compressed(comp_size);
+    ASSERT_RAISES(Invalid, PforWrapper<T>::Encode(values.data(), 16, vector_size,
+                                                  compressed.data(), &comp_size));
+  }
+}
+
+TYPED_TEST(PforTest, EncodeRejectsUndersizedOutputBuffer) {
+  using T = TypeParam;
+  std::vector<T> values(1024);
+  std::iota(values.begin(), values.end(), 0);
+  ASSERT_OK_AND_ASSIGN(const int64_t max_size,
+                       PforWrapper<T>::GetMaxCompressedSize(1024));
+
+  std::vector<uint8_t> compressed(max_size);
+  int64_t comp_size = max_size - 1;
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Encode(values.data(), 1024, compressed.data(),
+                                                &comp_size));
+}
+
+TYPED_TEST(PforTest, SerializeVectorRejectsUndersizedDestination) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), 0);
+  const auto encoded = PforCompression<T>::EncodeVector(values.data(), 64);
+  const int64_t needed = PforCompression<T>::SerializedVectorSize(encoded, 64);
+
+  std::vector<uint8_t> buffer(needed);
+  ASSERT_OK_AND_ASSIGN(const int64_t written,
+                       PforCompression<T>::SerializeVector(encoded, 64, buffer));
+  ASSERT_EQ(needed, written);
+  ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(
+                             encoded, 64, std::span<uint8_t>(buffer).subspan(1)));
+}
+
+// SerializedVectorSize is derived from the vector info, while the copy that
+// follows it takes its lengths from the sections, so a vector whose info and
+// sections disagree has to be refused rather than written past the size the
+// caller reserved.
+TYPED_TEST(PforTest, SerializeVectorRejectsInfoInconsistentWithSections) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), 0);
+  const auto encoded = PforCompression<T>::EncodeVector(values.data(), 64);
+  std::vector<uint8_t> buffer(PforCompression<T>::SerializedVectorSize(encoded, 64) + 64);
+
+  {
+    // A bit width that does not account for the packed bytes present.
+    auto corrupted = encoded;
+    corrupted.mutable_info().set_bit_width(
+        static_cast<uint8_t>(encoded.info().bit_width() + 1));
+    ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(corrupted, 64, buffer));
+  }
+  {
+    // An exception count with nothing behind it. Taken relative to the real
+    // count, which need not be zero: the frame search buys a narrower width
+    // with patches, so even a plain ascending run can arrive with one.
+    auto corrupted = encoded;
+    corrupted.mutable_info().set_num_exceptions(
+        static_cast<PforConstants::ExceptionCountType>(encoded.info().num_exceptions() +
+                                                       1));
+    ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(corrupted, 64, buffer));
+  }
+}
+
+// GetMaxCompressedSize is what the encoder allocates, and it is derived from the
+// cost model rather than from a worst case that assumes every value is an
+// exception, so inputs that push the model in different directions all have to
+// land inside it.
+TYPED_TEST(PforTest, MaxCompressedSizeBoundHoldsForAdversarialInputs) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 3000;
+  std::mt19937 rng(7);
+  std::uniform_int_distribution<T> full_range(std::numeric_limits<T>::min(),
+                                              std::numeric_limits<T>::max());
+
+  std::vector<std::vector<T>> inputs;
+  // Incompressible: every delta needs the full width, so the model picks it.
+  inputs.emplace_back(kNumValues);
+  for (auto& v : inputs.back()) v = full_range(rng);
+  // A narrow cluster with a scatter of far-away values, which is the case that
+  // trades bit width against exception count.
+  inputs.emplace_back(kNumValues, 1000);
+  for (int32_t i = 0; i < kNumValues; i += 3) {
+    inputs.back()[i] = full_range(rng);
+  }
+  // Alternating extremes, so the frame of reference cannot help.
+  inputs.emplace_back(kNumValues);
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    inputs.back()[i] =
+        (i % 2 == 0) ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
+  }
+
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    SCOPED_TRACE("input " + std::to_string(i));
+    this->RoundTripPage(inputs[i]);
+  }
+}
+
+// ======================================================================
+// Delta Mode and Frame Search Tests
+
+// The mode has to survive every width, not just the ones a plausible column
+// produces, so this drives it through all of them: a cumulative sum whose
+// differences are exactly w bits wide leaves the encoder no cheaper option than
+// differencing, since the values themselves span 1024 times as much.
+TYPED_TEST(PforTest, DeltaRoundTripsAtEveryBitWidth) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr int32_t kNumValues = 1024;
+
+  for (uint8_t width = 0; width <= PforTypeTraits<T>::kMaxBitWidth; ++width) {
+    SCOPED_TRACE("delta width " + std::to_string(width));
+    // Differences that need exactly `width` bits, and whose top bit is set so
+    // the width cannot be mistaken for a narrower one.
+    const UnsignedT step =
+        width == 0 ? UnsignedT{0} : static_cast<UnsignedT>(UnsignedT{1} << (width - 1));
+
+    std::vector<T> values(kNumValues);
+    auto acc = static_cast<UnsignedT>(0);
+    for (int32_t i = 0; i < kNumValues; ++i) {
+      std::memcpy(&values[i], &acc, sizeof(T));
+      acc += step;
+    }
+    this->RoundTripVector(values);
+  }
+}
+
+// The negative control for the sweep above. If the encoder stopped choosing the
+// delta mode -- a cost-model change, a gate that reads the wrong thing -- every
+// round-trip test would still pass while testing nothing, so assert here that
+// the path is reached at all, and that it is not reached for data it would only
+// make bigger.
+TYPED_TEST(PforTest, DeltaIsChosenForRunsAndDeclinedForNoise) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+
+  std::vector<T> ascending(kNumValues);
+  std::iota(ascending.begin(), ascending.end(), static_cast<T>(1'000'000));
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(ascending, &encoded);
+  EXPECT_TRUE(encoded.info().is_delta());
+
+  // Independent draws from a narrow band: the values fit in 10 bits, while
+  // their differences take 11 and swing both ways.
+  const std::vector<T> noise = this->RandomValues(kNumValues, 0, 1000, 42);
+  this->RoundTripVector(noise, &encoded);
+  EXPECT_FALSE(encoded.info().is_delta());
+}
+
+// The property the mode exists for: a delta vector carries its own first value,
+// so it decodes without the vector before it. Decoding vector 1 of a page
+// straight out of the middle is what a reader doing block-level random access
+// would do, and it has to produce that vector's values and no others.
+TYPED_TEST(PforTest, DeltaVectorDecodesWithoutThePrecedingVector) {
+  using T = TypeParam;
+  constexpr int32_t kVectorSize = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  constexpr int32_t kNumValues = 3 * kVectorSize;
+
+  std::vector<T> values(kNumValues);
+  std::iota(values.begin(), values.end(), static_cast<T>(500));
+  const std::vector<uint8_t> page = this->EncodePage(values);
+
+  // The offset array follows the header, one entry per vector, each counted
+  // from the start of the array itself.
+  const uint8_t* offsets = page.data() + PforConstants::kHeaderSize;
+  const auto second = util::SafeLoadAs<PforConstants::OffsetType>(
+      offsets + sizeof(PforConstants::OffsetType));
+  const uint8_t* vector = offsets + second;
+
+  std::vector<T> decoded(kVectorSize);
+  ASSERT_OK(PforCompression<T>::DecodeVector(
+      std::span<const uint8_t>(vector, page.data() + page.size() - vector), kVectorSize,
+      decoded.data()));
+  EXPECT_EQ(
+      std::vector<T>(values.begin() + kVectorSize, values.begin() + 2 * kVectorSize),
+      decoded);
+}
+
+// Two-sided patching. A tight cluster with one value far below it is the case
+// the old frame could not handle: at the minimum, the packed window has to span
+// the whole gap and every value in the cluster pays for it. The frame belongs
+// above the low value, which then becomes an exception like any other.
+TYPED_TEST(PforTest, FrameSitsAboveTheMinimumToPatchALowOutlier) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+
+  std::vector<T> values = this->RandomValues(kNumValues, 1'000'000, 1'000'063, 5);
+  values[500] = 0;  // one value four orders of magnitude below the cluster
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_GT(encoded.info().frame_of_reference(),
+            *std::min_element(values.begin(), values.end()));
+  EXPECT_GE(encoded.info().num_exceptions(), 1);
+  // Six bits covers the cluster; spanning the gap would take twenty. The bound
+  // is loose because the search picks the frame from bucketed counts and then
+  // lowers it to the smallest value it actually covers, which lands on the
+  // cluster minimum only when the cluster falls inside one bucket.
+  EXPECT_LE(encoded.info().bit_width(), 8);
+}
+
+// The two features together, on the shape that motivated them: a counter that
+// climbs steadily and resets, whose differences are a run of small positive
+// values with a handful of large negative ones. The differences want a frame
+// above their minimum, and the drops want patching -- neither alone is enough,
+// and this is where both of the encoder's bugs showed up during development.
+TYPED_TEST(PforTest, SawtoothPacksAtNearlyNoCost) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 8192;
+
+  std::vector<T> values(kNumValues);
+  T level = 0;
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    values[i] = level;
+    level = (i % 200 == 199) ? 0 : static_cast<T>(level + 12);
+  }
+
+  int64_t comp_size = 0;
+  this->RoundTripPage(values, &comp_size);
+  // The differences pack at width 0 with one patch per reset. Anything that
+  // falls back to a width wide enough to hold the climb costs at least 12 bits
+  // a value, so a bound of one is far from the boundary.
+  const double bits_per_value = 8.0 * comp_size / kNumValues;
+  EXPECT_LT(bits_per_value, 1.0) << "compressed to " << bits_per_value << " bits/value";
+}
+
+// An exception in a delta vector is itself a difference, so the decoder has to
+// patch before it sums. Summing first would carry the placeholder zero into
+// every value after the patch, which round-trips as a plausible-looking
+// sequence rather than an obvious corruption.
+TYPED_TEST(PforTest, DeltaExceptionsArePatchedBeforeTheSum) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+
+  // A steady climb with occasional jumps far larger than the packed width can
+  // hold, so the jumps become exceptions and everything after one depends on
+  // the patch having landed.
+  std::vector<T> values(kNumValues);
+  T level = 1000;
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    values[i] = level;
+    level = static_cast<T>(level + ((i % 137 == 100) ? 1'000'000 : 3));
+  }
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_TRUE(encoded.info().is_delta());
+  EXPECT_GE(encoded.info().num_exceptions(), 1);
+}
+
+// The delta flag shares its byte with the bit width, and the width goes up to
+// 64, which needs all seven of the bits left over. A vector whose differences
+// span the type is the case that would catch the two fields overlapping.
+TYPED_TEST(PforTest, DeltaAtFullWidthRoundTrips) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+  std::mt19937_64 rng(3);
+
+  // Values whose differences are full-width, built by accumulating full-width
+  // steps, so the sequence wraps the type as it goes.
+  std::vector<T> values(kNumValues);
+  auto acc = static_cast<typename PforTypeTraits<T>::UnsignedType>(0);
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    std::memcpy(&values[i], &acc, sizeof(T));
+    acc += static_cast<typename PforTypeTraits<T>::UnsignedType>(rng());
+  }
+  this->RoundTripVector(values);
+}
+
+// The same overlap, tested at the metadata directly rather than through data
+// that happens to produce it, at every width the type allows.
+TYPED_TEST(PforTest, VectorInfoKeepsTheDeltaFlagOutOfTheWidth) {
+  using T = TypeParam;
+  std::vector<uint8_t> buffer(PforVectorInfo<T>::kStoredSize);
+
+  for (uint8_t width = 0; width <= PforTypeTraits<T>::kMaxBitWidth; ++width) {
+    for (bool is_delta : {false, true}) {
+      SCOPED_TRACE("width " + std::to_string(width) + " delta " +
+                   std::to_string(is_delta));
+      const PforVectorInfo<T> info(static_cast<T>(-7), width, 123, is_delta);
+      info.Store(buffer);
+      ASSERT_OK_AND_ASSIGN(const auto loaded, PforVectorInfo<T>::Load(buffer));
+      EXPECT_EQ(loaded.bit_width(), width);
+      EXPECT_EQ(loaded.is_delta(), is_delta);
+      EXPECT_EQ(loaded.frame_of_reference(), static_cast<T>(-7));
+      EXPECT_EQ(loaded.num_exceptions(), 123);
+      EXPECT_EQ(loaded.stored_bytes(),
+                PforVectorInfo<T>::kStoredSize +
+                    (is_delta ? static_cast<int64_t>(sizeof(T)) : 0));
+    }
+  }
+}
+
+// Differencing is done in the unsigned domain because signed overflow is
+// undefined, and a column spanning the type's range will overflow. The bits
+// have to round-trip anyway.
+TYPED_TEST(PforTest, DeltaRoundTripsAcrossTheTypeExtremes) {
+  using T = TypeParam;
+  const T lo = std::numeric_limits<T>::min();
+  const T hi = std::numeric_limits<T>::max();
+
+  std::vector<std::vector<T>> inputs = {
+      {lo, hi, lo, hi, lo, hi, lo, hi},
+      {lo, static_cast<T>(lo + 1), static_cast<T>(lo + 2), hi, static_cast<T>(hi - 1)},
+      {hi, static_cast<T>(hi - 1), static_cast<T>(hi - 2), lo, static_cast<T>(lo + 1)},
+  };
+  // A ramp from the bottom of the type that runs off the top of it.
+  inputs.emplace_back(1024);
+  auto acc = static_cast<typename PforTypeTraits<T>::UnsignedType>(lo);
+  for (auto& v : inputs.back()) {
+    std::memcpy(&v, &acc, sizeof(T));
+    acc += static_cast<typename PforTypeTraits<T>::UnsignedType>(hi / 100);
+  }
+
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    SCOPED_TRACE("input " + std::to_string(i));
+    this->RoundTripVector(inputs[i]);
+  }
+}
+
+// Small vectors are where the start value is expensive: the format allows eight
+// values to a vector, and eight bytes across eight of them is a byte each. The
+// cost model has to account for it rather than differencing whenever the
+// differences happen to be narrower.
+TYPED_TEST(PforTest, StartValueIsPaidForAtEveryVectorSize) {
+  using T = TypeParam;
+  for (int32_t log_size = PforConstants::kMinLogVectorSize;
+       log_size <= PforConstants::kMaxLogVectorSize; ++log_size) {
+    const int32_t vector_size = 1 << log_size;
+    SCOPED_TRACE("vector size " + std::to_string(vector_size));
+
+    std::vector<T> values(static_cast<size_t>(vector_size) * 3);
+    std::iota(values.begin(), values.end(), static_cast<T>(77));
+
+    const auto num_values = static_cast<int32_t>(values.size());
+    ASSERT_OK_AND_ASSIGN(const int64_t max_size,
+                         PforWrapper<T>::GetMaxCompressedSize(num_values, vector_size));
+    std::vector<uint8_t> compressed(max_size);
+    int64_t comp_size = max_size;
+    ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, vector_size,
+                                     compressed.data(), &comp_size));
+    ASSERT_LE(comp_size, max_size);
+
+    std::vector<T> decoded(values.size());
+    ASSERT_OK(
+        PforWrapper<T>::Decode(compressed.data(), comp_size, num_values, decoded.data()));
+    EXPECT_EQ(values, decoded);
+  }
+}
+
+// A one-element vector has no difference to take, and a two-element one has
+// exactly one. Both are inside the range the format allows for a trailing
+// partial vector.
+TYPED_TEST(PforTest, DeltaHandlesVectorsTooShortToDifference) {
+  using T = TypeParam;
+  this->RoundTripVector(std::vector<T>{42});
+  this->RoundTripVector(std::vector<T>{42, 43});
+  this->RoundTripVector(std::vector<T>{std::numeric_limits<T>::max()});
+  this->RoundTripVector(
+      std::vector<T>{std::numeric_limits<T>::max(), std::numeric_limits<T>::min()});
+}
+
+namespace {
+
+/// A named column shape, for the gate test below.
+template <typename T>
+struct NamedColumn {
+  std::string name;
+  std::vector<T> values;
+};
+
+/// The distributions in pfor_benchmark.cc, plus the extremes, as one battery.
+/// Anything that changes the encoder's mind about differencing has to be seen
+/// on one of these or it is not being tested.
+template <typename T>
+std::vector<NamedColumn<T>> DeltaDecisionColumns() {
+  constexpr int32_t kN = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  std::vector<NamedColumn<T>> columns;
+  auto add = [&columns](std::string name, std::vector<T> values) {
+    columns.push_back({std::move(name), std::move(values)});
+  };
+  auto make = [](auto fn) {
+    std::vector<T> v(kN);
+    for (int32_t i = 0; i < kN; ++i) v[i] = fn(i);
+    return v;
+  };
+
+  add("constant", std::vector<T>(kN, static_cast<T>(-7)));
+  add("ascending", make([](int32_t i) { return static_cast<T>(1'000'000 + i); }));
+  add("descending", make([](int32_t i) { return static_cast<T>(1'000'000 - i); }));
+  add("monotonic_with_gaps", make([](int32_t i) {
+        return static_cast<T>(500'000 + i * 3 + (i % 64 == 0 ? 4096 : 0));
+      }));
+  add("timestamps",
+      make([](int32_t i) { return static_cast<T>(1'700'000'000 + i * 17 + (i % 7)); }));
+  // A ramp that resets: small positive differences with a handful of large
+  // negative ones. The shape the two-sided frame exists for.
+  add("sawtooth",
+      make([](int32_t i) { return static_cast<T>((i % 200) * 13 + 100'000); }));
+  add("cluster_far_from_zero",
+      make([](int32_t i) { return static_cast<T>(1'000'000 + (i % 37)); }));
+  add("two_clusters", make([](int32_t i) {
+        return static_cast<T>(i % 2 == 0 ? 100 + (i % 8) : 900'000 + (i % 8));
+      }));
+  add("cluster_with_outliers", make([](int32_t i) {
+        return static_cast<T>(i % 97 == 0 ? 1'000'000 + i : 500 + (i % 11));
+      }));
+  add("type_extremes", make([](int32_t i) {
+        return i % 2 == 0 ? std::numeric_limits<T>::lowest() + static_cast<T>(i)
+                          : std::numeric_limits<T>::max() - static_cast<T>(i);
+      }));
+  // A random walk, and independent draws at several spreads. The walk is where
+  // differencing pays; the draws are where it must be declined.
+  for (uint32_t seed : {1u, 7u, 42u, 1234u}) {
+    std::mt19937 rng(seed);
+    std::uniform_int_distribution<int32_t> step(-40, 40);
+    auto walk = static_cast<UnsignedT>(0);
+    std::vector<T> values(kN);
+    for (int32_t i = 0; i < kN; ++i) {
+      walk += static_cast<UnsignedT>(static_cast<T>(step(rng)));
+      std::memcpy(&values[i], &walk, sizeof(T));
+    }
+    add("random_walk_" + std::to_string(seed), std::move(values));
+  }
+  for (T spread : {static_cast<T>(1), static_cast<T>(1000), static_cast<T>(1'000'000)}) {
+    for (uint32_t seed : {3u, 99u}) {
+      std::vector<T> values(kN);
+      std::mt19937 rng(seed);
+      std::uniform_int_distribution<T> dist(static_cast<T>(0), spread);
+      for (auto& v : values) v = dist(rng);
+      add("noise_" + std::to_string(static_cast<int64_t>(spread)) + "_" +
+              std::to_string(seed),
+          std::move(values));
+    }
+  }
+  return columns;
+}
+
+/// What ChooseVectorPlan would decide with no gate in front of the delta
+/// search: cost both modes properly and keep the cheaper.
+template <typename T>
+PforVectorPlan<T> ChooseVectorPlanUngated(const T* values, int32_t num_elements,
+                                          T* delta_scratch) {
+  const FrameChoice<T> raw = ChooseFrameAndWidth<T>(values, num_elements);
+  PforVectorPlan<T> plan;
+  plan.frame_of_reference = raw.frame_of_reference;
+  plan.bit_width = raw.bit_width;
+  plan.num_exceptions = raw.num_exceptions;
+  plan.cost_bits = raw.cost_bits;
+  if (num_elements < 2 || raw.bit_width == 0) return plan;
+
+  MinMax<T> delta_bounds;
+  ComputeDeltas<T>(values, num_elements, delta_scratch, &delta_bounds);
+  const FrameChoice<T> delta =
+      ChooseFrameAndWidth<T>(delta_scratch, num_elements, delta_bounds);
+  const int64_t delta_cost = delta.cost_bits + static_cast<int64_t>(sizeof(T)) * 8;
+  if (delta_cost < plan.cost_bits) {
+    plan.delta = true;
+    plan.frame_of_reference = delta.frame_of_reference;
+    plan.start_value = values[0];
+    plan.bit_width = delta.bit_width;
+    plan.num_exceptions = delta.num_exceptions;
+    plan.cost_bits = delta_cost;
+  }
+  return plan;
+}
+
+}  // namespace
+
+// The gate in front of the delta search is an estimate, so it can in principle
+// decline a vector the search would have won. Pin that it does not, on every
+// shape the encoder is meant to handle: same mode, same width, same cost as the
+// ungated chooser. A change that makes the estimate too pessimistic shows up
+// here as a lost delta rather than as a silent ratio regression.
+TYPED_TEST(PforTest, DeltaGateAgreesWithTheUngatedChooser) {
+  using T = TypeParam;
+  int delta_chosen = 0;
+  for (const auto& column : DeltaDecisionColumns<T>()) {
+    SCOPED_TRACE(column.name);
+    const auto n = static_cast<int32_t>(column.values.size());
+    std::vector<T> scratch(n);
+    const PforVectorPlan<T> gated =
+        ChooseVectorPlan<T>(column.values.data(), n, scratch.data(),
+                            /*delta_enabled=*/true);
+    const PforVectorPlan<T> ungated =
+        ChooseVectorPlanUngated<T>(column.values.data(), n, scratch.data());
+
+    EXPECT_EQ(ungated.delta, gated.delta);
+    EXPECT_EQ(ungated.cost_bits, gated.cost_bits);
+    EXPECT_EQ(ungated.bit_width, gated.bit_width);
+    EXPECT_EQ(ungated.frame_of_reference, gated.frame_of_reference);
+    EXPECT_EQ(ungated.num_exceptions, gated.num_exceptions);
+    if (gated.delta) ++delta_chosen;
+  }
+  // The battery has to exercise both answers, or the agreement above is only
+  // evidence that the gate declines everything.
+  EXPECT_GT(delta_chosen, 0);
+}
+
+// The estimate is the point of the gate, so check it reaches the shape it was
+// built for. A gate reading the spread of the differences rather than their
+// distribution declines the sawtooth, whose differences are as widely spread as
+// its values and far cheaper to pack.
+TYPED_TEST(PforTest, DeltaGateAdmitsTheSawtooth) {
+  using T = TypeParam;
+  constexpr int32_t kN = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  std::vector<T> values(kN);
+  for (int32_t i = 0; i < kN; ++i) {
+    values[i] = static_cast<T>((i % 200) * 13 + 100'000);
+  }
+  std::vector<T> scratch(kN);
+  const PforVectorPlan<T> plan =
+      ChooseVectorPlan<T>(values.data(), kN, scratch.data(), /*delta_enabled=*/true);
+  EXPECT_TRUE(plan.delta);
+  // Five resets in 1024 values, patched, leaving a very narrow packed window.
+  EXPECT_LE(plan.bit_width, 5);
+}
+
+}  // 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..4aeda66fa411
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
@@ -0,0 +1,364 @@
+// 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 (header.packing_mode != PforConstants::kPackingModeForBitPack) {
+    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);
+  }
+  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;
+
+  // Step 1: Write header
+  PforHeader header;
+  header.packing_mode = PforConstants::kPackingModeForBitPack;
+  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);
+
+    auto encoded =
+        PforCompression<T>::EncodeVector(values + start_idx, elements_in_vector, options);
+
+    // 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));
+  }
+
+  return Status::OK();
+}
+
+// ----------------------------------------------------------------------
+// DecodeElementCount
+
+template <typename T>
+Result<int32_t> PforWrapper<T>::DecodeElementCount(const uint8_t* comp,
+                                                   int64_t comp_size) {
+  if (comp == nullptr) {
+    return Status::Invalid("PFOR compressed data pointer is null");
+  }
+  if (comp_size < 0) {
+    return Status::Invalid("PFOR compressed size must be non-negative: ", comp_size);
+  }
+  ARROW_ASSIGN_OR_RAISE(const PforHeader header,
+                        LoadHeader(std::span<const uint8_t>(comp, comp_size)));
+  return header.num_elements;
+}
+
+// ----------------------------------------------------------------------
+// GetMaxCompressedSize
+
+template <typename T>
+Result<int64_t> PforWrapper<T>::GetMaxCompressedSize(int32_t num_values,
+                                                     int32_t vector_size) {
+  if (num_values < 0) {
+    return Status::Invalid("PFOR num_values must be non-negative: ", num_values);
+  }
+  RETURN_NOT_OK(ValidateVectorSize(vector_size));
+
+  const int64_t num_vectors = bit_util::CeilDiv(num_values, vector_size);
+
+  // A vector never serializes to more than its values occupy unpacked. The cost
+  // model minimises `num_elements * bit_width + num_exceptions * (16 +
+  // 8 * sizeof(T))` bits, and the full-width candidate scores
+  // `num_elements * 8 * sizeof(T)` bits with no exceptions at all, so whatever
+  // width it does pick costs no more than that. Bit packing rounds the packed
+  // section up to a whole byte, hence the trailing byte. The delta mode adds
+  // one full-width start value, and the model only chooses it when doing so
+  // still comes out cheaper, but the bound has to hold for either outcome.
+  const int64_t max_vector_size = PforVectorInfo<T>::kStoredSize +
+                                  static_cast<int64_t>(sizeof(T)) +
+                                  vector_size * static_cast<int64_t>(sizeof(T)) + 1;
+
+  return PforConstants::kHeaderSize + num_vectors * (kOffsetSize + max_vector_size);
+}
+
+// Explicit template instantiations
+template class PforWrapper<int32_t>;
+template class PforWrapper<int64_t>;
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
new file mode 100644
index 000000000000..5fe52183ebe1
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
@@ -0,0 +1,119 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// High-level wrapper interface for PFOR compression
+//
+// Handles page-level serialization: header, offset array, and vectors.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <span>
+
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/pfor/pfor_internal.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+/// \class PforWrapper
+/// \brief High-level interface for PFOR page-level compression
+///
+/// Manages the page layout: [Header 7B] [Offset Array] [Vector 0] [Vector 1] ...
+///
+/// \tparam T the integer type (int32_t or int64_t)
+template <typename T>
+class PforWrapper {
+ public:
+  /// \brief Encode integer values into a PFOR-compressed page
+  ///
+  /// \param[in] values pointer to input integers
+  /// \param[in] num_values total number of values; zero writes a bare header,
+  ///            which is what an all-null page encodes to
+  /// \param[in] vector_size number of elements per vector (must be a power of 2,
+  ///            in [2^kMinLogVectorSize, 2^kMaxLogVectorSize])
+  /// \param[out] comp pointer to output buffer, at least
+  ///             GetMaxCompressedSize(num_values, vector_size) bytes
+  /// \param[in,out] comp_size input: available buffer size, which must be at
+  ///                least GetMaxCompressedSize(num_values, vector_size);
+  ///                output: bytes written
+  /// \param[in] options what the encoder is allowed to choose
+  /// \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
+  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;      // 0 = FOR + bit-packing
+    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..ee7ad198e3fe
--- /dev/null
+++ b/cpp/src/parquet/arrow/arrow_encoding_test.cc
@@ -0,0 +1,433 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// End-to-end tests for the column encodings, driven through the Arrow reader
+// and writer rather than through the encoder classes directly.
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "arrow/chunked_array.h"
+#include "arrow/io/memory.h"
+#include "arrow/table.h"
+#include "arrow/testing/builder.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/testing/random.h"
+#include "arrow/type.h"
+#include "arrow/util/config.h"
+
+#include "parquet/arrow/reader.h"
+#include "parquet/arrow/writer.h"
+#include "parquet/file_reader.h"
+#include "parquet/metadata.h"
+#include "parquet/platform.h"
+#include "parquet/properties.h"
+#include "parquet/test_util.h"
+#include "parquet/types.h"
+
+using arrow::ChunkedArray;
+using arrow::Table;
+using arrow::io::BufferReader;
+
+namespace parquet {
+namespace arrow {
+namespace {
+
+// Write `table` with `writer_properties` and read it straight back, handing back
+// the file's bytes as well so a caller can check what the writer chose.
+void DoRoundtrip(const std::shared_ptr<Table>& table, int64_t row_group_size,
+                 std::shared_ptr<Table>* out,
+                 const std::shared_ptr<WriterProperties>& writer_properties,
+                 std::shared_ptr<Buffer>* out_file = nullptr) {
+  auto sink = CreateOutputStream();
+  ASSERT_OK_NO_THROW(WriteTable(*table, ::arrow::default_memory_pool(), sink,
+                                row_group_size, writer_properties));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+  if (out_file != nullptr) {
+    *out_file = buffer;
+  }
+
+  std::unique_ptr<FileReader> reader;
+  FileReaderBuilder builder;
+  ASSERT_OK_NO_THROW(builder.Open(std::make_shared<BufferReader>(buffer)));
+  ASSERT_OK(builder.Build(&reader));
+  ASSERT_OK_AND_ASSIGN(*out, reader->ReadTable());
+}
+
+// Fail unless every column chunk of `file` was written with `encoding`. Without
+// this a round trip still passes when the writer quietly chose something else,
+// and the test would be checking the default encoding instead.
+void AssertAllColumnsUse(const std::shared_ptr<Buffer>& file, Encoding::type encoding) {
+  auto metadata =
+      ParquetFileReader::Open(std::make_shared<BufferReader>(file))->metadata();
+  ASSERT_GT(metadata->num_row_groups(), 0);
+  for (int rg = 0; rg < metadata->num_row_groups(); ++rg) {
+    auto row_group = metadata->RowGroup(rg);
+    for (int col = 0; col < row_group->num_columns(); ++col) {
+      EXPECT_THAT(row_group->ColumnChunk(col)->encodings(), ::testing::Contains(encoding))
+          << "row group " << rg << " column " << col << " does not use "
+          << EncodingToString(encoding);
+    }
+  }
+}
+
+// ============================================================================
+// PFOR encoding file-level integration tests
+// ============================================================================
+
+class ParquetPforEncodingTest : public ::testing::Test {
+ public:
+  void TestPforRoundTrip(const std::shared_ptr<Table>& table,
+                         int64_t row_group_size = -1) {
+    auto writer_props = WriterProperties::Builder()
+                            .disable_dictionary()
+                            ->enable_pfor_encoding()
+                            ->encoding(Encoding::PFOR)
+                            ->build();
+
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, row_group_size < 0 ? table->num_rows() : row_group_size, &result,
+                writer_props, &file);
+
+    ASSERT_NO_FATAL_FAILURE(AssertAllColumnsUse(file, Encoding::PFOR));
+    ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+  }
+
+  void TestPforWithCompression(const std::shared_ptr<Table>& table,
+                               Compression::type compression) {
+    auto writer_props = WriterProperties::Builder()
+                            .disable_dictionary()
+                            ->enable_pfor_encoding()
+                            ->encoding(Encoding::PFOR)
+                            ->compression(compression)
+                            ->build();
+
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, table->num_rows(), &result, writer_props, &file);
+
+    ASSERT_NO_FATAL_FAILURE(AssertAllColumnsUse(file, Encoding::PFOR));
+    ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+  }
+
+  // A table of one column named "values" holding `values`.
+  template <typename ArrowType, typename C>
+  static std::shared_ptr<Table> TableOf(const std::shared_ptr<::arrow::DataType>& type,
+                                        const C& values) {
+    std::shared_ptr<::arrow::Array> array;
+    ::arrow::ArrayFromVector<ArrowType>(values, &array);
+    return Table::Make(::arrow::schema({::arrow::field("values", type)}),
+                       {std::make_shared<ChunkedArray>(array)});
+  }
+};
+
+TEST_F(ParquetPforEncodingTest, SimpleInt32Table) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])"});
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, SimpleInt64Table) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[-100], [0], [100], [200], [300], [400], [500], [600], [700]])"});
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, MixedTypesWithInt32Int64) {
+  auto schema = ::arrow::schema({::arrow::field("id", ::arrow::int32()),
+                                 ::arrow::field("count", ::arrow::int64()),
+                                 ::arrow::field("ratio", ::arrow::float64()),
+                                 ::arrow::field("name", ::arrow::utf8())});
+  auto table = ::arrow::TableFromJSON(schema, {R"([[1, 1000, 1.5, "a"],
+                                          [2, 1001, 2.5, "b"],
+                                          [3, 1002, 3.5, "c"],
+                                          [4, 1003, 4.5, "d"],
+                                          [5, 1004, 5.5, "e"]])"});
+  // PFOR takes only the two integer columns; the rest keep their defaults.
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->enable_pfor_encoding()
+                          ->encoding("id", Encoding::PFOR)
+                          ->encoding("count", Encoding::PFOR)
+                          ->build();
+
+  std::shared_ptr<Table> result;
+  DoRoundtrip(table, table->num_rows(), &result, writer_props);
+
+  ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+}
+
+TEST_F(ParquetPforEncodingTest, LargeInt32Dataset) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int32(10000, -1000000, 1000000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, LargeInt64Dataset) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int64(10000, -1000000000LL, 1000000000LL);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table);
+}
+
+// The distribution PFOR is built for: a tight cluster sitting a long way from
+// zero, so the frame of reference carries the magnitude and the bit-packed
+// payload carries only the spread.
+TEST_F(ParquetPforEncodingTest, ClusteredValuesFarFromZero) {
+  std::vector<int64_t> values(4000);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 1'000'000'000'000LL + static_cast<int64_t>(i % 37);
+  }
+  TestPforRoundTrip(TableOf<::arrow::Int64Type>(::arrow::int64(), values));
+}
+
+// One vector of a constant, which encodes at bit width 0 and so has an empty
+// bit-packed payload.
+TEST_F(ParquetPforEncodingTest, ConstantColumn) {
+  std::vector<int32_t> values(2048, -7);
+  TestPforRoundTrip(TableOf<::arrow::Int32Type>(::arrow::int32(), values));
+}
+
+// A cluster with a few values far above it, which is what the exception path
+// exists to hold.
+TEST_F(ParquetPforEncodingTest, ClusterWithOutliers) {
+  std::vector<int32_t> values(3000);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 500 + static_cast<int32_t>(i % 11);
+    if (i % 97 == 0) {
+      values[i] = 1'000'000 + static_cast<int32_t>(i);
+    }
+  }
+  TestPforRoundTrip(TableOf<::arrow::Int32Type>(::arrow::int32(), values));
+}
+
+// The extremes of each type in one vector, where the span between the smallest
+// and largest value does not fit in the type and the encoder has to fall back
+// to storing full-width values.
+TEST_F(ParquetPforEncodingTest, Int32AtTypeBounds) {
+  std::vector<int32_t> values = {std::numeric_limits<int32_t>::lowest(),
+                                 std::numeric_limits<int32_t>::max(),
+                                 0,
+                                 -1,
+                                 1,
+                                 std::numeric_limits<int32_t>::lowest() + 1,
+                                 std::numeric_limits<int32_t>::max() - 1};
+  TestPforRoundTrip(TableOf<::arrow::Int32Type>(::arrow::int32(), values));
+}
+
+TEST_F(ParquetPforEncodingTest, Int64AtTypeBounds) {
+  std::vector<int64_t> values = {std::numeric_limits<int64_t>::lowest(),
+                                 std::numeric_limits<int64_t>::max(),
+                                 0,
+                                 -1,
+                                 1,
+                                 std::numeric_limits<int64_t>::lowest() + 1,
+                                 std::numeric_limits<int64_t>::max() - 1};
+  TestPforRoundTrip(TableOf<::arrow::Int64Type>(::arrow::int64(), values));
+}
+
+TEST_F(ParquetPforEncodingTest, Int32WithNulls) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[1], [null], [3], [null], [5], [6], [null], [8]])"});
+  TestPforRoundTrip(table);
+}
+
+// A PFOR page holds no nulls, so an all-null page carries no values at all and
+// has to survive the round trip as a header with an empty payload.
+TEST_F(ParquetPforEncodingTest, AllNullColumn) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[null], [null], [null], [null], [null], [null]])"});
+  TestPforRoundTrip(table);
+}
+
+// Nulls ahead of the first value, which makes the level count and the value
+// count differ from the very first batch a reader sees.
+TEST_F(ParquetPforEncodingTest, LeadingNulls) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[null], [null], [null], [7], [8], [9], [null], [11]])"});
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, MultipleRowGroups) {
+  ::arrow::random::RandomArrayGenerator rag(123);
+  auto array = rag.Int64(5000, -100, 100);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table, /*row_group_size=*/1000);
+}
+
+// Row groups that do not divide the vector size, so most pages end on a partial
+// vector.
+TEST_F(ParquetPforEncodingTest, RowGroupsEndOnPartialVectors) {
+  ::arrow::random::RandomArrayGenerator rag(7);
+  auto array = rag.Int32(5000, -50000, 50000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table, /*row_group_size=*/1500);
+}
+
+#ifdef ARROW_WITH_ZSTD
+TEST_F(ParquetPforEncodingTest, PforWithZstdCompression) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int64(5000, -1000, 1000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforWithCompression(table, Compression::ZSTD);
+}
+#endif
+
+#ifdef ARROW_WITH_SNAPPY
+TEST_F(ParquetPforEncodingTest, PforWithSnappyCompression) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int32(5000, -1000, 1000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforWithCompression(table, Compression::SNAPPY);
+}
+#endif
+
+TEST_F(ParquetPforEncodingTest, VerifyPforEncodingUsed) {
+  std::vector<int64_t> values(1000);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 5'000'000 + static_cast<int64_t>(i);
+  }
+  auto table = TableOf<::arrow::Int64Type>(::arrow::int64(), values);
+
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->enable_pfor_encoding()
+                          ->encoding(Encoding::PFOR)
+                          ->build();
+
+  auto sink = CreateOutputStream();
+  ASSERT_OK(WriteTable(*table, ::arrow::default_memory_pool(), sink, table->num_rows(),
+                       writer_props));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+
+  auto reader = ParquetFileReader::Open(std::make_shared<BufferReader>(buffer));
+  auto metadata = reader->metadata();
+
+  ASSERT_EQ(metadata->num_row_groups(), 1);
+  auto row_group = metadata->RowGroup(0);
+  ASSERT_EQ(row_group->num_columns(), 1);
+
+  auto encodings = row_group->ColumnChunk(0)->encodings();
+  EXPECT_THAT(encodings, ::testing::Contains(Encoding::PFOR))
+      << "PFOR encoding not found in column encodings";
+}
+
+// A reader that asks for fewer values than the page holds is served the rest on
+// later calls, so batches smaller than a page must reassemble exactly.
+TEST_F(ParquetPforEncodingTest, ReadInSmallBatches) {
+  ::arrow::random::RandomArrayGenerator rag(99);
+  auto array = rag.Int32(4096, -30000, 30000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->enable_pfor_encoding()
+                          ->encoding(Encoding::PFOR)
+                          ->build();
+
+  auto sink = CreateOutputStream();
+  ASSERT_OK(WriteTable(*table, ::arrow::default_memory_pool(), sink, table->num_rows(),
+                       writer_props));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+
+  std::unique_ptr<FileReader> reader;
+  FileReaderBuilder builder;
+  ASSERT_OK_NO_THROW(builder.Open(std::make_shared<BufferReader>(buffer)));
+  ASSERT_OK(builder.properties(default_arrow_reader_properties())->Build(&reader));
+  reader->set_batch_size(97);
+
+  ASSERT_OK_AND_ASSIGN(auto batch_reader, reader->GetRecordBatchReader());
+  ASSERT_OK_AND_ASSIGN(auto result, batch_reader->ToTable());
+
+  ASSERT_NO_FATAL_FAILURE(
+      ::arrow::AssertTablesEqual(*table, *result, /*same_chunk_layout=*/false));
+}
+
+// The delta mode is a per-column writer option, so a column it clearly helps
+// must come out smaller with the mode left on than with it turned off, and both
+// files must read back the same values.
+TEST_F(ParquetPforEncodingTest, DeltaModeCanBeTurnedOffPerColumn) {
+  // A long arithmetic run: undifferenced it needs enough bits to cover the whole
+  // span, differenced it is a constant and needs none.
+  std::vector<int64_t> values(4096);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 3'000'000'000'000LL + static_cast<int64_t>(i) * 7;
+  }
+  auto table = TableOf<::arrow::Int64Type>(::arrow::int64(), values);
+
+  auto size_of = [&](bool delta_enabled) {
+    auto builder = WriterProperties::Builder();
+    builder.disable_dictionary()
+        ->enable_pfor_encoding()
+        ->encoding(Encoding::PFOR)
+        ->disable_statistics();
+    if (!delta_enabled) {
+      builder.disable_pfor_delta_encoding("values");
+    }
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, table->num_rows(), &result, builder.build(), &file);
+    ::arrow::AssertTablesEqual(*table, *result);
+
+    auto metadata =
+        ParquetFileReader::Open(std::make_shared<BufferReader>(file))->metadata();
+    return metadata->RowGroup(0)->ColumnChunk(0)->total_uncompressed_size();
+  };
+
+  const int64_t with_delta = size_of(/*delta_enabled=*/true);
+  const int64_t without_delta = size_of(/*delta_enabled=*/false);
+  EXPECT_LT(with_delta, without_delta)
+      << "disable_pfor_delta_encoding did not reach the encoder: " << with_delta
+      << " bytes with the mode on, " << without_delta << " with it off";
+}
+
+}  // namespace
+}  // namespace arrow
+}  // namespace parquet
diff --git a/cpp/src/parquet/column_reader.cc b/cpp/src/parquet/column_reader.cc
index 162a72bd1576..b2d5c18630c8 100644
--- a/cpp/src/parquet/column_reader.cc
+++ b/cpp/src/parquet/column_reader.cc
@@ -971,7 +971,8 @@ 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: {
           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..ba2dab75945d 100644
--- a/cpp/src/parquet/decoder.cc
+++ b/cpp/src/parquet/decoder.cc
@@ -44,6 +44,7 @@
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging_internal.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
 #include "arrow/util/rle_encoding_internal.h"
 #include "arrow/util/spaced_internal.h"
 #include "arrow/util/ubsan.h"
@@ -2372,6 +2373,173 @@ class ByteStreamSplitDecoder<FLBAType> : public ByteStreamSplitDecoderBase<FLBAT
   }
 };
 
+// ----------------------------------------------------------------------
+// PFOR Decoder
+
+// TODO: support incremental decode. Partial reads currently decode the
+// entire page into `decoded_values_` on first call and copy out the
+// requested range; a future revision should decode only the requested
+// values, with state tracking for cross-call resumption. This is deferred
+// to a follow-up change; the encoder carries the matching TODO.
+template <typename DType>
+class PforDecoder : public TypedDecoderImpl<DType> {
+ public:
+  using Base = TypedDecoderImpl<DType>;
+  using T = typename DType::c_type;
+
+  // TODO: decode a vector at a time. PforWrapper::Decode keeps no resumption
+  // state, so a caller that reads a page in batches decodes the whole page into
+  // `decoded_values_` on the first batch and is served from it afterwards, which
+  // costs a page-sized allocation. The page layout is already addressed by
+  // vector: its offset array locates any vector in constant time, so a batched
+  // read could decode the vectors it needs into a scratch buffer of one vector
+  // and leave the rest of the page untouched.
+  explicit PforDecoder(const ColumnDescriptor* descr,
+                       MemoryPool* pool = ::arrow::default_memory_pool())
+      : Base(descr, Encoding::PFOR),
+        pool_(pool),
+        decoded_values_(AllocateBuffer(pool, 0)) {}
+
+  void SetData(int num_values, const uint8_t* data, int len) override {
+    Base::SetData(num_values, data, len);
+    if (num_values > 0 && len <= 0) {
+      throw ParquetException("PFOR SetData: num_values=" + std::to_string(num_values) +
+                             " but len=" + std::to_string(len));
+    }
+    // A decoder is cached per encoding and reused across the data pages of a
+    // column chunk, so every piece of state describing the previous page has to
+    // be dropped along with the page itself.
+    scratch_filled_ = false;
+    // `num_values` is the page's level count, which includes nulls, while a PFOR
+    // page stores only the non-null values. Its own header is the authority on
+    // how many, so take the count from there.
+    if (len > 0) {
+      PARQUET_ASSIGN_OR_THROW(total_values_,
+                              ::arrow::util::pfor::PforWrapper<T>::DecodeElementCount(
+                                  this->data_, this->len_));
+      if (total_values_ > num_values) {
+        throw ParquetException("PFOR page declares " + std::to_string(total_values_) +
+                               " values but the page header allows at most " +
+                               std::to_string(num_values));
+      }
+    } else {
+      total_values_ = 0;
+    }
+    this->num_values_ = total_values_;
+  }
+
+  int Decode(T* buffer, int max_values) override {
+    max_values = std::min(max_values, this->num_values_);
+    if (max_values == 0) return 0;
+
+    // The caller asked for the whole page and none of it has been served yet, so
+    // decode straight into its buffer -- no page-sized scratch and no copy. This
+    // is the path a full column read takes.
+    if (CanDecodeWholePage(max_values)) {
+      PARQUET_THROW_NOT_OK(::arrow::util::pfor::PforWrapper<T>::Decode(
+          this->data_, this->len_, total_values_, buffer));
+    } else {
+      std::memcpy(buffer, NextDecoded(), static_cast<size_t>(max_values) * sizeof(T));
+    }
+    this->num_values_ -= max_values;
+    return max_values;
+  }
+
+  // `num_values` counts output slots; only the non-null ones are backed by
+  // encoded values, so decode that many and spread them over the valid runs.
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<DType>::Accumulator* builder) override {
+    const int values_to_decode = num_values - null_count;
+    if (ARROW_PREDICT_FALSE(this->num_values_ < values_to_decode)) {
+      ParquetException::EofException(
+          "PFOR DecodeArrow: not enough values available. "
+          "Available: " +
+          std::to_string(this->num_values_) +
+          ", requested: " + std::to_string(values_to_decode));
+    }
+
+    PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+
+    // 1. Land the values in the builder's storage packed to the right, so step 2
+    //    can expand them in place into their final positions. An all-null run
+    //    asks for no values, and a page carrying none has nothing to decode.
+    if (values_to_decode > 0) {
+      T* decode_out = builder->GetMutableValue(builder->length() + null_count);
+      if (CanDecodeWholePage(values_to_decode)) {
+        PARQUET_THROW_NOT_OK(::arrow::util::pfor::PforWrapper<T>::Decode(
+            this->data_, this->len_, total_values_, decode_out));
+      } else {
+        std::memcpy(decode_out, NextDecoded(),
+                    static_cast<size_t>(values_to_decode) * sizeof(T));
+      }
+    }
+
+    // 2. Expand the values into their final positions.
+    if (null_count == 0) {
+      builder->UnsafeAdvance(num_values);
+    } else {
+      ::arrow::util::internal::SpacedExpandLeftward(
+          reinterpret_cast<uint8_t*>(builder->GetMutableValue(builder->length())),
+          static_cast<int>(sizeof(T)), num_values, null_count, valid_bits,
+          valid_bits_offset);
+      builder->UnsafeAdvance(num_values, valid_bits, valid_bits_offset);
+    }
+    this->num_values_ -= values_to_decode;
+    return values_to_decode;
+  }
+
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<DType>::DictAccumulator* out) override {
+    const int values_decoded = num_values - null_count;
+    std::vector<T> values(values_decoded);
+    if (Decode(values.data(), values_decoded) != values_decoded) {
+      ParquetException::EofException();
+    }
+
+    const T* data = values.data();
+    PARQUET_THROW_NOT_OK(out->Reserve(num_values));
+    VisitNullBitmapInline(
+        valid_bits, valid_bits_offset, num_values, null_count,
+        [&]() { PARQUET_THROW_NOT_OK(out->Append(*data++)); },
+        [&]() { PARQUET_THROW_NOT_OK(out->AppendNull()); });
+    return values_decoded;
+  }
+
+ private:
+  /// \brief Whether `count` values can be decoded straight to the caller
+  ///
+  /// PforWrapper::Decode only decodes a page from its start, so this holds when
+  /// the caller wants the whole page and nothing has been served from it yet.
+  bool CanDecodeWholePage(int count) const {
+    return !scratch_filled_ && count == total_values_;
+  }
+
+  /// \brief Pointer to the next undelivered value, decoding the page if needed
+  const T* NextDecoded() {
+    if (!scratch_filled_) {
+      PARQUET_THROW_NOT_OK(
+          decoded_values_->Resize(static_cast<int64_t>(total_values_) * sizeof(T),
+                                  /*shrink_to_fit=*/false));
+      PARQUET_THROW_NOT_OK(::arrow::util::pfor::PforWrapper<T>::Decode(
+          this->data_, this->len_, total_values_, decoded_values_->mutable_data_as<T>()));
+      scratch_filled_ = true;
+    }
+    return decoded_values_->data_as<T>() + (total_values_ - this->num_values_);
+  }
+
+  MemoryPool* pool_;
+  /// Values the page's PFOR header declares. The inherited `num_values_` counts
+  /// down from this as values are served and is the only record of progress, so
+  /// the next value sits at index `total_values_ - num_values_`.
+  int32_t total_values_ = 0;
+  // Whole-page scratch, used only by partial reads. Pool-backed so the
+  // allocation is accounted for like the other decoders' scratch space.
+  std::shared_ptr<ResizableBuffer> decoded_values_;
+  bool scratch_filled_ = false;
+};
+
 }  // namespace
 
 // ----------------------------------------------------------------------
@@ -2448,6 +2616,15 @@ 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 {
     ParquetException::NYI("Selected encoding is not supported");
   }
@@ -2491,8 +2668,8 @@ std::vector<Encoding::type> SupportedEncodings(Type::type physical_type) {
       return {Encoding::PLAIN, Encoding::RLE};
     case Type::INT32:
     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..414e127c2299 100644
--- a/cpp/src/parquet/encoder.cc
+++ b/cpp/src/parquet/encoder.cc
@@ -40,6 +40,7 @@
 #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 +48,7 @@
 
 #include "parquet/exception.h"
 #include "parquet/platform.h"
+#include "parquet/properties.h"
 #include "parquet/schema.h"
 #include "parquet/types.h"
 
@@ -1763,12 +1765,115 @@ 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_;
+};
+
 // ----------------------------------------------------------------------
 // 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 +1967,22 @@ 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 is a per-column option, so it is 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.
+    ::arrow::util::pfor::PforEncodeOptions options;
+    if (properties != nullptr && descr != nullptr) {
+      options.delta_enabled = properties->pfor_delta_enabled(descr->path());
+    }
+    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 {
     ParquetException::NYI("Selected encoding is not supported");
   }
diff --git a/cpp/src/parquet/encoding.h b/cpp/src/parquet/encoding.h
index e3de4f2aa60b..cdfff30c2f33 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,27 @@ 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.
 PARQUET_EXPORT
 std::unique_ptr<Encoder> MakeEncoder(
     Type::type type_num, Encoding::type encoding, bool use_dictionary = false,
     const ColumnDescriptor* descr = NULLPTR,
-    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
+    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
+    const WriterProperties* properties = NULLPTR);
 
 template <typename DType>
 std::unique_ptr<typename EncodingTraits<DType>::Encoder> MakeTypedEncoder(
     Encoding::type encoding, bool use_dictionary = false,
     const ColumnDescriptor* descr = NULLPTR,
-    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool()) {
+    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
+    const WriterProperties* properties = NULLPTR) {
   using OutType = typename EncodingTraits<DType>::Encoder;
   std::unique_ptr<Encoder> base =
-      MakeEncoder(DType::type_num, encoding, use_dictionary, descr, pool);
+      MakeEncoder(DType::type_num, encoding, use_dictionary, descr, pool, properties);
   return std::unique_ptr<OutType>(dynamic_cast<OutType*>(base.release()));
 }
 
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index 831829e4a210..12a5d3f3fb48 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -1044,6 +1044,71 @@ class EncodingAdHocTyped : public ::testing::Test {
     ::arrow::AssertArraysEqual(*values, *result);
   }
 
+  void Pfor(int seed) {
+    if (!std::is_same<ParquetType, Int32Type>::value &&
+        !std::is_same<ParquetType, Int64Type>::value) {
+      return;
+    }
+    auto values = GetValues(seed);
+    auto encoder =
+        MakeTypedEncoder<ParquetType>(Encoding::PFOR,
+                                      /*use_dictionary=*/false, column_descr());
+    auto decoder = MakeTypedDecoder<ParquetType>(Encoding::PFOR, column_descr());
+
+    ASSERT_NO_THROW(encoder->Put(*values));
+    auto buf = encoder->FlushValues();
+
+    int num_values = static_cast<int>(values->length() - values->null_count());
+    decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
+
+    BuilderType acc(arrow_type(), ::arrow::default_memory_pool());
+    ASSERT_EQ(num_values,
+              decoder->DecodeArrow(static_cast<int>(values->length()),
+                                   static_cast<int>(values->null_count()),
+                                   values->null_bitmap_data(), values->offset(), &acc));
+
+    std::shared_ptr<::arrow::Array> result;
+    ASSERT_OK(acc.Finish(&result));
+    ASSERT_OK(result->ValidateFull());
+    ASSERT_EQ(size_, result->length());
+    ::arrow::AssertArraysEqual(*values, *result, /*verbose=*/true);
+  }
+
+  void PforDict(int seed) {
+    if constexpr (!std::is_same_v<ParquetType, Int32Type> &&
+                  !std::is_same_v<ParquetType, Int64Type>) {
+      return;
+    } else {
+      auto values = GetValues(seed);
+      auto encoder =
+          MakeTypedEncoder<ParquetType>(Encoding::PFOR,
+                                        /*use_dictionary=*/false, column_descr());
+      auto decoder = MakeTypedDecoder<ParquetType>(Encoding::PFOR, column_descr());
+
+      ASSERT_NO_THROW(encoder->Put(*values));
+      auto buf = encoder->FlushValues();
+
+      int num_values = static_cast<int>(values->length() - values->null_count());
+      decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
+
+      DictBuilderType acc(arrow_type(), ::arrow::default_memory_pool());
+      ASSERT_EQ(num_values,
+                decoder->DecodeArrow(static_cast<int>(values->length()),
+                                     static_cast<int>(values->null_count()),
+                                     values->null_bitmap_data(), values->offset(), &acc));
+
+      std::shared_ptr<::arrow::Array> result;
+      ASSERT_OK(acc.Finish(&result));
+      ASSERT_OK(result->ValidateFull());
+      ASSERT_EQ(size_, result->length());
+
+      // The accumulator produced a DictionaryArray; compare it densely.
+      ASSERT_OK_AND_ASSIGN(auto dense_datum,
+                           ::arrow::compute::Cast(::arrow::Datum(result), arrow_type()));
+      ::arrow::AssertArraysEqual(*values, *dense_datum.make_array(), /*verbose=*/true);
+    }
+  }
+
   void Dict(int seed) {
     if (std::is_same<ParquetType, BooleanType>::value) {
       return;
@@ -1228,6 +1293,27 @@ TYPED_TEST(EncodingAdHocTyped, DeltaBitPackArrowDirectPut) {
   }
 }
 
+TYPED_TEST(EncodingAdHocTyped, PforArrowDirectPut) {
+  for (auto seed : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) {
+    this->Pfor(seed);
+  }
+  // Same, but without nulls (this could trigger different code paths)
+  this->null_probability_ = 0.0;
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->Pfor(seed);
+  }
+}
+
+TYPED_TEST(EncodingAdHocTyped, PforArrowDirectPutDictBuilder) {
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->PforDict(seed);
+  }
+  this->null_probability_ = 0.0;
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->PforDict(seed);
+  }
+}
+
 TYPED_TEST(EncodingAdHocTyped, DictArrowDirectPut) { this->Dict(0); }
 
 TYPED_TEST(EncodingAdHocTyped, DictArrowDirectPutIndices) { this->DictPutIndices(); }
@@ -2034,6 +2120,114 @@ TYPED_TEST(TestDeltaBitPackEncoding, ZeroDeltaBitWidth) {
   this->CheckRoundtripWithValues(int_values);
 }
 
+// ----------------------------------------------------------------------
+// PFOR encode/decode tests.
+
+template <typename Type>
+class TestPforEncoding : public TestEncodingBase<Type> {
+ public:
+  using c_type = typename Type::c_type;
+  static constexpr int TYPE = Type::type_num;
+
+  void CheckDecoding(int read_batch_size) {
+    auto decoder = MakeTypedDecoder<Type>(Encoding::PFOR, descr_.get());
+    decoder->SetData(num_values_, encode_buffer_->data(),
+                     static_cast<int>(encode_buffer_->size()));
+
+    std::vector<c_type> decoded(num_values_);
+    int values_decoded = 0;
+    while (values_decoded < num_values_) {
+      const int decoded_now =
+          decoder->Decode(decoded.data() + values_decoded, read_batch_size);
+      ASSERT_GT(decoded_now, 0);
+      values_decoded += decoded_now;
+    }
+    ASSERT_EQ(num_values_, values_decoded);
+    ASSERT_NO_FATAL_FAILURE(VerifyResults<c_type>(decoded.data(), draws_, num_values_));
+  }
+
+  void CheckRoundtrip() override {
+    auto encoder = MakeTypedEncoder<Type>(Encoding::PFOR,
+                                          /*use_dictionary=*/false, descr_.get());
+    encoder->Put(draws_, num_values_);
+    encode_buffer_ = encoder->FlushValues();
+
+    // A reader asks for whatever its batch size is, so the page has to come out
+    // the same whether it is drained in one call or in many.
+    for (const int read_batch_size : {1, 11, num_values_}) {
+      if (read_batch_size > 0) {
+        ASSERT_NO_FATAL_FAILURE(CheckDecoding(read_batch_size));
+      }
+    }
+  }
+
+ protected:
+  USING_BASE_MEMBERS();
+};
+
+using TestPforEncodingTypes = ::testing::Types<Int32Type, Int64Type>;
+TYPED_TEST_SUITE(TestPforEncoding, TestPforEncodingTypes);
+
+TYPED_TEST(TestPforEncoding, BasicRoundTrip) {
+  // The default vector size is 1024, so cover an empty page, a single value, a
+  // partial vector, an exact multiple, and a partial trailing vector.
+  ASSERT_NO_FATAL_FAILURE(this->Execute(0, 0));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(100, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1024, 4));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1025, 3));
+}
+
+TYPED_TEST(TestPforEncoding, DecoderReusedAcrossPages) {
+  using c_type = typename TypeParam::c_type;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::PFOR,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::PFOR, this->descr_.get());
+
+  // A column chunk reuses one decoder for all of its data pages, with only
+  // SetData between them. The second page is the longer one, so a decoder that
+  // kept the first page's values would also read past the end of them.
+  const std::vector<std::vector<c_type>> pages = {
+      {10, 11, 12, 13}, {900, 901, 902, 903, 904, 905, 906, 907}};
+
+  for (const auto& page : pages) {
+    const int page_values = static_cast<int>(page.size());
+    encoder->Put(page.data(), page_values);
+    auto buffer = encoder->FlushValues();
+    decoder->SetData(page_values, buffer->data(), static_cast<int>(buffer->size()));
+
+    std::vector<c_type> decoded(page.size());
+    ASSERT_EQ(page_values, decoder->Decode(decoded.data(), page_values));
+    ASSERT_EQ(page, decoded);
+  }
+}
+
+TYPED_TEST(TestPforEncoding, AllNullPage) {
+  constexpr int kNumValues = 40;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::PFOR,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto buffer = encoder->FlushValues();
+
+  // A reader hands the decoder the page's level count, which counts the nulls, so
+  // the page and its bare header have to survive being handed the full count.
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::PFOR, this->descr_.get());
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+
+  // All slots are null, so the page carries no encoded values at all.
+  std::vector<uint8_t> valid_bits(bit_util::BytesForBits(kNumValues), 0);
+  typename EncodingTraits<TypeParam>::Accumulator acc;
+  ASSERT_EQ(0, decoder->DecodeArrow(kNumValues, /*null_count=*/kNumValues,
+                                    valid_bits.data(), /*valid_bits_offset=*/0, &acc));
+
+  std::shared_ptr<::arrow::Array> result;
+  ASSERT_OK(acc.Finish(&result));
+  ASSERT_OK(result->ValidateFull());
+  ASSERT_EQ(kNumValues, result->length());
+  ASSERT_EQ(kNumValues, result->null_count());
+}
+
 // ----------------------------------------------------------------------
 // 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..dd0511a03d33
--- /dev/null
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -0,0 +1,1228 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Comparison benchmark: PFOR vs DeltaBitPack vs ZSTD vs RleBitPackHybrid
+//                       vs ByteStreamSplit+ZSTD vs ByteStreamSplit+LZ4
+//
+// All throughput is reported as uncompressed_size / time (MB/s).
+// Data generators mimic ClickBench and TPC-DS column distributions. A second
+// group covers columns with structure between neighbouring values, or with a
+// cluster the minimum is not part of; those are the ones on which PFOR's delta
+// mode and DELTA_BINARY_PACKED make different choices.
+
+#include <algorithm>
+#include <bit>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <numeric>
+#include <random>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+
+#include "arrow/util/compression.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+#include "arrow/util/rle_encoding_internal.h"
+
+#include "parquet/encoding.h"
+#include "parquet/platform.h"
+#include "parquet/schema.h"
+#include "parquet/types.h"
+
+using ::arrow::Compression;
+using ::arrow::util::Codec;
+
+namespace parquet {
+namespace {
+
+// ============================================================================
+// Data Generators — ClickBench-inspired
+// ============================================================================
+
+// Generator pointer type, parameterized on the column value type.
+template <typename T>
+using GenT = std::vector<T> (*)(int64_t);
+using Gen32 = GenT<int32_t>;
+using Gen64 = GenT<int64_t>;
+
+// Map the C++ value type to its Parquet physical type + descriptor type.
+template <typename T>
+struct PqTraits;
+template <>
+struct PqTraits<int32_t> {
+  using PType = Int32Type;
+  static constexpr Type::type kPhysicalType = Type::INT32;
+};
+template <>
+struct PqTraits<int64_t> {
+  using PType = Int64Type;
+  static constexpr Type::type kPhysicalType = Type::INT64;
+};
+
+std::vector<int32_t> GenClientIP(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(101);
+  std::uniform_int_distribution<uint32_t> dist(0x0A000000, 0xDFFFFFFF);
+  for (auto& x : v) x = static_cast<int32_t>(dist(rng));
+  return v;
+}
+
+std::vector<int32_t> GenUrlRegionID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(102);
+  // Zipf-like over ~1000 values
+  std::uniform_real_distribution<double> uni(0.0, 1.0);
+  for (auto& x : v) {
+    double u = uni(rng);
+    x = static_cast<int32_t>(std::pow(u, 2.0) * 1000) + 1;
+  }
+  return v;
+}
+
+std::vector<int32_t> GenCounterID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(103);
+  std::uniform_int_distribution<int32_t> jitter(0, 3);
+  int32_t counter = 100000;
+  for (auto& x : v) {
+    counter += 1 + jitter(rng);
+    x = counter;
+  }
+  return v;
+}
+
+std::vector<int32_t> GenEventDate(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(104);
+  const int32_t dates[] = {19691, 19692, 19693, 19694, 19695};
+  std::uniform_int_distribution<int> idx(0, 4);
+  for (auto& x : v) x = dates[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenEventTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(105);
+  const int32_t base = 1704067200;  // 2024-01-01
+  std::uniform_int_distribution<int32_t> offset(0, 86399);
+  for (auto& x : v) x = base + offset(rng);
+  return v;
+}
+
+std::vector<int32_t> GenGoodEvent(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(106);
+  std::uniform_int_distribution<int> dist(0, 99);
+  for (auto& x : v) x = (dist(rng) < 95) ? 1 : 0;
+  return v;
+}
+
+std::vector<int32_t> GenHID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(107);
+  std::uniform_int_distribution<int32_t> dist(std::numeric_limits<int32_t>::min(),
+                                              std::numeric_limits<int32_t>::max());
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenHitColor(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(108);
+  const int32_t colors[] = {1, 2, 3, 4, 5};
+  std::uniform_int_distribution<int> idx(0, 4);
+  for (auto& x : v) x = colors[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenIPNetworkID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(109);
+  std::uniform_int_distribution<int32_t> dist(1, 10000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenJavaEnable(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(110);
+  std::uniform_int_distribution<int> dist(0, 99);
+  for (auto& x : v) x = (dist(rng) < 85) ? 1 : 0;
+  return v;
+}
+
+std::vector<int32_t> GenOS(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(111);
+  std::uniform_int_distribution<int32_t> dist(1, 20);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenResolution(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(112);
+  const int32_t resolutions[] = {360,  480,  600,  720,  768,  800,  900,
+                                 1024, 1050, 1080, 1200, 1440, 1600, 2160};
+  std::uniform_int_distribution<int> idx(0, 13);
+  for (auto& x : v) x = resolutions[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenTrafficSourceID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(113);
+  std::uniform_int_distribution<int32_t> dist(0, 10);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenUserAgent(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(114);
+  // Zipf-like over ~100 user agents
+  std::uniform_real_distribution<double> uni(0.0, 1.0);
+  for (auto& x : v) {
+    double u = uni(rng);
+    x = static_cast<int32_t>(std::pow(u, 1.5) * 100) + 1;
+  }
+  return v;
+}
+
+// ============================================================================
+// Data Generators — TPC-DS (4 most queried columns from store_sales)
+// ============================================================================
+
+std::vector<int32_t> GenTpcdsSoldDateSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 2450815;
+  std::mt19937 rng(201);
+  std::uniform_int_distribution<int32_t> dist(0, 1820);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsStoreSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(202);
+  std::uniform_int_distribution<int32_t> dist(1, 1000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsItemSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMax = 100000;
+  std::mt19937 rng(203);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    int32_t val = static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val + 1, kMax);
+  }
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsQuantity(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(204);
+  std::uniform_int_distribution<int32_t> small_dist(1, 10);
+  std::uniform_int_distribution<int32_t> large_dist(11, 100);
+  std::uniform_int_distribution<int> chance(0, 99);
+  for (auto& x : v) {
+    x = (chance(rng) < 90) ? small_dist(rng) : large_dist(rng);
+  }
+  return v;
+}
+
+// --- TPC-H (lineitem) top-queried numeric columns (Q1/Q3/Q5/Q6) ------------
+// l_quantity: integer [1, 50], uniform. Small range, min 1.
+std::vector<int32_t> GenTpchLQuantity(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(301);
+  std::uniform_int_distribution<int32_t> dist(1, 50);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// l_extendedprice (cents): l_quantity * p_retailprice. p_retailprice spans
+// ~$900.00..$2099.00, so cents in [90000, 10495000]. Wide range, nonzero min.
+std::vector<int32_t> GenTpchLExtendedPrice(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(302);
+  std::uniform_int_distribution<int32_t> qty(1, 50);
+  std::uniform_int_distribution<int32_t> retail_cents(90000, 209900);
+  for (auto& x : v) x = qty(rng) * retail_cents(rng);
+  return v;
+}
+
+// l_discount (x100): integer [0, 10] i.e. 0.00..0.10. Genuinely includes 0
+// (0% discount is a real value), so this one legitimately starts at 0.
+std::vector<int32_t> GenTpchLDiscount(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(303);
+  std::uniform_int_distribution<int32_t> dist(0, 10);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// l_shipdate (days since 1970-01-01): 1992-01-01..1998-12 span. Base 8036,
+// range ~7 years. Large nonzero min -> exercises frame-of-reference.
+std::vector<int32_t> GenTpchLShipDate(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 8036;  // days since epoch for 1992-01-01
+  std::mt19937 rng(304);
+  std::uniform_int_distribution<int32_t> dist(0, 2557);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+// --- TPC-DS (store_sales / date_dim) further top-queried numeric columns ---
+// ss_customer_sk: surrogate key, uniform [1, 2,000,000]. Big range, min 1.
+std::vector<int32_t> GenTpcdsCustomerSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(311);
+  std::uniform_int_distribution<int32_t> dist(1, 2000000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// ss_ext_sales_price (cents): skewed price, exponential mean ~$50, floored at
+// $1.00 (a sale has a nonzero price), capped at $20,000. Long tail -> patches.
+std::vector<int32_t> GenTpcdsExtSalesPrice(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMin = 100, kMax = 2000000;
+  std::mt19937 rng(312);
+  std::exponential_distribution<double> exp_dist(1.0 / 5000.0);
+  for (auto& x : v) {
+    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ss_net_profit (cents): usually a small profit, sometimes a loss -> negative
+// values, so the frame of reference is negative (not zero).
+std::vector<int32_t> GenTpcdsNetProfit(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(313);
+  std::uniform_int_distribution<int32_t> dist(-10000, 300000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// d_year: queried date_dim year range [1998, 2003]. Low cardinality, min 1998.
+std::vector<int32_t> GenTpcdsDYear(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(314);
+  std::uniform_int_distribution<int32_t> dist(1998, 2003);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// --- NYC yellow-taxi trip numeric columns ----------------------------------
+// pickup timestamp (unix seconds): 2015-01, base 1,420,070,400 + ~31 days.
+// Very large min -> frame-of-reference is essential.
+std::vector<int32_t> GenTaxiPickupUnixTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 1420070400;  // 2015-01-01 UTC
+  std::mt19937 rng(321);
+  std::uniform_int_distribution<int32_t> dist(0, 2678400);  // ~31 days
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+// trip_distance (x100 miles): exponential mean ~1.8 mi, floored at 0.10 mi
+// (no zero-distance trips), capped at 100 mi. Long tail -> patches.
+std::vector<int32_t> GenTaxiTripDistanceX100(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMin = 10, kMax = 10000;
+  std::mt19937 rng(322);
+  std::exponential_distribution<double> exp_dist(1.0 / 180.0);
+  for (auto& x : v) {
+    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// fare_amount (cents): $2.50 base + exponential mean ~$10, capped at $150.
+// Nonzero floor at the base fare, skewed with a long tail.
+std::vector<int32_t> GenTaxiFareCents(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 250, kMax = 15000;
+  std::mt19937 rng(323);
+  std::exponential_distribution<double> exp_dist(1.0 / 1000.0);
+  for (auto& x : v) {
+    int32_t val = kBase + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ============================================================================
+// Data Generators — int64 / BIGINT columns (values that require 8 bytes,
+// i.e. exceed the int32 range). Covers the common 64-bit analytic cases:
+// nanosecond timestamps, large surrogate keys, scaled-decimal money, monotone
+// IDs, and wide counters.
+// ============================================================================
+
+// Nanosecond epoch timestamp (Parquet TIMESTAMP(NANOS)): 2024-01-01 base plus
+// up to ~1 day of jitter. Min ~1.70e18 -> very large frame of reference; raw
+// values need ~61 bits.
+std::vector<int64_t> GenTsNanos(int64_t n) {
+  std::vector<int64_t> v(n);
+  const int64_t kBase = 1704067200000000000LL;  // 2024-01-01T00:00:00Z in ns
+  std::mt19937_64 rng(401);
+  std::uniform_int_distribution<int64_t> off(0, 86399999999999LL);  // ~1 day
+  for (auto& x : v) x = kBase + off(rng);
+  return v;
+}
+
+// BIGINT surrogate / order key, uniform over [1, 10 billion] (exceeds 2^32).
+std::vector<int64_t> GenOrderKey(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(402);
+  std::uniform_int_distribution<int64_t> dist(1, 10000000000LL);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// Money as int64 scaled decimal (micro-units): $0.01 .. ~$100k, skewed, with a
+// nonzero floor at one cent.
+std::vector<int64_t> GenPriceMicros(int64_t n) {
+  std::vector<int64_t> v(n);
+  const int64_t kMin = 10000, kMax = 100000000000LL;  // $0.01 .. $100,000
+  std::mt19937_64 rng(403);
+  std::exponential_distribution<double> exp_dist(1.0 / 5000000.0);  // mean ~$5
+  for (auto& x : v) {
+    int64_t val = kMin + static_cast<int64_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// Snowflake-style monotone ID: large base + jittered per-row increments.
+// Monotone -> ideal for DELTA_BINARY_PACKED; huge min -> ideal for PFOR's FOR.
+std::vector<int64_t> GenSnowflakeId(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(404);
+  std::uniform_int_distribution<int64_t> step(1, 4096);
+  int64_t id = 1500000000000000000LL;
+  for (auto& x : v) {
+    id += step(rng);
+    x = id;
+  }
+  return v;
+}
+
+// Wide cumulative byte counts, uniform [1024, 5 trillion] (wide 64-bit range).
+std::vector<int64_t> GenByteCount(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(405);
+  std::uniform_int_distribution<int64_t> dist(1024, 5000000000000LL);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// ============================================================================
+// Data Generators — structure between neighbouring values
+// ============================================================================
+
+// The generators above are all either unordered or perfectly regular, so none
+// of them separates an encoding that differences neighbouring values from one
+// that packs them, and none of them puts a frame of reference anywhere but the
+// minimum. These do. They are the columns on which PFOR's delta mode and
+// DELTA_BINARY_PACKED make different choices, so they are what this file needs
+// in order to compare the two.
+//
+// Unlike the generators above, these are templates rather than a pair of
+// per-width functions: it keeps the int32 and int64 arms of every REGISTER
+// below on provably the same distribution, which two hand-written copies would
+// not. They live in their own namespace because two of them build on base
+// distributions whose names are already taken in this file by columns drawn
+// from different seeds -- keeping them separate is what makes these figures
+// comparable with pfor_benchmark.cc, which uses the same shapes.
+namespace delta_shapes {
+
+template <typename T>
+std::vector<T> GenSmallRange(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(100000, 200000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsItemSk(int64_t n) {
+  std::vector<T> v(n);
+  const T kMax = 100000;
+  std::mt19937_64 rng(12345);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    T val = static_cast<T>(exp_dist(rng));
+    x = std::min(static_cast<T>(val + 1), kMax);
+  }
+  return v;
+}
+
+/// A timestamp column with a fixed sampling interval and jitter: the
+/// differences cluster tightly around the interval, the values do not.
+template <typename T>
+std::vector<T> GenTrendJitter(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(7);
+  std::normal_distribution<double> jitter(0.0, 40.0);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += 3.0;
+    x = static_cast<T>(t + jitter(rng));
+  }
+  return v;
+}
+
+/// A TCP congestion window: a linear climb cut by a sharp halving. Almost
+/// every difference is the same small number and a few are large and
+/// negative, which is the shape a two-sided frame plus patching handles at
+/// close to no cost and a one-sided one cannot.
+template <typename T>
+std::vector<T> GenSawtooth(int64_t n) {
+  std::vector<T> v(n);
+  T cur = 1000;
+  for (int64_t i = 0; i < n; ++i) {
+    if (i % 200 == 199) {
+      cur /= 2;
+    } else {
+      cur += 12;
+    }
+    v[i] = cur;
+  }
+  return v;
+}
+
+/// A continuous quantity sampled over time, so the rate of change is bounded
+/// but the level wanders: differencing wins, though not by much.
+template <typename T>
+std::vector<T> GenMeasurement(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(11);
+  std::normal_distribution<double> noise(0.0, 1.0);
+  double level = 0.0;
+  double rate = 0.0;
+  for (int64_t i = 0; i < n; ++i) {
+    rate = 0.95 * rate + noise(rng);
+    level += rate;
+    v[i] = static_cast<T>(4000.0 * level / 50.0) + static_cast<T>(500000);
+  }
+  return v;
+}
+
+/// A sorted surrogate key column, which is what a clustered index or a
+/// sorted-by-key file produces.
+template <typename T>
+std::vector<T> GenSortedKeys(int64_t n) {
+  auto v = GenTpcdsItemSk<T>(n);
+  std::sort(v.begin(), v.end());
+  return v;
+}
+
+/// A measurement series punctuated by a low sentinel standing in for "no
+/// reading". The sentinel sits far below the cluster, so a frame pinned to
+/// the minimum has to widen to reach it and no value can ever be patched.
+template <typename T>
+std::vector<T> GenSensorDropouts(int64_t n) {
+  auto v = GenMeasurement<T>(n);
+  std::mt19937_64 rng(3);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-999999);
+  }
+  return v;
+}
+
+/// Monotonic ids with occasional large jumps, as a sequence shared between
+/// writers or restarted produces.
+template <typename T>
+std::vector<T> GenIdsWithGaps(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(5);
+  std::uniform_int_distribution<int> step(1, 6);
+  std::uniform_int_distribution<int> jump(0, 199);
+  T cur = 1000000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    if (jump(rng) == 0) cur += 100000;
+    x = cur;
+  }
+  return v;
+}
+
+/// Prices on a random walk: small signed steps around a high base, and no
+/// trend for the differences to line up on.
+template <typename T>
+std::vector<T> GenRandomWalk(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(13);
+  std::uniform_int_distribution<int> step(-25, 25);
+  T cur = 1500000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    x = cur;
+  }
+  return v;
+}
+
+/// Event arrival times in milliseconds since the epoch, bursty, so the gaps
+/// are skewed rather than clustered.
+template <typename T>
+std::vector<T> GenEventMillis(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(17);
+  std::exponential_distribution<double> gap(0.4);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = static_cast<T>(t);
+  }
+  return v;
+}
+
+/// A tight unordered cluster with a low "missing" sentinel: the frame cannot
+/// sit at the minimum and differencing has nothing to exploit either, so
+/// this is the column that has to come out no worse than before.
+template <typename T>
+std::vector<T> GenLowSentinel(int64_t n) {
+  auto v = GenSmallRange<T>(n);
+  std::mt19937_64 rng(23);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-1000);
+  }
+  return v;
+}
+
+/// Two interleaved clusters far apart, so no single window covers the vector
+/// and the cheaper cluster is worth framing on its own.
+template <typename T>
+std::vector<T> GenBimodal(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(19);
+  std::uniform_int_distribution<T> lo(1000, 1100);
+  std::uniform_int_distribution<T> hi(900000, 900100);
+  std::uniform_int_distribution<int> pick(0, 9);
+  for (auto& x : v) {
+    x = pick(rng) < 8 ? lo(rng) : hi(rng);
+  }
+  return v;
+}
+
+}  // namespace delta_shapes
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+template <typename T>
+static int32_t ComputeBitWidth(const std::vector<T>& values) {
+  using U = std::make_unsigned_t<T>;
+  U max_val = 0;
+  for (T v : values) {
+    max_val = std::max(max_val, static_cast<U>(v));
+  }
+  if (max_val == 0) return 1;
+  if constexpr (sizeof(T) == 8) {
+    return static_cast<int32_t>(std::bit_width(static_cast<uint64_t>(max_val)));
+  } else {
+    return static_cast<int32_t>(std::bit_width(static_cast<uint32_t>(max_val)));
+  }
+}
+
+template <typename T>
+static std::shared_ptr<ColumnDescriptor> MakeDescriptor() {
+  auto node = schema::PrimitiveNode::Make("col", Repetition::REQUIRED,
+                                          PqTraits<T>::kPhysicalType);
+  return std::make_shared<ColumnDescriptor>(node, /*max_def_level=*/0,
+                                            /*max_rep_level=*/0);
+}
+
+// ============================================================================
+// PFOR Encode/Decode
+// ============================================================================
+
+template <typename T>
+static void PforEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int64_t max_size = ::arrow::util::pfor::PforWrapper<T>::GetMaxCompressedSize(
+                         static_cast<int32_t>(num_values))
+                         .ValueOrDie();
+  std::vector<uint8_t> compressed(max_size);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size = max_size;
+  ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
+      values.data(), static_cast<int32_t>(num_values), compressed.data(), &comp_size));
+
+  for (auto _ : state) {
+    int64_t sz = max_size;
+    ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
+        values.data(), static_cast<int32_t>(num_values), compressed.data(), &sz));
+    benchmark::DoNotOptimize(sz);
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_PforEncode(benchmark::State& state, Gen32 gen) {
+  PforEncodeImpl<int32_t>(state, gen);
+}
+static void BM_Pfor64Encode(benchmark::State& state, Gen64 gen) {
+  PforEncodeImpl<int64_t>(state, gen);
+}
+
+template <typename T>
+static void PforDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  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));
+
+  std::vector<T> decoded(num_values);
+  for (auto _ : state) {
+    auto status = ::arrow::util::pfor::PforWrapper<T>::Decode(
+        compressed.data(), comp_size, static_cast<int32_t>(num_values), decoded.data());
+    ARROW_CHECK_OK(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_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);
+}
+
+// ============================================================================
+// 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();
+
+  std::vector<T> decoded(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.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);
+}
+static void BM_DeltaBitPackDecode(benchmark::State& state, Gen32 gen) {
+  DeltaBitPackDecodeImpl<int32_t>(state, gen);
+}
+static void BM_DeltaBitPack64Decode(benchmark::State& state, Gen64 gen) {
+  DeltaBitPackDecodeImpl<int64_t>(state, gen);
+}
+
+// ============================================================================
+// Plain + ZSTD Encode/Decode
+// ============================================================================
+
+template <typename T>
+static void PlainCodecEncodeImpl(benchmark::State& state, GenT<T> gen,
+                                 Compression::type codec_type) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+  const uint8_t* raw = reinterpret_cast<const uint8_t*>(values.data());
+
+  auto codec = *Codec::Create(codec_type);
+  int64_t max_comp = codec->MaxCompressedLen(uncompressed_size, raw);
+  std::vector<uint8_t> compressed(max_comp);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size =
+      *codec->Compress(uncompressed_size, raw, max_comp, compressed.data());
+
+  for (auto _ : state) {
+    auto sz = *codec->Compress(uncompressed_size, raw, max_comp, compressed.data());
+    benchmark::DoNotOptimize(sz);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+template <typename T>
+static void PlainCodecDecodeImpl(benchmark::State& state, GenT<T> gen,
+                                 Compression::type codec_type) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+  const uint8_t* raw = reinterpret_cast<const uint8_t*>(values.data());
+
+  auto codec = *Codec::Create(codec_type);
+  int64_t max_comp = codec->MaxCompressedLen(uncompressed_size, raw);
+  std::vector<uint8_t> compressed(max_comp);
+  int64_t comp_size =
+      *codec->Compress(uncompressed_size, raw, max_comp, compressed.data());
+
+  std::vector<uint8_t> decompressed(uncompressed_size);
+  for (auto _ : state) {
+    auto result = codec->Decompress(comp_size, compressed.data(), uncompressed_size,
+                                    decompressed.data());
+    ARROW_CHECK_OK(result.status());
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_PlainZstdEncode(benchmark::State& state, Gen32 gen) {
+  PlainCodecEncodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_PlainZstd64Encode(benchmark::State& state, Gen64 gen) {
+  PlainCodecEncodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+static void BM_PlainZstdDecode(benchmark::State& state, Gen32 gen) {
+  PlainCodecDecodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_PlainZstd64Decode(benchmark::State& state, Gen64 gen) {
+  PlainCodecDecodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+
+// ============================================================================
+// Plain + LZ4 Encode/Decode
+// ============================================================================
+
+static void BM_PlainLz4Encode(benchmark::State& state, Gen32 gen) {
+  PlainCodecEncodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_PlainLz464Encode(benchmark::State& state, Gen64 gen) {
+  PlainCodecEncodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_PlainLz4Decode(benchmark::State& state, Gen32 gen) {
+  PlainCodecDecodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_PlainLz464Decode(benchmark::State& state, Gen64 gen) {
+  PlainCodecDecodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+
+// ============================================================================
+// RleBitPackHybrid Encode/Decode
+// ============================================================================
+
+template <typename T>
+static void RleBitPackEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  using U = std::make_unsigned_t<T>;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int32_t bit_width = ComputeBitWidth<T>(values);
+  int64_t max_buf =
+      ::arrow::util::RleBitPackedEncoder::MaxBufferSize(bit_width, num_values) +
+      ::arrow::util::RleBitPackedEncoder::MinBufferSize(bit_width);
+  std::vector<uint8_t> buffer(max_buf);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size;
+  {
+    ::arrow::util::RleBitPackedEncoder enc(buffer.data(), static_cast<int>(max_buf),
+                                           bit_width);
+    for (int64_t i = 0; i < num_values; ++i) {
+      enc.Put(static_cast<uint64_t>(static_cast<U>(values[i])));
+    }
+    comp_size = enc.Flush();
+  }
+
+  for (auto _ : state) {
+    ::arrow::util::RleBitPackedEncoder encoder(buffer.data(), static_cast<int>(max_buf),
+                                               bit_width);
+    for (int64_t i = 0; i < num_values; ++i) {
+      encoder.Put(static_cast<uint64_t>(static_cast<U>(values[i])));
+    }
+    auto sz = encoder.Flush();
+    benchmark::DoNotOptimize(sz);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_RleBitPackEncode(benchmark::State& state, Gen32 gen) {
+  RleBitPackEncodeImpl<int32_t>(state, gen);
+}
+static void BM_RleBitPack64Encode(benchmark::State& state, Gen64 gen) {
+  RleBitPackEncodeImpl<int64_t>(state, gen);
+}
+
+template <typename T>
+static void RleBitPackDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  using U = std::make_unsigned_t<T>;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int32_t bit_width = ComputeBitWidth<T>(values);
+  int64_t max_buf =
+      ::arrow::util::RleBitPackedEncoder::MaxBufferSize(bit_width, num_values) +
+      ::arrow::util::RleBitPackedEncoder::MinBufferSize(bit_width);
+  std::vector<uint8_t> buffer(max_buf);
+
+  ::arrow::util::RleBitPackedEncoder encoder(buffer.data(), static_cast<int>(max_buf),
+                                             bit_width);
+  for (int64_t i = 0; i < num_values; ++i) {
+    encoder.Put(static_cast<uint64_t>(static_cast<U>(values[i])));
+  }
+  int comp_size = encoder.Flush();
+
+  std::vector<T> decoded(num_values);
+  for (auto _ : state) {
+    ::arrow::util::RleBitPackedParser parser(buffer.data(), comp_size, bit_width);
+    int64_t out_idx = 0;
+    struct Handler {
+      T* output;
+      int64_t* idx;
+      int64_t max_values;
+      int32_t bw;
+      ::arrow::util::RleBitPackedParser::ControlFlow OnRleRun(::arrow::util::RleRun run) {
+        ::arrow::util::RleRunDecoder<T> dec(run, bw);
+        auto want = static_cast<int32_t>(
+            std::min(static_cast<int64_t>(run.values_count()), max_values - *idx));
+        auto count = dec.GetBatch(output + *idx, want, bw);
+        *idx += count;
+        return *idx >= max_values
+                   ? ::arrow::util::RleBitPackedParser::ControlFlow::Break
+                   : ::arrow::util::RleBitPackedParser::ControlFlow::Continue;
+      }
+      ::arrow::util::RleBitPackedParser::ControlFlow OnBitPackedRun(
+          ::arrow::util::BitPackedRun run) {
+        ::arrow::util::BitPackedRunDecoder<T> dec(run, bw);
+        auto want = static_cast<int32_t>(
+            std::min(static_cast<int64_t>(dec.remaining()), max_values - *idx));
+        auto count = dec.GetBatch(output + *idx, want, bw);
+        *idx += count;
+        return *idx >= max_values
+                   ? ::arrow::util::RleBitPackedParser::ControlFlow::Break
+                   : ::arrow::util::RleBitPackedParser::ControlFlow::Continue;
+      }
+    };
+    Handler handler{decoded.data(), &out_idx, num_values, bit_width};
+    parser.Parse(handler);
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_RleBitPackDecode(benchmark::State& state, Gen32 gen) {
+  RleBitPackDecodeImpl<int32_t>(state, gen);
+}
+static void BM_RleBitPack64Decode(benchmark::State& state, Gen64 gen) {
+  RleBitPackDecodeImpl<int64_t>(state, gen);
+}
+
+// ============================================================================
+// ByteStreamSplit + Codec (ZSTD or LZ4)
+// ============================================================================
+
+template <typename T>
+static void BssCodecEncodeImpl(benchmark::State& state, GenT<T> gen,
+                               Compression::type codec_type) {
+  using PType = typename PqTraits<T>::PType;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto descr = MakeDescriptor<T>();
+  auto encoder = MakeTypedEncoder<PType>(Encoding::BYTE_STREAM_SPLIT,
+                                         /*use_dictionary=*/false, descr.get());
+  auto codec = *Codec::Create(codec_type);
+
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto encoded_buf = encoder->FlushValues();
+  int64_t encoded_size = encoded_buf->size();
+
+  int64_t max_comp = codec->MaxCompressedLen(encoded_size, encoded_buf->data());
+  std::vector<uint8_t> compressed(max_comp);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size =
+      *codec->Compress(encoded_size, encoded_buf->data(), max_comp, compressed.data());
+
+  for (auto _ : state) {
+    encoder->Put(values.data(), static_cast<int>(num_values));
+    auto buf = encoder->FlushValues();
+    auto sz = *codec->Compress(buf->size(), buf->data(), max_comp, compressed.data());
+    benchmark::DoNotOptimize(sz);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+template <typename T>
+static void BssCodecDecodeImpl(benchmark::State& state, GenT<T> gen,
+                               Compression::type codec_type) {
+  using PType = typename PqTraits<T>::PType;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto descr = MakeDescriptor<T>();
+  auto encoder = MakeTypedEncoder<PType>(Encoding::BYTE_STREAM_SPLIT,
+                                         /*use_dictionary=*/false, descr.get());
+  auto codec = *Codec::Create(codec_type);
+
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto encoded_buf = encoder->FlushValues();
+  int64_t encoded_size = encoded_buf->size();
+
+  int64_t max_comp = codec->MaxCompressedLen(encoded_size, encoded_buf->data());
+  std::vector<uint8_t> compressed(max_comp);
+  int64_t comp_size =
+      *codec->Compress(encoded_size, encoded_buf->data(), max_comp, compressed.data());
+
+  std::vector<uint8_t> decompressed(encoded_size);
+  std::vector<T> decoded(num_values);
+  auto decoder = MakeTypedDecoder<PType>(Encoding::BYTE_STREAM_SPLIT, descr.get());
+
+  for (auto _ : state) {
+    auto result = codec->Decompress(comp_size, compressed.data(), encoded_size,
+                                    decompressed.data());
+    ARROW_CHECK_OK(result.status());
+    decoder->SetData(static_cast<int>(num_values), decompressed.data(),
+                     static_cast<int>(encoded_size));
+    decoder->Decode(decoded.data(), static_cast<int>(num_values));
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+// Wrappers for BSS+ZSTD
+static void BM_BssZstdEncode(benchmark::State& state, Gen32 gen) {
+  BssCodecEncodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_BssZstd64Encode(benchmark::State& state, Gen64 gen) {
+  BssCodecEncodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+static void BM_BssZstdDecode(benchmark::State& state, Gen32 gen) {
+  BssCodecDecodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_BssZstd64Decode(benchmark::State& state, Gen64 gen) {
+  BssCodecDecodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+
+// Wrappers for BSS+LZ4
+static void BM_BssLz4Encode(benchmark::State& state, Gen32 gen) {
+  BssCodecEncodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_BssLz464Encode(benchmark::State& state, Gen64 gen) {
+  BssCodecEncodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_BssLz4Decode(benchmark::State& state, Gen32 gen) {
+  BssCodecDecodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_BssLz464Decode(benchmark::State& state, Gen64 gen) {
+  BssCodecDecodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+
+// ============================================================================
+// Benchmark Registration
+// ============================================================================
+
+static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
+
+// 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_DeltaBitPackEncode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_DeltaBitPackDecode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PlainZstdEncode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_PlainZstdDecode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_PlainLz4Encode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PlainLz4Decode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_RleBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_RleBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_BssZstdEncode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_BssZstdDecode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_BssLz4Encode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_BssLz4Decode, Name, &GenFunc)->Apply(CustomArgs);
+
+// Same as REGISTER_DATASET but for int64 (BIGINT) columns; benchmark names get
+// the "64" codec suffix (e.g. BM_Pfor64Encode) to distinguish them.
+#define REGISTER_DATASET64(Name, GenFunc)                                        \
+  BENCHMARK_CAPTURE(BM_Pfor64Encode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_Pfor64Decode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_DeltaBitPack64Encode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_DeltaBitPack64Decode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PlainZstd64Encode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_PlainZstd64Decode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_PlainLz464Encode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PlainLz464Decode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_RleBitPack64Encode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_RleBitPack64Decode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_BssZstd64Encode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_BssZstd64Decode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_BssLz464Encode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_BssLz464Decode, Name, &GenFunc)->Apply(CustomArgs);
+
+// ClickBench datasets
+REGISTER_DATASET(ClientIP, GenClientIP)
+REGISTER_DATASET(UrlRegionID, GenUrlRegionID)
+REGISTER_DATASET(CounterID, GenCounterID)
+REGISTER_DATASET(EventDate, GenEventDate)
+REGISTER_DATASET(EventTime, GenEventTime)
+REGISTER_DATASET(GoodEvent, GenGoodEvent)
+REGISTER_DATASET(HID, GenHID)
+REGISTER_DATASET(HitColor, GenHitColor)
+REGISTER_DATASET(IPNetworkID, GenIPNetworkID)
+REGISTER_DATASET(JavaEnable, GenJavaEnable)
+REGISTER_DATASET(OS, GenOS)
+REGISTER_DATASET(Resolution, GenResolution)
+REGISTER_DATASET(TrafficSourceID, GenTrafficSourceID)
+REGISTER_DATASET(UserAgent, GenUserAgent)
+
+// TPC-DS datasets
+REGISTER_DATASET(TpcdsSoldDateSk, GenTpcdsSoldDateSk)
+REGISTER_DATASET(TpcdsStoreSk, GenTpcdsStoreSk)
+REGISTER_DATASET(TpcdsItemSk, GenTpcdsItemSk)
+REGISTER_DATASET(TpcdsQuantity, GenTpcdsQuantity)
+REGISTER_DATASET(TpcdsCustomerSk, GenTpcdsCustomerSk)
+REGISTER_DATASET(TpcdsExtSalesPrice, GenTpcdsExtSalesPrice)
+REGISTER_DATASET(TpcdsNetProfit, GenTpcdsNetProfit)
+REGISTER_DATASET(TpcdsDYear, GenTpcdsDYear)
+// TPC-H datasets
+REGISTER_DATASET(TpchLQuantity, GenTpchLQuantity)
+REGISTER_DATASET(TpchLExtendedPrice, GenTpchLExtendedPrice)
+REGISTER_DATASET(TpchLDiscount, GenTpchLDiscount)
+REGISTER_DATASET(TpchLShipDate, GenTpchLShipDate)
+// NYC taxi datasets
+REGISTER_DATASET(TaxiPickupUnixTime, GenTaxiPickupUnixTime)
+REGISTER_DATASET(TaxiTripDistanceX100, GenTaxiTripDistanceX100)
+REGISTER_DATASET(TaxiFareCents, GenTaxiFareCents)
+// int64 / BIGINT datasets (8-byte signed values)
+REGISTER_DATASET64(TsNanos, GenTsNanos)
+REGISTER_DATASET64(OrderKey, GenOrderKey)
+REGISTER_DATASET64(PriceMicros, GenPriceMicros)
+REGISTER_DATASET64(SnowflakeId, GenSnowflakeId)
+REGISTER_DATASET64(ByteCount, GenByteCount)
+
+// Columns with structure between neighbouring values (see delta_shapes above),
+// registered at both widths from the same distribution.
+#define REGISTER_DELTA_SHAPE(Name, GenFunc) \
+  REGISTER_DATASET(Name, GenFunc<int32_t>)  \
+  REGISTER_DATASET64(Name, GenFunc<int64_t>)
+
+REGISTER_DELTA_SHAPE(TrendJitter, delta_shapes::GenTrendJitter)
+REGISTER_DELTA_SHAPE(Sawtooth, delta_shapes::GenSawtooth)
+REGISTER_DELTA_SHAPE(MeasurementSeries, delta_shapes::GenMeasurement)
+REGISTER_DELTA_SHAPE(SortedKeys, delta_shapes::GenSortedKeys)
+REGISTER_DELTA_SHAPE(SensorDropouts, delta_shapes::GenSensorDropouts)
+REGISTER_DELTA_SHAPE(IdsWithGaps, delta_shapes::GenIdsWithGaps)
+REGISTER_DELTA_SHAPE(RandomWalk, delta_shapes::GenRandomWalk)
+REGISTER_DELTA_SHAPE(EventMillis, delta_shapes::GenEventMillis)
+REGISTER_DELTA_SHAPE(LowSentinel, delta_shapes::GenLowSentinel)
+REGISTER_DELTA_SHAPE(Bimodal, delta_shapes::GenBimodal)
+
+}  // namespace
+}  // namespace parquet
diff --git a/cpp/src/parquet/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..76a9b4833c48 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_;
 };
 
@@ -853,6 +880,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 +1009,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,6 +1024,16 @@ 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_,
@@ -909,6 +1046,19 @@ class PARQUET_EXPORT WriterProperties {
    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_;
@@ -935,6 +1085,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_;
@@ -1046,6 +1198,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(),
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..1567d2b559e2 100644
--- a/cpp/src/parquet/types.cc
+++ b/cpp/src/parquet/types.cc
@@ -270,6 +270,8 @@ std::string EncodingToString(Encoding::type t) {
       return "RLE_DICTIONARY";
     case Encoding::BYTE_STREAM_SPLIT:
       return "BYTE_STREAM_SPLIT";
+    case Encoding::PFOR:
+      return "PFOR";
     default:
       return "UNKNOWN";
   }
diff --git a/cpp/src/parquet/types.h b/cpp/src/parquet/types.h
index 687353aa9bcb..acfedb45d795 100644
--- a/cpp/src/parquet/types.h
+++ b/cpp/src/parquet/types.h
@@ -539,8 +539,9 @@ struct Encoding {
     DELTA_BYTE_ARRAY = 7,
     RLE_DICTIONARY = 8,
     BYTE_STREAM_SPLIT = 9,
+    PFOR = 11,
     // Should always be last element (except UNKNOWN)
-    UNDEFINED = 10,
+    UNDEFINED = 12,
     UNKNOWN = 999
   };
 };