diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/schema.json b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/schema.json
new file mode 100644
index 000000000000..43c7cd03f778
--- /dev/null
+++ b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/schema.json
@@ -0,0 +1,14 @@
+{
+  "id": "voxel",
+  "classes": {
+    "voxel": {
+      "properties": {
+        "a": {
+          "type": "SCALAR",
+          "componentType": "FLOAT32",
+          "required": false
+        }
+      }
+    }
+  }
+}
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.gltf b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.gltf
new file mode 100644
index 000000000000..51189372b25e
--- /dev/null
+++ b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.gltf
@@ -0,0 +1,91 @@
+{
+  "asset": {
+    "version": "2.0"
+  },
+  "scene": 0,
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "mode": 2147483648,
+          "attributes": {
+            "_a": 0
+          },
+          "extensions": {
+            "EXT_primitive_voxels": {
+              "dimensions": [
+                2,
+                2,
+                2
+              ]
+            },
+            "EXT_structural_metadata": {
+              "propertyAttributes": [0]
+            }
+          }
+        }
+      ]
+    }
+  ],
+  "extensionsUsed": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensionsRequired": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensions": {
+    "EXT_structural_metadata": {
+      "schemaUri": "../../../../schema.json",
+      "propertyAttributes": [
+        {
+          "class": "voxel",
+          "properties": {
+            "a": {
+              "attribute": "_a"
+            }
+          }
+        }
+      ]
+    }
+  },
+  "accessors": [
+    {
+      "bufferView": 0,
+      "type": "SCALAR",
+      "componentType": 5126,
+      "min": [
+        0.0
+      ],
+      "max": [
+        1.0
+      ],
+      "count": 8
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteLength": 32
+    }
+  ],
+  "buffers": [
+    {
+      "uri": "a.bin",
+      "byteLength": 32
+    }
+  ]
+}
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.json b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.json
deleted file mode 100644
index 688327759afe..000000000000
--- a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "buffers": [
-    {
-      "uri": "a.bin",
-      "byteLength": 32
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteOffset": 0,
-      "byteLength": 32
-    }
-  ],
-  "propertyTables": [
-    {
-      "class": "voxel",
-      "count": 8,
-      "properties": {
-        "a": {
-          "values": 0
-        }
-      }
-    }
-  ],
-  "voxelTable": 0
-}
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json
index 7d704a8f00b5..a3bbf8bc97fa 100644
--- a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json
+++ b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json
@@ -2,19 +2,7 @@
   "asset": {
     "version": "1.1"
   },
-  "schema": {
-    "id": "voxel",
-    "classes": {
-      "voxel": {
-        "properties": {
-          "a": {
-            "type": "SCALAR",
-            "componentType": "FLOAT32"
-          }
-        }
-      }
-    }
-  },
+  "schemaUri": "schema.json",
   "statistics": {
     "classes": {
       "voxel": {
@@ -49,7 +37,7 @@
     "geometricError": 0.0,
     "refine": "REPLACE",
     "content": {
-      "uri": "tiles/{level}/{x}/{y}/{z}.json",
+      "uri": "tiles/{level}/{x}/{y}/{z}.gltf",
       "extensions": {
         "3DTILES_content_voxels": {
           "dimensions": [
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/schema.json b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/schema.json
new file mode 100644
index 000000000000..43c7cd03f778
--- /dev/null
+++ b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/schema.json
@@ -0,0 +1,14 @@
+{
+  "id": "voxel",
+  "classes": {
+    "voxel": {
+      "properties": {
+        "a": {
+          "type": "SCALAR",
+          "componentType": "FLOAT32",
+          "required": false
+        }
+      }
+    }
+  }
+}
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.gltf b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.gltf
new file mode 100644
index 000000000000..d7247ac82e1d
--- /dev/null
+++ b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.gltf
@@ -0,0 +1,88 @@
+{
+  "asset": {
+    "version": "2.0"
+  },
+  "scene": 0,
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "mode": 2147483650,
+          "attributes": {
+            "_a": 0
+          },
+          "extensions": {
+            "EXT_primitive_voxels": {
+              "dimensions": [
+                2,
+                2,
+                2
+              ]
+            }
+          }
+        }
+      ]
+    }
+  ],
+  "extensionsUsed": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensionsRequired": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensions": {
+    "EXT_structural_metadata": {
+      "schemaUri": "../../../../schema.json",
+      "propertyAttributes": [
+        {
+          "class": "voxel",
+          "properties": {
+            "a": {
+              "attribute": "_a"
+            }
+          }
+        }
+      ]
+    }
+  },
+  "accessors": [
+    {
+      "bufferView": 0,
+      "type": "SCALAR",
+      "componentType": 5126,
+      "min": [
+        0.0
+      ],
+      "max": [
+        1.0
+      ],
+      "count": 8
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteLength": 32
+    }
+  ],
+  "buffers": [
+    {
+      "uri": "a.bin",
+      "byteLength": 32
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.json b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.json
deleted file mode 100644
index 688327759afe..000000000000
--- a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "buffers": [
-    {
-      "uri": "a.bin",
-      "byteLength": 32
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteOffset": 0,
-      "byteLength": 32
-    }
-  ],
-  "propertyTables": [
-    {
-      "class": "voxel",
-      "count": 8,
-      "properties": {
-        "a": {
-          "values": 0
-        }
-      }
-    }
-  ],
-  "voxelTable": 0
-}
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json
index d1652c7e8757..07abdcad5187 100644
--- a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json
+++ b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json
@@ -2,19 +2,7 @@
   "asset": {
     "version": "1.1"
   },
-  "schema": {
-    "id": "voxel",
-    "classes": {
-      "voxel": {
-        "properties": {
-          "a": {
-            "type": "SCALAR",
-            "componentType": "FLOAT32"
-          }
-        }
-      }
-    }
-  },
+  "schemaUri": "schema.json",
   "statistics": {
     "classes": {
       "voxel": {
@@ -53,7 +41,7 @@
     "geometricError": 0.0,
     "refine": "REPLACE",
     "content": {
-      "uri": "tiles/{level}/{x}/{y}/{z}.json",
+      "uri": "tiles/{level}/{x}/{y}/{z}.gltf",
       "extensions": {
         "3DTILES_content_voxels": {
           "dimensions": [
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/schema.json b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/schema.json
new file mode 100644
index 000000000000..43c7cd03f778
--- /dev/null
+++ b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/schema.json
@@ -0,0 +1,14 @@
+{
+  "id": "voxel",
+  "classes": {
+    "voxel": {
+      "properties": {
+        "a": {
+          "type": "SCALAR",
+          "componentType": "FLOAT32",
+          "required": false
+        }
+      }
+    }
+  }
+}
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.gltf b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.gltf
new file mode 100644
index 000000000000..5a1815f6d105
--- /dev/null
+++ b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.gltf
@@ -0,0 +1,100 @@
+{
+  "asset": {
+    "version": "2.0"
+  },
+  "scene": 0,
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "mode": 2147483649,
+          "attributes": {
+            "_a": 0
+          },
+          "extensions": {
+            "EXT_primitive_voxels": {
+              "dimensions": [
+                2,
+                2,
+                2
+              ],
+              "bounds": {
+                "min": [
+                  0.0,
+                  0.0,
+                  -1.0
+                ],
+                "max": [
+                  1.0,
+                  1.0,
+                  0.0
+                ]
+              }
+            }
+          }
+        }
+      ]
+    }
+  ],
+  "extensionsUsed": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensionsRequired": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensions": {
+    "EXT_structural_metadata": {
+      "schemaUri": "../../../../schema.json",
+      "propertyAttributes": [
+        {
+          "class": "voxel",
+          "properties": {
+            "a": {
+              "attribute": "_a"
+            }
+          }
+        }
+      ]
+    }
+  },
+  "accessors": [
+    {
+      "bufferView": 0,
+      "type": "SCALAR",
+      "componentType": 5126,
+      "min": [
+        0.0
+      ],
+      "max": [
+        1.0
+      ],
+      "count": 8
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteLength": 32
+    }
+  ],
+  "buffers": [
+    {
+      "uri": "a.bin",
+      "byteLength": 32
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.json b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.json
deleted file mode 100644
index 688327759afe..000000000000
--- a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "buffers": [
-    {
-      "uri": "a.bin",
-      "byteLength": 32
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteOffset": 0,
-      "byteLength": 32
-    }
-  ],
-  "propertyTables": [
-    {
-      "class": "voxel",
-      "count": 8,
-      "properties": {
-        "a": {
-          "values": 0
-        }
-      }
-    }
-  ],
-  "voxelTable": 0
-}
diff --git a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json
index cbc44570ebac..fa43b62f031a 100644
--- a/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json
+++ b/Apps/SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json
@@ -2,19 +2,7 @@
   "asset": {
     "version": "1.1"
   },
-  "schema": {
-    "id": "voxel",
-    "classes": {
-      "voxel": {
-        "properties": {
-          "a": {
-            "type": "SCALAR",
-            "componentType": "FLOAT32"
-          }
-        }
-      }
-    }
-  },
+  "schemaUri": "schema.json",
   "statistics": {
     "classes": {
       "voxel": {
@@ -37,13 +25,13 @@
         1.0,
         1.0,
         -1.0,
-        0.0
+        500000.0
       ]
     },
     "geometricError": 0.0,
     "refine": "REPLACE",
     "content": {
-      "uri": "tiles/{level}/{x}/{y}/{z}.json",
+      "uri": "tiles/{level}/{x}/{y}/{z}.gltf",
       "extensions": {
         "3DTILES_content_voxels": {
           "dimensions": [
diff --git a/Apps/Sandcastle/gallery/Voxel Picking.html b/Apps/Sandcastle/gallery/Voxel Picking.html
index 18040bdca8c7..53a92a051a07 100644
--- a/Apps/Sandcastle/gallery/Voxel Picking.html	
+++ b/Apps/Sandcastle/gallery/Voxel Picking.html	
@@ -7,8 +7,11 @@
       name="viewport"
       content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"
     />
-    <meta name="description" content="For debugging voxel picking." />
-    <meta name="cesium-sandcastle-labels" content="Showcases, 3D Tiles" />
+    <meta
+      name="description"
+      content="Use the cursor to select and inspect individual voxel cells."
+    />
+    <meta name="cesium-sandcastle-labels" content="Showcases, Voxels" />
     <title>Cesium Demo</title>
     <script type="text/javascript" src="../Sandcastle-header.js"></script>
     <script type="module" src="../load-cesium-es6.js"></script>
@@ -74,7 +77,7 @@
           const { tileLevel, tileX, tileY, tileZ } = options;
 
           if (tileLevel >= this._levelCount) {
-            return undefined;
+            return Promise.reject(`No tiles available beyond level ${this._levelCount}`);
           }
 
           const dimensions = this.dimensions;
@@ -83,7 +86,8 @@
             tileZ * dimensions.y * dimensions.x + tileY * dimensions.x + tileX;
           const dataTile = constructRandomTileData(dimensions, type, randomSeed);
 
-          return Promise.resolve([dataTile]);
+          const content = Cesium.VoxelContent.fromMetadataArray([dataTile]);
+          return Promise.resolve(content);
         };
 
         function constructRandomTileData(dimensions, type, randomSeed) {
diff --git a/Apps/Sandcastle/gallery/Voxels in 3D Tiles.html b/Apps/Sandcastle/gallery/Voxels in 3D Tiles.html
new file mode 100644
index 000000000000..4b79212a38e8
--- /dev/null
+++ b/Apps/Sandcastle/gallery/Voxels in 3D Tiles.html	
@@ -0,0 +1,127 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"
+    />
+    <meta name="description" content="Load voxel datasets as 3D tiles." />
+    <meta name="cesium-sandcastle-labels" content="Showcases, 3D Tiles, Voxels" />
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script
+      type="text/javascript"
+      src="../../../Build/CesiumUnminified/Cesium.js"
+      nomodule
+    ></script>
+    <script type="module" src="../load-cesium-es6.js"></script>
+  </head>
+  <body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
+    <style>
+      @import url(../templates/bucket.css);
+    </style>
+    <div id="cesiumContainer" class="fullSize"></div>
+    <div id="loadingOverlay"><h1>Loading...</h1></div>
+    <div id="toolbar"></div>
+    <script id="cesium_sandcastle_script">
+      window.startup = async function (Cesium) {
+        "use strict";
+        //Sandcastle_Begin
+        const viewer = new Cesium.Viewer("cesiumContainer", {
+          baseLayer: Cesium.ImageryLayer.fromProviderAsync(
+            Cesium.TileMapServiceImageryProvider.fromUrl(
+              Cesium.buildModuleUrl("Assets/Textures/NaturalEarthII"),
+            ),
+          ),
+          baseLayerPicker: false,
+          geocoder: false,
+          animation: false,
+          timeline: false,
+        });
+
+        viewer.extend(Cesium.viewerVoxelInspectorMixin);
+        viewer.scene.debugShowFramesPerSecond = true;
+
+        const customShaderWhite = new Cesium.CustomShader({
+          fragmentShaderText: `void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
+  {
+      material.diffuse = vec3(1.0);
+      material.alpha = 1.0;
+  }`,
+        });
+
+        const modelMatrix = Cesium.Matrix4.fromScale(
+          Cesium.Cartesian3.fromElements(
+            Cesium.Ellipsoid.WGS84.maximumRadius,
+            Cesium.Ellipsoid.WGS84.maximumRadius,
+            Cesium.Ellipsoid.WGS84.maximumRadius,
+          ),
+        );
+
+        function createPrimitive(provider, customShader, modelMatrix) {
+          viewer.scene.primitives.removeAll();
+
+          const voxelPrimitive = viewer.scene.primitives.add(
+            new Cesium.VoxelPrimitive({
+              provider: provider,
+              customShader: customShader,
+              modelMatrix: modelMatrix,
+            }),
+          );
+
+          viewer.voxelInspector.viewModel.voxelPrimitive = voxelPrimitive;
+          viewer.camera.flyToBoundingSphere(voxelPrimitive.boundingSphere, {
+            duration: 0.0,
+          });
+
+          return voxelPrimitive;
+        }
+
+        Sandcastle.addToolbarMenu([
+          {
+            text: "Box - 3D Tiles",
+            onselect: async function () {
+              const provider = await Cesium.Cesium3DTilesVoxelProvider.fromUrl(
+                "../../SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json",
+              );
+              const primitive = createPrimitive(provider, customShaderWhite, modelMatrix);
+            },
+          },
+          {
+            text: "Ellipsoid - 3D Tiles",
+            onselect: async function () {
+              const provider = await Cesium.Cesium3DTilesVoxelProvider.fromUrl(
+                "../../SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json",
+              );
+              const primitive = createPrimitive(
+                provider,
+                customShaderWhite,
+                Cesium.Matrix4.IDENTITY,
+              );
+            },
+          },
+          {
+            text: "Cylinder - 3D Tiles",
+            onselect: async function () {
+              const provider = await Cesium.Cesium3DTilesVoxelProvider.fromUrl(
+                "../../SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json",
+              );
+              const primitive = createPrimitive(provider, customShaderWhite, modelMatrix);
+            },
+          },
+        ]);
+        //Sandcastle_End
+      };
+      if (typeof Cesium !== "undefined") {
+        window.startupCalled = true;
+        window.startup(Cesium).catch((error) => {
+          "use strict";
+          console.error(error);
+        });
+        Sandcastle.finishedLoading();
+      }
+    </script>
+  </body>
+</html>
diff --git a/Apps/Sandcastle/gallery/Voxels in 3D Tiles.jpg b/Apps/Sandcastle/gallery/Voxels in 3D Tiles.jpg
new file mode 100644
index 000000000000..af1cc3d5c70e
Binary files /dev/null and b/Apps/Sandcastle/gallery/Voxels in 3D Tiles.jpg differ
diff --git a/Apps/Sandcastle/gallery/Voxels.html b/Apps/Sandcastle/gallery/Voxels.html
index f989109d1b0d..48a42cc83866 100644
--- a/Apps/Sandcastle/gallery/Voxels.html
+++ b/Apps/Sandcastle/gallery/Voxels.html
@@ -7,8 +7,11 @@
       name="viewport"
       content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"
     />
-    <meta name="description" content="For debugging voxels." />
-    <meta name="cesium-sandcastle-labels" content="Showcases, 3D Tiles" />
+    <meta
+      name="description"
+      content="Render voxel primitives with different shape types."
+    />
+    <meta name="cesium-sandcastle-labels" content="Showcases, Voxels" />
     <title>Cesium Demo</title>
     <script type="text/javascript" src="../Sandcastle-header.js"></script>
     <script
@@ -58,7 +61,7 @@
 
         ProceduralSingleTileVoxelProvider.prototype.requestData = function (options) {
           if (options.tileLevel >= 1) {
-            return undefined;
+            return Promise.reject(`No tiles available beyond level 0`);
           }
 
           const dimensions = this.dimensions;
@@ -93,7 +96,8 @@
             }
           }
 
-          return Promise.resolve([dataColor]);
+          const content = Cesium.VoxelContent.fromMetadataArray([dataColor]);
+          return Promise.resolve(content);
         };
 
         function ProceduralMultiTileVoxelProvider(shape) {
@@ -143,7 +147,9 @@
           const { tileLevel, tileX, tileY, tileZ } = options;
 
           if (tileLevel >= this._levelCount) {
-            return undefined;
+            return Promise.reject(
+              `No tiles available beyond level ${this._levelCount - 1}`,
+            );
           }
 
           const type = this.types[0];
@@ -204,7 +210,8 @@
               }
             }
           }
-          return Promise.resolve([dataTile]);
+          const content = Cesium.VoxelContent.fromMetadataArray([dataTile]);
+          return Promise.resolve(content);
         };
 
         function createPrimitive(provider, customShader, modelMatrix) {
@@ -238,14 +245,6 @@
   }`,
         });
 
-        const customShaderWhite = new Cesium.CustomShader({
-          fragmentShaderText: `void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
-  {
-      material.diffuse = vec3(1.0);
-      material.alpha = 1.0;
-  }`,
-        });
-
         const modelMatrix = Cesium.Matrix4.fromScale(
           Cesium.Cartesian3.fromElements(
             Cesium.Ellipsoid.WGS84.maximumRadius,
@@ -293,15 +292,6 @@
               const primitive = createPrimitive(provider, customShaderColor, modelMatrix);
             },
           },
-          {
-            text: "Box - 3D Tiles",
-            onselect: async function () {
-              const provider = await Cesium.Cesium3DTilesVoxelProvider.fromUrl(
-                "../../SampleData/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json",
-              );
-              const primitive = createPrimitive(provider, customShaderWhite, modelMatrix);
-            },
-          },
           {
             text: "Ellipsoid - Procedural Tileset",
             onselect: function () {
@@ -313,19 +303,6 @@
               const primitive = createPrimitive(provider, customShaderColor, modelMatrix);
             },
           },
-          {
-            text: "Ellipsoid - 3D Tiles",
-            onselect: async function () {
-              const provider = await Cesium.Cesium3DTilesVoxelProvider.fromUrl(
-                "../../SampleData/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json",
-              );
-              const primitive = createPrimitive(
-                provider,
-                customShaderWhite,
-                Cesium.Matrix4.IDENTITY,
-              );
-            },
-          },
           {
             text: "Cylinder - Procedural Tileset",
             onselect: function () {
@@ -335,15 +312,6 @@
               const primitive = createPrimitive(provider, customShaderColor, modelMatrix);
             },
           },
-          {
-            text: "Cylinder - 3D Tiles",
-            onselect: async function () {
-              const provider = await Cesium.Cesium3DTilesVoxelProvider.fromUrl(
-                "../../SampleData/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json",
-              );
-              const primitive = createPrimitive(provider, customShaderWhite, modelMatrix);
-            },
-          },
         ]);
 
         const handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
diff --git a/CHANGES.md b/CHANGES.md
index 1d9ad35dd090..6ff3a6bb956d 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -8,6 +8,19 @@
 
 - `createGooglePhotorealistic3DTileset(key)` has been removed. Use `createGooglePhotorealistic3DTileset({key})` instead.
 - Changed behavior of `DataSourceDisplay.ready` to always stay `true` once it is initially set to `true`. [#12429](https://github.com/CesiumGS/cesium/pull/12429)
+- Updated `Cesium3DTilesVoxelProvider` to load glTF tiles using the new [`EXT_primitive_voxels` extension](https://github.com/CesiumGS/glTF/pull/69) to more closely align with the rest of the 3D Tiles ecosystem. Tilesets using the previous custom JSON format are no longer supported. [#12432](https://github.com/CesiumGS/cesium/pull/12432)
+- Updated the `requestData` method of the `VoxelProvider` interface to return a `Promise` to a `VoxelContent`. Custom providers should now use the `VoxelContent.fromMetadataArray` method to construct the returned data object. For example:
+
+```js
+CustomVoxelProvider.prototype.requestData = function (options) {
+  const metadataColumn = new Float32Array(options.dataLength);
+  // ... Fill metadataColumn with metadata values ...
+  const content = VoxelContent.fromMetadataArray([metadataColumn]);
+  return Promise.resolve(content);
+};
+```
+
+- Changed `VoxelCylinderShape` to assume coordinates in the order (radius, angle, height). See [CesiumGS/3d-tiles#780](https://github.com/CesiumGS/3d-tiles/pull/780)
 
 #### Additions :tada:
 
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/schema.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/schema.json
new file mode 100644
index 000000000000..43c7cd03f778
--- /dev/null
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/schema.json
@@ -0,0 +1,14 @@
+{
+  "id": "voxel",
+  "classes": {
+    "voxel": {
+      "properties": {
+        "a": {
+          "type": "SCALAR",
+          "componentType": "FLOAT32",
+          "required": false
+        }
+      }
+    }
+  }
+}
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.gltf b/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.gltf
new file mode 100644
index 000000000000..51189372b25e
--- /dev/null
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.gltf
@@ -0,0 +1,91 @@
+{
+  "asset": {
+    "version": "2.0"
+  },
+  "scene": 0,
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "mode": 2147483648,
+          "attributes": {
+            "_a": 0
+          },
+          "extensions": {
+            "EXT_primitive_voxels": {
+              "dimensions": [
+                2,
+                2,
+                2
+              ]
+            },
+            "EXT_structural_metadata": {
+              "propertyAttributes": [0]
+            }
+          }
+        }
+      ]
+    }
+  ],
+  "extensionsUsed": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensionsRequired": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensions": {
+    "EXT_structural_metadata": {
+      "schemaUri": "../../../../schema.json",
+      "propertyAttributes": [
+        {
+          "class": "voxel",
+          "properties": {
+            "a": {
+              "attribute": "_a"
+            }
+          }
+        }
+      ]
+    }
+  },
+  "accessors": [
+    {
+      "bufferView": 0,
+      "type": "SCALAR",
+      "componentType": 5126,
+      "min": [
+        0.0
+      ],
+      "max": [
+        1.0
+      ],
+      "count": 8
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteLength": 32
+    }
+  ],
+  "buffers": [
+    {
+      "uri": "a.bin",
+      "byteLength": 32
+    }
+  ]
+}
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.json
deleted file mode 100644
index 688327759afe..000000000000
--- a/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tiles/0/0/0/0.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "buffers": [
-    {
-      "uri": "a.bin",
-      "byteLength": 32
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteOffset": 0,
-      "byteLength": 32
-    }
-  ],
-  "propertyTables": [
-    {
-      "class": "voxel",
-      "count": 8,
-      "properties": {
-        "a": {
-          "values": 0
-        }
-      }
-    }
-  ],
-  "voxelTable": 0
-}
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json
index 7d704a8f00b5..a3bbf8bc97fa 100644
--- a/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json
@@ -2,19 +2,7 @@
   "asset": {
     "version": "1.1"
   },
-  "schema": {
-    "id": "voxel",
-    "classes": {
-      "voxel": {
-        "properties": {
-          "a": {
-            "type": "SCALAR",
-            "componentType": "FLOAT32"
-          }
-        }
-      }
-    }
-  },
+  "schemaUri": "schema.json",
   "statistics": {
     "classes": {
       "voxel": {
@@ -49,7 +37,7 @@
     "geometricError": 0.0,
     "refine": "REPLACE",
     "content": {
-      "uri": "tiles/{level}/{x}/{y}/{z}.json",
+      "uri": "tiles/{level}/{x}/{y}/{z}.gltf",
       "extensions": {
         "3DTILES_content_voxels": {
           "dimensions": [
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/schema.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/schema.json
new file mode 100644
index 000000000000..43c7cd03f778
--- /dev/null
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/schema.json
@@ -0,0 +1,14 @@
+{
+  "id": "voxel",
+  "classes": {
+    "voxel": {
+      "properties": {
+        "a": {
+          "type": "SCALAR",
+          "componentType": "FLOAT32",
+          "required": false
+        }
+      }
+    }
+  }
+}
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.gltf b/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.gltf
new file mode 100644
index 000000000000..d7247ac82e1d
--- /dev/null
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.gltf
@@ -0,0 +1,88 @@
+{
+  "asset": {
+    "version": "2.0"
+  },
+  "scene": 0,
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "mode": 2147483650,
+          "attributes": {
+            "_a": 0
+          },
+          "extensions": {
+            "EXT_primitive_voxels": {
+              "dimensions": [
+                2,
+                2,
+                2
+              ]
+            }
+          }
+        }
+      ]
+    }
+  ],
+  "extensionsUsed": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensionsRequired": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensions": {
+    "EXT_structural_metadata": {
+      "schemaUri": "../../../../schema.json",
+      "propertyAttributes": [
+        {
+          "class": "voxel",
+          "properties": {
+            "a": {
+              "attribute": "_a"
+            }
+          }
+        }
+      ]
+    }
+  },
+  "accessors": [
+    {
+      "bufferView": 0,
+      "type": "SCALAR",
+      "componentType": 5126,
+      "min": [
+        0.0
+      ],
+      "max": [
+        1.0
+      ],
+      "count": 8
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteLength": 32
+    }
+  ],
+  "buffers": [
+    {
+      "uri": "a.bin",
+      "byteLength": 32
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.json
deleted file mode 100644
index 688327759afe..000000000000
--- a/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tiles/0/0/0/0.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "buffers": [
-    {
-      "uri": "a.bin",
-      "byteLength": 32
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteOffset": 0,
-      "byteLength": 32
-    }
-  ],
-  "propertyTables": [
-    {
-      "class": "voxel",
-      "count": 8,
-      "properties": {
-        "a": {
-          "values": 0
-        }
-      }
-    }
-  ],
-  "voxelTable": 0
-}
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json
index d1652c7e8757..07abdcad5187 100644
--- a/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json
@@ -2,19 +2,7 @@
   "asset": {
     "version": "1.1"
   },
-  "schema": {
-    "id": "voxel",
-    "classes": {
-      "voxel": {
-        "properties": {
-          "a": {
-            "type": "SCALAR",
-            "componentType": "FLOAT32"
-          }
-        }
-      }
-    }
-  },
+  "schemaUri": "schema.json",
   "statistics": {
     "classes": {
       "voxel": {
@@ -53,7 +41,7 @@
     "geometricError": 0.0,
     "refine": "REPLACE",
     "content": {
-      "uri": "tiles/{level}/{x}/{y}/{z}.json",
+      "uri": "tiles/{level}/{x}/{y}/{z}.gltf",
       "extensions": {
         "3DTILES_content_voxels": {
           "dimensions": [
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/schema.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/schema.json
new file mode 100644
index 000000000000..43c7cd03f778
--- /dev/null
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/schema.json
@@ -0,0 +1,14 @@
+{
+  "id": "voxel",
+  "classes": {
+    "voxel": {
+      "properties": {
+        "a": {
+          "type": "SCALAR",
+          "componentType": "FLOAT32",
+          "required": false
+        }
+      }
+    }
+  }
+}
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.gltf b/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.gltf
new file mode 100644
index 000000000000..5a1815f6d105
--- /dev/null
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.gltf
@@ -0,0 +1,100 @@
+{
+  "asset": {
+    "version": "2.0"
+  },
+  "scene": 0,
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "mode": 2147483649,
+          "attributes": {
+            "_a": 0
+          },
+          "extensions": {
+            "EXT_primitive_voxels": {
+              "dimensions": [
+                2,
+                2,
+                2
+              ],
+              "bounds": {
+                "min": [
+                  0.0,
+                  0.0,
+                  -1.0
+                ],
+                "max": [
+                  1.0,
+                  1.0,
+                  0.0
+                ]
+              }
+            }
+          }
+        }
+      ]
+    }
+  ],
+  "extensionsUsed": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensionsRequired": [
+    "EXT_primitive_voxels",
+    "EXT_structural_metadata"
+  ],
+  "extensions": {
+    "EXT_structural_metadata": {
+      "schemaUri": "../../../../schema.json",
+      "propertyAttributes": [
+        {
+          "class": "voxel",
+          "properties": {
+            "a": {
+              "attribute": "_a"
+            }
+          }
+        }
+      ]
+    }
+  },
+  "accessors": [
+    {
+      "bufferView": 0,
+      "type": "SCALAR",
+      "componentType": 5126,
+      "min": [
+        0.0
+      ],
+      "max": [
+        1.0
+      ],
+      "count": 8
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteLength": 32
+    }
+  ],
+  "buffers": [
+    {
+      "uri": "a.bin",
+      "byteLength": 32
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.json
deleted file mode 100644
index 688327759afe..000000000000
--- a/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tiles/0/0/0/0.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "buffers": [
-    {
-      "uri": "a.bin",
-      "byteLength": 32
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteOffset": 0,
-      "byteLength": 32
-    }
-  ],
-  "propertyTables": [
-    {
-      "class": "voxel",
-      "count": 8,
-      "properties": {
-        "a": {
-          "values": 0
-        }
-      }
-    }
-  ],
-  "voxelTable": 0
-}
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json
index cbc44570ebac..fa43b62f031a 100644
--- a/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json
@@ -2,19 +2,7 @@
   "asset": {
     "version": "1.1"
   },
-  "schema": {
-    "id": "voxel",
-    "classes": {
-      "voxel": {
-        "properties": {
-          "a": {
-            "type": "SCALAR",
-            "componentType": "FLOAT32"
-          }
-        }
-      }
-    }
-  },
+  "schemaUri": "schema.json",
   "statistics": {
     "classes": {
       "voxel": {
@@ -37,13 +25,13 @@
         1.0,
         1.0,
         -1.0,
-        0.0
+        500000.0
       ]
     },
     "geometricError": 0.0,
     "refine": "REPLACE",
     "content": {
-      "uri": "tiles/{level}/{x}/{y}/{z}.json",
+      "uri": "tiles/{level}/{x}/{y}/{z}.gltf",
       "extensions": {
         "3DTILES_content_voxels": {
           "dimensions": [
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/schema.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/schema.json
new file mode 100644
index 000000000000..4c9893312194
--- /dev/null
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/schema.json
@@ -0,0 +1,27 @@
+{
+  "id": "voxel",
+  "classes": {
+    "voxel": {
+      "properties": {
+        "a": {
+          "type": "SCALAR",
+          "componentType": "FLOAT32",
+          "required": true,
+          "noData": -99999.0
+        },
+        "b": {
+          "type": "SCALAR",
+          "componentType": "FLOAT32",
+          "required": true,
+          "noData": -99999.0
+        },
+        "c": {
+          "type": "SCALAR",
+          "componentType": "FLOAT32",
+          "required": true,
+          "noData": -99999.0
+        }
+      }
+    }
+  }
+}
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tiles/0/0/0/0.gltf b/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tiles/0/0/0/0.gltf
new file mode 100644
index 000000000000..0a987473e24a
--- /dev/null
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tiles/0/0/0/0.gltf
@@ -0,0 +1,91 @@
+{
+  "extensionsUsed": ["EXT_structural_metadata", "EXT_primitive_voxels"],
+  "extensionsRequired": ["EXT_primitive_voxels"],
+  "accessors": [{
+      "bufferView": 0,
+      "componentType": 5126,
+      "count": 8,
+      "type": "SCALAR"
+    }, {
+      "bufferView": 1,
+      "componentType": 5126,
+      "count": 8,
+      "type": "SCALAR"
+    }, {
+      "bufferView": 2,
+      "componentType": 5126,
+      "count": 8,
+      "type": "SCALAR"
+    }],
+  "asset": {
+    "version": "2.0"
+  },
+  "buffers": [{
+      "uri": "data:application/octet-stream;base64,AACAPwAAgD8AAIA/AACAPwAAgD8AAIA/AACAPwAAgD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+      "byteLength": 96
+    }],
+  "bufferViews": [{
+      "buffer": 0,
+      "byteLength": 32,
+      "target": 34962
+    }, {
+      "buffer": 0,
+      "byteOffset": 32,
+      "byteLength": 32,
+      "target": 34962
+    }, {
+      "buffer": 0,
+      "byteOffset": 64,
+      "byteLength": 32,
+      "target": 34962
+    }],
+  "meshes": [{
+      "primitives": [{
+          "attributes": {
+            "_c": 0,
+            "_b": 1,
+            "_a": 2
+          },
+          "mode": 2147483648,
+          "extensions": {
+            "EXT_structural_metadata": {
+              "propertyAttributes": [0]
+            },
+            "EXT_primitive_voxels": {
+              "dimensions": [2, 2, 2],
+              "bounds": {
+                "min": [-1.0, -1.0, -1.0],
+                "max": [1.0, 1.0, 1.0]
+              }
+            }
+          }
+        }]
+    }],
+  "nodes": [{
+      "matrix": [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+      "mesh": 0
+    }],
+  "scene": 0,
+  "scenes": [{
+      "nodes": [0]
+    }],
+  "extensions": {
+    "EXT_structural_metadata": {
+      "schemaUri": "../../../../schema.json",
+      "propertyAttributes": [{
+          "class": "voxel",
+          "properties": {
+            "a": {
+              "attribute": "_a"
+            },
+            "b": {
+              "attribute": "_b"
+            },
+            "c": {
+              "attribute": "_c"
+            }
+          }
+        }]
+    }
+  }
+}
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tiles/0/0/0/0.voxel b/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tiles/0/0/0/0.voxel
deleted file mode 100644
index 765dc0b2d2d7..000000000000
Binary files a/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tiles/0/0/0/0.voxel and /dev/null differ
diff --git a/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tileset.json b/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tileset.json
index c9867877b88b..40b392283aed 100644
--- a/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tileset.json
+++ b/Specs/Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tileset.json
@@ -2,30 +2,7 @@
   "asset": {
     "version": "1.1"
   },
-  "schema": {
-    "id": "voxel",
-    "classes": {
-      "voxel": {
-        "properties": {
-          "a": {
-            "type": "SCALAR",
-            "componentType": "FLOAT32",
-            "required": true
-          },
-          "b": {
-            "type": "SCALAR",
-            "componentType": "FLOAT32",
-            "required": true
-          },
-          "c": {
-            "type": "SCALAR",
-            "componentType": "FLOAT32",
-            "required": true
-          }
-        }
-      }
-    }
-  },
+  "schemaUri": "schema.json",
   "statistics": {
     "classes": {
       "voxel": {
@@ -56,7 +33,7 @@
     "refine": "REPLACE",
     "transform": [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0],
     "content": {
-      "uri": "tiles/{level}/{x}/{y}/{z}.voxel",
+      "uri": "tiles/{level}/{x}/{y}/{z}.gltf",
       "extensions": {
         "3DTILES_content_voxels": {
           "dimensions": [2, 2, 2],
@@ -75,4 +52,4 @@
   },
   "extensionsUsed": ["3DTILES_content_voxels"],
   "extensionsRequired": ["3DTILES_content_voxels"]
-}
\ No newline at end of file
+}
diff --git a/packages/engine/Source/Scene/Cesium3DTilesVoxelProvider.js b/packages/engine/Source/Scene/Cesium3DTilesVoxelProvider.js
index 4501a1cbd106..92e69bf5e5ed 100644
--- a/packages/engine/Source/Scene/Cesium3DTilesVoxelProvider.js
+++ b/packages/engine/Source/Scene/Cesium3DTilesVoxelProvider.js
@@ -1,27 +1,49 @@
 import Cartesian3 from "../Core/Cartesian3.js";
+import Cesium3DTilesetMetadata from "./Cesium3DTilesetMetadata.js";
 import Check from "../Core/Check.js";
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import Ellipsoid from "../Core/Ellipsoid.js";
-import Matrix4 from "../Core/Matrix4.js";
-import OrientedBoundingBox from "../Core/OrientedBoundingBox.js";
-import Resource from "../Core/Resource.js";
-import RuntimeError from "../Core/RuntimeError.js";
-import Cesium3DTilesetMetadata from "./Cesium3DTilesetMetadata.js";
 import hasExtension from "./hasExtension.js";
 import ImplicitSubtree from "./ImplicitSubtree.js";
 import ImplicitSubtreeCache from "./ImplicitSubtreeCache.js";
 import ImplicitTileCoordinates from "./ImplicitTileCoordinates.js";
 import ImplicitTileset from "./ImplicitTileset.js";
+import Matrix4 from "../Core/Matrix4.js";
 import MetadataSemantic from "./MetadataSemantic.js";
 import MetadataType from "./MetadataType.js";
+import OrientedBoundingBox from "../Core/OrientedBoundingBox.js";
 import preprocess3DTileContent from "./preprocess3DTileContent.js";
+import Resource from "../Core/Resource.js";
 import ResourceCache from "./ResourceCache.js";
+import RuntimeError from "../Core/RuntimeError.js";
 import VoxelBoxShape from "./VoxelBoxShape.js";
 import VoxelContent from "./VoxelContent.js";
 import VoxelCylinderShape from "./VoxelCylinderShape.js";
 import VoxelShapeType from "./VoxelShapeType.js";
 
+/**
+ * @typedef {Object} Cesium3DTilesVoxelProvider.ConstructorOptions
+ *
+ * Initialization options for the Cesium3DTilesVoxelProvider constructor
+ *
+ * @property {string} className The class in the tileset schema describing voxel metadata.
+ * @property {string[]} names The metadata names.
+ * @property {MetadataType[]} types The metadata types.
+ * @property {MetadataComponentType[]} componentTypes The metadata component types.
+ * @property {VoxelShapeType} shape The {@link VoxelShapeType}.
+ * @property {Cartesian3} dimensions The number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
+ * @property {Cartesian3} [paddingBefore=Cartesian3.ZERO] The number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
+ * @property {Cartesian3} [paddingAfter=Cartesian3.ZERO] The number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
+ * @property {Matrix4} [globalTransform=Matrix4.IDENTITY] A transform from local space to global space.
+ * @property {Matrix4} [shapeTransform=Matrix4.IDENTITY] A transform from shape space to local space.
+ * @property {Cartesian3} [minBounds] The minimum bounds.
+ * @property {Cartesian3} [maxBounds] The maximum bounds.
+ * @property {number[][]} [minimumValues] The metadata minimum values.
+ * @property {number[][]} [maximumValues] The metadata maximum values.
+ * @property {number} [maximumTileCount] The maximum number of tiles that exist for this provider. This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory. If this value is not known it can be undefined.
+ */
+
 /**
  * A {@link VoxelProvider} that fetches voxel data from a 3D Tiles tileset.
  * <p>
@@ -35,7 +57,7 @@ import VoxelShapeType from "./VoxelShapeType.js";
  * @constructor
  * @augments VoxelProvider
  *
- * @param {object} options Object with the following properties:
+ * @param {Cesium3DTilesVoxelProvider.ConstructorOptions} options An object describing initialization options
  *
  * @see Cesium3DTilesVoxelProvider.fromUrl
  * @see VoxelProvider
@@ -47,58 +69,261 @@ import VoxelShapeType from "./VoxelShapeType.js";
 function Cesium3DTilesVoxelProvider(options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
-  /** @inheritdoc */
-  this.shapeTransform = undefined;
+  const {
+    className,
+    names,
+    types,
+    componentTypes,
+    shape,
+    dimensions,
+    paddingBefore = Cartesian3.ZERO.clone(),
+    paddingAfter = Cartesian3.ZERO.clone(),
+    globalTransform = Matrix4.IDENTITY.clone(),
+    shapeTransform = Matrix4.IDENTITY.clone(),
+    minBounds,
+    maxBounds,
+    minimumValues,
+    maximumValues,
+    maximumTileCount,
+  } = options;
+
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.string("className", className);
+  Check.typeOf.object("names", names);
+  Check.typeOf.object("types", types);
+  Check.typeOf.object("componentTypes", componentTypes);
+  Check.typeOf.string("shape", shape);
+  Check.typeOf.object("dimensions", dimensions);
+  //>>includeEnd('debug');
+
+  this._shapeTransform = shapeTransform;
+  this._globalTransform = globalTransform;
+  this._shape = shape;
+  this._minBounds = minBounds;
+  this._maxBounds = maxBounds;
+  this._dimensions = dimensions;
+  this._paddingBefore = paddingBefore;
+  this._paddingAfter = paddingAfter;
+  this._className = className;
+  this._names = names;
+  this._types = types;
+  this._componentTypes = componentTypes;
+  this._minimumValues = minimumValues;
+  this._maximumValues = maximumValues;
+  this._maximumTileCount = maximumTileCount;
+  this._availableLevels = undefined;
+  this._implicitTileset = undefined;
+  this._subtreeCache = new ImplicitSubtreeCache();
+}
+
+Object.defineProperties(Cesium3DTilesVoxelProvider.prototype, {
+  /**
+   * A transform from local space to global space.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {Matrix4}
+   * @default Matrix4.IDENTITY
+   * @readonly
+   */
+  globalTransform: {
+    get: function () {
+      return this._globalTransform;
+    },
+  },
 
-  /** @inheritdoc */
-  this.globalTransform = undefined;
+  /**
+   * A transform from shape space to local space.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {Matrix4}
+   * @default Matrix4.IDENTITY
+   * @readonly
+   */
+  shapeTransform: {
+    get: function () {
+      return this._shapeTransform;
+    },
+  },
 
-  /** @inheritdoc */
-  this.shape = undefined;
+  /**
+   * Gets the {@link VoxelShapeType}
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {VoxelShapeType}
+   * @readonly
+   */
+  shape: {
+    get: function () {
+      return this._shape;
+    },
+  },
 
-  /** @inheritdoc */
-  this.minBounds = undefined;
+  /**
+   * Gets the minimum bounds.
+   * If undefined, the shape's default minimum bounds will be used instead.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {Cartesian3|undefined}
+   * @readonly
+   */
+  minBounds: {
+    get: function () {
+      return this._minBounds;
+    },
+  },
 
-  /** @inheritdoc */
-  this.maxBounds = undefined;
+  /**
+   * Gets the maximum bounds.
+   * If undefined, the shape's default maximum bounds will be used instead.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {Cartesian3|undefined}
+   * @readonly
+   */
+  maxBounds: {
+    get: function () {
+      return this._maxBounds;
+    },
+  },
 
-  /** @inheritdoc */
-  this.dimensions = undefined;
+  /**
+   * Gets the number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {Cartesian3}
+   * @readonly
+   */
+  dimensions: {
+    get: function () {
+      return this._dimensions;
+    },
+  },
 
-  /** @inheritdoc */
-  this.paddingBefore = undefined;
+  /**
+   * Gets the number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {Cartesian3}
+   * @default Cartesian3.ZERO
+   * @readonly
+   */
+  paddingBefore: {
+    get: function () {
+      return this._paddingBefore;
+    },
+  },
 
-  /** @inheritdoc */
-  this.paddingAfter = undefined;
+  /**
+   * Gets the number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {Cartesian3}
+   * @default Cartesian3.ZERO
+   * @readonly
+   */
+  paddingAfter: {
+    get: function () {
+      return this._paddingAfter;
+    },
+  },
 
-  /** @inheritdoc */
-  this.names = undefined;
+  /**
+   * The metadata class for this tileset.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {string}
+   * @readonly
+   */
+  className: {
+    get: function () {
+      return this._className;
+    },
+  },
 
-  /** @inheritdoc */
-  this.types = undefined;
+  /**
+   * Gets the metadata names.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {string[]}
+   * @readonly
+   */
+  names: {
+    get: function () {
+      return this._names;
+    },
+  },
 
-  /** @inheritdoc */
-  this.componentTypes = undefined;
+  /**
+   * Gets the metadata types.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {MetadataType[]}
+   * @readonly
+   */
+  types: {
+    get: function () {
+      return this._types;
+    },
+  },
 
-  /** @inheritdoc */
-  this.minimumValues = undefined;
+  /**
+   * Gets the metadata component types.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {MetadataComponentType[]}
+   * @readonly
+   */
+  componentTypes: {
+    get: function () {
+      return this._componentTypes;
+    },
+  },
 
-  /** @inheritdoc */
-  this.maximumValues = undefined;
+  /**
+   * Gets the metadata minimum values.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {number[][]|undefined}
+   * @readonly
+   */
+  minimumValues: {
+    get: function () {
+      return this._minimumValues;
+    },
+  },
 
-  /** @inheritdoc */
-  this.maximumTileCount = undefined;
+  /**
+   * Gets the metadata maximum values.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {number[][]|undefined}
+   * @readonly
+   */
+  maximumValues: {
+    get: function () {
+      return this._maximumValues;
+    },
+  },
 
-  this._availableLevels = undefined;
-  this._implicitTileset = undefined;
-  this._subtreeCache = new ImplicitSubtreeCache();
-}
+  /**
+   * The maximum number of tiles that exist for this provider.
+   * This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory.
+   * If this value is not known it can be undefined.
+   *
+   * @memberof Cesium3DTilesVoxelProvider.prototype
+   * @type {number|undefined}
+   * @readonly
+   */
+  maximumTileCount: {
+    get: function () {
+      return this._maximumTileCount;
+    },
+  },
 
-Object.defineProperties(Cesium3DTilesVoxelProvider.prototype, {
   /**
    * The number of levels of detail containing available tiles in the tileset.
    *
-   * @memberof VoxelPrimitive.prototype
+   * @memberof Cesium3DTilesVoxelProvider.prototype
    * @type {number|undefined}
    * @readonly
    */
@@ -110,7 +335,7 @@ Object.defineProperties(Cesium3DTilesVoxelProvider.prototype, {
 });
 
 /**
- * Creates a {@link VoxelProvider} that fetches voxel data from a 3D Tiles tileset.
+ * Creates a {@link Cesium3DTilesVoxelProvider} that fetches voxel data from a 3D Tiles tileset.
  *
  * @param {Resource|string} url The URL to a tileset JSON file
  * @returns {Promise<Cesium3DTilesVoxelProvider>} The created provider
@@ -120,6 +345,22 @@ Object.defineProperties(Cesium3DTilesVoxelProvider.prototype, {
  * @exception {RuntimeException} Root tile must have implicit tiling
  * @exception {RuntimeException} Tileset must have a metadata schema
  * @exception {RuntimeException} Only box, region and 3DTILES_bounding_volume_cylinder are supported in Cesium3DTilesVoxelProvider
+ *
+ * @example
+ * try {
+ *   const voxelProvider = await Cesium3DTilesVoxelProvider.fromUrl(
+ *     "http://localhost:8002/tilesets/voxel/tileset.json"
+ *   );
+ *   const voxelPrimitive = new VoxelPrimitive({
+ *     provider: voxelProvider,
+ *     customShader: customShader,
+ *   });
+ *   scene.primitives.add(voxelPrimitive);
+ * } catch (error) {
+ *   console.error(`Error creating voxel primitive: ${error}`);
+ * }
+ *
+ * @see {@link VoxelPrimitive}
  */
 Cesium3DTilesVoxelProvider.fromUrl = async function (url) {
   //>>includeStart('debug', pragmas.debug);
@@ -134,48 +375,38 @@ Cesium3DTilesVoxelProvider.fromUrl = async function (url) {
   const schemaLoader = getMetadataSchemaLoader(tilesetJson, resource);
   await schemaLoader.load();
 
-  const root = tilesetJson.root;
-  const voxel = root.content.extensions["3DTILES_content_voxels"];
-  const className = voxel.class;
+  const { root } = tilesetJson;
 
   const metadataJson = hasExtension(tilesetJson, "3DTILES_metadata")
     ? tilesetJson.extensions["3DTILES_metadata"]
     : tilesetJson;
 
-  const metadataSchema = schemaLoader.schema;
-  const metadata = new Cesium3DTilesetMetadata({
+  const tilesetMetadata = new Cesium3DTilesetMetadata({
     metadataJson: metadataJson,
-    schema: metadataSchema,
+    schema: schemaLoader.schema,
   });
 
-  const provider = new Cesium3DTilesVoxelProvider();
-
-  addAttributeInfo(provider, metadata, className);
-
-  const implicitTileset = new ImplicitTileset(resource, root, metadataSchema);
-
-  const { shape, minBounds, maxBounds, shapeTransform, globalTransform } =
-    getShape(root);
+  const voxel = root.content.extensions["3DTILES_content_voxels"];
+  const className = voxel.class;
 
-  provider.shape = shape;
-  provider.minBounds = minBounds;
-  provider.maxBounds = maxBounds;
-  provider.dimensions = Cartesian3.unpack(voxel.dimensions);
-  provider.shapeTransform = shapeTransform;
-  provider.globalTransform = globalTransform;
-  provider.maximumTileCount = getTileCount(metadata);
+  const providerOptions = getAttributeInfo(tilesetMetadata, className);
+  Object.assign(providerOptions, getShape(root));
 
-  let paddingBefore;
-  let paddingAfter;
+  providerOptions.dimensions = Cartesian3.unpack(voxel.dimensions);
+  providerOptions.maximumTileCount = getTileCount(tilesetMetadata);
 
   if (defined(voxel.padding)) {
-    paddingBefore = Cartesian3.unpack(voxel.padding.before);
-    paddingAfter = Cartesian3.unpack(voxel.padding.after);
+    providerOptions.paddingBefore = Cartesian3.unpack(voxel.padding.before);
+    providerOptions.paddingAfter = Cartesian3.unpack(voxel.padding.after);
   }
 
-  provider.paddingBefore = paddingBefore;
-  provider.paddingAfter = paddingAfter;
+  const provider = new Cesium3DTilesVoxelProvider(providerOptions);
 
+  const implicitTileset = new ImplicitTileset(
+    resource,
+    root,
+    schemaLoader.schema,
+  );
   provider._implicitTileset = implicitTileset;
   provider._availableLevels = implicitTileset.availableLevels;
 
@@ -315,7 +546,7 @@ function getMetadataSchemaLoader(tilesetJson, resource) {
   });
 }
 
-function addAttributeInfo(provider, metadata, className) {
+function getAttributeInfo(metadata, className) {
   const { schema, statistics } = metadata;
   const classStatistics = statistics?.classes[className];
   const properties = schema.classes[className].properties;
@@ -331,16 +562,22 @@ function addAttributeInfo(provider, metadata, className) {
     return { id, type, componentType, minValue, maxValue };
   });
 
-  provider.names = propertyInfo.map((info) => info.id);
-  provider.types = propertyInfo.map((info) => info.type);
-  provider.componentTypes = propertyInfo.map((info) => info.componentType);
+  const names = propertyInfo.map((info) => info.id);
+  const types = propertyInfo.map((info) => info.type);
+  const componentTypes = propertyInfo.map((info) => info.componentType);
 
   const minimumValues = propertyInfo.map((info) => info.minValue);
   const maximumValues = propertyInfo.map((info) => info.maxValue);
   const hasMinimumValues = minimumValues.some(defined);
 
-  provider.minimumValues = hasMinimumValues ? minimumValues : undefined;
-  provider.maximumValues = hasMinimumValues ? maximumValues : undefined;
+  return {
+    className,
+    names,
+    types,
+    componentTypes,
+    minimumValues: hasMinimumValues ? minimumValues : undefined,
+    maximumValues: hasMinimumValues ? maximumValues : undefined,
+  };
 }
 
 function copyArray(values, length) {
@@ -356,29 +593,14 @@ function copyArray(values, length) {
   return Array.from({ length }, (v, i) => valuesArray[i]);
 }
 
-async function getVoxelContent(implicitTileset, tileCoordinates) {
-  const voxelRelative =
-    implicitTileset.contentUriTemplates[0].getDerivedResource({
-      templateValues: tileCoordinates.getTemplateValues(),
-    });
-  const voxelResource = implicitTileset.baseResource.getDerivedResource({
-    url: voxelRelative.url,
-  });
-
-  const arrayBuffer = await voxelResource.fetchArrayBuffer();
-  const preprocessed = preprocess3DTileContent(arrayBuffer);
-
-  const voxelContent = await VoxelContent.fromJson(
-    voxelResource,
-    preprocessed.jsonPayload,
-    preprocessed.binaryPayload,
-    implicitTileset.metadataSchema,
-  );
-
-  return voxelContent;
-}
-
-async function getSubtreePromise(provider, subtreeCoord) {
+/**
+ * Get the subtree at a given subtree coordinate
+ * @param {VoxelProvider} provider The voxel provider
+ * @param {ImplicitTileCoordinates} subtreeCoord The coordinate at which to retrieve the subtree
+ * @returns {Promise<ImplicitSubtree>} The subtree at the given coordinate
+ * @private
+ */
+async function getSubtree(provider, subtreeCoord) {
   const implicitTileset = provider._implicitTileset;
   const subtreeCache = provider._subtreeCache;
 
@@ -419,27 +641,38 @@ async function getSubtreePromise(provider, subtreeCoord) {
   return subtree;
 }
 
-/** @inheritdoc */
-Cesium3DTilesVoxelProvider.prototype.requestData = function (options) {
+/**
+ * Requests the data for a given tile.
+ *
+ * @param {object} [options] Object with the following properties:
+ * @param {number} [options.tileLevel=0] The tile's level.
+ * @param {number} [options.tileX=0] The tile's X coordinate.
+ * @param {number} [options.tileY=0] The tile's Y coordinate.
+ * @param {number} [options.tileZ=0] The tile's Z coordinate.
+ * @privateparam {number} [options.keyframe=0] The requested keyframe.
+ * @returns {Promise<VoxelContent>|undefined} A promise resolving to a VoxelContent containing the data for the tile, or undefined if the request could not be scheduled this frame.
+ */
+Cesium3DTilesVoxelProvider.prototype.requestData = async function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const tileLevel = defaultValue(options.tileLevel, 0);
-  const tileX = defaultValue(options.tileX, 0);
-  const tileY = defaultValue(options.tileY, 0);
-  const tileZ = defaultValue(options.tileZ, 0);
-  const keyframe = defaultValue(options.keyframe, 0);
+  const {
+    tileLevel = 0,
+    tileX = 0,
+    tileY = 0,
+    tileZ = 0,
+    keyframe = 0,
+  } = options;
 
-  // 3D Tiles currently doesn't support time-dynamic data.
   if (keyframe !== 0) {
-    return undefined;
+    return Promise.reject(
+      `3D Tiles currently doesn't support time-dynamic data.`,
+    );
   }
 
   // 1. Load the subtree that the tile belongs to (possibly from the subtree cache)
   // 2. Load the voxel content if available
 
-  const implicitTileset = this._implicitTileset;
-  const names = this.names;
-
   // Can't use a scratch variable here because the object is used inside the promise chain.
+  const implicitTileset = this._implicitTileset;
   const tileCoordinates = new ImplicitTileCoordinates({
     subdivisionScheme: implicitTileset.subdivisionScheme,
     subtreeLevels: implicitTileset.subtreeLevels,
@@ -461,23 +694,29 @@ Cesium3DTilesVoxelProvider.prototype.requestData = function (options) {
 
   const that = this;
 
-  return getSubtreePromise(that, subtreeCoord)
-    .then(function (subtree) {
-      const available = isSubtreeRoot
-        ? subtree.childSubtreeIsAvailableAtCoordinates(tileCoordinates)
-        : subtree.tileIsAvailableAtCoordinates(tileCoordinates);
-
-      if (!available) {
-        return Promise.reject("Tile is not available");
-      }
-
-      return getVoxelContent(implicitTileset, tileCoordinates);
-    })
-    .then(function (voxelContent) {
-      return names.map(function (name) {
-        return voxelContent.metadataTable.getPropertyTypedArray(name);
-      });
-    });
+  const subtree = await getSubtree(that, subtreeCoord);
+  // NOTE: these two subtree methods are ONLY used by voxels!
+  const isAvailable = isSubtreeRoot
+    ? subtree.childSubtreeIsAvailableAtCoordinates
+    : subtree.tileIsAvailableAtCoordinates;
+
+  const available = isAvailable.call(subtree, tileCoordinates);
+
+  if (!available) {
+    return Promise.reject(
+      `Tile is not available at level ${tileLevel}, x ${tileX}, y ${tileY}, z ${tileZ}.`,
+    );
+  }
+
+  const { contentUriTemplates, baseResource } = implicitTileset;
+  const gltfRelative = contentUriTemplates[0].getDerivedResource({
+    templateValues: tileCoordinates.getTemplateValues(),
+  });
+  const gltfResource = baseResource.getDerivedResource({
+    url: gltfRelative.url,
+  });
+
+  return VoxelContent.fromGltf(gltfResource);
 };
 
 export default Cesium3DTilesVoxelProvider;
diff --git a/packages/engine/Source/Scene/GltfLoader.js b/packages/engine/Source/Scene/GltfLoader.js
index 35cdc7585012..e1fa984f6b73 100644
--- a/packages/engine/Source/Scene/GltfLoader.js
+++ b/packages/engine/Source/Scene/GltfLoader.js
@@ -2191,16 +2191,14 @@ function loadPrimitiveMetadata(primitive, structuralMetadataExtension) {
   if (!defined(structuralMetadataExtension)) {
     return;
   }
+  const { propertyTextures, propertyAttributes } = structuralMetadataExtension;
 
-  // Property Textures
-  if (defined(structuralMetadataExtension.propertyTextures)) {
-    primitive.propertyTextureIds = structuralMetadataExtension.propertyTextures;
+  if (defined(propertyTextures)) {
+    primitive.propertyTextureIds = propertyTextures;
   }
 
-  // Property Attributes
-  if (defined(structuralMetadataExtension.propertyAttributes)) {
-    primitive.propertyAttributeIds =
-      structuralMetadataExtension.propertyAttributes;
+  if (defined(propertyAttributes)) {
+    primitive.propertyAttributeIds = propertyAttributes;
   }
 }
 
diff --git a/packages/engine/Source/Scene/ImplicitSubtree.js b/packages/engine/Source/Scene/ImplicitSubtree.js
index d59d4516e34a..33dcc59caf13 100644
--- a/packages/engine/Source/Scene/ImplicitSubtree.js
+++ b/packages/engine/Source/Scene/ImplicitSubtree.js
@@ -183,6 +183,7 @@ ImplicitSubtree.prototype.tileIsAvailableAtIndex = function (index) {
 
 /**
  * Check if a specific tile is available at an implicit tile coordinate
+ * NOTE: only used for voxels.
  *
  * @param {ImplicitTileCoordinates} implicitCoordinates The global coordinates of a tile
  * @returns {boolean} The value of the i-th bit
@@ -249,6 +250,7 @@ ImplicitSubtree.prototype.childSubtreeIsAvailableAtIndex = function (index) {
 
 /**
  * Check if a specific child subtree is available at an implicit tile coordinate
+ * NOTE: only used for voxels.
  *
  * @param {ImplicitTileCoordinates} implicitCoordinates The global coordinates of a child subtree
  * @returns {boolean} The value of the i-th bit
diff --git a/packages/engine/Source/Scene/KeyframeNode.js b/packages/engine/Source/Scene/KeyframeNode.js
index 43071b8a9d0a..4b8ad648ab20 100644
--- a/packages/engine/Source/Scene/KeyframeNode.js
+++ b/packages/engine/Source/Scene/KeyframeNode.js
@@ -1,7 +1,7 @@
 const LoadState = Object.freeze({
   UNLOADED: 0, // Has no data and is in dormant state
   RECEIVING: 1, // Is waiting on data from the provider
-  RECEIVED: 2, // Received data from the provider
+  PROCESSING: 2, // Data received.  Contents are being processed for rendering.  Depending on the content, it might make its own requests for external data.
   LOADED: 3, // Processed data from provider
   FAILED: 4, // Failed to receive data from the provider
   UNAVAILABLE: 5, // No data available for this tile
@@ -20,12 +20,26 @@ function KeyframeNode(spatialNode, keyframe) {
   this.spatialNode = spatialNode;
   this.keyframe = keyframe;
   this.state = LoadState.UNLOADED;
-  this.metadata = [];
+  this.content = undefined;
   this.megatextureIndex = -1;
   this.priority = -Number.MAX_VALUE;
   this.highPriorityFrameNumber = -1;
 }
 
+/**
+ * Frees the resources used by this object.
+ * @private
+ */
+KeyframeNode.prototype.unload = function () {
+  this.content = this.content && this.content.destroy();
+
+  this.spatialNode = undefined;
+  this.state = LoadState.UNLOADED;
+  this.megatextureIndex = -1;
+  this.priority = -Number.MAX_VALUE;
+  this.highPriorityFrameNumber = -1;
+};
+
 /**
  * @param {KeyframeNode} a
  * @param {KeyframeNode} b
diff --git a/packages/engine/Source/Scene/Megatexture.js b/packages/engine/Source/Scene/Megatexture.js
index f91828ef0d3f..4489196d4357 100644
--- a/packages/engine/Source/Scene/Megatexture.js
+++ b/packages/engine/Source/Scene/Megatexture.js
@@ -16,6 +16,7 @@ import Texture from "../Renderer/Texture.js";
 import TextureMagnificationFilter from "../Renderer/TextureMagnificationFilter.js";
 import TextureMinificationFilter from "../Renderer/TextureMinificationFilter.js";
 import TextureWrap from "../Renderer/TextureWrap.js";
+import VoxelMetadataOrder from "./VoxelMetadataOrder.js";
 
 /**
  * @alias Megatexture
@@ -275,10 +276,12 @@ function MegatextureNode(index) {
 }
 
 /**
- * @param {Array} data
- * @returns {number}
+ * Add an array of tile metadata to the megatexture.
+ * @param {Array} data The data to be added.
+ * @param {VoxelMetadataOrder} [order=VoxelMetadataOrder.XYZ] The ordering of the data in the array.
+ * @returns {number} The index of the tile's location in the megatexture.
  */
-Megatexture.prototype.add = function (data) {
+Megatexture.prototype.add = function (data, order) {
   if (this.isFull()) {
     throw new DeveloperError("Trying to add when there are no empty spots");
   }
@@ -298,7 +301,7 @@ Megatexture.prototype.add = function (data) {
   this.occupiedList = node;
 
   const index = node.index;
-  this.writeDataToTexture(index, data);
+  this.writeDataToTexture(index, data, order);
 
   this.occupiedCount++;
   return index;
@@ -390,55 +393,53 @@ Megatexture.getApproximateTextureMemoryByteLength = function (
 };
 
 /**
- * @param {number} index
- * @param {Float32Array|Uint16Array|Uint8Array} data
+ * Write an array of tile metadata to the megatexture.
+ * @param {number} index The index of the tile's location in the megatexture.
+ * @param {Float32Array|Uint16Array|Uint8Array} data The data to be written.
+ * @param {VoxelMetadataOrder} [order=VoxelMetadataOrder.XYZ] The ordering of the data in the array
  */
-Megatexture.prototype.writeDataToTexture = function (index, data) {
+Megatexture.prototype.writeDataToTexture = function (index, data, order) {
   // Unsigned short textures not allowed in webgl 1, so treat as float
   const tileData =
     data.constructor === Uint16Array ? new Float32Array(data) : data;
 
-  const voxelDimensionsPerTile = this.voxelCountPerTile;
-  const sliceDimensionsPerRegion = this.sliceCountPerRegion;
-  const voxelDimensionsPerRegion = this.voxelCountPerRegion;
-  const channelCount = this.channelCount;
-
-  const tileVoxelData = this.tileVoxelDataTemp;
-  for (let z = 0; z < voxelDimensionsPerTile.z; z++) {
-    const sliceVoxelOffsetX =
-      (z % sliceDimensionsPerRegion.x) * voxelDimensionsPerTile.x;
+  const {
+    tileVoxelDataTemp,
+    voxelCountPerTile,
+    sliceCountPerRegion,
+    voxelCountPerRegion,
+    channelCount,
+    regionCountPerMegatexture,
+  } = this;
+
+  for (let z = 0; z < voxelCountPerTile.z; z++) {
+    const sliceVoxelOffsetX = (z % sliceCountPerRegion.x) * voxelCountPerTile.x;
     const sliceVoxelOffsetY =
-      Math.floor(z / sliceDimensionsPerRegion.x) * voxelDimensionsPerTile.y;
-    for (let y = 0; y < voxelDimensionsPerTile.y; y++) {
-      for (let x = 0; x < voxelDimensionsPerTile.x; x++) {
-        const readIndex =
-          z * voxelDimensionsPerTile.y * voxelDimensionsPerTile.x +
-          y * voxelDimensionsPerTile.x +
-          x;
-        const writeIndex =
-          (sliceVoxelOffsetY + y) * voxelDimensionsPerRegion.x +
-          (sliceVoxelOffsetX + x);
+      Math.floor(z / sliceCountPerRegion.x) * voxelCountPerTile.y;
+    for (let y = 0; y < voxelCountPerTile.y; y++) {
+      const readOffset = getReadOffset(order, voxelCountPerTile, y, z);
+      const writeOffset =
+        (sliceVoxelOffsetY + y) * voxelCountPerRegion.x + sliceVoxelOffsetX;
+      for (let x = 0; x < voxelCountPerTile.x; x++) {
+        const readIndex = readOffset + x;
+        const writeIndex = writeOffset + x;
         for (let c = 0; c < channelCount; c++) {
-          tileVoxelData[writeIndex * channelCount + c] =
+          tileVoxelDataTemp[writeIndex * channelCount + c] =
             tileData[readIndex * channelCount + c];
         }
       }
     }
   }
 
-  const regionDimensionsPerMegatexture = this.regionCountPerMegatexture;
-  const voxelWidth = voxelDimensionsPerRegion.x;
-  const voxelHeight = voxelDimensionsPerRegion.y;
   const voxelOffsetX =
-    (index % regionDimensionsPerMegatexture.x) * voxelDimensionsPerRegion.x;
+    (index % regionCountPerMegatexture.x) * voxelCountPerRegion.x;
   const voxelOffsetY =
-    Math.floor(index / regionDimensionsPerMegatexture.x) *
-    voxelDimensionsPerRegion.y;
+    Math.floor(index / regionCountPerMegatexture.x) * voxelCountPerRegion.y;
 
   const source = {
-    arrayBufferView: tileVoxelData,
-    width: voxelWidth,
-    height: voxelHeight,
+    arrayBufferView: tileVoxelDataTemp,
+    width: voxelCountPerRegion.x,
+    height: voxelCountPerRegion.y,
   };
 
   const copyOptions = {
@@ -450,6 +451,29 @@ Megatexture.prototype.writeDataToTexture = function (index, data) {
   this.texture.copyFrom(copyOptions);
 };
 
+/**
+ * Get the offset into the data array for a given row of contiguous voxel data.
+ *
+ * @param {VoxelMetadataOrder} order
+ * @param {Cartesian3} dimensions The number of voxels in each dimension of the tile.
+ * @param {number} y The y index of the voxel row
+ * @param {number} z The z index of the voxel row
+ * @returns {number} The offset into the data array
+ * @private
+ */
+function getReadOffset(order, dimensions, y, z) {
+  if (order !== VoxelMetadataOrder.GLTF) {
+    const voxelsPerInputSlice = dimensions.y * dimensions.x;
+    const sliceIndex = z;
+    const rowIndex = y;
+    return sliceIndex * voxelsPerInputSlice + rowIndex * dimensions.x;
+  }
+  const voxelsPerInputSlice = dimensions.z * dimensions.x;
+  const sliceIndex = y;
+  const rowIndex = dimensions.z - 1 - z;
+  return sliceIndex * voxelsPerInputSlice + rowIndex * dimensions.x;
+}
+
 /**
  * Returns true if this object was destroyed; otherwise, false.
  * <br /><br />
diff --git a/packages/engine/Source/Scene/Model/Model.js b/packages/engine/Source/Scene/Model/Model.js
index d1aae816fd2a..afc4aa6e7b67 100644
--- a/packages/engine/Source/Scene/Model/Model.js
+++ b/packages/engine/Source/Scene/Model/Model.js
@@ -120,9 +120,9 @@ import pickModel from "./pickModel.js";
  * @alias Model
  * @internalConstructor
  *
+ * @privateParam {object} options Object with the following properties:
  * @privateParam {ResourceLoader} options.loader The loader used to load resources for this model.
  * @privateParam {ModelType} options.type Type of this model, to distinguish individual glTF files from 3D Tiles internally.
- * @privateParam {object} options Object with the following properties:
  * @privateParam {Resource} options.resource The Resource to the 3D model.
  * @privateParam {boolean} [options.show=true] Whether or not to render the model.
  * @privateParam {Matrix4} [options.modelMatrix=Matrix4.IDENTITY]  The 4x4 transformation matrix that transforms the model from model to world coordinates.
diff --git a/packages/engine/Source/Scene/Model/ModelUtility.js b/packages/engine/Source/Scene/Model/ModelUtility.js
index a117a878b10f..f21a96071eb9 100644
--- a/packages/engine/Source/Scene/Model/ModelUtility.js
+++ b/packages/engine/Source/Scene/Model/ModelUtility.js
@@ -346,15 +346,18 @@ ModelUtility.supportedExtensions = {
   CESIUM_primitive_outline: true,
   CESIUM_RTC: true,
   EXT_feature_metadata: true,
+  EXT_implicit_cylinder_region: true,
+  EXT_implicit_ellipsoid_region: true,
   EXT_instance_features: true,
   EXT_mesh_features: true,
   EXT_mesh_gpu_instancing: true,
   EXT_meshopt_compression: true,
+  EXT_primitive_voxels: true,
   EXT_structural_metadata: true,
   EXT_texture_webp: true,
   KHR_blend: true,
   KHR_draco_mesh_compression: true,
-  KHR_techniques_webgl: true,
+  KHR_implicit_shapes: true,
   KHR_materials_common: true,
   KHR_materials_pbrSpecularGlossiness: true,
   KHR_materials_specular: true,
@@ -362,6 +365,7 @@ ModelUtility.supportedExtensions = {
   KHR_materials_clearcoat: true,
   KHR_materials_unlit: true,
   KHR_mesh_quantization: true,
+  KHR_techniques_webgl: true,
   KHR_texture_basisu: true,
   KHR_texture_transform: true,
   WEB3D_quantized_attributes: true,
diff --git a/packages/engine/Source/Scene/SpatialNode.js b/packages/engine/Source/Scene/SpatialNode.js
index 1617bb41ab23..e7a34ff58f6f 100644
--- a/packages/engine/Source/Scene/SpatialNode.js
+++ b/packages/engine/Source/Scene/SpatialNode.js
@@ -320,12 +320,7 @@ SpatialNode.prototype.destroyKeyframeNode = function (
     this.renderableKeyframeNodes.splice(renderableKeyframeNodeIndex, 1);
   }
 
-  keyframeNode.spatialNode = undefined;
-  keyframeNode.state = KeyframeNode.LoadState.UNLOADED;
-  keyframeNode.metadata = {};
-  keyframeNode.megatextureIndex = -1;
-  keyframeNode.priority = -Number.MAX_VALUE;
-  keyframeNode.highPriorityFrameNumber = -1;
+  keyframeNode.unload();
 };
 
 /**
@@ -337,20 +332,18 @@ SpatialNode.prototype.addKeyframeNodeToMegatextures = function (
   megatextures,
 ) {
   if (
-    keyframeNode.state !== KeyframeNode.LoadState.RECEIVED ||
     keyframeNode.megatextureIndex !== -1 ||
-    keyframeNode.metadata.length !== megatextures.length
+    keyframeNode.content.metadata.length !== megatextures.length
   ) {
     throw new DeveloperError("Keyframe node cannot be added to megatexture");
   }
 
+  const { metadata, order } = keyframeNode.content;
   for (let i = 0; i < megatextures.length; i++) {
     const megatexture = megatextures[i];
-    keyframeNode.megatextureIndex = megatexture.add(keyframeNode.metadata[i]);
+    keyframeNode.megatextureIndex = megatexture.add(metadata[i], order);
   }
 
-  keyframeNode.state = KeyframeNode.LoadState.LOADED;
-
   const renderableKeyframeNodes = this.renderableKeyframeNodes;
   let renderableKeyframeNodeIndex = findKeyframeIndex(
     keyframeNode.keyframe,
diff --git a/packages/engine/Source/Scene/VoxelCell.js b/packages/engine/Source/Scene/VoxelCell.js
index b87d0e235bde..ead0d793a7c4 100644
--- a/packages/engine/Source/Scene/VoxelCell.js
+++ b/packages/engine/Source/Scene/VoxelCell.js
@@ -71,8 +71,8 @@ VoxelCell.fromKeyframeNode = function (
   //>>includeEnd('debug');
 
   const voxelCell = new VoxelCell(primitive, tileIndex, sampleIndex);
-  const { spatialNode, metadata } = keyframeNode;
-  voxelCell._metadata = getMetadataForSample(primitive, metadata, sampleIndex);
+  const { spatialNode, content } = keyframeNode;
+  voxelCell._metadata = getMetadataForSample(primitive, content, sampleIndex);
   voxelCell._orientedBoundingBox = getOrientedBoundingBox(
     primitive,
     spatialNode,
@@ -85,15 +85,16 @@ VoxelCell.fromKeyframeNode = function (
 /**
  * @private
  * @param {VoxelPrimitive} primitive
- * @param {object} metadata
+ * @param {VoxelContent} content
  * @param {number} sampleIndex
  * @returns {object}
  */
-function getMetadataForSample(primitive, metadata, sampleIndex) {
-  if (!defined(metadata)) {
+function getMetadataForSample(primitive, content, sampleIndex) {
+  if (!defined(content) || !defined(content.metadata)) {
     return undefined;
   }
   const { names, types } = primitive.provider;
+  const { metadata } = content;
   const metadataMap = {};
   for (let i = 0; i < names.length; i++) {
     const name = names[i];
diff --git a/packages/engine/Source/Scene/VoxelContent.js b/packages/engine/Source/Scene/VoxelContent.js
index 451be03d2493..4f2d0e3afa74 100644
--- a/packages/engine/Source/Scene/VoxelContent.js
+++ b/packages/engine/Source/Scene/VoxelContent.js
@@ -1,167 +1,251 @@
+import { destroyObject } from "@cesium/engine";
 import Check from "../Core/Check.js";
+import ComponentDatatype from "../Core/ComponentDatatype.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import defined from "../Core/defined.js";
-import getJsonFromTypedArray from "../Core/getJsonFromTypedArray.js";
-import MetadataTable from "./MetadataTable.js";
+import GltfLoader from "./GltfLoader.js";
+import MetadataComponentType from "./MetadataComponentType.js";
+import MetadataType from "./MetadataType.js";
+import VoxelMetadataOrder from "./VoxelMetadataOrder.js";
 
 /**
+ * <div class="notice">
+ * To construct a VoxelContent, call {@link VoxelContent.fromMetadataArray} or {@link VoxelContent.fromGltf}. Do not call the constructor directly.
+ * </div>
  * An object representing voxel content for a {@link Cesium3DTilesVoxelProvider}.
  *
  * @alias VoxelContent
- * @constructor
+ * @internalConstructor
  *
- * @param {Resource} resource The resource for this voxel content. This is used for fetching external buffers as needed.
+ * @privateParam {object} options An object with the following properties:
+ * @privateParam {ResourceLoader} [options.loader] The loader used to load the voxel content.
+ * @privateParam {Int8Array[]|Uint8Array[]|Int16Array[]|Uint16Array[]|Int32Array[]|Uint32Array[]|Float32Array[]|Float64Array[]} [options.metadata] The metadata for this voxel content.
+ * @privateParam {VoxelMetadataOrder} [options.order=VoxelMetadataOrder.XYZ] The order of the metadata.
+ *
+ * @exception {DeveloperError} One of loader and metadata must be defined.
+ * @exception {DeveloperError} metadata must be an array of TypedArrays.
  *
- * @private
  * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
  */
-function VoxelContent(resource) {
+function VoxelContent(options) {
   //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("resource", resource);
+  Check.typeOf.object("options", options);
+  if (!defined(options.loader)) {
+    if (!defined(options.metadata)) {
+      throw new DeveloperError("One of loader and metadata must be defined.");
+    }
+    if (!Array.isArray(options.metadata)) {
+      throw new DeveloperError("metadata must be an array of TypedArrays.");
+    }
+  }
   //>>includeEnd('debug');
 
-  this._resource = resource;
-  this._metadataTable = undefined;
+  const { loader, metadata, order = VoxelMetadataOrder.XYZ } = options;
+
+  this._loader = loader;
+  this._metadata = metadata;
+  this._order = order;
+  this._resourcesLoaded = false;
+  this._ready = false;
 }
 
 Object.defineProperties(VoxelContent.prototype, {
   /**
-   * The {@link MetadataTable} storing voxel property values.
+   * Returns true when the content is ready to render; otherwise false
+   *
+   * @memberof VoxelContent.prototype
    *
-   * @type {MetadataTable}
+   * @type {boolean}
    * @readonly
    * @private
    */
-  metadataTable: {
+  ready: {
+    get: function () {
+      return this._ready;
+    },
+  },
+
+  /**
+   * The metadata for this voxel content.
+   * The metadata is an array of typed arrays, one for each field.
+   * The data for one field is a flattened 3D array ordered by X, then Y, then Z.
+   * @type {Int8Array[]|Uint8Array[]|Int16Array[]|Uint16Array[]|Int32Array[]|Uint32Array[]|Float32Array[]|Float64Array[]}
+   * @readonly
+   */
+  metadata: {
     get: function () {
-      return this._metadataTable;
+      return this._metadata;
+    },
+  },
+
+  /**
+   * The order of the metadata.
+   * @type {VoxelMetadataOrder}
+   * @readonly
+   */
+  order: {
+    get: function () {
+      return this._order;
     },
   },
 });
 
 /**
- * Creates an object representing voxel content for a {@link Cesium3DTilesVoxelProvider}.
+ * Constructs a VoxelContent from an array of metadata.
  *
- * @param {Resource} resource The resource for this voxel content. This is used for fetching external buffers as needed.
- * @param {object} [json] Voxel JSON contents. Mutually exclusive with binary.
- * @param {Uint8Array} [binary] Voxel binary contents. Mutually exclusive with json.
- * @param {MetadataSchema} metadataSchema The metadata schema used by property tables in the voxel content
- * @returns {Promise<VoxelContent>}
+ * @param {Int8Array[]|Uint8Array[]|Int16Array[]|Uint16Array[]|Int32Array[]|Uint32Array[]|Float32Array[]|Float64Array[]} metadata The metadata to use for this voxel content.
+ * @returns {VoxelContent} A VoxelContent containing the specified metadata.
+ */
+VoxelContent.fromMetadataArray = function (metadata) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("metadata", metadata);
+  if (!Array.isArray(metadata)) {
+    throw new DeveloperError("metadata must be an array of TypedArrays.");
+  }
+  //>>includeEnd('debug');
+
+  return new VoxelContent({
+    metadata,
+    order: VoxelMetadataOrder.XYZ,
+  });
+};
+
+/**
+ * Constructs a VoxelContent from a glTF resource.
  *
- * @exception {DeveloperError} One of json and binary must be defined.
+ * @param {Resource} resource A Resource pointing to a glTF containing voxel content.
+ * @returns {Promise<VoxelContent>} A promise that resolves to the voxel content.
+ *
+ * @private
  */
-VoxelContent.fromJson = async function (
-  resource,
-  json,
-  binary,
-  metadataSchema,
-) {
+VoxelContent.fromGltf = async function (resource) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("resource", resource);
-  if (defined(json) === defined(binary)) {
-    throw new DeveloperError("One of json and binary must be defined.");
-  }
   //>>includeEnd('debug');
 
-  let chunks;
-  if (defined(json)) {
-    chunks = {
-      json: json,
-      binary: undefined,
-    };
-  } else {
-    chunks = parseVoxelChunks(binary);
+  // Construct the glTF loader
+  const loader = new GltfLoader({
+    gltfResource: resource,
+    releaseGltfJson: false,
+    loadAttributesAsTypedArray: true,
+  });
+
+  try {
+    // This loads the gltf JSON and ensures the gltf is valid
+    // Further resource loading is handled synchronously in loader.process()
+    // via voxelContent.update() as the frameState is needed
+    await loader.load();
+  } catch (error) {
+    loader.destroy();
+    throw error;
   }
 
-  const buffersU8 = await requestBuffers(resource, chunks.json, chunks.binary);
-  const bufferViewsU8 = {};
-  const bufferViewsLength = chunks.json.bufferViews.length;
-  for (let i = 0; i < bufferViewsLength; ++i) {
-    const bufferViewJson = chunks.json.bufferViews[i];
-    const start = bufferViewJson.byteOffset;
-    const end = start + bufferViewJson.byteLength;
-    const buffer = buffersU8[bufferViewJson.buffer];
-    const bufferView = buffer.subarray(start, end);
-    bufferViewsU8[i] = bufferView;
+  return new VoxelContent({
+    loader: loader,
+    order: VoxelMetadataOrder.GLTF,
+  });
+};
+
+/**
+ * Updates the content until all resources are ready for rendering.
+ * @param {FrameState} frameState The frame state
+ * @private
+ */
+VoxelContent.prototype.update = function (primitive, frameState) {
+  const loader = this._loader;
+
+  if (this._ready) {
+    // Nothing to do
+    return;
   }
 
-  const propertyTableIndex = chunks.json.voxelTable;
-  const propertyTableJson = chunks.json.propertyTables[propertyTableIndex];
+  // Ensures frames continue to render in requestRender mode while resources are processing
+  frameState.afterRender.push(() => true);
 
-  const content = new VoxelContent(resource);
+  if (!defined(loader)) {
+    this._ready = true;
+    return;
+  }
 
-  content._metadataTable = new MetadataTable({
-    count: propertyTableJson.count,
-    properties: propertyTableJson.properties,
-    class: metadataSchema.classes[propertyTableJson.class],
-    bufferViews: bufferViewsU8,
-  });
+  if (this._resourcesLoaded) {
+    const { structuralMetadata, scene } = loader.components;
+    const { attributes } = scene.nodes[0].primitives[0];
+    this._metadata = processAttributes(
+      attributes,
+      structuralMetadata,
+      primitive,
+    );
+    this._ready = true;
+    return;
+  }
 
-  return content;
+  this._resourcesLoaded = loader.process(frameState);
 };
 
-function requestBuffers(resource, json, binary) {
-  const buffersLength = json.buffers.length;
-  const bufferPromises = new Array(buffersLength);
-  for (let i = 0; i < buffersLength; i++) {
-    const buffer = json.buffers[i];
-    if (defined(buffer.uri)) {
-      const baseResource = resource;
-      const bufferResource = baseResource.getDerivedResource({
-        url: buffer.uri,
-      });
-      bufferPromises[i] = bufferResource
-        .fetchArrayBuffer()
-        .then(function (arrayBuffer) {
-          return new Uint8Array(arrayBuffer);
-        });
-    } else {
-      bufferPromises[i] = Promise.resolve(binary);
+/**
+ * Processes the attributes from the glTF loader, reordering them into the order expected by the primitive.
+ *
+ * @param {ModelComponents.Attribute[]} attributes The attributes to process
+ * @param {StructuralMetadata} structuralMetadata Information from the glTF EXT_structural_metadata extension
+ * @param {VoxelPrimitive} primitive The primitive for which this voxel content will be used.
+ * @returns {Int8Array[]|Uint8Array[]|Int16Array[]|Uint16Array[]|Int32Array[]|Uint32Array[]|Float32Array[]|Float64Array[]} An array of typed arrays containing the attribute values
+ * @private
+ */
+function processAttributes(attributes, structuralMetadata, primitive) {
+  const { className, names, types, componentTypes } = primitive.provider;
+  const propertyAttribute = structuralMetadata.propertyAttributes.find(
+    (p) => p.class.id === className,
+  );
+  const { properties } = propertyAttribute;
+  const data = new Array(names.length);
+
+  for (let i = 0; i < attributes.length; i++) {
+    // Find the appropriate glTF attribute based on its name.
+    const name = properties[names[i]].attribute;
+    const attribute = attributes.find((a) => a.name === name);
+    if (!defined(attribute)) {
+      continue;
     }
+
+    const componentDatatype = MetadataComponentType.toComponentDatatype(
+      componentTypes[i],
+    );
+    const componentCount = MetadataType.getComponentCount(types[i]);
+    const totalCount = attribute.count * componentCount;
+    data[i] = ComponentDatatype.createArrayBufferView(
+      componentDatatype,
+      attribute.typedArray.buffer,
+      attribute.typedArray.byteOffset + attribute.byteOffset,
+      totalCount,
+    );
   }
 
-  return Promise.all(bufferPromises);
+  return data;
 }
 
 /**
- * A helper object for storing the two parts of the binary voxel content
+ * Returns true if this object was destroyed; otherwise, false.
+ * <br /><br />
+ * If this object was destroyed, it should not be used; calling any function other than
+ * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+ *
+ * @returns {boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+ *
+ * @see VoxelContent#destroy
  *
- * @typedef {object} VoxelChunks
- * @property {object} json The json chunk of the binary voxel content
- * @property {Uint8Array} binary The binary chunk of the binary voxel content. This represents the internal buffer.
  * @private
  */
+VoxelContent.prototype.isDestroyed = function () {
+  return false;
+};
 
 /**
- * Given binary voxel content, split into JSON and binary chunks
- *
- * @param {Uint8Array} binaryView The binary voxel content
- * @returns {VoxelChunks} An object containing the JSON and binary chunks
+ * Frees the resources used by this object.
  * @private
  */
-function parseVoxelChunks(binaryView) {
-  // Parse the header
-  const littleEndian = true;
-  const reader = new DataView(binaryView.buffer, binaryView.byteOffset);
-  // Skip to the chunk lengths
-  let byteOffset = 8;
-
-  // Read the bottom 32 bits of the 64-bit byte length. This is ok for now because:
-  // 1) not all browsers have native 64-bit operations
-  // 2) the data is well under 4GB
-  const jsonByteLength = reader.getUint32(byteOffset, littleEndian);
-  byteOffset += 8;
-  const binaryByteLength = reader.getUint32(byteOffset, littleEndian);
-  byteOffset += 8;
-
-  const json = getJsonFromTypedArray(binaryView, byteOffset, jsonByteLength);
-  byteOffset += jsonByteLength;
-  const binary = binaryView.subarray(byteOffset, byteOffset + binaryByteLength);
-
-  return {
-    json: json,
-    binary: binary,
-  };
-}
+VoxelContent.prototype.destroy = function () {
+  this._loader = this._loader && this._loader.destroy();
+  return destroyObject(this);
+};
 
 export default VoxelContent;
diff --git a/packages/engine/Source/Scene/VoxelCylinderShape.js b/packages/engine/Source/Scene/VoxelCylinderShape.js
index 7418193bdfc9..28cfe6647ffc 100644
--- a/packages/engine/Source/Scene/VoxelCylinderShape.js
+++ b/packages/engine/Source/Scene/VoxelCylinderShape.js
@@ -71,37 +71,37 @@ function VoxelCylinderShape() {
    * @type {number}
    * @private
    */
-  this._minimumHeight = VoxelCylinderShape.DefaultMinBounds.y;
+  this._minimumAngle = VoxelCylinderShape.DefaultMinBounds.y;
 
   /**
    * @type {number}
    * @private
    */
-  this._maximumHeight = VoxelCylinderShape.DefaultMaxBounds.y;
+  this._maximumAngle = VoxelCylinderShape.DefaultMaxBounds.y;
 
   /**
    * @type {number}
    * @private
    */
-  this._minimumAngle = VoxelCylinderShape.DefaultMinBounds.z;
+  this._minimumHeight = VoxelCylinderShape.DefaultMinBounds.z;
 
   /**
    * @type {number}
    * @private
    */
-  this._maximumAngle = VoxelCylinderShape.DefaultMaxBounds.z;
+  this._maximumHeight = VoxelCylinderShape.DefaultMaxBounds.z;
 
   /**
    * @type {Object<string, any>}
    * @readonly
    */
   this.shaderUniforms = {
-    cylinderRenderHeightMinMax: new Cartesian2(),
     cylinderRenderRadiusMinMax: new Cartesian2(),
     cylinderRenderAngleMinMax: new Cartesian2(),
+    cylinderRenderHeightMinMax: new Cartesian2(),
     cylinderUvToShapeUvRadius: new Cartesian2(),
-    cylinderUvToShapeUvHeight: new Cartesian2(),
     cylinderUvToShapeUvAngle: new Cartesian2(),
+    cylinderUvToShapeUvHeight: new Cartesian2(),
     cylinderShapeUvAngleMinMax: new Cartesian2(),
     cylinderShapeUvAngleRangeZeroMid: 0.0,
   };
@@ -173,10 +173,10 @@ VoxelCylinderShape.prototype.update = function (
 
   const defaultMinRadius = VoxelCylinderShape.DefaultMinBounds.x;
   const defaultMaxRadius = VoxelCylinderShape.DefaultMaxBounds.x;
-  const defaultMinHeight = VoxelCylinderShape.DefaultMinBounds.y;
-  const defaultMaxHeight = VoxelCylinderShape.DefaultMaxBounds.y;
-  const defaultMinAngle = VoxelCylinderShape.DefaultMinBounds.z;
-  const defaultMaxAngle = VoxelCylinderShape.DefaultMaxBounds.z;
+  const defaultMinAngle = VoxelCylinderShape.DefaultMinBounds.y;
+  const defaultMaxAngle = VoxelCylinderShape.DefaultMaxBounds.y;
+  const defaultMinHeight = VoxelCylinderShape.DefaultMinBounds.z;
+  const defaultMaxHeight = VoxelCylinderShape.DefaultMaxBounds.z;
   const defaultAngleRange = defaultMaxAngle - defaultMinAngle;
   const defaultAngleRangeHalf = 0.5 * defaultAngleRange;
 
@@ -208,38 +208,38 @@ VoxelCylinderShape.prototype.update = function (
   const renderMinRadius = Math.max(shapeMinRadius, clipMinRadius);
   const renderMaxRadius = Math.min(shapeMaxRadius, clipMaxRadius);
 
+  // Clamp the angles to the valid range
+  const shapeMinAngle = CesiumMath.negativePiToPi(minBounds.y);
+  const shapeMaxAngle = CesiumMath.negativePiToPi(maxBounds.y);
+  const clipMinAngle = CesiumMath.negativePiToPi(clipMinBounds.y);
+  const clipMaxAngle = CesiumMath.negativePiToPi(clipMaxBounds.y);
+  const renderMinAngle = Math.max(shapeMinAngle, clipMinAngle);
+  const renderMaxAngle = Math.min(shapeMaxAngle, clipMaxAngle);
+
   // Clamp the heights to the valid range
   const shapeMinHeight = CesiumMath.clamp(
-    minBounds.y,
+    minBounds.z,
     defaultMinHeight,
     defaultMaxHeight,
   );
   const shapeMaxHeight = CesiumMath.clamp(
-    maxBounds.y,
+    maxBounds.z,
     defaultMinHeight,
     defaultMaxHeight,
   );
   const clipMinHeight = CesiumMath.clamp(
-    clipMinBounds.y,
+    clipMinBounds.z,
     defaultMinHeight,
     defaultMaxHeight,
   );
   const clipMaxHeight = CesiumMath.clamp(
-    clipMaxBounds.y,
+    clipMaxBounds.z,
     defaultMinHeight,
     defaultMaxHeight,
   );
   const renderMinHeight = Math.max(shapeMinHeight, clipMinHeight);
   const renderMaxHeight = Math.min(shapeMaxHeight, clipMaxHeight);
 
-  // Clamp the angles to the valid range
-  const shapeMinAngle = CesiumMath.negativePiToPi(minBounds.z);
-  const shapeMaxAngle = CesiumMath.negativePiToPi(maxBounds.z);
-  const clipMinAngle = CesiumMath.negativePiToPi(clipMinBounds.z);
-  const clipMaxAngle = CesiumMath.negativePiToPi(clipMaxBounds.z);
-  const renderMinAngle = Math.max(shapeMinAngle, clipMinAngle);
-  const renderMaxAngle = Math.min(shapeMaxAngle, clipMaxAngle);
-
   const scale = Matrix4.getScale(modelMatrix, scratchScale);
 
   // Exit early if the shape is not visible.
@@ -263,20 +263,20 @@ VoxelCylinderShape.prototype.update = function (
 
   this._minimumRadius = shapeMinRadius; // [0,1]
   this._maximumRadius = shapeMaxRadius; // [0,1]
-  this._minimumHeight = shapeMinHeight; // [-1,+1]
-  this._maximumHeight = shapeMaxHeight; // [-1,+1]
   this._minimumAngle = shapeMinAngle; // [-pi,+pi]
   this._maximumAngle = shapeMaxAngle; // [-pi,+pi]
+  this._minimumHeight = shapeMinHeight; // [-1,+1]
+  this._maximumHeight = shapeMaxHeight; // [-1,+1]
 
   this.shapeTransform = Matrix4.clone(modelMatrix, this.shapeTransform);
 
   this.orientedBoundingBox = getCylinderChunkObb(
     renderMinRadius,
     renderMaxRadius,
-    renderMinHeight,
-    renderMaxHeight,
     renderMinAngle,
     renderMaxAngle,
+    renderMinHeight,
+    renderMaxHeight,
     this.shapeTransform,
     this.orientedBoundingBox,
   );
@@ -296,8 +296,6 @@ VoxelCylinderShape.prototype.update = function (
   const shapeIsDefaultMinRadius = shapeMinRadius === defaultMinRadius;
   const shapeIsDefaultRadius =
     shapeIsDefaultMinRadius && shapeIsDefaultMaxRadius;
-  const shapeIsDefaultHeight =
-    shapeMinHeight === defaultMinHeight && shapeMaxHeight === defaultMaxHeight;
   const shapeIsAngleReversed = shapeMaxAngle < shapeMinAngle;
   const shapeAngleRange =
     shapeMaxAngle - shapeMinAngle + shapeIsAngleReversed * defaultAngleRange;
@@ -323,6 +321,8 @@ VoxelCylinderShape.prototype.update = function (
     undefined,
     epsilonAngleDiscontinuity,
   );
+  const shapeIsDefaultHeight =
+    shapeMinHeight === defaultMinHeight && shapeMaxHeight === defaultMaxHeight;
 
   const renderIsDefaultMinRadius = renderMinRadius === defaultMinRadius;
   const renderIsAngleReversed = renderMaxAngle < renderMinAngle;
@@ -529,10 +529,10 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForTile = function (
 
   const minimumRadius = this._minimumRadius;
   const maximumRadius = this._maximumRadius;
-  const minimumHeight = this._minimumHeight;
-  const maximumHeight = this._maximumHeight;
   const minimumAngle = this._minimumAngle;
   const maximumAngle = this._maximumAngle;
+  const minimumHeight = this._minimumHeight;
+  const maximumHeight = this._maximumHeight;
 
   const sizeAtLevel = 1.0 / Math.pow(2.0, tileLevel);
 
@@ -546,34 +546,34 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForTile = function (
     maximumRadius,
     (tileX + 1) * sizeAtLevel,
   );
-  const heightStart = CesiumMath.lerp(
-    minimumHeight,
-    maximumHeight,
-    tileY * sizeAtLevel,
-  );
-  const heightEnd = CesiumMath.lerp(
-    minimumHeight,
-    maximumHeight,
-    (tileY + 1) * sizeAtLevel,
-  );
   const angleStart = CesiumMath.lerp(
     minimumAngle,
     maximumAngle,
-    tileZ * sizeAtLevel,
+    tileY * sizeAtLevel,
   );
   const angleEnd = CesiumMath.lerp(
     minimumAngle,
     maximumAngle,
+    (tileY + 1) * sizeAtLevel,
+  );
+  const heightStart = CesiumMath.lerp(
+    minimumHeight,
+    maximumHeight,
+    tileZ * sizeAtLevel,
+  );
+  const heightEnd = CesiumMath.lerp(
+    minimumHeight,
+    maximumHeight,
     (tileZ + 1) * sizeAtLevel,
   );
 
   return getCylinderChunkObb(
     radiusStart,
     radiusEnd,
-    heightStart,
-    heightEnd,
     angleStart,
     angleEnd,
+    heightStart,
+    heightEnd,
     this.shapeTransform,
     result,
   );
@@ -651,10 +651,10 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForSample = function (
   return getCylinderChunkObb(
     radiusStart,
     radiusEnd,
-    heightStart,
-    heightEnd,
     angleStart,
     angleEnd,
+    heightStart,
+    heightEnd,
     this.shapeTransform,
     result,
   );
@@ -670,7 +670,7 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForSample = function (
  * @private
  */
 VoxelCylinderShape.DefaultMinBounds = Object.freeze(
-  new Cartesian3(0.0, -1.0, -CesiumMath.PI),
+  new Cartesian3(0.0, -CesiumMath.PI, -1.0),
 );
 
 /**
@@ -683,7 +683,7 @@ VoxelCylinderShape.DefaultMinBounds = Object.freeze(
  * @private
  */
 VoxelCylinderShape.DefaultMaxBounds = Object.freeze(
-  new Cartesian3(1.0, +1.0, +CesiumMath.PI),
+  new Cartesian3(1.0, +CesiumMath.PI, +1.0),
 );
 
 const maxTestAngles = 5;
@@ -744,10 +744,10 @@ function computeLooseOrientedBoundingBox(matrix, result) {
  *
  * @param {number} radiusStart The radiusStart.
  * @param {number} radiusEnd The radiusEnd.
- * @param {number} heightStart The heightStart.
- * @param {number} heightEnd The heightEnd.
  * @param {number} angleStart The angleStart.
  * @param {number} angleEnd The angleEnd.
+ * @param {number} heightStart The heightStart.
+ * @param {number} heightEnd The heightEnd.
  * @param {Matrix4} matrix The matrix to transform the points.
  * @param {OrientedBoundingBox} result The object onto which to store the result.
  * @returns {OrientedBoundingBox} The oriented bounding box that contains this subregion.
@@ -757,10 +757,10 @@ function computeLooseOrientedBoundingBox(matrix, result) {
 function getCylinderChunkObb(
   radiusStart,
   radiusEnd,
-  heightStart,
-  heightEnd,
   angleStart,
   angleEnd,
+  heightStart,
+  heightEnd,
   matrix,
   result,
 ) {
@@ -768,10 +768,10 @@ function getCylinderChunkObb(
   const defaultMaxBounds = VoxelCylinderShape.DefaultMaxBounds;
   const defaultMinRadius = defaultMinBounds.x; // 0
   const defaultMaxRadius = defaultMaxBounds.x; // 1
-  const defaultMinHeight = defaultMinBounds.y; // -1
-  const defaultMaxHeight = defaultMaxBounds.y; // +1
-  const defaultMinAngle = defaultMinBounds.z; // -pi
-  const defaultMaxAngle = defaultMaxBounds.z; // +pi
+  const defaultMinAngle = defaultMinBounds.y; // -pi
+  const defaultMaxAngle = defaultMaxBounds.y; // +pi
+  const defaultMinHeight = defaultMinBounds.z; // -1
+  const defaultMaxHeight = defaultMaxBounds.z; // +1
 
   // Return early if using the default bounds
   if (
diff --git a/packages/engine/Source/Scene/VoxelMetadataOrder.js b/packages/engine/Source/Scene/VoxelMetadataOrder.js
new file mode 100644
index 000000000000..7d955a2cc7fd
--- /dev/null
+++ b/packages/engine/Source/Scene/VoxelMetadataOrder.js
@@ -0,0 +1,12 @@
+/**
+ * Metadata ordering for voxel content.
+ * In all cases, x data is contiguous in strides along the y axis,
+ * and each group of y strides represents a z slice.
+ * However, the orientation of the axes follows different conventions.
+ * @enum {number}
+ */
+const VoxelMetadataOrder = {
+  XYZ: 0, // Default ordering following the 3D Tiles convention. Z-axis points upward.
+  GLTF: 1, // Ordering following the glTF convention. Y-axis points upward.
+};
+export default Object.freeze(VoxelMetadataOrder);
diff --git a/packages/engine/Source/Scene/VoxelPrimitive.js b/packages/engine/Source/Scene/VoxelPrimitive.js
index 3445556d9736..ecd910ec150d 100644
--- a/packages/engine/Source/Scene/VoxelPrimitive.js
+++ b/packages/engine/Source/Scene/VoxelPrimitive.js
@@ -2,30 +2,31 @@ import buildVoxelDrawCommands from "./buildVoxelDrawCommands.js";
 import Cartesian2 from "../Core/Cartesian2.js";
 import Cartesian3 from "../Core/Cartesian3.js";
 import Cartesian4 from "../Core/Cartesian4.js";
+import Cartographic from "../Core/Cartographic.js";
+import Cesium3DTilesetStatistics from "./Cesium3DTilesetStatistics.js";
 import CesiumMath from "../Core/Math.js";
 import Check from "../Core/Check.js";
-import clone from "../Core/clone.js";
 import Color from "../Core/Color.js";
+import ClippingPlaneCollection from "./ClippingPlaneCollection.js";
+import clone from "../Core/clone.js";
+import CustomShader from "./Model/CustomShader.js";
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
+import Ellipsoid from "../Core/Ellipsoid.js";
 import Event from "../Core/Event.js";
 import JulianDate from "../Core/JulianDate.js";
+import Material from "./Material.js";
 import Matrix3 from "../Core/Matrix3.js";
 import Matrix4 from "../Core/Matrix4.js";
-import oneTimeWarning from "../Core/oneTimeWarning.js";
-import ClippingPlaneCollection from "./ClippingPlaneCollection.js";
-import Material from "./Material.js";
 import MetadataComponentType from "./MetadataComponentType.js";
 import MetadataType from "./MetadataType.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
 import PolylineCollection from "./PolylineCollection.js";
+import VerticalExaggeration from "../Core/VerticalExaggeration.js";
+import VoxelContent from "./VoxelContent.js";
 import VoxelShapeType from "./VoxelShapeType.js";
 import VoxelTraversal from "./VoxelTraversal.js";
-import CustomShader from "./Model/CustomShader.js";
-import Cartographic from "../Core/Cartographic.js";
-import Ellipsoid from "../Core/Ellipsoid.js";
-import VerticalExaggeration from "../Core/VerticalExaggeration.js";
-import Cesium3DTilesetStatistics from "./Cesium3DTilesetStatistics.js";
 
 /**
  * A primitive that renders voxel data from a {@link VoxelProvider}.
@@ -2079,7 +2080,8 @@ DefaultVoxelProvider.prototype.requestData = function (options) {
     return undefined;
   }
 
-  return Promise.resolve([new Float32Array(1)]);
+  const content = new VoxelContent({ metadata: [new Float32Array(1)] });
+  return Promise.resolve(content);
 };
 
 VoxelPrimitive.DefaultProvider = new DefaultVoxelProvider();
diff --git a/packages/engine/Source/Scene/VoxelProvider.js b/packages/engine/Source/Scene/VoxelProvider.js
index 3b97d390d960..9b11d992e37b 100644
--- a/packages/engine/Source/Scene/VoxelProvider.js
+++ b/packages/engine/Source/Scene/VoxelProvider.js
@@ -19,10 +19,11 @@ function VoxelProvider() {
 
 Object.defineProperties(VoxelProvider.prototype, {
   /**
-   * A transform from local space to global space. If undefined, the identity matrix will be used instead.
+   * A transform from local space to global space.
    *
    * @memberof VoxelProvider.prototype
-   * @type {Matrix4|undefined}
+   * @type {Matrix4}
+   * @default Matrix4.IDENTITY
    * @readonly
    */
   globalTransform: {
@@ -30,10 +31,11 @@ Object.defineProperties(VoxelProvider.prototype, {
   },
 
   /**
-   * A transform from shape space to local space. If undefined, the identity matrix will be used instead.
+   * A transform from shape space to local space.
    *
    * @memberof VoxelProvider.prototype
-   * @type {Matrix4|undefined}
+   * @type {Matrix4}
+   * @default Matrix4.IDENTITY
    * @readonly
    */
   shapeTransform: {
@@ -42,7 +44,6 @@ Object.defineProperties(VoxelProvider.prototype, {
 
   /**
    * Gets the {@link VoxelShapeType}
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
    * @type {VoxelShapeType}
@@ -55,7 +56,6 @@ Object.defineProperties(VoxelProvider.prototype, {
   /**
    * Gets the minimum bounds.
    * If undefined, the shape's default minimum bounds will be used instead.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
    * @type {Cartesian3|undefined}
@@ -68,7 +68,6 @@ Object.defineProperties(VoxelProvider.prototype, {
   /**
    * Gets the maximum bounds.
    * If undefined, the shape's default maximum bounds will be used instead.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
    * @type {Cartesian3|undefined}
@@ -80,7 +79,6 @@ Object.defineProperties(VoxelProvider.prototype, {
 
   /**
    * Gets the number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
    * @type {Cartesian3}
@@ -92,10 +90,10 @@ Object.defineProperties(VoxelProvider.prototype, {
 
   /**
    * Gets the number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
-   * @type {Cartesian3|undefined}
+   * @type {Cartesian3}
+   * @default Cartesian3.ZERO
    * @readonly
    */
   paddingBefore: {
@@ -104,10 +102,10 @@ Object.defineProperties(VoxelProvider.prototype, {
 
   /**
    * Gets the number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
-   * @type {Cartesian3|undefined}
+   * @type {Cartesian3}
+   * @default Cartesian3.ZERO
    * @readonly
    */
   paddingAfter: {
@@ -116,7 +114,6 @@ Object.defineProperties(VoxelProvider.prototype, {
 
   /**
    * Gets the metadata names.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
    * @type {string[]}
@@ -128,7 +125,6 @@ Object.defineProperties(VoxelProvider.prototype, {
 
   /**
    * Gets the metadata types.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
    * @type {MetadataType[]}
@@ -140,7 +136,6 @@ Object.defineProperties(VoxelProvider.prototype, {
 
   /**
    * Gets the metadata component types.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
    * @type {MetadataComponentType[]}
@@ -152,7 +147,6 @@ Object.defineProperties(VoxelProvider.prototype, {
 
   /**
    * Gets the metadata minimum values.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
    * @type {number[][]|undefined}
@@ -164,7 +158,6 @@ Object.defineProperties(VoxelProvider.prototype, {
 
   /**
    * Gets the metadata maximum values.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
    * @type {number[][]|undefined}
@@ -175,8 +168,9 @@ Object.defineProperties(VoxelProvider.prototype, {
   },
 
   /**
-   * The maximum number of tiles that exist for this provider. This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory. If this value is not known it can be undefined.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
+   * The maximum number of tiles that exist for this provider.
+   * This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory.
+   * If this value is not known it can be undefined.
    *
    * @memberof VoxelProvider.prototype
    * @type {number|undefined}
@@ -198,10 +192,9 @@ Object.defineProperties(VoxelProvider.prototype, {
 
   /**
    * Gets the number of keyframes in the dataset.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
    *
    * @memberof VoxelProvider.prototype
-   * @type {number}
+   * @type {number|undefined}
    * @readonly
    * @private
    */
@@ -210,11 +203,11 @@ Object.defineProperties(VoxelProvider.prototype, {
   },
 
   /**
-   * Gets the {@link TimeIntervalCollection} for the dataset, or undefined if it doesn't have timestamps.
-   * This should not be called before {@link VoxelProvider#ready} returns true.
+   * Gets the {@link TimeIntervalCollection} for the dataset,
+   * or undefined if it doesn't have timestamps.
    *
    * @memberof VoxelProvider.prototype
-   * @type {TimeIntervalCollection}
+   * @type {TimeIntervalCollection|undefined}
    * @readonly
    * @private
    */
@@ -224,9 +217,7 @@ Object.defineProperties(VoxelProvider.prototype, {
 });
 
 /**
- * Requests the data for a given tile. The data is a flattened 3D array ordered by X, then Y, then Z.
- * This function should not be called before {@link VoxelProvider#ready} returns true.
- * @function
+ * Requests the data for a given tile.
  *
  * @param {object} [options] Object with the following properties:
  * @param {number} [options.tileLevel=0] The tile's level.
@@ -234,8 +225,10 @@ Object.defineProperties(VoxelProvider.prototype, {
  * @param {number} [options.tileY=0] The tile's Y coordinate.
  * @param {number} [options.tileZ=0] The tile's Z coordinate.
  * @privateparam {number} [options.keyframe=0] The requested keyframe.
- * @returns {Promise<Array[]>|undefined} A promise to an array of typed arrays containing the requested voxel data or undefined if there was a problem loading the data.
+ * @returns {Promise<VoxelContent>|undefined} A promise resolving to a VoxelContent containing the data for the tile, or undefined if the request could not be scheduled this frame.
  */
-VoxelProvider.prototype.requestData = DeveloperError.throwInstantiationError;
+VoxelProvider.prototype.requestData = function (options) {
+  DeveloperError.throwInstantiationError();
+};
 
 export default VoxelProvider;
diff --git a/packages/engine/Source/Scene/VoxelTraversal.js b/packages/engine/Source/Scene/VoxelTraversal.js
index a2735265591a..da4bf655a0b8 100644
--- a/packages/engine/Source/Scene/VoxelTraversal.js
+++ b/packages/engine/Source/Scene/VoxelTraversal.js
@@ -43,7 +43,6 @@ function VoxelTraversal(
   maximumTextureMemoryByteLength,
 ) {
   /**
-   * TODO: maybe this shouldn't be stored or passed into update function?
    * @type {VoxelPrimitive}
    * @private
    */
@@ -113,6 +112,12 @@ function VoxelTraversal(
    */
   this._highPriorityKeyframeNodes = new Array(maximumTileCount);
 
+  /**
+   * @type {number}
+   * @private
+   */
+  this._highPriorityKeyframeNodeCount = 0;
+
   /**
    * @type {KeyframeNode[]}
    * @private
@@ -318,7 +323,8 @@ VoxelTraversal.prototype.update = function (
 
   this._frameNumber = frameState.frameNumber;
   const timestamp0 = getTimestamp();
-  loadAndUnload(this, frameState);
+  selectKeyframeNodes(this, frameState);
+  updateKeyframeNodes(this, frameState);
   const timestamp1 = getTimestamp();
   generateOctree(this, sampleCount, levelBlendFactor);
   const timestamp2 = getTimestamp();
@@ -427,7 +433,8 @@ function requestData(that, keyframeNode) {
     return;
   }
 
-  const provider = that._primitive._provider;
+  const primitive = that._primitive;
+  const provider = primitive.provider;
   const { keyframe, spatialNode } = keyframeNode;
   if (
     defined(provider.availableLevels) &&
@@ -436,66 +443,34 @@ function requestData(that, keyframeNode) {
     return;
   }
 
-  const requestOptions = {
-    tileLevel: spatialNode.level,
-    tileX: spatialNode.x,
-    tileY: spatialNode.y,
-    tileZ: spatialNode.z,
-    keyframe: keyframe,
-  };
-
   function postRequestSuccess(result) {
     that._simultaneousRequestCount--;
-    const length = provider.types.length;
-
-    if (!defined(result)) {
-      keyframeNode.state = KeyframeNode.LoadState.UNAVAILABLE;
-    } else if (result === KeyframeNode.LoadState.FAILED) {
-      keyframeNode.state = KeyframeNode.LoadState.FAILED;
-    } else if (!Array.isArray(result) || result.length !== length) {
-      // TODO should this throw runtime error?
-      keyframeNode.state = KeyframeNode.LoadState.FAILED;
-    } else {
-      const megatextures = that.megatextures;
-      for (let i = 0; i < length; i++) {
-        const { voxelCountPerTile, channelCount } = megatextures[i];
-        const { x, y, z } = voxelCountPerTile;
-        const tileVoxelCount = x * y * z;
-
-        const data = result[i];
-        const expectedLength = tileVoxelCount * channelCount;
-        if (data.length === expectedLength) {
-          keyframeNode.metadata[i] = data;
-          // State is received only when all metadata requests have been received
-          keyframeNode.state = KeyframeNode.LoadState.RECEIVED;
-          that._primitive.tileLoad.raiseEvent();
-        } else {
-          keyframeNode.state = KeyframeNode.LoadState.FAILED;
-          break;
-        }
-      }
-    }
-    if (keyframeNode.state === KeyframeNode.LoadState.FAILED) {
-      that._primitive.tileFailed.raiseEvent();
-    }
+    keyframeNode.content = result;
+    keyframeNode.state = defined(result)
+      ? KeyframeNode.LoadState.PROCESSING
+      : KeyframeNode.LoadState.UNAVAILABLE;
   }
 
-  function postRequestFailure() {
+  function postRequestFailure(error) {
     that._simultaneousRequestCount--;
     keyframeNode.state = KeyframeNode.LoadState.FAILED;
     that._primitive.tileFailed.raiseEvent();
   }
 
-  const promise = provider.requestData(requestOptions);
-
-  if (defined(promise)) {
-    that._simultaneousRequestCount++;
-    keyframeNode.state = KeyframeNode.LoadState.RECEIVING;
-    promise.then(postRequestSuccess).catch(postRequestFailure);
-  } else {
-    keyframeNode.state = KeyframeNode.LoadState.FAILED;
-    that._primitive.tileFailed.raiseEvent();
+  const requestParameters = {
+    tileLevel: spatialNode.level,
+    tileX: spatialNode.x,
+    tileY: spatialNode.y,
+    tileZ: spatialNode.z,
+    keyframe: keyframe,
+  };
+  const promise = provider.requestData(requestParameters);
+  if (!defined(promise)) {
+    return;
   }
+  that._simultaneousRequestCount++;
+  keyframeNode.state = KeyframeNode.LoadState.RECEIVING;
+  promise.then(postRequestSuccess).catch(postRequestFailure);
 }
 
 /**
@@ -511,105 +486,23 @@ function mapInfiniteRangeToZeroOne(x) {
 }
 
 /**
- * @function
- *
  * @param {VoxelTraversal} that
  * @param {FrameState} frameState
  *
  * @private
  */
-function loadAndUnload(that, frameState) {
+function selectKeyframeNodes(that, frameState) {
   const frameNumber = that._frameNumber;
-  const primitive = that._primitive;
-  const shape = primitive._shape;
-  const targetScreenSpaceError = primitive.screenSpaceError;
   const priorityQueue = that._priorityQueue;
-  const keyframeCount = that._keyframeCount;
-
-  const previousKeyframe = CesiumMath.clamp(
-    Math.floor(that._keyframeLocation),
-    0,
-    keyframeCount - 2,
-  );
-  const nextKeyframe = previousKeyframe + 1;
-
-  const { camera, context, pixelRatio } = frameState;
-  const { positionWC, frustum } = camera;
-  const screenHeight = context.drawingBufferHeight / pixelRatio;
-  const screenSpaceErrorMultiplier = screenHeight / frustum.sseDenominator;
-
-  /**
-   * @ignore
-   * @param {SpatialNode} spatialNode
-   * @param {number} visibilityPlaneMask
-   */
-  function addToQueueRecursive(spatialNode, visibilityPlaneMask) {
-    spatialNode.computeScreenSpaceError(positionWC, screenSpaceErrorMultiplier);
-
-    visibilityPlaneMask = spatialNode.visibility(
-      frameState,
-      visibilityPlaneMask,
-    );
-    if (visibilityPlaneMask === CullingVolume.MASK_OUTSIDE) {
-      return;
-    }
-    spatialNode.visitedFrameNumber = frameNumber;
-
-    // Create keyframe nodes at the playhead.
-    // If they already exist, nothing will be created.
-    if (keyframeCount === 1) {
-      spatialNode.createKeyframeNode(0);
-    } else if (spatialNode.keyframeNodes.length !== keyframeCount) {
-      for (let k = 0; k < keyframeCount; k++) {
-        spatialNode.createKeyframeNode(k);
-      }
-    }
-    const { screenSpaceError, keyframeNodes } = spatialNode;
-    const ssePriority = mapInfiniteRangeToZeroOne(screenSpaceError);
-
-    let hasLoadedKeyframe = false;
-    for (let i = 0; i < keyframeNodes.length; i++) {
-      const keyframeNode = keyframeNodes[i];
-
-      keyframeNode.priority =
-        10.0 * ssePriority +
-        keyframePriority(
-          previousKeyframe,
-          keyframeNode.keyframe,
-          nextKeyframe,
-          that,
-        );
-
-      if (
-        keyframeNode.state !== KeyframeNode.LoadState.UNAVAILABLE &&
-        keyframeNode.state !== KeyframeNode.LoadState.FAILED &&
-        keyframeNode.priority !== -Number.MAX_VALUE
-      ) {
-        priorityQueue.insert(keyframeNode);
-      }
-      if (keyframeNode.state === KeyframeNode.LoadState.LOADED) {
-        hasLoadedKeyframe = true;
-      }
-    }
-
-    if (screenSpaceError < targetScreenSpaceError || !hasLoadedKeyframe) {
-      // Free up memory
-      spatialNode.children = undefined;
-      return;
-    }
-
-    if (!defined(spatialNode.children)) {
-      spatialNode.constructChildNodes(shape);
-    }
-    for (let childIndex = 0; childIndex < 8; childIndex++) {
-      const child = spatialNode.children[childIndex];
-      addToQueueRecursive(child, visibilityPlaneMask);
-    }
-  }
 
   // Add all the nodes to the queue, to sort them by priority.
   priorityQueue.reset();
-  addToQueueRecursive(that.rootNode, CullingVolume.MASK_INDETERMINATE);
+  addToQueueRecursive(
+    that.rootNode,
+    CullingVolume.MASK_INDETERMINATE,
+    that,
+    frameState,
+  );
 
   // Move the nodes from the queue to array of high priority nodes.
   const highPriorityKeyframeNodes = that._highPriorityKeyframeNodes;
@@ -622,23 +515,29 @@ function loadAndUnload(that, frameState) {
       highPriorityKeyframeNode;
     highPriorityKeyframeNodeCount++;
   }
+  that._highPriorityKeyframeNodeCount = highPriorityKeyframeNodeCount;
+}
+
+/**
+ * @param {VoxelTraversal} that
+ * @param {FrameState} frameState
+ *
+ * @private
+ */
+function updateKeyframeNodes(that, frameState) {
+  const megatexture = that.megatextures[0];
+  const keyframeNodesInMegatextureCount = megatexture.occupiedCount;
 
   // Sort the list of keyframe nodes in the megatexture by priority, so
   // we can remove the lowest priority nodes if we need space.
   const keyframeNodesInMegatexture = that._keyframeNodesInMegatexture;
-  // TODO: some of the megatexture state should be stored once, not duplicate for each megatexture
-  const megatexture = that.megatextures[0];
-  const keyframeNodesInMegatextureCount = megatexture.occupiedCount;
   keyframeNodesInMegatexture.length = keyframeNodesInMegatextureCount;
-  keyframeNodesInMegatexture.sort(function (a, b) {
-    if (a.highPriorityFrameNumber === b.highPriorityFrameNumber) {
-      return b.priority - a.priority;
-    }
-    return b.highPriorityFrameNumber - a.highPriorityFrameNumber;
-  });
+  keyframeNodesInMegatexture.sort(keyframeNodeSort);
 
   // Add the high priority nodes to the megatexture,
   // removing existing lower-priority nodes if necessary.
+  const highPriorityKeyframeNodes = that._highPriorityKeyframeNodes;
+  const highPriorityKeyframeNodeCount = that._highPriorityKeyframeNodeCount;
   let destroyedCount = 0;
   let addedCount = 0;
 
@@ -647,7 +546,7 @@ function loadAndUnload(that, frameState) {
     highPriorityKeyframeNodeIndex < highPriorityKeyframeNodeCount;
     highPriorityKeyframeNodeIndex++
   ) {
-    highPriorityKeyframeNode =
+    const highPriorityKeyframeNode =
       highPriorityKeyframeNodes[highPriorityKeyframeNodeIndex];
 
     if (
@@ -661,7 +560,18 @@ function loadAndUnload(that, frameState) {
     if (highPriorityKeyframeNode.state === KeyframeNode.LoadState.UNLOADED) {
       requestData(that, highPriorityKeyframeNode);
     }
-    if (highPriorityKeyframeNode.state === KeyframeNode.LoadState.RECEIVED) {
+    if (highPriorityKeyframeNode.state === KeyframeNode.LoadState.PROCESSING) {
+      const { content } = highPriorityKeyframeNode;
+      content.update(that._primitive, frameState);
+      if (!content.ready) {
+        continue;
+      }
+      if (!validateMetadata(content.metadata, that)) {
+        highPriorityKeyframeNode.content = undefined;
+        highPriorityKeyframeNode.state = KeyframeNode.LoadState.FAILED;
+        that._primitive.tileFailed.raiseEvent();
+        continue;
+      }
       let addNodeIndex = 0;
       if (megatexture.isFull()) {
         // If the megatexture is full, try removing a discardable node with the lowest priority.
@@ -682,9 +592,138 @@ function loadAndUnload(that, frameState) {
         highPriorityKeyframeNode,
         that.megatextures,
       );
+      highPriorityKeyframeNode.state = KeyframeNode.LoadState.LOADED;
       keyframeNodesInMegatexture[addNodeIndex] = highPriorityKeyframeNode;
+      that._primitive.tileLoad.raiseEvent();
+    }
+  }
+}
+
+function keyframeNodeSort(a, b) {
+  if (a.highPriorityFrameNumber === b.highPriorityFrameNumber) {
+    return b.priority - a.priority;
+  }
+  return b.highPriorityFrameNumber - a.highPriorityFrameNumber;
+}
+
+/**
+ * Check if an array of metadata is of the expected type and size
+ *
+ * @param {TypedArray[]} metadata The metadata to validate
+ * @param {VoxelTraversal} traversal The traversal to validate against
+ * @returns {boolean} <code>true</code> if the metadata is valid, <code>false</code> otherwise
+ *
+ * @private
+ */
+function validateMetadata(metadata, traversal) {
+  const length = traversal._primitive.provider.types.length;
+  if (!Array.isArray(metadata) || metadata.length !== length) {
+    return false;
+  }
+  const { megatextures } = traversal;
+  for (let i = 0; i < length; i++) {
+    const { voxelCountPerTile, channelCount } = megatextures[i];
+    const { x, y, z } = voxelCountPerTile;
+    const tileVoxelCount = x * y * z;
+
+    const data = metadata[i];
+    const expectedLength = tileVoxelCount * channelCount;
+    if (data.length !== expectedLength) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * @param {SpatialNode} spatialNode
+ * @param {number} visibilityPlaneMask
+ * @param {VoxelTraversal} that
+ * @param {FrameState} frameState
+ *
+ * @private
+ */
+function addToQueueRecursive(
+  spatialNode,
+  visibilityPlaneMask,
+  that,
+  frameState,
+) {
+  const { camera, context, pixelRatio, frameNumber } = frameState;
+  const { positionWC, frustum } = camera;
+  const screenHeight = context.drawingBufferHeight / pixelRatio;
+  const screenSpaceErrorMultiplier = screenHeight / frustum.sseDenominator;
+
+  spatialNode.computeScreenSpaceError(positionWC, screenSpaceErrorMultiplier);
+
+  visibilityPlaneMask = spatialNode.visibility(frameState, visibilityPlaneMask);
+  if (visibilityPlaneMask === CullingVolume.MASK_OUTSIDE) {
+    return;
+  }
+  spatialNode.visitedFrameNumber = frameNumber;
+
+  const primitive = that._primitive;
+  const shape = primitive._shape;
+  const targetScreenSpaceError = primitive.screenSpaceError;
+  const priorityQueue = that._priorityQueue;
+  const keyframeCount = that._keyframeCount;
+  const previousKeyframe = CesiumMath.clamp(
+    Math.floor(that._keyframeLocation),
+    0,
+    keyframeCount - 2,
+  );
+  const nextKeyframe = previousKeyframe + 1;
+
+  // Create keyframe nodes at the playhead.
+  // If they already exist, nothing will be created.
+  if (keyframeCount === 1) {
+    spatialNode.createKeyframeNode(0);
+  } else if (spatialNode.keyframeNodes.length !== keyframeCount) {
+    for (let k = 0; k < keyframeCount; k++) {
+      spatialNode.createKeyframeNode(k);
+    }
+  }
+  const { screenSpaceError, keyframeNodes } = spatialNode;
+  const ssePriority = mapInfiniteRangeToZeroOne(screenSpaceError);
+
+  let hasLoadedKeyframe = false;
+  for (let i = 0; i < keyframeNodes.length; i++) {
+    const keyframeNode = keyframeNodes[i];
+
+    keyframeNode.priority =
+      10.0 * ssePriority +
+      keyframePriority(
+        previousKeyframe,
+        keyframeNode.keyframe,
+        nextKeyframe,
+        that,
+      );
+
+    if (
+      keyframeNode.state !== KeyframeNode.LoadState.UNAVAILABLE &&
+      keyframeNode.state !== KeyframeNode.LoadState.FAILED &&
+      keyframeNode.priority !== -Number.MAX_VALUE
+    ) {
+      priorityQueue.insert(keyframeNode);
+    }
+    if (keyframeNode.state === KeyframeNode.LoadState.LOADED) {
+      hasLoadedKeyframe = true;
     }
   }
+
+  if (screenSpaceError < targetScreenSpaceError || !hasLoadedKeyframe) {
+    // Free up memory
+    spatialNode.children = undefined;
+    return;
+  }
+
+  if (!defined(spatialNode.children)) {
+    spatialNode.constructChildNodes(shape);
+  }
+  for (let childIndex = 0; childIndex < 8; childIndex++) {
+    const child = spatialNode.children[childIndex];
+    addToQueueRecursive(child, visibilityPlaneMask, that, frameState);
+  }
 }
 
 /**
@@ -748,16 +787,12 @@ function postPassesUpdate(
     loadStateIndex < loadStateCount;
     loadStateIndex++
   ) {
-    const keyframeArray = new Array(keyframeCount);
+    const keyframeArray = new Array(keyframeCount).fill(0);
     loadStatesByKeyframe[loadStateIndex] = keyframeArray;
-    for (let i = 0; i < keyframeCount; i++) {
-      keyframeArray[i] = 0;
-    }
     loadStateByCount[loadStateIndex] = 0;
   }
 
   /**
-   * @ignore
    * @param {SpatialNode} node
    */
   function traverseRecursive(node) {
@@ -787,7 +822,7 @@ function postPassesUpdate(
   const numberOfPendingRequests =
     loadStateByCount[KeyframeNode.LoadState.RECEIVING];
   const numberOfTilesProcessing =
-    loadStateByCount[KeyframeNode.LoadState.RECEIVED];
+    loadStateByCount[KeyframeNode.LoadState.PROCESSING];
 
   const progressChanged =
     numberOfPendingRequests !==
@@ -839,7 +874,7 @@ function postPassesUpdate(
   const loadStateStatistics =
     `UNLOADED: ${loadStateByCount[KeyframeNode.LoadState.UNLOADED]} | ` +
     `RECEIVING: ${loadStateByCount[KeyframeNode.LoadState.RECEIVING]} | ` +
-    `RECEIVED: ${loadStateByCount[KeyframeNode.LoadState.RECEIVED]} | ` +
+    `PROCESSING: ${loadStateByCount[KeyframeNode.LoadState.PROCESSING]} | ` +
     `LOADED: ${loadStateByCount[KeyframeNode.LoadState.LOADED]} | ` +
     `FAILED: ${loadStateByCount[KeyframeNode.LoadState.FAILED]} | ` +
     `UNAVAILABLE: ${loadStateByCount[KeyframeNode.LoadState.UNAVAILABLE]} | ` +
@@ -900,7 +935,6 @@ const GpuOctreeFlag = {
  * @function
  *
  * @param {VoxelTraversal} that
- * @param {FrameState} frameState
  * @param {number} sampleCount
  * @param {number} levelBlendFactor
  * @private
@@ -917,7 +951,6 @@ function generateOctree(that, sampleCount, levelBlendFactor) {
   const leafNodeOctreeData = [];
 
   /**
-   * @ignore
    * @param {SpatialNode} node
    * @param {number} childOctreeIndex
    * @param {number} childEntryIndex
diff --git a/packages/engine/Source/Scene/processVoxelProperties.js b/packages/engine/Source/Scene/processVoxelProperties.js
index cc90a6db5ead..d820a9ccf444 100644
--- a/packages/engine/Source/Scene/processVoxelProperties.js
+++ b/packages/engine/Source/Scene/processVoxelProperties.js
@@ -310,6 +310,9 @@ function processVoxelProperties(renderResources, primitive) {
         const glslField = getGlslField(type, j);
         const minimumValue = minimumValues[i][j];
         const maximumValue = maximumValues[i][j];
+        if (!defined(minimumValue) || !defined(maximumValue)) {
+          continue;
+        }
         shaderBuilder.addFunctionLines(functionId, [
           `${statisticsFieldName}.${name}.min${glslField} = ${getGlslNumberAsFloat(
             minimumValue,
diff --git a/packages/engine/Source/Shaders/Voxels/convertUvToCylinder.glsl b/packages/engine/Source/Shaders/Voxels/convertUvToCylinder.glsl
index 4acf081b1119..32bae86e7699 100644
--- a/packages/engine/Source/Shaders/Voxels/convertUvToCylinder.glsl
+++ b/packages/engine/Source/Shaders/Voxels/convertUvToCylinder.glsl
@@ -37,7 +37,7 @@ PointJacobianT convertUvToShapeSpaceDerivative(in vec3 positionUv) {
     float angle = atan(position.y, position.x);
     vec3 east = normalize(vec3(-position.y, position.x, 0.0));
 
-    vec3 point = vec3(radius, height, angle);
+    vec3 point = vec3(radius, angle, height);
     mat3 jacobianT = mat3(radial, z, east / length(position.xy));
     return PointJacobianT(point, jacobianT);
 }
@@ -48,12 +48,7 @@ vec3 convertShapeToShapeUvSpace(in vec3 positionShape) {
         radius = radius * u_cylinderUvToShapeUvRadius.x + u_cylinderUvToShapeUvRadius.y;
     #endif
 
-    float height = positionShape.y;
-    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
-        height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y;
-    #endif
-
-    float angle = (positionShape.z + czm_pi) / czm_twoPi;
+    float angle = (positionShape.y + czm_pi) / czm_twoPi;
     #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)
         #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED)
             // Comparing against u_cylinderShapeUvAngleMinMax has precision problems. u_cylinderShapeUvAngleRangeZeroMid is more conservative.
@@ -70,7 +65,12 @@ vec3 convertShapeToShapeUvSpace(in vec3 positionShape) {
         angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y;
     #endif
 
-    return vec3(radius, height, angle);
+    float height = positionShape.z;
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
+        height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y;
+    #endif
+
+    return vec3(radius, angle, height);
 }
 
 PointJacobianT convertUvToShapeUvSpaceDerivative(in vec3 positionUv) {
@@ -85,15 +85,15 @@ vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {
         radius /= u_cylinderUvToShapeUvRadius.x;
     #endif
 
-    float height = shapeUv.y;
-    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
-        height /= u_cylinderUvToShapeUvHeight.x;
-    #endif
-
-    float angle = shapeUv.z * czm_twoPi;
+    float angle = shapeUv.y * czm_twoPi;
     #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)
         angle /= u_cylinderUvToShapeUvAngle.x;
     #endif
 
-    return vec3(radius, height, angle);
+    float height = shapeUv.z;
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
+        height /= u_cylinderUvToShapeUvHeight.x;
+    #endif
+
+    return vec3(radius, angle, height);
 }
diff --git a/packages/engine/Specs/Scene/Cesium3DTilesVoxelProviderSpec.js b/packages/engine/Specs/Scene/Cesium3DTilesVoxelProviderSpec.js
index 49f5ff44fdbc..efc579e0d9cd 100644
--- a/packages/engine/Specs/Scene/Cesium3DTilesVoxelProviderSpec.js
+++ b/packages/engine/Specs/Scene/Cesium3DTilesVoxelProviderSpec.js
@@ -10,9 +10,18 @@ import {
   VoxelProvider,
   VoxelShapeType,
 } from "../../index.js";
+import createScene from "../../../../Specs/createScene.js";
+import pollToPromise from "../../../../Specs/pollToPromise.js";
 
 describe("Scene/Cesium3DTilesVoxelProvider", function () {
+  let scene;
+
+  beforeEach(async function () {
+    scene = createScene();
+  });
+
   afterEach(function () {
+    scene.destroyForSpecs();
     ResourceCache.clearForSpecs();
   });
 
@@ -32,10 +41,10 @@ describe("Scene/Cesium3DTilesVoxelProvider", function () {
     );
     expect(provider.shape).toEqual(VoxelShapeType.ELLIPSOID);
     expect(provider.minBounds).toEqual(new Cartesian3(0.0, 0.0, -1.0));
-    expect(provider.maxBounds).toEqual(new Cartesian3(1.0, 1.0, 0.0));
+    expect(provider.maxBounds).toEqual(new Cartesian3(1.0, 1.0, 500000.0));
     expect(provider.dimensions).toEqual(new Cartesian3(2, 2, 2));
-    expect(provider.paddingBefore).toBeUndefined();
-    expect(provider.paddingAfter).toBeUndefined();
+    expect(provider.paddingBefore).toEqual(Cartesian3.ZERO);
+    expect(provider.paddingAfter).toEqual(Cartesian3.ZERO);
     expect(provider.names).toEqual(["a"]);
     expect(provider.types).toEqual([MetadataType.SCALAR]);
     expect(provider.componentTypes).toEqual([MetadataComponentType.FLOAT32]);
@@ -43,29 +52,101 @@ describe("Scene/Cesium3DTilesVoxelProvider", function () {
     expect(provider.maximumValues).toEqual([[1]]);
   });
 
-  it("requestData works for root tile", async function () {
+  it("requestData works for root tile of ellipsoid tileset", async function () {
     const url = "./Data/Cesium3DTiles/Voxel/VoxelEllipsoid3DTiles/tileset.json";
     const provider = await Cesium3DTilesVoxelProvider.fromUrl(url);
+    const primitive = { provider };
+
+    const content = await provider.requestData({
+      frameState: scene.frameState,
+    });
 
-    const data = await provider.requestData();
-    expect(data.length).toEqual(1);
+    await pollToPromise(function () {
+      scene.renderForSpecs();
+      content.update(primitive, scene.frameState);
+      return content.ready;
+    });
 
-    const dimensions = provider.dimensions;
-    const voxelCount = dimensions.x * dimensions.y * dimensions.z;
+    const { metadata } = content;
+    expect(metadata.length).toEqual(1);
+
+    const { x, y, z } = provider.dimensions;
+    const voxelCount = x * y * z;
     const componentCount = MetadataType.getComponentCount(provider.types[0]);
     const expectedLength = voxelCount * componentCount;
-    expect(data[0].length).toEqual(expectedLength);
+    expect(metadata[0].length).toEqual(expectedLength);
+  });
+
+  it("requestData works for root tile of box tileset", async function () {
+    const url = "./Data/Cesium3DTiles/Voxel/VoxelBox3DTiles/tileset.json";
+    const provider = await Cesium3DTilesVoxelProvider.fromUrl(url);
+    const primitive = { provider };
+
+    const content = await provider.requestData({
+      frameState: scene.frameState,
+    });
+
+    await pollToPromise(function () {
+      scene.renderForSpecs();
+      content.update(primitive, scene.frameState);
+      return content.ready;
+    });
+
+    const { metadata } = content;
+    expect(metadata.length).toEqual(1);
+
+    const { x, y, z } = provider.dimensions;
+    const voxelCount = x * y * z;
+    const componentCount = MetadataType.getComponentCount(provider.types[0]);
+    const expectedLength = voxelCount * componentCount;
+    expect(metadata[0].length).toEqual(expectedLength);
+  });
+
+  it("requestData works for root tile of cylinder tileset", async function () {
+    const url = "./Data/Cesium3DTiles/Voxel/VoxelCylinder3DTiles/tileset.json";
+    const provider = await Cesium3DTilesVoxelProvider.fromUrl(url);
+    const primitive = { provider };
+
+    const content = await provider.requestData({
+      frameState: scene.frameState,
+    });
+
+    await pollToPromise(function () {
+      scene.renderForSpecs();
+      content.update(primitive, scene.frameState);
+      return content.ready;
+    });
+
+    const { metadata } = content;
+    expect(metadata.length).toEqual(1);
+
+    const { x, y, z } = provider.dimensions;
+    const voxelCount = x * y * z;
+    const componentCount = MetadataType.getComponentCount(provider.types[0]);
+    const expectedLength = voxelCount * componentCount;
+    expect(metadata[0].length).toEqual(expectedLength);
   });
 
   it("requestData loads multiple attributes correctly", async function () {
     const url =
       "./Data/Cesium3DTiles/Voxel/VoxelMultiAttribute3DTiles/tileset.json";
     const provider = await Cesium3DTilesVoxelProvider.fromUrl(url);
+    const primitive = { provider };
+
+    const content = await provider.requestData({
+      frameState: scene.frameState,
+    });
+
+    await pollToPromise(function () {
+      scene.renderForSpecs();
+      content.update(primitive, scene.frameState);
+      return content.ready;
+    });
 
-    const data = await provider.requestData();
-    expect(data.length).toBe(3);
-    expect(data[0][0]).toBe(0.0);
-    expect(data[1][0]).toBe(0.5);
-    expect(data[2][0]).toBe(1.0);
+    const { metadata } = content;
+    expect(metadata.length).toBe(3);
+    expect(metadata[0][0]).toBe(0.0);
+    expect(metadata[1][0]).toBe(0.5);
+    expect(metadata[2][0]).toBe(1.0);
   });
 });
diff --git a/packages/engine/Specs/Scene/KeyframeNodeSpec.js b/packages/engine/Specs/Scene/KeyframeNodeSpec.js
index ef8c86607285..dc06f386bd1b 100644
--- a/packages/engine/Specs/Scene/KeyframeNodeSpec.js
+++ b/packages/engine/Specs/Scene/KeyframeNodeSpec.js
@@ -10,7 +10,7 @@ describe("Scene/KeyframeNode", function () {
     expect(keyframeNode.spatialNode).toBe(dummySpatialNode);
     expect(keyframeNode.keyframe).toBe(keyframe);
     expect(keyframeNode.state).toBe(KeyframeNode.LoadState.UNLOADED);
-    expect(keyframeNode.metadata).toEqual([]);
+    expect(keyframeNode.content).toEqual(undefined);
     expect(keyframeNode.megatextureIndex).toBe(-1);
     expect(keyframeNode.priority).toBe(-Number.MAX_VALUE);
     expect(keyframeNode.highPriorityFrameNumber).toBe(-1);
diff --git a/packages/engine/Specs/Scene/VoxelCylinderShapeSpec.js b/packages/engine/Specs/Scene/VoxelCylinderShapeSpec.js
index 224fbc926397..0e980ad9a2b8 100644
--- a/packages/engine/Specs/Scene/VoxelCylinderShapeSpec.js
+++ b/packages/engine/Specs/Scene/VoxelCylinderShapeSpec.js
@@ -85,12 +85,12 @@ describe("Scene/VoxelCylinderShape", function () {
     // Half revolution
     const minRadius = 0.25;
     const maxRadius = 0.75;
-    const minHeight = -0.5;
-    const maxHeight = +0.5;
     const minAngle = -CesiumMath.PI;
     const maxAngle = 0.0;
-    const minBounds = new Cartesian3(minRadius, minHeight, minAngle);
-    const maxBounds = new Cartesian3(maxRadius, maxHeight, maxAngle);
+    const minHeight = -0.5;
+    const maxHeight = +0.5;
+    const minBounds = new Cartesian3(minRadius, minAngle, minHeight);
+    const maxBounds = new Cartesian3(maxRadius, maxAngle, maxHeight);
     const visible = shape.update(modelMatrix, minBounds, maxBounds);
 
     const expectedMinX = translation.x - maxRadius * scale.x;
@@ -172,13 +172,13 @@ describe("Scene/VoxelCylinderShape", function () {
     const defaultMaxBounds = VoxelCylinderShape.DefaultMaxBounds;
     const minBounds = new Cartesian3(
       defaultMinBounds.x,
-      defaultMinBounds.y,
       minAngle,
+      defaultMinBounds.z,
     );
     const maxBounds = new Cartesian3(
       defaultMaxBounds.x,
-      defaultMaxBounds.y,
       maxAngle,
+      defaultMaxBounds.z,
     );
     const visible = shape.update(modelMatrix, minBounds, maxBounds);
 
@@ -241,12 +241,12 @@ describe("Scene/VoxelCylinderShape", function () {
     // Half revolution
     const minRadius = 0.25;
     const maxRadius = 0.75;
-    const minHeight = -0.5;
-    const maxHeight = +0.5;
     const minAngle = -CesiumMath.PI;
     const maxAngle = 0.0;
-    const minBounds = new Cartesian3(minRadius, minHeight, minAngle);
-    const maxBounds = new Cartesian3(maxRadius, maxHeight, maxAngle);
+    const minHeight = -0.5;
+    const maxHeight = +0.5;
+    const minBounds = new Cartesian3(minRadius, minAngle, minHeight);
+    const maxBounds = new Cartesian3(maxRadius, maxAngle, maxHeight);
     shape.update(modelMatrix, minBounds, maxBounds);
     result = shape.computeOrientedBoundingBoxForTile(0, 0, 0, 0, result);
     expect(result.center.x).toEqual(1.0);
diff --git a/packages/engine/Specs/Scene/VoxelTraversalSpec.js b/packages/engine/Specs/Scene/VoxelTraversalSpec.js
index 233b5981ec20..526d4707baef 100644
--- a/packages/engine/Specs/Scene/VoxelTraversalSpec.js
+++ b/packages/engine/Specs/Scene/VoxelTraversalSpec.js
@@ -210,63 +210,7 @@ describe(
       expect(keyframeNode).toBeDefined();
       expect(keyframeNode.state).toBe(KeyframeNode.LoadState.LOADED);
       const expectedMetadata = new Float32Array([0, 0, 0, 0, 1, 1, 1, 1]);
-      expect(keyframeNode.metadata[0]).toEqual(expectedMetadata);
-    });
-
-    xit("unloads tiles in megatexture", function () {
-      const keyFrameLocation = 0;
-      const recomputeBoundingVolumes = true;
-      const pauseUpdate = false;
-      function updateTraversalTenTimes() {
-        // to fully fetch data and copy to texture
-        function updateTraversal() {
-          traversal.update(
-            scene.frameState,
-            keyFrameLocation,
-            recomputeBoundingVolumes,
-            pauseUpdate,
-          );
-        }
-        for (let i = 0; i < 15; i++) {
-          updateTraversal();
-        }
-      }
-
-      const eps = CesiumMath.EPSILON7;
-      const bottomLeftNearCorner = Cartesian3.fromElements(
-        -0.5 - eps,
-        -0.5 - eps,
-        -0.5 - eps,
-      );
-      const topRightFarCorner = Cartesian3.fromElements(
-        0.5 + eps,
-        0.5 + eps,
-        0.5 + eps,
-      );
-      scene.camera.position = bottomLeftNearCorner;
-      updateTraversalTenTimes();
-      const numberOfNodesOnGPU = traversal._keyframeNodesInMegatexture.length;
-      const deepestNode =
-        traversal._keyframeNodesInMegatexture[numberOfNodesOnGPU - 1];
-      const deepestSpatialNode = deepestNode.spatialNode;
-      const nodeIsInMegatexture =
-        deepestNode.state === VoxelTraversal.LoadState.LOADED;
-      expect(nodeIsInMegatexture).toBe(true);
-
-      scene.camera.position = topRightFarCorner;
-      turnCameraAround(scene);
-      updateTraversalTenTimes();
-      const nodeNoLongerInMegatexture =
-        traversal._keyframeNodesInMegatexture.filter(function (keyFrameNode) {
-          const spatialNode = keyFrameNode.spatialNode;
-          return (
-            spatialNode.level === deepestSpatialNode.level &&
-            spatialNode.x === deepestSpatialNode.x &&
-            spatialNode.y === deepestSpatialNode.y &&
-            spatialNode.x === deepestSpatialNode.z
-          );
-        }).length === 0;
-      expect(nodeNoLongerInMegatexture).toBe(true);
+      expect(keyframeNode.content.metadata[0]).toEqual(expectedMetadata);
     });
   },
   "WebGL",