@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import importlib.util
 import itertools
 import logging
 import math
@@ -46,8 +47,9 @@
 )
 from vesuvius.ink_detection.models.model import make_model
 from vesuvius.ink_detection.volume_io import (
+    open_vc_reader,
     open_volume,
-    read_bbox_with_padding,
+    read_bboxes_with_padding,
 )
 from vesuvius.label_zarr import create_v2_array, open_v2_group
 from vesuvius.utils.cli import HyphenUnderscoreParser
@@ -149,13 +151,30 @@ def parse_args(argv: Sequence[str] | None = None):
     parser.add_argument("--max-target-chunks", type=int, default=None)
     parser.add_argument("--cache-dir", type=Path, default=None)
     parser.add_argument("--cache-max-gb", type=float, default=None)
+    parser.add_argument("--reader", choices=("zarr", "vc_reader"), default="zarr")
+    parser.add_argument("--reader-connections", type=int, default=32)
+    parser.add_argument(
+        "--reader-memory-cache-mb",
+        type=int,
+        default=512,
+        help="vc_reader memory cache per DataLoader worker",
+    )
     parser.add_argument("--log-level", default="INFO")
     args = parser.parse_args(argv)
     checks = (
         (args.batch_size > 0, "--batch-size must be positive"),
         (args.num_workers >= 0, "--num-workers must be >= 0"),
         (args.prefetch_factor > 0, "--prefetch-factor must be positive"),
         (args.downsample_workers > 0, "--downsample-workers must be positive"),
+        (args.reader_connections > 0, "--reader-connections must be positive"),
+        (
+            args.reader_memory_cache_mb >= 0,
+            "--reader-memory-cache-mb must be >= 0",
+        ),
+        (
+            args.reader != "vc_reader" or importlib.util.find_spec("vc_reader"),
+            "--reader vc_reader needs the vc_reader package (villa/vc_reader)",
+        ),
         (
             args.tta_batch_size is None or args.tta_batch_size > 0,
             "--tta-batch-size must be positive",
@@ -849,7 +868,12 @@ def __init__(
         config,
         cache_dir=None,
         cache_max_gb=None,
+        reader="zarr",
+        reader_connections=32,
+        reader_memory_cache_mb=512,
     ) -> None:
+        if reader not in {"zarr", "vc_reader"}:
+            raise ValueError(f"reader must be 'zarr' or 'vc_reader', got {reader!r}")
         self.tifxyz_dir = Path(tifxyz_dir)
         self.volume_path = str(volume_path)
         self.resolution = str(resolution)
@@ -859,6 +883,9 @@ def __init__(
         self.normalization = config.data.normalization
         self.cache_dir = cache_dir
         self.cache_max_gb = cache_max_gb
+        self.reader = reader
+        self.reader_connections = int(reader_connections)
+        self.reader_memory_cache_mb = int(reader_memory_cache_mb)
         (
             self.flat_grid_stride,
             self.native_coordinate_scale,
@@ -883,6 +910,15 @@ def __getstate__(self):
         return state
 
     def _ensure_volume(self):
+        if self._volume is None and self.reader == "vc_reader":
+            self._volume = open_vc_reader(
+                self.volume_path,
+                self.resolution,
+                cache_dir=self.cache_dir,
+                cache_max_gb=self.cache_max_gb,
+                memory_cache_mb=self.reader_memory_cache_mb,
+                connections=self.reader_connections,
+            )
         if self._volume is None:
             self._volume = _open_shared_volume(
                 self.volume_path,
@@ -949,15 +985,28 @@ def _surface_mask(self, bbox_zyx) -> np.ndarray:
         )
 
     def __getitem__(self, index: int):
-        patch = self.patches[int(index)]
-        starts = (int(patch.z0), int(patch.y0), int(patch.x0))
-        stops = tuple(
-            starts[axis] + self.patch_size_zyx[axis] for axis in range(3)
-        )
-        bbox = (*starts, *stops)
-        crop, valid_slices = read_bbox_with_padding(
-            self._ensure_volume(), bbox, fill_value=0
+        return self.__getitems__([index])[0]
+
+    def __getitems__(self, indices):
+        """DataLoader batch fetch; a vc_reader volume reads the batch in one call."""
+        bboxes = []
+        for index in indices:
+            patch = self.patches[int(index)]
+            starts = (int(patch.z0), int(patch.y0), int(patch.x0))
+            stops = tuple(
+                starts[axis] + self.patch_size_zyx[axis] for axis in range(3)
+            )
+            bboxes.append((*starts, *stops))
+        reads = read_bboxes_with_padding(
+            self._ensure_volume(), bboxes, fill_value=0
         )
+        return [
+            self._sample(bbox, crop, valid_slices)
+            for bbox, (crop, valid_slices) in zip(bboxes, reads)
+        ]
+
+    def _sample(self, bbox, crop, valid_slices):
+        starts = bbox[:3]
         crop = crop.astype(np.float32, copy=False)
         if valid_slices is not None:
             crop[valid_slices] = normalize_image(
@@ -1175,6 +1224,9 @@ def run_command(args) -> int:
         config=config,
         cache_dir=args.cache_dir,
         cache_max_gb=args.cache_max_gb,
+        reader=args.reader,
+        reader_connections=args.reader_connections,
+        reader_memory_cache_mb=args.reader_memory_cache_mb,
     )
     run_native_inference(
         args=args,
 
@@ -244,3 +244,78 @@ def read_bbox_with_padding(
     )
     output[destination] = crop
     return output, destination
+
+
+def open_vc_reader(
+    path: str | Path,
+    resolution: int | str,
+    *,
+    cache_dir: str | Path | None = None,
+    cache_max_gb: float | None = None,
+    memory_cache_mb: int = 512,
+    connections: int = 32,
+):
+    """Open one pyramid level with the optional compiled ``vc_reader`` package.
+
+    Each process (e.g. each DataLoader worker) gets its own memory cache and
+    connection pool.
+    """
+
+    try:
+        from vc_reader.reader import open_zarr
+    except ImportError as exc:
+        raise ImportError(
+            "reader 'vc_reader' needs the vc_reader package (villa/vc_reader); "
+            "install it or use the default zarr reader"
+        ) from exc
+    return open_zarr(
+        str(path),
+        level=str(resolution),
+        cache_dir=cache_dir,
+        cache_max_bytes=None if cache_max_gb is None else int(cache_max_gb * 2**30),
+        memory_cache=int(memory_cache_mb) << 20,
+        connections=int(connections),
+    )
+
+
+def read_bboxes_with_padding(
+    volume: Any,
+    bboxes_zyx: list[tuple[int, int, int, int, int, int]],
+    *,
+    fill_value: int | float = 0,
+) -> list[tuple[np.ndarray, tuple[slice, slice, slice] | None]]:
+    """Read several bboxes like read_bbox_with_padding.
+
+    A vc_reader volume reads them in one call, fetching shared chunks once.
+    """
+    if not hasattr(volume, "read_regions"):
+        return [
+            read_bbox_with_padding(volume, bbox, fill_value=fill_value)
+            for bbox in bboxes_zyx
+        ]
+    bboxes = [tuple(int(value) for value in bbox) for bbox in bboxes_zyx]
+    for bbox in bboxes:
+        if any(bbox[axis + 3] <= bbox[axis] for axis in range(3)):
+            raise ValueError(f"bbox must define a positive crop, got {bbox!r}")
+    shape = tuple(int(value) for value in volume.shape[:3])
+    sizes = [tuple(bbox[axis + 3] - bbox[axis] for axis in range(3)) for bbox in bboxes]
+    crops = volume.read_regions(
+        [(bbox[:3], size) for bbox, size in zip(bboxes, sizes)]
+    )
+    results = []
+    for bbox, size, crop in zip(bboxes, sizes, crops):
+        if crop.shape != size:
+            raise ValueError(f"read_regions returned {crop.shape} for bbox {bbox!r}")
+        # Copy out of vc_reader's recycled buffers and pad with fill_value.
+        output = np.full(size, fill_value, dtype=np.dtype(volume.dtype))
+        starts = [max(0, bbox[axis]) for axis in range(3)]
+        stops = [min(shape[axis], bbox[axis + 3]) for axis in range(3)]
+        destination = None
+        if all(stop > start for start, stop in zip(starts, stops)):
+            destination = tuple(
+                slice(start - bbox[axis], stop - bbox[axis])
+                for axis, (start, stop) in enumerate(zip(starts, stops))
+            )
+            output[destination] = crop[destination]
+        results.append((output, destination))
+    return results
@@ -551,6 +551,9 @@ def open_shared_volume_stub(path, resolution, *, cache_dir, cache_max_gb):
         prefetch_factor=2,
         cache_dir=None,
         cache_max_gb=None,
+        reader="zarr",
+        reader_connections=32,
+        reader_memory_cache_mb=512,
         downsample_workers=1,
     )
     assert native.run_command(args) == 0
@@ -566,3 +569,53 @@ def open_shared_volume_stub(path, resolution, *, cache_dir, cache_max_gb):
         np.all(np.asarray(zarr.open_group(output, mode="r")[str(level)]) == 128)
         for level in range(6)
     )
+
+
+def test_native_dataset_vc_reader_batches_match_zarr_reads(monkeypatch):
+    from torch.utils.data import DataLoader
+
+    from vesuvius.ink_detection.config import NormalizationConfig
+
+    array = np.random.default_rng(0).integers(0, 255, (6, 7, 8), dtype=np.uint8)
+
+    class RegionVolume:
+        shape, dtype = array.shape, array.dtype
+
+        def read_regions(self, regions):
+            calls.append(len(regions))
+            padded = np.pad(array, 8, constant_values=7)
+            return [
+                padded[tuple(slice(s + 8, s + n + 8) for s, n in zip(start, size))]
+                for start, size in regions
+            ]
+
+    calls = []
+    monkeypatch.setattr(native, "_open_shared_volume", lambda *a, **k: array)
+    monkeypatch.setattr(native, "open_vc_reader", lambda *a, **k: RegionVolume())
+    config = SimpleNamespace(
+        data=SimpleNamespace(
+            mode="full_3d", normalization=NormalizationConfig.from_value("none")
+        )
+    )
+    patches = [
+        native.PatchSpec(z, y, x)
+        for z, y, x in ((-2, 0, 1), (2, 3, 4), (5, 6, 7), (9, 0, 0))
+    ]
+    batches = {}
+    for reader in ("zarr", "vc_reader"):
+        dataset = native.NativePatchDataset(
+            tifxyz_dir=Path("unused"),
+            volume_path="memory://native",
+            resolution="0",
+            patches=patches,
+            patch_size_zyx=(3, 3, 3),
+            config=config,
+            reader=reader,
+        )
+        batches[reader] = list(DataLoader(dataset, batch_size=3))
+    assert calls == [3, 1]
+    for (image, starts), (want_image, want_starts) in zip(
+        batches["vc_reader"], batches["zarr"]
+    ):
+        assert torch.equal(image, want_image)
+        assert torch.equal(starts, want_starts)
@@ -6,6 +6,7 @@
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
 import multiprocessing as mp
 import os
+import sys
 from pathlib import Path
 import threading
 from types import SimpleNamespace
@@ -423,3 +424,70 @@ class CompatiblePathError(Exception):
     assert isinstance(
         volume_io._missing_node_error("missing"), CompatiblePathError
     )
+
+
+class _RegionVolume:
+    """vc_reader-like stub: read_regions fills outside the array with 7."""
+
+    def __init__(self, array):
+        self.array = array
+        self.shape = array.shape
+        self.dtype = array.dtype
+        self.calls = 0
+
+    def read_regions(self, regions):
+        self.calls += 1
+        padded = np.pad(self.array, 8, constant_values=7)
+        crops = []
+        for start, size in regions:
+            index = tuple(slice(s + 8, s + n + 8) for s, n in zip(start, size))
+            crops.append(padded[index])  # views, like vc_reader's recycled buffers
+        return crops
+
+
+def test_read_bboxes_with_padding_matches_single_reads():
+    array = np.arange(6 * 7 * 8, dtype=np.uint8).reshape(6, 7, 8)
+    bboxes = [
+        (-1, 1, 3, 2, 5, 7),
+        (0, 0, 0, 6, 7, 8),
+        (4, 5, 6, 9, 9, 9),
+        (7, 0, 0, 9, 2, 2),
+    ]
+    expected = [
+        volume_io.read_bbox_with_padding(array, bbox, fill_value=0) for bbox in bboxes
+    ]
+    for (crop, valid), (want, want_valid) in zip(
+        volume_io.read_bboxes_with_padding(array, bboxes), expected
+    ):
+        np.testing.assert_array_equal(crop, want)
+        assert valid == want_valid
+    stub = _RegionVolume(array)
+    for (crop, valid), (want, want_valid) in zip(
+        volume_io.read_bboxes_with_padding(stub, bboxes), expected
+    ):
+        np.testing.assert_array_equal(crop, want)
+        assert valid == want_valid
+    assert stub.calls == 1
+
+
+def test_vc_reader_matches_zarr_reads(tmp_path):
+    pytest.importorskip("vc_reader")
+    array = np.random.default_rng(0).integers(0, 255, (9, 10, 11), dtype=np.uint8)
+    _write_pyramid(tmp_path / "volume.zarr", array)
+    bboxes = [(-2, 3, 4, 4, 9, 12), (5, 0, 0, 9, 10, 11), (8, 8, 8, 12, 12, 12)]
+    zarr_reads = volume_io.read_bboxes_with_padding(
+        open_volume(tmp_path / "volume.zarr", 0), bboxes
+    )
+    vc_reads = volume_io.read_bboxes_with_padding(
+        volume_io.open_vc_reader(tmp_path / "volume.zarr", 0), bboxes
+    )
+    for (crop, valid), (want, want_valid) in zip(vc_reads, zarr_reads):
+        np.testing.assert_array_equal(crop, want)
+        assert valid == want_valid
+
+
+def test_open_vc_reader_without_package_says_how_to_fix(monkeypatch):
+    monkeypatch.setitem(sys.modules, "vc_reader", None)
+    monkeypatch.setitem(sys.modules, "vc_reader.reader", None)
+    with pytest.raises(ImportError, match="needs the vc_reader package"):
+        volume_io.open_vc_reader("volume.zarr", 0)