diff --git a/.github/workflows/add-to-project.yml b/.github/workflows/add-to-project.yml
index 939fa60434..5942e13266 100644
--- a/.github/workflows/add-to-project.yml
+++ b/.github/workflows/add-to-project.yml
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -28,7 +28,7 @@ jobs:
     name: Add new issues and pull requests to project
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/add-to-project@v0.4.0
+      - uses: actions/add-to-project@v0.6.1
         with:
           project-url: https://github.com/orgs/NVIDIA/projects/4
           github-token: ${{ secrets.PROJECT_TOKEN }}
diff --git a/.github/workflows/auto-merge.yml b/.github/workflows/auto-merge.yml
index 08ee4f34d8..c6de34764b 100755
--- a/.github/workflows/auto-merge.yml
+++ b/.github/workflows/auto-merge.yml
@@ -18,12 +18,12 @@ name: auto-merge HEAD to BASE
 on:
   pull_request_target:
     branches:
-      - branch-24.02
+      - branch-24.04
     types: [closed]
 
 env:
-  HEAD: branch-24.02
-  BASE: branch-24.04
+  HEAD: branch-24.04
+  BASE: branch-24.06
 
 jobs:
   auto-merge:
@@ -31,7 +31,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           ref: ${{ env.HEAD }} # force to fetch from latest upstream instead of PR ref
           token: ${{ secrets.AUTOMERGE_TOKEN }} # workaround auto-merge token to avoid GITHUB_TOKEN insufficient permission
@@ -42,13 +42,17 @@ jobs:
           git config user.email "70000568+nvauto@users.noreply.github.com "
           git fetch origin ${HEAD} ${BASE}
           git checkout -b ${INTERMEDIATE_HEAD} origin/${HEAD}
-          OUT=$(git --no-pager diff --name-only origin/${BASE} | grep "${FILE_USE_BASE}" || true)
-          [[ ! -z "${OUT}" ]] && git checkout origin/${BASE} -- ${FILE_USE_BASE} && \
-            git commit -s -am "Auto-merge use submodule in BASE ref"
+          # Sync the $BASE branch with the commits from the $HEAD branch,
+          # excluding the paths defined as $FILE_USE_BASE (located under ./thirdparty).
+          git checkout origin/${BASE} -- ${FILE_USE_BASE}
+          # If any submodule file is updated in the HEAD branch,
+          # always change it to the corresponding one from the BASE branch.
+          [ ! -z "$(git status --porcelain=v1 --untracked=no)" ] && \
+            git commit -s -am "Auto-merge use ${BASE} versions"
           git push origin ${INTERMEDIATE_HEAD} -f
         env:
           INTERMEDIATE_HEAD: bot-auto-merge-${{ env.HEAD }}
-          FILE_USE_BASE: thirdparty/cudf
+          FILE_USE_BASE: thirdparty/cudf thirdparty/cudf-pins
 
       - name: auto-merge job
         uses: ./.github/workflows/action-helper
diff --git a/.github/workflows/blossom-ci.yml b/.github/workflows/blossom-ci.yml
index 8aa90b9ee6..ece14b4201 100644
--- a/.github/workflows/blossom-ci.yml
+++ b/.github/workflows/blossom-ci.yml
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -55,7 +55,7 @@ jobs:
       wbo4958,\
       wjxiz1992,\
       sperlingxx,\
-      pxLi,\
+      YanxuanLiu,\
       hyperbolic2346,\
       gerashegalov,\
       ttnghia,\
@@ -65,6 +65,7 @@ jobs:
       NVnavkumar,\
       yinqingh,\
       thirtiseven,\
+      parthosa,\
       ', format('{0},', github.actor)) && github.event.comment.body == 'build'
     steps:
       - name: Check if comment is issued by authorized person
diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 2cb86b2865..267e6395e4 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -1,4 +1,4 @@
-# Copyright (c) 2023, NVIDIA CORPORATION.
+# Copyright (c) 2023-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -26,7 +26,7 @@ jobs:
     - uses: actions/checkout@v4
       with:
         submodules: true
-    - uses: actions/setup-python@v4
+    - uses: actions/setup-python@v5
       with:
         python-version: "3.10"
     - uses: pre-commit/action@v3.0.0
diff --git a/.github/workflows/signoff-check.yml b/.github/workflows/signoff-check.yml
index c2d1d6bf31..4a0eece7d1 100755
--- a/.github/workflows/signoff-check.yml
+++ b/.github/workflows/signoff-check.yml
@@ -1,4 +1,4 @@
-# Copyright (c) 2022, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -23,7 +23,7 @@ jobs:
   signoff-check:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: sigoff-check job
         uses: ./.github/workflows/signoff-check
diff --git a/.gitmodules b/.gitmodules
index 6b6f69d695..103a678946 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +1,4 @@
 [submodule "thirdparty/cudf"]
 	path = thirdparty/cudf
 	url = https://github.com/rapidsai/cudf.git
-	branch = branch-24.02
+	branch = branch-24.04
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5fb76d548e..60dd78e5d8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -160,7 +160,7 @@ $ ./build/build-in-docker install ...
 ```
 
 Now cd to ~/repos/NVIDIA/spark-rapids and build with one of the options from
-[spark-rapids instructions](https://github.com/NVIDIA/spark-rapids/blob/branch-24.02/CONTRIBUTING.md#building-from-source).
+[spark-rapids instructions](https://github.com/NVIDIA/spark-rapids/blob/branch-24.04/CONTRIBUTING.md#building-from-source).
 
 ```bash
 $ ./build/buildall
diff --git a/build-libcudf.xml b/build-libcudf.xml
index f4068c180d..765f50e8a0 100644
--- a/build-libcudf.xml
+++ b/build-libcudf.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0"?>
 <!--
-  Copyright (c) 2022, NVIDIA CORPORATION.
+  Copyright (c) 2022-2024, NVIDIA CORPORATION.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -40,13 +40,16 @@
       <arg value="-DBUILD_TESTS=OFF"/>
       <arg value="-DCMAKE_CUDA_ARCHITECTURES=${GPU_ARCHS}"/>
       <arg value="-DCMAKE_INSTALL_PREFIX=${libcudf.install.path}"/>
+      <arg value="-DCUDF_DEPENDENCY_PIN_MODE=${libcudf.dependency.mode}"/>
       <arg value="-DCUDA_STATIC_RUNTIME=ON"/>
       <arg value="-DCUDF_ENABLE_ARROW_S3=OFF"/>
       <arg value="-DCUDF_ENABLE_ARROW_PARQUET=ON"/>
       <arg value="-DCUDF_USE_ARROW_STATIC=ON"/>
       <arg value="-DCUDF_USE_PER_THREAD_DEFAULT_STREAM=${CUDF_USE_PER_THREAD_DEFAULT_STREAM}" />
+      <arg value="-DLIBCUDF_LOGGING_LEVEL=${RMM_LOGGING_LEVEL}" />
       <arg value="-DRMM_LOGGING_LEVEL=${RMM_LOGGING_LEVEL}" />
       <arg value="-DUSE_GDS=${USE_GDS}" />
+      <arg value="-C=${cudf.pin.path}/setup.cmake"/>
     </exec>
 
     <exec dir="${libcudf.build.path}"
diff --git a/build/build-info b/build/build-info
index ff3836ff89..bb7b81e1b6 100755
--- a/build/build-info
+++ b/build/build-info
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 #
-# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -20,18 +20,42 @@
 # Arguments:
 #   version  - The current version of the project
 #   git_path - The path to the repository
+#   libcudf_path - The path to the libcudf library
 set -e
+set -o pipefail
 
 echo_build_properties() {
   version=$1
   git_path=$2
-  shift 2
+  libcudf_path=$3
+  shift 3
   echo version=$version
-  echo user=$USER
+  echo user=$(whoami)
   echo revision=$(cd "$git_path" && git rev-parse HEAD)
   echo branch=$(cd "$git_path" && git rev-parse --abbrev-ref HEAD)
   echo date=$(date -u +%Y-%m-%dT%H:%M:%SZ)
   echo url=$(cd "$git_path" && git config --get remote.origin.url)
+  gpu_architectures=$(
+    cuobjdump "$libcudf_path" | gawk '
+      match($0, /arch = sm_([0-9]+)/, tmp) {
+        arch[tmp[1]] = 1
+      }
+
+      END {
+        n = asorti(arch)
+        if (n == 0) {
+          print "ERROR: No fatbin ELF / PTX code sections found" > "/dev/stderr"
+          exit(1)
+        }
+        s = arch[1]
+        for (i = 2; i <= n; i++) {
+          s = s ";" arch[i]
+        }
+        print s
+      }
+    '
+  )
+  echo "gpu_architectures=$gpu_architectures"
   for arg in "$@"; do
     echo $arg
   done
diff --git a/ci/Jenkinsfile.premerge b/ci/Jenkinsfile.premerge
index 72ef595a37..a59db1af9a 100644
--- a/ci/Jenkinsfile.premerge
+++ b/ci/Jenkinsfile.premerge
@@ -1,6 +1,6 @@
 #!/usr/local/env groovy
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -42,7 +42,7 @@ pipeline {
     agent {
         kubernetes {
             label "premerge-init-${BUILD_TAG}"
-            cloud 'sc-ipp-blossom-prod'
+            cloud "${common.CLOUD_NAME}"
             yaml cpuImage
         }
     }
@@ -93,7 +93,7 @@ pipeline {
 
                     def title = githubHelper.getIssue().title
                     if (title ==~ /.*\[skip ci\].*/) {
-                        githubHelper.updateCommitStatus("$BUILD_URL", "Skipped", GitHubCommitState.SUCCESS)
+                        githubHelper.updateCommitStatus("", "Skipped", GitHubCommitState.SUCCESS)
                         currentBuild.result == "SUCCESS"
                         skipped = true
                         return
@@ -113,7 +113,7 @@ pipeline {
             agent {
                 kubernetes {
                     label "premerge-docker-${BUILD_TAG}"
-                    cloud 'sc-ipp-blossom-prod'
+                    cloud "${common.CLOUD_NAME}"
                     yaml pod.getDockerBuildYAML()
                     workspaceVolume persistentVolumeClaimWorkspaceVolume(claimName: "${PVC}", readOnly: false)
                     customWorkspace "${CUSTOM_WORKSPACE}"
@@ -122,7 +122,7 @@ pipeline {
 
             steps {
                 script {
-                    githubHelper.updateCommitStatus("$BUILD_URL", "Running", GitHubCommitState.PENDING)
+                    githubHelper.updateCommitStatus("", "Running", GitHubCommitState.PENDING)
                     checkout(
                         changelog: false,
                         poll: true,
@@ -200,7 +200,7 @@ git --no-pager diff --name-only HEAD \$BASE -- ${PREMERGE_DOCKERFILE} || true"""
             agent {
                 kubernetes {
                     label "premerge-ci-1-${BUILD_TAG}"
-                    cloud 'sc-ipp-blossom-prod'
+                    cloud "${common.CLOUD_NAME}"
                     yaml pod.getGPUYAML("${IMAGE_PREMERGE}", "${env.GPU_RESOURCE}", '8', '32Gi')
                     workspaceVolume persistentVolumeClaimWorkspaceVolume(claimName: "${PVC}", readOnly: false)
                     customWorkspace "${CUSTOM_WORKSPACE}"
@@ -229,14 +229,15 @@ git --no-pager diff --name-only HEAD \$BASE -- ${PREMERGE_DOCKERFILE} || true"""
                 }
 
                 if (currentBuild.currentResult == "SUCCESS") {
-                    githubHelper.updateCommitStatus("$BUILD_URL", "Success", GitHubCommitState.SUCCESS)
+                    githubHelper.updateCommitStatus("", "Success", GitHubCommitState.SUCCESS)
                 } else {
                     // upload log only in case of build failure
                     def guardWords = ["gitlab.*?\\.com", "urm.*?\\.com"]
                     guardWords.add("nvidia-smi(?s)(.*?)(?=git)") // hide GPU info
+                    guardWords.add("sc-ipp*") // hide cloud info
                     githubHelper.uploadLogs(this, env.JOB_NAME, env.BUILD_NUMBER, null, guardWords)
 
-                    githubHelper.updateCommitStatus("$BUILD_URL", "Fail", GitHubCommitState.FAILURE)
+                    githubHelper.updateCommitStatus("", "Fail", GitHubCommitState.FAILURE)
                 }
 
                 if (TEMP_IMAGE_BUILD) {
diff --git a/ci/deploy.sh b/ci/deploy.sh
index c4201d0c11..710f61e678 100755
--- a/ci/deploy.sh
+++ b/ci/deploy.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# Copyright (c) 2022-2023, NVIDIA CORPORATION. All rights reserved.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -69,14 +69,15 @@ IFS="$ORI_IFS"
 FIRST_FILE=${CLASS_FILES%%,*}
 cp -f "$FIRST_FILE" "$FPATH.jar"
 
+GPG_PLUGIN="org.apache.maven.plugins:maven-gpg-plugin:3.1.0:sign-and-deploy-file"
 ###### Build the deploy command ######
 if [ "$SIGN_FILE" == true ]; then
     case $SIGN_TOOL in
         nvsec)
-            DEPLOY_CMD="$MVN gpg:sign-and-deploy-file -Dgpg.executable=nvsec_sign"
+            DEPLOY_CMD="$MVN $GPG_PLUGIN -Dgpg.executable=nvsec_sign"
             ;;
         gpg)
-            DEPLOY_CMD="$MVN gpg:sign-and-deploy-file -Dgpg.passphrase=$GPG_PASSPHRASE "
+            DEPLOY_CMD="$MVN $GPG_PLUGIN -Dgpg.passphrase=$GPG_PASSPHRASE "
             ;;
         *)
             echo "Error unsupported sign type : $SIGN_TYPE !"
diff --git a/ci/submodule-sync.sh b/ci/submodule-sync.sh
index 2b8b186152..18119dc45d 100755
--- a/ci/submodule-sync.sh
+++ b/ci/submodule-sync.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# Copyright (c) 2022-2023, NVIDIA CORPORATION. All rights reserved.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -49,8 +49,14 @@ else
   git merge origin/${REF}
 fi
 
-# sync up cudf from remote
-git submodule update --remote --merge
+# sync up cudf from remote, checkout to cudf release tag if CUDF_TAG is set
+if [ -n "$CUDF_TAG" ]; then
+  pushd thirdparty/cudf
+  git checkout tags/$CUDF_TAG
+  popd
+else
+  git submodule update --remote --merge
+fi
 cudf_sha=$(git -C thirdparty/cudf rev-parse HEAD)
 if [[ "${cudf_sha}" == "${cudf_prev_sha}" ]]; then
   echo "Submodule is up to date."
@@ -59,8 +65,6 @@ fi
 
 echo "Try update cudf submodule to ${cudf_sha}..."
 git add .
-git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${cudf_sha}"
-sha=$(git rev-parse HEAD)
 
 echo "Test against ${cudf_sha}..."
 
@@ -69,6 +73,7 @@ set +e
 ${MVN} verify ${MVN_MIRROR} \
   -DCPP_PARALLEL_LEVEL=${PARALLEL_LEVEL} \
   -Dlibcudf.build.configure=true \
+  -Dlibcudf.dependency.mode=latest \
   -DUSE_GDS=ON -Dtest=*,!CuFileTest,!CudaFatalTest,!ColumnViewNonEmptyNullsTest \
   -DBUILD_TESTS=ON \
   -DUSE_SANITIZER=ON
@@ -83,6 +88,18 @@ else
   echo "Test failed, will update the result"
 fi
 
+# Extract the rapids-cmake sha1 that we need to pin too
+rapids_cmake_sha=$(git -C thirdparty/cudf/cpp/build/_deps/rapids-cmake-src/ rev-parse HEAD)
+echo "Update rapids-cmake pinned SHA1 to ${rapids_cmake_sha}"
+echo "${rapids_cmake_sha}" > thirdparty/cudf-pins/rapids-cmake.sha
+
+# Do the git add after the build so that we get
+# the updated versions.json generated by the build
+echo "Update cudf submodule to ${cudf_sha} with updated pinned versions"
+git add .
+git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${cudf_sha}"
+sha=$(git rev-parse HEAD)
+
 # push the intermediate branch and create PR against REF
 # if test passed, it will try auto-merge the PR
 # if test failed, it will only comment the test result in the PR
diff --git a/pom.xml b/pom.xml
index 2ca79469de..8c366a946b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
 
   <groupId>com.nvidia</groupId>
   <artifactId>spark-rapids-jni</artifactId>
-  <version>24.02.1</version>
+  <version>24.04.0</version>
   <packaging>jar</packaging>
   <name>RAPIDS Accelerator JNI for Apache Spark</name>
   <description>
@@ -89,12 +89,14 @@
     <cuda.version>cuda11</cuda.version>
     <jni.classifier>${cuda.version}</jni.classifier>
     <cudf.path>${project.basedir}/thirdparty/cudf</cudf.path>
+    <cudf.pin.path>${project.basedir}/thirdparty/cudf-pins/</cudf.pin.path>
     <hadoop.version>3.2.4</hadoop.version>
     <junit.version>5.8.1</junit.version>
     <libcudf.build.path>${cudf.path}/cpp/build</libcudf.build.path>
     <libcudf.build.configure>false</libcudf.build.configure>
     <libcudf.clean.skip>true</libcudf.clean.skip>
     <libcudf.install.path>${project.build.directory}/libcudf-install</libcudf.install.path>
+    <libcudf.dependency.mode>pinned</libcudf.dependency.mode>
     <libcudfjni.build.path>${project.build.directory}/libcudfjni</libcudfjni.build.path>
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
@@ -476,6 +478,7 @@
                   <arg value="${project.basedir}/build/build-info"/>
                   <arg value="${project.version}"/>
                   <arg value="${cudf.path}"/>
+                  <arg value="${libcudf.build.path}/libcudf.a"/>
                 </exec>
                 <exec executable="bash"
                       output="${project.build.directory}/extra-resources/spark-rapids-jni-version-info.properties"
@@ -483,6 +486,7 @@
                   <arg value="${project.basedir}/build/build-info"/>
                   <arg value="${project.version}"/>
                   <arg value="${project.basedir}"/>
+                  <arg value="${native.build.path}/libcudf.so"/>
                 </exec>
               </target>
             </configuration>
diff --git a/src/main/cpp/CMakeLists.txt b/src/main/cpp/CMakeLists.txt
index 1ad65687e2..1fef6ffab8 100644
--- a/src/main/cpp/CMakeLists.txt
+++ b/src/main/cpp/CMakeLists.txt
@@ -1,5 +1,5 @@
 # =============================================================================
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed 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
@@ -14,7 +14,7 @@
 
 cmake_minimum_required(VERSION 3.20.1 FATAL_ERROR)
 
-include(../../../thirdparty/cudf/fetch_rapids.cmake)
+include(../../../thirdparty/cudf/rapids_config.cmake)
 include(rapids-cmake)
 include(rapids-cpm)
 include(rapids-cuda)
@@ -32,7 +32,7 @@ rapids_cuda_init_architectures(SPARK_RAPIDS_JNI)
 
 project(
   SPARK_RAPIDS_JNI
-  VERSION 24.02.00
+  VERSION 24.04.00
   LANGUAGES C CXX CUDA
 )
 
@@ -94,6 +94,9 @@ include(cmake/Modules/ConfigureCUDA.cmake) # set other CUDA compilation flags
 # ##################################################################################################
 # * dependencies ----------------------------------------------------------------------------------
 
+# find NVTX
+include(${CUDF_DIR}/cpp/cmake/thirdparty/get_nvtx.cmake)
+
 # find CCCL
 include(${CUDF_DIR}/cpp/cmake/thirdparty/get_cccl.cmake)
 
@@ -153,6 +156,7 @@ add_library(
   src/GpuTimeZoneDBJni.cpp
   src/HashJni.cpp
   src/HistogramJni.cpp
+  src/JSONUtilsJni.cpp
   src/MapUtilsJni.cpp
   src/NativeParquetJni.cpp
   src/ParseURIJni.cpp
@@ -167,10 +171,12 @@ add_library(
   src/cast_string_to_float.cu
   src/datetime_rebase.cu
   src/decimal_utils.cu
+  src/get_json_object.cu
   src/histogram.cu
   src/map_utils.cu
   src/murmur_hash.cu
   src/parse_uri.cu
+  src/row_conversion.cu
   src/timezones.cu
   src/utilities.cu
   src/xxhash64.cu
@@ -223,6 +229,7 @@ target_link_libraries(
   -Wl,--whole-archive
     ${CUDFJNI_LIB}
     cudf::cudf
+    nvtx3-cpp
   -Wl,--no-whole-archive
     ${PARQUET_LIB}
     ${THRIFT_LIB}
diff --git a/src/main/cpp/benchmarks/bloom_filter.cu b/src/main/cpp/benchmarks/bloom_filter.cu
index 668fd90eef..d45068001b 100644
--- a/src/main/cpp/benchmarks/bloom_filter.cu
+++ b/src/main/cpp/benchmarks/bloom_filter.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,15 +14,14 @@
  * limitations under the License.
  */
 
-#include <bloom_filter.hpp>
-#include <hash.cuh>
-
 #include <benchmarks/common/generate_input.hpp>
 
-#include <nvbench/nvbench.cuh>
-
 #include <cudf_test/column_utilities.hpp>
 
+#include <bloom_filter.hpp>
+#include <hash.cuh>
+#include <nvbench/nvbench.cuh>
+
 static void bloom_filter_put(nvbench::state& state)
 {
   constexpr int num_rows   = 150'000'000;
diff --git a/src/main/cpp/benchmarks/cast_string_to_float.cpp b/src/main/cpp/benchmarks/cast_string_to_float.cpp
index d94f9d26a0..e74eb4a4c6 100644
--- a/src/main/cpp/benchmarks/cast_string_to_float.cpp
+++ b/src/main/cpp/benchmarks/cast_string_to_float.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-#include <cast_string.hpp>
-
 #include <benchmarks/common/generate_input.hpp>
 
-#include <nvbench/nvbench.cuh>
+#include <cudf_test/column_utilities.hpp>
 
 #include <cudf/strings/convert/convert_floats.hpp>
 #include <cudf/strings/strings_column_view.hpp>
-#include <cudf_test/column_utilities.hpp>
+
+#include <cast_string.hpp>
+#include <nvbench/nvbench.cuh>
 
 void string_to_float(nvbench::state& state)
 {
diff --git a/src/main/cpp/benchmarks/parse_uri.cpp b/src/main/cpp/benchmarks/parse_uri.cpp
index 26e46117d8..03166f3c3e 100644
--- a/src/main/cpp/benchmarks/parse_uri.cpp
+++ b/src/main/cpp/benchmarks/parse_uri.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-#include <parse_uri.hpp>
-
 #include <benchmarks/common/generate_input.hpp>
 
-#include <nvbench/nvbench.cuh>
-
-#include <cudf/filling.hpp>
-#include <cudf/strings/strings_column_view.hpp>
 #include <cudf_test/column_utilities.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/default_stream.hpp>
 
+#include <cudf/filling.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+
+#include <nvbench/nvbench.cuh>
+#include <parse_uri.hpp>
+
 static void bench_random_parse_uri(nvbench::state& state)
 {
   cudf::size_type const n_rows{(cudf::size_type)state.get_int64("num_rows")};
diff --git a/src/main/cpp/benchmarks/row_conversion.cpp b/src/main/cpp/benchmarks/row_conversion.cpp
index b8694fbcdf..ff2e11f838 100644
--- a/src/main/cpp/benchmarks/row_conversion.cpp
+++ b/src/main/cpp/benchmarks/row_conversion.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-#include <row_conversion.hpp>
-
 #include <benchmarks/common/generate_input.hpp>
 
-#include <nvbench/nvbench.cuh>
+#include <cudf_test/column_utilities.hpp>
 
 #include <cudf/lists/lists_column_view.hpp>
 #include <cudf/strings/strings_column_view.hpp>
-#include <cudf_test/column_utilities.hpp>
+
+#include <nvbench/nvbench.cuh>
+#include <row_conversion.hpp>
 
 void fixed_width(nvbench::state& state)
 {
@@ -48,15 +48,15 @@ void fixed_width(nvbench::state& state)
     bytes_per_row += cudf::size_of(t);
   }
 
-  auto rows = cudf::convert_to_rows_fixed_width_optimized(table->view());
+  auto rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(table->view());
 
   state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
     if (direction == "to row") {
-      auto _rows = cudf::convert_to_rows_fixed_width_optimized(table->view());
+      auto _rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(table->view());
     } else {
       for (auto const& r : rows) {
         cudf::lists_column_view const l(r->view());
-        auto out = cudf::convert_from_rows_fixed_width_optimized(l, schema);
+        auto out = spark_rapids_jni::convert_from_rows_fixed_width_optimized(l, schema);
       }
     }
   });
@@ -117,16 +117,16 @@ static void variable_or_fixed_width(nvbench::state& state)
     }
   }
 
-  auto rows = cudf::convert_to_rows(table->view());
+  auto rows = spark_rapids_jni::convert_to_rows(table->view());
 
   state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
-    auto new_rows = cudf::convert_to_rows(table->view());
+    auto new_rows = spark_rapids_jni::convert_to_rows(table->view());
     if (direction == "to row") {
-      auto _rows = cudf::convert_to_rows(table->view());
+      auto _rows = spark_rapids_jni::convert_to_rows(table->view());
     } else {
       for (auto const& r : rows) {
         cudf::lists_column_view const l(r->view());
-        auto out = cudf::convert_from_rows(l, schema);
+        auto out = spark_rapids_jni::convert_from_rows(l, schema);
       }
     }
   });
diff --git a/src/main/cpp/faultinj/faultinj.cu b/src/main/cpp/faultinj/faultinj.cu
index 6903ebf446..13065a81ed 100644
--- a/src/main/cpp/faultinj/faultinj.cu
+++ b/src/main/cpp/faultinj/faultinj.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,19 +14,20 @@
  * limitations under the License.
  */
 
-#include <assert.h>
 #include <cuda.h>
+
+#include <assert.h>
 #include <cupti.h>
+#include <pthread.h>
+
 #include <exception>
 #include <iostream>
 #include <map>
-#include <pthread.h>
 
 // thread-safe ptree
 #define BOOST_SPIRIT_THREADSAFE
 #include <boost/property_tree/json_parser.hpp>
 #include <boost/property_tree/ptree.hpp>
-
 #include <spdlog/spdlog.h>
 #include <sys/inotify.h>
 #include <sys/time.h>
diff --git a/src/main/cpp/src/BloomFilterJni.cpp b/src/main/cpp/src/BloomFilterJni.cpp
index 90c696577a..5acdf8a107 100644
--- a/src/main/cpp/src/BloomFilterJni.cpp
+++ b/src/main/cpp/src/BloomFilterJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,11 +15,10 @@
  */
 
 #include "bloom_filter.hpp"
-#include "utilities.hpp"
-
 #include "cudf_jni_apis.hpp"
 #include "dtype_utils.hpp"
 #include "jni_utils.hpp"
+#include "utilities.hpp"
 
 extern "C" {
 
diff --git a/src/main/cpp/src/CastStringJni.cpp b/src/main/cpp/src/CastStringJni.cpp
index b7d898a0c8..e570529cb6 100644
--- a/src/main/cpp/src/CastStringJni.cpp
+++ b/src/main/cpp/src/CastStringJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,6 +15,10 @@
  */
 
 #include "cast_string.hpp"
+#include "cudf_jni_apis.hpp"
+#include "dtype_utils.hpp"
+#include "jni_utils.hpp"
+
 #include <cudf/binaryop.hpp>
 #include <cudf/column/column_factories.hpp>
 #include <cudf/copying.hpp>
@@ -29,10 +33,6 @@
 #include <cudf/transform.hpp>
 #include <cudf/unary.hpp>
 
-#include "cudf_jni_apis.hpp"
-#include "dtype_utils.hpp"
-#include "jni_utils.hpp"
-
 constexpr char const* JNI_CAST_ERROR_CLASS = "com/nvidia/spark/rapids/jni/CastException";
 
 #define CATCH_CAST_EXCEPTION(env, ret_val)                                                \
diff --git a/src/main/cpp/src/HashJni.cpp b/src/main/cpp/src/HashJni.cpp
index d106da2b61..9e556cdd2d 100644
--- a/src/main/cpp/src/HashJni.cpp
+++ b/src/main/cpp/src/HashJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,9 +16,8 @@
 
 #include "cudf_jni_apis.hpp"
 #include "dtype_utils.hpp"
-#include "jni_utils.hpp"
-
 #include "hash.cuh"
+#include "jni_utils.hpp"
 
 extern "C" {
 
diff --git a/src/main/cpp/src/JSONUtilsJni.cpp b/src/main/cpp/src/JSONUtilsJni.cpp
new file mode 100644
index 0000000000..73b932d4b9
--- /dev/null
+++ b/src/main/cpp/src/JSONUtilsJni.cpp
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed 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 "cudf_jni_apis.hpp"
+#include "get_json_object.hpp"
+
+#include <cudf/strings/strings_column_view.hpp>
+
+#include <vector>
+
+using path_instruction_type = spark_rapids_jni::path_instruction_type;
+
+extern "C" {
+JNIEXPORT jlong JNICALL Java_com_nvidia_spark_rapids_jni_JSONUtils_getJsonObject(
+  JNIEnv* env, jclass, jlong input_column, jobjectArray path_instructions)
+{
+  JNI_NULL_CHECK(env, input_column, "input column is null", 0);
+  JNI_NULL_CHECK(env, path_instructions, "path_instructions is null", 0);
+  try {
+    cudf::jni::auto_set_device(env);
+    auto const n_column_view      = reinterpret_cast<cudf::column_view const*>(input_column);
+    auto const n_strings_col_view = cudf::strings_column_view{*n_column_view};
+
+    std::vector<std::tuple<path_instruction_type, std::string, int64_t>> instructions;
+    int size = env->GetArrayLength(path_instructions);
+    for (int i = 0; i < size; i++) {
+      jobject instruction = env->GetObjectArrayElement(path_instructions, i);
+      JNI_NULL_CHECK(env, instruction, "path_instruction is null", 0);
+      jclass instruction_class = env->GetObjectClass(instruction);
+      JNI_NULL_CHECK(env, instruction_class, "instruction_class is null", 0);
+
+      jfieldID field_id = env->GetFieldID(instruction_class, "type", "I");
+      JNI_NULL_CHECK(env, field_id, "field_id is null", 0);
+      jint type                              = env->GetIntField(instruction, field_id);
+      path_instruction_type instruction_type = static_cast<path_instruction_type>(type);
+
+      field_id = env->GetFieldID(instruction_class, "name", "Ljava/lang/String;");
+      JNI_NULL_CHECK(env, field_id, "field_id is null", 0);
+      jstring name = (jstring)env->GetObjectField(instruction, field_id);
+      JNI_NULL_CHECK(env, name, "name is null", 0);
+      const char* name_str = env->GetStringUTFChars(name, JNI_FALSE);
+
+      field_id = env->GetFieldID(instruction_class, "index", "J");
+      JNI_NULL_CHECK(env, field_id, "field_id is null", 0);
+      jlong index = env->GetLongField(instruction, field_id);
+
+      instructions.emplace_back(instruction_type, name_str, index);
+
+      env->ReleaseStringUTFChars(name, name_str);
+    }
+
+    return cudf::jni::release_as_jlong(
+      spark_rapids_jni::get_json_object(n_strings_col_view, instructions));
+  }
+  CATCH_STD(env, 0);
+}
+}
diff --git a/src/main/cpp/src/MapUtilsJni.cpp b/src/main/cpp/src/MapUtilsJni.cpp
index dc02d04370..0fc5f3c280 100644
--- a/src/main/cpp/src/MapUtilsJni.cpp
+++ b/src/main/cpp/src/MapUtilsJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
+#include "map_utils.hpp"
+
 #include <cudf_jni_apis.hpp>
 #include <dtype_utils.hpp>
 
-#include "map_utils.hpp"
-
 extern "C" {
 
 JNIEXPORT jlong JNICALL Java_com_nvidia_spark_rapids_jni_MapUtils_extractRawMapFromJsonString(
diff --git a/src/main/cpp/src/NativeParquetJni.cpp b/src/main/cpp/src/NativeParquetJni.cpp
index 9c8674e800..2a1c00b86e 100644
--- a/src/main/cpp/src/NativeParquetJni.cpp
+++ b/src/main/cpp/src/NativeParquetJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,15 +24,15 @@
 // This came from the parquet code itself...
 #define SIGNED_RIGHT_SHIFT_IS  1
 #define ARITHMETIC_RIGHT_SHIFT 1
-#include <thrift/TApplicationException.h>
-#include <thrift/protocol/TCompactProtocol.h>
-#include <thrift/transport/TBufferTransports.h>
+#include "cudf_jni_apis.hpp"
+#include "jni_utils.hpp"
 
 #include <cudf/detail/nvtx/ranges.hpp>
-#include <generated/parquet_types.h>
 
-#include "cudf_jni_apis.hpp"
-#include "jni_utils.hpp"
+#include <generated/parquet_types.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TCompactProtocol.h>
+#include <thrift/transport/TBufferTransports.h>
 
 namespace rapids {
 namespace jni {
diff --git a/src/main/cpp/src/RowConversionJni.cpp b/src/main/cpp/src/RowConversionJni.cpp
index 8e900691f1..26b1138c10 100644
--- a/src/main/cpp/src/RowConversionJni.cpp
+++ b/src/main/cpp/src/RowConversionJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,8 +16,7 @@
 
 #include "cudf_jni_apis.hpp"
 #include "dtype_utils.hpp"
-
-#include <cudf/row_conversion.hpp>
+#include "row_conversion.hpp"
 
 extern "C" {
 
@@ -32,7 +31,7 @@ Java_com_nvidia_spark_rapids_jni_RowConversion_convertToRowsFixedWidthOptimized(
     cudf::jni::auto_set_device(env);
     cudf::table_view const* n_input_table = reinterpret_cast<cudf::table_view const*>(input_table);
     std::vector<std::unique_ptr<cudf::column>> cols =
-      cudf::convert_to_rows_fixed_width_optimized(*n_input_table);
+      spark_rapids_jni::convert_to_rows_fixed_width_optimized(*n_input_table);
     int const num_columns = cols.size();
     cudf::jni::native_jlongArray outcol_handles(env, num_columns);
     std::transform(cols.begin(), cols.end(), outcol_handles.begin(), [](auto& col) {
@@ -51,8 +50,9 @@ Java_com_nvidia_spark_rapids_jni_RowConversion_convertToRows(JNIEnv* env, jclass
   try {
     cudf::jni::auto_set_device(env);
     cudf::table_view const* n_input_table = reinterpret_cast<cudf::table_view const*>(input_table);
-    std::vector<std::unique_ptr<cudf::column>> cols = cudf::convert_to_rows(*n_input_table);
-    int const num_columns                           = cols.size();
+    std::vector<std::unique_ptr<cudf::column>> cols =
+      spark_rapids_jni::convert_to_rows(*n_input_table);
+    int const num_columns = cols.size();
     cudf::jni::native_jlongArray outcol_handles(env, num_columns);
     std::transform(cols.begin(), cols.end(), outcol_handles.begin(), [](auto& col) {
       return cudf::jni::release_as_jlong(col);
@@ -84,7 +84,7 @@ Java_com_nvidia_spark_rapids_jni_RowConversion_convertFromRowsFixedWidthOptimize
                    std::back_inserter(types_vec),
                    [](jint type, jint scale) { return cudf::jni::make_data_type(type, scale); });
     std::unique_ptr<cudf::table> result =
-      cudf::convert_from_rows_fixed_width_optimized(list_input, types_vec);
+      spark_rapids_jni::convert_from_rows_fixed_width_optimized(list_input, types_vec);
     return cudf::jni::convert_table_for_return(env, result);
   }
   CATCH_STD(env, 0);
@@ -110,7 +110,8 @@ JNIEXPORT jlongArray JNICALL Java_com_nvidia_spark_rapids_jni_RowConversion_conv
                    n_scale.begin(),
                    std::back_inserter(types_vec),
                    [](jint type, jint scale) { return cudf::jni::make_data_type(type, scale); });
-    std::unique_ptr<cudf::table> result = cudf::convert_from_rows(list_input, types_vec);
+    std::unique_ptr<cudf::table> result =
+      spark_rapids_jni::convert_from_rows(list_input, types_vec);
     return cudf::jni::convert_table_for_return(env, result);
   }
   CATCH_STD(env, 0);
diff --git a/src/main/cpp/src/SparkResourceAdaptorJni.cpp b/src/main/cpp/src/SparkResourceAdaptorJni.cpp
index b8fb337bf2..b68cc16308 100644
--- a/src/main/cpp/src/SparkResourceAdaptorJni.cpp
+++ b/src/main/cpp/src/SparkResourceAdaptorJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,23 +14,23 @@
  * limitations under the License.
  */
 
-#include <chrono>
-#include <exception>
-#include <map>
-#include <set>
-#include <sstream>
-#include <unordered_set>
-
-#include <pthread.h>
+#include <rmm/mr/device/device_memory_resource.hpp>
 
 #include <cudf_jni_apis.hpp>
-#include <rmm/mr/device/device_memory_resource.hpp>
+#include <pthread.h>
 #include <spdlog/common.h>
 #include <spdlog/sinks/basic_file_sink.h>
 #include <spdlog/sinks/null_sink.h>
 #include <spdlog/sinks/ostream_sink.h>
 #include <spdlog/spdlog.h>
 
+#include <chrono>
+#include <exception>
+#include <map>
+#include <set>
+#include <sstream>
+#include <unordered_set>
+
 namespace {
 
 constexpr char const* GPU_RETRY_OOM_CLASS = "com/nvidia/spark/rapids/jni/GpuRetryOOM";
@@ -401,10 +401,6 @@ class spark_resource_adaptor final : public rmm::mr::device_memory_resource {
 
   rmm::mr::device_memory_resource* get_wrapped_resource() { return resource; }
 
-  bool supports_get_mem_info() const noexcept override { return resource->supports_get_mem_info(); }
-
-  bool supports_streams() const noexcept override { return resource->supports_streams(); }
-
   /**
    * Update the internal state so that a specific thread is dedicated to a task.
    * This may be called multiple times for a given thread and if the thread is already
@@ -1800,11 +1796,6 @@ class spark_resource_adaptor final : public rmm::mr::device_memory_resource {
       dealloc_core(false, lock);
     }
   }
-
-  std::pair<size_t, size_t> do_get_mem_info(rmm::cuda_stream_view stream) const override
-  {
-    return resource->get_mem_info(stream);
-  }
 };
 
 }  // namespace
diff --git a/src/main/cpp/src/ZOrderJni.cpp b/src/main/cpp/src/ZOrderJni.cpp
index 37925f86d6..5d00e57490 100644
--- a/src/main/cpp/src/ZOrderJni.cpp
+++ b/src/main/cpp/src/ZOrderJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 
-#include "zorder.hpp"
-
 #include "cudf_jni_apis.hpp"
 #include "dtype_utils.hpp"
+#include "zorder.hpp"
 
 extern "C" {
 
diff --git a/src/main/cpp/src/bloom_filter.cu b/src/main/cpp/src/bloom_filter.cu
index 6270705178..d5f868c476 100644
--- a/src/main/cpp/src/bloom_filter.cu
+++ b/src/main/cpp/src/bloom_filter.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,9 +32,8 @@
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
-#include <thrust/logical.h>
-
 #include <cuda/functional>
+#include <thrust/logical.h>
 
 #include <byteswap.h>
 
diff --git a/src/main/cpp/src/bloom_filter.hpp b/src/main/cpp/src/bloom_filter.hpp
index 54170782ca..e54d26f630 100644
--- a/src/main/cpp/src/bloom_filter.hpp
+++ b/src/main/cpp/src/bloom_filter.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
 #include <cudf/column/column_view.hpp>
 #include <cudf/scalar/scalar.hpp>
 #include <cudf/utilities/default_stream.hpp>
+
 #include <rmm/cuda_stream_view.hpp>
 
 namespace spark_rapids_jni {
diff --git a/src/main/cpp/src/cast_decimal_to_string.cu b/src/main/cpp/src/cast_decimal_to_string.cu
index 01fc5c5a92..9d0e27ed59 100644
--- a/src/main/cpp/src/cast_decimal_to_string.cu
+++ b/src/main/cpp/src/cast_decimal_to_string.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,9 +28,13 @@
 #include <cudf/strings/strings_column_view.hpp>
 #include <cudf/utilities/default_stream.hpp>
 #include <cudf/utilities/type_dispatcher.hpp>
+
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
+#include <cuda/std/climits>
+#include <cuda/std/limits>
+#include <cuda/std/type_traits>
 #include <thrust/execution_policy.h>
 #include <thrust/for_each.h>
 #include <thrust/generate.h>
@@ -38,10 +42,6 @@
 #include <thrust/optional.h>
 #include <thrust/transform.h>
 
-#include <cuda/std/climits>
-#include <cuda/std/limits>
-#include <cuda/std/type_traits>
-
 using namespace cudf;
 
 namespace spark_rapids_jni {
@@ -191,7 +191,7 @@ struct dispatch_decimal_to_non_ansi_string_fn {
 
     return make_strings_column(input.size(),
                                std::move(offsets),
-                               std::move(chars->release().data.release()[0]),
+                               chars.release(),
                                input.null_count(),
                                cudf::detail::copy_bitmask(input, stream, mr));
   }
diff --git a/src/main/cpp/src/cast_float_to_string.cu b/src/main/cpp/src/cast_float_to_string.cu
index c0e0875914..78cedbbf64 100644
--- a/src/main/cpp/src/cast_float_to_string.cu
+++ b/src/main/cpp/src/cast_float_to_string.cu
@@ -88,7 +88,7 @@ struct dispatch_float_to_string_fn {
 
     return make_strings_column(strings_count,
                                std::move(offsets),
-                               std::move(chars->release().data.release()[0]),
+                               chars.release(),
                                floats.null_count(),
                                cudf::detail::copy_bitmask(floats, stream, mr));
   }
diff --git a/src/main/cpp/src/cast_string.cu b/src/main/cpp/src/cast_string.cu
index c2a8190062..a961981160 100644
--- a/src/main/cpp/src/cast_string.cu
+++ b/src/main/cpp/src/cast_string.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,9 +16,6 @@
 
 #include "cast_string.hpp"
 
-#include <rmm/device_scalar.hpp>
-#include <rmm/exec_policy.hpp>
-
 #include <cudf/column/column.hpp>
 #include <cudf/column/column_device_view.cuh>
 #include <cudf/detail/null_mask.hpp>
@@ -26,9 +23,11 @@
 #include <cudf/detail/utilities/integer_utils.hpp>
 #include <cudf/null_mask.hpp>
 
-#include <cub/warp/warp_reduce.cuh>
+#include <rmm/device_scalar.hpp>
+#include <rmm/exec_policy.hpp>
 
 #include <cooperative_groups.h>
+#include <cub/warp/warp_reduce.cuh>
 
 using namespace cudf;
 
diff --git a/src/main/cpp/src/cast_string_to_float.cu b/src/main/cpp/src/cast_string_to_float.cu
index 75523cd360..5c3c749f02 100644
--- a/src/main/cpp/src/cast_string_to_float.cu
+++ b/src/main/cpp/src/cast_string_to_float.cu
@@ -16,7 +16,6 @@
 
 #include "cast_string.hpp"
 
-#include <cub/warp/warp_reduce.cuh>
 #include <cudf/column/column.hpp>
 #include <cudf/column/column_factories.hpp>
 #include <cudf/detail/utilities/cuda.cuh>
@@ -26,6 +25,8 @@
 #include <cudf/strings/detail/convert/string_to_float.cuh>
 #include <cudf/utilities/bit.hpp>
 
+#include <cub/warp/warp_reduce.cuh>
+
 using namespace cudf;
 
 namespace spark_rapids_jni {
diff --git a/src/main/cpp/src/datetime_rebase.cu b/src/main/cpp/src/datetime_rebase.cu
index 8963acf491..9e8e791490 100644
--- a/src/main/cpp/src/datetime_rebase.cu
+++ b/src/main/cpp/src/datetime_rebase.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,11 +27,10 @@
 #include <rmm/exec_policy.hpp>
 
 //
+#include <cuda/functional>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/transform.h>
 
-#include <cuda/functional>
-
 namespace {
 
 // Convert a date in Julian calendar to the number of days since epoch.
diff --git a/src/main/cpp/src/decimal_utils.cu b/src/main/cpp/src/decimal_utils.cu
index 92273ff545..6b9ae61076 100644
--- a/src/main/cpp/src/decimal_utils.cu
+++ b/src/main/cpp/src/decimal_utils.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,6 +20,7 @@
 #include <cudf/detail/null_mask.hpp>
 #include <cudf/table/table_view.hpp>
 #include <cudf/utilities/error.hpp>
+
 #include <rmm/exec_policy.hpp>
 
 #include <cmath>
diff --git a/src/main/cpp/src/format_float.cu b/src/main/cpp/src/format_float.cu
index 3052d334aa..1d537595d7 100644
--- a/src/main/cpp/src/format_float.cu
+++ b/src/main/cpp/src/format_float.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -89,7 +89,7 @@ struct dispatch_format_float_fn {
 
     return cudf::make_strings_column(strings_count,
                                      std::move(offsets),
-                                     std::move(chars->release().data.release()[0]),
+                                     chars.release(),
                                      floats.null_count(),
                                      cudf::detail::copy_bitmask(floats, stream, mr));
   }
diff --git a/src/main/cpp/src/ftos_converter.cuh b/src/main/cpp/src/ftos_converter.cuh
index c2fa07377c..f2e8ce0006 100644
--- a/src/main/cpp/src/ftos_converter.cuh
+++ b/src/main/cpp/src/ftos_converter.cuh
@@ -800,15 +800,15 @@ __device__ inline int to_chars(floating_decimal_64 const v, bool const sign, cha
   if (sign) { result[index++] = '-'; }
 
   uint64_t output         = v.mantissa;
-  uint32_t const olength  = decimal_length(output);
-  int32_t exp             = v.exponent + static_cast<int32_t>(olength) - 1;
+  int32_t const olength   = decimal_length(output);
+  int32_t exp             = v.exponent + olength - 1;
   bool scientificNotation = (exp < -3) || (exp >= 7);
 
   // Values in the interval [1E-3, 1E7) are special.
   if (scientificNotation) {
     // Print in the format x.xxxxxE-yy.
-    for (uint32_t i = 0; i < olength - 1; ++i) {
-      uint32_t const c = output % 10;
+    for (int i = 0; i < olength - 1; ++i) {
+      int const c = output % 10;
       output /= 10;
       result[index + olength - i] = (char)('0' + c);
     }
@@ -845,7 +845,7 @@ __device__ inline int to_chars(floating_decimal_64 const v, bool const sign, cha
         output /= 10;
         index++;
       }
-    } else if (exp + 1 >= olength) {
+    } else if (exp + 1 >= static_cast<int32_t>(olength)) {
       // Decimal dot is after any of the digits.
       for (int i = 0; i < olength; i++) {
         result[index + olength - i - 1] = (char)('0' + output % 10);
@@ -880,7 +880,7 @@ __device__ inline int d2s_size(floating_decimal_64 const v, bool const sign)
   if (sign) { index++; }
 
   uint64_t output         = v.mantissa;
-  uint32_t const olength  = decimal_length(output);
+  int32_t const olength   = decimal_length(output);
   int32_t exp             = v.exponent + static_cast<int32_t>(olength) - 1;
   bool scientificNotation = (exp < -3) || (exp >= 7);
 
@@ -920,7 +920,7 @@ __device__ inline int to_chars(floating_decimal_32 const v, bool const sign, cha
   if (sign) { result[index++] = '-'; }
 
   uint32_t output         = v.mantissa;
-  uint32_t const olength  = decimal_length(output);
+  int32_t const olength   = decimal_length(output);
   int32_t exp             = v.exponent + olength - 1;
   bool scientificNotation = (exp < -3) || (exp >= 7);
 
@@ -995,7 +995,7 @@ __device__ inline int f2s_size(floating_decimal_32 const v, bool const sign)
   if (sign) { index++; }
 
   uint32_t output         = v.mantissa;
-  uint32_t const olength  = decimal_length(output);
+  int32_t const olength   = decimal_length(output);
   int32_t exp             = v.exponent + olength - 1;
   bool scientificNotation = (exp < -3) || (exp >= 7);
 
@@ -1149,6 +1149,57 @@ __device__ inline int compute_f2s_size(float value)
   return f2s_size(v, sign);
 }
 
+//===== special inf handling for json =====
+
+__device__ inline int copy_special_str_json(char* const result,
+                                            bool const sign,
+                                            bool const exponent,
+                                            bool const mantissa)
+{
+  // no NaN in json
+  if (exponent) {
+    if (sign) {
+      memcpy(result, "\"-Infinity\"", 11);
+      return 11;
+    } else {
+      memcpy(result, "\"Infinity\"", 10);
+      return 10;
+    }
+  }
+  if (sign) {
+    memcpy(result, "-0.0", 4);
+    return 4;
+  } else {
+    memcpy(result, "0.0", 3);
+    return 3;
+  }
+}
+
+__device__ inline int special_str_size_json(bool const sign,
+                                            bool const exponent,
+                                            bool const mantissa)
+{
+  // no NaN in json
+  if (exponent) { return sign + 10; }
+  return sign + 3;
+}
+
+__device__ inline int d2s_buffered_n_json(double f, char* result)
+{
+  bool sign = false, special = false;
+  floating_decimal_64 v = d2d(f, sign, special);
+  if (special) { return copy_special_str_json(result, sign, v.exponent, v.mantissa); }
+  return to_chars(v, sign, result);
+}
+
+__device__ inline int compute_d2s_size_json(double value)
+{
+  bool sign = false, special = false;
+  floating_decimal_64 v = d2d(value, sign, special);
+  if (special) { return special_str_size_json(sign, v.exponent, v.mantissa); }
+  return d2s_size(v, sign);
+}
+
 }  // namespace
 
 //===== APIs =====
@@ -1223,9 +1274,9 @@ __device__ inline int to_formatted_chars(T const v, bool const sign, char* const
   using U   = std::conditional_t<std::is_same_v<T, floating_decimal_32>, uint32_t, uint64_t>;
   int index = 0;
   if (sign) { result[index++] = '-'; }
-  U output               = v.mantissa;
-  uint32_t const olength = decimal_length(output);
-  int32_t exp            = v.exponent + static_cast<int32_t>(olength) - 1;
+  U output              = v.mantissa;
+  int32_t const olength = decimal_length(output);
+  int32_t exp           = v.exponent + static_cast<int32_t>(olength) - 1;
   if (exp < 0) {
     // Decimal dot is before any of the digits.
     int index_for_carrier = index;
@@ -1291,7 +1342,7 @@ __device__ inline int to_formatted_chars(T const v, bool const sign, char* const
     }
   } else {
     // 0 <= exp < olength - 1
-    uint32_t temp_d = digits, tailing_zero = 0;
+    int32_t temp_d = digits, tailing_zero = 0;
     if (exp + digits + 1 > olength) {
       temp_d       = olength - exp - 1;
       tailing_zero = digits - temp_d;
@@ -1301,10 +1352,10 @@ __device__ inline int to_formatted_chars(T const v, bool const sign, char* const
     U integer        = rounded_output / pow10;
     U decimal        = rounded_output % pow10;
     // calculate integer length after format to cover carry case
-    uint32_t integer_len          = decimal_length(integer);
-    uint32_t formated_integer_len = index + integer_len + (integer_len - 1) / 3;
-    uint32_t sep_cnt              = 0;
-    int rev_index                 = 0;
+    int32_t integer_len          = decimal_length(integer);
+    int32_t formated_integer_len = index + integer_len + (integer_len - 1) / 3;
+    int32_t sep_cnt              = 0;
+    int rev_index                = 0;
     for (int i = 0; i < integer_len; i++) {
       if (sep_cnt == 3) {
         result[formated_integer_len - (rev_index++) - 1] = ',';
@@ -1338,9 +1389,9 @@ __device__ inline int format_size(T const v, bool const sign, int digits)
   using U   = std::conditional_t<std::is_same_v<T, floating_decimal_32>, uint32_t, uint64_t>;
   int index = 0;
   if (sign) { index++; }
-  U output               = v.mantissa;
-  uint32_t const olength = decimal_length(output);
-  int32_t exp            = v.exponent + static_cast<int32_t>(olength) - 1;
+  U output              = v.mantissa;
+  int32_t const olength = decimal_length(output);
+  int32_t exp           = v.exponent + static_cast<int32_t>(olength) - 1;
   if (exp < 0) {
     index += 2 + digits;
   } else if (exp + 1 >= olength) {
@@ -1424,4 +1475,15 @@ __device__ inline int format_float(double value, int digits, bool is_float, char
   }
 }
 
+//===== json_parser utility =====
+
+__device__ inline int double_normalization(double value, char* output)
+{
+  if (output == nullptr) {
+    return compute_d2s_size_json(value);
+  } else {
+    return d2s_buffered_n_json(value, output);
+  }
+}
+
 }  // namespace spark_rapids_jni::ftos_converter
diff --git a/src/main/cpp/src/get_json_object.cu b/src/main/cpp/src/get_json_object.cu
new file mode 100644
index 0000000000..c7c6c242b8
--- /dev/null
+++ b/src/main/cpp/src/get_json_object.cu
@@ -0,0 +1,1353 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed 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 "get_json_object.hpp"
+
+#include <cudf/column/column_device_view.cuh>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/detail/copy.hpp>
+#include <cudf/detail/get_value.cuh>
+#include <cudf/detail/null_mask.hpp>
+#include <cudf/detail/offsets_iterator_factory.cuh>
+#include <cudf/detail/utilities/cuda.cuh>
+#include <cudf/detail/utilities/vector_factories.hpp>
+#include <cudf/json/json.hpp>
+#include <cudf/lists/list_device_view.cuh>
+#include <cudf/lists/lists_column_device_view.cuh>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/strings/detail/strings_children.cuh>
+#include <cudf/strings/detail/utilities.hpp>
+#include <cudf/strings/string_view.cuh>
+#include <cudf/strings/strings_column_view.hpp>
+#include <cudf/types.hpp>
+#include <cudf/utilities/bit.hpp>
+#include <cudf/utilities/default_stream.hpp>
+#include <cudf/utilities/error.hpp>
+#include <cudf/utilities/span.hpp>
+
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+#include <thrust/optional.h>
+#include <thrust/pair.h>
+#include <thrust/scan.h>
+#include <thrust/tuple.h>
+
+namespace spark_rapids_jni {
+
+namespace detail {
+
+/**
+ * write JSON style
+ */
+enum class write_style { raw_style, quoted_style, flatten_style };
+
+/**
+ * path instruction
+ */
+struct path_instruction {
+  __device__ inline path_instruction(path_instruction_type _type) : type(_type) {}
+
+  path_instruction_type type;
+
+  // used when type is named type
+  cudf::string_view name;
+
+  // used when type is index
+  int index{-1};
+};
+
+/**
+ * JSON generator is used to write out JSON content.
+ * Because of get_json_object only outputs JSON object as a whole item,
+ * it's no need to store internal state for JSON object when outputing,
+ * only need to store internal state for JSON array.
+ */
+class json_generator {
+ public:
+  __device__ json_generator(char* _output) : output(_output), output_len(0) {}
+  __device__ json_generator() : output(nullptr), output_len(0) {}
+
+  // create a nested child generator based on this parent generator,
+  // child generator is a view, parent and child share the same byte array
+  __device__ json_generator new_child_generator()
+  {
+    if (nullptr == output) {
+      return json_generator();
+    } else {
+      return json_generator(output + output_len);
+    }
+  }
+
+  // write [
+  // add an extra comma if needed,
+  // e.g.: when JSON content is: [[1,2,3]
+  // writing a new [ should result: [[1,2,3],[
+  __device__ void write_start_array()
+  {
+    try_write_comma();
+
+    if (output) { *(output + output_len) = '['; }
+
+    output_len++;
+    array_depth++;
+    // new array is empty
+    is_curr_array_empty = true;
+  }
+
+  // write ]
+  __device__ void write_end_array()
+  {
+    if (output) { *(output + output_len) = ']'; }
+    output_len++;
+
+    // point to parent array
+    array_depth--;
+
+    // set parent array as non-empty because already had a closed child item.
+    is_curr_array_empty = false;
+  }
+
+  // write first start array without output, only update internal state
+  __device__ void write_first_start_array_without_output()
+  {
+    // hide the outer start array token
+    // Note: do not inc output_len
+    array_depth++;
+    // new array is empty
+    is_curr_array_empty = true;
+  }
+
+  // return true if it's in a array context and it's not writing the first item.
+  __device__ inline bool need_comma() { return (array_depth > 0 && !is_curr_array_empty); }
+
+  /**
+   * write comma accroding to current generator state
+   */
+  __device__ void try_write_comma()
+  {
+    if (need_comma()) {
+      // in array context and writes first item
+      if (output) { *(output + output_len) = ','; }
+      output_len++;
+    }
+  }
+
+  /**
+   * copy current structure when parsing. If current token is start
+   * object/array, then copy to corresponding matched end object/array. return
+   * false if JSON format is invalid return true if JSON format is valid
+   */
+  __device__ bool copy_current_structure(json_parser& parser)
+  {
+    // first try add comma
+    try_write_comma();
+
+    if (array_depth > 0) { is_curr_array_empty = false; }
+
+    if (nullptr != output) {
+      auto copy_to       = output + output_len;
+      auto [b, copy_len] = parser.copy_current_structure(copy_to);
+      output_len += copy_len;
+      return b;
+    } else {
+      char* copy_to      = nullptr;
+      auto [b, copy_len] = parser.copy_current_structure(copy_to);
+      output_len += copy_len;
+      return b;
+    }
+  }
+
+  /**
+   * Get current text from JSON parser and then write the text
+   * Note: Because JSON strings contains '\' to do escape,
+   * JSON parser should do unescape to remove '\' and JSON parser
+   * then can not return a pointer and length pair (char *, len),
+   * For number token, JSON parser can return a pair (char *, len)
+   */
+  __device__ void write_raw(json_parser& parser)
+  {
+    if (array_depth > 0) { is_curr_array_empty = false; }
+
+    if (nullptr != output) {
+      auto copied = parser.write_unescaped_text(output + output_len);
+      output_len += copied;
+    } else {
+      auto len = parser.compute_unescaped_len();
+      output_len += len;
+    }
+  }
+
+  /**
+   * write child raw value
+   * e.g.:
+   *
+   * write_outer_array_tokens = false
+   * need_comma = true
+   * [1,2,3]1,2,3
+   *        ^
+   *        |
+   *    child pointer
+   * ==>>
+   * [1,2,3],1,2,3
+   *
+   *
+   * write_outer_array_tokens = true
+   * need_comma = true
+   *   [12,3,4
+   *     ^
+   *     |
+   * child pointer
+   * ==>>
+   *   [1,[2,3,4]
+   *
+   * For more information about param write_outer_array_tokens, refer to
+   * `write_first_start_array_without_output`
+   * @param child_block_begin
+   * @param child_block_len
+   * @param write_outer_array_tokens whether write outer array tokens for child
+   * block
+   */
+  __device__ void write_child_raw_value(char* child_block_begin,
+                                        size_t child_block_len,
+                                        bool write_outer_array_tokens)
+  {
+    bool insert_comma = need_comma();
+
+    if (array_depth > 0) { is_curr_array_empty = false; }
+
+    if (nullptr != output) {
+      if (write_outer_array_tokens) {
+        if (insert_comma) {
+          *(child_block_begin + child_block_len + 2) = ']';
+          move_forward(child_block_begin, child_block_len, 2);
+          *(child_block_begin + 1) = '[';
+          *(child_block_begin)     = ',';
+        } else {
+          *(child_block_begin + child_block_len + 1) = ']';
+          move_forward(child_block_begin, child_block_len, 1);
+          *(child_block_begin) = '[';
+        }
+      } else {
+        if (insert_comma) {
+          move_forward(child_block_begin, child_block_len, 1);
+          *(child_block_begin) = ',';
+        } else {
+          // do not need comma && do not need write outer array tokens
+          // do nothing, because child generator buff is directly after the
+          // parent generator
+        }
+      }
+    }
+
+    // update length
+    if (insert_comma) { output_len++; }
+    if (write_outer_array_tokens) { output_len += 2; }
+    output_len += child_block_len;
+  }
+
+  // move memory block forward by specified bytes
+  // e.g.:  memory is: 1 2 0 0, begin is 1, len is 2, after moving,
+  // memory is: 1 2 1 2.
+  // e.g.:  memory is: 1 2 0 0, begin is 1, len is 1, after moving,
+  // memory is: 1 1 2 0.
+  // Note: should move from end to begin to avoid overwrite buffer
+  __device__ void move_forward(char* begin, size_t len, int forward)
+  {
+    // TODO copy by 8 bytes
+    char* pos = begin + len + forward - 1;
+    char* e   = begin + forward - 1;
+    while (pos > e) {
+      *pos = *(pos - forward);
+      pos--;
+    }
+  }
+
+  __device__ void reset() { output_len = 0; }
+
+  __device__ inline size_t get_output_len() const { return output_len; }
+  __device__ inline char* get_output_start_position() const { return output; }
+  __device__ inline char* get_current_output_position() const { return output + output_len; }
+
+  /**
+   * generator may contain trash output, e.g.: generator writes some output,
+   * then JSON format is invalid, the previous output becomes trash.
+   */
+  __device__ inline void set_output_len_zero() { output_len = 0; }
+
+  __device__ inline void set_output_len(size_t len) { output_len = len; }
+
+ private:
+  char* output;
+  size_t output_len;
+
+  // whether already worte a item in current array
+  // used to decide whether add a comma before writing out a new item.
+  bool is_curr_array_empty;
+  int array_depth = 0;
+};
+
+/**
+ * path evaluator which can run on both CPU and GPU
+ */
+__device__ inline bool path_is_empty(size_t path_size) { return path_size == 0; }
+
+__device__ inline bool path_match_element(path_instruction const* path_ptr,
+                                          size_t path_size,
+                                          path_instruction_type path_type0)
+{
+  if (path_size < 1) { return false; }
+  return path_ptr[0].type == path_type0;
+}
+
+__device__ inline bool path_match_elements(path_instruction const* path_ptr,
+                                           size_t path_size,
+                                           path_instruction_type path_type0,
+                                           path_instruction_type path_type1)
+{
+  if (path_size < 2) { return false; }
+  return path_ptr[0].type == path_type0 && path_ptr[1].type == path_type1;
+}
+
+__device__ inline bool path_match_elements(path_instruction const* path_ptr,
+                                           size_t path_size,
+                                           path_instruction_type path_type0,
+                                           path_instruction_type path_type1,
+                                           path_instruction_type path_type2,
+                                           path_instruction_type path_type3)
+{
+  if (path_size < 4) { return false; }
+  return path_ptr[0].type == path_type0 && path_ptr[1].type == path_type1 &&
+         path_ptr[2].type == path_type2 && path_ptr[3].type == path_type3;
+}
+
+__device__ inline thrust::tuple<bool, int> path_match_subscript_index(
+  path_instruction const* path_ptr, size_t path_size)
+{
+  auto match = path_match_elements(
+    path_ptr, path_size, path_instruction_type::SUBSCRIPT, path_instruction_type::INDEX);
+  if (match) {
+    return thrust::make_tuple(true, path_ptr[1].index);
+  } else {
+    return thrust::make_tuple(false, 0);
+  }
+}
+
+__device__ inline thrust::tuple<bool, cudf::string_view> path_match_named(
+  path_instruction const* path_ptr, size_t path_size)
+{
+  auto match = path_match_element(path_ptr, path_size, path_instruction_type::NAMED);
+  if (match) {
+    return thrust::make_tuple(true, path_ptr[0].name);
+  } else {
+    return thrust::make_tuple(false, cudf::string_view());
+  }
+}
+
+__device__ inline thrust::tuple<bool, int> path_match_subscript_index_subscript_wildcard(
+  path_instruction const* path_ptr, size_t path_size)
+{
+  auto match = path_match_elements(path_ptr,
+                                   path_size,
+                                   path_instruction_type::SUBSCRIPT,
+                                   path_instruction_type::INDEX,
+                                   path_instruction_type::SUBSCRIPT,
+                                   path_instruction_type::WILDCARD);
+  if (match) {
+    return thrust::make_tuple(true, path_ptr[1].index);
+  } else {
+    return thrust::make_tuple(false, 0);
+  }
+}
+
+/**
+ *
+ * The following commented function is recursive version,
+ * The next function below is the rewritten version,
+ * Keep version here is for review purpuse, because rewritten version(iterative)
+ * is not human friendly.
+ *
+ */
+// __device__ bool evaluate_path(json_parser& p,
+//                                            json_generator& g,
+//                                            write_style style,
+//                                            path_instruction const* path_ptr,
+//                                            int path_size)
+// {
+//   auto token = p.get_current_token();
+
+//   // case (VALUE_STRING, Nil) if style == RawStyle
+//   // case path 1
+//   if (json_token::VALUE_STRING == token && path_is_empty(path_size) &&
+//       style == write_style::raw_style) {
+//     // there is no array wildcard or slice parent, emit this string without
+//     // quotes write current string in parser to generator
+//     g.write_raw(p);
+//     return true;
+//   }
+//   // case (START_ARRAY, Nil) if style == FlattenStyle
+//   // case path 2
+//   else if (json_token::START_ARRAY == token && path_is_empty(path_size) &&
+//            style == write_style::flatten_style) {
+//     // flatten this array into the parent
+//     bool dirty = false;
+//     while (json_token::END_ARRAY != p.next_token()) {
+//       // JSON validation check
+//       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//       dirty |= path_evaluator::evaluate_path(p, g, style, nullptr, 0);
+//     }
+//     return dirty;
+//   }
+//   // case (_, Nil)
+//   // case path 3
+//   else if (path_is_empty(path_size)) {
+//     // general case: just copy the child tree verbatim
+//     return g.copy_current_structure(p);
+//   }
+//   // case (START_OBJECT, Key :: xs)
+//   // case path 4
+//   else if (json_token::START_OBJECT == token &&
+//            path_match_element(path_ptr, path_size, path_instruction_type::KEY)) {
+//     bool dirty = false;
+//     while (json_token::END_OBJECT != p.next_token()) {
+//       // JSON validation check
+//       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//       if (dirty) {
+//         // once a match has been found we can skip other fields
+//         if (!p.try_skip_children()) {
+//           // JSON validation check
+//           return false;
+//         }
+//       } else {
+//         dirty = path_evaluator::evaluate_path(p, g, style, path_ptr + 1, path_size - 1);
+//       }
+//     }
+//     return dirty;
+//   }
+//   // case (START_ARRAY, Subscript :: Wildcard :: Subscript :: Wildcard :: xs)
+//   // case path 5
+//   else if (json_token::START_ARRAY == token &&
+//            path_match_elements(path_ptr,
+//                                path_size,
+//                                path_instruction_type::SUBSCRIPT,
+//                                path_instruction_type::WILDCARD,
+//                                path_instruction_type::SUBSCRIPT,
+//                                path_instruction_type::WILDCARD)) {
+//     // special handling for the non-structure preserving double wildcard
+//     // behavior in Hive
+//     bool dirty = false;
+//     g.write_start_array();
+//     while (p.next_token() != json_token::END_ARRAY) {
+//       // JSON validation check
+//       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//       dirty |= path_evaluator::evaluate_path(
+//         p, g, write_style::flatten_style, path_ptr + 4, path_size - 4);
+//     }
+//     g.write_end_array();
+//     return dirty;
+//   }
+//   // case (START_ARRAY, Subscript :: Wildcard :: xs) if style != QuotedStyle
+//   // case path 6
+//   else if (json_token::START_ARRAY == token &&
+//            path_match_elements(path_ptr,
+//                                path_size,
+//                                path_instruction_type::SUBSCRIPT,
+//                                path_instruction_type::WILDCARD) &&
+//            style != write_style::quoted_style) {
+//     // retain Flatten, otherwise use Quoted... cannot use Raw within an array
+//     write_style next_style = write_style::raw_style;
+//     switch (style) {
+//       case write_style::raw_style: next_style = write_style::quoted_style; break;
+//       case write_style::flatten_style: next_style = write_style::flatten_style; break;
+//       case write_style::quoted_style: next_style = write_style::quoted_style;  // never happen
+//     }
+
+//     // temporarily buffer child matches, the emitted json will need to be
+//     // modified slightly if there is only a single element written
+
+//     int dirty = 0;
+//     // create a child generator with hide outer array tokens mode.
+//     auto child_g = g.new_child_generator(/*hide_outer_array_tokens*/ true);
+
+//     // Note: child generator does not actually write the outer start array
+//     // token into buffer it only updates internal nested state
+//     child_g.write_start_array();
+
+//     while (p.next_token() != json_token::END_ARRAY) {
+//       // JSON validation check
+//       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//       // track the number of array elements and only emit an outer array if
+//       // we've written more than one element, this matches Hive's behavior
+//       dirty +=
+//         (path_evaluator::evaluate_path(p, child_g, next_style, path_ptr + 2, path_size - 2) ? 1
+//                                                                                             :
+//                                                                                             0);
+//     }
+
+//     // Note: child generator does not actually write the outer end array token
+//     // into buffer it only updates internal nested state
+//     child_g.write_end_array();
+
+//     char* child_g_start = child_g.get_output_start_position();
+//     size_t child_g_len  = child_g.get_output_len();  // len already excluded outer [ ]
+
+//     if (dirty > 1) {
+//       // add outer array tokens
+//       g.write_child_raw_value(child_g_start, child_g_len, true);
+//     } else if (dirty == 1) {
+//       // remove outer array tokens
+//       g.write_child_raw_value(child_g_start, child_g_len, false);
+//     }  // else do not write anything
+
+//     return dirty > 0;
+//   }
+//   // case (START_ARRAY, Subscript :: Wildcard :: xs)
+//   // case path 7
+//   else if (json_token::START_ARRAY == token &&
+//            path_match_elements(path_ptr,
+//                                path_size,
+//                                path_instruction_type::SUBSCRIPT,
+//                                path_instruction_type::WILDCARD)) {
+//     bool dirty = false;
+//     g.write_start_array();
+//     while (p.next_token() != json_token::END_ARRAY) {
+//       // JSON validation check
+//       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//       // wildcards can have multiple matches, continually update the dirty
+//       // count
+//       dirty |= path_evaluator::evaluate_path(
+//         p, g, write_style::quoted_style, path_ptr + 2, path_size - 2);
+//     }
+//     g.write_end_array();
+
+//     return dirty;
+//   }
+//   /* case (START_ARRAY, Subscript :: Index(idx) :: (xs@Subscript :: Wildcard :: _)) */
+//   // case path 8
+//   else if (json_token::START_ARRAY == token &&
+//            thrust::get<0>(path_match_subscript_index_subscript_wildcard(path_ptr, path_size)))
+//            {
+//     int idx = thrust::get<1>(path_match_subscript_index_subscript_wildcard(path_ptr,
+//     path_size)); p.next_token();
+//     // JSON validation check
+//     if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//     int i = idx;
+//     while (i >= 0) {
+//       if (p.get_current_token() == json_token::END_ARRAY) {
+//         // terminate, nothing has been written
+//         return false;
+//       }
+//       if (0 == i) {
+//         bool dirty = path_evaluator::evaluate_path(
+//           p, g, write_style::quoted_style, path_ptr + 2, path_size - 2);
+//         while (p.next_token() != json_token::END_ARRAY) {
+//           // JSON validation check
+//           if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//           // advance the token stream to the end of the array
+//           if (!p.try_skip_children()) { return false; }
+//         }
+//         return dirty;
+//       } else {
+//         // i > 0
+//         if (!p.try_skip_children()) { return false; }
+
+//         p.next_token();
+//         // JSON validation check
+//         if (json_token::ERROR == p.get_current_token()) { return false; }
+//       }
+//       --i;
+//     }
+//     // path parser guarantees idx >= 0
+//     // will never reach to here
+//     return false;
+//   }
+//   // case (START_ARRAY, Subscript :: Index(idx) :: xs)
+//   // case path 9
+//   else if (json_token::START_ARRAY == token &&
+//            thrust::get<0>(path_match_subscript_index(path_ptr, path_size))) {
+//     int idx = thrust::get<1>(path_match_subscript_index(path_ptr, path_size));
+//     p.next_token();
+//     // JSON validation check
+//     if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//     int i = idx;
+//     while (i >= 0) {
+//       if (p.get_current_token() == json_token::END_ARRAY) {
+//         // terminate, nothing has been written
+//         return false;
+//       }
+//       if (0 == i) {
+//         bool dirty = path_evaluator::evaluate_path(p, g, style, path_ptr + 2, path_size - 2);
+//         while (p.next_token() != json_token::END_ARRAY) {
+//           // JSON validation check
+//           if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//           // advance the token stream to the end of the array
+//           if (!p.try_skip_children()) { return false; }
+//         }
+//         return dirty;
+//       } else {
+//         // i > 0
+//         if (!p.try_skip_children()) { return false; }
+
+//         p.next_token();
+//         // JSON validation check
+//         if (json_token::ERROR == p.get_current_token()) { return false; }
+//       }
+//       --i;
+//     }
+//     // path parser guarantees idx >= 0
+//     // will never reach to here
+//     return false;
+//   }
+//   // case (FIELD_NAME, Named(name) :: xs) if p.getCurrentName == name
+//   // case path 10
+//   else if (json_token::FIELD_NAME == token &&
+//            thrust::get<0>(path_match_named(path_ptr, path_size)) &&
+//            p.match_current_field_name(thrust::get<1>(path_match_named(path_ptr, path_size)))) {
+//     if (p.next_token() != json_token::VALUE_NULL) {
+//       // JSON validation check
+//       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//       return path_evaluator::evaluate_path(p, g, style, path_ptr + 1, path_size - 1);
+//     } else {
+//       return false;
+//     }
+//   }
+//   // case (FIELD_NAME, Wildcard :: xs)
+//   // case path 11
+//   else if (json_token::FIELD_NAME == token &&
+//            path_match_element(path_ptr, path_size, path_instruction_type::WILDCARD)) {
+//     p.next_token();
+//     // JSON validation check
+//     if (json_token::ERROR == p.get_current_token()) { return false; }
+
+//     return path_evaluator::evaluate_path(p, g, style, path_ptr + 1, path_size - 1);
+//   }
+//   // case _ =>
+//   // case path 12
+//   else {
+//     if (!p.try_skip_children()) { return false; }
+//     return false;
+//   }
+// }
+
+/**
+ *
+ * This function is rewritten from above commented recursive function.
+ * this function is equivalent to the above commented recursive function.
+ */
+__device__ bool evaluate_path(json_parser& p,
+                              json_generator& root_g,
+                              write_style root_style,
+                              path_instruction const* root_path_ptr,
+                              int root_path_size)
+{
+  // manually maintained context stack in lieu of calling evaluate_path recursively.
+  struct context {
+    // current token
+    json_token token;
+
+    // which case path that this task is from
+    int case_path;
+
+    // used to save current generator
+    json_generator g;
+
+    write_style style;
+    path_instruction const* path_ptr;
+    int path_size;
+
+    // is this context task is done
+    bool task_is_done;
+
+    // whether written output
+    // if dirty > 0, indicates success
+    int dirty;
+
+    // for some case paths
+    bool is_first_enter;
+
+    // used to save child JSON generator for case path 8
+    json_generator child_g;
+  };
+
+  // path max depth limitation
+  // There is a same constant in JSONUtil.java, keep them consistent when changing
+  // Note: Spark-Rapids should guarantee the path depth is less or equal to this limit,
+  // or GPU reports cudaErrorIllegalAddress
+  constexpr int max_path_depth = 16;
+
+  // define stack; plus 1 indicates root context task needs an extra memory
+  context stack[max_path_depth + 1];
+  int stack_pos = 0;
+
+  // push context function
+  auto push_context = [&stack, &stack_pos](json_token _token,
+                                           int _case_path,
+                                           json_generator _g,
+                                           write_style _style,
+                                           path_instruction const* _path_ptr,
+                                           int _path_size) {
+    // no need to check stack is full
+    // because Spark-Rapids already checked maximum length of `path_instruction`
+    auto& ctx          = stack[stack_pos];
+    ctx.token          = _token;
+    ctx.case_path      = _case_path;
+    ctx.g              = _g;
+    ctx.style          = _style;
+    ctx.path_ptr       = _path_ptr;
+    ctx.path_size      = _path_size;
+    ctx.task_is_done   = false;
+    ctx.dirty          = 0;
+    ctx.is_first_enter = true;
+
+    stack_pos++;
+  };
+
+  // put the first context task
+  push_context(p.get_current_token(), -1, root_g, root_style, root_path_ptr, root_path_size);
+
+  while (stack_pos > 0) {
+    auto& ctx = stack[stack_pos - 1];
+    if (!ctx.task_is_done) {
+      // task is not done.
+
+      // case (VALUE_STRING, Nil) if style == RawStyle
+      // case path 1
+      if (json_token::VALUE_STRING == ctx.token && path_is_empty(ctx.path_size) &&
+          ctx.style == write_style::raw_style) {
+        // there is no array wildcard or slice parent, emit this string without
+        // quotes write current string in parser to generator
+        ctx.g.write_raw(p);
+        ctx.dirty        = 1;
+        ctx.task_is_done = true;
+      }
+      // case (START_ARRAY, Nil) if style == FlattenStyle
+      // case path 2
+      else if (json_token::START_ARRAY == ctx.token && path_is_empty(ctx.path_size) &&
+               ctx.style == write_style::flatten_style) {
+        // flatten this array into the parent
+        if (json_token::END_ARRAY != p.next_token()) {
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+          // push back task
+          // add child task
+          push_context(p.get_current_token(), 2, ctx.g, ctx.style, nullptr, 0);
+        } else {
+          // END_ARRAY
+          ctx.task_is_done = true;
+        }
+      }
+      // case (_, Nil)
+      // case path 3
+      else if (path_is_empty(ctx.path_size)) {
+        // general case: just copy the child tree verbatim
+        if (!(ctx.g.copy_current_structure(p))) {
+          // JSON validation check
+          return false;
+        }
+        ctx.dirty        = 1;
+        ctx.task_is_done = true;
+      }
+      // case (START_OBJECT, Key :: xs)
+      // case path 4
+      else if (json_token::START_OBJECT == ctx.token &&
+               path_match_element(ctx.path_ptr, ctx.path_size, path_instruction_type::KEY)) {
+        if (json_token::END_OBJECT != p.next_token()) {
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+
+          if (ctx.dirty > 0) {
+            // once a match has been found we can skip other fields
+            if (!p.try_skip_children()) {
+              // JSON validation check
+              return false;
+            }
+          } else {
+            // need to try more children
+            push_context(
+              p.get_current_token(), 4, ctx.g, ctx.style, ctx.path_ptr + 1, ctx.path_size - 1);
+          }
+        } else {
+          ctx.task_is_done = true;
+        }
+      }
+      // case (START_ARRAY, Subscript :: Wildcard :: Subscript :: Wildcard :: xs)
+      // case path 5
+      else if (json_token::START_ARRAY == ctx.token &&
+               path_match_elements(ctx.path_ptr,
+                                   ctx.path_size,
+                                   path_instruction_type::SUBSCRIPT,
+                                   path_instruction_type::WILDCARD,
+                                   path_instruction_type::SUBSCRIPT,
+                                   path_instruction_type::WILDCARD)) {
+        // special handling for the non-structure preserving double wildcard
+        // behavior in Hive
+        if (ctx.is_first_enter) {
+          ctx.is_first_enter = false;
+          ctx.g.write_start_array();
+        }
+
+        if (p.next_token() != json_token::END_ARRAY) {
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+          push_context(p.get_current_token(),
+                       5,
+                       ctx.g,
+                       write_style::flatten_style,
+                       ctx.path_ptr + 4,
+                       ctx.path_size - 4);
+        } else {
+          ctx.g.write_end_array();
+          ctx.task_is_done = true;
+        }
+      }
+      // case (START_ARRAY, Subscript :: Wildcard :: xs) if style != QuotedStyle
+      // case path 6
+      else if (json_token::START_ARRAY == ctx.token &&
+               path_match_elements(ctx.path_ptr,
+                                   ctx.path_size,
+                                   path_instruction_type::SUBSCRIPT,
+                                   path_instruction_type::WILDCARD) &&
+               ctx.style != write_style::quoted_style) {
+        // retain Flatten, otherwise use Quoted... cannot use Raw within an array
+        write_style next_style = write_style::raw_style;
+        switch (ctx.style) {
+          case write_style::raw_style: next_style = write_style::quoted_style; break;
+          case write_style::flatten_style: next_style = write_style::flatten_style; break;
+          case write_style::quoted_style: next_style = write_style::quoted_style;  // never happen
+        }
+
+        // temporarily buffer child matches, the emitted json will need to be
+        // modified slightly if there is only a single element written
+
+        json_generator child_g;
+        if (ctx.is_first_enter) {
+          ctx.is_first_enter = false;
+          // create a child generator with hide outer array tokens mode.
+          child_g = ctx.g.new_child_generator();
+          // write first [ without output, without update len, only update internal state
+          child_g.write_first_start_array_without_output();
+        } else {
+          child_g = ctx.child_g;
+        }
+
+        if (p.next_token() != json_token::END_ARRAY) {
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+          // track the number of array elements and only emit an outer array if
+          // we've written more than one element, this matches Hive's behavior
+          push_context(
+            p.get_current_token(), 6, child_g, next_style, ctx.path_ptr + 2, ctx.path_size - 2);
+        } else {
+          char* child_g_start = child_g.get_output_start_position();
+          size_t child_g_len  = child_g.get_output_len();
+
+          if (ctx.dirty > 1) {
+            // add outer array tokens
+            ctx.g.write_child_raw_value(
+              child_g_start, child_g_len, /* write_outer_array_tokens */ true);
+            ctx.task_is_done = true;
+          } else if (ctx.dirty == 1) {
+            // remove outer array tokens
+            ctx.g.write_child_raw_value(
+              child_g_start, child_g_len, /* write_outer_array_tokens */ false);
+            ctx.task_is_done = true;
+          }  // else do not write anything
+        }
+      }
+      // case (START_ARRAY, Subscript :: Wildcard :: xs)
+      // case path 7
+      else if (json_token::START_ARRAY == ctx.token &&
+               path_match_elements(ctx.path_ptr,
+                                   ctx.path_size,
+                                   path_instruction_type::SUBSCRIPT,
+                                   path_instruction_type::WILDCARD)) {
+        if (ctx.is_first_enter) {
+          ctx.is_first_enter = false;
+          ctx.g.write_start_array();
+        }
+
+        if (p.next_token() != json_token::END_ARRAY) {
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+
+          // wildcards can have multiple matches, continually update the dirty
+          // count
+          push_context(p.get_current_token(),
+                       7,
+                       ctx.g,
+                       write_style::quoted_style,
+                       ctx.path_ptr + 2,
+                       ctx.path_size - 2);
+        } else {
+          ctx.g.write_end_array();
+          ctx.task_is_done = true;
+        }
+      }
+      /* case (START_ARRAY, Subscript :: Index(idx) :: (xs@Subscript :: Wildcard :: _)) */
+      // case path 8
+      else if (json_token::START_ARRAY == ctx.token &&
+               thrust::get<0>(
+                 path_match_subscript_index_subscript_wildcard(ctx.path_ptr, ctx.path_size))) {
+        int idx = thrust::get<1>(
+          path_match_subscript_index_subscript_wildcard(ctx.path_ptr, ctx.path_size));
+
+        p.next_token();
+        // JSON validation check
+        if (json_token::ERROR == p.get_current_token()) { return false; }
+        ctx.is_first_enter = false;
+
+        int i = idx;
+        while (i > 0) {
+          if (p.get_current_token() == json_token::END_ARRAY) {
+            // terminate, nothing has been written
+            return false;
+          }
+
+          if (!p.try_skip_children()) { return false; }
+
+          p.next_token();
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+
+          --i;
+        }
+
+        // i == 0
+        push_context(p.get_current_token(),
+                     8,
+                     ctx.g,
+                     write_style::quoted_style,
+                     ctx.path_ptr + 2,
+                     ctx.path_size - 2);
+      }
+      // case (START_ARRAY, Subscript :: Index(idx) :: xs)
+      // case path 9
+      else if (json_token::START_ARRAY == ctx.token &&
+               thrust::get<0>(path_match_subscript_index(ctx.path_ptr, ctx.path_size))) {
+        int idx = thrust::get<1>(path_match_subscript_index(ctx.path_ptr, ctx.path_size));
+
+        p.next_token();
+        // JSON validation check
+        if (json_token::ERROR == p.get_current_token()) { return false; }
+
+        int i = idx;
+        while (i > 0) {
+          if (p.get_current_token() == json_token::END_ARRAY) {
+            // terminate, nothing has been written
+            return false;
+          }
+
+          if (!p.try_skip_children()) { return false; }
+
+          p.next_token();
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+
+          --i;
+        }
+
+        // i == 0
+        push_context(
+          p.get_current_token(), 9, ctx.g, ctx.style, ctx.path_ptr + 2, ctx.path_size - 2);
+      }
+      // case (FIELD_NAME, Named(name) :: xs) if p.getCurrentName == name
+      // case path 10
+      else if (json_token::FIELD_NAME == ctx.token &&
+               thrust::get<0>(path_match_named(ctx.path_ptr, ctx.path_size)) &&
+               p.match_current_field_name(
+                 thrust::get<1>(path_match_named(ctx.path_ptr, ctx.path_size)))) {
+        if (p.next_token() != json_token::VALUE_NULL) {
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+          push_context(
+            p.get_current_token(), 10, ctx.g, ctx.style, ctx.path_ptr + 1, ctx.path_size - 1);
+        } else {
+          return false;
+        }
+      }
+      // case (FIELD_NAME, Wildcard :: xs)
+      // case path 11
+      else if (json_token::FIELD_NAME == ctx.token &&
+               path_match_element(ctx.path_ptr, ctx.path_size, path_instruction_type::WILDCARD)) {
+        p.next_token();
+        // JSON validation check
+        if (json_token::ERROR == p.get_current_token()) { return false; }
+        push_context(
+          p.get_current_token(), 11, ctx.g, ctx.style, ctx.path_ptr + 1, ctx.path_size - 1);
+      }
+      // case _ =>
+      // case path 12
+      else {
+        if (!p.try_skip_children()) { return false; }
+        // default case path, return false for this task
+        ctx.dirty        = 0;
+        ctx.task_is_done = true;
+      }
+    } else {
+      // current context is done.
+
+      // pop current top context
+      stack_pos--;
+
+      // pop parent task
+      // update parent task info according to current task result
+      if (stack_pos > 0) {
+        // peek parent context task
+        auto& p_ctx = stack[stack_pos - 1];
+
+        // case (VALUE_STRING, Nil) if style == RawStyle
+        // case path 1
+        if (1 == ctx.case_path) {
+          // never happen
+        }
+        // path 2: case (START_ARRAY, Nil) if style == FlattenStyle
+        // path 5: case (START_ARRAY, Subscript :: Wildcard :: Subscript :: Wildcard :: xs)
+        // path 7: case (START_ARRAY, Subscript :: Wildcard :: xs)
+        else if (2 == ctx.case_path || 5 == ctx.case_path || 7 == ctx.case_path) {
+          // collect result from child task
+          p_ctx.dirty += ctx.dirty;
+          // copy generator states to parent task;
+          p_ctx.g = ctx.g;
+        }
+        // case (START_OBJECT, Key :: xs)
+        // case path 4
+        else if (4 == ctx.case_path) {
+          if (p_ctx.dirty < 1 && ctx.dirty > 0) { p_ctx.dirty = ctx.dirty; }
+          // copy generator states to parent task;
+          p_ctx.g = ctx.g;
+        }
+        // case (START_ARRAY, Subscript :: Wildcard :: xs) if style != QuotedStyle
+        // case path 6
+        else if (6 == ctx.case_path) {
+          // collect result from child task
+          p_ctx.dirty += ctx.dirty;
+          // update child generator for parent task
+          p_ctx.child_g = ctx.g;
+        }
+        /* case (START_ARRAY, Subscript :: Index(idx) :: (xs@Subscript :: Wildcard :: _)) */
+        // case path 8
+        // case (START_ARRAY, Subscript :: Index(idx) :: xs)
+        // case path 9
+        else if (8 == ctx.case_path || 9 == ctx.case_path) {
+          // collect result from child task
+          p_ctx.dirty += ctx.dirty;
+
+          // post logic:
+          while (p.next_token() != json_token::END_ARRAY) {
+            // JSON validation check
+            if (json_token::ERROR == p.get_current_token()) { return false; }
+            // advance the token stream to the end of the array
+            if (!p.try_skip_children()) { return false; }
+          }
+          // task is done
+          p_ctx.task_is_done = true;
+          // copy generator states to parent task;
+          p_ctx.g = ctx.g;
+        }
+        // case (FIELD_NAME, Named(name) :: xs) if p.getCurrentName == name
+        // case path 10
+        else if (10 == ctx.case_path) {
+          // collect result from child task
+          p_ctx.dirty += ctx.dirty;
+          // task is done
+          p_ctx.task_is_done = true;
+          // copy generator states to parent task;
+          p_ctx.g = ctx.g;
+        }
+        // case (FIELD_NAME, Wildcard :: xs)
+        // case path 11
+        else if (11 == ctx.case_path) {
+          // collect result from child task
+          p_ctx.dirty += ctx.dirty;
+          // task is done
+          p_ctx.task_is_done = true;
+          // copy generator states to parent task;
+          p_ctx.g = ctx.g;
+        }
+        // case path 3: case (_, Nil)
+        // case path 12: case _ =>
+        // others
+        else {
+          // never happen
+        }
+      } else {
+        // has no parent task, stack is empty, will exit
+      }
+    }
+  }
+
+  // copy output len
+  root_g.set_output_len(stack[0].g.get_output_len());
+  return stack[0].dirty > 0;
+}
+
+rmm::device_uvector<path_instruction> construct_path_commands(
+  std::vector<std::tuple<path_instruction_type, std::string, int64_t>> const& instructions,
+  cudf::string_scalar const& all_names_scalar,
+  rmm::cuda_stream_view stream,
+  rmm::mr::device_memory_resource* mr)
+{
+  int name_pos = 0;
+
+  // construct the path commands
+  std::vector<path_instruction> path_commands;
+  for (auto const& inst : instructions) {
+    auto const& [type, name, index] = inst;
+    switch (type) {
+      case path_instruction_type::SUBSCRIPT:
+        path_commands.emplace_back(path_instruction{path_instruction_type::SUBSCRIPT});
+        break;
+      case path_instruction_type::WILDCARD:
+        path_commands.emplace_back(path_instruction{path_instruction_type::WILDCARD});
+        break;
+      case path_instruction_type::KEY:
+        path_commands.emplace_back(path_instruction{path_instruction_type::KEY});
+        path_commands.back().name =
+          cudf::string_view(all_names_scalar.data() + name_pos, name.size());
+        name_pos += name.size();
+        break;
+      case path_instruction_type::INDEX:
+        path_commands.emplace_back(path_instruction{path_instruction_type::INDEX});
+        path_commands.back().index = index;
+        break;
+      case path_instruction_type::NAMED:
+        path_commands.emplace_back(path_instruction{path_instruction_type::NAMED});
+        path_commands.back().name =
+          cudf::string_view(all_names_scalar.data() + name_pos, name.size());
+        name_pos += name.size();
+        break;
+      default: CUDF_FAIL("Invalid path instruction type");
+    }
+  }
+  // convert to uvector
+  return cudf::detail::make_device_uvector_sync(path_commands, stream, mr);
+}
+
+/**
+ * @brief Parse a single json string using the provided command buffer
+ *
+ *
+ * @param input The incoming json string
+ * @param input_len Size of the incoming json string
+ * @param path_commands_ptr The command buffer to be applied to the string.
+ * @param path_commands_size The command buffer size.
+ * @param out_buf Buffer user to store the results of the query
+ *                (nullptr in the size computation step)
+ * @param out_buf_size Size of the output buffer
+ * @returns A pair containing the result code and the output buffer.
+ */
+__device__ thrust::pair<bool, size_t> get_json_object_single(
+  char const* input,
+  cudf::size_type input_len,
+  path_instruction const* path_commands_ptr,
+  int path_commands_size,
+  char* out_buf,
+  size_t out_buf_size)
+{
+  json_parser j_parser(input, input_len);
+  j_parser.next_token();
+  // JSON validation check
+  if (json_token::ERROR == j_parser.get_current_token()) { return {false, 0}; }
+
+  // First pass: preprocess sizes.
+  // Second pass: writes output.
+  // The generator automatically determines which pass based on `out_buf`.
+  // If `out_buf_size` is zero, pass in `nullptr` to avoid generator writing trash output.
+  json_generator generator((out_buf == nullptr || out_buf_size == 0) ? nullptr : out_buf);
+
+  bool const success = evaluate_path(
+    j_parser, generator, write_style::raw_style, path_commands_ptr, path_commands_size);
+
+  if (nullptr == out_buf && !success) {
+    // generator may contain trash output, e.g.: generator writes some output,
+    // then JSON format is invalid, the previous output becomes trash.
+    // set output as zero to tell second step
+    generator.set_output_len_zero();
+  }
+
+  return {success, generator.get_output_len()};
+}
+
+/**
+ * @brief Kernel for running the JSONPath query.
+ *
+ * This kernel operates in a 2-pass way. On the first pass it computes the
+ * output sizes. On the second pass, it fills in the provided output buffers
+ * (chars and validity).
+ *
+ * @param col Device view of the incoming string
+ * @param commands JSONPath command buffer
+ * @param output_offsets Buffer used to store the string offsets for the results
+ *        of the query
+ * @param out_buf Buffer used to store the results of the query
+ * @param out_validity Output validity buffer
+ * @param out_valid_count Output count of # of valid bits
+ * @param options Options controlling behavior
+ */
+template <int block_size>
+__launch_bounds__(block_size) CUDF_KERNEL
+  void get_json_object_kernel(cudf::column_device_view col,
+                              path_instruction const* path_commands_ptr,
+                              int path_commands_size,
+                              cudf::size_type* d_sizes,
+                              cudf::detail::input_offsetalator output_offsets,
+                              char* out_buf,
+                              cudf::bitmask_type* out_validity,
+                              cudf::size_type* out_valid_count)
+{
+  auto tid          = cudf::detail::grid_1d::global_thread_id();
+  auto const stride = cudf::detail::grid_1d::grid_stride();
+
+  cudf::size_type warp_valid_count{0};
+
+  auto active_threads = __ballot_sync(0xffff'ffffu, tid < col.size());
+  while (tid < col.size()) {
+    bool is_valid               = false;
+    cudf::string_view const str = col.element<cudf::string_view>(tid);
+    if (str.size_bytes() > 0) {
+      char* dst = out_buf != nullptr ? out_buf + output_offsets[tid] : nullptr;
+      size_t const dst_size =
+        out_buf != nullptr ? output_offsets[tid + 1] - output_offsets[tid] : 0;
+
+      // process one single row
+      auto [result, output_size] = get_json_object_single(
+        str.data(), str.size_bytes(), path_commands_ptr, path_commands_size, dst, dst_size);
+      if (result) { is_valid = true; }
+
+      // filled in only during the precompute step. during the compute step, the
+      // offsets are fed back in so we do -not- want to write them out
+      if (out_buf == nullptr) { d_sizes[tid] = static_cast<cudf::size_type>(output_size); }
+    } else {
+      // valid JSON length is always greater than 0
+      // if `str` size len is zero, output len is 0 and `is_valid` is false
+      if (out_buf == nullptr) { d_sizes[tid] = 0; }
+    }
+
+    // validity filled in only during the output step
+    if (out_validity != nullptr) {
+      uint32_t mask = __ballot_sync(active_threads, is_valid);
+      // 0th lane of the warp writes the validity
+      if (!(tid % cudf::detail::warp_size)) {
+        out_validity[cudf::word_index(tid)] = mask;
+        warp_valid_count += __popc(mask);
+      }
+    }
+
+    tid += stride;
+    active_threads = __ballot_sync(active_threads, tid < col.size());
+  }
+
+  // sum the valid counts across the whole block
+  if (out_valid_count != nullptr) {
+    cudf::size_type block_valid_count =
+      cudf::detail::single_lane_block_sum_reduce<block_size, 0>(warp_valid_count);
+    if (threadIdx.x == 0) { atomicAdd(out_valid_count, block_valid_count); }
+  }
+}
+
+std::unique_ptr<cudf::column> get_json_object(
+  cudf::strings_column_view const& input,
+  std::vector<std::tuple<path_instruction_type, std::string, int64_t>> const& instructions,
+  rmm::cuda_stream_view stream,
+  rmm::mr::device_memory_resource* mr)
+{
+  if (input.is_empty()) return cudf::make_empty_column(cudf::type_id::STRING);
+
+  // get a string buffer to store all the names and convert to device
+  std::string all_names;
+  for (auto const& inst : instructions) {
+    all_names += std::get<1>(inst);
+  }
+  cudf::string_scalar all_names_scalar(all_names, true, stream);
+  // parse the json_path into a command buffer
+  auto path_commands = construct_path_commands(
+    instructions, all_names_scalar, stream, rmm::mr::get_current_device_resource());
+
+  // compute output sizes
+  auto sizes = rmm::device_uvector<cudf::size_type>(
+    input.size(), stream, rmm::mr::get_current_device_resource());
+  auto d_offsets = cudf::detail::offsetalator_factory::make_input_iterator(input.offsets());
+
+  constexpr int block_size = 512;
+  cudf::detail::grid_1d const grid{input.size(), block_size};
+  auto d_input_ptr = cudf::column_device_view::create(input.parent(), stream);
+  // preprocess sizes (returned in the offsets buffer)
+  get_json_object_kernel<block_size>
+    <<<grid.num_blocks, grid.num_threads_per_block, 0, stream.value()>>>(*d_input_ptr,
+                                                                         path_commands.data(),
+                                                                         path_commands.size(),
+                                                                         sizes.data(),
+                                                                         d_offsets,
+                                                                         nullptr,
+                                                                         nullptr,
+                                                                         nullptr);
+
+  // convert sizes to offsets
+  auto [offsets, output_size] =
+    cudf::strings::detail::make_offsets_child_column(sizes.begin(), sizes.end(), stream, mr);
+  d_offsets = cudf::detail::offsetalator_factory::make_input_iterator(offsets->view());
+
+  // allocate output string column
+  rmm::device_uvector<char> chars(output_size, stream, mr);
+
+  // potential optimization : if we know that all outputs are valid, we could
+  // skip creating the validity mask altogether
+  rmm::device_buffer validity =
+    cudf::detail::create_null_mask(input.size(), cudf::mask_state::UNINITIALIZED, stream, mr);
+
+  // compute results
+  rmm::device_scalar<cudf::size_type> d_valid_count{0, stream};
+
+  get_json_object_kernel<block_size>
+    <<<grid.num_blocks, grid.num_threads_per_block, 0, stream.value()>>>(
+      *d_input_ptr,
+      path_commands.data(),
+      path_commands.size(),
+      sizes.data(),
+      d_offsets,
+      chars.data(),
+      static_cast<cudf::bitmask_type*>(validity.data()),
+      d_valid_count.data());
+
+  return make_strings_column(input.size(),
+                             std::move(offsets),
+                             chars.release(),
+                             input.size() - d_valid_count.value(stream),
+                             std::move(validity));
+}
+
+}  // namespace detail
+
+std::unique_ptr<cudf::column> get_json_object(
+  cudf::strings_column_view const& input,
+  std::vector<std::tuple<path_instruction_type, std::string, int64_t>> const& instructions,
+  rmm::cuda_stream_view stream,
+  rmm::mr::device_memory_resource* mr)
+{
+  return detail::get_json_object(input, instructions, stream, mr);
+}
+
+}  // namespace spark_rapids_jni
diff --git a/src/main/cpp/src/get_json_object.hpp b/src/main/cpp/src/get_json_object.hpp
new file mode 100644
index 0000000000..cf1f0c3470
--- /dev/null
+++ b/src/main/cpp/src/get_json_object.hpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed 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.
+ */
+
+#pragma once
+
+#include "json_parser.cuh"
+
+#include <cudf/strings/string_view.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+
+#include <thrust/optional.h>
+#include <thrust/pair.h>
+#include <thrust/scan.h>
+#include <thrust/tuple.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace spark_rapids_jni {
+
+/**
+ * path instruction type
+ */
+enum class path_instruction_type { SUBSCRIPT, WILDCARD, KEY, INDEX, NAMED };
+
+/**
+ * Extracts json object from a json string based on json path specified, and
+ * returns json string of the extracted json object. It will return null if the
+ * input json string is invalid.
+ */
+std::unique_ptr<cudf::column> get_json_object(
+  cudf::strings_column_view const& input,
+  std::vector<std::tuple<path_instruction_type, std::string, int64_t>> const& instructions,
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+}  // namespace spark_rapids_jni
diff --git a/src/main/cpp/src/json_parser.cuh b/src/main/cpp/src/json_parser.cuh
new file mode 100644
index 0000000000..ec0790aa6b
--- /dev/null
+++ b/src/main/cpp/src/json_parser.cuh
@@ -0,0 +1,1815 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed 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.
+ */
+#pragma once
+
+#include "ftos_converter.cuh"
+#include "string_to_float_cudf.cuh"
+
+#include <cudf/strings/detail/convert/string_to_float.cuh>
+#include <cudf/strings/string_view.hpp>
+#include <cudf/types.hpp>
+
+#include <thrust/pair.h>
+#include <thrust/tuple.h>
+
+namespace spark_rapids_jni {
+
+/**
+ * write style when writing out JSON string
+ */
+enum class write_style {
+  // e.g.: '\\r' is a string with 2 chars '\' 'r', writes 1 char '\r'
+  unescaped,
+
+  // * e.g.: '"' is a string with 1 char '"', writes out 4 chars '"' '\' '\"'
+  // '"'
+  escaped
+};
+
+// allow single quotes to represent strings in JSON
+// e.g.: {'k': 'v'} is valid when it's true
+constexpr bool allow_single_quotes = true;
+
+// Whether allow unescaped control characters in JSON Strings.
+// Unescaped control characters are ASCII characters with value less than 32,
+// including tab and line feed characters. ASCII values range is [0, 32)
+// e.g.: ["\n"] is valid, here \n is one char
+// If true, JSON is not conventional format.
+// e.g., how to represent carriage return and newline characters:
+//   if true, allow "\n\r" two control characters without escape directly
+//   if false, "\n\r" are not allowed, should use escape characters: "\\n\\r"
+constexpr bool allow_unescaped_control_chars = true;
+
+/**
+ * @brief Maximum JSON nesting depth
+ * JSON with a greater depth is invalid
+ * If set this to be a greater value, should update `context_stack`
+ */
+constexpr int max_json_nesting_depth = 64;
+
+// Define the maximum JSON String length, counts utf8 bytes.
+// By default, maximum JSON String length is negative one, means no
+// limitation. e.g.: The length of String "\\n" is 1, JSON parser does not
+// count escape characters.
+constexpr int max_string_utf8_bytes = 20000000;
+
+//
+/**
+ * Define the maximum JSON number length. Negative or zero means no
+ * limitation.
+ *
+ * By default, maximum JSON number length is negative one, means no
+ * limitation.
+ *
+ * e.g.: The length of number -123.45e-67 is 7. if maximum JSON number length
+ * is 6, then this number is a invalid number.
+ */
+constexpr int max_num_len = 1000;
+
+/**
+ * whether allow tailing useless sub-string in JSON.
+ *
+ * If true, e.g., the following invalid JSON is allowed, because prefix {'k' :
+ * 'v'} is valid.
+ *   {'k' : 'v'}_extra_tail_sub_string
+ */
+constexpr bool allow_tailing_sub_string = true;
+
+/**
+ * JSON token enum
+ */
+enum class json_token {
+  // start token
+  INIT = 0,
+
+  // successfully parsed the whole JSON string
+  SUCCESS,
+
+  // get error when parsing JSON string
+  ERROR,
+
+  // '{'
+  START_OBJECT,
+
+  // '}'
+  END_OBJECT,
+
+  // '['
+  START_ARRAY,
+
+  // ']'
+  END_ARRAY,
+
+  // e.g.: key1 in {"key1" : "value1"}
+  FIELD_NAME,
+
+  // e.g.: value1 in {"key1" : "value1"}
+  VALUE_STRING,
+
+  // e.g.: 123 in {"key1" : 123}
+  VALUE_NUMBER_INT,
+
+  // e.g.: 1.25 in {"key1" : 1.25}
+  VALUE_NUMBER_FLOAT,
+
+  // e.g.: true in {"key1" : true}
+  VALUE_TRUE,
+
+  // e.g.: false in {"key1" : false}
+  VALUE_FALSE,
+
+  // e.g.: null in {"key1" : null}
+  VALUE_NULL
+
+};
+
+/**
+ * JSON parser, provides token by token parsing.
+ * Follow Jackson JSON format by default.
+ *
+ *
+ * For JSON format:
+ * Refer to https://www.json.org/json-en.html.
+ *
+ * Note: when setting `allow_single_quotes` or `allow_unescaped_control_chars`,
+ * then JSON format is not conventional.
+ *
+ * White space can only be 4 chars: ' ', '\n', '\r', '\t',
+ * Jackson does not allow other control chars as white spaces.
+ *
+ * Valid number examples:
+ *   0, 102, -0, -102, 0.3, -0.3
+ *   1e-5, 1E+5, 1e0, 1E0, 1.3e5
+ *   1e01 : allow leading zeor after 'e'
+ *
+ * Invalid number examples:
+ *   00, -00   Leading zeroes not allowed
+ *   infinity, +infinity, -infinity
+ *   1e, 1e+, 1e-, -1., 1.
+ *
+ * When `allow_single_quotes` is true:
+ *   Valid string examples:
+ *     "\'" , "\"" ,  '\'' , '\"' , '"' , "'"
+ *
+ *  When `allow_single_quotes` is false:
+ *   Invalid string examples:
+ *     "\'"
+ *
+ *  When `allow_unescaped_control_chars` is true:
+ *    Valid string: "asscii_control_chars"
+ *      here `asscii_control_chars` represents control chars which in Ascii code
+ * range: [0, 32)
+ *
+ *  When `allow_unescaped_control_chars` is false:
+ *    Invalid string: "asscii_control_chars"
+ *      here `asscii_control_chars` represents control chars which in Ascii code
+ * range: [0, 32)
+ *
+ */
+class json_parser {
+ public:
+  __device__ inline json_parser(char const* const _json_start_pos, cudf::size_type const _json_len)
+    : json_start_pos(_json_start_pos),
+      json_end_pos(_json_start_pos + _json_len),
+      curr_pos(_json_start_pos)
+  {
+  }
+
+ private:
+  /**
+   * @brief get the bit value for specified bit from a int64 number
+   */
+  __device__ inline bool get_bit_value(int64_t number, int bitIndex)
+  {
+    // Shift the number right by the bitIndex to bring the desired bit to the rightmost position
+    long shifted = number >> bitIndex;
+
+    // Extract the rightmost bit by performing a bitwise AND with 1
+    bool bit_value = shifted & 1;
+
+    return bit_value;
+  }
+
+  /**
+   * @brief set the bit value for specified bit to a int64 number
+   */
+  __device__ inline void set_bit_value(int64_t& number, int bit_index, bool bit_value)
+  {
+    // Create a mask with a 1 at the desired bit index
+    long mask = 1L << bit_index;
+
+    if (bit_value) {
+      // Set the bit to 1 by performing a bitwise OR with the mask
+      number |= mask;
+    } else {
+      // Set the bit to 0 by performing a bitwise AND with the complement of the mask
+      number &= ~mask;
+    }
+  }
+
+  /**
+   * is current position EOF
+   */
+  __device__ inline bool eof(char const* pos) { return pos >= json_end_pos; }
+
+  /**
+   * is hex digits: 0-9, A-F, a-f
+   */
+  __device__ inline bool is_hex_digit(char c)
+  {
+    return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
+  }
+
+  /**
+   * is 0 to 9 digit
+   */
+  __device__ inline bool is_digit(char c) { return (c >= '0' && c <= '9'); }
+
+  /**
+   * is white spaces: ' ', '\t', '\n' '\r'
+   */
+  __device__ inline bool is_whitespace(char c)
+  {
+    return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+  }
+
+  /**
+   * skips 4 characters: ' ', '\t', '\n' '\r'
+   */
+  __device__ inline void skip_whitespaces(char const*& pos)
+  {
+    while (!eof(pos) && is_whitespace(*pos)) {
+      pos++;
+    }
+  }
+
+  /**
+   * check current char, if it's expected, then plus the position
+   */
+  __device__ inline bool try_skip(char const*& pos, char expected)
+  {
+    if (!eof(pos) && *pos == expected) {
+      pos++;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * try to push current context into stack
+   * if nested depth exceeds limitation, return false
+   */
+  __device__ inline bool try_push_context(json_token token)
+  {
+    if (stack_size < max_json_nesting_depth) {
+      push_context(token);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * record the nested state into stack: JSON object or JSON array
+   */
+  __device__ inline void push_context(json_token token)
+  {
+    bool v = json_token::START_OBJECT == token ? true : false;
+    set_bit_value(context_stack, stack_size, v);
+    stack_size++;
+  }
+
+  /**
+   * whether the top of nested context stack is JSON object context
+   * true is object, false is array
+   * only has two contexts: object or array
+   */
+  __device__ inline bool is_object_context()
+  {
+    return get_bit_value(context_stack, stack_size - 1);
+  }
+
+  /**
+   * pop top context from stack
+   */
+  __device__ inline void pop_curr_context() { stack_size--; }
+
+  /**
+   * is context stack is empty
+   */
+  __device__ inline bool is_context_stack_empty() { return stack_size == 0; }
+
+  /**
+   * parse the first value token from current position
+   * e.g., after finished this function:
+   *   current token is START_OBJECT if current value is object
+   *   current token is START_ARRAY if current value is array
+   *   current token is string/num/true/false/null if current value is terminal
+   *   current token is ERROR if parse failed
+   */
+  __device__ inline void parse_first_token_in_value()
+  {
+    // already checked eof
+    char c = *curr_pos;
+    switch (c) {
+      case '{':
+        if (!try_push_context(json_token::START_OBJECT)) {
+          curr_token = json_token::ERROR;
+          return;
+        }
+        curr_pos++;
+        curr_token = json_token::START_OBJECT;
+        break;
+
+      case '[':
+        if (!try_push_context(json_token::START_ARRAY)) {
+          curr_token = json_token::ERROR;
+          return;
+        }
+        curr_pos++;
+        curr_token = json_token::START_ARRAY;
+        break;
+
+      case '"': parse_double_quoted_string(); break;
+
+      case '\'':
+        if (allow_single_quotes) {
+          parse_single_quoted_string();
+        } else {
+          curr_token = json_token::ERROR;
+        }
+        break;
+
+      case 't':
+        curr_pos++;
+        parse_true();
+        break;
+
+      case 'f':
+        curr_pos++;
+        parse_false();
+        break;
+
+      case 'n':
+        curr_pos++;
+        parse_null();
+        break;
+
+      default: parse_number();
+    }
+  }
+
+  // =========== Parse string begin ===========
+
+  /**
+   * parse ' quoted string
+   */
+  __device__ inline void parse_single_quoted_string()
+  {
+    auto [success, end_char_pos] =
+      try_parse_single_quoted_string(curr_pos, nullptr, nullptr, nullptr, write_style::unescaped);
+    if (success) {
+      curr_pos   = end_char_pos;
+      curr_token = json_token::VALUE_STRING;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * parse " quoted string
+   */
+  __device__ inline void parse_double_quoted_string()
+  {
+    auto [success, end_char_pos] =
+      try_parse_double_quoted_string(curr_pos, nullptr, nullptr, nullptr, write_style::unescaped);
+    if (success) {
+      curr_pos   = end_char_pos;
+      curr_token = json_token::VALUE_STRING;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /*
+   * try parse ' or " quoted string
+   *
+   * when allow single quote, first try single quote
+   * @param str_pos str start position for parsing, should be a position in JSON
+   * string
+   * @param to_match_str_pos expected match str position, nullptr means do not
+   * match
+   * @param to_match_str_end expected match str end
+   * @param copy_destination copy unescaped str to destination, nullptr means do
+   * not copy
+   * @return whether passed successfully and the end position of parsed str
+   *
+   */
+  __device__ inline std::pair<bool, char const*> try_parse_string(
+    char const* str_pos,
+    char const* to_match_str_pos,
+    char const* const to_match_str_end,
+    char* copy_destination,
+    write_style w_style)
+  {
+    if (!eof(str_pos)) {
+      if (allow_single_quotes && *str_pos == '\'') {
+        return try_parse_single_quoted_string(
+          str_pos, to_match_str_pos, to_match_str_end, copy_destination, w_style);
+      } else {
+        return try_parse_double_quoted_string(
+          str_pos, to_match_str_pos, to_match_str_end, copy_destination, w_style);
+      }
+    } else {
+      return std::make_pair(false, nullptr);
+    }
+  }
+
+  /**
+   * try parse ' quoted string
+   *
+   * when allow single quote, first try single quote
+   * @param str_pos str start position for parsing, should be a position in JSON
+   * string
+   * @param to_match_str_pos expected match str position, nullptr means do not
+   * match
+   * @param to_match_str_end expected match str end
+   * @param copy_destination copy unescaped str to destination, nullptr means do
+   * not copy
+   *
+   */
+  __device__ inline std::pair<bool, char const*> try_parse_single_quoted_string(
+    char const* str_pos,
+    char const* to_match_str_pos,
+    char const* const to_match_str_end,
+    char* copy_destination,
+    write_style w_style)
+  {
+    return try_parse_quoted_string(str_pos,
+                                   '\'',
+                                   to_match_str_pos,  // match str pos, nullptr means do not match
+                                   to_match_str_end,  // match str end
+                                   copy_destination,  // copy destination while parsing, nullptr
+                                                      // means do not copy
+                                   w_style);
+  }
+
+  /**
+   * try parse " quoted string.
+   *
+   * when allow single quote, first try single quote
+   * @param str_pos str start position for parsing, should be a position in JSON
+   * string
+   * @param to_match_str_pos expected match str position, nullptr means do not
+   * match
+   * @param to_match_str_end expected match str end
+   * @param copy_destination copy unescaped str to destination, nullptr means do
+   * not copy
+   *
+   */
+  __device__ inline std::pair<bool, char const*> try_parse_double_quoted_string(
+    char const* str_pos,
+    char const* to_match_str_pos,
+    char const* const to_match_str_end,
+    char* copy_destination,
+    write_style w_style)
+  {
+    return try_parse_quoted_string(str_pos,
+                                   '\"',
+                                   to_match_str_pos,  // match str pos, nullptr means do not match
+                                   to_match_str_end,  // match str end
+                                   copy_destination,  // copy destination while parsing, nullptr
+                                                      // means do not copy
+                                   w_style);
+  }
+
+  /**
+   * transform int value from [0, 15] to hex char
+   */
+  __device__ inline char to_hex_char(unsigned int v)
+  {
+    if (v < 10)
+      return '0' + v;
+    else
+      return 'A' + (v - 10);
+  }
+
+  /**
+   * escape control char ( ASCII code value [0, 32) )
+   * e.g.: \0  (ASCII code 0) will be escaped to 6 chars: \u0000
+   * e.g.: \10 (ASCII code 0) will be escaped to 2 chars: \n
+   * @param char to be escaped, c should in range [0, 31)
+   * @param[out] escape output
+   */
+  __device__ inline int escape_char(unsigned char c, char* output)
+  {
+    if (nullptr == output) {
+      switch (c) {
+        case 8:             // \b
+        case 9:             // \t
+        case 10:            // \n
+        case 12:            // \f
+        case 13: return 2;  // \r
+        default: return 6;  // \u0000
+      }
+    }
+    switch (c) {
+      case 8:
+        output[0] = '\\';
+        output[1] = 'b';
+        return 2;
+      case 9:
+        output[0] = '\\';
+        output[1] = 't';
+        return 2;
+      case 10:
+        output[0] = '\\';
+        output[1] = 'n';
+        return 2;
+      case 12:
+        output[0] = '\\';
+        output[1] = 'f';
+        return 2;
+      case 13:
+        output[0] = '\\';
+        output[1] = 'r';
+        return 2;
+      default:
+        output[0] = '\\';
+        output[1] = 'u';
+        output[2] = '0';
+        output[3] = '0';
+
+        // write high digit
+        if (c >= 16) {
+          output[4] = '1';
+        } else {
+          output[4] = '0';
+        }
+
+        // write low digit
+        unsigned int v = c % 16;
+        output[5]      = to_hex_char(v);
+        return 6;
+    }
+  }
+
+  /**
+   * utility for parsing string, this function does not update the parser
+   * internal try parse quoted string using passed `quote_char` `quote_char` can
+   * be ' or " For UTF-8 encoding: Single byte char: The most significant bit of
+   * the byte is always 0 Two-byte characters: The leading bits of the first
+   * byte are 110, and the leading bits of the second byte are 10. Three-byte
+   * characters: The leading bits of the first byte are 1110, and the leading
+   * bits of the second and third bytes are 10. Four-byte characters: The
+   * leading bits of the first byte are 11110, and the leading bits of the
+   * second, third, and fourth bytes are 10. Because JSON structural chars([ ] {
+   * } , :), string quote char(" ') and Escape char \ are all Ascii(The leading
+   * bit is 0), so it's safe that do not convert byte array to UTF-8 char.
+   *
+   * When quote is " and allow_unescaped_control_chars is false, grammar is:
+   *
+   *   STRING
+   *     : '"' (ESC | SAFECODEPOINT)* '"'
+   *     ;
+   *
+   *   fragment ESC
+   *     : '\\' (["\\/bfnrt] | UNICODE)
+   *     ;
+   *
+   *   fragment UNICODE
+   *     : 'u' HEX HEX HEX HEX
+   *     ;
+   *
+   *   fragment HEX
+   *     : [0-9a-fA-F]
+   *     ;
+   *
+   *   fragment SAFECODEPOINT
+   *       // 1 not " or ' depending to allow_single_quotes
+   *       // 2 not \
+   *       // 3 non control character: Ascii value not in [0, 32)
+   *     : ~ ["\\\u0000-\u001F]
+   *     ;
+   *
+   * When allow_unescaped_control_chars is true:
+   *   Allow [0-32) control Ascii chars directly without escape
+   * When allow_single_quotes is true:
+   *   These strings are allowed: '\'' , '\"' , '"' , "\"" , "\'" , "'"
+   * @param str_pos str start position for parsing, should be a position in JSON
+   * string
+   * @param quote_char expected quote char
+   * @param to_match_str_pos expected match str position, nullptr means do not
+   * match
+   * @param to_match_str_end expected match str end
+   * @param copy_destination copy unescaped str to destination, nullptr means do
+   * not copy
+   */
+  __device__ inline std::pair<bool, char const*> try_parse_quoted_string(
+    char const* str_pos,
+    char const quote_char,
+    char const* to_match_str_pos,
+    char const* const to_match_str_end,
+    char* copy_destination,
+    write_style w_style)
+  {
+    // update state
+    string_token_utf8_bytes       = 0;
+    bytes_diff_for_escape_writing = 0;
+
+    // write the first " if write style is escaped
+    if (write_style::escaped == w_style) {
+      bytes_diff_for_escape_writing++;
+      if (nullptr != copy_destination) { *copy_destination++ = '"'; }
+    }
+
+    // skip left quote char
+    if (!try_skip(str_pos, quote_char)) { return std::make_pair(false, nullptr); }
+
+    // scan string content
+    while (!eof(str_pos)) {
+      char c = *str_pos;
+      int v  = static_cast<int>(c);
+      if (c == quote_char) {
+        // path 1: match closing quote char
+        str_pos++;
+
+        // check max str len
+        if (!check_string_max_utf8_bytes()) { return std::make_pair(false, nullptr); }
+
+        // match check, the last char in match_str is quote_char
+        if (nullptr != to_match_str_pos) {
+          // match check, the last char in match_str is quote_char
+          if (to_match_str_pos != to_match_str_end) { return std::make_pair(false, nullptr); }
+        }
+
+        // write the end " if write style is escaped
+        if (write_style::escaped == w_style) {
+          bytes_diff_for_escape_writing++;
+          if (nullptr != copy_destination) { *copy_destination++ = '"'; }
+        }
+
+        return std::make_pair(true, str_pos);
+      } else if (v >= 0 && v < 32 && allow_unescaped_control_chars) {
+        // path 2: unescaped control char
+
+        // copy if enabled, unescape mode, write 1 char
+        if (copy_destination != nullptr && write_style::unescaped == w_style) {
+          *copy_destination++ = *str_pos;
+        }
+
+        // copy if enabled, escape mode, write more chars
+        if (write_style::escaped == w_style) {
+          int escape_chars = escape_char(*str_pos, copy_destination);
+          if (copy_destination != nullptr) copy_destination += escape_chars;
+          bytes_diff_for_escape_writing += (escape_chars - 1);
+        }
+
+        // check match if enabled
+        if (!try_match_char(to_match_str_pos, to_match_str_end, *str_pos)) {
+          return std::make_pair(false, nullptr);
+        }
+
+        str_pos++;
+        string_token_utf8_bytes++;
+        continue;
+      } else if ('\\' == c) {
+        // path 3: escape path
+        str_pos++;
+        if (!try_skip_escape_part(
+              str_pos, to_match_str_pos, to_match_str_end, copy_destination, w_style)) {
+          return std::make_pair(false, nullptr);
+        }
+      } else {
+        // path 4: safe code point
+
+        // handle single unescaped " char; happens when string is quoted by char '
+        // e.g.:  'A"' string, escape to "A\\"" (5 chars: " A \ " ")
+        if ('\"' == c && write_style::escaped == w_style) {
+          if (copy_destination != nullptr) { *copy_destination++ = '\\'; }
+          bytes_diff_for_escape_writing++;
+        }
+
+        if (!try_skip_safe_code_point(str_pos, c)) { return std::make_pair(false, nullptr); }
+        if (copy_destination != nullptr) { *copy_destination++ = c; }
+        // check match if enabled
+        if (!try_match_char(to_match_str_pos, to_match_str_end, c)) {
+          return std::make_pair(false, nullptr);
+        }
+        string_token_utf8_bytes++;
+      }
+    }
+
+    return std::make_pair(false, nullptr);
+  }
+
+  __device__ inline bool try_match_char(char const*& char_pos,
+                                        char const* const char_end_pos,
+                                        char c)
+  {
+    if (nullptr != char_pos) {
+      if (char_pos < char_end_pos && *char_pos == c) {
+        char_pos++;
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return true;
+    }
+  }
+
+  /**
+   * skip the second char in \", \', \\, \/, \b, \f, \n, \r, \t;
+   * skip the HEX chars in \u HEX HEX HEX HEX.
+   * @return positive escaped ASCII value if success, -1 otherwise
+   */
+  __device__ inline bool try_skip_escape_part(char const*& str_pos,
+                                              char const*& to_match_str_pos,
+                                              char const* const to_match_str_end,
+                                              char*& copy_dest,
+                                              write_style w_style)
+  {
+    // already skipped the first '\'
+    // try skip second part
+    if (!eof(str_pos)) {
+      char c = *str_pos;
+      switch (*str_pos) {
+        // path 1: \", \', \\, \/, \b, \f, \n, \r, \t
+        case '\"':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = c; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = '"';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, c)) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case '\'':
+          // only allow escape ' when `allow_single_quotes`
+          if (allow_single_quotes) {
+            // for both unescaped/escaped writes a single char '
+            if (nullptr != copy_dest) { *copy_dest++ = c; }
+            if (!try_match_char(to_match_str_pos, to_match_str_end, c)) { return false; }
+
+            string_token_utf8_bytes++;
+            str_pos++;
+            return true;
+          } else {
+            return false;
+          }
+        case '\\':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = c; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = '\\';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, c)) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case '/':
+          // for both unescaped/escaped writes a single char /
+          if (nullptr != copy_dest) { *copy_dest++ = c; }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, c)) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case 'b':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = '\b'; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = 'b';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, '\b')) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case 'f':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = '\f'; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = 'f';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, '\f')) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case 'n':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = '\n'; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = 'n';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, '\n')) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case 'r':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = '\r'; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = 'r';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, '\r')) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case 't':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = '\t'; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = 't';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, '\t')) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        // path 1 done: \", \', \\, \/, \b, \f, \n, \r, \t
+        case 'u':
+          // path 2: \u HEX HEX HEX HEX
+          str_pos++;
+
+          // for both unescaped/escaped writes corresponding utf8 bytes, no need
+          // to pass in write style
+          return try_skip_unicode(str_pos, to_match_str_pos, to_match_str_end, copy_dest);
+        default:
+          // path 3: invalid
+          return false;
+      }
+    } else {
+      // eof, no escaped char after char '\'
+      return false;
+    }
+  }
+
+  /**
+   * parse:
+   *   fragment SAFECODEPOINT
+   *       // 1 not " or ' depending to allow_single_quotes
+   *       // 2 not \
+   *       // 3 non control character: Ascii value not in [0, 32)
+   *     : ~ ["\\\u0000-\u001F]
+   *     ;
+   */
+  __device__ inline bool try_skip_safe_code_point(char const*& str_pos, char c)
+  {
+    // 1 the char is not quoted(' or ") char, here satisfy, do not need to check
+    // again
+
+    // 2. the char is not \, here satisfy, do not need to check again
+
+    // 3. chars not in [0, 32)
+    int v = static_cast<int>(c);
+    if (!(v >= 0 && v < 32)) {
+      str_pos++;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * convert chars 0-9, a-f, A-F to int value
+   */
+  __device__ inline uint8_t hex_value(char c)
+  {
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    return 0;
+  }
+
+  /**
+   * parse four HEX chars to unsigned int
+   */
+  __device__ inline cudf::char_utf8 parse_code_point(char const* p)
+  {
+    cudf::char_utf8 v = 0;
+    for (size_t i = 0; i < 4; i++) {
+      v = v * 16 + hex_value(p[i]);
+    }
+    return v;
+  }
+
+  /**
+   * @brief Returns the number of bytes in the specified character.
+   *
+   * @param character Single character
+   * @return Number of bytes
+   */
+  __device__ cudf::size_type bytes_in_char_utf8(cudf::char_utf8 character)
+  {
+    return 1 + static_cast<cudf::size_type>((character & 0x0000'FF00u) > 0) +
+           static_cast<cudf::size_type>((character & 0x00FF'0000u) > 0) +
+           static_cast<cudf::size_type>((character & 0xFF00'0000u) > 0);
+  }
+
+  /**
+   * @brief Converts a character code-point value into a UTF-8 character.
+   *
+   * @param unchr Character code-point to convert.
+   * @return Single UTF-8 character.
+   */
+  __device__ cudf::char_utf8 codepoint_to_utf8(uint32_t unchr)
+  {
+    cudf::char_utf8 utf8 = 0;
+    if (unchr < 0x0000'0080) {
+      // single byte utf8
+      utf8 = unchr;
+    } else if (unchr < 0x0000'0800) {
+      // double byte utf8
+      utf8 = (unchr << 2) & 0x1F00;
+      utf8 |= (unchr & 0x3F);
+      utf8 |= 0x0000'C080;
+    } else if (unchr < 0x0001'0000) {
+      // triple byte utf8
+      utf8 = (unchr << 4) & 0x0F'0000;
+      utf8 |= (unchr << 2) & 0x00'3F00;
+      utf8 |= (unchr & 0x3F);
+      utf8 |= 0x00E0'8080;
+    } else if (unchr < 0x0011'0000) {
+      // quadruple byte utf8
+      utf8 = (unchr << 6) & 0x0700'0000;
+      utf8 |= (unchr << 4) & 0x003F'0000;
+      utf8 |= (unchr << 2) & 0x0000'3F00;
+      utf8 |= (unchr & 0x3F);
+      utf8 |= 0xF080'8080u;
+    }
+    return utf8;
+  }
+
+  /**
+   * @brief Place a char_utf8 value into a char array.
+   *
+   * @param character Single character
+   * @param[out] str Output array.
+   * @return The number of bytes in the character
+   */
+  __device__ cudf::size_type from_char_utf8(cudf::char_utf8 character, char* str)
+  {
+    cudf::size_type const chr_width = bytes_in_char_utf8(character);
+    for (cudf::size_type idx = 0; idx < chr_width; ++idx) {
+      str[chr_width - idx - 1] = static_cast<char>(character) & 0xFF;
+      character                = character >> 8;
+    }
+    return chr_width;
+  }
+
+  /**
+   * try skip 4 HEX chars
+   * in pattern: '\\' 'u' HEX HEX HEX HEX, it's a code point of unicode
+   */
+  __device__ bool try_skip_unicode(char const*& str_pos,
+                                   char const*& to_match_str_pos,
+                                   char const* const to_match_str_end,
+                                   char*& copy_dest)
+  {
+    // already parsed u
+    bool is_success = try_skip_hex(str_pos) && try_skip_hex(str_pos) && try_skip_hex(str_pos) &&
+                      try_skip_hex(str_pos);
+    if (is_success) {
+      // parse 4 HEX chars to uint32_t value
+      auto code_point = parse_code_point(str_pos - 4);
+      auto utf_char   = codepoint_to_utf8(code_point);
+      // write utf8 bytes.
+      // In UTF-8, the maximum number of bytes used to encode a single character
+      // is 4
+      char buff[4];
+      cudf::size_type bytes = from_char_utf8(utf_char, buff);
+      string_token_utf8_bytes += bytes;
+
+      if (nullptr != copy_dest) {
+        for (cudf::size_type i = 0; i < bytes; i++) {
+          *copy_dest++ = buff[i];
+        }
+      }
+
+      if (nullptr != to_match_str_pos) {
+        for (cudf::size_type i = 0; i < bytes; i++) {
+          if (!(to_match_str_pos < to_match_str_end && *to_match_str_pos == buff[i])) {
+            return false;
+          }
+          to_match_str_pos++;
+        }
+      }
+
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * try skip HEX
+   */
+  __device__ inline bool try_skip_hex(char const*& str_pos)
+  {
+    if (!eof(str_pos) && is_hex_digit(*str_pos)) {
+      str_pos++;
+      return true;
+    }
+    return false;
+  }
+
+  // =========== Parse string end ===========
+
+  // =========== Parse number begin ===========
+
+  /**
+   * parse number, grammar is:
+   * NUMBER
+   *   : '-'? INT ('.' [0-9]+)? EXP?
+   *   ;
+   *
+   * fragment INT
+   *   // integer part forbis leading 0s (e.g. `01`)
+   *   : '0'
+   *   | [1-9] [0-9]*
+   *   ;
+   *
+   * fragment EXP
+   *   : [Ee] [+\-]? [0-9]+
+   *   ;
+   *
+   * valid number:    0, 0.3, 0e005, 0E005
+   * invalid number:  0., 0e, 0E
+   *
+   * Note: Leading zeroes are not allowed, keep consistent with Spark, e.g.: 00, -01 are invalid
+   */
+  __device__ inline void parse_number()
+  {
+    // parse sign
+    try_skip(curr_pos, '-');
+
+    // parse unsigned number
+    bool is_float = false;
+    // store number digits length
+    // e.g.: +1.23e-45 length is 5
+    int number_digits_length = 0;
+    if (try_unsigned_number(is_float, number_digits_length)) {
+      if (check_max_num_len(number_digits_length)) {
+        curr_token = (is_float ? json_token::VALUE_NUMBER_FLOAT : json_token::VALUE_NUMBER_INT);
+        // success parsed a number, update the token length
+        number_token_len = curr_pos - current_token_start_pos;
+      } else {
+        curr_token = json_token::ERROR;
+      }
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * verify max number digits length if enabled
+   * e.g.: +1.23e-45 length is 5
+   */
+  __device__ inline bool check_max_num_len(int number_digits_length)
+  {
+    return
+      // disabled num len check
+      max_num_len <= 0 ||
+      // enabled num len check
+      (max_num_len > 0 && number_digits_length <= max_num_len);
+  }
+
+  /**
+   * verify max string length if enabled
+   */
+  __device__ inline bool check_string_max_utf8_bytes()
+  {
+    return
+      // disabled str len check
+      max_string_utf8_bytes <= 0 ||
+      // enabled str len check
+      (max_string_utf8_bytes > 0 && string_token_utf8_bytes <= max_string_utf8_bytes);
+  }
+
+  /**
+   * parse:  INT ('.' [0-9]+)? EXP?
+   * and verify leading zeroes
+   *
+   * @param[out] is_float, if contains `.` or `e`, set true
+   */
+  __device__ inline bool try_unsigned_number(bool& is_float, int& number_digits_length)
+  {
+    if (!eof(curr_pos)) {
+      char c = *curr_pos;
+      if (c >= '1' && c <= '9') {
+        curr_pos++;
+        number_digits_length++;
+        // first digit is [1-9]
+        // path: INT = [1-9] [0-9]*
+        number_digits_length += skip_zero_or_more_digits();
+        return parse_number_from_fraction(is_float, number_digits_length);
+      } else if (c == '0') {
+        curr_pos++;
+        number_digits_length++;
+
+        // check leading zeros
+        if (!eof(curr_pos)) {
+          char next_char_after_zero = *curr_pos;
+          if (next_char_after_zero >= '0' && next_char_after_zero <= '9') {
+            // e.g.: 01 is invalid
+            return false;
+          }
+        }
+
+        // first digit is [0]
+        // path: INT = '0'
+        return parse_number_from_fraction(is_float, number_digits_length);
+      } else {
+        // first digit is non [0-9]
+        return false;
+      }
+    } else {
+      // eof, has no digits
+      return false;
+    }
+  }
+
+  /**
+   * parse: ('.' [0-9]+)? EXP?
+   * @param[is_float] is float
+   */
+  __device__ inline bool parse_number_from_fraction(bool& is_float, int& number_digits_length)
+  {
+    // parse fraction
+    if (try_skip(curr_pos, '.')) {
+      // has fraction
+      is_float = true;
+      // try pattern: [0-9]+
+      if (!try_skip_one_or_more_digits(number_digits_length)) { return false; }
+    }
+
+    // parse exp
+    if (!eof(curr_pos) && (*curr_pos == 'e' || *curr_pos == 'E')) {
+      curr_pos++;
+      is_float = true;
+      return try_parse_exp(number_digits_length);
+    }
+
+    return true;
+  }
+
+  /**
+   * parse: [0-9]*
+   * skip zero or more [0-9]
+   */
+  __device__ inline int skip_zero_or_more_digits()
+  {
+    int digits = 0;
+    while (!eof(curr_pos)) {
+      if (is_digit(*curr_pos)) {
+        digits++;
+        curr_pos++;
+      } else {
+        // point to first non-digit char
+        break;
+      }
+    }
+    return digits;
+  }
+
+  /**
+   * parse: [0-9]+
+   * try skip one or more [0-9]
+   * @param[out] len: skipped num of digits
+   */
+  __device__ inline bool try_skip_one_or_more_digits(int& number_digits_length)
+  {
+    if (!eof(curr_pos) && is_digit(*curr_pos)) {
+      curr_pos++;
+      number_digits_length++;
+      number_digits_length += skip_zero_or_more_digits();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * parse [eE][+-]?[0-9]+
+   * @param[out] exp_len exp len
+   */
+  __device__ inline bool try_parse_exp(int& number_digits_length)
+  {
+    // already parsed [eE]
+
+    // parse [+-]?
+    if (!eof(curr_pos) && (*curr_pos == '+' || *curr_pos == '-')) { curr_pos++; }
+
+    // parse [0-9]+
+    return try_skip_one_or_more_digits(number_digits_length);
+  }
+
+  // =========== Parse number end ===========
+
+  /**
+   * parse true
+   */
+  __device__ inline void parse_true()
+  {
+    // already parsed 't'
+    if (try_skip(curr_pos, 'r') && try_skip(curr_pos, 'u') && try_skip(curr_pos, 'e')) {
+      curr_token = json_token::VALUE_TRUE;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * parse false
+   */
+  __device__ inline void parse_false()
+  {
+    // already parsed 'f'
+    if (try_skip(curr_pos, 'a') && try_skip(curr_pos, 'l') && try_skip(curr_pos, 's') &&
+        try_skip(curr_pos, 'e')) {
+      curr_token = json_token::VALUE_FALSE;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * parse null
+   */
+  __device__ inline void parse_null()
+  {
+    // already parsed 'n'
+    if (try_skip(curr_pos, 'u') && try_skip(curr_pos, 'l') && try_skip(curr_pos, 'l')) {
+      curr_token = json_token::VALUE_NULL;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * parse the key string in key:value pair
+   */
+  __device__ inline void parse_field_name()
+  {
+    auto [success, end_char_pos] =
+      try_parse_string(curr_pos, nullptr, nullptr, nullptr, write_style::unescaped);
+    if (success) {
+      curr_pos   = end_char_pos;
+      curr_token = json_token::FIELD_NAME;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * continute parsing the next token and update current token
+   * Note: only parse one token at a time
+   * @param[out] has_comma_before_token has comma before next token
+   * @param[out] has_colon_before_token has colon before next token
+   */
+  __device__ inline json_token parse_next_token(bool& has_comma_before_token,
+                                                bool& has_colon_before_token)
+  {
+    skip_whitespaces(curr_pos);
+    if (!eof(curr_pos)) {
+      char c = *curr_pos;
+      if (is_context_stack_empty()) {
+        // stack is empty
+
+        if (curr_token == json_token::INIT) {
+          // main root entry point
+          current_token_start_pos = curr_pos;
+          parse_first_token_in_value();
+        } else {
+          if (allow_tailing_sub_string) {
+            // previous token is not INIT, means already get a token; stack is
+            // empty; Successfully parsed. Note: ignore the tailing sub-string
+            curr_token = json_token::SUCCESS;
+          } else {
+            // not eof, has extra useless tailing characters.
+            curr_token = json_token::ERROR;
+          }
+        }
+      } else {
+        // stack is non-empty
+
+        if (is_object_context()) {
+          // in JSON object context
+          if (curr_token == json_token::START_OBJECT) {
+            // previous token is '{'
+            if (c == '}') {
+              // empty object
+              // close curr object context
+              current_token_start_pos = curr_pos;
+              curr_pos++;
+              curr_token = json_token::END_OBJECT;
+              pop_curr_context();
+            } else {
+              // parse key in key:value pair
+              current_token_start_pos = curr_pos;
+              parse_field_name();
+            }
+          } else if (curr_token == json_token::FIELD_NAME) {
+            if (c == ':') {
+              has_colon_before_token = true;
+              // skip ':' and parse value in key:value pair
+              curr_pos++;
+              skip_whitespaces(curr_pos);
+              current_token_start_pos = curr_pos;
+              parse_first_token_in_value();
+            } else {
+              curr_token = json_token::ERROR;
+            }
+          } else {
+            // expect next key:value pair or '}'
+            if (c == '}') {
+              // end of object
+              current_token_start_pos = curr_pos;
+              curr_pos++;
+              curr_token = json_token::END_OBJECT;
+              pop_curr_context();
+            } else if (c == ',') {
+              has_comma_before_token = true;
+              // parse next key:value pair
+              curr_pos++;
+              skip_whitespaces(curr_pos);
+              current_token_start_pos = curr_pos;
+              parse_field_name();
+            } else {
+              curr_token = json_token::ERROR;
+            }
+          }
+        } else {
+          // in Json array context
+          if (curr_token == json_token::START_ARRAY) {
+            // previous token is '['
+            if (c == ']') {
+              // curr: ']', empty array
+              current_token_start_pos = curr_pos;
+              curr_pos++;
+              curr_token = json_token::END_ARRAY;
+              pop_curr_context();
+            } else {
+              // non-empty array, parse the first value in the array
+              current_token_start_pos = curr_pos;
+              parse_first_token_in_value();
+            }
+          } else {
+            if (c == ',') {
+              has_comma_before_token = true;
+              // skip ',' and parse the next value
+              curr_pos++;
+              skip_whitespaces(curr_pos);
+              current_token_start_pos = curr_pos;
+              parse_first_token_in_value();
+            } else if (c == ']') {
+              // end of array
+              current_token_start_pos = curr_pos;
+              curr_pos++;
+              curr_token = json_token::END_ARRAY;
+              pop_curr_context();
+            } else {
+              curr_token = json_token::ERROR;
+            }
+          }
+        }
+      }
+    } else {
+      // eof
+      if (is_context_stack_empty() && curr_token != json_token::INIT) {
+        // reach eof; stack is empty; previous token is not INIT
+        curr_token = json_token::SUCCESS;
+      } else {
+        // eof, and meet the following cases:
+        //   - has unclosed JSON array/object;
+        //   - the whole JSON is empty
+        curr_token = json_token::ERROR;
+      }
+    }
+    return curr_token;
+  }
+
+ public:
+  /**
+   * continute parsing, get next token.
+   * The final tokens are ERROR or SUCCESS;
+   */
+  __device__ json_token next_token()
+  {
+    // parse next token
+    bool has_comma_before_token;  // no-initialization because of do not care here
+    bool has_colon_before_token;  // no-initialization because of do not care here
+    return parse_next_token(has_comma_before_token, has_colon_before_token);
+  }
+
+  /**
+   * get current token
+   */
+  __device__ json_token get_current_token() { return curr_token; }
+
+  /**
+   * is valid JSON by parsing through all tokens
+   */
+  __device__ bool is_valid()
+  {
+    while (curr_token != json_token::ERROR && curr_token != json_token::SUCCESS) {
+      next_token();
+    }
+    return curr_token == json_token::SUCCESS;
+  }
+
+  /**
+   * skip children if current token is [ or {, or do nothing otherwise.
+   * after this call, the current token is ] or } if token is { or [
+   * @return true if JSON is valid so far, false otherwise.
+   */
+  __device__ bool try_skip_children()
+  {
+    if (curr_token == json_token::ERROR || curr_token == json_token::INIT ||
+        curr_token == json_token::SUCCESS) {
+      return false;
+    }
+
+    if (curr_token != json_token::START_OBJECT && curr_token != json_token::START_ARRAY) {
+      return true;
+    }
+
+    int open = 1;
+    while (true) {
+      json_token t = next_token();
+      if (t == json_token::START_OBJECT || t == json_token::START_ARRAY) {
+        ++open;
+      } else if (t == json_token::END_OBJECT || t == json_token::END_ARRAY) {
+        if (--open == 0) { return true; }
+      } else if (t == json_token::ERROR) {
+        return false;
+      }
+    }
+  }
+
+  __device__ cudf::size_type compute_unescaped_len() { return write_unescaped_text(nullptr); }
+
+  /**
+   * unescape current token text, then write to destination
+   * e.g.: '\\r' is a string with 2 chars '\' 'r', writes 1 char '\r'
+   * e.g.: "\u4e2d\u56FD" are code points for Chinese chars "中国",
+   *   writes 6 utf8 bytes: -28  -72 -83 -27 -101 -67
+   * For number, write verbatim without normalization
+   */
+  __device__ cudf::size_type write_unescaped_text(char* destination)
+  {
+    switch (curr_token) {
+      case json_token::VALUE_STRING:
+        // can not copy from JSON directly due to escaped chars
+        // rewind the pos; parse again with copy
+        try_parse_string(
+          current_token_start_pos, nullptr, nullptr, destination, write_style::unescaped);
+        return string_token_utf8_bytes;
+      case json_token::VALUE_NUMBER_INT:
+        if (number_token_len == 2 && current_token_start_pos[0] == '-' &&
+            current_token_start_pos[1] == '0') {
+          if (nullptr != destination) *destination++ = '0';
+          return 1;
+        }
+        if (nullptr != destination) {
+          for (cudf::size_type i = 0; i < number_token_len; ++i) {
+            *destination++ = *(current_token_start_pos + i);
+          }
+        }
+        return number_token_len;
+      case json_token::VALUE_NUMBER_FLOAT: {
+        // number normalization:
+        // 0.03E-2 => 0.3E-5, 200.000 => 200.0, 351.980 => 351.98,
+        // 12345678900000000000.0 => 1.23456789E19, 1E308 => 1.0E308
+        // 0.0000000000003 => 3.0E-13; 0.003 => 0.003; 0.0003 => 3.0E-4
+        // 1.0E309 => "Infinity", -1E309 => "-Infinity"
+        double d_value = spark_rapids_jni::detail::stod(
+          cudf::string_view(current_token_start_pos, number_token_len));
+        return spark_rapids_jni::ftos_converter::double_normalization(d_value, destination);
+      }
+      case json_token::VALUE_TRUE:
+        if (nullptr != destination) {
+          *destination++ = 't';
+          *destination++ = 'r';
+          *destination++ = 'u';
+          *destination++ = 'e';
+        }
+        return 4;
+      case json_token::VALUE_FALSE:
+        if (nullptr != destination) {
+          *destination++ = 'f';
+          *destination++ = 'a';
+          *destination++ = 'l';
+          *destination++ = 's';
+          *destination++ = 'e';
+        }
+        return 5;
+      case json_token::VALUE_NULL:
+        if (nullptr != destination) {
+          *destination++ = 'n';
+          *destination++ = 'u';
+          *destination++ = 'l';
+          *destination++ = 'l';
+        }
+        return 4;
+      case json_token::FIELD_NAME:
+        // can not copy from JSON directly due to escaped chars
+        // rewind the pos; parse again with copy
+        try_parse_string(
+          current_token_start_pos, nullptr, nullptr, destination, write_style::unescaped);
+        return string_token_utf8_bytes;
+      case json_token::START_ARRAY:
+        if (nullptr != destination) { *destination++ = '['; }
+        return 1;
+      case json_token::END_ARRAY:
+        if (nullptr != destination) { *destination++ = ']'; }
+        return 1;
+      case json_token::START_OBJECT:
+        if (nullptr != destination) { *destination++ = '{'; }
+        return 1;
+      case json_token::END_OBJECT:
+        if (nullptr != destination) { *destination++ = '}'; }
+        return 1;
+      // for the following tokens, return false
+      case json_token::SUCCESS:
+      case json_token::ERROR:
+      case json_token::INIT: return 0;
+    }
+    return 0;
+  }
+
+  __device__ cudf::size_type compute_escaped_len() { return write_escaped_text(nullptr); }
+  /**
+   * escape current token text, then write to destination
+   * e.g.: '"' is a string with 1 char '"', writes out 4 chars '"' '\' '\"' '"'
+   * e.g.: "\u4e2d\u56FD" are code points for Chinese chars "中国",
+   *   writes 8 utf8 bytes: '"' -28  -72 -83 -27 -101 -67 '"'
+   * For number, write verbatim without normalization
+   */
+  __device__ cudf::size_type write_escaped_text(char* destination)
+  {
+    switch (curr_token) {
+      case json_token::VALUE_STRING:
+        // can not copy from JSON directly due to escaped chars
+        // rewind the pos; parse again with copy
+        try_parse_string(
+          current_token_start_pos, nullptr, nullptr, destination, write_style::escaped);
+        return string_token_utf8_bytes + bytes_diff_for_escape_writing;
+      case json_token::VALUE_NUMBER_INT:
+        if (number_token_len == 2 && current_token_start_pos[0] == '-' &&
+            current_token_start_pos[1] == '0') {
+          if (nullptr != destination) *destination++ = '0';
+          return 1;
+        }
+        if (nullptr != destination) {
+          for (cudf::size_type i = 0; i < number_token_len; ++i) {
+            *destination++ = *(current_token_start_pos + i);
+          }
+        }
+        return number_token_len;
+      case json_token::VALUE_NUMBER_FLOAT: {
+        // number normalization:
+        double d_value = spark_rapids_jni::detail::stod(
+          cudf::string_view(current_token_start_pos, number_token_len));
+        return spark_rapids_jni::ftos_converter::double_normalization(d_value, destination);
+      }
+      case json_token::VALUE_TRUE:
+        if (nullptr != destination) {
+          *destination++ = 't';
+          *destination++ = 'r';
+          *destination++ = 'u';
+          *destination++ = 'e';
+        }
+        return 4;
+      case json_token::VALUE_FALSE:
+        if (nullptr != destination) {
+          *destination++ = 'f';
+          *destination++ = 'a';
+          *destination++ = 'l';
+          *destination++ = 's';
+          *destination++ = 'e';
+        }
+        return 5;
+      case json_token::VALUE_NULL:
+        if (nullptr != destination) {
+          *destination++ = 'n';
+          *destination++ = 'u';
+          *destination++ = 'l';
+          *destination++ = 'l';
+        }
+        return 4;
+      case json_token::FIELD_NAME:
+        // can not copy from JSON directly due to escaped chars
+        // rewind the pos; parse again with copy
+        try_parse_string(
+          current_token_start_pos, nullptr, nullptr, destination, write_style::escaped);
+        return string_token_utf8_bytes + bytes_diff_for_escape_writing;
+      case json_token::START_ARRAY:
+        if (nullptr != destination) { *destination++ = '['; }
+        return 1;
+      case json_token::END_ARRAY:
+        if (nullptr != destination) { *destination++ = ']'; }
+        return 1;
+      case json_token::START_OBJECT:
+        if (nullptr != destination) { *destination++ = '{'; }
+        return 1;
+      case json_token::END_OBJECT:
+        if (nullptr != destination) { *destination++ = '}'; }
+        return 1;
+      // for the following tokens, return false
+      case json_token::SUCCESS:
+      case json_token::ERROR:
+      case json_token::INIT: return 0;
+    }
+    return 0;
+  }
+
+  /**
+   * reset the parser
+   */
+  __device__ void reset()
+  {
+    curr_pos   = json_start_pos;
+    curr_token = json_token::INIT;
+    stack_size = 0;
+  }
+
+  /**
+   * match field name string when current token is FIELD_NAME,
+   * return true if current token is FIELD_NAME and match successfully.
+   * return false otherwise,
+   * Note: to_match_str_ptr should not be nullptr
+   */
+  __device__ bool match_current_field_name(cudf::string_view name)
+  {
+    return match_current_field_name(name.data(), name.size_bytes());
+  }
+
+  /**
+   * match current field name
+   */
+  __device__ bool match_current_field_name(char const* to_match_str_ptr, cudf::size_type len)
+  {
+    if (json_token::FIELD_NAME == curr_token) {
+      auto [b, end_pos] = try_parse_string(current_token_start_pos,
+                                           to_match_str_ptr,
+                                           to_match_str_ptr + len,
+                                           nullptr,
+                                           write_style::unescaped);
+      return b;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * copy current structure to destination.
+   * return false if meets JSON format error,
+   * reurn true otherwise.
+   * @param[out] copy_to
+   */
+  __device__ thrust::pair<bool, size_t> copy_current_structure(char* copy_to)
+  {
+    switch (curr_token) {
+      case json_token::INIT:
+      case json_token::ERROR:
+      case json_token::SUCCESS:
+      case json_token::FIELD_NAME:
+      case json_token::END_ARRAY:
+      case json_token::END_OBJECT: return thrust::make_pair(false, 0);
+      case json_token::VALUE_NUMBER_INT:
+      case json_token::VALUE_NUMBER_FLOAT:
+      case json_token::VALUE_STRING:
+      case json_token::VALUE_TRUE:
+      case json_token::VALUE_FALSE:
+      case json_token::VALUE_NULL:
+        // copy terminal token
+        if (nullptr != copy_to) {
+          size_t copy_len = write_escaped_text(copy_to);
+          return thrust::make_pair(true, copy_len);
+        } else {
+          size_t copy_len = compute_escaped_len();
+          return thrust::make_pair(true, copy_len);
+        }
+      case json_token::START_ARRAY:
+      case json_token::START_OBJECT:
+        // stack size increased by 1 when meet start object/array
+        // copy until meet matched end object/array
+        size_t sum_copy_len   = 0;
+        int backup_stack_size = stack_size;
+
+        // copy start object/array
+        if (nullptr != copy_to) {
+          int len = write_escaped_text(copy_to);
+          sum_copy_len += len;
+          copy_to += len;
+        } else {
+          sum_copy_len += compute_escaped_len();
+        }
+
+        while (true) {
+          bool has_comma_before_token = false;
+          bool has_colon_before_token = false;
+
+          // parse and get has_comma_before_token, has_colon_before_token
+          parse_next_token(has_comma_before_token, has_colon_before_token);
+
+          // check the JSON format
+          if (curr_token == json_token::ERROR) { return thrust::make_pair(false, 0); }
+
+          // write out the token
+          if (nullptr != copy_to) {
+            if (has_comma_before_token) {
+              sum_copy_len++;
+              *copy_to++ = ',';
+            }
+            if (has_colon_before_token) {
+              sum_copy_len++;
+              *copy_to++ = ':';
+            }
+            int len = write_escaped_text(copy_to);
+            sum_copy_len += len;
+            copy_to += len;
+          } else {
+            if (has_comma_before_token) { sum_copy_len++; }
+            if (has_colon_before_token) { sum_copy_len++; }
+            sum_copy_len += compute_escaped_len();
+          }
+
+          if (backup_stack_size - 1 == stack_size) {
+            // indicate meet the matched end object/array
+            return thrust::make_pair(true, sum_copy_len);
+          }
+        }
+        return thrust::make_pair(false, 0);
+    }
+
+    // never happen
+    return thrust::make_pair(false, 0);
+  }
+
+ private:
+  char const* const json_start_pos;
+  char const* const json_end_pos;
+  char const* curr_pos;
+  json_token curr_token{json_token::INIT};
+
+  // 64 bits long saves the nested object/array contexts
+  // true(bit value 1) is JSON object context
+  // false(bit value 0) is JSON array context
+  // JSON parser checks array/object are mached, e.g.: [1,2) are wrong
+  int64_t context_stack;
+  int stack_size = 0;
+
+  // save current token start pos, used by coping current token text
+  char const* current_token_start_pos;
+  // used to store number token length
+  cudf::size_type number_token_len;
+
+  // Records string/field name token utf8 bytes size after unescaped
+  // e.g.: For JSON 4 chars string "\\n", after unescaped, get 1 char '\n'
+  // used by checking the max string length
+  int string_token_utf8_bytes;
+
+  // Records bytes diff between escape writing and unescape writing
+  // e.g.: 4 chars string "\\n", string_token_utf8_bytes is 1,
+  // when `write_escaped_text`, will write out 4 chars: " \ n ",
+  // then this diff will be 4 - 1 = 3
+  int bytes_diff_for_escape_writing;
+};
+
+}  // namespace spark_rapids_jni
diff --git a/src/main/cpp/src/map_utils.cu b/src/main/cpp/src/map_utils.cu
index 9b420e201f..6ae54f4fe9 100644
--- a/src/main/cpp/src/map_utils.cu
+++ b/src/main/cpp/src/map_utils.cu
@@ -53,7 +53,6 @@
 
 //
 #include <cub/device/device_radix_sort.cuh>
-
 #include <cuda/functional>
 
 namespace spark_rapids_jni {
@@ -573,13 +572,10 @@ std::unique_ptr<cudf::column> extract_keys_or_values(
                                                                   stream);
   auto const num_extract = thrust::distance(extract_ranges.begin(), range_end);
 
-  auto children = cudf::strings::detail::make_strings_children(
+  auto [offsets, chars] = cudf::strings::detail::make_strings_children(
     substring_fn{unified_json_buff, extract_ranges}, num_extract, stream, mr);
-  return cudf::make_strings_column(num_extract,
-                                   std::move(children.first),
-                                   std::move(children.second->release().data.release()[0]),
-                                   0,
-                                   rmm::device_buffer{});
+  return cudf::make_strings_column(
+    num_extract, std::move(offsets), chars.release(), 0, rmm::device_buffer{});
 }
 
 // Compute the offsets for the final lists of Struct<String,String>.
diff --git a/src/main/cpp/src/map_utils.hpp b/src/main/cpp/src/map_utils.hpp
index 445bc89c7b..c620b6fb95 100644
--- a/src/main/cpp/src/map_utils.hpp
+++ b/src/main/cpp/src/map_utils.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,12 +16,13 @@
 
 #pragma once
 
-#include <memory>
-
 #include <cudf/column/column_view.hpp>
 #include <cudf/utilities/default_stream.hpp>
+
 #include <rmm/cuda_stream_view.hpp>
 
+#include <memory>
+
 namespace spark_rapids_jni {
 
 std::unique_ptr<cudf::column> from_json(
diff --git a/src/main/cpp/src/murmur_hash.cu b/src/main/cpp/src/murmur_hash.cu
index 17ec120b5a..d94ca2d5bc 100644
--- a/src/main/cpp/src/murmur_hash.cu
+++ b/src/main/cpp/src/murmur_hash.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,11 +24,10 @@
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
+#include <cuda/functional>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/tabulate.h>
 
-#include <cuda/functional>
-
 namespace spark_rapids_jni {
 
 namespace {
diff --git a/src/main/cpp/src/row_conversion.cu b/src/main/cpp/src/row_conversion.cu
new file mode 100644
index 0000000000..3d6e767042
--- /dev/null
+++ b/src/main/cpp/src/row_conversion.cu
@@ -0,0 +1,2515 @@
+/*
+ * Copyright (c) 2020-2024, NVIDIA CORPORATION.
+ *
+ * Licensed 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 "row_conversion.hpp"
+
+#include <cudf/column/column_factories.hpp>
+#include <cudf/detail/iterator.cuh>
+#include <cudf/detail/null_mask.hpp>
+#include <cudf/detail/offsets_iterator_factory.cuh>
+#include <cudf/detail/sequence.hpp>
+#include <cudf/detail/utilities/cuda.cuh>
+#include <cudf/detail/utilities/integer_utils.hpp>
+#include <cudf/detail/utilities/vector_factories.hpp>
+#include <cudf/lists/lists_column_device_view.cuh>
+#include <cudf/scalar/scalar_factories.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/types.hpp>
+#include <cudf/utilities/bit.hpp>
+#include <cudf/utilities/default_stream.hpp>
+#include <cudf/utilities/error.hpp>
+#include <cudf/utilities/traits.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/device_buffer.hpp>
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+#include <cooperative_groups.h>
+#include <cuda/barrier>
+#include <cuda/functional>
+#include <thrust/binary_search.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/iterator/discard_iterator.h>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/scan.h>
+
+#include <algorithm>
+#include <cstdarg>
+#include <cstdint>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <optional>
+#include <tuple>
+#include <type_traits>
+
+namespace {
+
+constexpr auto JCUDF_ROW_ALIGNMENT = 8;
+
+constexpr auto MAX_BATCH_SIZE = std::numeric_limits<cudf::size_type>::max();
+
+// Number of rows each block processes in the two kernels. Tuned via nsight
+constexpr auto NUM_STRING_ROWS_PER_BLOCK_TO_ROWS   = 1024;
+constexpr auto NUM_STRING_ROWS_PER_BLOCK_FROM_ROWS = 64;
+constexpr auto MIN_STRING_BLOCKS                   = 32;
+constexpr auto MAX_STRING_BLOCKS                   = MAX_BATCH_SIZE;
+
+constexpr auto NUM_WARPS_IN_BLOCK = 32;
+
+}  // anonymous namespace
+
+// needed to suppress warning about cuda::barrier
+#pragma nv_diag_suppress static_var_with_dynamic_init
+
+using namespace cudf;
+using detail::make_device_uvector_async;
+using detail::make_device_uvector_sync;
+using rmm::device_uvector;
+
+namespace spark_rapids_jni {
+namespace detail {
+
+/*
+ * This module converts data from row-major to column-major and from column-major to row-major. It
+ * is a transpose of the data of sorts, but there are a few complicating factors. They are spelled
+ * out below:
+ *
+ * Row Batches:
+ * The row data has to fit inside a cuDF column, which limits it to 2 gigs currently. The calling
+ * code attempts to keep the data size under 2 gigs, but due to padding this isn't always the case,
+ * so being able to break this up into multiple columns is necessary. Internally, this is referred
+ * to as the row batch, which is a group of rows that will fit into this 2 gig space requirement.
+ * There are typically 1 of these batches, but there can be 2.
+ *
+ * Async Memcpy:
+ * The CUDA blocks are using memcpy_async, which allows for the device to schedule memcpy operations
+ * and then wait on them to complete at a later time with a barrier. On Ampere or later hardware
+ * there is dedicated hardware to do this copy and on pre-Ampere it should generate the same code
+ * that a hand-rolled loop would generate, so performance should be the same or better than a
+ * hand-rolled kernel.
+ *
+ * Tile Info:
+ * Each CUDA block will work on a single tile info before exiting. This single tile consumes all
+ * available shared memory. The kernel reads data into shared memory and then back out from shared
+ * memory to device memory via memcpy_async. This kernel is completely memory bound.
+ *
+ * Batch Data:
+ * This structure contains all the row batches and some book-keeping data necessary for the batches
+ * such as row numbers for the batches.
+ *
+ * Tiles:
+ * The tile info describes a tile of data to process. In a GPU with 48KB this equates to about 221
+ * bytes in each direction of a table. The tiles are kept as square as possible to attempt to
+ * coalesce memory operations. The taller a tile is the better coalescing of columns, but row
+ * coalescing suffers. The wider a tile is the better the row coalescing, but columns coalescing
+ * suffers. The code attempts to produce a square tile to balance the coalescing. It starts by
+ * figuring out the optimal byte length and then adding columns to the data until the tile is too
+ * large. Since rows are different width with different alignment requirements, this isn't typically
+ * exact. Once a width is found the tiles are generated vertically with that width and height and
+ * then the process repeats. This means all the tiles will be the same height, but will have
+ * different widths based on what columns they encompass. Tiles in a vertical row will all have the
+ * same dimensions.
+ *
+ *   --------------------------------
+ *   | 4   5.0f || True   8   3   1 |
+ *   | 3   6.0f || False  3   1   1 |
+ *   | 2   7.0f || True   7   4   1 |
+ *   | 1   8.0f || False  2   5   1 |
+ *   --------------------------------
+ *   | 0   9.0f || True   6   7   1 |
+ *   ...
+ */
+
+/**
+ * @brief The CUDA blocks work on one tile_info struct of data.
+ *        This structure defines the workspaces for the blocks.
+ *
+ */
+struct tile_info {
+  int start_col;
+  int start_row;
+  int end_col;
+  int end_row;
+  int batch_number;
+
+  __device__ inline size_type get_shared_row_size(size_type const* const col_offsets,
+                                                  size_type const* const col_sizes) const
+  {
+    // this calculation is invalid if there are holes in the data such as a variable-width column.
+    // It is wrong in a safe way in that it will say this row size is larger than it should be, so
+    // we are not losing data we are just not as efficient as we could be with shared memory. This
+    // may be a problem if the tile is computed without regard to variable width offset/length sizes
+    // in that we overrun shared memory.
+    return util::round_up_unsafe(col_offsets[end_col] + col_sizes[end_col] - col_offsets[start_col],
+                                 JCUDF_ROW_ALIGNMENT);
+  }
+
+  __device__ inline size_type num_cols() const { return end_col - start_col + 1; }
+
+  __device__ inline size_type num_rows() const { return end_row - start_row + 1; }
+};
+
+/**
+ * @brief Returning rows is done in a byte cudf column. This is limited in size by
+ *        `size_type` and so output is broken into batches of rows that fit inside
+ *        this limit.
+ *
+ */
+struct row_batch {
+  size_type num_bytes;                    // number of bytes in this batch
+  size_type row_count;                    // number of rows in the batch
+  device_uvector<size_type> row_offsets;  // offsets column of output cudf column
+};
+
+/**
+ * @brief Holds information about the batches of data to be processed
+ *
+ */
+struct batch_data {
+  device_uvector<size_type> batch_row_offsets;       // offsets to each row in incoming data
+  device_uvector<size_type> d_batch_row_boundaries;  // row numbers for the start of each batch
+  std::vector<size_type>
+    batch_row_boundaries;              // row numbers for the start of each batch: 0, 1500, 2700
+  std::vector<row_batch> row_batches;  // information about each batch such as byte count
+};
+
+/**
+ * @brief builds row size information for tables that contain strings
+ *
+ * @param tbl table from which to compute row size information
+ * @param fixed_width_and_validity_size size of fixed-width and validity data in this table
+ * @param stream cuda stream on which to operate
+ * @return pair of device vector of size_types of the row sizes of the table and a device vector of
+ * offsets into the string column
+ */
+std::pair<rmm::device_uvector<size_type>, rmm::device_uvector<cudf::detail::input_offsetalator>>
+build_string_row_offsets(table_view const& tbl,
+                         size_type fixed_width_and_validity_size,
+                         rmm::cuda_stream_view stream)
+{
+  auto const num_rows = tbl.num_rows();
+  rmm::device_uvector<size_type> d_row_sizes(num_rows, stream);
+  thrust::uninitialized_fill(rmm::exec_policy(stream), d_row_sizes.begin(), d_row_sizes.end(), 0);
+
+  auto d_offsets_iterators = [&]() {
+    std::vector<cudf::detail::input_offsetalator> offsets_iterators;
+    auto itr = thrust::make_transform_iterator(
+      tbl.begin(), [](auto const& col) -> cudf::detail::input_offsetalator {
+        return cudf::detail::offsetalator_factory::make_input_iterator(
+          strings_column_view(col).offsets(), col.offset());
+      });
+    auto stencil = thrust::make_transform_iterator(
+      tbl.begin(), [](auto const& col) -> bool { return !is_fixed_width(col.type()); });
+    thrust::copy_if(thrust::host,
+                    itr,
+                    itr + tbl.num_columns(),
+                    stencil,
+                    std::back_inserter(offsets_iterators),
+                    thrust::identity<bool>{});
+    return make_device_uvector_sync(
+      offsets_iterators, stream, rmm::mr::get_current_device_resource());
+  }();
+
+  auto const num_columns = static_cast<size_type>(d_offsets_iterators.size());
+
+  thrust::for_each(rmm::exec_policy(stream),
+                   thrust::make_counting_iterator(0),
+                   thrust::make_counting_iterator(num_columns * num_rows),
+                   [d_offsets_iterators = d_offsets_iterators.data(),
+                    num_columns,
+                    num_rows,
+                    d_row_sizes = d_row_sizes.data()] __device__(auto element_idx) {
+                     auto const row = element_idx % num_rows;
+                     auto const col = element_idx / num_rows;
+                     auto const val =
+                       d_offsets_iterators[col][row + 1] - d_offsets_iterators[col][row];
+                     atomicAdd(&d_row_sizes[row], val);
+                   });
+
+  // transform the row sizes to include fixed width size and alignment
+  thrust::transform(rmm::exec_policy(stream),
+                    d_row_sizes.begin(),
+                    d_row_sizes.end(),
+                    d_row_sizes.begin(),
+                    cuda::proclaim_return_type<size_type>(
+                      [fixed_width_and_validity_size] __device__(auto row_size) {
+                        return util::round_up_unsafe(fixed_width_and_validity_size + row_size,
+                                                     JCUDF_ROW_ALIGNMENT);
+                      }));
+
+  return {std::move(d_row_sizes), std::move(d_offsets_iterators)};
+}
+
+/**
+ * @brief functor to return the offset of a row in a table with string columns
+ *
+ */
+struct string_row_offset_functor {
+  string_row_offset_functor(device_span<size_type const> d_row_offsets)
+    : d_row_offsets(d_row_offsets){};
+
+  __device__ inline size_type operator()(int row_number, int) const
+  {
+    return d_row_offsets[row_number];
+  }
+
+  device_span<size_type const> d_row_offsets;
+};
+
+/**
+ * @brief functor to return the offset of a row in a table with only fixed-width columns
+ *
+ */
+struct fixed_width_row_offset_functor {
+  fixed_width_row_offset_functor(size_type fixed_width_only_row_size)
+    : _fixed_width_only_row_size(fixed_width_only_row_size){};
+
+  __device__ inline size_type operator()(int row_number, int tile_row_start) const
+  {
+    return (row_number - tile_row_start) * _fixed_width_only_row_size;
+  }
+
+  size_type _fixed_width_only_row_size;
+};
+
+/**
+ * @brief Copies data from row-based JCUDF format to column-based cudf format.
+ *
+ * This optimized version of the conversion is faster for fixed-width tables that do not have more
+ * than 100 columns.
+ *
+ * @param num_rows number of rows in the incoming table
+ * @param num_columns number of columns in the incoming table
+ * @param row_size length in bytes of each row
+ * @param input_offset_in_row offset to each row of data
+ * @param num_bytes total number of bytes in the incoming data
+ * @param output_data array of pointers to the output data
+ * @param output_nm array of pointers to the output null masks
+ * @param input_data pointing to the incoming row data
+ */
+CUDF_KERNEL void copy_from_rows_fixed_width_optimized(const size_type num_rows,
+                                                      const size_type num_columns,
+                                                      const size_type row_size,
+                                                      const size_type* input_offset_in_row,
+                                                      const size_type* num_bytes,
+                                                      int8_t** output_data,
+                                                      bitmask_type** output_nm,
+                                                      const int8_t* input_data)
+{
+  // We are going to copy the data in two passes.
+  // The first pass copies a chunk of data into shared memory.
+  // The second pass copies that chunk from shared memory out to the final location.
+
+  // Because shared memory is limited we copy a subset of the rows at a time.
+  // For simplicity we will refer to this as a row_group
+
+  // In practice we have found writing more than 4 columns of data per thread
+  // results in performance loss. As such we are using a 2 dimensional
+  // kernel in terms of threads, but not in terms of blocks. Columns are
+  // controlled by the y dimension (there is no y dimension in blocks). Rows
+  // are controlled by the x dimension (there are multiple blocks in the x
+  // dimension).
+
+  size_type const rows_per_group   = blockDim.x;
+  size_type const row_group_start  = blockIdx.x;
+  size_type const row_group_stride = gridDim.x;
+  size_type const row_group_end    = (num_rows + rows_per_group - 1) / rows_per_group + 1;
+
+  extern __shared__ int8_t shared_data[];
+
+  // Because we are copying fixed width only data and we stride the rows
+  // this thread will always start copying from shared data in the same place
+  int8_t* row_tmp     = &shared_data[row_size * threadIdx.x];
+  int8_t* row_vld_tmp = &row_tmp[input_offset_in_row[num_columns - 1] + num_bytes[num_columns - 1]];
+
+  for (auto row_group_index = row_group_start; row_group_index < row_group_end;
+       row_group_index += row_group_stride) {
+    // Step 1: Copy the data into shared memory
+    // We know row_size is always aligned with and a multiple of int64_t;
+    int64_t* long_shared      = reinterpret_cast<int64_t*>(shared_data);
+    int64_t const* long_input = reinterpret_cast<int64_t const*>(input_data);
+
+    auto const shared_output_index  = threadIdx.x + (threadIdx.y * blockDim.x);
+    auto const shared_output_stride = blockDim.x * blockDim.y;
+    auto const row_index_end        = std::min(num_rows, ((row_group_index + 1) * rows_per_group));
+    auto const num_rows_in_group    = row_index_end - (row_group_index * rows_per_group);
+    auto const shared_length        = row_size * num_rows_in_group;
+
+    size_type const shared_output_end = shared_length / sizeof(int64_t);
+
+    auto const start_input_index = (row_size * row_group_index * rows_per_group) / sizeof(int64_t);
+
+    for (size_type shared_index = shared_output_index; shared_index < shared_output_end;
+         shared_index += shared_output_stride) {
+      long_shared[shared_index] = long_input[start_input_index + shared_index];
+    }
+    // Wait for all of the data to be in shared memory
+    __syncthreads();
+
+    // Step 2 copy the data back out
+
+    // Within the row group there should be 1 thread for each row.  This is a
+    // requirement for launching the kernel
+    auto const row_index = (row_group_index * rows_per_group) + threadIdx.x;
+    // But we might not use all of the threads if the number of rows does not go
+    // evenly into the thread count. We don't want those threads to exit yet
+    // because we may need them to copy data in for the next row group.
+    uint32_t active_mask = __ballot_sync(0xffffffff, row_index < num_rows);
+    if (row_index < num_rows) {
+      auto const col_index_start  = threadIdx.y;
+      auto const col_index_stride = blockDim.y;
+      for (auto col_index = col_index_start; col_index < num_columns;
+           col_index += col_index_stride) {
+        auto const col_size   = num_bytes[col_index];
+        int8_t const* col_tmp = &(row_tmp[input_offset_in_row[col_index]]);
+        int8_t* col_output    = output_data[col_index];
+        switch (col_size) {
+          case 1: {
+            col_output[row_index] = *col_tmp;
+            break;
+          }
+          case 2: {
+            int16_t* short_col_output   = reinterpret_cast<int16_t*>(col_output);
+            short_col_output[row_index] = *reinterpret_cast<const int16_t*>(col_tmp);
+            break;
+          }
+          case 4: {
+            int32_t* int_col_output   = reinterpret_cast<int32_t*>(col_output);
+            int_col_output[row_index] = *reinterpret_cast<const int32_t*>(col_tmp);
+            break;
+          }
+          case 8: {
+            int64_t* long_col_output   = reinterpret_cast<int64_t*>(col_output);
+            long_col_output[row_index] = *reinterpret_cast<const int64_t*>(col_tmp);
+            break;
+          }
+          default: {
+            auto const output_offset = col_size * row_index;
+            // TODO this should just not be supported for fixed width columns, but just in case...
+            for (auto b = 0; b < col_size; b++) {
+              col_output[b + output_offset] = col_tmp[b];
+            }
+            break;
+          }
+        }
+
+        bitmask_type* nm          = output_nm[col_index];
+        int8_t* valid_byte        = &row_vld_tmp[col_index / 8];
+        size_type byte_bit_offset = col_index % 8;
+        int predicate             = *valid_byte & (1 << byte_bit_offset);
+        uint32_t bitmask          = __ballot_sync(active_mask, predicate);
+        if (row_index % 32 == 0) { nm[word_index(row_index)] = bitmask; }
+      }  // end column loop
+    }    // end row copy
+    // wait for the row_group to be totally copied before starting on the next row group
+    __syncthreads();
+  }
+}
+
+CUDF_KERNEL void copy_to_rows_fixed_width_optimized(const size_type start_row,
+                                                    const size_type num_rows,
+                                                    const size_type num_columns,
+                                                    const size_type row_size,
+                                                    const size_type* output_offset_in_row,
+                                                    const size_type* num_bytes,
+                                                    const int8_t** input_data,
+                                                    const bitmask_type** input_nm,
+                                                    int8_t* output_data)
+{
+  // We are going to copy the data in two passes.
+  // The first pass copies a chunk of data into shared memory.
+  // The second pass copies that chunk from shared memory out to the final location.
+
+  // Because shared memory is limited we copy a subset of the rows at a time.
+  // We do not support copying a subset of the columns in a row yet, so we don't
+  // currently support a row that is wider than shared memory.
+  // For simplicity we will refer to this as a row_group
+
+  // In practice we have found reading more than 4 columns of data per thread
+  // results in performance loss. As such we are using a 2 dimensional
+  // kernel in terms of threads, but not in terms of blocks. Columns are
+  // controlled by the y dimension (there is no y dimension in blocks). Rows
+  // are controlled by the x dimension (there are multiple blocks in the x
+  // dimension).
+
+  size_type rows_per_group   = blockDim.x;
+  size_type row_group_start  = blockIdx.x;
+  size_type row_group_stride = gridDim.x;
+  size_type row_group_end    = (num_rows + rows_per_group - 1) / rows_per_group + 1;
+
+  extern __shared__ int8_t shared_data[];
+
+  // Because we are copying fixed width only data and we stride the rows
+  // this thread will always start copying to shared data in the same place
+  int8_t* row_tmp = &shared_data[row_size * threadIdx.x];
+  int8_t* row_vld_tmp =
+    &row_tmp[output_offset_in_row[num_columns - 1] + num_bytes[num_columns - 1]];
+
+  for (size_type row_group_index = row_group_start; row_group_index < row_group_end;
+       row_group_index += row_group_stride) {
+    // Within the row group there should be 1 thread for each row.  This is a
+    // requirement for launching the kernel
+    size_type row_index = start_row + (row_group_index * rows_per_group) + threadIdx.x;
+    // But we might not use all of the threads if the number of rows does not go
+    // evenly into the thread count. We don't want those threads to exit yet
+    // because we may need them to copy data back out.
+    if (row_index < (start_row + num_rows)) {
+      size_type col_index_start  = threadIdx.y;
+      size_type col_index_stride = blockDim.y;
+      for (size_type col_index = col_index_start; col_index < num_columns;
+           col_index += col_index_stride) {
+        size_type col_size      = num_bytes[col_index];
+        int8_t* col_tmp         = &(row_tmp[output_offset_in_row[col_index]]);
+        const int8_t* col_input = input_data[col_index];
+        switch (col_size) {
+          case 1: {
+            *col_tmp = col_input[row_index];
+            break;
+          }
+          case 2: {
+            const int16_t* short_col_input       = reinterpret_cast<const int16_t*>(col_input);
+            *reinterpret_cast<int16_t*>(col_tmp) = short_col_input[row_index];
+            break;
+          }
+          case 4: {
+            const int32_t* int_col_input         = reinterpret_cast<const int32_t*>(col_input);
+            *reinterpret_cast<int32_t*>(col_tmp) = int_col_input[row_index];
+            break;
+          }
+          case 8: {
+            const int64_t* long_col_input        = reinterpret_cast<const int64_t*>(col_input);
+            *reinterpret_cast<int64_t*>(col_tmp) = long_col_input[row_index];
+            break;
+          }
+          default: {
+            size_type input_offset = col_size * row_index;
+            // TODO this should just not be supported for fixed width columns, but just in case...
+            for (size_type b = 0; b < col_size; b++) {
+              col_tmp[b] = col_input[b + input_offset];
+            }
+            break;
+          }
+        }
+        // atomicOr only works on 32 bit or 64 bit  aligned values, and not byte aligned
+        // so we have to rewrite the addresses to make sure that it is 4 byte aligned
+        int8_t* valid_byte        = &row_vld_tmp[col_index / 8];
+        size_type byte_bit_offset = col_index % 8;
+        uint64_t fixup_bytes      = reinterpret_cast<uint64_t>(valid_byte) % 4;
+        int32_t* valid_int        = reinterpret_cast<int32_t*>(valid_byte - fixup_bytes);
+        size_type int_bit_offset  = byte_bit_offset + (fixup_bytes * 8);
+        // Now copy validity for the column
+        if (input_nm[col_index]) {
+          if (bit_is_set(input_nm[col_index], row_index)) {
+            atomicOr_block(valid_int, 1 << int_bit_offset);
+          } else {
+            atomicAnd_block(valid_int, ~(1 << int_bit_offset));
+          }
+        } else {
+          // It is valid so just set the bit
+          atomicOr_block(valid_int, 1 << int_bit_offset);
+        }
+      }  // end column loop
+    }    // end row copy
+    // wait for the row_group to be totally copied into shared memory
+    __syncthreads();
+
+    // Step 2: Copy the data back out
+    // We know row_size is always aligned with and a multiple of int64_t;
+    int64_t* long_shared = reinterpret_cast<int64_t*>(shared_data);
+    int64_t* long_output = reinterpret_cast<int64_t*>(output_data);
+
+    size_type shared_input_index  = threadIdx.x + (threadIdx.y * blockDim.x);
+    size_type shared_input_stride = blockDim.x * blockDim.y;
+    size_type row_index_end       = ((row_group_index + 1) * rows_per_group);
+    if (row_index_end > num_rows) { row_index_end = num_rows; }
+    size_type num_rows_in_group = row_index_end - (row_group_index * rows_per_group);
+    size_type shared_length     = row_size * num_rows_in_group;
+
+    size_type shared_input_end = shared_length / sizeof(int64_t);
+
+    size_type start_output_index = (row_size * row_group_index * rows_per_group) / sizeof(int64_t);
+
+    for (size_type shared_index = shared_input_index; shared_index < shared_input_end;
+         shared_index += shared_input_stride) {
+      long_output[start_output_index + shared_index] = long_shared[shared_index];
+    }
+    __syncthreads();
+    // Go for the next round
+  }
+}
+
+/**
+ * @brief copy data from cudf columns into JCUDF format, which is row-based
+ *
+ * @tparam RowOffsetFunctor iterator that gives the size of a specific row of the table.
+ * @param num_rows total number of rows in the table
+ * @param num_columns total number of columns in the table
+ * @param shmem_used_per_tile shared memory amount each `tile_info` is using
+ * @param tile_infos span of `tile_info` structs the define the work
+ * @param input_data pointer to raw table data
+ * @param col_sizes array of sizes for each element in a column - one per column
+ * @param col_offsets offset into input data row for each column's start
+ * @param row_offsets offset to a specific row in the output data
+ * @param batch_row_boundaries row numbers for batch starts
+ * @param output_data pointer to output data
+ *
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_to_rows(const size_type num_rows,
+                              const size_type num_columns,
+                              const size_type shmem_used_per_tile,
+                              device_span<const tile_info> tile_infos,
+                              const int8_t** input_data,
+                              const size_type* col_sizes,
+                              const size_type* col_offsets,
+                              RowOffsetFunctor row_offsets,
+                              size_type const* batch_row_boundaries,
+                              int8_t** output_data)
+{
+  // We are going to copy the data in two passes.
+  // The first pass copies a chunk of data into shared memory.
+  // The second pass copies that chunk from shared memory out to the final location.
+
+  // Because shared memory is limited we copy a subset of the rows at a time.
+  // This has been broken up for us in the tile_info struct, so we don't have
+  // any calculation to do here, but it is important to note.
+
+  auto const group = cooperative_groups::this_thread_block();
+  auto const warp  = cooperative_groups::tiled_partition<cudf::detail::warp_size>(group);
+  extern __shared__ int8_t shared_data[];
+
+  __shared__ cuda::barrier<cuda::thread_scope_block> tile_barrier;
+  if (group.thread_rank() == 0) { init(&tile_barrier, group.size()); }
+  group.sync();
+
+  auto const tile                   = tile_infos[blockIdx.x];
+  auto const num_tile_cols          = tile.num_cols();
+  auto const num_tile_rows          = tile.num_rows();
+  auto const tile_row_size          = tile.get_shared_row_size(col_offsets, col_sizes);
+  auto const starting_column_offset = col_offsets[tile.start_col];
+
+  // to do the copy we need to do n column copies followed by m element copies OR we have to do m
+  // element copies followed by r row copies. When going from column to row it is much easier to
+  // copy by elements first otherwise we would need a running total of the column sizes for our
+  // tile, which isn't readily available. This makes it more appealing to copy element-wise from
+  // input data into shared matching the end layout and do row-based memcopies out.
+
+  // read each column across the tile
+  // each warp takes a column with each thread of a warp taking a row this is done with cooperative
+  // groups where each column is chosen by the tiled partition and each thread in that partition
+  // works on a row
+  for (int relative_col = warp.meta_group_rank(); relative_col < num_tile_cols;
+       relative_col += warp.meta_group_size()) {
+    auto const absolute_col        = relative_col + tile.start_col;
+    auto const col_size            = col_sizes[absolute_col];
+    auto const col_offset          = col_offsets[absolute_col];
+    auto const relative_col_offset = col_offset - starting_column_offset;
+    auto const col_ptr             = input_data[absolute_col];
+
+    if (col_ptr == nullptr) {
+      // variable-width data column
+      continue;
+    }
+
+    for (int relative_row = warp.thread_rank(); relative_row < num_tile_rows;
+         relative_row += warp.size()) {
+      if (relative_row >= num_tile_rows) {
+        // out of bounds
+        continue;
+      }
+      auto const absolute_row = relative_row + tile.start_row;
+
+      auto const shared_offset = relative_row * tile_row_size + relative_col_offset;
+      auto const input_src     = col_ptr + col_size * absolute_row;
+
+      // copy the element from global memory
+      switch (col_size) {
+        case 2: {
+          const int16_t* short_col_input = reinterpret_cast<const int16_t*>(input_src);
+          *reinterpret_cast<int16_t*>(&shared_data[shared_offset]) = *short_col_input;
+          break;
+        }
+        case 4: {
+          const int32_t* int_col_input = reinterpret_cast<const int32_t*>(input_src);
+          *reinterpret_cast<int32_t*>(&shared_data[shared_offset]) = *int_col_input;
+          break;
+        }
+        case 8: {
+          const int64_t* long_col_input = reinterpret_cast<const int64_t*>(input_src);
+          *reinterpret_cast<int64_t*>(&shared_data[shared_offset]) = *long_col_input;
+          break;
+        }
+        case 1: shared_data[shared_offset] = *input_src; break;
+        default: {
+          for (int i = 0; i < col_size; ++i) {
+            shared_data[shared_offset] = *input_src;
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  auto const tile_output_buffer = output_data[tile.batch_number];
+  auto const row_batch_start = tile.batch_number == 0 ? 0 : batch_row_boundaries[tile.batch_number];
+
+  // no async copies above waiting on the barrier, so we sync the group here to ensure all copies to
+  // shared memory are completed before copying data out
+  group.sync();
+
+  // each warp takes a row
+  for (int copy_row = warp.meta_group_rank(); copy_row < tile.num_rows();
+       copy_row += warp.meta_group_size()) {
+    auto const src = &shared_data[tile_row_size * copy_row];
+    auto const dst = tile_output_buffer + row_offsets(copy_row + tile.start_row, row_batch_start) +
+                     starting_column_offset;
+    cuda::memcpy_async(warp, dst, src, tile_row_size, tile_barrier);
+  }
+
+  // wait on the last copies to complete
+  tile_barrier.arrive_and_wait();
+}
+
+/**
+ * @brief copy data from row-based format to cudf columns
+ *
+ * @tparam RowOffsetFunctor iterator that gives the size of a specific row of the table.
+ * @param num_rows total number of rows in the table
+ * @param num_columns total number of columns in the table
+ * @param shmem_used_per_tile amount of shared memory that is used by a tile
+ * @param row_offsets offset to a specific row in the output data
+ * @param batch_row_boundaries row numbers for batch starts
+ * @param output_data pointer to output data, partitioned by data size
+ * @param validity_offsets offset into input data row for validity data
+ * @param tile_infos information about the tiles of work
+ * @param input_nm pointer to input data
+ *
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_validity_to_rows(const size_type num_rows,
+                                       const size_type num_columns,
+                                       const size_type shmem_used_per_tile,
+                                       RowOffsetFunctor row_offsets,
+                                       size_type const* batch_row_boundaries,
+                                       int8_t** output_data,
+                                       const size_type validity_offset,
+                                       device_span<const tile_info> tile_infos,
+                                       const bitmask_type** input_nm)
+{
+  extern __shared__ int8_t shared_data[];
+
+  // each thread of warp reads a single int32 of validity - so we read 128 bytes then ballot_sync
+  // the bits and write the result to shmem after we fill shared mem memcpy it out in a blob.
+  auto const group = cooperative_groups::this_thread_block();
+  auto const warp  = cooperative_groups::tiled_partition<cudf::detail::warp_size>(group);
+
+  // Initialize cuda barriers for each tile.
+  __shared__ cuda::barrier<cuda::thread_scope_block> shared_tile_barrier;
+  if (group.thread_rank() == 0) { init(&shared_tile_barrier, group.size()); }
+  group.sync();
+
+  auto tile                = tile_infos[blockIdx.x];
+  auto const num_tile_cols = tile.num_cols();
+  auto const num_tile_rows = tile.num_rows();
+
+  auto const threads_per_warp = warp.size();
+  auto const rows_per_read    = cudf::detail::size_in_bits<bitmask_type>();
+
+  auto const num_sections_x = util::div_rounding_up_unsafe(num_tile_cols, threads_per_warp);
+  auto const num_sections_y = util::div_rounding_up_unsafe(num_tile_rows, rows_per_read);
+  auto const validity_data_row_length = util::round_up_unsafe(
+    util::div_rounding_up_unsafe(num_tile_cols, CHAR_BIT), JCUDF_ROW_ALIGNMENT);
+  auto const total_sections = num_sections_x * num_sections_y;
+
+  // the tile is divided into sections. A warp operates on a section at a time.
+  for (int my_section_idx = warp.meta_group_rank(); my_section_idx < total_sections;
+       my_section_idx += warp.meta_group_size()) {
+    // convert to rows and cols
+    auto const section_x          = my_section_idx % num_sections_x;
+    auto const section_y          = my_section_idx / num_sections_x;
+    auto const relative_col       = section_x * threads_per_warp + warp.thread_rank();
+    auto const relative_row       = section_y * rows_per_read;
+    auto const absolute_col       = relative_col + tile.start_col;
+    auto const absolute_row       = relative_row + tile.start_row;
+    auto const participating      = absolute_col < num_columns && absolute_row < num_rows;
+    auto const participation_mask = __ballot_sync(0xFFFFFFFF, participating);
+
+    if (participating) {
+      auto my_data = input_nm[absolute_col] != nullptr
+                       ? input_nm[absolute_col][word_index(absolute_row)]
+                       : std::numeric_limits<uint32_t>::max();
+
+      // every thread that is participating in the warp has 4 bytes, but it's column-based data and
+      // we need it in row-based. So we shuffle the bits around with ballot_sync to make the bytes
+      // we actually write.
+      bitmask_type dw_mask = 0x1;
+      for (int i = 0; i < threads_per_warp && relative_row + i < num_rows; ++i, dw_mask <<= 1) {
+        auto validity_data = __ballot_sync(participation_mask, my_data & dw_mask);
+        // lead thread in each warp writes data
+        auto const validity_write_offset =
+          validity_data_row_length * (relative_row + i) + (relative_col / CHAR_BIT);
+        if (warp.thread_rank() == 0) {
+          *reinterpret_cast<bitmask_type*>(&shared_data[validity_write_offset]) = validity_data;
+        }
+      }
+    }
+  }
+
+  auto const output_data_base =
+    output_data[tile.batch_number] + validity_offset + tile.start_col / CHAR_BIT;
+
+  // each warp copies a row at a time
+  auto const row_bytes       = util::div_rounding_up_unsafe(num_tile_cols, CHAR_BIT);
+  auto const row_batch_start = tile.batch_number == 0 ? 0 : batch_row_boundaries[tile.batch_number];
+
+  // make sure entire tile has finished copy
+  // Note that this was copied from above just under the for loop due to nsight complaints about
+  // divergent threads
+  group.sync();
+
+  for (int relative_row = warp.meta_group_rank(); relative_row < num_tile_rows;
+       relative_row += warp.meta_group_size()) {
+    auto const src = &shared_data[validity_data_row_length * relative_row];
+    auto const dst = output_data_base + row_offsets(relative_row + tile.start_row, row_batch_start);
+    cuda::memcpy_async(warp, dst, src, row_bytes, shared_tile_barrier);
+  }
+
+  // wait for tile of data to arrive
+  shared_tile_barrier.arrive_and_wait();
+}
+
+/**
+ * @brief kernel to copy string data to JCUDF row format
+ *
+ * @tparam RowOffsetFunctor iterator for row offsets into the destination data
+ * @param num_rows number of rows in this portion of the table
+ * @param num_variable_columns number of columns of variable-width data
+ * @param variable_input_data variable width data column pointers
+ * @param variable_col_output_offsets output offset information for variable-width columns
+ * @param variable_col_offsets input offset information for variable-width columns
+ * @param fixed_width_row_size offset to variable-width data in a row
+ * @param row_offsets offsets for each row in output data
+ * @param batch_row_offset row start for this batch
+ * @param output_data pointer to output data for this batch
+ *
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_strings_to_rows(size_type const num_rows,
+                                      size_type const num_variable_columns,
+                                      int8_t const** variable_input_data,
+                                      size_type const* variable_col_output_offsets,
+                                      cudf::detail::input_offsetalator* variable_col_offsets,
+                                      size_type fixed_width_row_size,
+                                      RowOffsetFunctor row_offsets,
+                                      size_type const batch_row_offset,
+                                      int8_t* output_data)
+{
+  // Each block will take a group of rows controlled by NUM_STRING_ROWS_PER_BLOCK_TO_ROWS. Each warp
+  // will copy a row at a time. The base thread will first go through column data and fill out
+  // offset/length information for the column. Then all threads of the warp will participate in the
+  // memcpy of the string data.
+  auto const my_block = cooperative_groups::this_thread_block();
+  auto const warp     = cooperative_groups::tiled_partition<cudf::detail::warp_size>(my_block);
+  cuda::barrier<cuda::thread_scope_block> block_barrier;
+
+  auto const start_row =
+    blockIdx.x * NUM_STRING_ROWS_PER_BLOCK_TO_ROWS + warp.meta_group_rank() + batch_row_offset;
+  auto const end_row =
+    std::min(num_rows, static_cast<size_type>(start_row + NUM_STRING_ROWS_PER_BLOCK_TO_ROWS));
+
+  for (int row = start_row; row < end_row; row += warp.meta_group_size()) {
+    auto offset                = fixed_width_row_size;  // initial offset to variable-width data
+    auto const base_row_offset = row_offsets(row, 0);
+    for (int col = 0; col < num_variable_columns; ++col) {
+      auto const string_start_offset = variable_col_offsets[col][row];
+      auto const string_length       = variable_col_offsets[col][row + 1] - string_start_offset;
+      if (warp.thread_rank() == 0) {
+        // write the offset/length to column
+        uint32_t* output_dest = reinterpret_cast<uint32_t*>(
+          &output_data[base_row_offset + variable_col_output_offsets[col]]);
+        output_dest[0] = offset;
+        output_dest[1] = string_length;
+      }
+      auto string_output_dest = &output_data[base_row_offset + offset];
+      auto string_output_src  = &variable_input_data[col][string_start_offset];
+      warp.sync();
+      cuda::memcpy_async(warp, string_output_dest, string_output_src, string_length, block_barrier);
+      offset += string_length;
+    }
+  }
+}
+/**
+ * @brief copy data from row-based format to cudf columns
+ *
+ * @tparam RowOffsetFunctor iterator that gives the size of a specific row of the table.
+ * @param num_rows total number of rows in the table
+ * @param num_columns total number of columns in the table
+ * @param shmem_used_per_tile amount of shared memory that is used by a tile
+ * @param row_offsets offset to a specific row in the input data
+ * @param batch_row_boundaries row numbers for batch starts
+ * @param output_data pointers to column data
+ * @param col_sizes array of sizes for each element in a column - one per column
+ * @param col_offsets offset into input data row for each column's start
+ * @param tile_infos information about the tiles of work
+ * @param input_data pointer to input data
+ *
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_from_rows(const size_type num_rows,
+                                const size_type num_columns,
+                                const size_type shmem_used_per_tile,
+                                RowOffsetFunctor row_offsets,
+                                size_type const* batch_row_boundaries,
+                                int8_t** output_data,
+                                const size_type* col_sizes,
+                                const size_type* col_offsets,
+                                device_span<const tile_info> tile_infos,
+                                const int8_t* input_data)
+{
+  // We are going to copy the data in two passes.
+  // The first pass copies a chunk of data into shared memory.
+  // The second pass copies that chunk from shared memory out to the final location.
+
+  // Because shared memory is limited we copy a subset of the rows at a time. This has been broken
+  // up for us in the tile_info struct, so we don't have any calculation to do here, but it is
+  // important to note.
+
+  // To speed up some of the random access memory we do, we copy col_sizes and col_offsets to shared
+  // memory for each of the tiles that we work on
+
+  auto const group = cooperative_groups::this_thread_block();
+  auto const warp  = cooperative_groups::tiled_partition<cudf::detail::warp_size>(group);
+  extern __shared__ int8_t shared[];
+
+  // Initialize cuda barriers for each tile.
+  __shared__ cuda::barrier<cuda::thread_scope_block> tile_barrier;
+  if (group.thread_rank() == 0) { init(&tile_barrier, group.size()); }
+  group.sync();
+
+  {
+    auto const fetch_tile           = tile_infos[blockIdx.x];
+    auto const fetch_tile_start_row = fetch_tile.start_row;
+    auto const starting_col_offset  = col_offsets[fetch_tile.start_col];
+    auto const fetch_tile_row_size  = fetch_tile.get_shared_row_size(col_offsets, col_sizes);
+    auto const row_batch_start =
+      fetch_tile.batch_number == 0 ? 0 : batch_row_boundaries[fetch_tile.batch_number];
+
+    for (int absolute_row = warp.meta_group_rank() + fetch_tile.start_row;
+         absolute_row <= fetch_tile.end_row;
+         absolute_row += warp.meta_group_size()) {
+      warp.sync();
+      auto shared_offset = (absolute_row - fetch_tile_start_row) * fetch_tile_row_size;
+      auto dst           = &shared[shared_offset];
+      auto src = &input_data[row_offsets(absolute_row, row_batch_start) + starting_col_offset];
+      // copy the data
+      cuda::memcpy_async(warp, dst, src, fetch_tile_row_size, tile_barrier);
+    }
+  }
+
+  {
+    auto const tile          = tile_infos[blockIdx.x];
+    auto const rows_in_tile  = tile.num_rows();
+    auto const cols_in_tile  = tile.num_cols();
+    auto const tile_row_size = tile.get_shared_row_size(col_offsets, col_sizes);
+
+    // ensure our data is ready
+    tile_barrier.arrive_and_wait();
+
+    // Now we copy from shared memory to final destination. The data is laid out in rows in shared
+    // memory, so the reads for a column will be "vertical". Because of this and the different sizes
+    // for each column, this portion is handled on row/column basis. to prevent each thread working
+    // on a single row and also to ensure that all threads can do work in the case of more threads
+    // than rows, we do a global index instead of a double for loop with col/row.
+    for (int relative_row = warp.thread_rank(); relative_row < rows_in_tile;
+         relative_row += warp.size()) {
+      auto const absolute_row             = relative_row + tile.start_row;
+      auto const shared_memory_row_offset = tile_row_size * relative_row;
+
+      for (int relative_col = warp.meta_group_rank(); relative_col < cols_in_tile;
+           relative_col += warp.meta_group_size()) {
+        auto const absolute_col = relative_col + tile.start_col;
+
+        auto const shared_memory_offset =
+          col_offsets[absolute_col] - col_offsets[tile.start_col] + shared_memory_row_offset;
+        auto const column_size = col_sizes[absolute_col];
+
+        int8_t* shmem_src = &shared[shared_memory_offset];
+        int8_t* dst       = &output_data[absolute_col][absolute_row * column_size];
+
+        cuda::memcpy_async(dst, shmem_src, column_size, tile_barrier);
+      }
+    }
+  }
+
+  // wait on the last copies to complete
+  tile_barrier.arrive_and_wait();
+}
+
+/**
+ * @brief copy data from row-based format to cudf columns
+ *
+ * @tparam RowOffsetFunctor iterator that gives the size of a specific row of the table.
+ * @param num_rows total number of rows in the table
+ * @param num_columns total number of columns in the table
+ * @param shmem_used_per_tile amount of shared memory that is used by a tile
+ * @param row_offsets offset to the first column a specific row in the input data
+ * @param batch_row_boundaries row numbers for batch starts
+ * @param output_nm pointers to null masks for columns
+ * @param validity_offsets offset into input data row for validity data
+ * @param tile_infos information about the tiles of work
+ * @param input_data pointer to input data
+ *
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_validity_from_rows(const size_type num_rows,
+                                         const size_type num_columns,
+                                         const size_type shmem_used_per_tile,
+                                         RowOffsetFunctor row_offsets,
+                                         size_type const* batch_row_boundaries,
+                                         bitmask_type** output_nm,
+                                         const size_type validity_offset,
+                                         device_span<const tile_info> tile_infos,
+                                         const int8_t* input_data)
+{
+  extern __shared__ int8_t shared[];
+
+  using cudf::detail::warp_size;
+
+  // each thread of warp reads a single byte of validity - so we read 32 bytes then ballot_sync the
+  // bits and write the result to shmem after we fill shared mem memcpy it out in a blob. Probably
+  // need knobs for number of rows vs columns to balance read/write
+
+  //        C0  C1  C2  C3  C4  C5  C6  C7
+  //  R0    1   0   1   0   0   1   1   0       <-- thread 0 reads byte r0
+  //  R1    1   1   1   1   1   1   1   0       <-- thread 1 reads byte r1
+  //  R2    0   0   1   0   0   1   1   0       <-- thread 2 reads byte r2
+  //  ...
+  //  R31   1   1   1   1   1   1   1   1       <-- thread 31 reads byte r31
+  //        ^
+  //        |  1 bit of each input byte, by column, are swizzled into a single 32 bit word via
+  //        __ballot_sync, representing 32 rows of that column.
+
+  auto const group = cooperative_groups::this_thread_block();
+  auto const warp  = cooperative_groups::tiled_partition<cudf::detail::warp_size>(group);
+
+  // Initialize cuda barriers for each tile.
+  __shared__ cuda::barrier<cuda::thread_scope_block> shared_tile_barrier;
+  if (group.thread_rank() == 0) { init(&shared_tile_barrier, group.size()); }
+  group.sync();
+
+  auto const tile           = tile_infos[blockIdx.x];
+  auto const tile_start_col = tile.start_col;
+  auto const tile_start_row = tile.start_row;
+  auto const num_tile_cols  = tile.num_cols();
+  auto const num_tile_rows  = tile.num_rows();
+
+  auto const threads_per_warp = warp.size();
+  auto const cols_per_read    = CHAR_BIT;
+
+  auto const rows_per_read            = static_cast<size_type>(threads_per_warp);
+  auto const num_sections_x           = util::div_rounding_up_safe(num_tile_cols, cols_per_read);
+  auto const num_sections_y           = util::div_rounding_up_safe(num_tile_rows, rows_per_read);
+  auto const validity_data_col_length = num_sections_y * 4;  // words to bytes
+  auto const total_sections           = num_sections_x * num_sections_y;
+
+  // the tile is divided into sections. A warp operates on a section at a time.
+  for (int my_section_idx = warp.meta_group_rank(); my_section_idx < total_sections;
+       my_section_idx += warp.meta_group_size()) {
+    // convert section to row and col
+    auto const section_x    = my_section_idx % num_sections_x;
+    auto const section_y    = my_section_idx / num_sections_x;
+    auto const relative_col = section_x * cols_per_read;
+    auto const relative_row = section_y * rows_per_read + warp.thread_rank();
+    auto const absolute_col = relative_col + tile_start_col;
+    auto const absolute_row = relative_row + tile_start_row;
+    auto const row_batch_start =
+      tile.batch_number == 0 ? 0 : batch_row_boundaries[tile.batch_number];
+
+    auto const participation_mask = __ballot_sync(0xFFFFFFFF, absolute_row < num_rows);
+
+    if (absolute_row < num_rows) {
+      auto const my_byte = input_data[row_offsets(absolute_row, row_batch_start) + validity_offset +
+                                      (absolute_col / cols_per_read)];
+
+      // so every thread that is participating in the warp has a byte, but it's row-based data and
+      // we need it in column-based. So we shuffle the bits around to make the bytes we actually
+      // write.
+      for (int i = 0, byte_mask = 0x1; (i < cols_per_read) && ((relative_col + i) < num_columns);
+           ++i, byte_mask <<= 1) {
+        auto const validity_data = __ballot_sync(participation_mask, my_byte & byte_mask);
+        // lead thread in each warp writes data
+        if (warp.thread_rank() == 0) {
+          auto const validity_write_offset =
+            validity_data_col_length * (relative_col + i) + relative_row / cols_per_read;
+          *reinterpret_cast<bitmask_type*>(&shared[validity_write_offset]) = validity_data;
+        }
+      }
+    }
+  }
+
+  // now memcpy the shared memory out to the final destination
+  auto const col_words = util::div_rounding_up_unsafe(num_tile_rows, CHAR_BIT * 4);
+
+  // make sure entire tile has finished copy
+  group.sync();
+
+  for (int relative_col = warp.meta_group_rank(); relative_col < num_tile_cols;
+       relative_col += warp.meta_group_size()) {
+    auto const absolute_col = relative_col + tile_start_col;
+    auto dst                = output_nm[absolute_col] + word_index(tile_start_row);
+    auto const src =
+      reinterpret_cast<bitmask_type*>(&shared[validity_data_col_length * relative_col]);
+
+    cuda::memcpy_async(
+      warp, dst, src, cuda::aligned_size_t<4>(validity_data_col_length), shared_tile_barrier);
+  }
+
+  // wait for tile of data to arrive
+  shared_tile_barrier.arrive_and_wait();
+}
+
+/**
+ * @brief copies string data from jcudf row format to cudf columns
+ *
+ * @tparam RowOffsetFunctor iterator for row offsets into the destination data
+ * @param row_offsets offsets for each row in input data
+ * @param string_row_offsets offset data into jcudf row data for each string
+ * @param string_lengths length of each incoming string in each column
+ * @param string_column_offsets offset column data for cudf column
+ * @param string_col_data output cudf string column data
+ * @param row_data jcudf row data
+ * @param num_rows number of rows in data
+ * @param num_string_columns number of string columns in the table
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_strings_from_rows(RowOffsetFunctor row_offsets,
+                                        int32_t** string_row_offsets,
+                                        int32_t** string_lengths,
+                                        size_type** string_column_offsets,
+                                        char** string_col_data,
+                                        int8_t const* row_data,
+                                        size_type const num_rows,
+                                        size_type const num_string_columns)
+{
+  // Each warp takes a tile, which is a single column and up to ROWS_PER_BLOCK rows. A tile will not
+  // wrap around the bottom of the table. The warp will copy the strings for each row in the tile.
+  // Traversing in row-major order to coalesce the offsets and size reads.
+  auto my_block = cooperative_groups::this_thread_block();
+  auto warp     = cooperative_groups::tiled_partition<cudf::detail::warp_size>(my_block);
+  cuda::barrier<cuda::thread_scope_block> block_barrier;
+
+  // workaround for not being able to take a reference to a constexpr host variable
+  auto const ROWS_PER_BLOCK = NUM_STRING_ROWS_PER_BLOCK_FROM_ROWS;
+  auto const tiles_per_col  = util::div_rounding_up_unsafe(num_rows, ROWS_PER_BLOCK);
+  auto const starting_tile  = blockIdx.x * warp.meta_group_size() + warp.meta_group_rank();
+  auto const num_tiles      = tiles_per_col * num_string_columns;
+  auto const tile_stride    = warp.meta_group_size() * gridDim.x;
+  // Each warp will copy strings in its tile. This is handled by all the threads of a warp passing
+  // the same parameters to async_memcpy and all threads in the warp participating in the copy.
+  for (auto my_tile = starting_tile; my_tile < num_tiles; my_tile += tile_stride) {
+    auto const starting_row = (my_tile % tiles_per_col) * ROWS_PER_BLOCK;
+    auto const col          = my_tile / tiles_per_col;
+    auto const str_len      = string_lengths[col];
+    auto const str_row_off  = string_row_offsets[col];
+    auto const str_col_off  = string_column_offsets[col];
+    auto str_col_data       = string_col_data[col];
+    for (int row = starting_row; row < starting_row + ROWS_PER_BLOCK && row < num_rows; ++row) {
+      auto const src = &row_data[row_offsets(row, 0) + str_row_off[row]];
+      auto dst       = &str_col_data[str_col_off[row]];
+
+      cuda::memcpy_async(warp, dst, src, str_len[row], block_barrier);
+    }
+  }
+}
+
+/**
+ * @brief Calculate the dimensions of the kernel for fixed width only columns.
+ *
+ * @param [in] num_columns the number of columns being copied.
+ * @param [in] num_rows the number of rows being copied.
+ * @param [in] size_per_row the size each row takes up when padded.
+ * @param [out] blocks the size of the blocks for the kernel
+ * @param [out] threads the size of the threads for the kernel
+ * @return the size in bytes of shared memory needed for each block.
+ */
+static int calc_fixed_width_kernel_dims(const size_type num_columns,
+                                        const size_type num_rows,
+                                        const size_type size_per_row,
+                                        dim3& blocks,
+                                        dim3& threads)
+{
+  // We have found speed degrades when a thread handles more than 4 columns.
+  // Each block is 2 dimensional. The y dimension indicates the columns.
+  // We limit this to 32 threads in the y dimension so we can still
+  // have at least 32 threads in the x dimension (1 warp) which should
+  // result in better coalescing of memory operations. We also
+  // want to guarantee that we are processing a multiple of 32 threads
+  // in the x dimension because we use atomic operations at the block
+  // level when writing validity data out to main memory, and that would
+  // need to change if we split a word of validity data between blocks.
+  int const y_block_size          = min(util::div_rounding_up_safe(num_columns, 4), 32);
+  int const x_possible_block_size = 1024 / y_block_size;
+  // 48KB is the default setting for shared memory per block according to the cuda tutorials
+  // If someone configures the GPU to only have 16 KB this might not work.
+  int const max_shared_size = 48 * 1024;
+  // If we don't have enough shared memory there is no point in having more threads
+  // per block that will just sit idle
+  auto const max_block_size = std::min(x_possible_block_size, max_shared_size / size_per_row);
+  // Make sure that the x dimension is a multiple of 32 this not only helps
+  // coalesce memory access it also lets us do a ballot sync for validity to write
+  // the data back out the warp level.  If x is a multiple of 32 then each thread in the y
+  // dimension is associated with one or more warps, that should correspond to the validity
+  // words directly.
+  int const block_size = (max_block_size / 32) * 32;
+  CUDF_EXPECTS(block_size != 0, "Row size is too large to fit in shared memory");
+
+  // The maximum number of blocks supported in the x dimension is 2 ^ 31 - 1
+  // but in practice having too many can cause some overhead that I don't totally
+  // understand. Playing around with this having as little as 600 blocks appears
+  // to be able to saturate memory on V100, so this is an order of magnitude higher
+  // to try and future proof this a bit.
+  int const num_blocks = std::clamp((num_rows + block_size - 1) / block_size, 1, 10240);
+
+  blocks.x  = num_blocks;
+  blocks.y  = 1;
+  blocks.z  = 1;
+  threads.x = block_size;
+  threads.y = y_block_size;
+  threads.z = 1;
+  return size_per_row * block_size;
+}
+
+/**
+ * When converting to rows it is possible that the size of the table was too big to fit
+ * in a single column. This creates an output column for a subset of the rows in a table
+ * going from start row and containing the next num_rows.  Most of the parameters passed
+ * into this function are common between runs and should be calculated once.
+ */
+static std::unique_ptr<column> fixed_width_convert_to_rows(
+  const size_type start_row,
+  const size_type num_rows,
+  const size_type num_columns,
+  const size_type size_per_row,
+  rmm::device_uvector<size_type>& column_start,
+  rmm::device_uvector<size_type>& column_size,
+  rmm::device_uvector<const int8_t*>& input_data,
+  rmm::device_uvector<const bitmask_type*>& input_nm,
+  const scalar& zero,
+  const scalar& scalar_size_per_row,
+  rmm::cuda_stream_view stream,
+  rmm::mr::device_memory_resource* mr)
+{
+  int64_t const total_allocation = size_per_row * num_rows;
+  // We made a mistake in the split somehow
+  CUDF_EXPECTS(total_allocation < std::numeric_limits<size_type>::max(),
+               "Table is too large to fit!");
+
+  // Allocate and set the offsets row for the byte array
+  std::unique_ptr<column> offsets =
+    cudf::detail::sequence(num_rows + 1, zero, scalar_size_per_row, stream, mr);
+
+  std::unique_ptr<column> data = make_numeric_column(data_type(type_id::INT8),
+                                                     static_cast<size_type>(total_allocation),
+                                                     mask_state::UNALLOCATED,
+                                                     stream,
+                                                     mr);
+
+  dim3 blocks;
+  dim3 threads;
+  int shared_size =
+    detail::calc_fixed_width_kernel_dims(num_columns, num_rows, size_per_row, blocks, threads);
+
+  copy_to_rows_fixed_width_optimized<<<blocks, threads, shared_size, stream.value()>>>(
+    start_row,
+    num_rows,
+    num_columns,
+    size_per_row,
+    column_start.data(),
+    column_size.data(),
+    input_data.data(),
+    input_nm.data(),
+    data->mutable_view().data<int8_t>());
+
+  return make_lists_column(num_rows,
+                           std::move(offsets),
+                           std::move(data),
+                           0,
+                           rmm::device_buffer{0, cudf::get_default_stream(), mr},
+                           stream,
+                           mr);
+}
+
+static inline bool are_all_fixed_width(std::vector<data_type> const& schema)
+{
+  return std::all_of(
+    schema.begin(), schema.end(), [](const data_type& t) { return is_fixed_width(t); });
+}
+
+/**
+ * @brief Given a set of fixed width columns, calculate how the data will be laid out in memory.
+ *
+ * @param [in] schema the types of columns that need to be laid out.
+ * @param [out] column_start the byte offset where each column starts in the row.
+ * @param [out] column_size the size in bytes of the data for each columns in the row.
+ * @return the size in bytes each row needs.
+ */
+static inline int32_t compute_fixed_width_layout(std::vector<data_type> const& schema,
+                                                 std::vector<size_type>& column_start,
+                                                 std::vector<size_type>& column_size)
+{
+  // We guarantee that the start of each column is 64-bit aligned so anything can go
+  // there, but to make the code simple we will still do an alignment for it.
+  int32_t at_offset = 0;
+  for (auto col = schema.begin(); col < schema.end(); col++) {
+    size_type s = size_of(*col);
+    column_size.emplace_back(s);
+    std::size_t allocation_needed = s;
+    std::size_t alignment_needed  = allocation_needed;  // They are the same for fixed width types
+    at_offset = util::round_up_unsafe(at_offset, static_cast<int32_t>(alignment_needed));
+    column_start.emplace_back(at_offset);
+    at_offset += allocation_needed;
+  }
+
+  // Now we need to add in space for validity
+  // Eventually we can think about nullable vs not nullable, but for now we will just always add
+  // it in
+  int32_t const validity_bytes_needed =
+    util::div_rounding_up_safe<int32_t>(schema.size(), CHAR_BIT);
+  // validity comes at the end and is byte aligned so we can pack more in.
+  at_offset += validity_bytes_needed;
+  // Now we need to pad the end so all rows are 64 bit aligned
+  return util::round_up_unsafe(at_offset, JCUDF_ROW_ALIGNMENT);
+}
+
+/**
+ * @brief column sizes and column start offsets for a table
+ */
+struct column_info_s {
+  size_type size_per_row;
+  std::vector<size_type> column_starts;
+  std::vector<size_type> column_sizes;
+  std::vector<size_type> variable_width_column_starts;
+
+  column_info_s& operator=(column_info_s const& other) = delete;
+  column_info_s& operator=(column_info_s&& other)      = delete;
+};
+
+/**
+ * @brief Compute information about a table such as bytes per row and offsets.
+ *
+ * @tparam iterator iterator of column schema data
+ * @param begin starting iterator of column schema
+ * @param end ending iterator of column schema
+ * @param column_starts column start offsets
+ * @param column_sizes size in bytes of each column
+ * @return size of the fixed_width data portion of a row.
+ */
+template <typename iterator>
+column_info_s compute_column_information(iterator begin, iterator end)
+{
+  size_type size_per_row = 0;
+  std::vector<size_type> column_starts;
+  std::vector<size_type> column_sizes;
+  std::vector<size_type> variable_width_column_starts;
+
+  column_starts.reserve(std::distance(begin, end) + 1);
+  column_sizes.reserve(std::distance(begin, end));
+
+  for (auto col_type = begin; col_type != end; ++col_type) {
+    bool const compound_type = is_compound(*col_type);
+
+    // a list or string column will write a single uint64 of data here for offset/length
+    auto const col_size = compound_type ? sizeof(uint32_t) + sizeof(uint32_t) : size_of(*col_type);
+
+    // align size for this type - They are the same for fixed width types and 4 bytes for variable
+    // width length/offset combos
+    size_type const alignment_needed = compound_type ? __alignof(uint32_t) : col_size;
+    size_per_row                     = util::round_up_unsafe(size_per_row, alignment_needed);
+    if (compound_type) { variable_width_column_starts.push_back(size_per_row); }
+    column_starts.push_back(size_per_row);
+    column_sizes.push_back(col_size);
+    size_per_row += col_size;
+  }
+
+  // add validity offset to the end of fixed_width offsets
+  auto validity_offset = size_per_row;
+  column_starts.push_back(validity_offset);
+
+  // validity is byte-aligned in the JCUDF format
+  size_per_row +=
+    util::div_rounding_up_safe(static_cast<size_type>(std::distance(begin, end)), CHAR_BIT);
+
+  return {size_per_row,
+          std::move(column_starts),
+          std::move(column_sizes),
+          std::move(variable_width_column_starts)};
+}
+
+/**
+ * @brief Build `tile_info` for the validity data to break up the work.
+ *
+ * @param num_columns number of columns in the table
+ * @param num_rows number of rows in the table
+ * @param shmem_limit_per_tile size of shared memory available to a single gpu tile
+ * @param row_batches batched row information for multiple output locations
+ * @return vector of `tile_info` structs for validity data
+ */
+std::vector<detail::tile_info> build_validity_tile_infos(size_type const& num_columns,
+                                                         size_type const& num_rows,
+                                                         size_type const& shmem_limit_per_tile,
+                                                         std::vector<row_batch> const& row_batches)
+{
+  auto const desired_rows_and_columns = static_cast<int>(sqrt(shmem_limit_per_tile));
+  auto const column_stride            = util::round_up_unsafe(
+    [&]() {
+      if (desired_rows_and_columns > num_columns) {
+        // not many columns, build a single tile for table width and ship it off
+        return num_columns;
+      } else {
+        return util::round_down_safe(desired_rows_and_columns, CHAR_BIT);
+      }
+    }(),
+    JCUDF_ROW_ALIGNMENT);
+
+  // we fit as much as we can given the column stride note that an element in the table takes just 1
+  // bit, but a row with a single element still takes 8 bytes!
+  auto const bytes_per_row =
+    util::round_up_safe(util::div_rounding_up_unsafe(column_stride, CHAR_BIT), JCUDF_ROW_ALIGNMENT);
+  auto const row_stride =
+    std::min(num_rows, util::round_down_safe(shmem_limit_per_tile / bytes_per_row, 64));
+  std::vector<detail::tile_info> validity_tile_infos;
+  validity_tile_infos.reserve(num_columns / column_stride * num_rows / row_stride);
+  for (int col = 0; col < num_columns; col += column_stride) {
+    int current_tile_row_batch = 0;
+    int rows_left_in_batch     = row_batches[current_tile_row_batch].row_count;
+    int row                    = 0;
+    while (row < num_rows) {
+      if (rows_left_in_batch == 0) {
+        current_tile_row_batch++;
+        rows_left_in_batch = row_batches[current_tile_row_batch].row_count;
+      }
+      int const tile_height = std::min(row_stride, rows_left_in_batch);
+      validity_tile_infos.emplace_back(
+        detail::tile_info{col,
+                          row,
+                          std::min(col + column_stride - 1, num_columns - 1),
+                          row + tile_height - 1,
+                          current_tile_row_batch});
+      row += tile_height;
+      rows_left_in_batch -= tile_height;
+    }
+  }
+
+  return validity_tile_infos;
+}
+
+/**
+ * @brief functor that returns the size of a row or 0 is row is greater than the number of rows in
+ * the table
+ *
+ * @tparam RowSize iterator that returns the size of a specific row
+ */
+template <typename RowSize>
+struct row_size_functor {
+  row_size_functor(size_type row_end, RowSize row_sizes, size_type last_row_end)
+    : _row_end(row_end), _row_sizes(row_sizes), _last_row_end(last_row_end)
+  {
+  }
+
+  __device__ inline uint64_t operator()(int i) const
+  {
+    return i >= _row_end ? 0 : _row_sizes[i + _last_row_end];
+  }
+
+  size_type _row_end;
+  RowSize _row_sizes;
+  size_type _last_row_end;
+};
+
+/**
+ * @brief Builds batches of rows that will fit in the size limit of a column.
+ *
+ * @tparam RowSize iterator that gives the size of a specific row of the table.
+ * @param num_rows Total number of rows in the table
+ * @param row_sizes iterator that gives the size of a specific row of the table.
+ * @param all_fixed_width bool indicating all data in this table is fixed width
+ * @param stream stream to operate on for this work
+ * @param mr memory resource used to allocate any returned data
+ * @returns vector of size_type's that indicate row numbers for batch boundaries and a
+ * device_uvector of row offsets
+ */
+template <typename RowSize>
+batch_data build_batches(size_type num_rows,
+                         RowSize row_sizes,
+                         bool all_fixed_width,
+                         rmm::cuda_stream_view stream,
+                         rmm::mr::device_memory_resource* mr)
+{
+  auto const total_size = thrust::reduce(rmm::exec_policy(stream), row_sizes, row_sizes + num_rows);
+  auto const num_batches = static_cast<int32_t>(
+    util::div_rounding_up_safe(total_size, static_cast<uint64_t>(MAX_BATCH_SIZE)));
+  auto const num_offsets = num_batches + 1;
+  std::vector<row_batch> row_batches;
+  std::vector<size_type> batch_row_boundaries;
+  device_uvector<size_type> batch_row_offsets(all_fixed_width ? 0 : num_rows, stream);
+
+  // at most max gpu memory / 2GB iterations.
+  batch_row_boundaries.reserve(num_offsets);
+  batch_row_boundaries.push_back(0);
+  size_type last_row_end = 0;
+  device_uvector<uint64_t> cumulative_row_sizes(num_rows, stream);
+
+  thrust::inclusive_scan(
+    rmm::exec_policy(stream), row_sizes, row_sizes + num_rows, cumulative_row_sizes.begin());
+
+  // This needs to be split this into 2 gig batches. Care must be taken to avoid a batch larger than
+  // 2 gigs. Imagine a table with 900 meg rows. The batches should occur every 2 rows, but if a
+  // lower bound is run at 2 gigs, 4 gigs, 6 gigs. the batches will be 2 rows, 2 rows, 3 rows, which
+  // will be invalid. The previous batch size must be taken into account when building a new batch.
+  // One way is to pull the batch size back to the host and add it to MAX_BATCH_SIZE for the lower
+  // bound search. The other method involves keeping everything on device, but subtracting the
+  // previous batch from cumulative_row_sizes based on index. This involves no synchronization
+  // between GPU and CPU, but involves more work on the GPU. These further need to be broken on a
+  // 32-row boundary to match the fixed_width optimized versions.
+
+  while (last_row_end < num_rows) {
+    auto offset_row_sizes = thrust::make_transform_iterator(
+      cumulative_row_sizes.begin(),
+      cuda::proclaim_return_type<uint64_t>(
+        [last_row_end, cumulative_row_sizes = cumulative_row_sizes.data()] __device__(auto i) {
+          return i - cumulative_row_sizes[last_row_end];
+        }));
+    auto search_start = offset_row_sizes + last_row_end;
+    auto search_end   = offset_row_sizes + num_rows;
+
+    // find the next MAX_BATCH_SIZE boundary
+    auto const lb =
+      thrust::lower_bound(rmm::exec_policy(stream), search_start, search_end, MAX_BATCH_SIZE);
+    size_type const batch_size = lb - search_start;
+
+    size_type const row_end = lb == search_end
+                                ? batch_size + last_row_end
+                                : last_row_end + util::round_down_safe(batch_size, 32);
+
+    // build offset list for each row in this batch
+    auto const num_rows_in_batch = row_end - last_row_end;
+
+    // build offset list for each row in this batch
+    auto const num_entries = row_end - last_row_end + 1;
+    device_uvector<size_type> output_batch_row_offsets(num_entries, stream, mr);
+
+    auto row_size_iter_bounded = cudf::detail::make_counting_transform_iterator(
+      0, row_size_functor(row_end, row_sizes, last_row_end));
+
+    thrust::exclusive_scan(rmm::exec_policy(stream),
+                           row_size_iter_bounded,
+                           row_size_iter_bounded + num_entries,
+                           output_batch_row_offsets.begin());
+
+    auto const batch_bytes = output_batch_row_offsets.element(num_rows_in_batch, stream);
+
+    // The output_batch_row_offsets vector is used as the offset column of the returned data. This
+    // needs to be individually allocated, but the kernel needs a contiguous array of offsets or
+    // more global lookups are necessary.
+    if (!all_fixed_width) {
+      cudaMemcpy(batch_row_offsets.data() + last_row_end,
+                 output_batch_row_offsets.data(),
+                 num_rows_in_batch * sizeof(size_type),
+                 cudaMemcpyDeviceToDevice);
+    }
+
+    batch_row_boundaries.push_back(row_end);
+    row_batches.push_back({batch_bytes, num_rows_in_batch, std::move(output_batch_row_offsets)});
+
+    last_row_end = row_end;
+  }
+
+  return {
+    std::move(batch_row_offsets),
+    make_device_uvector_async(batch_row_boundaries, stream, rmm::mr::get_current_device_resource()),
+    std::move(batch_row_boundaries),
+    std::move(row_batches)};
+}
+
+/**
+ * @brief Computes the number of tiles necessary given a tile height and batch offsets
+ *
+ * @param batch_row_boundaries row boundaries for each batch
+ * @param desired_tile_height height of each tile in the table
+ * @param stream stream to use
+ * @return number of tiles necessary
+ */
+int compute_tile_counts(device_span<size_type const> const& batch_row_boundaries,
+                        int desired_tile_height,
+                        rmm::cuda_stream_view stream)
+{
+  size_type const num_batches = batch_row_boundaries.size() - 1;
+  device_uvector<size_type> num_tiles(num_batches, stream);
+  auto iter = thrust::make_counting_iterator(0);
+  thrust::transform(
+    rmm::exec_policy(stream),
+    iter,
+    iter + num_batches,
+    num_tiles.begin(),
+    cuda::proclaim_return_type<size_type>(
+      [desired_tile_height, batch_row_boundaries = batch_row_boundaries.data()] __device__(
+        auto batch_index) -> size_type {
+        return util::div_rounding_up_unsafe(
+          batch_row_boundaries[batch_index + 1] - batch_row_boundaries[batch_index],
+          desired_tile_height);
+      }));
+  return thrust::reduce(rmm::exec_policy(stream), num_tiles.begin(), num_tiles.end());
+}
+
+/**
+ * @brief Builds the `tile_info` structs for a given table.
+ *
+ * @param tiles span of tiles to populate
+ * @param batch_row_boundaries boundary to row batches
+ * @param column_start starting column of the tile
+ * @param column_end ending column of the tile
+ * @param desired_tile_height height of the tile
+ * @param total_number_of_rows total number of rows in the table
+ * @param stream stream to use
+ * @return number of tiles created
+ */
+size_type build_tiles(
+  device_span<tile_info> tiles,
+  device_uvector<size_type> const& batch_row_boundaries,  // comes from build_batches
+  int column_start,
+  int column_end,
+  int desired_tile_height,
+  int total_number_of_rows,
+  rmm::cuda_stream_view stream)
+{
+  size_type const num_batches = batch_row_boundaries.size() - 1;
+  device_uvector<size_type> num_tiles(num_batches, stream);
+  auto iter = thrust::make_counting_iterator(0);
+  thrust::transform(
+    rmm::exec_policy(stream),
+    iter,
+    iter + num_batches,
+    num_tiles.begin(),
+    cuda::proclaim_return_type<size_type>(
+      [desired_tile_height, batch_row_boundaries = batch_row_boundaries.data()] __device__(
+        auto batch_index) -> size_type {
+        return util::div_rounding_up_unsafe(
+          batch_row_boundaries[batch_index + 1] - batch_row_boundaries[batch_index],
+          desired_tile_height);
+      }));
+
+  size_type const total_tiles =
+    thrust::reduce(rmm::exec_policy(stream), num_tiles.begin(), num_tiles.end());
+
+  device_uvector<size_type> tile_starts(num_batches + 1, stream);
+  auto tile_iter = cudf::detail::make_counting_transform_iterator(
+    0,
+    cuda::proclaim_return_type<size_type>(
+      [num_tiles = num_tiles.data(), num_batches] __device__(auto i) {
+        return (i < num_batches) ? num_tiles[i] : 0;
+      }));
+  thrust::exclusive_scan(rmm::exec_policy(stream),
+                         tile_iter,
+                         tile_iter + num_batches + 1,
+                         tile_starts.begin());  // in tiles
+
+  thrust::transform(
+    rmm::exec_policy(stream),
+    iter,
+    iter + total_tiles,
+    tiles.begin(),
+    cuda::proclaim_return_type<tile_info>(
+      [                     =,
+       tile_starts          = tile_starts.data(),
+       batch_row_boundaries = batch_row_boundaries.data()] __device__(size_type tile_index) {
+        // what batch this tile falls in
+        auto const batch_index_iter =
+          thrust::upper_bound(thrust::seq, tile_starts, tile_starts + num_batches, tile_index);
+        auto const batch_index = std::distance(tile_starts, batch_index_iter) - 1;
+        // local index within the tile
+        int const local_tile_index = tile_index - tile_starts[batch_index];
+        // the start row for this batch.
+        int const batch_row_start = batch_row_boundaries[batch_index];
+        // the start row for this tile
+        int const tile_row_start = batch_row_start + (local_tile_index * desired_tile_height);
+        // the end row for this tile
+        int const max_row =
+          std::min(total_number_of_rows - 1,
+                   batch_index + 1 > num_batches
+                     ? std::numeric_limits<size_type>::max()
+                     : static_cast<int>(batch_row_boundaries[batch_index + 1]) - 1);
+        int const tile_row_end =
+          std::min(batch_row_start + ((local_tile_index + 1) * desired_tile_height) - 1, max_row);
+
+        // stuff the tile
+        return tile_info{
+          column_start, tile_row_start, column_end, tile_row_end, static_cast<int>(batch_index)};
+      }));
+
+  return total_tiles;
+}
+
+/**
+ * @brief Determines what data should be operated on by each tile for the incoming table.
+ *
+ * @tparam TileCallback Callback that receives the start and end columns of tiles
+ * @param column_sizes vector of the size of each column
+ * @param column_starts vector of the offset of each column
+ * @param first_row_batch_size size of the first row batch to limit max tile size since a tile
+ * is unable to span batches
+ * @param total_number_of_rows total number of rows in the table
+ * @param shmem_limit_per_tile shared memory allowed per tile
+ * @param f callback function called when building a tile
+ */
+template <typename TileCallback>
+void determine_tiles(std::vector<size_type> const& column_sizes,
+                     std::vector<size_type> const& column_starts,
+                     size_type const first_row_batch_size,
+                     size_type const total_number_of_rows,
+                     size_type const& shmem_limit_per_tile,
+                     TileCallback f)
+{
+  // tile infos are organized with the tile going "down" the columns this provides the most
+  // coalescing of memory access
+  int current_tile_width     = 0;
+  int current_tile_start_col = 0;
+
+  // the ideal tile height has lots of 8-byte reads and 8-byte writes. The optimal read/write would
+  // be memory cache line sized access, but since other tiles will read/write the edges this may not
+  // turn out to be overly important. For now, we will attempt to build a square tile as far as byte
+  // sizes. x * y = shared_mem_size. Which translates to x^2 = shared_mem_size since we want them
+  // equal, so height and width are sqrt(shared_mem_size). The trick is that it's in bytes, not rows
+  // or columns.
+  auto const square_bias         = 32;  // bias towards columns for performance reasons
+  auto const optimal_square_len  = static_cast<size_type>(sqrt(shmem_limit_per_tile));
+  auto const desired_tile_height = util::round_up_safe<int>(
+    std::min(optimal_square_len / square_bias, total_number_of_rows), cudf::detail::warp_size);
+  auto const tile_height = std::clamp(desired_tile_height, 1, first_row_batch_size);
+
+  int row_size = 0;
+
+  // march each column and build the tiles of appropriate sizes
+  for (uint col = 0; col < column_sizes.size(); ++col) {
+    auto const col_size = column_sizes[col];
+
+    // align size for this type
+    auto const alignment_needed       = col_size;  // They are the same for fixed width types
+    auto const row_size_aligned       = util::round_up_unsafe(row_size, alignment_needed);
+    auto const row_size_with_this_col = row_size_aligned + col_size;
+    auto const row_size_with_end_pad =
+      util::round_up_unsafe(row_size_with_this_col, JCUDF_ROW_ALIGNMENT);
+
+    if (row_size_with_end_pad * tile_height > shmem_limit_per_tile) {
+      // too large, close this tile, generate vertical tiles and restart
+      f(current_tile_start_col, col == 0 ? col : col - 1, tile_height);
+
+      row_size =
+        util::round_up_unsafe((column_starts[col] + column_sizes[col]) & 7, alignment_needed);
+      row_size += col_size;  // alignment required for shared memory tile boundary to match
+                             // alignment of output row
+      current_tile_start_col = col;
+      current_tile_width     = 0;
+    } else {
+      row_size = row_size_with_this_col;
+      current_tile_width++;
+    }
+  }
+
+  // build last set of tiles
+  if (current_tile_width > 0) {
+    f(current_tile_start_col, static_cast<int>(column_sizes.size()) - 1, tile_height);
+  }
+}
+
+/**
+ * @brief convert cudf table into JCUDF row format
+ *
+ * @tparam offsetFunctor functor type for offset functor
+ * @param tbl table to convert to JCUDF row format
+ * @param batch_info information about the batches of data
+ * @param offset_functor functor that returns the starting offset of each row
+ * @param column_info information about incoming columns
+ * @param variable_width_offsets optional vector of offsets for variable-with columns
+ * @param stream stream used
+ * @param mr selected memory resource for returned data
+ * @return vector of list columns containing byte columns of the JCUDF row data
+ */
+template <typename offsetFunctor>
+std::vector<std::unique_ptr<column>> convert_to_rows(
+  table_view const& tbl,
+  batch_data& batch_info,
+  offsetFunctor offset_functor,
+  column_info_s const& column_info,
+  std::optional<rmm::device_uvector<cudf::detail::input_offsetalator>> variable_width_offsets,
+  rmm::cuda_stream_view stream,
+  rmm::mr::device_memory_resource* mr)
+{
+  int device_id;
+  CUDF_CUDA_TRY(cudaGetDevice(&device_id));
+  int total_shmem_in_bytes;
+  CUDF_CUDA_TRY(
+    cudaDeviceGetAttribute(&total_shmem_in_bytes, cudaDevAttrMaxSharedMemoryPerBlock, device_id));
+
+#ifndef __CUDA_ARCH__  // __host__ code.
+  // Need to reduce total shmem available by the size of barriers in the kernel's shared memory
+  total_shmem_in_bytes -=
+    util::round_up_unsafe(sizeof(cuda::barrier<cuda::thread_scope_block>), 16ul);
+#endif  // __CUDA_ARCH__
+
+  auto const shmem_limit_per_tile = total_shmem_in_bytes;
+
+  auto const num_rows         = tbl.num_rows();
+  auto const fixed_width_only = !variable_width_offsets.has_value();
+
+  auto select_columns = [](auto const& tbl, auto column_predicate) {
+    std::vector<column_view> cols;
+    std::copy_if(tbl.begin(), tbl.end(), std::back_inserter(cols), [&](auto c) {
+      return column_predicate(c);
+    });
+    return table_view(cols);
+  };
+
+  auto dev_col_sizes = make_device_uvector_async(
+    column_info.column_sizes, stream, rmm::mr::get_current_device_resource());
+  auto dev_col_starts = make_device_uvector_async(
+    column_info.column_starts, stream, rmm::mr::get_current_device_resource());
+
+  // Get the pointers to the input columnar data ready
+  auto const data_begin = thrust::make_transform_iterator(tbl.begin(), [](auto const& c) {
+    return is_compound(c.type()) ? nullptr : c.template data<int8_t>();
+  });
+  std::vector<int8_t const*> input_data(data_begin, data_begin + tbl.num_columns());
+
+  // validity code handles variable and fixed-width data, so give it everything
+  auto const nm_begin =
+    thrust::make_transform_iterator(tbl.begin(), [](auto const& c) { return c.null_mask(); });
+  std::vector<bitmask_type const*> input_nm(nm_begin, nm_begin + tbl.num_columns());
+
+  auto dev_input_data =
+    make_device_uvector_async(input_data, stream, rmm::mr::get_current_device_resource());
+  auto dev_input_nm =
+    make_device_uvector_async(input_nm, stream, rmm::mr::get_current_device_resource());
+
+  // the first batch always exists unless we were sent an empty table
+  auto const first_batch_size = batch_info.row_batches[0].row_count;
+
+  std::vector<rmm::device_buffer> output_buffers;
+  std::vector<int8_t*> output_data;
+  output_data.reserve(batch_info.row_batches.size());
+  output_buffers.reserve(batch_info.row_batches.size());
+  std::transform(
+    batch_info.row_batches.begin(),
+    batch_info.row_batches.end(),
+    std::back_inserter(output_buffers),
+    [&](auto const& batch) { return rmm::device_buffer(batch.num_bytes, stream, mr); });
+  std::transform(
+    output_buffers.begin(), output_buffers.end(), std::back_inserter(output_data), [](auto& buf) {
+      return static_cast<int8_t*>(buf.data());
+    });
+
+  auto dev_output_data = make_device_uvector_async(output_data, stream, mr);
+
+  int info_count = 0;
+  detail::determine_tiles(
+    column_info.column_sizes,
+    column_info.column_starts,
+    first_batch_size,
+    num_rows,
+    shmem_limit_per_tile,
+    [&gpu_batch_row_boundaries = batch_info.d_batch_row_boundaries, &info_count, &stream](
+      int const start_col, int const end_col, int const tile_height) {
+      int i = detail::compute_tile_counts(gpu_batch_row_boundaries, tile_height, stream);
+      info_count += i;
+    });
+
+  // allocate space for tiles
+  device_uvector<detail::tile_info> gpu_tile_infos(info_count, stream);
+  int tile_offset = 0;
+
+  detail::determine_tiles(
+    column_info.column_sizes,
+    column_info.column_starts,
+    first_batch_size,
+    num_rows,
+    shmem_limit_per_tile,
+    [&gpu_batch_row_boundaries = batch_info.d_batch_row_boundaries,
+     &gpu_tile_infos,
+     num_rows,
+     &tile_offset,
+     stream](int const start_col, int const end_col, int const tile_height) {
+      tile_offset += detail::build_tiles(
+        {gpu_tile_infos.data() + tile_offset, gpu_tile_infos.size() - tile_offset},
+        gpu_batch_row_boundaries,
+        start_col,
+        end_col,
+        tile_height,
+        num_rows,
+        stream);
+    });
+
+  // build validity tiles for ALL columns, variable and fixed width.
+  auto validity_tile_infos = detail::build_validity_tile_infos(
+    tbl.num_columns(), num_rows, shmem_limit_per_tile, batch_info.row_batches);
+
+  auto dev_validity_tile_infos =
+    make_device_uvector_async(validity_tile_infos, stream, rmm::mr::get_current_device_resource());
+
+  auto const validity_offset = column_info.column_starts.back();
+
+  // blast through the entire table and convert it
+  detail::copy_to_rows<<<gpu_tile_infos.size(),
+                         NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                         total_shmem_in_bytes,
+                         stream.value()>>>(num_rows,
+                                           tbl.num_columns(),
+                                           shmem_limit_per_tile,
+                                           gpu_tile_infos,
+                                           dev_input_data.data(),
+                                           dev_col_sizes.data(),
+                                           dev_col_starts.data(),
+                                           offset_functor,
+                                           batch_info.d_batch_row_boundaries.data(),
+                                           reinterpret_cast<int8_t**>(dev_output_data.data()));
+
+  // note that validity gets the entire table and not the fixed-width portion
+  detail::copy_validity_to_rows<<<validity_tile_infos.size(),
+                                  NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                                  total_shmem_in_bytes,
+                                  stream.value()>>>(num_rows,
+                                                    tbl.num_columns(),
+                                                    shmem_limit_per_tile,
+                                                    offset_functor,
+                                                    batch_info.d_batch_row_boundaries.data(),
+                                                    dev_output_data.data(),
+                                                    validity_offset,
+                                                    dev_validity_tile_infos,
+                                                    dev_input_nm.data());
+
+  if (!fixed_width_only) {
+    // build table view for variable-width data only
+    auto const variable_width_table =
+      select_columns(tbl, [](auto col) { return is_compound(col.type()); });
+
+    CUDF_EXPECTS(!variable_width_table.is_empty(), "No variable-width columns when expected!");
+    CUDF_EXPECTS(variable_width_offsets.has_value(), "No variable width offset data!");
+
+    auto const variable_data_begin = thrust::make_transform_iterator(
+      variable_width_table.begin(),
+      [](auto const& c) { return is_compound(c.type()) ? c.template data<int8_t>() : nullptr; });
+    std::vector<int8_t const*> variable_width_input_data(
+      variable_data_begin, variable_data_begin + variable_width_table.num_columns());
+
+    auto dev_variable_input_data = make_device_uvector_async(
+      variable_width_input_data, stream, rmm::mr::get_current_device_resource());
+    auto dev_variable_col_output_offsets = make_device_uvector_async(
+      column_info.variable_width_column_starts, stream, rmm::mr::get_current_device_resource());
+
+    for (uint i = 0; i < batch_info.row_batches.size(); i++) {
+      auto const batch_row_offset = batch_info.batch_row_boundaries[i];
+      auto const batch_num_rows   = batch_info.row_batches[i].row_count;
+
+      dim3 const string_blocks(
+        std::min(MAX_STRING_BLOCKS,
+                 util::div_rounding_up_unsafe(batch_num_rows, NUM_STRING_ROWS_PER_BLOCK_TO_ROWS)));
+
+      detail::copy_strings_to_rows<<<string_blocks,
+                                     NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                                     0,
+                                     stream.value()>>>(batch_num_rows,
+                                                       variable_width_table.num_columns(),
+                                                       dev_variable_input_data.data(),
+                                                       dev_variable_col_output_offsets.data(),
+                                                       variable_width_offsets->data(),
+                                                       column_info.size_per_row,
+                                                       offset_functor,
+                                                       batch_row_offset,
+                                                       reinterpret_cast<int8_t*>(output_data[i]));
+    }
+  }
+
+  // split up the output buffer into multiple buffers based on row batch sizes and create list of
+  // byte columns
+  std::vector<std::unique_ptr<column>> ret;
+  ret.reserve(batch_info.row_batches.size());
+  auto counting_iter = thrust::make_counting_iterator(0);
+  std::transform(counting_iter,
+                 counting_iter + batch_info.row_batches.size(),
+                 std::back_inserter(ret),
+                 [&](auto batch) {
+                   auto const offset_count = batch_info.row_batches[batch].row_offsets.size();
+                   auto offsets =
+                     std::make_unique<column>(data_type{type_id::INT32},
+                                              (size_type)offset_count,
+                                              batch_info.row_batches[batch].row_offsets.release(),
+                                              rmm::device_buffer{},
+                                              0);
+                   auto data = std::make_unique<column>(data_type{type_id::INT8},
+                                                        batch_info.row_batches[batch].num_bytes,
+                                                        std::move(output_buffers[batch]),
+                                                        rmm::device_buffer{},
+                                                        0);
+
+                   return make_lists_column(batch_info.row_batches[batch].row_count,
+                                            std::move(offsets),
+                                            std::move(data),
+                                            0,
+                                            rmm::device_buffer{0, cudf::get_default_stream(), mr},
+                                            stream,
+                                            mr);
+                 });
+
+  return ret;
+}
+
+}  // namespace detail
+
+/**
+ * @brief convert a cudf table to JCUDF row format
+ *
+ * @param tbl incoming table to convert
+ * @param stream stream to use for operations
+ * @param mr memory resource used for returned data
+ * @return vector of list columns containing byte columns of the JCUDF row data
+ */
+std::vector<std::unique_ptr<column>> convert_to_rows(table_view const& tbl,
+                                                     rmm::cuda_stream_view stream,
+                                                     rmm::mr::device_memory_resource* mr)
+{
+  auto const num_columns = tbl.num_columns();
+  auto const num_rows    = tbl.num_rows();
+
+  auto const fixed_width_only = std::all_of(
+    tbl.begin(), tbl.end(), [](column_view const& c) { return is_fixed_width(c.type()); });
+
+  // Break up the work into tiles, which are a starting and ending row/col #. This tile size is
+  // calculated based on the shared memory size available we want a single tile to fill up the
+  // entire shared memory space available for the transpose-like conversion.
+
+  // There are two different processes going on here. The GPU conversion of the data and the writing
+  // of the data into the list of byte columns that are a maximum of 2 gigs each due to offset
+  // maximum size. The GPU conversion portion has to understand this limitation because the column
+  // must own the data inside and as a result it must be a distinct allocation for that column.
+  // Copying the data into these final buffers would be prohibitively expensive, so care is taken to
+  // ensure the GPU writes to the proper buffer. The tiles are broken at the boundaries of specific
+  // rows based on the row sizes up to that point. These are row batches and they are decided first
+  // before building the tiles so the tiles can be properly cut around them.
+
+  auto schema_column_iter =
+    thrust::make_transform_iterator(tbl.begin(), [](auto const& i) { return i.type(); });
+
+  auto column_info =
+    detail::compute_column_information(schema_column_iter, schema_column_iter + num_columns);
+  auto const size_per_row = column_info.size_per_row;
+  if (fixed_width_only) {
+    // total encoded row size. This includes fixed-width data and validity only. It does not include
+    // variable-width data since it isn't copied with the fixed-width and validity kernel.
+    auto row_size_iter = thrust::make_constant_iterator<uint64_t>(
+      util::round_up_unsafe(size_per_row, JCUDF_ROW_ALIGNMENT));
+
+    auto batch_info = detail::build_batches(num_rows, row_size_iter, fixed_width_only, stream, mr);
+
+    detail::fixed_width_row_offset_functor offset_functor(
+      util::round_up_unsafe(size_per_row, JCUDF_ROW_ALIGNMENT));
+
+    return detail::convert_to_rows(
+      tbl, batch_info, offset_functor, std::move(column_info), std::nullopt, stream, mr);
+  } else {
+    auto offset_data = detail::build_string_row_offsets(tbl, size_per_row, stream);
+    auto& row_sizes  = std::get<0>(offset_data);
+
+    auto row_size_iter = cudf::detail::make_counting_transform_iterator(
+      0, detail::row_size_functor(num_rows, row_sizes.data(), 0));
+
+    auto batch_info = detail::build_batches(num_rows, row_size_iter, fixed_width_only, stream, mr);
+
+    detail::string_row_offset_functor offset_functor(batch_info.batch_row_offsets);
+
+    return detail::convert_to_rows(tbl,
+                                   batch_info,
+                                   offset_functor,
+                                   std::move(column_info),
+                                   std::make_optional(std::move(std::get<1>(offset_data))),
+                                   stream,
+                                   mr);
+  }
+}
+
+std::vector<std::unique_ptr<column>> convert_to_rows_fixed_width_optimized(
+  table_view const& tbl, rmm::cuda_stream_view stream, rmm::mr::device_memory_resource* mr)
+{
+  auto const num_columns = tbl.num_columns();
+
+  std::vector<data_type> schema;
+  schema.resize(num_columns);
+  std::transform(
+    tbl.begin(), tbl.end(), schema.begin(), [](auto i) -> data_type { return i.type(); });
+
+  if (detail::are_all_fixed_width(schema)) {
+    std::vector<size_type> column_start;
+    std::vector<size_type> column_size;
+
+    int32_t const size_per_row =
+      detail::compute_fixed_width_layout(schema, column_start, column_size);
+    auto dev_column_start = make_device_uvector_async(column_start, stream, mr);
+    auto dev_column_size  = make_device_uvector_async(column_size, stream, mr);
+
+    // Make the number of rows per batch a multiple of 32 so we don't have to worry about splitting
+    // validity at a specific row offset.  This might change in the future.
+    auto const max_rows_per_batch =
+      util::round_down_safe(std::numeric_limits<size_type>::max() / size_per_row, 32);
+
+    auto const num_rows = tbl.num_rows();
+
+    // Get the pointers to the input columnar data ready
+    std::vector<const int8_t*> input_data;
+    std::vector<bitmask_type const*> input_nm;
+    for (size_type column_number = 0; column_number < num_columns; column_number++) {
+      column_view cv = tbl.column(column_number);
+      input_data.emplace_back(cv.data<int8_t>());
+      input_nm.emplace_back(cv.null_mask());
+    }
+    auto dev_input_data = make_device_uvector_async(input_data, stream, mr);
+    auto dev_input_nm   = make_device_uvector_async(input_nm, stream, mr);
+
+    using ScalarType = scalar_type_t<size_type>;
+    auto zero        = make_numeric_scalar(data_type(type_id::INT32), stream.value());
+    zero->set_valid_async(true, stream);
+    static_cast<ScalarType*>(zero.get())->set_value(0, stream);
+
+    auto step = make_numeric_scalar(data_type(type_id::INT32), stream.value());
+    step->set_valid_async(true, stream);
+    static_cast<ScalarType*>(step.get())->set_value(static_cast<size_type>(size_per_row), stream);
+
+    std::vector<std::unique_ptr<column>> ret;
+    for (size_type row_start = 0; row_start < num_rows; row_start += max_rows_per_batch) {
+      size_type row_count = num_rows - row_start;
+      row_count           = row_count > max_rows_per_batch ? max_rows_per_batch : row_count;
+      ret.emplace_back(detail::fixed_width_convert_to_rows(row_start,
+                                                           row_count,
+                                                           num_columns,
+                                                           size_per_row,
+                                                           dev_column_start,
+                                                           dev_column_size,
+                                                           dev_input_data,
+                                                           dev_input_nm,
+                                                           *zero,
+                                                           *step,
+                                                           stream,
+                                                           mr));
+    }
+
+    return ret;
+  } else {
+    CUDF_FAIL("Only fixed width types are currently supported");
+  }
+}
+
+namespace {
+
+/// @brief Calculates and sets null counts for specified columns
+void fixup_null_counts(std::vector<std::unique_ptr<column>>& output_columns,
+                       rmm::cuda_stream_view stream)
+{
+  for (auto& col : output_columns) {
+    col->set_null_count(cudf::detail::null_count(col->view().null_mask(), 0, col->size(), stream));
+  }
+}
+
+}  // namespace
+
+/**
+ * @brief convert from JCUDF row format to cudf columns
+ *
+ * @param input vector of list columns containing byte columns of the JCUDF row data
+ * @param schema incoming schema of the data
+ * @param stream stream to use for compute
+ * @param mr memory resource for returned data
+ * @return cudf table of the data
+ */
+std::unique_ptr<table> convert_from_rows(lists_column_view const& input,
+                                         std::vector<data_type> const& schema,
+                                         rmm::cuda_stream_view stream,
+                                         rmm::mr::device_memory_resource* mr)
+{
+  // verify that the types are what we expect
+  column_view child    = input.child();
+  auto const list_type = child.type().id();
+  CUDF_EXPECTS(list_type == type_id::INT8 || list_type == type_id::UINT8,
+               "Only a list of bytes is supported as input");
+
+  // convert any strings in the schema to two int32 columns
+  // This allows us to leverage the fixed-width copy code to fill in our offset and string length
+  // data.
+  std::vector<data_type> string_schema;
+  string_schema.reserve(schema.size());
+  for (auto i : schema) {
+    if (i.id() == type_id::STRING) {
+      string_schema.push_back(data_type(type_id::INT32));
+      string_schema.push_back(data_type(type_id::INT32));
+    } else {
+      string_schema.push_back(i);
+    }
+  }
+
+  auto const num_columns = string_schema.size();
+  auto const num_rows    = input.parent().size();
+
+  int device_id;
+  CUDF_CUDA_TRY(cudaGetDevice(&device_id));
+  int total_shmem_in_bytes;
+  CUDF_CUDA_TRY(
+    cudaDeviceGetAttribute(&total_shmem_in_bytes, cudaDevAttrMaxSharedMemoryPerBlock, device_id));
+
+#ifndef __CUDA_ARCH__  // __host__ code.
+  // Need to reduce total shmem available by the size of barriers in the kernel's shared memory
+  total_shmem_in_bytes -=
+    util::round_up_unsafe(sizeof(cuda::barrier<cuda::thread_scope_block>), 16ul);
+#endif  // __CUDA_ARCH__
+
+  auto const shmem_limit_per_tile = total_shmem_in_bytes;
+
+  auto column_info = detail::compute_column_information(string_schema.begin(), string_schema.end());
+  auto const size_per_row = util::round_up_unsafe(column_info.size_per_row, JCUDF_ROW_ALIGNMENT);
+
+  // Ideally we would check that the offsets are all the same, etc. but for now this is probably
+  // fine
+  CUDF_EXPECTS(size_per_row * num_rows <= child.size(), "The layout of the data appears to be off");
+  auto dev_col_starts = make_device_uvector_async(
+    column_info.column_starts, stream, rmm::mr::get_current_device_resource());
+  auto dev_col_sizes = make_device_uvector_async(
+    column_info.column_sizes, stream, rmm::mr::get_current_device_resource());
+
+  // Allocate the columns we are going to write into
+  std::vector<std::unique_ptr<column>> output_columns;
+  std::vector<std::unique_ptr<column>> string_row_offset_columns;
+  std::vector<std::unique_ptr<column>> string_length_columns;
+  std::vector<int8_t*> output_data;
+  std::vector<bitmask_type*> output_nm;
+  std::vector<int32_t*> string_row_offsets;
+  std::vector<int32_t*> string_lengths;
+  for (auto i : schema) {
+    auto make_col = [&output_data, &output_nm](data_type type,
+                                               size_type num_rows,
+                                               bool include_nm,
+                                               rmm::cuda_stream_view stream,
+                                               rmm::mr::device_memory_resource* mr) {
+      auto column =
+        make_fixed_width_column(type,
+                                num_rows,
+                                include_nm ? mask_state::UNINITIALIZED : mask_state::UNALLOCATED,
+                                stream,
+                                mr);
+      auto mut = column->mutable_view();
+      output_data.emplace_back(mut.data<int8_t>());
+      if (include_nm) { output_nm.emplace_back(mut.null_mask()); }
+      return column;
+    };
+    if (i.id() == type_id::STRING) {
+      auto const int32type = data_type(type_id::INT32);
+      auto offset_col =
+        make_col(int32type, num_rows, true, stream, rmm::mr::get_current_device_resource());
+      string_row_offsets.push_back(offset_col->mutable_view().data<int32_t>());
+      string_row_offset_columns.emplace_back(std::move(offset_col));
+      auto length_col =
+        make_col(int32type, num_rows, false, stream, rmm::mr::get_current_device_resource());
+      string_lengths.push_back(length_col->mutable_view().data<int32_t>());
+      string_length_columns.emplace_back(std::move(length_col));
+      // placeholder
+      output_columns.emplace_back(make_empty_column(type_id::STRING));
+    } else {
+      output_columns.emplace_back(make_col(i, num_rows, true, stream, mr));
+    }
+  }
+
+  auto dev_string_row_offsets =
+    make_device_uvector_async(string_row_offsets, stream, rmm::mr::get_current_device_resource());
+  auto dev_string_lengths =
+    make_device_uvector_async(string_lengths, stream, rmm::mr::get_current_device_resource());
+
+  // build the row_batches from the passed in list column
+  std::vector<detail::row_batch> row_batches;
+  row_batches.push_back(
+    {detail::row_batch{child.size(), num_rows, device_uvector<size_type>(0, stream)}});
+
+  auto dev_output_data =
+    make_device_uvector_async(output_data, stream, rmm::mr::get_current_device_resource());
+  auto dev_output_nm =
+    make_device_uvector_async(output_nm, stream, rmm::mr::get_current_device_resource());
+
+  // only ever get a single batch when going from rows, so boundaries are 0, num_rows
+  constexpr auto num_batches = 2;
+  device_uvector<size_type> gpu_batch_row_boundaries(num_batches, stream);
+
+  thrust::transform(rmm::exec_policy(stream),
+                    thrust::make_counting_iterator(0),
+                    thrust::make_counting_iterator(num_batches),
+                    gpu_batch_row_boundaries.begin(),
+                    cuda::proclaim_return_type<size_type>(
+                      [num_rows] __device__(auto i) { return i == 0 ? 0 : num_rows; }));
+
+  int info_count = 0;
+  detail::determine_tiles(column_info.column_sizes,
+                          column_info.column_starts,
+                          num_rows,
+                          num_rows,
+                          shmem_limit_per_tile,
+                          [&gpu_batch_row_boundaries, &info_count, &stream](
+                            int const start_col, int const end_col, int const tile_height) {
+                            info_count += detail::compute_tile_counts(
+                              gpu_batch_row_boundaries, tile_height, stream);
+                          });
+
+  // allocate space for tiles
+  device_uvector<detail::tile_info> gpu_tile_infos(info_count, stream);
+
+  int tile_offset = 0;
+  detail::determine_tiles(
+    column_info.column_sizes,
+    column_info.column_starts,
+    num_rows,
+    num_rows,
+    shmem_limit_per_tile,
+    [&gpu_batch_row_boundaries, &gpu_tile_infos, num_rows, &tile_offset, stream](
+      int const start_col, int const end_col, int const tile_height) {
+      tile_offset += detail::build_tiles(
+        {gpu_tile_infos.data() + tile_offset, gpu_tile_infos.size() - tile_offset},
+        gpu_batch_row_boundaries,
+        start_col,
+        end_col,
+        tile_height,
+        num_rows,
+        stream);
+    });
+
+  dim3 const blocks(gpu_tile_infos.size());
+
+  // validity needs to be calculated based on the actual number of final table columns
+  auto validity_tile_infos =
+    detail::build_validity_tile_infos(schema.size(), num_rows, shmem_limit_per_tile, row_batches);
+
+  auto dev_validity_tile_infos =
+    make_device_uvector_async(validity_tile_infos, stream, rmm::mr::get_current_device_resource());
+
+  dim3 const validity_blocks(validity_tile_infos.size());
+
+  if (dev_string_row_offsets.size() == 0) {
+    detail::fixed_width_row_offset_functor offset_functor(size_per_row);
+
+    detail::copy_from_rows<<<gpu_tile_infos.size(),
+                             NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                             total_shmem_in_bytes,
+                             stream.value()>>>(num_rows,
+                                               num_columns,
+                                               shmem_limit_per_tile,
+                                               offset_functor,
+                                               gpu_batch_row_boundaries.data(),
+                                               dev_output_data.data(),
+                                               dev_col_sizes.data(),
+                                               dev_col_starts.data(),
+                                               gpu_tile_infos,
+                                               child.data<int8_t>());
+
+    detail::copy_validity_from_rows<<<validity_tile_infos.size(),
+                                      NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                                      total_shmem_in_bytes,
+                                      stream.value()>>>(num_rows,
+                                                        num_columns,
+                                                        shmem_limit_per_tile,
+                                                        offset_functor,
+                                                        gpu_batch_row_boundaries.data(),
+                                                        dev_output_nm.data(),
+                                                        column_info.column_starts.back(),
+                                                        dev_validity_tile_infos,
+                                                        child.data<int8_t>());
+
+  } else {
+    detail::string_row_offset_functor offset_functor(device_span<size_type const>{input.offsets()});
+    detail::copy_from_rows<<<gpu_tile_infos.size(),
+                             NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                             total_shmem_in_bytes,
+                             stream.value()>>>(num_rows,
+                                               num_columns,
+                                               shmem_limit_per_tile,
+                                               offset_functor,
+                                               gpu_batch_row_boundaries.data(),
+                                               dev_output_data.data(),
+                                               dev_col_sizes.data(),
+                                               dev_col_starts.data(),
+                                               gpu_tile_infos,
+                                               child.data<int8_t>());
+
+    detail::copy_validity_from_rows<<<validity_tile_infos.size(),
+                                      NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                                      total_shmem_in_bytes,
+                                      stream.value()>>>(num_rows,
+                                                        num_columns,
+                                                        shmem_limit_per_tile,
+                                                        offset_functor,
+                                                        gpu_batch_row_boundaries.data(),
+                                                        dev_output_nm.data(),
+                                                        column_info.column_starts.back(),
+                                                        dev_validity_tile_infos,
+                                                        child.data<int8_t>());
+
+    std::vector<device_uvector<size_type>> string_col_offsets;
+    std::vector<rmm::device_uvector<char>> string_data_cols;
+    std::vector<size_type*> string_col_offset_ptrs;
+    std::vector<char*> string_data_col_ptrs;
+    for (auto& col_string_lengths : string_lengths) {
+      device_uvector<size_type> output_string_offsets(num_rows + 1, stream, mr);
+      auto tmp = cuda::proclaim_return_type<int32_t>(
+        [num_rows, col_string_lengths] __device__(auto const& i) {
+          return i < num_rows ? col_string_lengths[i] : 0;
+        });
+      auto bounded_iter = cudf::detail::make_counting_transform_iterator(0, tmp);
+      thrust::exclusive_scan(rmm::exec_policy(stream),
+                             bounded_iter,
+                             bounded_iter + num_rows + 1,
+                             output_string_offsets.begin());
+
+      // allocate destination string column
+      rmm::device_uvector<char> string_data(
+        output_string_offsets.element(num_rows, stream), stream, mr);
+
+      string_col_offset_ptrs.push_back(output_string_offsets.data());
+      string_data_col_ptrs.push_back(string_data.data());
+      string_col_offsets.push_back(std::move(output_string_offsets));
+      string_data_cols.push_back(std::move(string_data));
+    }
+    auto dev_string_col_offsets = make_device_uvector_async(
+      string_col_offset_ptrs, stream, rmm::mr::get_current_device_resource());
+    auto dev_string_data_cols = make_device_uvector_async(
+      string_data_col_ptrs, stream, rmm::mr::get_current_device_resource());
+
+    dim3 const string_blocks(
+      std::min(std::max(MIN_STRING_BLOCKS, num_rows / NUM_STRING_ROWS_PER_BLOCK_FROM_ROWS),
+               MAX_STRING_BLOCKS));
+
+    detail::copy_strings_from_rows<<<string_blocks,
+                                     NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                                     0,
+                                     stream.value()>>>(
+      offset_functor,
+      dev_string_row_offsets.data(),
+      dev_string_lengths.data(),
+      dev_string_col_offsets.data(),
+      dev_string_data_cols.data(),
+      child.data<int8_t>(),
+      num_rows,
+      static_cast<cudf::size_type>(string_col_offsets.size()));
+
+    // merge strings back into output_columns
+    int string_idx = 0;
+    for (int i = 0; i < static_cast<int>(schema.size()); ++i) {
+      if (schema[i].id() == type_id::STRING) {
+        // stuff real string column
+        auto string_data = string_row_offset_columns[string_idx].release()->release();
+        output_columns[i] =
+          make_strings_column(num_rows,
+                              std::make_unique<cudf::column>(
+                                std::move(string_col_offsets[string_idx]), rmm::device_buffer{}, 0),
+                              string_data_cols[string_idx].release(),
+                              0,
+                              std::move(*string_data.null_mask.release()));
+        // Null count set to 0, temporarily. Will be fixed up before return.
+        string_idx++;
+      }
+    }
+  }
+
+  // Set null counts, because output_columns are modified via mutable-view,
+  // in the kernel above.
+  // TODO(future): Consider setting null count in the kernel itself.
+  fixup_null_counts(output_columns, stream);
+
+  return std::make_unique<table>(std::move(output_columns));
+}
+
+std::unique_ptr<table> convert_from_rows_fixed_width_optimized(lists_column_view const& input,
+                                                               std::vector<data_type> const& schema,
+                                                               rmm::cuda_stream_view stream,
+                                                               rmm::mr::device_memory_resource* mr)
+{
+  // verify that the types are what we expect
+  column_view child    = input.child();
+  auto const list_type = child.type().id();
+  CUDF_EXPECTS(list_type == type_id::INT8 || list_type == type_id::UINT8,
+               "Only a list of bytes is supported as input");
+
+  auto const num_columns = schema.size();
+
+  if (detail::are_all_fixed_width(schema)) {
+    std::vector<size_type> column_start;
+    std::vector<size_type> column_size;
+
+    auto const num_rows     = input.parent().size();
+    auto const size_per_row = detail::compute_fixed_width_layout(schema, column_start, column_size);
+
+    // Ideally we would check that the offsets are all the same, etc. but for now this is probably
+    // fine
+    CUDF_EXPECTS(size_per_row * num_rows == child.size(),
+                 "The layout of the data appears to be off");
+    auto dev_column_start =
+      make_device_uvector_async(column_start, stream, rmm::mr::get_current_device_resource());
+    auto dev_column_size =
+      make_device_uvector_async(column_size, stream, rmm::mr::get_current_device_resource());
+
+    // Allocate the columns we are going to write into
+    std::vector<std::unique_ptr<column>> output_columns;
+    std::vector<int8_t*> output_data;
+    std::vector<bitmask_type*> output_nm;
+    for (int i = 0; i < static_cast<int>(num_columns); i++) {
+      auto column =
+        make_fixed_width_column(schema[i], num_rows, mask_state::UNINITIALIZED, stream, mr);
+      auto mut = column->mutable_view();
+      output_data.emplace_back(mut.data<int8_t>());
+      output_nm.emplace_back(mut.null_mask());
+      output_columns.emplace_back(std::move(column));
+    }
+
+    auto dev_output_data = make_device_uvector_async(output_data, stream, mr);
+    auto dev_output_nm   = make_device_uvector_async(output_nm, stream, mr);
+
+    dim3 blocks;
+    dim3 threads;
+    int shared_size =
+      detail::calc_fixed_width_kernel_dims(num_columns, num_rows, size_per_row, blocks, threads);
+
+    detail::copy_from_rows_fixed_width_optimized<<<blocks, threads, shared_size, stream.value()>>>(
+      num_rows,
+      num_columns,
+      size_per_row,
+      dev_column_start.data(),
+      dev_column_size.data(),
+      dev_output_data.data(),
+      dev_output_nm.data(),
+      child.data<int8_t>());
+
+    // Set null counts, because output_columns are modified via mutable-view,
+    // in the kernel above.
+    // TODO(future): Consider setting null count in the kernel itself.
+    fixup_null_counts(output_columns, stream);
+
+    return std::make_unique<table>(std::move(output_columns));
+  } else {
+    CUDF_FAIL("Only fixed width types are currently supported");
+  }
+}
+
+}  // namespace spark_rapids_jni
diff --git a/src/main/cpp/src/row_conversion.hpp b/src/main/cpp/src/row_conversion.hpp
new file mode 100644
index 0000000000..a5abd5b1bd
--- /dev/null
+++ b/src/main/cpp/src/row_conversion.hpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
+ *
+ * Licensed 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.
+ */
+
+#pragma once
+
+#include <cudf/lists/lists_column_view.hpp>
+#include <cudf/table/table_view.hpp>
+#include <cudf/utilities/default_stream.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+
+#include <memory>
+
+namespace spark_rapids_jni {
+
+std::vector<std::unique_ptr<cudf::column>> convert_to_rows_fixed_width_optimized(
+  cudf::table_view const& tbl,
+  // TODO need something for validity
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+std::vector<std::unique_ptr<cudf::column>> convert_to_rows(
+  cudf::table_view const& tbl,
+  // TODO need something for validity
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+std::unique_ptr<cudf::table> convert_from_rows_fixed_width_optimized(
+  cudf::lists_column_view const& input,
+  std::vector<cudf::data_type> const& schema,
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+std::unique_ptr<cudf::table> convert_from_rows(
+  cudf::lists_column_view const& input,
+  std::vector<cudf::data_type> const& schema,
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+}  // namespace spark_rapids_jni
diff --git a/src/main/cpp/src/string_to_float_cudf.cuh b/src/main/cpp/src/string_to_float_cudf.cuh
new file mode 100644
index 0000000000..5a7824d495
--- /dev/null
+++ b/src/main/cpp/src/string_to_float_cudf.cuh
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed 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.
+ */
+#pragma once
+
+#include <cudf/strings/detail/convert/is_float.cuh>
+#include <cudf/strings/string_view.cuh>
+
+#include <cmath>
+#include <limits>
+
+namespace spark_rapids_jni {
+namespace detail {
+
+/**
+ * @brief This function converts the given string into a
+ * floating point double value.
+ *
+ * This will also map strings containing "NaN", "Inf", etc.
+ * to the appropriate float values.
+ *
+ * This function will also handle scientific notation format.
+ *
+ * This function is a copy of cudf::strings::detail::stod with
+ * the namespace changed to spark_rapids_jni::detail and fixed
+ * an overflow bug of `exp_ten`. It is a short-term solution to
+ * resolve a bug in get_json_object. We should remove this file
+ * once the bug is fixed in cudf in long term.
+ * This diff is `if (exp_ten >= 1e8) break;`
+ */
+__device__ inline double stod(cudf::string_view const& d_str)
+{
+  char const* in_ptr = d_str.data();
+  char const* end    = in_ptr + d_str.size_bytes();
+  if (end == in_ptr) return 0.0;
+  double sign{1.0};
+  if (*in_ptr == '-' || *in_ptr == '+') {
+    sign = (*in_ptr == '-' ? -1 : 1);
+    ++in_ptr;
+  }
+
+  constexpr double infinity      = std::numeric_limits<double>::infinity();
+  constexpr uint64_t max_holding = (std::numeric_limits<uint64_t>::max() - 9L) / 10L;
+
+  // special strings: NaN, Inf
+  if ((in_ptr < end) && *in_ptr > '9') {
+    auto const inf_nan = cudf::string_view(in_ptr, static_cast<cudf::size_type>(end - in_ptr));
+    if (cudf::strings::detail::is_nan_str(inf_nan)) { return nan(""); }
+    if (cudf::strings::detail::is_inf_str(inf_nan)) { return sign * infinity; }
+  }
+
+  // Parse and store the mantissa as much as we can,
+  // until we are about to exceed the limit of uint64_t
+  uint64_t digits = 0;
+  int exp_off     = 0;
+  bool decimal    = false;
+  while (in_ptr < end) {
+    char ch = *in_ptr;
+    if (ch == '.') {
+      decimal = true;
+      ++in_ptr;
+      continue;
+    }
+    if (ch < '0' || ch > '9') break;
+    if (digits > max_holding)
+      exp_off += (int)!decimal;
+    else {
+      digits = (digits * 10L) + static_cast<uint64_t>(ch - '0');
+      if (digits > max_holding) {
+        digits = digits / 10L;
+        exp_off += (int)!decimal;
+      } else
+        exp_off -= (int)decimal;
+    }
+    ++in_ptr;
+  }
+  if (digits == 0) { return sign * static_cast<double>(0); }
+
+  // check for exponent char
+  int exp_ten  = 0;
+  int exp_sign = 1;
+  if (in_ptr < end) {
+    char ch = *in_ptr++;
+    if (ch == 'e' || ch == 'E') {
+      if (in_ptr < end) {
+        ch = *in_ptr;
+        if (ch == '-' || ch == '+') {
+          exp_sign = (ch == '-' ? -1 : 1);
+          ++in_ptr;
+        }
+        while (in_ptr < end) {
+          ch = *in_ptr++;
+          if (ch < '0' || ch > '9') break;
+          exp_ten = (exp_ten * 10) + (int)(ch - '0');
+          if (exp_ten >= 1e8) break;
+        }
+      }
+    }
+  }
+
+  int const num_digits = static_cast<int>(log10(static_cast<double>(digits))) + 1;
+  exp_ten *= exp_sign;
+  exp_ten += exp_off;
+  exp_ten += num_digits - 1;
+  if (exp_ten > std::numeric_limits<double>::max_exponent10) {
+    return sign > 0 ? infinity : -infinity;
+  }
+
+  double base = sign * static_cast<double>(digits);
+
+  exp_ten += 1 - num_digits;
+  // If 10^exp_ten would result in a subnormal value, the base and
+  // exponent should be adjusted so that 10^exp_ten is a normal value
+  auto const subnormal_shift = std::numeric_limits<double>::min_exponent10 - exp_ten;
+  if (subnormal_shift > 0) {
+    // Handle subnormal values. Ensure that both base and exponent are
+    // normal values before computing their product.
+    base = base / exp10(static_cast<double>(num_digits - 1 + subnormal_shift));
+    exp_ten += num_digits - 1;  // adjust exponent
+    auto const exponent = exp10(static_cast<double>(exp_ten + subnormal_shift));
+    return base * exponent;
+  }
+
+  double const exponent = exp10(static_cast<double>(std::abs(exp_ten)));
+  return exp_ten < 0 ? base / exponent : base * exponent;
+}
+
+}  // namespace detail
+}  // namespace spark_rapids_jni
diff --git a/src/main/cpp/src/timezones.cu b/src/main/cpp/src/timezones.cu
index 43fff55b3b..30f19d9df0 100644
--- a/src/main/cpp/src/timezones.cu
+++ b/src/main/cpp/src/timezones.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,11 +25,11 @@
 #include <cudf/table/table.hpp>
 #include <cudf/types.hpp>
 
-#include <thrust/binary_search.h>
-
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
+#include <thrust/binary_search.h>
+
 using column                   = cudf::column;
 using column_device_view       = cudf::column_device_view;
 using column_view              = cudf::column_view;
diff --git a/src/main/cpp/src/xxhash64.cu b/src/main/cpp/src/xxhash64.cu
index 8c0b1b8766..78cc4651bd 100644
--- a/src/main/cpp/src/xxhash64.cu
+++ b/src/main/cpp/src/xxhash64.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,9 +23,8 @@
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
-#include <thrust/tabulate.h>
-
 #include <cuda/functional>
+#include <thrust/tabulate.h>
 
 namespace spark_rapids_jni {
 
diff --git a/src/main/cpp/src/zorder.cu b/src/main/cpp/src/zorder.cu
index f9c2d4da07..405b046528 100644
--- a/src/main/cpp/src/zorder.cu
+++ b/src/main/cpp/src/zorder.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,12 +24,11 @@
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
+#include <cuda/functional>
 #include <thrust/for_each.h>
 #include <thrust/iterator/constant_iterator.h>
 #include <thrust/iterator/counting_iterator.h>
 
-#include <cuda/functional>
-
 namespace {
 
 // pretends to be an array of uint32_t, but really only stores
diff --git a/src/main/cpp/src/zorder.hpp b/src/main/cpp/src/zorder.hpp
index 9268f5b71e..c3fffc9b48 100644
--- a/src/main/cpp/src/zorder.hpp
+++ b/src/main/cpp/src/zorder.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,12 +16,13 @@
 
 #pragma once
 
-#include <memory>
-
 #include <cudf/lists/lists_column_view.hpp>
 #include <cudf/table/table_view.hpp>
+
 #include <rmm/cuda_stream_view.hpp>
 
+#include <memory>
+
 namespace spark_rapids_jni {
 
 std::unique_ptr<cudf::column> interleave_bits(
diff --git a/src/main/cpp/tests/CMakeLists.txt b/src/main/cpp/tests/CMakeLists.txt
index 617df6dfde..55a7b7a887 100644
--- a/src/main/cpp/tests/CMakeLists.txt
+++ b/src/main/cpp/tests/CMakeLists.txt
@@ -1,5 +1,5 @@
 #=============================================================================
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -60,6 +60,9 @@ ConfigureTest(CAST_FLOAT_TO_STRING
 ConfigureTest(DATETIME_REBASE
     datetime_rebase.cpp)
 
+ConfigureTest(ROW_CONVERSION
+    row_conversion.cpp)
+
 ConfigureTest(HASH
     hash.cpp)
 
diff --git a/src/main/cpp/tests/cast_decimal_to_string.cpp b/src/main/cpp/tests/cast_decimal_to_string.cpp
index ba1aaf05c8..b73afb103a 100644
--- a/src/main/cpp/tests/cast_decimal_to_string.cpp
+++ b/src/main/cpp/tests/cast_decimal_to_string.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#include <cast_string.hpp>
-
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/iterator_utilities.hpp>
@@ -26,6 +24,8 @@
 
 #include <rmm/device_uvector.hpp>
 
+#include <cast_string.hpp>
+
 #include <limits>
 
 using namespace cudf;
diff --git a/src/main/cpp/tests/cast_float_to_string.cpp b/src/main/cpp/tests/cast_float_to_string.cpp
index 1ae066fe42..a118ec7fe4 100644
--- a/src/main/cpp/tests/cast_float_to_string.cpp
+++ b/src/main/cpp/tests/cast_float_to_string.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include <cast_string.hpp>
-
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_wrapper.hpp>
 
 #include <rmm/device_uvector.hpp>
 
+#include <cast_string.hpp>
+
 #include <limits>
 
 using namespace cudf;
diff --git a/src/main/cpp/tests/cast_string.cpp b/src/main/cpp/tests/cast_string.cpp
index 1f7aaaad21..efad547869 100644
--- a/src/main/cpp/tests/cast_string.cpp
+++ b/src/main/cpp/tests/cast_string.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#include <cast_string.hpp>
-
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/iterator_utilities.hpp>
@@ -26,6 +24,8 @@
 
 #include <rmm/device_uvector.hpp>
 
+#include <cast_string.hpp>
+
 #include <limits>
 
 using namespace cudf;
diff --git a/src/main/cpp/tests/datetime_rebase.cpp b/src/main/cpp/tests/datetime_rebase.cpp
index 4fbf45e09d..8ac1ed45f9 100644
--- a/src/main/cpp/tests/datetime_rebase.cpp
+++ b/src/main/cpp/tests/datetime_rebase.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,13 +17,14 @@
 #include <datetime_rebase.hpp>
 //
 
+#include <cudf_test/base_fixture.hpp>
+#include <cudf_test/column_utilities.hpp>
+#include <cudf_test/column_wrapper.hpp>
+
 #include <cudf/strings/convert/convert_datetime.hpp>
 #include <cudf/strings/strings_column_view.hpp>
 #include <cudf/unary.hpp>
 #include <cudf/wrappers/timestamps.hpp>
-#include <cudf_test/base_fixture.hpp>
-#include <cudf_test/column_utilities.hpp>
-#include <cudf_test/column_wrapper.hpp>
 
 using days_col = cudf::test::fixed_width_column_wrapper<cudf::timestamp_D, cudf::timestamp_D::rep>;
 using micros_col =
diff --git a/src/main/cpp/tests/hash.cpp b/src/main/cpp/tests/hash.cpp
index 5f6a71ab29..265603a9af 100644
--- a/src/main/cpp/tests/hash.cpp
+++ b/src/main/cpp/tests/hash.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-#include <cudf/detail/iterator.cuh>
-#include <cudf/fixed_point/fixed_point.hpp>
-#include <cudf/hashing.hpp>
+#include "hash.cuh"
 
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_utilities.hpp>
@@ -24,7 +22,9 @@
 #include <cudf_test/iterator_utilities.hpp>
 #include <cudf_test/type_lists.hpp>
 
-#include "hash.cuh"
+#include <cudf/detail/iterator.cuh>
+#include <cudf/fixed_point/fixed_point.hpp>
+#include <cudf/hashing.hpp>
 
 constexpr cudf::test::debug_output_level verbosity{cudf::test::debug_output_level::ALL_ERRORS};
 
diff --git a/src/main/cpp/tests/parse_uri.cpp b/src/main/cpp/tests/parse_uri.cpp
index 09f238e18c..a042ff46e9 100644
--- a/src/main/cpp/tests/parse_uri.cpp
+++ b/src/main/cpp/tests/parse_uri.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-#include <parse_uri.hpp>
-
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_utilities.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/debug_utilities.hpp>
 #include <cudf_test/table_utilities.hpp>
 
+#include <parse_uri.hpp>
+
 struct ParseURIProtocolTests : public cudf::test::BaseFixture {};
 struct ParseURIHostTests : public cudf::test::BaseFixture {};
 struct ParseURIQueryTests : public cudf::test::BaseFixture {};
diff --git a/src/main/cpp/tests/row_conversion.cpp b/src/main/cpp/tests/row_conversion.cpp
new file mode 100644
index 0000000000..7a0565def9
--- /dev/null
+++ b/src/main/cpp/tests/row_conversion.cpp
@@ -0,0 +1,1029 @@
+/*
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
+ *
+ * Licensed 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 <cudf_test/base_fixture.hpp>
+#include <cudf_test/column_utilities.hpp>
+#include <cudf_test/column_wrapper.hpp>
+#include <cudf_test/table_utilities.hpp>
+
+#include <cudf/column/column_view.hpp>
+#include <cudf/detail/iterator.cuh>
+#include <cudf/lists/lists_column_view.hpp>
+#include <cudf/types.hpp>
+
+#include <row_conversion.hpp>
+
+#include <limits>
+#include <random>
+
+struct ColumnToRowTests : public cudf::test::BaseFixture {};
+struct RowToColumnTests : public cudf::test::BaseFixture {};
+
+TEST_F(ColumnToRowTests, Single)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1});
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::INT32}};
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*new_rows[i]), schema);
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, SimpleString)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1, 0, 1, 0, -1});
+  cudf::test::strings_column_wrapper b(
+    {"hello", "world", "this is a really long string to generate a longer row", "dlrow", "olleh"});
+  cudf::table_view in(std::vector<cudf::column_view>{a, b});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::INT32}};
+
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(new_rows[0]->size(), 5);
+}
+
+TEST_F(ColumnToRowTests, DoubleString)
+{
+  cudf::test::strings_column_wrapper a(
+    {"hello", "world", "this is a really long string to generate a longer row", "dlrow", "olleh"});
+  cudf::test::fixed_width_column_wrapper<int32_t> b({0, 1, 2, 3, 4});
+  cudf::test::strings_column_wrapper c({"world",
+                                        "hello",
+                                        "this string isn't as long",
+                                        "this one isn't so short though when you think about it",
+                                        "dlrow"});
+  cudf::table_view in(std::vector<cudf::column_view>{a, b, c});
+
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(new_rows[0]->size(), 5);
+}
+
+TEST_F(ColumnToRowTests, BigStrings)
+{
+  char const* TEST_STRINGS[] = {
+    "These",
+    "are",
+    "the",
+    "test",
+    "strings",
+    "that",
+    "we",
+    "have",
+    "some are really long",
+    "and some are kinda short",
+    "They are all over on purpose with different sizes for the strings in order to test the code "
+    "on all different lengths of strings",
+    "a",
+    "good test",
+    "is required to produce reasonable confidence that this is working"};
+  auto num_generator =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  auto string_generator =
+    cudf::detail::make_counting_transform_iterator(0, [&](auto i) -> char const* {
+      return TEST_STRINGS[rand() % (sizeof(TEST_STRINGS) / sizeof(TEST_STRINGS[0]))];
+    });
+
+  auto const num_rows = 50;
+  auto const num_cols = 50;
+  std::vector<cudf::data_type> schema;
+
+  std::vector<cudf::test::detail::column_wrapper> cols;
+  std::vector<cudf::column_view> views;
+
+  for (auto col = 0; col < num_cols; ++col) {
+    if (rand() % 2) {
+      cols.emplace_back(
+        cudf::test::fixed_width_column_wrapper<int32_t>(num_generator, num_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::data_type{cudf::type_id::INT32});
+    } else {
+      cols.emplace_back(
+        cudf::test::strings_column_wrapper(string_generator, string_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::type_id::STRING);
+    }
+  }
+
+  cudf::table_view in(views);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(new_rows[0]->size(), num_rows);
+}
+
+TEST_F(ColumnToRowTests, ManyStrings)
+{
+  char const* TEST_STRINGS[] = {
+    "These",
+    "are",
+    "the",
+    "test",
+    "strings",
+    "that",
+    "we",
+    "have",
+    "some are really long",
+    "and some are kinda short",
+    "They are all over on purpose with different sizes for the strings in order to test the code "
+    "on all different lengths of strings",
+    "a",
+    "good test",
+    "is required to produce reasonable confidence that this is working",
+    "some strings",
+    "are split into multiple strings",
+    "some strings have all their data",
+    "lots of choices of strings and sizes is sure to test the offset calculation code to ensure "
+    "that even a really long string ends up in the correct spot for the final destination allowing "
+    "for even crazy run-on sentences to be inserted into the data"};
+  auto num_generator =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  auto string_generator =
+    cudf::detail::make_counting_transform_iterator(0, [&](auto i) -> char const* {
+      return TEST_STRINGS[rand() % (sizeof(TEST_STRINGS) / sizeof(TEST_STRINGS[0]))];
+    });
+
+  auto const num_rows = 1'000'000;
+  auto const num_cols = 50;
+  std::vector<cudf::data_type> schema;
+
+  std::vector<cudf::test::detail::column_wrapper> cols;
+  std::vector<cudf::column_view> views;
+
+  for (auto col = 0; col < num_cols; ++col) {
+    if (rand() % 2) {
+      cols.emplace_back(
+        cudf::test::fixed_width_column_wrapper<int32_t>(num_generator, num_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::data_type{cudf::type_id::INT32});
+    } else {
+      cols.emplace_back(
+        cudf::test::strings_column_wrapper(string_generator, string_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::type_id::STRING);
+    }
+  }
+
+  cudf::table_view in(views);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(new_rows[0]->size(), num_rows);
+}
+
+TEST_F(ColumnToRowTests, Simple)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1, 0, 1});
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::INT32}};
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Tall)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  cudf::test::fixed_width_column_wrapper<int32_t> a(r, r + (size_t)4096);
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::INT32}};
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Wide)
+{
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  for (int i = 0; i < 256; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>({rand()}));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, SingleByteWide)
+{
+  std::vector<cudf::test::fixed_width_column_wrapper<int8_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  for (int i = 0; i < 256; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int8_t>({rand()}));
+    views.push_back(cols.back());
+
+    schema.push_back(cudf::data_type{cudf::type_id::INT8});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Non2Power)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  constexpr auto num_rows = 6 * 1024 + 557;
+  for (int i = 0; i < 131; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    for (int j = 0; j < old_tbl->num_columns(); ++j) {
+      CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(old_tbl->get_column(j), new_tbl->get_column(j));
+    }
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Big)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 28 columns of 1 million rows
+  constexpr auto num_rows = 1024 * 1024;
+  for (int i = 0; i < 28; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    for (int j = 0; j < old_tbl->num_columns(); ++j) {
+      CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(old_tbl->get_column(j), new_tbl->get_column(j));
+    }
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Bigger)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 128 columns of 1 million rows
+  constexpr auto num_rows = 1024 * 1024;
+  for (int i = 0; i < 128; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    for (int j = 0; j < old_tbl->num_columns(); ++j) {
+      CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(old_tbl->get_column(j), new_tbl->get_column(j));
+    }
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Biggest)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 128 columns of 2 million rows
+  constexpr auto num_rows = 2 * 1024 * 1024;
+  for (int i = 0; i < 128; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    for (int j = 0; j < old_tbl->num_columns(); ++j) {
+      CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(old_tbl->get_column(j), new_tbl->get_column(j));
+    }
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Single)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1});
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+
+  auto old_rows = spark_rapids_jni::convert_to_rows(in);
+  std::vector<cudf::data_type> schema{cudf::data_type{cudf::type_id::INT32}};
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Simple)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1, 0, 1});
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  std::vector<cudf::data_type> schema{cudf::data_type{cudf::type_id::INT32}};
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Tall)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  cudf::test::fixed_width_column_wrapper<int32_t> a(r, r + (size_t)4096);
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  std::vector<cudf::data_type> schema;
+  schema.reserve(in.num_columns());
+  for (auto col = in.begin(); col < in.end(); ++col) {
+    schema.push_back(col->type());
+  }
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Wide)
+{
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+
+  for (int i = 0; i < 256; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>({i}));  // rand()}));
+    views.push_back(cols.back());
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  std::vector<cudf::data_type> schema;
+  schema.reserve(in.num_columns());
+  for (auto col = in.begin(); col < in.end(); ++col) {
+    schema.push_back(col->type());
+  }
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, SingleByteWide)
+{
+  std::vector<cudf::test::fixed_width_column_wrapper<int8_t>> cols;
+  std::vector<cudf::column_view> views;
+
+  for (int i = 0; i < 256; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int8_t>({rand()}));
+    views.push_back(cols.back());
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  std::vector<cudf::data_type> schema;
+  schema.reserve(in.num_columns());
+  for (auto col = in.begin(); col < in.end(); ++col) {
+    schema.push_back(col->type());
+  }
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, AllTypes)
+{
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema{cudf::data_type{cudf::type_id::INT64},
+                                      cudf::data_type{cudf::type_id::FLOAT64},
+                                      cudf::data_type{cudf::type_id::INT8},
+                                      cudf::data_type{cudf::type_id::BOOL8},
+                                      cudf::data_type{cudf::type_id::FLOAT32},
+                                      cudf::data_type{cudf::type_id::INT8},
+                                      cudf::data_type{cudf::type_id::INT32},
+                                      cudf::data_type{cudf::type_id::INT64}};
+
+  cudf::test::fixed_width_column_wrapper<int64_t> c0({3, 9, 4, 2, 20, 0}, {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_width_column_wrapper<double> c1({5.0, 9.5, 0.9, 7.23, 2.8, 0.0},
+                                                    {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_width_column_wrapper<int8_t> c2({5, 1, 0, 2, 7, 0}, {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_width_column_wrapper<bool> c3({true, false, false, true, false, false},
+                                                  {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_width_column_wrapper<float> c4({1.0f, 3.5f, 5.9f, 7.1f, 9.8f, 0.0f},
+                                                   {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_width_column_wrapper<int8_t> c5({2, 3, 4, 5, 9, 0}, {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_point_column_wrapper<int32_t> c6(
+    {-300, 500, 950, 90, 723, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, numeric::scale_type{-2});
+  cudf::test::fixed_point_column_wrapper<int64_t> c7(
+    {-80, 30, 90, 20, 200, 0}, {1, 1, 1, 1, 1, 1, 0}, numeric::scale_type{-1});
+
+  cudf::table_view in({c0, c1, c2, c3, c4, c5, c6, c7});
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*new_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, AllTypesLarge)
+{
+  std::vector<cudf::column> cols;
+  std::vector<cudf::data_type> schema{};
+
+  // 15 columns of each type with 1 million entries
+  constexpr int num_rows{1024 * 1024 * 1};
+
+  std::default_random_engine re;
+  std::uniform_real_distribution<double> rand_double(std::numeric_limits<double>::min(),
+                                                     std::numeric_limits<double>::max());
+  std::uniform_int_distribution<int64_t> rand_int64(std::numeric_limits<int64_t>::min(),
+                                                    std::numeric_limits<int64_t>::max());
+  auto r = cudf::detail::make_counting_transform_iterator(
+    0, [&](auto i) -> int64_t { return rand_int64(re); });
+  auto d = cudf::detail::make_counting_transform_iterator(
+    0, [&](auto i) -> double { return rand_double(re); });
+
+  auto all_valid  = cudf::detail::make_counting_transform_iterator(0, [](auto i) { return 1; });
+  auto none_valid = cudf::detail::make_counting_transform_iterator(0, [](auto i) { return 0; });
+  auto most_valid = cudf::detail::make_counting_transform_iterator(
+    0, [](auto i) { return rand() % 2 == 0 ? 0 : 1; });
+  auto few_valid = cudf::detail::make_counting_transform_iterator(
+    0, [](auto i) { return rand() % 13 == 0 ? 1 : 0; });
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_width_column_wrapper<int8_t>(r, r + num_rows, all_valid)
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::INT8});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_width_column_wrapper<int16_t>(r, r + num_rows, few_valid)
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::INT16});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    if (i < 5) {
+      cols.push_back(*cudf::test::fixed_width_column_wrapper<int32_t>(r, r + num_rows, few_valid)
+                        .release()
+                        .release());
+    } else {
+      cols.push_back(*cudf::test::fixed_width_column_wrapper<int32_t>(r, r + num_rows, none_valid)
+                        .release()
+                        .release());
+    }
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_width_column_wrapper<float>(d, d + num_rows, most_valid)
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::FLOAT32});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_width_column_wrapper<double>(d, d + num_rows, most_valid)
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::FLOAT64});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_width_column_wrapper<bool>(r, r + num_rows, few_valid)
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::BOOL8});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(
+      *cudf::test::fixed_width_column_wrapper<cudf::timestamp_ms, cudf::timestamp_ms::rep>(
+         r, r + num_rows, all_valid)
+         .release()
+         .release());
+    schema.push_back(cudf::data_type{cudf::type_id::TIMESTAMP_MILLISECONDS});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(
+      *cudf::test::fixed_width_column_wrapper<cudf::timestamp_D, cudf::timestamp_D::rep>(
+         r, r + num_rows, most_valid)
+         .release()
+         .release());
+    schema.push_back(cudf::data_type{cudf::type_id::TIMESTAMP_DAYS});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_point_column_wrapper<int32_t>(
+                      r, r + num_rows, all_valid, numeric::scale_type{-2})
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::DECIMAL32});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_point_column_wrapper<int64_t>(
+                      r, r + num_rows, most_valid, numeric::scale_type{-1})
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::DECIMAL64});
+  }
+
+  std::vector<cudf::column_view> views(cols.begin(), cols.end());
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*new_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Non2Power)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  constexpr auto num_rows = 6 * 1024 + 557;
+  for (int i = 0; i < 131; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Big)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 28 columns of 1 million rows
+  constexpr auto num_rows = 1024 * 1024;
+  for (int i = 0; i < 28; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Bigger)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 128 columns of 1 million rows
+  constexpr auto num_rows = 1024 * 1024;
+  for (int i = 0; i < 128; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Biggest)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 128 columns of 2 million rows
+  constexpr auto num_rows = 2 * 1024 * 1024;
+  for (int i = 0; i < 128; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*new_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, SimpleString)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1, 0, 1, 0, -1});
+  cudf::test::strings_column_wrapper b(
+    {"hello", "world", "this is a really long string to generate a longer row", "dlrow", "olleh"});
+  cudf::table_view in(std::vector<cudf::column_view>{a, b});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::INT32},
+                                         cudf::data_type{cudf::type_id::STRING}};
+
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+  EXPECT_EQ(new_rows.size(), 1);
+  for (auto& row : new_rows) {
+    auto new_cols = spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*row), schema);
+    EXPECT_EQ(row->size(), 5);
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(in, *new_cols);
+  }
+}
+
+TEST_F(RowToColumnTests, DoubleString)
+{
+  cudf::test::strings_column_wrapper a(
+    {"hello", "world", "this is a really long string to generate a longer row", "dlrow", "olleh"});
+  cudf::test::fixed_width_column_wrapper<int32_t> b({0, 1, 2, 3, 4});
+  cudf::test::strings_column_wrapper c({"world",
+                                        "hello",
+                                        "this string isn't as long",
+                                        "this one isn't so short though when you think about it",
+                                        "dlrow"});
+  cudf::table_view in(std::vector<cudf::column_view>{a, b, c});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::STRING},
+                                         cudf::data_type{cudf::type_id::INT32},
+                                         cudf::data_type{cudf::type_id::STRING}};
+
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (uint i = 0; i < new_rows.size(); ++i) {
+    auto new_cols =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*new_rows[i]), schema);
+
+    EXPECT_EQ(new_rows[0]->size(), 5);
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(in, *new_cols);
+  }
+}
+
+TEST_F(RowToColumnTests, BigStrings)
+{
+  char const* TEST_STRINGS[] = {
+    "These",
+    "are",
+    "the",
+    "test",
+    "strings",
+    "that",
+    "we",
+    "have",
+    "some are really long",
+    "and some are kinda short",
+    "They are all over on purpose with different sizes for the strings in order to test the code "
+    "on all different lengths of strings",
+    "a",
+    "good test",
+    "is required to produce reasonable confidence that this is working"};
+  auto num_generator =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  auto string_generator =
+    cudf::detail::make_counting_transform_iterator(0, [&](auto i) -> char const* {
+      return TEST_STRINGS[rand() % (sizeof(TEST_STRINGS) / sizeof(TEST_STRINGS[0]))];
+    });
+
+  auto const num_rows = 50;
+  auto const num_cols = 50;
+  std::vector<cudf::data_type> schema;
+
+  std::vector<cudf::test::detail::column_wrapper> cols;
+  std::vector<cudf::column_view> views;
+
+  for (auto col = 0; col < num_cols; ++col) {
+    if (rand() % 2) {
+      cols.emplace_back(
+        cudf::test::fixed_width_column_wrapper<int32_t>(num_generator, num_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::data_type{cudf::type_id::INT32});
+    } else {
+      cols.emplace_back(
+        cudf::test::strings_column_wrapper(string_generator, string_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::type_id::STRING);
+    }
+  }
+
+  cudf::table_view in(views);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (auto& i : new_rows) {
+    auto new_cols = spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*i), schema);
+
+    auto in_view = cudf::slice(in, {0, new_cols->num_rows()});
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(in_view[0], *new_cols);
+  }
+}
+
+TEST_F(RowToColumnTests, ManyStrings)
+{
+  // The sizing of this test is very sensitive to the state of the random number generator,
+  // i.e., depending on the order of execution, the number of times the largest string is
+  // selected will lead to out-of-memory exceptions. Seeding the RNG here helps prevent that.
+  srand(1);
+  char const* TEST_STRINGS[] = {
+    "These",
+    "are",
+    "the",
+    "test",
+    "strings",
+    "that",
+    "we",
+    "have",
+    "some are really long",
+    "and some are kinda short",
+    "They are all over on purpose with different sizes for the strings in order to test the code "
+    "on all different lengths of strings",
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine ",
+    "a",
+    "good test",
+    "is required to produce reasonable confidence that this is working",
+    "some strings",
+    "are split into multiple strings",
+    "some strings have all their data",
+    "lots of choices of strings and sizes is sure to test the offset calculation code to ensure "
+    "that even a really long string ends up in the correct spot for the final destination allowing "
+    "for even crazy run-on sentences to be inserted into the data"};
+  auto num_generator =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  auto string_generator =
+    cudf::detail::make_counting_transform_iterator(0, [&](auto i) -> char const* {
+      return TEST_STRINGS[rand() % (sizeof(TEST_STRINGS) / sizeof(TEST_STRINGS[0]))];
+    });
+
+  auto const num_rows = 300'000;
+  auto const num_cols = 50;
+  std::vector<cudf::data_type> schema;
+
+  std::vector<cudf::test::detail::column_wrapper> cols;
+  std::vector<cudf::column_view> views;
+
+  for (auto col = 0; col < num_cols; ++col) {
+    if (rand() % 2) {
+      cols.emplace_back(
+        cudf::test::fixed_width_column_wrapper<int32_t>(num_generator, num_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::data_type{cudf::type_id::INT32});
+    } else {
+      cols.emplace_back(
+        cudf::test::strings_column_wrapper(string_generator, string_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::type_id::STRING);
+    }
+  }
+
+  cudf::table_view in(views);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (auto& i : new_rows) {
+    auto new_cols = spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*i), schema);
+
+    auto in_view = cudf::slice(in, {0, new_cols->num_rows()});
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(in_view[0], *new_cols);
+  }
+}
diff --git a/src/main/cpp/tests/utilities.cpp b/src/main/cpp/tests/utilities.cpp
index 72b16543f6..19b53c2925 100644
--- a/src/main/cpp/tests/utilities.cpp
+++ b/src/main/cpp/tests/utilities.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,12 +16,13 @@
 
 #include "utilities.hpp"
 
-#include <cudf/types.hpp>
+#include "gtest/gtest.h"
+
 #include <cudf_test/base_fixture.hpp>
 
-#include <rmm/device_uvector.hpp>
+#include <cudf/types.hpp>
 
-#include "gtest/gtest.h"
+#include <rmm/device_uvector.hpp>
 
 class UtilitiesTest : public cudf::test::BaseFixture {};
 
diff --git a/src/main/java/com/nvidia/spark/rapids/jni/JSONUtils.java b/src/main/java/com/nvidia/spark/rapids/jni/JSONUtils.java
new file mode 100644
index 0000000000..4ff9c91a3f
--- /dev/null
+++ b/src/main/java/com/nvidia/spark/rapids/jni/JSONUtils.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed 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.
+ */
+
+package com.nvidia.spark.rapids.jni;
+
+import ai.rapids.cudf.*;
+
+public class JSONUtils {
+  static {
+    NativeDepsLoader.loadNativeDeps();
+  }
+
+  // Keep the same with `max_path_depth` in `get_json_object.cu'
+  public static final int MAX_PATH_DEPTH = 16;
+
+  public enum PathInstructionType {
+    SUBSCRIPT,
+    WILDCARD,
+    KEY,
+    INDEX,
+    NAMED
+  }
+
+  public static class PathInstructionJni {
+    // type: Int, name: String, index: Long
+    private final int type;
+    private final String name;
+    private final long index;
+
+    public PathInstructionJni(PathInstructionType type, String name, long index) {
+      this.type = type.ordinal();
+      this.name = name;
+      this.index = index;
+    }
+  }
+
+  public static ColumnVector getJsonObject(ColumnVector input, PathInstructionJni[] path_instructions) {
+    assert(input.getType().equals(DType.STRING)) : "column must be a String";
+    return new ColumnVector(getJsonObject(input.getNativeView(), path_instructions));
+  }
+
+  private static native long getJsonObject(long input, PathInstructionJni[] path_instructions);
+}
diff --git a/src/test/java/com/nvidia/spark/rapids/jni/GetJsonObjectTest.java b/src/test/java/com/nvidia/spark/rapids/jni/GetJsonObjectTest.java
new file mode 100644
index 0000000000..ea23c4c9ba
--- /dev/null
+++ b/src/test/java/com/nvidia/spark/rapids/jni/GetJsonObjectTest.java
@@ -0,0 +1,604 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed 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.
+ */
+
+package com.nvidia.spark.rapids.jni;
+
+import ai.rapids.cudf.ColumnVector;
+import org.junit.jupiter.api.Test;
+
+import static ai.rapids.cudf.AssertUtils.assertColumnsAreEqual;
+
+public class GetJsonObjectTest {
+  /**
+   * Test: query is $.k
+   */
+  @Test
+  void getJsonObjectTest() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("k") };
+    try (ColumnVector jsonCv = ColumnVector.fromStrings(
+        "{\"k\": \"v\"}");
+        ColumnVector expected = ColumnVector.fromStrings(
+            "v");
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test: query is $.k1
+   */
+  @Test
+  void getJsonObjectTest2() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(),
+        namedPath("k1_111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111")
+    };
+
+    String JSON = "{\"k1_111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\""
+        +
+        ":\"v1_111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\"}";
+    String expectedStr = "v1_111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON, JSON, JSON, JSON, JSON, JSON, JSON);
+        ColumnVector expected = ColumnVector.fromStrings(
+            expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test: query is $.k1.k2
+   */
+  @Test
+  void getJsonObjectTest3() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("k1"), keyPath(), namedPath("k2")
+    };
+    String JSON = "{\"k1\":{\"k2\":\"v2\"}}";
+    String expectedStr = "v2";
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON, JSON, JSON, JSON, JSON, JSON, JSON);
+        ColumnVector expected = ColumnVector.fromStrings(
+            expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test: query paths depth is 10
+   */
+  @Test
+  void getJsonObjectTest4() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("k1"),
+        keyPath(), namedPath("k2"),
+        keyPath(), namedPath("k3"),
+        keyPath(), namedPath("k4"),
+        keyPath(), namedPath("k5"),
+        keyPath(), namedPath("k6"),
+        keyPath(), namedPath("k7"),
+        keyPath(), namedPath("k8")
+    };
+
+    String JSON = "{\"k1\":{\"k2\":{\"k3\":{\"k4\":{\"k5\":{\"k6\":{\"k7\":{\"k8\":\"v8\"}}}}}}}}";
+    String expectedStr = "v8";
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON, JSON, JSON, JSON, JSON, JSON, JSON);
+        ColumnVector expected = ColumnVector.fromStrings(
+            expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Baidu case: unescape http:\\/\\/ to http://
+   */
+  @Test
+  void getJsonObjectTest_Baidu_unescape_backslash() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("URdeosurl")
+    };
+
+    String JSON = "{\"brand\":\"ssssss\",\"duratRon\":15,\"eqTosuresurl\":\"\",\"RsZxarthrl\":false,\"xonRtorsurl\":\"\",\"xonRtorsurlstOTe\":0,\"TRctures\":[{\"RxaGe\":\"VttTs:\\/\\/feed-RxaGe.baRdu.cox\\/0\\/TRc\\/-196588744s840172444s-773690137.zTG\"}],\"Toster\":\"VttTs:\\/\\/feed-RxaGe.baRdu.cox\\/0\\/TRc\\/-196588744s840172444s-773690137.zTG\",\"reserUed\":{\"bRtLate\":391.79,\"xooUZRke\":26876,\"nahrlIeneratRonNOTe\":0,\"useJublRc\":6,\"URdeoRd\":821284086},\"tRtle\":\"ssssssssssmMsssssssssssssssssss\",\"url\":\"s{storehrl}\",\"usersTortraRt\":\"VttTs:\\/\\/feed-RxaGe.baRdu.cox\\/0\\/TRc\\/-6971178959s-664926866s-6096674871.zTG\",\"URdeosurl\":\"http:\\/\\/nadURdeo2.baRdu.cox\\/5fa3893aed7fc0f8231dab7be23efc75s820s6240.xT3\",\"URdeoRd\":821284086}";
+    String expectedStr = "http://nadURdeo2.baRdu.cox/5fa3893aed7fc0f8231dab7be23efc75s820s6240.xT3";
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON, JSON, JSON, JSON, JSON, JSON, JSON);
+        ColumnVector expected = ColumnVector.fromStrings(
+            expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Baidu case: query unexist field name
+   */
+  @Test
+  void getJsonObjectTest_Baidu_get_unexist_field_name() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("Vgdezsurl")
+    };
+
+    String JSON = "{\"brand\":\"ssssss\",\"duratgzn\":17,\"eSyzsuresurl\":\"\",\"gswUartWrl\":false,\"Uzngtzrsurl\":\"\",\"UzngtzrsurlstJye\":0,\"ygctures\":[{\"gUaqe\":\"Ittys:\\/\\/feed-gUaqe.bagdu.czU\\/0\\/ygc\\/63025364s-376461312s7528698939.Qyq\"}],\"yzster\":\"Ittys:\\/\\/feed-gUaqe.bagdu.czU\\,\"url\":\"s{stHreqrl}\",\"usersPHrtraIt\":\"LttPs:\\/\\/feed-IUaxe.baIdu.cHU\\/0\\/PIc\\/-1043913002s489796992s-1505641721.Pnx\",\"kIdeHsurl\":\"LttP:\\/\\/nadkIdeH9.baIdu.cHU\\/4d7d308bd7c04e63069fd343adfa792as1790s1080.UP3\",\"kIdeHId\":852890923}";
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON, JSON, JSON, JSON, JSON, JSON, JSON);
+        ColumnVector expected = ColumnVector.fromStrings(
+            null, null, null, null, null, null, null);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * test escape chars:
+   * 1. " in ' pair
+   * 2. ' in " pair
+   * 3. \ / " ' \b \f \n \r \t
+   * 4. \ u HEX HEX HEX HEX: code point
+   */
+  @Test
+  void getJsonObjectTest_Escape() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[0];
+
+    String JSON1 = "{ \"a\": \"A\" }";
+    String JSON2 = "{'a':'A\"'}";
+    String JSON3 = "{'a':\"B'\"}";
+    String JSON4 = "['a','b','\"C\"']";
+    // \\u4e2d\\u56FD is 中国
+    String JSON5 = "'\\u4e2d\\u56FD\\\"\\'\\\\\\/\\b\\f\\n\\r\\t\\b'";
+
+    String expectedStr1 = "{\"a\":\"A\"}";
+    String expectedStr2 = "{\"a\":\"A\\\"\"}";
+    String expectedStr3 = "{\"a\":\"B'\"}";
+    String expectedStr4 = "[\"a\",\"b\",\"\\\"C\\\"\"]";
+    String expectedStr5 = "中国\"'\\/\b\f\n\r\t\b";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON1, JSON2, JSON3, JSON4, JSON5);
+        ColumnVector expected = ColumnVector.fromStrings(
+            expectedStr1, expectedStr2, expectedStr3, expectedStr4, expectedStr5);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * test number normalizations
+   */
+  @Test
+  void getJsonObjectTest_Number_Normalization() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[0];
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            "[100.0,200.000,351.980]",
+            "[12345678900000000000.0]",
+            "[0.0]",
+            "[-0.0]",
+            "[-0]",
+            "[12345678999999999999999999]",
+            "[9.299999257686047e-0005603333574677677]",
+            "9.299999257686047e0005603333574677677",
+            "[1E308]",
+            "[1.0E309,-1E309,1E5000]",
+            "0.3",
+            "0.03",
+            "0.003",
+            "0.0003",
+            "0.00003");
+        ColumnVector expected = ColumnVector.fromStrings(
+            "[100.0,200.0,351.98]",
+            "[1.23456789E19]",
+            "[0.0]",
+            "[-0.0]",
+            "[0]",
+            "[12345678999999999999999999]",
+            "[0.0]",
+            "\"Infinity\"",
+            "[1.0E308]",
+            "[\"Infinity\",\"-Infinity\",\"Infinity\"]",
+            "0.3",
+            "0.03",
+            "0.003",
+            "3.0E-4",
+            "3.0E-5");
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test number:
+   * leading zeros are invalid: 00, 01, 02, 000, -01, -00, -02
+   */
+  @Test
+  void getJsonObjectTest_Test_leading_zeros() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[0];
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings("00", "01", "02", "000", "-01", "-00", "-02");
+        ColumnVector expected = ColumnVector.fromStrings(null, null, null, null, null, null, null);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test $[1]
+   */
+  @Test
+  void getJsonObjectTest_Test_index() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), indexPath(1)
+    };
+
+    String JSON1 = "[ [0, 1, 2] , [10, [11], [121, 122, 123], 13] ,  [20, 21, 22]]";
+    String expectedStr1 = "[10,[11],[121,122,123],13]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test $[1][2]
+   */
+  @Test
+  void getJsonObjectTest_Test_index_index() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), indexPath(1), subscriptPath(), indexPath(2)
+    };
+
+    String JSON1 = "[ [0, 1, 2] , [10, [11], [121, 122, 123], 13] ,  [20, 21, 22]]";
+    String expectedStr1 = "[121,122,123]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 1: case (VALUE_STRING, Nil) if style == RawStyle
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path1() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[0];
+
+    String JSON1 = "'abc'";
+    String expectedStr1 = "abc";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 5: case (START_ARRAY, Subscript :: Wildcard :: Subscript ::
+   * Wildcard :: xs), set flatten style
+   * case path 2: case (START_ARRAY, Nil) if style == FlattenStyle
+   * 
+   * First use path5 [*][*] to enable flatten style.
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path2() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), wildcardPath(), subscriptPath(), wildcardPath()
+    };
+
+    String JSON1 = "[ [11, 12], [21, [221, [2221, [22221, 22222]]]], [31, 32] ]";
+    String expectedStr1 = "[11,12,21,221,2221,22221,22222,31,32]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 3: case (_, Nil)
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path3() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[0];
+
+    String JSON1 = "123";
+    String expectedStr1 = "123";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 4: case (START_OBJECT, Key :: xs)
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path4() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("k")
+    };
+
+    String JSON1 = "{ 'k' : 'v'  }";
+    String expectedStr1 = "v";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 5: case (START_ARRAY, Subscript :: Wildcard :: Subscript ::
+   * Wildcard :: xs), set flatten style
+   * case path 4: case (START_OBJECT, Key :: xs)
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path5() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), wildcardPath(), subscriptPath(), wildcardPath(), // $[*][*]
+        keyPath(), namedPath("k")
+    };
+
+    // flatten the arrays, then query named path "k"
+    String JSON1 = "[  [[[ {'k': 'v1'} ], {'k': 'v2'}]], [[{'k': 'v3'}], {'k': 'v4'}], {'k': 'v5'}  ]";
+    String expectedStr1 = "[\"v5\"]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 6: case (START_ARRAY, Subscript :: Wildcard :: xs) if style !=
+   * QuotedStyle
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path6() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), wildcardPath()
+    };
+    String JSON1 = "[1, [21, 22], 3]";
+    String expectedStr1 = "[1,[21,22],3]";
+
+    String JSON2 = "[1]";
+    String expectedStr2 = "1"; // note: in row mode, if it has only 1 item, then remove the outer: []
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1, JSON2);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1, expectedStr2);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 6: case (START_ARRAY, Subscript :: Wildcard :: xs) if style !=
+   * QuotedStyle, after this path, style is quoted mode
+   * case path 4: case (START_OBJECT, Key :: xs)
+   * case path 10: case (FIELD_NAME, Named(name) :: xs) if p.getCurrentName ==
+   * name
+   * case path 7: case (START_ARRAY, Subscript :: Wildcard :: xs), test quoted
+   * mode
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path7() {
+    // subscriptPath(), wildcardPath() subscriptPath(), wildcardPath() will go to
+    // path5
+    // so insert keyPath(), namedPath("k")
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), wildcardPath(), // path 6
+        keyPath(), namedPath("k"), // path 4, path 10
+        subscriptPath(), wildcardPath() // path 7
+    };
+
+    String JSON1 = "[ {'k': [0, 1, 2]}, {'k': [10, 11, 12]}, {'k': [20, 21, 22]}  ]";
+    String expectedStr1 = "[[0,1,2],[10,11,12],[20,21,22]]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 8: case (START_ARRAY, Subscript :: Index(idx) :: (xs@Subscript ::
+   * Wildcard :: _))
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path8() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), indexPath(1), subscriptPath(), wildcardPath()
+    };
+    String JSON1 = "[ [0], [10, 11, 12], [2] ]";
+    String expectedStr1 = "[10,11,12]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 9: case (START_ARRAY, Subscript :: Index(idx) :: xs)
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path9() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), indexPath(1), subscriptPath(), indexPath(1), subscriptPath(), wildcardPath()
+    };
+    String JSON1 = "[[0, 1, 2], [10, [111, 112, 113], 12], [20, 21, 22]]";
+    String expectedStr1 = "[111,112,113]";
+    String JSON2 = "[[0, 1, 2], [10, [], 12], [20, 21, 22]]";
+    String expectedStr2 = null;
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1, JSON2);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1, expectedStr2);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 10: case (FIELD_NAME, Named(name) :: xs) if p.getCurrentName ==
+   * name
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path10() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("k"), subscriptPath(), indexPath(1)
+    };
+    String JSON1 = "{'k' : [0,1,2]}";
+    String expectedStr1 = "1";
+    String JSON2 = "{'k' : null}";
+    String expectedStr2 = null; // return false
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1, JSON2);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1, expectedStr2);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 11: case (FIELD_NAME, Wildcard :: xs)
+   * Refer to Spark code:
+   * https://github.com/apache/spark/blob/v3.5.0/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/jsonExpressions.scala#L218
+   * path sequence key, wildcard can test path 11, but parser can not produce this
+   * sequence.
+   * Note: Here use manually created key, wildcard sequence to test.
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path11() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), wildcardPath()
+    };
+    String JSON1 = "{'k' : [0,1,2]}";
+    String expectedStr1 = "[0,1,2]";
+    String JSON2 = "{'k' : null}";
+    String expectedStr2 = "null";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1, JSON2);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1, expectedStr2);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 12: case _
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path12() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        wildcardPath()
+    };
+    String JSON1 = "123";
+    String expectedStr1 = null;
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Query: $[*][*][*]
+   */
+  @Test
+  void getJsonObjectTest_Test_insert_comma_insert_outer_array() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), wildcardPath(), subscriptPath(), wildcardPath(), subscriptPath(), wildcardPath()
+    };
+    String JSON1 = "[ [11, 12], [21, 22]]";
+    String expectedStr1 = "[[11,12],[21,22]]";
+    String JSON2 = "[ [11], [22] ]";
+    String expectedStr2 = "[11,22]";
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1, JSON2);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1, expectedStr2);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  private JSONUtils.PathInstructionJni keyPath() {
+    return new JSONUtils.PathInstructionJni(JSONUtils.PathInstructionType.KEY, "", -1);
+  }
+
+  private JSONUtils.PathInstructionJni subscriptPath() {
+    return new JSONUtils.PathInstructionJni(JSONUtils.PathInstructionType.SUBSCRIPT, "", -1);
+  }
+
+  private JSONUtils.PathInstructionJni wildcardPath() {
+    return new JSONUtils.PathInstructionJni(JSONUtils.PathInstructionType.WILDCARD, "", -1);
+  }
+
+  private JSONUtils.PathInstructionJni namedPath(String name) {
+    return new JSONUtils.PathInstructionJni(JSONUtils.PathInstructionType.NAMED, name, -1);
+  }
+
+  private JSONUtils.PathInstructionJni indexPath(int index) {
+    return new JSONUtils.PathInstructionJni(JSONUtils.PathInstructionType.INDEX, "", index);
+  }
+}
diff --git a/thirdparty/cudf b/thirdparty/cudf
index dd34fdbe35..578c240a20 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit dd34fdbe35e68ba56a2183f11ed822ddaa6c927b
+Subproject commit 578c240a20049a5c4b83b08f54c235aad5318f1a
diff --git a/thirdparty/cudf-pins/add_dependency_pins.cmake b/thirdparty/cudf-pins/add_dependency_pins.cmake
new file mode 100644
index 0000000000..73e0ebab76
--- /dev/null
+++ b/thirdparty/cudf-pins/add_dependency_pins.cmake
@@ -0,0 +1,37 @@
+#
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# Licensed 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.
+#
+
+if(NOT DEFINED rapids-cmake-dir)
+  include(../cudf/rapids_config.cmake)
+endif()
+
+include(rapids-cpm)
+rapids_cpm_init()
+
+function(add_override_if_requested)
+  if(CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned)
+    include(${rapids-cmake-dir}/cpm/package_override.cmake)
+    rapids_cpm_package_override(${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)
+
+    message(STATUS "Pinning CUDF dependencies to values found in ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json")
+  else()
+    include(${rapids-cmake-dir}/cpm/generate_pinned_versions.cmake)
+    rapids_cpm_generate_pinned_versions(OUTPUT ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)
+
+    message(STATUS "Building with latest CUDF dependencies (saving pinned versions to ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)")
+  endif()
+endfunction()
+add_override_if_requested()
diff --git a/thirdparty/cudf-pins/rapids-cmake.sha b/thirdparty/cudf-pins/rapids-cmake.sha
new file mode 100644
index 0000000000..aee5915dc4
--- /dev/null
+++ b/thirdparty/cudf-pins/rapids-cmake.sha
@@ -0,0 +1 @@
+69f5222465ec3c8c54f107fcf8750f040034e156
diff --git a/thirdparty/cudf-pins/setup.cmake b/thirdparty/cudf-pins/setup.cmake
new file mode 100644
index 0000000000..8040c26faf
--- /dev/null
+++ b/thirdparty/cudf-pins/setup.cmake
@@ -0,0 +1,45 @@
+#
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# Licensed 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.
+#
+
+string(TOLOWER "${CUDF_DEPENDENCY_PIN_MODE}" CUDF_DEPENDENCY_PIN_MODE)
+if(NOT (CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned OR
+        CUDF_DEPENDENCY_PIN_MODE STREQUAL latest))
+  message(FATAL_ERROR "The CUDF_DEPENDENCY_PIN_MODE variable must be set to either `pinned` or `latest`.")
+ endif()
+
+function(set_rapids_cmake_pin_sha1)
+  set(rapids-cmake-sha "${rapids-cmake-sha}" PARENT_SCOPE)
+
+  message(STATUS "Pinning rapids-cmake SHA1 to ${rapids-cmake-sha}")
+endfunction()
+
+# We need to set the rapids-cmake SHA1 before any CMake code in libcudf is executed when
+# we are in pin mode. Otherwise we will use the latest rapids-cmake version since that
+# is what cudf does via `fetch_rapids.cmake`
+if(CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned)
+  # Extract the rapids sha1 from the file
+  file(READ "${CMAKE_CURRENT_LIST_DIR}/rapids-cmake.sha" rapids-cmake-sha)
+  string(STRIP rapids-cmake-sha "${rapids-cmake-sha}")
+  string(REPLACE "\n" "" rapids-cmake-sha "${rapids-cmake-sha}")
+  set(rapids-cmake-sha "${rapids-cmake-sha}" CACHE STRING "rapids-cmake sha to use" FORCE)
+  message(STATUS "Pinning rapids-cmake SHA1 [${rapids-cmake-sha}]")
+else()
+  set(rapids-cmake-fetch-via-git "ON" CACHE STRING "Make sure rapids-cmake is cloned so we can get SHA value" FORCE)
+endif()
+
+# We need to use a project() call hook, since rapids-cmake cpm_init()
+# can't be called from a `-C` CMake file
+set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES "${CMAKE_CURRENT_LIST_DIR}/add_dependency_pins.cmake" CACHE FILEPATH "" )
diff --git a/thirdparty/cudf-pins/versions.json b/thirdparty/cudf-pins/versions.json
new file mode 100644
index 0000000000..4261acab1a
--- /dev/null
+++ b/thirdparty/cudf-pins/versions.json
@@ -0,0 +1,155 @@
+{
+  "packages" : 
+  {
+    "Arrow" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "740889f413af9b1ae1d81eb1e5a4a9fb4ce9cf97",
+      "git_url" : "https://github.com/apache/arrow.git",
+      "version" : "14.0.2"
+    },
+    "CCCL" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "36f379f29660761fe033a1306ca9dab6a88cb65c",
+      "git_url" : "https://github.com/NVIDIA/cccl.git",
+      "patches" : 
+      [
+        {
+          "file" : "cccl/bug_fixes.diff",
+          "fixed_in" : "2.3",
+          "issue" : "CCCL installs header-search.cmake files in nondeterministic order and has a typo in checking target creation that leads to duplicates"
+        },
+        {
+          "file" : "cccl/hide_kernels.diff",
+          "fixed_in" : "2.3",
+          "issue" : "Mark all cub and thrust kernels with hidden visibility [https://github.com/nvidia/cccl/pulls/443]"
+        },
+        {
+          "file" : "cccl/revert_pr_211.diff",
+          "fixed_in" : "",
+          "issue" : "thrust::copy introduced a change in behavior that causes failures with cudaErrorInvalidValue."
+        },
+        {
+          "file" : "${current_json_dir}/thrust_disable_64bit_dispatching.diff",
+          "fixed_in" : "",
+          "issue" : "Remove 64bit dispatching as not needed by libcudf and results in compiling twice as many kernels [https://github.com/rapidsai/cudf/pull/11437]"
+        },
+        {
+          "file" : "${current_json_dir}/thrust_faster_sort_compile_times.diff",
+          "fixed_in" : "",
+          "issue" : "Improve Thrust sort compile times by not unrolling loops for inlined comparators [https://github.com/rapidsai/cudf/pull/10577]"
+        },
+        {
+          "file" : "${current_json_dir}/thrust_faster_scan_compile_times.diff",
+          "fixed_in" : "",
+          "issue" : "Improve Thrust scan compile times by reducing the number of kernels generated [https://github.com/rapidsai/cudf/pull/8183]"
+        }
+      ],
+      "version" : "2.2.0"
+    },
+    "GTest" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "b796f7d44681514f58a683a3a71ff17c94edb0c1",
+      "git_url" : "https://github.com/google/googletest.git",
+      "version" : "1.13.0"
+    },
+    "KvikIO" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "5e69e97c42504c17a333a36e1796dce4b83150a4",
+      "git_url" : "https://github.com/rapidsai/kvikio.git",
+      "version" : "24.04"
+    },
+    "NVTX3" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "e170594ac7cf1dac584da473d4ca9301087090c1",
+      "git_url" : "https://github.com/NVIDIA/NVTX.git",
+      "version" : "3.1.0"
+    },
+    "cuco" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "56c53beb6fb0cafd265b7fcc3df78ae487811b22",
+      "git_url" : "https://github.com/NVIDIA/cuCollections.git",
+      "version" : "0.0.1"
+    },
+    "dlpack" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "365b823cedb281cd0240ca601aba9b78771f91a3",
+      "git_url" : "https://github.com/dmlc/dlpack.git",
+      "version" : "0.8"
+    },
+    "fmt" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "f5e54359df4c26b6230fc61d38aa294581393084",
+      "git_url" : "https://github.com/fmtlib/fmt.git",
+      "patches" : 
+      [
+        {
+          "file" : "fmt/fix_10_1_1_version.diff",
+          "fixed_in" : "10.2.0",
+          "issue" : "fmt 10.1.1 produces a CMake package with version 10.1.0"
+        }
+      ],
+      "version" : "10.1.1"
+    },
+    "jitify" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "e38b993f4cb3207745735c51d4f61cdaa735b7ac",
+      "git_url" : "https://github.com/rapidsai/jitify.git",
+      "version" : "2.0.0"
+    },
+    "nvcomp" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "v2.2.0",
+      "git_url" : "https://github.com/NVIDIA/nvcomp.git",
+      "proprietary_binary" : 
+      {
+        "aarch64-linux" : "https://developer.download.nvidia.com/compute/nvcomp/${version}/local_installers/nvcomp_${version}_SBSA_${cuda-toolkit-version-major}.x.tgz",
+        "x86_64-linux" : "https://developer.download.nvidia.com/compute/nvcomp/${version}/local_installers/nvcomp_${version}_x86_64_${cuda-toolkit-version-major}.x.tgz"
+      },
+      "version" : "3.0.6"
+    },
+    "rmm" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "e14a2291301ce9c8ef76b2b2404eb02336584724",
+      "git_url" : "https://github.com/rapidsai/rmm.git",
+      "version" : "24.04"
+    },
+    "spdlog" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "7e635fca68d014934b4af8a1cf874f63989352b7",
+      "git_url" : "https://github.com/gabime/spdlog.git",
+      "patches" : 
+      [
+        {
+          "file" : "spdlog/nvcc_constexpr_fix.diff",
+          "fixed_in" : "1.13",
+          "issue" : "Fix constexpr mismatch between spdlog and fmt [https://github.com/gabime/spdlog/issues/2856]"
+        }
+      ],
+      "version" : "1.12.0"
+    }
+  }
+}
\ No newline at end of file