diff --git a/src/main/java/com/glencoesoftware/bioformats2raw/Axis.java b/src/main/java/com/glencoesoftware/bioformats2raw/Axis.java
index 30941956..ac1a1e38 100644
--- a/src/main/java/com/glencoesoftware/bioformats2raw/Axis.java
+++ b/src/main/java/com/glencoesoftware/bioformats2raw/Axis.java
@@ -12,9 +12,10 @@
  */
 public class Axis {
 
-  private char type;
+  private String type;
   private int length;
   private int chunkSize;
+  private String dimensionType;
 
   /**
    * Create a new Axis.
@@ -22,17 +23,31 @@ public class Axis {
    * @param t axis type (e.g. 'X')
    * @param len axis length
    * @param chunk chunk length (expected to be in range [1, len])
+   * @param dimType Zarr dimension type e.g. 'space'
    */
-  public Axis(char t, int len, int chunk) {
+  public Axis(char t, int len, int chunk, String dimType) {
+    this(String.valueOf(t), len, chunk, dimType);
+  }
+
+  /**
+   * Create a new Axis.
+   *
+   * @param t axis type (e.g. 'X')
+   * @param len axis length
+   * @param chunk chunk length (expected to be in range [1, len])
+   * @param dimType Zarr dimension type e.g. 'space'
+   */
+  public Axis(String t, int len, int chunk, String dimType) {
     type = t;
     length = len;
     chunkSize = chunk;
+    dimensionType = dimType;
   }
 
   /**
    * @return axis type (e.g. 'X')
    */
-  public char getType() {
+  public String getType() {
     return type;
   }
 
@@ -50,4 +65,11 @@ public int getChunkSize() {
     return chunkSize;
   }
 
+  /**
+   * @return dimension type e.g. 'space'
+   */
+  public String getDimensionType() {
+    return dimensionType;
+  }
+
 }
diff --git a/src/main/java/com/glencoesoftware/bioformats2raw/Converter.java b/src/main/java/com/glencoesoftware/bioformats2raw/Converter.java
index d506ee1f..17bc7214 100644
--- a/src/main/java/com/glencoesoftware/bioformats2raw/Converter.java
+++ b/src/main/java/com/glencoesoftware/bioformats2raw/Converter.java
@@ -51,6 +51,7 @@
 import loci.formats.Memoizer;
 import loci.formats.MinMaxCalculator;
 import loci.formats.MissingLibraryException;
+import loci.formats.Modulo;
 import loci.formats.in.DynamicMetadataOptions;
 import loci.formats.meta.IMetadata;
 import loci.formats.ome.OMEXMLMetadata;
@@ -1250,7 +1251,7 @@ public SupportedVersions getNGFFVersion() {
    * @return true if Zarr v3 data should be written
    */
   public boolean getV3() {
-    return getNGFFVersion() == SupportedVersions.NGFF_05;
+    return getNGFFVersion().getZarrVersion() == 3;
   }
 
   /**
@@ -2110,17 +2111,17 @@ private byte[] getTileDownsampled(
     int activeTileWidth = 1;
     int activeTileHeight = 1;
     for (int i=0; i<axes.size(); i++) {
-      switch (axes.get(i).getType()) {
-        case 'X':
-          activeTileWidth = blockSizes[i];
-          xDim = dimensions[i];
-          break;
-        case 'Y':
-          activeTileHeight = blockSizes[i];
-          yDim = dimensions[i];
-          break;
-        default:
-          LOGGER.trace("ignoring axis type {}", axes.get(i).getType());
+      String axisType = axes.get(i).getType();
+      if (axisType.equals("X")) {
+        activeTileWidth = blockSizes[i];
+        xDim = dimensions[i];
+      }
+      else if (axisType.equals("Y")) {
+        activeTileHeight = blockSizes[i];
+        yDim = dimensions[i];
+      }
+      else {
+        LOGGER.trace("ignoring axis type {}", axes.get(i).getType());
       }
     }
 
@@ -2209,26 +2210,74 @@ private List<Axis> getDimensions(
         dimensionOrder != null? dimensionOrder.toString()
         : reader.getDimensionOrder()).reverse().toString();
 
+    Modulo mz = null;
+    Modulo mc = null;
+    Modulo mt = null;
+    if (getNGFFVersion().supportsExtraDimensions()) {
+      mz = reader.getModuloZ();
+      mc = reader.getModuloC();
+      mt = reader.getModuloT();
+    }
+
     int spatialDims = 0;
     for (char c : o.toCharArray()) {
       switch (c) {
         case 'X':
-          axes.add(new Axis(c, scaledWidth, scaledTileWidth));
+          axes.add(new Axis(c, scaledWidth, scaledTileWidth, "space"));
           spatialDims++;
           break;
         case 'Y':
-          axes.add(new Axis(c, scaledHeight, scaledTileHeight));
+          axes.add(new Axis(c, scaledHeight, scaledTileHeight, "space"));
           spatialDims++;
           break;
         case 'Z':
-          axes.add(new Axis(c, scaledDepth, scaledChunkDepth));
+          if (mz != null && mz.length() > 1) {
+            Axis actualZ =
+              new Axis(c, scaledDepth / mz.length(), scaledChunkDepth, "space");
+            Axis moduloZ = new Axis(mz.type, mz.length(), 1, "space");
+            if (Math.abs(mz.step - 1) > Constants.EPSILON) {
+              axes.add(moduloZ);
+              axes.add(actualZ);
+            }
+            else {
+              axes.add(actualZ);
+              axes.add(moduloZ);
+            }
+          }
+          else {
+            axes.add(new Axis(c, scaledDepth, scaledChunkDepth, "space"));
+          }
           spatialDims++;
           break;
         case 'C':
-          axes.add(new Axis(c, sizeC, 1));
+          if (mc != null && mc.length() > 1) {
+            if (Math.abs(mc.step - 1) > Constants.EPSILON) {
+              axes.add(new Axis(mc.type, mc.length(), 1, "channel"));
+              axes.add(new Axis(c, sizeC / mc.length(), 1, "channel"));
+            }
+            else {
+              axes.add(new Axis(c, sizeC / mc.length(), 1, "channel"));
+              axes.add(new Axis(mc.type, mc.length(), 1, "channel"));
+            }
+          }
+          else {
+            axes.add(new Axis(c, sizeC, 1, "channel"));
+          }
           break;
         case 'T':
-          axes.add(new Axis(c, sizeT, 1));
+          if (mt != null && mt.length() > 1) {
+            if (Math.abs(mt.step - 1) > Constants.EPSILON) {
+              axes.add(new Axis(mt.type, mt.length(), 1, "time"));
+              axes.add(new Axis(c, sizeT / mt.length(), 1, "time"));
+            }
+            else {
+              axes.add(new Axis(c, sizeT / mt.length(), 1, "time"));
+              axes.add(new Axis(mt.type, mt.length(), 1, "time"));
+            }
+          }
+          else {
+            axes.add(new Axis(c, sizeT, 1, "time"));
+          }
           break;
         default:
           LOGGER.trace("ignoring axis type {}", c);
@@ -2241,8 +2290,8 @@ private List<Axis> getDimensions(
       for (int a=0; a<axes.size(); a++) {
         Axis axis = axes.get(a);
         if (axis.getLength() == 1) {
-          char type = axis.getType();
-          if (type == 'X' || type == 'Y' || type == 'Z') {
+          String type = axis.getType();
+          if (type.equals("X") || type.equals("Y") || type.equals("Z")) {
             spatialDims--;
           }
           axes.remove(axis);
@@ -2278,18 +2327,18 @@ private int[] getShardSizeArray(List<Axis> axes) {
     int[] shard = new int[axes.size()];
     for (int i=0; i<axes.size(); i++) {
       Axis axis = axes.get(i);
-      switch (axis.getType()) {
-        case 'X':
-          shard[i] = getShardWidth();
-          break;
-        case 'Y':
-          shard[i] = getShardHeight();
-          break;
-        case 'Z':
-          shard[i] = getShardDepth();
-          break;
-        default:
-          shard[i] = axis.getChunkSize();
+      String axisType = axis.getType();
+      if (axisType.equals("X")) {
+        shard[i] = getShardWidth();
+      }
+      else if (axisType.equals("Y")) {
+        shard[i] = getShardHeight();
+      }
+      else if (axisType.equals("Z")) {
+        shard[i] = getShardDepth();
+      }
+      else {
+        shard[i] = axis.getChunkSize();
       }
     }
     return shard;
@@ -2299,23 +2348,47 @@ private int[] createShape(List<Axis> axes, int width, int height, int depth) {
     int[] shape = new int[axes.size()];
     Arrays.fill(shape, 1);
     for (int i=0; i<axes.size(); i++) {
-      switch (axes.get(i).getType()) {
-        case 'X':
-          shape[i] = width;
-          break;
-        case 'Y':
-          shape[i] = height;
-          break;
-        case 'Z':
-          shape[i] = depth;
-          break;
-        default:
-          LOGGER.trace("ignoring axis type {}", axes.get(i).getType());
+      String axisType = axes.get(i).getType();
+      if (axisType.equals("X")) {
+        shape[i] = width;
+      }
+      else if (axisType.equals("Y")) {
+        shape[i] = height;
+      }
+      else if (axisType.equals("Z")) {
+        shape[i] = depth;
+      }
+      else {
+        LOGGER.trace("ignoring axis type {}", axisType);
       }
     }
     return shape;
   }
 
+  private int[] getModuloLengths(Modulo m, int size) {
+    if (m == null) {
+      // no modulo, so the number of axis lengths is 1
+      // unless dimension compacting was applied
+      if (getCompactDimensions() && size == 1) {
+        return new int[0];
+      }
+      return new int[1];
+    }
+    if (getCompactDimensions()) {
+      // one or both modulo dimensions may have been compacted away
+      // so don't assume the length should be 2
+      int count = 0;
+      if (m.length() > 1) {
+        count++;
+      }
+      if (size / m.length() > 1) {
+        count++;
+      }
+      return new int[count];
+    }
+    return new int[m.length() > 1 ? 2 : 1];
+  }
+
   /**
    * Retrieve the offset based on either the configured or input file
    * dimension order at the current resolution.
@@ -2334,31 +2407,80 @@ private int[] getOffset(
     int[] zct = reader.getZCTCoords(plane);
     int[] offset = new int[axes.size()];
     Arrays.fill(offset, 0);
+
+    boolean useModulo = getNGFFVersion().supportsExtraDimensions();
+    Modulo mz = useModulo ? reader.getModuloZ() : null;
+    int[] zLengths = getModuloLengths(mz, reader.getSizeZ());
+    int zLengthIndex = zLengths.length - 1;
+    Modulo mc = useModulo ? reader.getModuloC() : null;
+    int[] cLengths = getModuloLengths(mc, reader.getSizeC());
+    int cLengthIndex = cLengths.length - 1;
+    Modulo mt = useModulo ? reader.getModuloT() : null;
+    int[] tLengths = getModuloLengths(mt, reader.getSizeT());
+    int tLengthIndex = tLengths.length - 1;
+
     for (int i=0; i<axes.size(); i++) {
       Axis a = axes.get(i);
-      switch (a.getType()) {
-        case 'X':
-          offset[i] = x;
-          break;
-        case 'Y':
-          offset[i] = y;
-          break;
-        case 'Z':
-          offset[i] = zct[0];
-          break;
-        case 'C':
-          offset[i] = zct[1];
-          break;
-        case 'T':
-          offset[i] = zct[2];
-          break;
-        default:
-          LOGGER.trace("ignoring axis type {}", axes.get(i).getType());
+      String axisType = a.getType();
+      if (axisType.equals("X")) {
+        offset[i] = x;
+      }
+      else if (axisType.equals("Y")) {
+        offset[i] = y;
+      }
+      else if (axisType.equals("Z") ||
+        (mz != null && axisType.equals(mz.type)))
+      {
+        zLengths[zLengthIndex] = a.getLength();
+        zLengthIndex--;
+      }
+      else if (axisType.equals("C") ||
+        (mc != null && axisType.equals(mc.type)))
+      {
+        cLengths[cLengthIndex] = a.getLength();
+        cLengthIndex--;
+      }
+      else if (axisType.equals("T") ||
+        (mt != null && axisType.equals(mt.type)))
+      {
+        tLengths[tLengthIndex] = a.getLength();
+        tLengthIndex--;
+      }
+      else {
+        LOGGER.trace("ignoring axis type {}", axes.get(i).getType());
+      }
+
+      if (zLengthIndex < 0) {
+        int[] zOffset = reverse(FormatTools.rasterToPosition(zLengths, zct[0]));
+        System.arraycopy(zOffset, 0,
+          offset, i - (zOffset.length - 1), zOffset.length);
+        zLengthIndex = zLengths.length - 1;
+      }
+      if (cLengthIndex < 0) {
+        int[] cOffset = reverse(FormatTools.rasterToPosition(cLengths, zct[1]));
+        System.arraycopy(cOffset, 0,
+          offset, i - (cOffset.length - 1), cOffset.length);
+        cLengthIndex = cLengths.length - 1;
+      }
+      if (tLengthIndex < 0) {
+        int[] tOffset = reverse(FormatTools.rasterToPosition(tLengths, zct[2]));
+        System.arraycopy(tOffset, 0,
+          offset, i - (tOffset.length - 1), tOffset.length);
+        tLengthIndex = tLengths.length - 1;
       }
     }
     return offset;
   }
 
+  private int[] reverse(int[] pos) {
+    for (int i=0; i<pos.length/2; i++) {
+      int tmp = pos[i];
+      pos[i] = pos[pos.length - i - 1];
+      pos[pos.length - i - 1] = tmp;
+    }
+    return pos;
+  }
+
   private void processChunk(int series, int resolution, int plane,
       int[] offset, int[] shape, List<Axis> axes)
         throws EnumerationException, FormatException, IOException,
@@ -2383,21 +2505,21 @@ private void processChunk(int series, int resolution, int plane,
       //Get coords of current series
       zct = reader.getZCTCoords(plane);
       for (int i=0; i<axes.size(); i++) {
-        switch (axes.get(i).getType()) {
-          case 'X':
-            xOffset = offset[i];
-            xShape = shape[i];
-            break;
-          case 'Y':
-            yOffset = offset[i];
-            yShape = shape[i];
-            break;
-          case 'Z':
-            zOffset = offset[i];
-            zShape = shape[i];
-            break;
-          default:
-            LOGGER.trace("ignoring axis type {}", axes.get(i).getType());
+        String axisType = axes.get(i).getType();
+        if (axisType.equals("X")) {
+          xOffset = offset[i];
+          xShape = shape[i];
+        }
+        else if (axisType.equals("Y")) {
+          yOffset = offset[i];
+          yShape = shape[i];
+        }
+        else if (axisType.equals("Z")) {
+          zOffset = offset[i];
+          zShape = shape[i];
+        }
+        else {
+          LOGGER.trace("ignoring axis type {}", axisType);
         }
       }
     }
@@ -2414,6 +2536,12 @@ private void processChunk(int series, int resolution, int plane,
         int planeIndex;
         try {
           planeIndex = FormatTools.getIndex(reader, z, zct[1], zct[2]);
+          if (getNGFFVersion().supportsExtraDimensions()) {
+            Modulo mz = reader.getModuloZ();
+            if (mz != null && mz.length() > 1) {
+              planeIndex = plane;
+            }
+          }
         }
         finally {
           readers.put(reader);
@@ -3014,9 +3142,9 @@ private void setSeriesLevelMetadata(int series, int resolutions)
       scale.put("type", "scale");
       List<Double> axisValues = new ArrayList<Double>();
       for (int i=0; i<activeAxes.size(); i++) {
-        String axisChar =
+        String axisType =
           String.valueOf(activeAxes.get(i).getType()).toLowerCase();
-        Quantity axisScale = getScale(meta, series, axisChar.charAt(0));
+        Quantity axisScale = getScale(meta, series, axisType);
 
         if (axisScale != null) {
           // if physical dimension information is defined,
@@ -3024,10 +3152,10 @@ private void setSeriesLevelMetadata(int series, int resolutions)
           // increase it according to the resolution number for dimensions that
           // are scaled (X and Y)
           double as = axisScale.value().doubleValue();
-          if (axisChar.equals("x")) {
+          if (axisType.equals("x")) {
             axisValues.add(as * resolutionScalesX.get(r));
           }
-          else if (axisChar.equals("y")) {
+          else if (axisType.equals("y")) {
             axisValues.add(as * resolutionScalesY.get(r));
           }
           else {
@@ -3038,10 +3166,10 @@ else if (axisChar.equals("y")) {
           // if physical dimension information is not defined,
           // store the scale factor for the dimension in the current resolution,
           // i.e. 1.0 for everything other than X and Y
-          if (axisChar.equals("x")) {
+          if (axisType.equals("x")) {
             axisValues.add(resolutionScalesX.get(r));
           }
-          else if (axisChar.equals("y")) {
+          else if (axisType.equals("y")) {
             axisValues.add(resolutionScalesY.get(r));
           }
           else {
@@ -3063,17 +3191,13 @@ else if (axisChar.equals("y")) {
     List<Map<String, String>> axes = new ArrayList<Map<String, String>>();
     for (int i=0; i<activeAxes.size(); i++) {
       String axis = String.valueOf(activeAxes.get(i).getType()).toLowerCase();
-      String type = "space";
-      Quantity scale = getScale(meta, series, axis.charAt(0));
-      if (axis.equals("t")) {
-        type = "time";
-      }
-      else if (axis.equals("c")) {
-        type = "channel";
-      }
+      String type = activeAxes.get(i).getDimensionType();
+      Quantity scale = getScale(meta, series, axis);
       Map<String, String> thisAxis = new HashMap<String, String>();
       thisAxis.put("name", axis);
-      thisAxis.put("type", type);
+      if (type != null) {
+        thisAxis.put("type", type);
+      }
       if (scale != null) {
         String symbol = scale.unit().getSymbol();
         String unitName = null;
@@ -3221,7 +3345,7 @@ else if (scale instanceof Time) {
     LOGGER.debug("    finished writing subgroup attributes");
   }
 
-  private Quantity getScale(IMetadata meta, int series, char axisChar) {
+  private Quantity getScale(IMetadata meta, int series, String axisType) {
     if (meta == null) {
       return null;
     }
@@ -3231,24 +3355,25 @@ private Quantity getScale(IMetadata meta, int series, char axisChar) {
       return null;
     }
 
-    switch (axisChar) {
-      case 'x':
-        return meta.getPixelsPhysicalSizeX(seriesIndex);
-      case 'y':
-        return meta.getPixelsPhysicalSizeY(seriesIndex);
-      case 'z':
-        return meta.getPixelsPhysicalSizeZ(seriesIndex);
-      case 't':
-        Quantity timeIncrement = meta.getPixelsTimeIncrement(seriesIndex);
-        if (timeIncrement != null && timeIncrement.value().doubleValue() > 0) {
-          return timeIncrement;
-        }
-        else {
-          return null;
-        }
-      default:
+    if (axisType.equalsIgnoreCase("x")) {
+      return meta.getPixelsPhysicalSizeX(seriesIndex);
+    }
+    else if (axisType.equalsIgnoreCase("y")) {
+      return meta.getPixelsPhysicalSizeY(seriesIndex);
+    }
+    else if (axisType.equalsIgnoreCase("z")) {
+      return meta.getPixelsPhysicalSizeZ(seriesIndex);
+    }
+    else if (axisType.equalsIgnoreCase("t")) {
+      Quantity timeIncrement = meta.getPixelsTimeIncrement(seriesIndex);
+      if (timeIncrement != null && timeIncrement.value().doubleValue() > 0) {
+        return timeIncrement;
+      }
+      else {
         return null;
+      }
     }
+    return null;
   }
 
   /**
diff --git a/src/main/java/com/glencoesoftware/bioformats2raw/SupportedVersions.java b/src/main/java/com/glencoesoftware/bioformats2raw/SupportedVersions.java
index 89dc513a..717cf962 100644
--- a/src/main/java/com/glencoesoftware/bioformats2raw/SupportedVersions.java
+++ b/src/main/java/com/glencoesoftware/bioformats2raw/SupportedVersions.java
@@ -7,15 +7,44 @@
  */
 package com.glencoesoftware.bioformats2raw;
 
+import java.util.Arrays;
+import java.util.List;
+
 public enum SupportedVersions {
-  NGFF_01("0.1"),
-  NGFF_04("0.4"),
-  NGFF_05("0.5");
+  NGFF_01("0.1", 2, null),
+  NGFF_04("0.4", 2, null),
+  NGFF_05("0.5", 3, new Integer[] {2}),
+  NGFF_DEV("0.9.dev1", 3, new Integer[] {2, 3});
 
   private final String value;
+  private final int zarrVersion;
+  private final List<Integer> supportedRFCs;
 
-  private SupportedVersions(final String value) {
+  private SupportedVersions(
+    final String value, int zarrVersion, Integer[] rfcs)
+  {
     this.value = value;
+    this.zarrVersion = zarrVersion;
+    if (rfcs != null) {
+      this.supportedRFCs = Arrays.asList(rfcs);
+    }
+    else {
+      this.supportedRFCs = null;
+    }
+  }
+
+  /**
+   * @return the version of the Zarr format used by this OME-Zarr version
+   */
+  public int getZarrVersion() {
+    return zarrVersion;
+  }
+
+  /**
+   * @return true if extra dimensions (RFC-3) are supported by this version
+   */
+  public boolean supportsExtraDimensions() {
+    return supportedRFCs != null && supportedRFCs.contains(3);
   }
 
   @Override
diff --git a/src/test/java/com/glencoesoftware/bioformats2raw/test/AbstractZarrTest.java b/src/test/java/com/glencoesoftware/bioformats2raw/test/AbstractZarrTest.java
index 1b82c998..862a9374 100644
--- a/src/test/java/com/glencoesoftware/bioformats2raw/test/AbstractZarrTest.java
+++ b/src/test/java/com/glencoesoftware/bioformats2raw/test/AbstractZarrTest.java
@@ -18,13 +18,17 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Stream;
 
 import loci.common.LogbackTools;
 import loci.common.services.ServiceFactory;
 import loci.formats.FormatTools;
 import loci.formats.in.FakeReader;
+import loci.formats.in.OMETiffReader;
+import loci.formats.ome.OMEXMLMetadata;
 import loci.formats.services.OMEXMLService;
 import ome.xml.model.OME;
+import ome.xml.model.Pixels;
 
 import com.glencoesoftware.bioformats2raw.Converter;
 import dev.zarr.zarrjava.ZarrException;
@@ -34,6 +38,9 @@
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -162,6 +169,66 @@ static Path fake(Map<String, String> options,
     }
   }
 
+  /**
+   * Test modulo dimension handling.
+   * As written, this tests correct behavior for OME-Zarr 0.5 and earlier,
+   * which is to ignore the modulo dimensions in favor of the parent dimension.
+   *
+   * @param moduloFile OME-TIFF file with modulo dimension(s)
+   * @param compact true if compact dimensions should be used
+   */
+  @ParameterizedTest
+  @MethodSource("getModuloFiles")
+  public void testModulo(String moduloFile, boolean compact) throws Exception {
+    input = getTestFile(moduloFile);
+    // intentionally skip compact tests by default, since there are many other
+    // compact tests that cover the case where modulo dimensions are not used
+    if (compact) {
+      return;
+    }
+    assertTool();
+
+    OME ome = getOMEMetadata();
+    Pixels pix = ome.getImage(0).getPixels();
+    int x = pix.getSizeX().getValue().intValue();
+    int y = pix.getSizeY().getValue().intValue();
+    int z = pix.getSizeZ().getValue().intValue();
+    int c = pix.getSizeC().getValue().intValue();
+    int t = pix.getSizeT().getValue().intValue();
+
+    Array series0 = Array.open(store.resolve("0", "0"));
+    assertArrayEquals(new long[] {t, c, z, y, x}, series0.metadata().shape);
+    assertArrayEquals(
+      new int[] {1, 1, 1, y, x}, series0.metadata().chunkShape());
+
+    try (OMETiffReader r = new OMETiffReader()) {
+      r.setId(input.toString());
+      for (int p=0; p<r.getImageCount(); p++) {
+        int[] zct = r.getZCTCoords(p);
+        byte[] src = r.openBytes(p);
+        ucar.ma2.Array dest = series0.read(
+          new long[] {zct[2], zct[1], zct[0], 0, 0},
+          Utils.toLongArray(series0.metadata().chunkShape()));
+        ByteBuffer buf = dest.getDataAsByteBuffer();
+        byte[] destBytes = new byte[buf.remaining()];
+        buf.get(destBytes);
+
+        assertArrayEquals(src, destBytes);
+      }
+    }
+  }
+
+  static Stream<Arguments> getModuloFiles() {
+    return Stream.of(
+      Arguments.of("mini-flim-moduloC.ome.tiff", false),
+      Arguments.of("mini-flim-moduloC.ome.tiff", true),
+      Arguments.of("mini-flim-moduloT.ome.tiff", false),
+      Arguments.of("mini-flim-moduloT.ome.tiff", true),
+      Arguments.of("mini-spim-moduloZ.ome.tiff", false),
+      Arguments.of("mini-spim-moduloZ.ome.tiff", true)
+    );
+  }
+
   void checkAxes(List<Map<String, Object>> axes, String order,
     String[] units)
   {
@@ -197,6 +264,15 @@ OME getOMEMetadata() throws Exception {
     return (OME) xmlService.createOMEXMLRoot(omexml);
   }
 
+  OMEXMLMetadata getOMEMetadataStore() throws Exception {
+    Path xml = output.resolve("OME").resolve("METADATA.ome.xml");
+    String omexml = new String(Files.readAllBytes(xml), StandardCharsets.UTF_8);
+    ServiceFactory sf = new ServiceFactory();
+    OMEXMLService xmlService = sf.getInstance(OMEXMLService.class);
+    assertTrue(xmlService.validateOMEXML(omexml));
+    return xmlService.createOMEXMLMetadata(omexml);
+  }
+
   void checkPlateSeriesMetadata(List<String> groupMap,
     int rowCount, int colCount, int fieldCount)
   {
@@ -329,4 +405,5 @@ public void checkSpecialPixels(int s, int sizeZ, int sizeC, int sizeT,
   abstract void checkMultiscale(Map<String, Object> multiscale, String name);
 
   abstract String getNGFFVersion();
+
 }
diff --git a/src/test/java/com/glencoesoftware/bioformats2raw/test/OMEZarr1Test.java b/src/test/java/com/glencoesoftware/bioformats2raw/test/OMEZarr1Test.java
new file mode 100644
index 00000000..d459aa5c
--- /dev/null
+++ b/src/test/java/com/glencoesoftware/bioformats2raw/test/OMEZarr1Test.java
@@ -0,0 +1,154 @@
+/**
+ * Copyright (c) 2025 Glencoe Software, Inc. All rights reserved.
+ *
+ * This software is distributed under the terms described by the LICENSE.txt
+ * file you can find at the root of the distribution bundle.  If the file is
+ * missing please request a copy by contacting info@glencoesoftware.com
+ */
+package com.glencoesoftware.bioformats2raw.test;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+import dev.zarr.zarrjava.utils.Utils;
+import dev.zarr.zarrjava.v3.Array;
+
+import loci.common.Constants;
+import loci.common.services.ServiceFactory;
+import loci.formats.FormatTools;
+import loci.formats.Modulo;
+import loci.formats.in.OMETiffReader;
+import loci.formats.ome.OMEXMLMetadata;
+import loci.formats.services.OMEXMLService;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class OMEZarr1Test extends ZarrV3Test {
+
+  @Override
+  String getNGFFVersion() {
+    return "0.9.dev1";
+  }
+
+  /**
+   * Test modulo dimension handling.
+   * Since this is OME-Zarr 0.9.dev1 which includes RFC-3, modulo dimensions
+   * should be reported as their own axis.
+   *
+   * @param moduloFile OME-TIFF file with modulo dimension(s)
+   * @param compact true if compact dimensions should be written
+   */
+  @ParameterizedTest
+  @MethodSource("getModuloFiles")
+  public void testModulo(String moduloFile, boolean compact) throws Exception {
+    input = getTestFile(moduloFile);
+    if (compact) {
+      assertTool("--ngff-version", getNGFFVersion(), "--compact");
+    }
+    else {
+      assertTool("--ngff-version", getNGFFVersion());
+    }
+
+    OMEXMLMetadata meta = getOMEMetadataStore();
+    OMEXMLService service =
+          new ServiceFactory().getInstance(OMEXMLService.class);
+
+    int x = meta.getPixelsSizeX(0).getValue().intValue();
+    int y = meta.getPixelsSizeY(0).getValue().intValue();
+    int z = meta.getPixelsSizeZ(0).getValue().intValue();
+    int c = meta.getPixelsSizeC(0).getValue().intValue();
+    int t = meta.getPixelsSizeT(0).getValue().intValue();
+    Modulo mz = service.getModuloAlongZ(meta, 0);
+    Modulo mc = service.getModuloAlongC(meta, 0);
+    Modulo mt = service.getModuloAlongT(meta, 0);
+
+    int[] zAxes = getAxes(z, mz, compact);
+    int[] cAxes = getAxes(c, mc, compact);
+    int[] tAxes = getAxes(t, mt, compact);
+    int dims = zAxes.length + cAxes.length + tAxes.length + 2;
+    int[] chunkShape = new int[dims];
+    Arrays.fill(chunkShape, 1);
+    chunkShape[dims - 2] = y;
+    chunkShape[dims - 1] = x;
+
+    long[] shape = new long[dims];
+    System.arraycopy(Utils.toLongArray(tAxes), 0, shape, 0, tAxes.length);
+    System.arraycopy(Utils.toLongArray(cAxes), 0,
+      shape, tAxes.length, cAxes.length);
+    System.arraycopy(Utils.toLongArray(zAxes), 0,
+      shape, tAxes.length + cAxes.length, zAxes.length);
+    shape[dims - 2] = y;
+    shape[dims - 1] = x;
+
+    Array series0 = Array.open(store.resolve("0", "0"));
+    assertArrayEquals(shape, series0.metadata().shape);
+    assertArrayEquals(chunkShape, series0.metadata().chunkShape());
+
+    try (OMETiffReader r = new OMETiffReader()) {
+      r.setId(input.toString());
+      for (int p=0; p<r.getImageCount(); p++) {
+        int[] zct = r.getZCTCoords(p);
+        int[] zz = reverse(
+          FormatTools.rasterToPosition(reverse(zAxes), zct[0]));
+        int[] cc = reverse(
+          FormatTools.rasterToPosition(reverse(cAxes), zct[1]));
+        int[] tt = reverse(
+          FormatTools.rasterToPosition(reverse(tAxes), zct[2]));
+        int[] offset = new int[dims];
+        System.arraycopy(tt, 0, offset, 0, tt.length);
+        System.arraycopy(cc, 0, offset, tt.length, cc.length);
+        System.arraycopy(zz, 0, offset, tt.length + cc.length, zz.length);
+        offset[dims - 2] = 0;
+        offset[dims - 1] = 0;
+        byte[] src = r.openBytes(p);
+        ucar.ma2.Array dest = series0.read(
+          Utils.toLongArray(offset),
+          Utils.toLongArray(series0.metadata().chunkShape()));
+        ByteBuffer buf = dest.getDataAsByteBuffer();
+        byte[] destBytes = new byte[buf.remaining()];
+        buf.get(destBytes);
+
+        assertArrayEquals(src, destBytes,
+          "plane #" + p + ", offset = " + Arrays.toString(offset));
+      }
+    }
+  }
+
+  private int[] getAxes(int size, Modulo m, boolean compact) {
+    if (compact && size == 1) {
+      return new int[0];
+    }
+    if (m != null) {
+      int mLength = m.length();
+      int newSize = size / m.length();
+      if (compact && newSize == 1) {
+        return new int[] {mLength};
+      }
+      if (compact && mLength == 1) {
+        return new int[] {newSize};
+      }
+      if (Math.abs(m.step - 1) > Constants.EPSILON) {
+        return new int[] {mLength, newSize};
+      }
+      else {
+        return new int[] {newSize, mLength};
+      }
+    }
+    return new int[] {size};
+  }
+
+  private int[] reverse(int[] pos) {
+    if (pos.length == 1) {
+      return pos;
+    }
+    int[] reversed = new int[pos.length];
+    for (int i=0; i<pos.length/2; i++) {
+      reversed[i] = pos[pos.length - i - 1];
+      reversed[reversed.length - i - 1] = pos[i];
+    }
+    return reversed;
+  }
+
+}
diff --git a/src/test/java/com/glencoesoftware/bioformats2raw/test/ZarrV3Test.java b/src/test/java/com/glencoesoftware/bioformats2raw/test/ZarrV3Test.java
index 1976847d..5a0ceda2 100644
--- a/src/test/java/com/glencoesoftware/bioformats2raw/test/ZarrV3Test.java
+++ b/src/test/java/com/glencoesoftware/bioformats2raw/test/ZarrV3Test.java
@@ -83,7 +83,7 @@ public void testDefault() throws Exception {
     rootGroup = Group.open(store.resolve("0"));
     attrs = rootGroup.metadata().attributes;
     omeAttrs = attrs.getAttributes("ome");
-    assertEquals("0.5", omeAttrs.get("version"));
+    assertEquals(getNGFFVersion(), omeAttrs.get("version"));
 
     List<Map<String, Object>> multiscales =
       (List<Map<String, Object>>) omeAttrs.get("multiscales");
diff --git a/src/test/resources/com/glencoesoftware/bioformats2raw/test/mini-flim-moduloC.ome.tiff b/src/test/resources/com/glencoesoftware/bioformats2raw/test/mini-flim-moduloC.ome.tiff
new file mode 100755
index 00000000..c15135e8
Binary files /dev/null and b/src/test/resources/com/glencoesoftware/bioformats2raw/test/mini-flim-moduloC.ome.tiff differ
diff --git a/src/test/resources/com/glencoesoftware/bioformats2raw/test/mini-flim-moduloT.ome.tiff b/src/test/resources/com/glencoesoftware/bioformats2raw/test/mini-flim-moduloT.ome.tiff
new file mode 100755
index 00000000..f62177a3
Binary files /dev/null and b/src/test/resources/com/glencoesoftware/bioformats2raw/test/mini-flim-moduloT.ome.tiff differ
diff --git a/src/test/resources/com/glencoesoftware/bioformats2raw/test/mini-spim-moduloZ.ome.tiff b/src/test/resources/com/glencoesoftware/bioformats2raw/test/mini-spim-moduloZ.ome.tiff
new file mode 100755
index 00000000..7d7edd9d
Binary files /dev/null and b/src/test/resources/com/glencoesoftware/bioformats2raw/test/mini-spim-moduloZ.ome.tiff differ