diff --git a/kerchunk/codecs.py b/kerchunk/codecs.py
index 852076ea..46b19072 100644
--- a/kerchunk/codecs.py
+++ b/kerchunk/codecs.py
@@ -1,11 +1,18 @@
 import ast
+from dataclasses import dataclass
 import io
+from typing import Self, TYPE_CHECKING
 
 import numcodecs
 from numcodecs.abc import Codec
 import numpy as np
 import threading
 import zlib
+from zarr.core.array_spec import ArraySpec
+from zarr.abc.codec import ArrayBytesCodec
+from zarr.core.buffer import Buffer, NDArrayLike, NDBuffer
+from zarr.core.common import JSON, parse_enum, parse_named_configuration
+from zarr.registry import register_codec
 
 
 class FillStringsCodec(Codec):
@@ -115,6 +122,78 @@ def decode(self, buf, out=None):
 numcodecs.register_codec(GRIBCodec, "grib")
 
 
+@dataclass(frozen=True)
+class GRIBZarrCodec(ArrayBytesCodec):
+    eclock = threading.RLock()
+
+    var: str
+    dtype: np.dtype
+
+    def __init__(self, *, var: str, dtype: np.dtype) -> None:
+        object.__setattr__(self, "var", var)
+        object.__setattr__(self, "dtype", dtype)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, JSON]) -> Self:
+        _, configuration_parsed = parse_named_configuration(
+            data, "bytes", require_configuration=True
+        )
+        configuration_parsed = configuration_parsed or {}
+        return cls(**configuration_parsed)  # type: ignore[arg-type]
+
+    def to_dict(self) -> dict[str, JSON]:
+        if self.endian is None:
+            return {"name": "grib"}
+        else:
+            return {
+                "name": "grib",
+                "configuration": {"var": self.var, "dtype": self.dtype},
+            }
+        
+    async def _decode_single(
+        self,
+        chunk_bytes: Buffer,
+        chunk_spec: ArraySpec,
+    ) -> NDBuffer:
+        assert isinstance(chunk_bytes, Buffer)
+        import eccodes
+
+        if self.var in ["latitude", "longitude"]:
+            var = self.var + "s"
+            dt = self.dtype or "float64"
+        else:
+            var = "values"
+            dt = self.dtype or "float32"
+
+        with self.eclock:
+            mid = eccodes.codes_new_from_message(chunk_bytes.to_bytes())
+            try:
+                data = eccodes.codes_get_array(mid, var)
+                missingValue = eccodes.codes_get_string(mid, "missingValue")
+                if var == "values" and missingValue:
+                    data[data == float(missingValue)] = np.nan
+                return data.astype(dt, copy=False)
+
+            finally:
+                eccodes.codes_release(mid)
+
+    async def _encode_single(
+        self,
+        chunk_array: NDBuffer,
+        chunk_spec: ArraySpec,
+    ) -> Buffer | None:
+        # This is a one way codec
+        raise NotImplementedError
+
+    def compute_encoded_size(
+        self, input_byte_length: int, _chunk_spec: ArraySpec
+    ) -> int:
+        raise NotImplementedError
+
+
+register_codec("grib", GRIBZarrCodec)
+
+
 class AsciiTableCodec(numcodecs.abc.Codec):
     """Decodes ASCII-TABLE extensions in FITS files"""
 
@@ -166,7 +245,6 @@ def decode(self, buf, out=None):
         arr2 = np.empty((self.nrow,), dtype=dt_out)
         heap = buf[arr.nbytes :]
         for name in dt_out.names:
-
             if dt_out[name] == "O":
                 dt = np.dtype(self.ftypes[self.types[name]])
                 counts = arr[name][:, 0]
@@ -244,8 +322,7 @@ def encode(self, buf):
 class ZlibCodec(Codec):
     codec_id = "zlib"
 
-    def __init__(self):
-        ...
+    def __init__(self): ...
 
     def decode(self, data, out=None):
         if out:
diff --git a/kerchunk/combine.py b/kerchunk/combine.py
index eb891de1..b02fa395 100644
--- a/kerchunk/combine.py
+++ b/kerchunk/combine.py
@@ -203,7 +203,7 @@ def append(
         ds = xr.open_dataset(
             fs.get_mapper(), engine="zarr", backend_kwargs={"consolidated": False}
         )
-        z = zarr.open(fs.get_mapper())
+        z = zarr.open(fs.get_mapper(), zarr_format=2)
         mzz = MultiZarrToZarr(
             path,
             out=fs.references,  # dict or parquet/lazy
@@ -360,7 +360,7 @@ def first_pass(self):
                 fs._dircache_from_items()
 
             logger.debug("First pass: %s", i)
-            z = zarr.open_group(fs.get_mapper(""))
+            z = zarr.open_group(fs.get_mapper(""), zarr_format=2)
             for var in self.concat_dims:
                 value = self._get_value(i, z, var, fn=self._paths[i])
                 if isinstance(value, np.ndarray):
@@ -387,7 +387,7 @@ def store_coords(self):
         """
         kv = {}
         store = zarr.storage.KVStore(kv)
-        group = zarr.open(store)
+        group = zarr.open(store, zarr_format=2)
         m = self.fss[0].get_mapper("")
         z = zarr.open(m)
         for k, v in self.coos.items():
@@ -461,7 +461,7 @@ def second_pass(self):
         for i, fs in enumerate(self.fss):
             to_download = {}
             m = fs.get_mapper("")
-            z = zarr.open(m)
+            z = zarr.open(m, zarr_format=2)
 
             if no_deps is None:
                 # done first time only
diff --git a/kerchunk/fits.py b/kerchunk/fits.py
index 18729a9b..f0d4fa8e 100644
--- a/kerchunk/fits.py
+++ b/kerchunk/fits.py
@@ -8,7 +8,7 @@
 from fsspec.implementations.reference import LazyReferenceMapper
 
 
-from kerchunk.utils import class_factory
+from kerchunk.utils import class_factory, dict_to_store
 from kerchunk.codecs import AsciiTableCodec, VarArrCodec
 
 try:
@@ -72,7 +72,8 @@ def process_file(
 
     storage_options = storage_options or {}
     out = out or {}
-    g = zarr.open(out)
+    store = dict_to_store(out)
+    g = zarr.open_group(store=store, zarr_format=2)
 
     with fsspec.open(url, mode="rb", **storage_options) as f:
         infile = fits.open(f, do_not_scale_image_data=True)
@@ -164,7 +165,7 @@ def process_file(
             # TODO: we could sub-chunk on biggest dimension
             name = hdu.name or str(ext)
             arr = g.empty(
-                name, dtype=dtype, shape=shape, chunks=shape, compression=None, **kwargs
+                name=name, dtype=dtype, shape=shape, chunks=shape, compressor=None, zarr_format=2, **kwargs
             )
             arr.attrs.update(
                 {
diff --git a/kerchunk/grib2.py b/kerchunk/grib2.py
index f105fe8b..e4e64bf3 100644
--- a/kerchunk/grib2.py
+++ b/kerchunk/grib2.py
@@ -11,7 +11,7 @@
 import xarray
 import numpy as np
 
-from kerchunk.utils import class_factory, _encode_for_JSON
+from kerchunk.utils import class_factory, _encode_for_JSON, dict_to_store, translate_refs_serializable
 from kerchunk.codecs import GRIBCodec
 from kerchunk.combine import MultiZarrToZarr, drop
 from kerchunk._grib_idx import parse_grib_idx, build_idx_grib_mapping, map_from_index
@@ -71,13 +71,13 @@ def _store_array(store, z, data, var, inline_threshold, offset, size, attr):
     shape = tuple(data.shape or ())
     if nbytes < inline_threshold:
         logger.debug(f"Store {var} inline")
-        d = z.create_dataset(
+        d = z.create_array(
             name=var,
             shape=shape,
             chunks=shape,
             dtype=data.dtype,
             fill_value=attr.get("missingValue", None),
-            compressor=False,
+            compressor=None,
         )
         if hasattr(data, "tobytes"):
             b = data.tobytes()
@@ -91,15 +91,14 @@ def _store_array(store, z, data, var, inline_threshold, offset, size, attr):
         store[f"{var}/0"] = b.decode("ascii")
     else:
         logger.debug(f"Store {var} reference")
-        d = z.create_dataset(
+        d = z.create_array(
             name=var,
             shape=shape,
             chunks=shape,
             dtype=data.dtype,
             fill_value=attr.get("missingValue", None),
             filters=[GRIBCodec(var=var, dtype=str(data.dtype))],
-            compressor=False,
-            overwrite=True,
+            compressor=None,
         )
         store[f"{var}/" + ".".join(["0"] * len(shape))] = ["{{u}}", offset, size]
     d.attrs.update(attr)
@@ -153,7 +152,9 @@ def scan_grib(
     with fsspec.open(url, "rb", **storage_options) as f:
         logger.debug(f"File {url}")
         for offset, size, data in _split_file(f, skip=skip):
-            store = {}
+            store_dict = {}
+            store = dict_to_store(store_dict)
+
             mid = eccodes.codes_new_from_message(data)
             m = cfgrib.cfmessage.CfMessage(mid)
 
@@ -191,7 +192,7 @@ def scan_grib(
             if good is False:
                 continue
 
-            z = zarr.open_group(store)
+            z = zarr.open_group(store, zarr_format=2)
             global_attrs = {
                 f"GRIB_{k}": m[k]
                 for k in cfgrib.dataset.GLOBAL_ATTRIBUTES_KEYS
@@ -227,7 +228,7 @@ def scan_grib(
             varName = m["cfVarName"]
             if varName in ("undef", "unknown"):
                 varName = m["shortName"]
-            _store_array(store, z, vals, varName, inline_threshold, offset, size, attrs)
+            _store_array(store_dict, z, vals, varName, inline_threshold, offset, size, attrs)
             if "typeOfLevel" in message_keys and "level" in message_keys:
                 name = m["typeOfLevel"]
                 coordinates.append(name)
@@ -241,7 +242,7 @@ def scan_grib(
                     attrs = {}
                 attrs["_ARRAY_DIMENSIONS"] = []
                 _store_array(
-                    store, z, data, name, inline_threshold, offset, size, attrs
+                    store_dict, z, data, name, inline_threshold, offset, size, attrs
                 )
             dims = (
                 ["y", "x"]
@@ -298,7 +299,7 @@ def scan_grib(
                     dims = [coord]
                 attrs = cfgrib.dataset.COORD_ATTRS[coord]
                 _store_array(
-                    store,
+                    store_dict,
                     z,
                     x,
                     coord,
@@ -311,10 +312,11 @@ def scan_grib(
             if coordinates:
                 z.attrs["coordinates"] = " ".join(coordinates)
 
+            translate_refs_serializable(store_dict)
             out.append(
                 {
                     "version": 1,
-                    "refs": _encode_for_JSON(store),
+                    "refs": _encode_for_JSON(store_dict),
                     "templates": {"u": url},
                 }
             )
@@ -397,8 +399,9 @@ def grib_tree(
     filters = ["stepType", "typeOfLevel"]
 
     # TODO allow passing a LazyReferenceMapper as output?
-    zarr_store = {}
-    zroot = zarr.open_group(store=zarr_store)
+    zarr_store_dict = {}
+    zarr_store = dict_to_store(zarr_store_dict)
+    zroot = zarr.open_group(store=zarr_store, zarr_format=2)
 
     aggregations: Dict[str, List] = defaultdict(list)
     aggregation_dims: Dict[str, Set] = defaultdict(set)
diff --git a/kerchunk/hdf.py b/kerchunk/hdf.py
index 549923d4..1d4d0054 100644
--- a/kerchunk/hdf.py
+++ b/kerchunk/hdf.py
@@ -10,7 +10,7 @@
 import numcodecs
 
 from .codecs import FillStringsCodec
-from .utils import _encode_for_JSON
+from .utils import _encode_for_JSON, encode_fill_value, dict_to_store, translate_refs_serializable
 
 try:
     import h5py
@@ -21,12 +21,6 @@
         "for more details."
     )
 
-try:
-    from zarr.meta import encode_fill_value
-except ModuleNotFoundError:
-    # https://github.com/zarr-developers/zarr-python/issues/2021
-    from zarr.v2.meta import encode_fill_value
-
 lggr = logging.getLogger("h5-to-zarr")
 _HIDDEN_ATTRS = {  # from h5netcdf.attrs
     "REFERENCE_LIST",
@@ -111,9 +105,9 @@ def __init__(
         if vlen_encode not in ["embed", "null", "leave", "encode"]:
             raise NotImplementedError
         self.vlen = vlen_encode
-        self.store = out or {}
-        self._zroot = zarr.group(store=self.store, overwrite=True)
-
+        self.store_dict = out or {}
+        self.store = dict_to_store(self.store_dict)
+        self._zroot = zarr.group(store=self.store, zarr_format=2, overwrite=True)
         self._uri = url
         self.error = error
         lggr.debug(f"HDF5 file URI: {self._uri}")
@@ -140,7 +134,6 @@ def translate(self, preserve_linked_dsets=False):
         """
         lggr.debug("Translation begins")
         self._transfer_attrs(self._h5f, self._zroot)
-
         self._h5f.visititems(self._translator)
 
         if preserve_linked_dsets:
@@ -157,7 +150,8 @@ def translate(self, preserve_linked_dsets=False):
             self.store.flush()
             return self.store
         else:
-            store = _encode_for_JSON(self.store)
+            translate_refs_serializable(self.store_dict)
+            store = _encode_for_JSON(self.store_dict)
             return {"version": 1, "refs": store}
 
     def _unref(self, ref):
@@ -465,26 +459,30 @@ def _translator(
                     if h5py.h5ds.is_scale(h5obj.id) and not cinfo:
                         return
                     if h5obj.attrs.get("_FillValue") is not None:
+                        fill = h5obj.attrs.get("_FillValue")
                         fill = encode_fill_value(
-                            h5obj.attrs.get("_FillValue"), dt or h5obj.dtype
+                            fill, dt or h5obj.dtype
                         )
 
-                # Create a Zarr array equivalent to this HDF5 dataset...
-                za = self._zroot.require_dataset(
-                    h5obj.name,
+                adims = self._get_array_dims(h5obj)
+
+                # Create a Zarr array equivalent to this HDF5 dataset..
+                za = self._zroot.require_array(
+                    name=h5obj.name,
                     shape=h5obj.shape,
                     dtype=dt or h5obj.dtype,
                     chunks=h5obj.chunks or False,
                     fill_value=fill,
-                    compression=None,
+                    compressor=None,
                     filters=filters,
-                    overwrite=True,
+                    attributes={
+                        "_ARRAY_DIMENSIONS": adims,
+                    },
                     **kwargs,
                 )
                 lggr.debug(f"Created Zarr array: {za}")
                 self._transfer_attrs(h5obj, za)
-                adims = self._get_array_dims(h5obj)
-                za.attrs["_ARRAY_DIMENSIONS"] = adims
+
                 lggr.debug(f"_ARRAY_DIMENSIONS = {adims}")
 
                 if "data" in kwargs:
@@ -496,6 +494,8 @@ def _translator(
                         if h5obj.fletcher32:
                             logging.info("Discarding fletcher32 checksum")
                             v["size"] -= 4
+                        key =  str.removeprefix(h5obj.name, "/") + "/" + ".".join(map(str, k))
+
                         if (
                             self.inline
                             and isinstance(v, dict)
@@ -508,9 +508,10 @@ def _translator(
                                 data.decode("ascii")
                             except UnicodeDecodeError:
                                 data = b"base64:" + base64.b64encode(data)
-                            self.store[za._chunk_key(k)] = data
+
+                            self.store_dict[key] = data
                         else:
-                            self.store[za._chunk_key(k)] = [
+                            self.store_dict[key] = [
                                 self._uri,
                                 v["offset"],
                                 v["size"],
@@ -681,3 +682,4 @@ def _is_netcdf_variable(dataset: h5py.Dataset):
 
 def has_visititems_links():
     return hasattr(h5py.Group, "visititems_links")
+
diff --git a/kerchunk/hdf4.py b/kerchunk/hdf4.py
index 483ffba7..8339659b 100644
--- a/kerchunk/hdf4.py
+++ b/kerchunk/hdf4.py
@@ -144,7 +144,7 @@ def translate(self, filename=None, storage_options=None):
             remote_protocol=prot,
             remote_options=self.st,
         )
-        g = zarr.open_group("reference://", storage_options=dict(fs=fs))
+        g = zarr.open_group("reference://", storage_options=dict(fs=fs), zarr_format=2)
         refs = {}
         for k, v in output.items():
             if isinstance(v, dict):
diff --git a/kerchunk/netCDF3.py b/kerchunk/netCDF3.py
index d43b6b97..31438bb0 100644
--- a/kerchunk/netCDF3.py
+++ b/kerchunk/netCDF3.py
@@ -1,11 +1,12 @@
 from functools import reduce
+from packaging.version import Version
 from operator import mul
 
 import numpy as np
 from fsspec.implementations.reference import LazyReferenceMapper
 import fsspec
 
-from kerchunk.utils import _encode_for_JSON, inline_array
+from kerchunk.utils import _encode_for_JSON, dict_to_store, inline_array, translate_refs_serializable
 
 try:
     from scipy.io._netcdf import ZERO, NC_VARIABLE, netcdf_file, netcdf_variable
@@ -167,7 +168,9 @@ def translate(self):
         import zarr
 
         out = self.out
-        z = zarr.open(out, mode="w")
+        store = dict_to_store(out)
+        z = zarr.open(store, mode="w", zarr_format=2, overwrite=True)
+
         for dim, var in self.variables.items():
             if dim in self.chunks:
                 shape = self.chunks[dim][-1]
@@ -191,13 +194,13 @@ def translate(self):
                     fill = float(fill)
                 if fill is not None and var.data.dtype.kind == "i":
                     fill = int(fill)
-                arr = z.create_dataset(
+                arr = z.create_array(
                     name=dim,
                     shape=shape,
                     dtype=var.data.dtype,
                     fill_value=fill,
                     chunks=shape,
-                    compression=None,
+                    compressor=None,
                 )
                 part = ".".join(["0"] * len(shape)) or "0"
                 k = f"{dim}/{part}"
@@ -245,13 +248,13 @@ def translate(self):
                     fill = float(fill)
                 if fill is not None and base.kind == "i":
                     fill = int(fill)
-                arr = z.create_dataset(
+                arr = z.create_array(
                     name=name,
                     shape=shape,
                     dtype=base,
                     fill_value=fill,
                     chunks=(1,) + dtype.shape,
-                    compression=None,
+                    compressor=None,
                 )
                 arr.attrs.update(
                     {
@@ -295,6 +298,7 @@ def translate(self):
             out.flush()
             return out
         else:
+            translate_refs_serializable(out)
             out = _encode_for_JSON(out)
             return {"version": 1, "refs": out}
 
diff --git a/kerchunk/tests/test_combine.py b/kerchunk/tests/test_combine.py
index 13994921..868a39ff 100644
--- a/kerchunk/tests/test_combine.py
+++ b/kerchunk/tests/test_combine.py
@@ -133,14 +133,14 @@
 
 # simple time arrays - xarray can't make these!
 m = fs.get_mapper("time1.zarr")
-z = zarr.open(m, mode="w")
+z = zarr.open(m, mode="w", zarr_format=2)
 ar = z.create_dataset("time", data=np.array([1], dtype="M8[s]"))
 ar.attrs.update({"_ARRAY_DIMENSIONS": ["time"]})
 ar = z.create_dataset("data", data=arr)
 ar.attrs.update({"_ARRAY_DIMENSIONS": ["time", "x", "y"]})
 
 m = fs.get_mapper("time2.zarr")
-z = zarr.open(m, mode="w")
+z = zarr.open(m, mode="w", zarr_format=2)
 ar = z.create_dataset("time", data=np.array([2], dtype="M8[s]"))
 ar.attrs.update({"_ARRAY_DIMENSIONS": ["time"]})
 ar = z.create_dataset("data", data=arr)
@@ -272,7 +272,7 @@ def test_get_coos(refs, selector, expected):
     mzz.first_pass()
     assert mzz.coos["time"].tolist() == expected
     mzz.store_coords()
-    g = zarr.open(mzz.out)
+    g = zarr.open(mzz.out, zarr_format=2)
     assert g["time"][:].tolist() == expected
     assert dict(g.attrs)
 
diff --git a/kerchunk/tests/test_combine_concat.py b/kerchunk/tests/test_combine_concat.py
index 3f7ff823..23e785df 100644
--- a/kerchunk/tests/test_combine_concat.py
+++ b/kerchunk/tests/test_combine_concat.py
@@ -51,7 +51,7 @@ def test_success(tmpdir, arrays, chunks, axis, m):
     refs = []
     for i, x in enumerate(arrays):
         fn = f"{tmpdir}/out{i}.zarr"
-        g = zarr.open(fn)
+        g = zarr.open(fn, zarr_format=2)
         g.create_dataset("x", data=x, chunks=chunks)
         fns.append(fn)
         ref = kerchunk.zarr.single_zarr(fn, inline=0)
@@ -62,7 +62,7 @@ def test_success(tmpdir, arrays, chunks, axis, m):
     )
 
     mapper = fsspec.get_mapper("reference://", fo=out)
-    g = zarr.open(mapper)
+    g = zarr.open(mapper, zarr_format=2)
     assert (g.x[:] == np.concatenate(arrays, axis=axis)).all()
 
     try:
@@ -76,7 +76,7 @@ def test_success(tmpdir, arrays, chunks, axis, m):
         remote_protocol="file",
         skip_instance_cache=True,
     )
-    g = zarr.open(mapper)
+    g = zarr.open(mapper, zarr_format=2)
     assert (g.x[:] == np.concatenate(arrays, axis=axis)).all()
 
     kerchunk.df.refs_to_dataframe(out, "memory://out.parq", record_size=1)
@@ -86,7 +86,7 @@ def test_success(tmpdir, arrays, chunks, axis, m):
         remote_protocol="file",
         skip_instance_cache=True,
     )
-    g = zarr.open(mapper)
+    g = zarr.open(mapper, zarr_format=2)
     assert (g.x[:] == np.concatenate(arrays, axis=axis)).all()
 
 
@@ -95,9 +95,9 @@ def test_fail_chunks(tmpdir):
     fn2 = f"{tmpdir}/out2.zarr"
     x1 = np.arange(10)
     x2 = np.arange(10, 20)
-    g = zarr.open(fn1)
+    g = zarr.open(fn1, zarr_format=2)
     g.create_dataset("x", data=x1, chunks=(2,))
-    g = zarr.open(fn2)
+    g = zarr.open(fn2, zarr_format=2)
     g.create_dataset("x", data=x2, chunks=(3,))
 
     ref1 = kerchunk.zarr.single_zarr(fn1, inline=0)
@@ -112,9 +112,9 @@ def test_fail_shape(tmpdir):
     fn2 = f"{tmpdir}/out2.zarr"
     x1 = np.arange(12).reshape(6, 2)
     x2 = np.arange(12, 24)
-    g = zarr.open(fn1)
+    g = zarr.open(fn1, zarr_format=2)
     g.create_dataset("x", data=x1, chunks=(2,))
-    g = zarr.open(fn2)
+    g = zarr.open(fn2, zarr_format=2)
     g.create_dataset("x", data=x2, chunks=(2,))
 
     ref1 = kerchunk.zarr.single_zarr(fn1, inline=0)
@@ -129,9 +129,9 @@ def test_fail_irregular_chunk_boundaries(tmpdir):
     fn2 = f"{tmpdir}/out2.zarr"
     x1 = np.arange(10)
     x2 = np.arange(10, 24)
-    g = zarr.open(fn1)
+    g = zarr.open(fn1, zarr_format=2)
     g.create_dataset("x", data=x1, chunks=(4,))
-    g = zarr.open(fn2)
+    g = zarr.open(fn2, zarr_format=2)
     g.create_dataset("x", data=x2, chunks=(4,))
 
     ref1 = kerchunk.zarr.single_zarr(fn1, inline=0)
diff --git a/kerchunk/tests/test_fits.py b/kerchunk/tests/test_fits.py
index 14ea6fc0..de2cad5f 100644
--- a/kerchunk/tests/test_fits.py
+++ b/kerchunk/tests/test_fits.py
@@ -2,6 +2,8 @@
 import fsspec
 import pytest
 
+from kerchunk.utils import refs_as_store
+
 
 fits = pytest.importorskip("astropy.io.fits")
 import kerchunk.fits
@@ -17,8 +19,8 @@ def test_ascii_table():
     # this one directly hits a remote server - should cache?
     url = "https://fits.gsfc.nasa.gov/samples/WFPC2u5780205r_c0fx.fits"
     out = kerchunk.fits.process_file(url, extension=1)
-    m = fsspec.get_mapper("reference://", fo=out, remote_protocol="https")
-    g = zarr.open(m)
+    store = refs_as_store(out, remote_protocol="https")
+    g = zarr.open(store, zarr_format=2)
     arr = g["u5780205r_cvt.c0h.tab"][:]
     with fsspec.open(
         "https://fits.gsfc.nasa.gov/samples/WFPC2u5780205r_c0fx.fits"
@@ -30,8 +32,8 @@ def test_ascii_table():
 
 def test_binary_table():
     out = kerchunk.fits.process_file(btable, extension=1)
-    m = fsspec.get_mapper("reference://", fo=out)
-    z = zarr.open(m)
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     arr = z["1"]
     with open(btable, "rb") as f:
         hdul = fits.open(f)
@@ -47,8 +49,8 @@ def test_binary_table():
 
 def test_cube():
     out = kerchunk.fits.process_file(range_im)
-    m = fsspec.get_mapper("reference://", fo=out)
-    z = zarr.open(m)
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     arr = z["PRIMARY"]
     with open(range_im, "rb") as f:
         hdul = fits.open(f)
@@ -60,8 +62,8 @@ def test_with_class():
     ftz = kerchunk.fits.FitsToZarr(range_im)
     out = ftz.translate()
     assert "fits" in repr(ftz)
-    m = fsspec.get_mapper("reference://", fo=out)
-    z = zarr.open(m)
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     arr = z["PRIMARY"]
     with open(range_im, "rb") as f:
         hdul = fits.open(f)
@@ -75,8 +77,8 @@ def test_var():
 
     ftz = kerchunk.fits.FitsToZarr(var)
     out = ftz.translate()
-    m = fsspec.get_mapper("reference://", fo=out)
-    z = zarr.open(m)
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     arr = z["1"]
     vars = [_.tolist() for _ in arr["var"]]
 
diff --git a/kerchunk/tests/test_grib.py b/kerchunk/tests/test_grib.py
index 32092ced..7d9cf32b 100644
--- a/kerchunk/tests/test_grib.py
+++ b/kerchunk/tests/test_grib.py
@@ -6,7 +6,7 @@
 import pandas as pd
 import pytest
 import xarray as xr
-import datatree
+#import datatree
 import zarr
 import ujson
 from kerchunk.grib2 import (
@@ -21,6 +21,7 @@
     extract_dataset_chunk_index,
     extract_datatree_chunk_index,
 )
+from kerchunk.utils import refs_as_store
 
 eccodes_ver = tuple(int(i) for i in eccodes.__version__.split("."))
 cfgrib = pytest.importorskip("cfgrib")
@@ -68,17 +69,13 @@ def _fetch_first(url):
 def test_archives(tmpdir, url):
     grib = GribToZarr(url, storage_options={"anon": True}, skip=1)
     out = grib.translate()[0]
-    ours = xr.open_dataset(
-        "reference://",
-        engine="zarr",
-        backend_kwargs={
-            "consolidated": False,
-            "storage_options": {
-                "fo": out,
-                "remote_protocol": "s3",
-                "remote_options": {"anon": True},
-            },
-        },
+
+    store = refs_as_store(out)
+
+    ours = xr.open_zarr(
+        store,
+        zarr_format=2,
+        consolidated=False
     )
 
     data = _fetch_first(url)
@@ -119,7 +116,7 @@ def test_grib_tree():
     corrected_msg_groups = [correct_hrrr_subhf_step(msg) for msg in scanned_msg_groups]
     result = grib_tree(corrected_msg_groups)
     fs = fsspec.filesystem("reference", fo=result)
-    zg = zarr.open_group(fs.get_mapper(""))
+    zg = zarr.open_group(fs.get_mapper(""), zarr_format=2)
     assert isinstance(zg["refc/instant/atmosphere/refc"], zarr.Array)
     assert isinstance(zg["vbdsf/avg/surface/vbdsf"], zarr.Array)
     assert set(zg["vbdsf/avg/surface"].attrs["coordinates"].split()) == set(
@@ -147,14 +144,14 @@ def test_correct_hrrr_subhf_group_step():
         scanned_msgs = ujson.load(fobj)
 
     original_zg = [
-        zarr.open_group(fsspec.filesystem("reference", fo=val).get_mapper(""))
+        zarr.open_group(fsspec.filesystem("reference", fo=val).get_mapper(""), zarr_format=2)
         for val in scanned_msgs
     ]
 
     corrected_msgs = [correct_hrrr_subhf_step(msg) for msg in scanned_msgs]
 
     corrected_zg = [
-        zarr.open_group(fsspec.filesystem("reference", fo=val).get_mapper(""))
+        zarr.open_group(fsspec.filesystem("reference", fo=val).get_mapper(""), zarr_format=2)
         for val in corrected_msgs
     ]
 
@@ -177,7 +174,7 @@ def test_hrrr_subhf_corrected_grib_tree():
 
     corrected_msgs = [correct_hrrr_subhf_step(msg) for msg in scanned_msgs]
     merged = grib_tree(corrected_msgs)
-    zg = zarr.open_group(fsspec.filesystem("reference", fo=merged).get_mapper(""))
+    zg = zarr.open_group(fsspec.filesystem("reference", fo=merged).get_mapper(""), zarr_format=2)
     # Check the values and shape of the time coordinates
     assert zg.u.instant.heightAboveGround.step[:].tolist() == [
         0.0,
@@ -220,7 +217,7 @@ def test_hrrr_sfcf_grib_tree():
     with open(fpath, "rb") as fobj:
         scanned_msgs = ujson.load(fobj)
     merged = grib_tree(scanned_msgs)
-    zg = zarr.open_group(fsspec.filesystem("reference", fo=merged).get_mapper(""))
+    zg = zarr.open_group(fsspec.filesystem("reference", fo=merged).get_mapper(""), zarr_format=2)
     # Check the heightAboveGround level shape of the time coordinates
     assert zg.u.instant.heightAboveGround.heightAboveGround[()] == 80.0
     assert zg.u.instant.heightAboveGround.heightAboveGround.shape == ()
@@ -266,22 +263,22 @@ def test_hrrr_sfcf_grib_tree():
     assert zg.u.instant.isobaricInhPa.time.shape == (1,)
 
 
-def test_hrrr_sfcf_grib_datatree():
-    fpath = os.path.join(here, "hrrr.wrfsfcf.subset.json")
-    with open(fpath, "rb") as fobj:
-        scanned_msgs = ujson.load(fobj)
-    merged = grib_tree(scanned_msgs)
-    dt = datatree.open_datatree(
-        fsspec.filesystem("reference", fo=merged).get_mapper(""),
-        engine="zarr",
-        consolidated=False,
-    )
-    # Assert a few things... but if it loads we are mostly done.
-    np.testing.assert_array_equal(
-        dt.u.instant.heightAboveGround.step.values[:],
-        np.array([0, 3600 * 10**9], dtype="timedelta64[ns]"),
-    )
-    assert dt.u.attrs == dict(name="U component of wind")
+# def test_hrrr_sfcf_grib_datatree():
+#     fpath = os.path.join(here, "hrrr.wrfsfcf.subset.json")
+#     with open(fpath, "rb") as fobj:
+#         scanned_msgs = ujson.load(fobj)
+#     merged = grib_tree(scanned_msgs)
+#     dt = datatree.open_datatree(
+#         fsspec.filesystem("reference", fo=merged).get_mapper(""),
+#         engine="zarr",
+#         consolidated=False,
+#     )
+#     # Assert a few things... but if it loads we are mostly done.
+#     np.testing.assert_array_equal(
+#         dt.u.instant.heightAboveGround.step.values[:],
+#         np.array([0, 3600 * 10**9], dtype="timedelta64[ns]"),
+#     )
+#     assert dt.u.attrs == dict(name="U component of wind")
 
 
 def test_parse_grib_idx_invalid_url():
@@ -345,17 +342,17 @@ def test_parse_grib_idx_content(idx_url, storage_options):
     assert idx_df.iloc[message_no]["length"] == output[message_no]["refs"][variable][2]
 
 
-@pytest.fixture
-def zarr_tree_and_datatree_instance():
-    fn = os.path.join(here, "gfs.t00z.pgrb2.0p25.f006.test-limit-100")
-    tree_store = tree_store = grib_tree(scan_grib(fn))
-    dt_instance = datatree.open_datatree(
-        fsspec.filesystem("reference", fo=tree_store).get_mapper(""),
-        engine="zarr",
-        consolidated=False,
-    )
+# @pytest.fixture
+# def zarr_tree_and_datatree_instance():
+#     fn = os.path.join(here, "gfs.t00z.pgrb2.0p25.f006.test-limit-100")
+#     tree_store = tree_store = grib_tree(scan_grib(fn))
+#     dt_instance = datatree.open_datatree(
+#         fsspec.filesystem("reference", fo=tree_store).get_mapper(""),
+#         engine="zarr",
+#         consolidated=False,
+#     )
 
-    return tree_store, dt_instance, fn
+#     return tree_store, dt_instance, fn
 
 
 def test_extract_dataset_chunk_index(zarr_tree_and_datatree_instance):
diff --git a/kerchunk/tests/test_hdf.py b/kerchunk/tests/test_hdf.py
index 69fd22b5..f600a127 100644
--- a/kerchunk/tests/test_hdf.py
+++ b/kerchunk/tests/test_hdf.py
@@ -1,15 +1,22 @@
+import asyncio
 import fsspec
+import json
 import os.path as osp
 
+import zarr.core
+import zarr.core.buffer
+import zarr.core.group
+
 import kerchunk.hdf
 import numpy as np
 import pytest
 import xarray as xr
 import zarr
-import h5py
 
 from kerchunk.hdf import SingleHdf5ToZarr, has_visititems_links
 from kerchunk.combine import MultiZarrToZarr, drop
+from kerchunk.utils import refs_as_fs, refs_as_store
+from kerchunk.utils import fs_as_store
 
 here = osp.dirname(__file__)
 
@@ -18,18 +25,19 @@ def test_single():
     """Test creating references for a single HDF file"""
     url = "s3://noaa-nwm-retro-v2.0-pds/full_physics/2017/201704010000.CHRTOUT_DOMAIN1.comp"
     so = dict(anon=True, default_fill_cache=False, default_cache_type="none")
+
     with fsspec.open(url, **so) as f:
-        h5chunks = SingleHdf5ToZarr(f, url, storage_options=so)
+        h5chunks = SingleHdf5ToZarr(f, url, storage_options=so, inline_threshold=1)
         test_dict = h5chunks.translate()
 
-    m = fsspec.get_mapper(
-        "reference://", fo=test_dict, remote_protocol="s3", remote_options=so
-    )
-    ds = xr.open_dataset(m, engine="zarr", backend_kwargs=dict(consolidated=False))
+    with open("test_dict.json", "w") as f:
+        json.dump(test_dict, f)
+
+    store = refs_as_store(test_dict, remote_options=dict(asynchronous=True, anon=True))
+    ds = xr.open_zarr(store, zarr_format=2, consolidated=False)
 
     with fsspec.open(url, **so) as f:
         expected = xr.open_dataset(f, engine="h5netcdf")
-
         xr.testing.assert_equal(ds.drop_vars("crs"), expected.drop_vars("crs"))
 
 
@@ -42,22 +50,20 @@ def test_single_direct_open():
         h5f=url, inline_threshold=300, storage_options=so
     ).translate()
 
-    m = fsspec.get_mapper(
-        "reference://", fo=test_dict, remote_protocol="s3", remote_options=so
-    )
+    store = refs_as_store(test_dict)
+
     ds_direct = xr.open_dataset(
-        m, engine="zarr", backend_kwargs=dict(consolidated=False)
+        store, engine="zarr", zarr_format=2, backend_kwargs=dict(consolidated=False)
     )
 
     with fsspec.open(url, **so) as f:
         h5chunks = SingleHdf5ToZarr(f, url, storage_options=so)
         test_dict = h5chunks.translate()
 
-    m = fsspec.get_mapper(
-        "reference://", fo=test_dict, remote_protocol="s3", remote_options=so
-    )
+    store = refs_as_store(test_dict)
+
     ds_from_file_opener = xr.open_dataset(
-        m, engine="zarr", backend_kwargs=dict(consolidated=False)
+        store, engine="zarr", zarr_format=2, backend_kwargs=dict(consolidated=False)
     )
 
     xr.testing.assert_equal(
@@ -81,10 +87,10 @@ def test_multizarr(generate_mzz):
     mzz = generate_mzz
     test_dict = mzz.translate()
 
-    m = fsspec.get_mapper(
-        "reference://", fo=test_dict, remote_protocol="s3", remote_options=so
+    store = refs_as_store(test_dict)
+    ds = xr.open_dataset(
+        store, engine="zarr", zarr_format=2, backend_kwargs=dict(consolidated=False)
     )
-    ds = xr.open_dataset(m, engine="zarr", backend_kwargs=dict(consolidated=False))
 
     with fsspec.open_files(urls, **so) as fs:
         expts = [xr.open_dataset(f, engine="h5netcdf") for f in fs]
@@ -158,11 +164,10 @@ def test_times(times_data):
         h5chunks = SingleHdf5ToZarr(f, url)
         test_dict = h5chunks.translate()
 
-    m = fsspec.get_mapper(
-        "reference://",
-        fo=test_dict,
+    store = refs_as_store(test_dict, remote_protocol="file")
+    result = xr.open_dataset(
+        store, engine="zarr", zarr_format=2, backend_kwargs=dict(consolidated=False)
     )
-    result = xr.open_dataset(m, engine="zarr", backend_kwargs=dict(consolidated=False))
     expected = x1.to_dataset()
     xr.testing.assert_equal(result, expected)
 
@@ -174,11 +179,10 @@ def test_times_str(times_data):
     h5chunks = SingleHdf5ToZarr(url)
     test_dict = h5chunks.translate()
 
-    m = fsspec.get_mapper(
-        "reference://",
-        fo=test_dict,
+    store = refs_as_store(test_dict)
+    result = xr.open_dataset(
+        store, engine="zarr", zarr_format=2, backend_kwargs=dict(consolidated=False)
     )
-    result = xr.open_dataset(m, engine="zarr", backend_kwargs=dict(consolidated=False))
     expected = x1.to_dataset()
     xr.testing.assert_equal(result, expected)
 
@@ -191,9 +195,10 @@ def test_string_embed():
     fn = osp.join(here, "vlen.h5")
     h = kerchunk.hdf.SingleHdf5ToZarr(fn, fn, vlen_encode="embed")
     out = h.translate()
-    fs = fsspec.filesystem("reference", fo=out)
+    fs = refs_as_fs(out)
     assert txt in fs.references["vlen_str/0"]
-    z = zarr.open(fs.get_mapper())
+    store = fs_as_store(fs)
+    z = zarr.open(store, zarr_format=2)
     assert z.vlen_str.dtype == "O"
     assert z.vlen_str[0] == txt
     assert (z.vlen_str[1:] == "").all()
@@ -203,8 +208,8 @@ def test_string_null():
     fn = osp.join(here, "vlen.h5")
     h = kerchunk.hdf.SingleHdf5ToZarr(fn, fn, vlen_encode="null", inline_threshold=0)
     out = h.translate()
-    fs = fsspec.filesystem("reference", fo=out)
-    z = zarr.open(fs.get_mapper())
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     assert z.vlen_str.dtype == "O"
     assert (z.vlen_str[:] == None).all()
 
@@ -216,8 +221,8 @@ def test_string_leave():
             f, fn, vlen_encode="leave", inline_threshold=0
         )
         out = h.translate()
-    fs = fsspec.filesystem("reference", fo=out)
-    z = zarr.open(fs.get_mapper())
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     assert z.vlen_str.dtype == "S16"
     assert z.vlen_str[0]  # some obscured ID
     assert (z.vlen_str[1:] == b"").all()
@@ -230,9 +235,10 @@ def test_string_decode():
             f, fn, vlen_encode="encode", inline_threshold=0
         )
         out = h.translate()
-    fs = fsspec.filesystem("reference", fo=out)
+    fs = refs_as_fs(out)
     assert txt in fs.cat("vlen_str/.zarray").decode()  # stored in filter def
-    z = zarr.open(fs.get_mapper())
+    store = fs_as_store(fs)
+    z = zarr.open(store, zarr_format=2)
     assert z.vlen_str[0] == txt
     assert (z.vlen_str[1:] == "").all()
 
@@ -242,8 +248,8 @@ def test_compound_string_null():
     with open(fn, "rb") as f:
         h = kerchunk.hdf.SingleHdf5ToZarr(f, fn, vlen_encode="null", inline_threshold=0)
         out = h.translate()
-    fs = fsspec.filesystem("reference", fo=out)
-    z = zarr.open(fs.get_mapper())
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     assert z.vlen_str[0].tolist() == (10, None)
     assert (z.vlen_str["ints"][1:] == 0).all()
     assert (z.vlen_str["strs"][1:] == None).all()
@@ -256,8 +262,8 @@ def test_compound_string_leave():
             f, fn, vlen_encode="leave", inline_threshold=0
         )
         out = h.translate()
-    fs = fsspec.filesystem("reference", fo=out)
-    z = zarr.open(fs.get_mapper())
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     assert z.vlen_str["ints"][0] == 10
     assert z.vlen_str["strs"][0]  # random ID
     assert (z.vlen_str["ints"][1:] == 0).all()
@@ -271,8 +277,8 @@ def test_compound_string_encode():
             f, fn, vlen_encode="encode", inline_threshold=0
         )
         out = h.translate()
-    fs = fsspec.filesystem("reference", fo=out)
-    z = zarr.open(fs.get_mapper())
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     assert z.vlen_str["ints"][0] == 10
     assert z.vlen_str["strs"][0] == "water"
     assert (z.vlen_str["ints"][1:] == 0).all()
@@ -302,8 +308,8 @@ def test_compress():
                 h.translate()
             continue
         out = h.translate()
-        m = fsspec.get_mapper("reference://", fo=out)
-        g = zarr.open(m)
+        store = refs_as_store(out)
+        g = zarr.open(store, zarr_format=2)
         assert np.mean(g.data) == 49.5
 
 
@@ -312,8 +318,8 @@ def test_embed():
     h = kerchunk.hdf.SingleHdf5ToZarr(fn, vlen_encode="embed")
     out = h.translate()
 
-    fs = fsspec.filesystem("reference", fo=out)
-    z = zarr.open(fs.get_mapper())
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     data = z["Domain_10"]["STER"]["min_1"]["boom_1"]["temperature"][:]
     assert data[0].tolist() == [
         "2014-04-01 00:00:00.0",
@@ -347,8 +353,8 @@ def test_translate_links():
     out = kerchunk.hdf.SingleHdf5ToZarr(fn, inline_threshold=50).translate(
         preserve_linked_dsets=True
     )
-    fs = fsspec.filesystem("reference", fo=out)
-    z = zarr.open(fs.get_mapper())
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
 
     # 1. Test the hard linked datasets were translated correctly
     # 2. Test the soft linked datasets were translated correctly
diff --git a/kerchunk/tests/test_netcdf.py b/kerchunk/tests/test_netcdf.py
index 43b6021b..755823da 100644
--- a/kerchunk/tests/test_netcdf.py
+++ b/kerchunk/tests/test_netcdf.py
@@ -7,6 +7,8 @@
 import pytest
 from kerchunk import netCDF3
 
+from kerchunk.utils import refs_as_store
+
 xr = pytest.importorskip("xarray")
 
 
@@ -28,12 +30,15 @@ def test_one(m):
     m.pipe("data.nc3", bdata)
     h = netCDF3.netcdf_recording_file("memory://data.nc3")
     out = h.translate()
+
+    store = refs_as_store(out, remote_protocol="memory")
+
     ds = xr.open_dataset(
-        "reference://",
+        store,
         engine="zarr",
         backend_kwargs={
             "consolidated": False,
-            "storage_options": {"fo": out, "remote_protocol": "memory"},
+            "zarr_format": 2,
         },
     )
     assert (ds.data == data).all()
diff --git a/kerchunk/tests/test_tiff.py b/kerchunk/tests/test_tiff.py
index 3cc52471..b81e7bab 100644
--- a/kerchunk/tests/test_tiff.py
+++ b/kerchunk/tests/test_tiff.py
@@ -5,6 +5,8 @@
 import pytest
 import xarray as xr
 
+from kerchunk.utils import refs_as_store
+
 pytest.importorskip("tifffile")
 pytest.importorskip("rioxarray")
 import kerchunk.tiff
@@ -15,8 +17,8 @@
 def test_one():
     fn = files[0]
     out = kerchunk.tiff.tiff_to_zarr(fn)
-    m = fsspec.get_mapper("reference://", fo=out)
-    z = zarr.open(m)
+    store = refs_as_store(out)
+    z = zarr.open(store, zarr_format=2)
     assert list(z) == ["0", "1", "2"]
     assert z.attrs["multiscales"] == [
         {
@@ -33,8 +35,8 @@ def test_one():
 def test_coord():
     fn = files[0]
     out = kerchunk.tiff.tiff_to_zarr(fn)
-    m = fsspec.get_mapper("reference://", fo=out)
-    z = zarr.open(m)  # highest res is the one xarray picks
+    store = refs_as_store(out)
+    z = zarr.open(out, zarr_format=2)  # highest res is the one xarray picks
     out = kerchunk.tiff.generate_coords(z.attrs, z[0].shape)
 
     ds = xr.open_dataset(fn)
diff --git a/kerchunk/tests/test_utils.py b/kerchunk/tests/test_utils.py
index a1bb094d..a951c36c 100644
--- a/kerchunk/tests/test_utils.py
+++ b/kerchunk/tests/test_utils.py
@@ -79,13 +79,13 @@ def test_inline_array():
     assert "data/1" not in out2
     assert json.loads(out2["data/.zattrs"]) == json.loads(refs["data/.zattrs"])
     fs = fsspec.filesystem("reference", fo=out2)
-    g = zarr.open(fs.get_mapper())
+    g = zarr.open(fs.get_mapper(), zarr_format=2)
     assert g.data[:].tolist() == [1, 2]
 
     out3 = kerchunk.utils.inline_array(refs, threshold=1000)  # inlines because of size
     assert "data/1" not in out3
     fs = fsspec.filesystem("reference", fo=out3)
-    g = zarr.open(fs.get_mapper())
+    g = zarr.open(fs.get_mapper(), zarr_format=2)
     assert g.data[:].tolist() == [1, 2]
 
 
@@ -99,7 +99,7 @@ def test_json():
 @pytest.mark.parametrize("chunks", [[10, 10], [5, 10]])
 def test_subchunk_exact(m, chunks):
     store = m.get_mapper("test.zarr")
-    g = zarr.open_group(store, mode="w")
+    g = zarr.open_group(store, mode="w", zarr_format=2)
     data = np.arange(100).reshape(10, 10)
     arr = g.create_dataset("data", data=data, chunks=chunks, compression=None)
     ref = kerchunk.zarr.single_zarr("memory://test.zarr")["refs"]
@@ -114,7 +114,7 @@ def test_subchunk_exact(m, chunks):
     ]
 
     g2 = zarr.open_group(
-        "reference://", storage_options={"fo": out, "remote_protocol": "memory"}
+        "reference://", storage_options={"fo": out, "remote_protocol": "memory"}, zarr_format=2
     )
     assert (g2.data[:] == data).all()
 
diff --git a/kerchunk/utils.py b/kerchunk/utils.py
index 838c3cb1..8cc2f765 100644
--- a/kerchunk/utils.py
+++ b/kerchunk/utils.py
@@ -1,14 +1,80 @@
 import base64
 import copy
 import itertools
+import fsspec.asyn
+from packaging.version import Version
+from typing import Any, cast
 import warnings
 
 import ujson
 
 import fsspec
+import numpy as np
 import zarr
 
 
+def refs_as_fs(refs, remote_protocol=None, remote_options=None, **kwargs):
+    """Convert a reference set to an fsspec filesystem"""
+    fs = fsspec.filesystem(
+        "reference",
+        fo=refs,
+        remote_protocol=remote_protocol,
+        remote_options=remote_options,
+        **kwargs,
+    )
+    return fs
+
+
+def refs_as_store(refs, mode="r", remote_protocol=None, remote_options=None):
+    """Convert a reference set to a zarr store"""
+    asynchronous = False
+    if is_zarr3():
+        asynchronous = True
+        if remote_options is None:
+            remote_options = {"asynchronous": True}
+        else:
+            remote_options["asynchronous"] = True
+
+    fs = refs_as_fs(
+        refs,
+        remote_protocol=remote_protocol,
+        remote_options=remote_options,
+        asynchronous=asynchronous,
+    )
+    return fs_as_store(fs, mode=mode)
+
+
+def is_zarr3():
+    """Check if the installed zarr version is version 3"""
+    return Version(zarr.__version__) >= Version("3.0.0.a0")
+
+
+def dict_to_store(store_dict: dict):
+    """Create an in memory zarr store backed by the given dictionary"""
+    if is_zarr3():
+        return zarr.storage.MemoryStore(mode="w", store_dict=store_dict)
+    else:
+        return zarr.storage.KVStore(store_dict)
+
+
+def fs_as_store(fs: fsspec.asyn.AsyncFileSystem, mode="r"):
+    """Open the refs as a zarr store
+
+    Parameters
+    ----------
+    fs: fsspec.async.AsyncFileSystem
+    mode: str
+
+    Returns
+    -------
+    zarr.storage.Store or zarr.storage.Mapper, fsspec.AbstractFileSystem
+    """
+    if is_zarr3():
+        return zarr.storage.RemoteStore(fs, mode=mode)
+    else:
+        return fs.get_mapper()
+
+
 def class_factory(func):
     """Experimental uniform API across function-based file scanners"""
 
@@ -72,7 +138,7 @@ def rename_target(refs, renames):
     -------
     dict: the altered reference set, which can be saved
     """
-    fs = fsspec.filesystem("reference", fo=refs)  # to produce normalised refs
+    fs = refs_as_fs(refs)  # to produce normalised refs
     refs = fs.references
     out = {}
     for k, v in refs.items():
@@ -134,6 +200,47 @@ def _encode_for_JSON(store):
     return store
 
 
+def encode_fill_value(v: Any, dtype: np.dtype, object_codec: Any = None) -> Any:
+    # early out
+    if v is None:
+        return v
+    if dtype.kind == "V" and dtype.hasobject:
+        if object_codec is None:
+            raise ValueError("missing object_codec for object array")
+        v = object_codec.encode(v)
+        v = str(base64.standard_b64encode(v), "ascii")
+        return v
+    if dtype.kind == "f":
+        if np.isnan(v):
+            return "NaN"
+        elif np.isposinf(v):
+            return "Infinity"
+        elif np.isneginf(v):
+            return "-Infinity"
+        else:
+            return float(v)
+    elif dtype.kind in "ui":
+        return int(v)
+    elif dtype.kind == "b":
+        return bool(v)
+    elif dtype.kind in "c":
+        c = cast(np.complex128, np.dtype(complex).type())
+        v = (
+            encode_fill_value(v.real, c.real.dtype, object_codec),
+            encode_fill_value(v.imag, c.imag.dtype, object_codec),
+        )
+        return v
+    elif dtype.kind in "SV":
+        v = str(base64.standard_b64encode(v), "ascii")
+        return v
+    elif dtype.kind == "U":
+        return v
+    elif dtype.kind in "mM":
+        return int(v.view("i8"))
+    else:
+        return v
+
+
 def do_inline(store, threshold, remote_options=None, remote_protocol=None):
     """Replace short chunks with the value of that chunk and inline metadata
 
@@ -146,6 +253,9 @@ def do_inline(store, threshold, remote_options=None, remote_protocol=None):
         remote_options=remote_options,
         remote_protocol=remote_protocol,
     )
+    fs = refs_as_fs(
+        store, remote_protocol=remote_protocol, remote_options=remote_options
+    )
     out = fs.references.copy()
 
     # Inlining is done when one of two conditions are satisfied:
@@ -223,10 +333,9 @@ def inline_array(store, threshold=1000, names=None, remote_options=None):
     -------
     amended references set (simple style)
     """
-    fs = fsspec.filesystem(
-        "reference", fo=store, **(remote_options or {}), skip_instance_cache=True
-    )
-    g = zarr.open_group(fs.get_mapper(), mode="r+")
+    fs = refs_as_fs(store, remote_options=remote_options or {})
+    zarr_store = fs_as_store(fs, mode="r+", remote_options=remote_options or {})
+    g = zarr.open_group(zarr_store, mode="r+", zarr_format=2)
     _inline_array(g, threshold, names=names or [])
     return fs.references
 
@@ -249,7 +358,7 @@ def subchunk(store, variable, factor):
     -------
     modified store
     """
-    fs = fsspec.filesystem("reference", fo=store)
+    fs = refs_as_fs(store)
     store = fs.references
     meta_file = f"{variable}/.zarray"
     meta = ujson.loads(fs.cat(meta_file))
@@ -440,3 +549,34 @@ def templateize(strings, min_length=10, template_name="u"):
     else:
         template = {}
     return template, strings
+
+
+def translate_refs_serializable(refs: dict):
+    """Translate a reference set to a serializable form, given that zarr
+    v3 memory stores store data in buffers by default. This modifies the
+    input dictionary in place, and returns a reference to it.
+
+    It also fixes keys that have a leading slash, which is not appropriate for
+    zarr v3 keys
+
+    Parameters
+    ----------
+    refs: dict
+        The reference set
+
+    Returns
+    -------
+    dict
+        A serializable form of the reference set
+    """
+    keys_to_remove = []
+    new_keys = {}
+    for k, v in refs.items():
+        if isinstance(v, zarr.core.buffer.cpu.Buffer):
+            key = k.removeprefix("/")
+            new_keys[key] = v.to_bytes()
+            keys_to_remove.append(k)
+    for k in keys_to_remove:
+        del refs[k]
+    refs.update(new_keys)
+    return refs
diff --git a/kerchunk/xarray_backend.py b/kerchunk/xarray_backend.py
index ca377f6d..dfbbafba 100644
--- a/kerchunk/xarray_backend.py
+++ b/kerchunk/xarray_backend.py
@@ -43,4 +43,6 @@ def open_reference_dataset(
 
     m = fsspec.get_mapper("reference://", fo=filename_or_obj, **storage_options)
 
-    return xr.open_dataset(m, engine="zarr", consolidated=False, **open_dataset_options)
+    return xr.open_dataset(
+        m, engine="zarr", zarr_format=2, consolidated=False, **open_dataset_options
+    )
diff --git a/pyproject.toml b/pyproject.toml
index 415c3cbd..5eb7c0c9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -24,7 +24,7 @@ dependencies = [
   "numcodecs",
   "numpy",
   "ujson",
-  "zarr<3",
+  "zarr",
 ]
 
 [project.optional-dependencies]