diff --git a/main.c b/main.c
index 9724f27..aa3eb2c 100644
--- a/main.c
+++ b/main.c
@@ -5,9 +5,9 @@
 int main() {
 
     size_t shape[] = {20, 20, 20};
-    size_t chunks[] = {10, 10, 10};
-    size_t offset[] = {0, 0, 0};
-    size_t offset2[] = {10, 10, 10};
+    size_t count[] = {10, 10, 10};
+    size_t start[] = {0, 0, 0};
+    size_t start2[] = {10, 10, 10};
     float data1[10][10][10];
     float data2[10][10][10];
     float rdata[10][10][10];
@@ -15,17 +15,17 @@ int main() {
     long long int idata2[10][10][10];
     long long int irdata[10][10][10];
     unsigned int ndim = 3;
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++){
-            for (int k = 0; k<chunks[2]; k++){ 
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++){
+            for (int k = 0; k<count[2]; k++){ 
                 data1[i][j][k]=rand()%1000+1;
                 idata1[i][j][k]=rand()%1000+1;
             }    
         }
     }
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++){
-            for (int k = 0; k<chunks[2]; k++){ 
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++){
+            for (int k = 0; k<count[2]; k++){ 
                 data2[i][j][k]=rand()%1000+1;
                 idata2[i][j][k]=rand()%1000+1;
             }    
@@ -34,49 +34,49 @@ int main() {
     char* arrayName = "test_c.z5";
     int cusezlib = 1;
     int level = 1;
-    z5CreateFloat32Dataset(arrayName, ndim, shape, chunks, cusezlib, level);
-    z5WriteFloat32Subarray(arrayName, data1, ndim, chunks, offset);
-    z5ReadFloat32Subarray(arrayName, rdata, ndim, chunks, offset);
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++) 
-                assert(data1[i][j][k] == rdata[i][j][k]); 
+    z5CreateFloat32Dataset(arrayName, ndim, shape, count, cusezlib, level);
+    z5WriteFloat32Subarray(arrayName, data1, ndim, count, start);
+    z5ReadFloat32Subarray(arrayName, rdata, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
+                assert(data1[i][j][k] == rdata[i][j][k]);
         printf("data1 = %f\n",data1[i][0][0]);
     }
-    z5WriteFloat32Subarray("test_c.z5", data2, ndim, chunks, offset2);
-    z5ReadFloat32Subarray("test_c.z5", rdata, ndim, chunks, offset2);
+    z5WriteFloat32Subarray("test_c.z5", data2, ndim, count, start2);
+    z5ReadFloat32Subarray("test_c.z5", rdata, ndim, count, start2);
     printf("after read float\n");
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++) 
-                assert(data2[i][j][k] == rdata[i][j][k]); 
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
+                assert(data2[i][j][k] == rdata[i][j][k]);
         printf("data2 = %f\n",data2[i][0][0]);
     }
     printf("after assert\n");
 
     char* iarrayName = "test_c_int64.z5";
-    z5CreateInt64Dataset(iarrayName, ndim, shape, chunks, cusezlib, level);
-    z5WriteInt64Subarray(iarrayName, idata1, ndim, chunks, offset);
-    z5ReadInt64Subarray(iarrayName, irdata, ndim, chunks, offset); 
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++) 
-                assert(idata1[i][j][k] == irdata[i][j][k]); 
+    z5CreateInt64Dataset(iarrayName, ndim, shape, count, cusezlib, level);
+    z5WriteInt64Subarray(iarrayName, idata1, ndim, count, start);
+    z5ReadInt64Subarray(iarrayName, irdata, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
+                assert(idata1[i][j][k] == irdata[i][j][k]);
         printf("idata1 = %lu\n",idata1[i][0][0]);
     }
-    z5WriteInt64Subarray(iarrayName, idata2, ndim, chunks, offset2);
-    z5ReadInt64Subarray(iarrayName, irdata, ndim, chunks, offset2); 
+    z5WriteInt64Subarray(iarrayName, idata2, ndim, count, start2);
+    z5ReadInt64Subarray(iarrayName, irdata, ndim, count, start2);
     printf("after read float\n");
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++) 
-                assert(idata2[i][j][k] == irdata[i][j][k]); 
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
+                assert(idata2[i][j][k] == irdata[i][j][k]);
         printf("idata2 = %lu\n",idata2[i][0][0]);
     }
     printf("after assert\n");
-    size_t chunkSize0=z5GetFileSize("test_c_int64.z5/0.0.0");
-    size_t chunkSize1=z5GetFileSize("test_c_int64.z5/1.1.1");
-    printf("size = %lu, %lu\n",chunkSize0,chunkSize1);
+    size_t countize0=z5GetFileSize("test_c_int64.z5/0.0.0");
+    size_t countize1=z5GetFileSize("test_c_int64.z5/1.1.1");
+    printf("size = %lu, %lu\n",countize0,countize1);
     z5Delete("test_c_int64.z5");
     return 0;
 }
diff --git a/test_attributes.c b/test_attributes.c
index 4db2bfc..95379ae 100644
--- a/test_attributes.c
+++ b/test_attributes.c
@@ -5,9 +5,9 @@
 void my_create_dataset(char* arrayName)
 {
     size_t shape[] = {20, 20, 20};
-    size_t chunks[] = {10, 10, 10};
-    size_t offset[] = {0, 0, 0};
-    size_t offset2[] = {10, 10, 10};
+    size_t count[] = {10, 10, 10};
+    size_t start[] = {0, 0, 0};
+    size_t start2[] = {10, 10, 10};
     float data1[10][10][10];
     float data2[10][10][10];
     float rdata[10][10][10];
@@ -33,9 +33,9 @@ void my_create_dataset(char* arrayName)
     uint64_t ui64data[10][10][10];
     uint64_t rui64data[10][10][10];
     unsigned int ndim = 3;
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++){
-            for (int k = 0; k<chunks[2]; k++){
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++){
+            for (int k = 0; k<count[2]; k++){
                 data1[i][j][k]=rand()%1000+1;
                 idata1[i][j][k]=rand()%1000+1;
                 data2[i][j][k]=rand()%1000+1;
@@ -53,168 +53,168 @@ void my_create_dataset(char* arrayName)
     }
     int cusezlib = 1;
     int level = 1;
-    z5CreateFloat32Dataset(arrayName, ndim, shape, chunks, cusezlib, level);
-    z5WriteFloat32Subarray(arrayName, data1, ndim, chunks, offset);
-    z5ReadFloat32Subarray(arrayName, rdata, ndim, chunks, offset);
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++)
+    z5CreateFloat32Dataset(arrayName, ndim, shape, count, cusezlib, level);
+    z5WriteFloat32Subarray(arrayName, data1, ndim, count, start);
+    z5ReadFloat32Subarray(arrayName, rdata, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
                 assert(data1[i][j][k] == rdata[i][j][k]);
     }
-    z5WriteFloat32Subarray(arrayName, data2, ndim, chunks, offset2);
-    z5ReadFloat32Subarray(arrayName, rdata, ndim, chunks, offset2);
+    z5WriteFloat32Subarray(arrayName, data2, ndim, count, start2);
+    z5ReadFloat32Subarray(arrayName, rdata, ndim, count, start2);
     printf("after read float\n");
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++)
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
                 assert(data2[i][j][k] == rdata[i][j][k]);
         printf("data2 = %f\n",data2[i][0][0]);
     }
     z5writeAttributesString(arrayName, "time", "noon");
-    
+
     float floatval = 42.0;
     z5writeAttributesfloat(arrayName, "float", &floatval);
-    
+
     double doubleval = 42.0;
     z5writeAttributesdouble(arrayName, "double", &doubleval);
-    
+
     int intval = 42;
     z5writeAttributesint(arrayName, "int", &intval);
-    
+
     long int longval = 42;
     z5writeAttributeslong(arrayName, "long", &longval);
-   
+
     long long longlongval = 42;
     z5writeAttributeslonglong(arrayName, "longlong", &longlongval);
-    
+
     unsigned long long ulonglongval = 42;
     z5writeAttributesulonglong(arrayName, "ulonglong", &ulonglongval);
-    
+
     unsigned short ushortval = 42;
     z5writeAttributesushort(arrayName, "unshort", &ushortval);
-   
+
     unsigned int uint = 42;
     z5writeAttributesuint(arrayName, "uint", &uint);
 
     unsigned short usint = 42;
     z5writeAttributesusint(arrayName, "usint", &usint);
- 
+
     short shortint = 42;
     z5writeAttributesshort(arrayName, "short", &shortint);
 
     // testing read all attributes
     z5readAttributes(arrayName);
-    
+
     // testing read attributes by providing keys
     char *keysinput[2] = {"uint", "double"};
-    z5readAttributesWithKeys(arrayName, keysinput, 2); 
-    
+    z5readAttributesWithKeys(arrayName, keysinput, 2);
+
     printf("after assert\n");
 
     printf("testing different array types\n");
 
 
     char* float64arrayName = "new_file/group1/float64variables";
-    z5CreateFloat64Dataset(float64arrayName, ndim, shape, chunks, cusezlib, level);
+    z5CreateFloat64Dataset(float64arrayName, ndim, shape, count, cusezlib, level);
     printf("===successfully creat Float64Dataset===\n");
-    z5WriteFloat64Subarray(float64arrayName, ddata, ndim, chunks, offset);
+    z5WriteFloat64Subarray(float64arrayName, ddata, ndim, count, start);
     printf("===successfully write Float64Dataset===\n");
-    z5ReadFloat64Subarray(float64arrayName, rddata, ndim, chunks, offset);
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++)
+    z5ReadFloat64Subarray(float64arrayName, rddata, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
                 assert(ddata[i][j][k] == rddata[i][j][k]);
     }
     printf("===successfully read Float64Dataset===\n");
 
 
     char* int8arrayName = "new_file/group1/int8variables";
-    z5CreateInt8Dataset(int8arrayName, ndim, shape, chunks, cusezlib, level);
+    z5CreateInt8Dataset(int8arrayName, ndim, shape, count, cusezlib, level);
     printf("===successfully creat Int8Dataset===\n");
-    z5WriteInt8Subarray(int8arrayName, i8data, ndim, chunks, offset);
+    z5WriteInt8Subarray(int8arrayName, i8data, ndim, count, start);
     printf("===successfully write Int8Dataset===\n");
-    z5ReadInt8Subarray(int8arrayName, ri8data, ndim, chunks, offset);
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++)
+    z5ReadInt8Subarray(int8arrayName, ri8data, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
                 assert(i8data[i][j][k] == ri8data[i][j][k]);
     }
     printf("===successfully read Int8Dataset===\n");
 
     char* int16arrayName = "new_file/group1/int16variables";
-    z5CreateInt16Dataset(int16arrayName, ndim, shape, chunks, cusezlib, level);
+    z5CreateInt16Dataset(int16arrayName, ndim, shape, count, cusezlib, level);
     printf("===successfully creat Int16Dataset===\n");
-    z5WriteInt16Subarray(int16arrayName, i16data, ndim, chunks, offset);
+    z5WriteInt16Subarray(int16arrayName, i16data, ndim, count, start);
     printf("===successfully write Int16Dataset===\n");
-    z5ReadInt16Subarray(int16arrayName, ri16data, ndim, chunks, offset);
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++)
+    z5ReadInt16Subarray(int16arrayName, ri16data, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
                 assert(i16data[i][j][k] == ri16data[i][j][k]);
     }
     printf("===successfully read Int16Dataset===\n");
 
     char* int32arrayName = "new_file/group1/int32variables";
-    z5CreateInt32Dataset(int32arrayName, ndim, shape, chunks, cusezlib, level);
+    z5CreateInt32Dataset(int32arrayName, ndim, shape, count, cusezlib, level);
     printf("===successfully creat Int32Dataset===\n");
-    z5WriteInt32Subarray(int32arrayName, i32data, ndim, chunks, offset);
+    z5WriteInt32Subarray(int32arrayName, i32data, ndim, count, start);
     printf("===successfully write Int32Dataset===\n");
-    z5ReadInt32Subarray(int32arrayName, ri32data, ndim, chunks, offset);
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++)
+    z5ReadInt32Subarray(int32arrayName, ri32data, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
                 assert(i32data[i][j][k] == ri32data[i][j][k]);
     }
     printf("===successfully read Int32Dataset===\n");
 
     char* uint8arrayName = "new_file/group1/uint8variables";
-    z5CreateUInt8Dataset(uint8arrayName, ndim, shape, chunks, cusezlib, level);
+    z5CreateUInt8Dataset(uint8arrayName, ndim, shape, count, cusezlib, level);
     printf("===successfully creat UInt8Dataset===\n");
-    z5WriteUInt8Subarray(uint8arrayName, ui8data, ndim, chunks, offset);
+    z5WriteUInt8Subarray(uint8arrayName, ui8data, ndim, count, start);
     printf("===successfully write UInt8Dataset===\n");
-    z5ReadUInt8Subarray(uint8arrayName, rui8data, ndim, chunks, offset);
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++)
+    z5ReadUInt8Subarray(uint8arrayName, rui8data, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
                 assert(ui8data[i][j][k] == rui8data[i][j][k]);
     }
     printf("===successfully read UInt8Dataset===\n");
 
     char* uint16arrayName = "new_file/group1/uint16variables";
-    z5CreateUInt16Dataset(uint16arrayName, ndim, shape, chunks, cusezlib, level);
+    z5CreateUInt16Dataset(uint16arrayName, ndim, shape, count, cusezlib, level);
     printf("===successfully creat UInt16Dataset===\n");
-    z5WriteUInt16Subarray(uint16arrayName, ui16data, ndim, chunks, offset);
+    z5WriteUInt16Subarray(uint16arrayName, ui16data, ndim, count, start);
     printf("===successfully write UInt16Dataset===\n");
-    z5ReadUInt16Subarray(uint16arrayName, rui16data, ndim, chunks, offset);
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++)
+    z5ReadUInt16Subarray(uint16arrayName, rui16data, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
                 assert(ui16data[i][j][k] == rui16data[i][j][k]);
     }
     printf("===successfully read UInt16Dataset===\n");
 
     char* uint32arrayName = "new_file/group1/uint32variables";
-    z5CreateUInt32Dataset(uint32arrayName, ndim, shape, chunks, cusezlib, level);
+    z5CreateUInt32Dataset(uint32arrayName, ndim, shape, count, cusezlib, level);
     printf("===successfully creat UInt32Dataset===\n");
-    z5WriteUInt32Subarray(uint32arrayName, ui32data, ndim, chunks, offset);
+    z5WriteUInt32Subarray(uint32arrayName, ui32data, ndim, count, start);
     printf("===successfully write UInt32Dataset===\n");
-    z5ReadUInt32Subarray(uint32arrayName, rui32data, ndim, chunks, offset);
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++)
+    z5ReadUInt32Subarray(uint32arrayName, rui32data, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
                 assert(ui32data[i][j][k] == rui32data[i][j][k]);
     }
     printf("===successfully read UInt32Dataset===\n");
 
     char* uint64arrayName = "new_file/group1/uint64variables";
-    z5CreateUInt64Dataset(uint64arrayName, ndim, shape, chunks, cusezlib, level);
+    z5CreateUInt64Dataset(uint64arrayName, ndim, shape, count, cusezlib, level);
     printf("===successfully creat UInt64Dataset===\n");
-    z5WriteUInt64Subarray(uint64arrayName, ui64data, ndim, chunks, offset);
+    z5WriteUInt64Subarray(uint64arrayName, ui64data, ndim, count, start);
     printf("===successfully write UInt64Dataset===\n");
-    z5ReadUInt64Subarray(uint64arrayName, rui64data, ndim, chunks, offset);
-    for (int i = 0; i < chunks[0]; i++){
-        for (int j = 0; j < chunks[1]; j++)
-            for (int k = 0; k<chunks[2]; k++)
+    z5ReadUInt64Subarray(uint64arrayName, rui64data, ndim, count, start);
+    for (int i = 0; i < count[0]; i++){
+        for (int j = 0; j < count[1]; j++)
+            for (int k = 0; k<count[2]; k++)
                 assert(ui64data[i][j][k] == rui64data[i][j][k]);
     }
     printf("===successfully read UInt64Dataset===\n");
diff --git a/z5wrapper.cc b/z5wrapper.cc
index 30e715e..64c9a29 100644
--- a/z5wrapper.cc
+++ b/z5wrapper.cc
@@ -25,14 +25,14 @@ namespace z5 {
         handle::Group cGroup(path_s);
         createGroup(cGroup, asZarr);
     } 
-    void z5CreateFloat32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level) {
+    void z5CreateFloat32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level) {
         std::string path_s(path);
         std::vector<std::string> dtype({"float32"});
         std::vector<size_t> shape_v(shape, shape + ndim);
-        std::vector<size_t> chunks_v(chunks, chunks + ndim);
+        std::vector<size_t> count_v(count, count + ndim);
         bool asZarr = true;
  
-        DatasetMetadata floatMeta(types::Datatype::float32,shape_v,chunks_v,asZarr);
+        DatasetMetadata floatMeta(types::Datatype::float32,shape_v,count_v,asZarr);
         if (cuseZlib) {
           floatMeta.compressor = types::zlib;
           floatMeta.compressionOptions["useZlib"] = true;
@@ -44,41 +44,41 @@ namespace z5 {
 
     }
 
-    void z5WriteFloat32Subarray(char *path, float *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5WriteFloat32Subarray(char *path, float *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds =openDataset(path_s);
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size=size*(*i);
-        xt::xarray<float> adp_array=xt::adapt(array,size,xt::no_ownership(),shape_v);
-        std::vector<size_t> offset_v(offset,offset + ndim);
-        multiarray::writeSubarray<float>(ds,adp_array,offset_v.begin());
+        xt::xarray<float> adp_array=xt::adapt(array,size,xt::no_ownership(),count_v);
+        std::vector<size_t> start_v(start,start + ndim);
+        multiarray::writeSubarray<float>(ds,adp_array,start_v.begin());
     }
 
-    void z5ReadFloat32Subarray(char *path, float *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5ReadFloat32Subarray(char *path, float *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds = openDataset(path_s);
         using vec_type = std::vector<float>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size*=(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::readSubarray<float>(ds,adp_array,offset_v.begin());
+        multiarray::readSubarray<float>(ds,adp_array,start_v.begin());
     }
 
-    void z5CreateFloat64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level) {
+    void z5CreateFloat64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level) {
         std::string path_s(path);
         std::vector<std::string> dtype({"float64"});
         std::vector<size_t> shape_v(shape, shape + ndim);
-        std::vector<size_t> chunks_v(chunks, chunks + ndim);
+        std::vector<size_t> count_v(count, count + ndim);
         bool asZarr = true;
     
-        DatasetMetadata floatMeta(types::Datatype::float64,shape_v,chunks_v,asZarr);
+        DatasetMetadata floatMeta(types::Datatype::float64,shape_v,count_v,asZarr);
         if (cuseZlib) {
           floatMeta.compressor = types::zlib;
           floatMeta.compressionOptions["useZlib"] = true;
@@ -90,41 +90,41 @@ namespace z5 {
     
     }
 
-    void z5WriteFloat64Subarray(char *path, double *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5WriteFloat64Subarray(char *path, double *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds =openDataset(path_s);
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size=size*(*i);
-        xt::xarray<double> adp_array=xt::adapt(array,size,xt::no_ownership(),shape_v);
-        std::vector<size_t> offset_v(offset,offset + ndim);
-        multiarray::writeSubarray<double>(ds,adp_array,offset_v.begin());
+        xt::xarray<double> adp_array=xt::adapt(array,size,xt::no_ownership(),count_v);
+        std::vector<size_t> start_v(start,start + ndim);
+        multiarray::writeSubarray<double>(ds,adp_array,start_v.begin());
     }
 
-    void z5ReadFloat64Subarray(char *path, double *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5ReadFloat64Subarray(char *path, double *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds = openDataset(path_s);
         using vec_type = std::vector<float>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size*=(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::readSubarray<double>(ds,adp_array,offset_v.begin());
+        multiarray::readSubarray<double>(ds,adp_array,start_v.begin());
     }
 
-    void z5CreateInt8Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level) {
+    void z5CreateInt8Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level) {
         std::string path_s(path);
 
         std::vector<size_t> shape_v(shape, shape + ndim);
-        std::vector<size_t> chunks_v(chunks, chunks + ndim);
+        std::vector<size_t> count_v(count, count + ndim);
         bool asZarr = true;
 
-        DatasetMetadata int8Meta(types::Datatype::int8,shape_v,chunks_v,asZarr);
+        DatasetMetadata int8Meta(types::Datatype::int8,shape_v,count_v,asZarr);
         if (cuseZlib) {
             int8Meta.compressor = types::zlib;
             int8Meta.compressionOptions["useZlib"] = true;
@@ -135,44 +135,44 @@ namespace z5 {
         writeMetadata(handle_, int8Meta);
     }
 
-    void z5WriteInt8Subarray(char *path, int8_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5WriteInt8Subarray(char *path, int8_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds =openDataset(path_s);
         using vec_type = std::vector<int8_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size=size*(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::writeSubarray<int8_t>(ds,adp_array,offset_v.begin());
+        multiarray::writeSubarray<int8_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5ReadInt8Subarray(char *path, int8_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5ReadInt8Subarray(char *path, int8_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds = openDataset(path_s);
         using vec_type = std::vector<int8_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size*=(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::readSubarray<int8_t>(ds,adp_array,offset_v.begin());
+        multiarray::readSubarray<int8_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5CreateInt16Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level) {
+    void z5CreateInt16Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level) {
         std::string path_s(path);
 
         std::vector<size_t> shape_v(shape, shape + ndim);
-        std::vector<size_t> chunks_v(chunks, chunks + ndim);
+        std::vector<size_t> count_v(count, count + ndim);
         bool asZarr = true;
 
-        DatasetMetadata int16Meta(types::Datatype::int16,shape_v,chunks_v,asZarr);
+        DatasetMetadata int16Meta(types::Datatype::int16,shape_v,count_v,asZarr);
         if (cuseZlib) {
             int16Meta.compressor = types::zlib;
             int16Meta.compressionOptions["useZlib"] = true;
@@ -183,44 +183,44 @@ namespace z5 {
         writeMetadata(handle_, int16Meta);
     }
 
-    void z5WriteInt16Subarray(char *path, int16_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5WriteInt16Subarray(char *path, int16_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds =openDataset(path_s);
         using vec_type = std::vector<int16_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size=size*(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::writeSubarray<int16_t>(ds,adp_array,offset_v.begin());
+        multiarray::writeSubarray<int16_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5ReadInt16Subarray(char *path, int16_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5ReadInt16Subarray(char *path, int16_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds = openDataset(path_s);
         using vec_type = std::vector<int16_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size*=(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::readSubarray<int16_t>(ds,adp_array,offset_v.begin());
+        multiarray::readSubarray<int16_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5CreateInt32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level) {
+    void z5CreateInt32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level) {
         std::string path_s(path);
 
         std::vector<size_t> shape_v(shape, shape + ndim);
-        std::vector<size_t> chunks_v(chunks, chunks + ndim);
+        std::vector<size_t> count_v(count, count + ndim);
         bool asZarr = true;
 
-        DatasetMetadata int32Meta(types::Datatype::int32,shape_v,chunks_v,asZarr);
+        DatasetMetadata int32Meta(types::Datatype::int32,shape_v,count_v,asZarr);
         if (cuseZlib) {
             int32Meta.compressor = types::zlib;
             int32Meta.compressionOptions["useZlib"] = true;
@@ -231,44 +231,44 @@ namespace z5 {
         writeMetadata(handle_, int32Meta);
     }
 
-    void z5WriteInt32Subarray(char *path, int32_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5WriteInt32Subarray(char *path, int32_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds =openDataset(path_s);
         using vec_type = std::vector<int32_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size=size*(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::writeSubarray<int32_t>(ds,adp_array,offset_v.begin());
+        multiarray::writeSubarray<int32_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5ReadInt32Subarray(char *path, int32_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5ReadInt32Subarray(char *path, int32_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds = openDataset(path_s);
         using vec_type = std::vector<int32_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size*=(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::readSubarray<int32_t>(ds,adp_array,offset_v.begin());
+        multiarray::readSubarray<int32_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5CreateInt64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level) {
+    void z5CreateInt64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level) {
         std::string path_s(path);
 
         std::vector<size_t> shape_v(shape, shape + ndim);
-        std::vector<size_t> chunks_v(chunks, chunks + ndim);
+        std::vector<size_t> count_v(count, count + ndim);
         bool asZarr = true;
 
-        DatasetMetadata int64Meta(types::Datatype::int64,shape_v,chunks_v,asZarr);
+        DatasetMetadata int64Meta(types::Datatype::int64,shape_v,count_v,asZarr);
         if (cuseZlib) {
             int64Meta.compressor = types::zlib;
             int64Meta.compressionOptions["useZlib"] = true;
@@ -279,44 +279,44 @@ namespace z5 {
         writeMetadata(handle_, int64Meta);
     }
 
-    void z5WriteInt64Subarray(char *path, long long int *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5WriteInt64Subarray(char *path, long long int *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds =openDataset(path_s);
         using vec_type = std::vector<long int>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size=size*(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::writeSubarray<long int>(ds,adp_array,offset_v.begin());
+        multiarray::writeSubarray<long int>(ds,adp_array,start_v.begin());
     }
 
-    void z5ReadInt64Subarray(char *path, long long int *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5ReadInt64Subarray(char *path, long long int *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds = openDataset(path_s);
         using vec_type = std::vector<long int>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size*=(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::readSubarray<long int>(ds,adp_array,offset_v.begin());
+        multiarray::readSubarray<long int>(ds,adp_array,start_v.begin());
     }
 
-    void z5CreateUInt8Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level) {
+    void z5CreateUInt8Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level) {
         std::string path_s(path);
 
         std::vector<size_t> shape_v(shape, shape + ndim);
-        std::vector<size_t> chunks_v(chunks, chunks + ndim);
+        std::vector<size_t> count_v(count, count + ndim);
         bool asZarr = true;
 
-        DatasetMetadata uint8Meta(types::Datatype::uint8,shape_v,chunks_v,asZarr);
+        DatasetMetadata uint8Meta(types::Datatype::uint8,shape_v,count_v,asZarr);
         if (cuseZlib) {
             uint8Meta.compressor = types::zlib;
             uint8Meta.compressionOptions["useZlib"] = true;
@@ -327,44 +327,44 @@ namespace z5 {
         writeMetadata(handle_, uint8Meta);
     }
 
-    void z5WriteUInt8Subarray(char *path, uint8_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5WriteUInt8Subarray(char *path, uint8_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds =openDataset(path_s);
         using vec_type = std::vector<uint8_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size=size*(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::writeSubarray<uint8_t>(ds,adp_array,offset_v.begin());
+        multiarray::writeSubarray<uint8_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5ReadUInt8Subarray(char *path, uint8_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5ReadUInt8Subarray(char *path, uint8_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds = openDataset(path_s);
         using vec_type = std::vector<uint8_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size*=(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::readSubarray<uint8_t>(ds,adp_array,offset_v.begin());
+        multiarray::readSubarray<uint8_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5CreateUInt16Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level) {
+    void z5CreateUInt16Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level) {
         std::string path_s(path);
 
         std::vector<size_t> shape_v(shape, shape + ndim);
-        std::vector<size_t> chunks_v(chunks, chunks + ndim);
+        std::vector<size_t> count_v(count, count + ndim);
         bool asZarr = true;
 
-        DatasetMetadata uint16Meta(types::Datatype::uint16,shape_v,chunks_v,asZarr);
+        DatasetMetadata uint16Meta(types::Datatype::uint16,shape_v,count_v,asZarr);
         if (cuseZlib) {
             uint16Meta.compressor = types::zlib;
             uint16Meta.compressionOptions["useZlib"] = true;
@@ -375,44 +375,44 @@ namespace z5 {
         writeMetadata(handle_, uint16Meta);
     }
 
-    void z5WriteUInt16Subarray(char *path, uint16_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5WriteUInt16Subarray(char *path, uint16_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds =openDataset(path_s);
         using vec_type = std::vector<uint16_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size=size*(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::writeSubarray<uint16_t>(ds,adp_array,offset_v.begin());
+        multiarray::writeSubarray<uint16_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5ReadUInt16Subarray(char *path, uint16_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5ReadUInt16Subarray(char *path, uint16_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds = openDataset(path_s);
         using vec_type = std::vector<uint16_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size*=(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::readSubarray<uint16_t>(ds,adp_array,offset_v.begin());
+        multiarray::readSubarray<uint16_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5CreateUInt32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level) {
+    void z5CreateUInt32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level) {
         std::string path_s(path);
 
         std::vector<size_t> shape_v(shape, shape + ndim);
-        std::vector<size_t> chunks_v(chunks, chunks + ndim);
+        std::vector<size_t> count_v(count, count + ndim);
         bool asZarr = true;
 
-        DatasetMetadata uint32Meta(types::Datatype::uint32,shape_v,chunks_v,asZarr);
+        DatasetMetadata uint32Meta(types::Datatype::uint32,shape_v,count_v,asZarr);
         if (cuseZlib) {
             uint32Meta.compressor = types::zlib;
             uint32Meta.compressionOptions["useZlib"] = true;
@@ -423,44 +423,44 @@ namespace z5 {
         writeMetadata(handle_, uint32Meta);
     }
 
-    void z5WriteUInt32Subarray(char *path, uint32_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5WriteUInt32Subarray(char *path, uint32_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds =openDataset(path_s);
         using vec_type = std::vector<uint32_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size=size*(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::writeSubarray<uint32_t>(ds,adp_array,offset_v.begin());
+        multiarray::writeSubarray<uint32_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5ReadUInt32Subarray(char *path, uint32_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5ReadUInt32Subarray(char *path, uint32_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds = openDataset(path_s);
         using vec_type = std::vector<uint32_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size*=(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::readSubarray<uint32_t>(ds,adp_array,offset_v.begin());
+        multiarray::readSubarray<uint32_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5CreateUInt64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level) {
+    void z5CreateUInt64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level) {
         std::string path_s(path);
 
         std::vector<size_t> shape_v(shape, shape + ndim);
-        std::vector<size_t> chunks_v(chunks, chunks + ndim);
+        std::vector<size_t> count_v(count, count + ndim);
         bool asZarr = true;
 
-        DatasetMetadata uint64Meta(types::Datatype::uint64,shape_v,chunks_v,asZarr);
+        DatasetMetadata uint64Meta(types::Datatype::uint64,shape_v,count_v,asZarr);
         if (cuseZlib) {
             uint64Meta.compressor = types::zlib;
             uint64Meta.compressionOptions["useZlib"] = true;
@@ -471,34 +471,34 @@ namespace z5 {
         writeMetadata(handle_, uint64Meta);
     }
 
-    void z5WriteUInt64Subarray(char *path, uint64_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5WriteUInt64Subarray(char *path, uint64_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds =openDataset(path_s);
         using vec_type = std::vector<uint64_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size=size*(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::writeSubarray<uint64_t>(ds,adp_array,offset_v.begin());
+        multiarray::writeSubarray<uint64_t>(ds,adp_array,start_v.begin());
     }
 
-    void z5ReadUInt64Subarray(char *path, uint64_t *array, unsigned int ndim, size_t *shape, size_t *offset) {
+    void z5ReadUInt64Subarray(char *path, uint64_t *array, unsigned int ndim, size_t *count, size_t *start) {
         std::string path_s(path);
         auto ds = openDataset(path_s);
         using vec_type = std::vector<uint64_t>;
         size_t size = 1;
-        std::vector<std::size_t> shape_v(shape,shape + ndim);
-        for (std::vector<size_t>::const_iterator i = shape_v.begin(); i != shape_v.end(); ++i)
+        std::vector<std::size_t> count_v(count,count + ndim);
+        for (std::vector<size_t>::const_iterator i = count_v.begin(); i != count_v.end(); ++i)
             size*=(*i);
-        using shape_type = std::vector<vec_type::size_type>;
-        shape_type s(shape,shape+ndim);
-        std::vector<size_t> offset_v(offset,offset + ndim);
+        using count_type = std::vector<vec_type::size_type>;
+        count_type s(count,count+ndim);
+        std::vector<size_t> start_v(start,start + ndim);
         auto adp_array=xt::adapt(array,size,xt::no_ownership(),s);
-        multiarray::readSubarray<uint64_t>(ds,adp_array,offset_v.begin());
+        multiarray::readSubarray<uint64_t>(ds,adp_array,start_v.begin());
     }
 
     size_t z5GetFileSize(char *path){
diff --git a/z5wrapper.h b/z5wrapper.h
index 7ef6029..9e641f5 100644
--- a/z5wrapper.h
+++ b/z5wrapper.h
@@ -29,54 +29,54 @@ namespace z5 {
         void z5CreateGroup(char* path);
 
         // float 32
-        void z5CreateFloat32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level);
-        void z5WriteFloat32Subarray(char *path, float *array, unsigned int ndim, size_t *shape, size_t *offset);
-        void z5ReadFloat32Subarray(char *path, float *array, unsigned int ndim, size_t *shape, size_t *offset);
+        void z5CreateFloat32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level);
+        void z5WriteFloat32Subarray(char *path, float *array, unsigned int ndim, size_t *count, size_t *start);
+        void z5ReadFloat32Subarray(char *path, float *array, unsigned int ndim, size_t *count, size_t *start);
 
         // float 64 / double
-        void z5CreateFloat64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level);
-        void z5WriteFloat64Subarray(char *path, double *array, unsigned int ndim, size_t *shape, size_t *offset);
-        void z5ReadFloat64Subarray(char *path, double *array, unsigned int ndim, size_t *shape, size_t *offset);
+        void z5CreateFloat64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level);
+        void z5WriteFloat64Subarray(char *path, double *array, unsigned int ndim, size_t *count, size_t *start);
+        void z5ReadFloat64Subarray(char *path, double *array, unsigned int ndim, size_t *count, size_t *start);
 
         // int8_t
-        void z5CreateInt8Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level);
-        void z5WriteInt8Subarray(char *path, int8_t *array, unsigned int ndim, size_t *shape, size_t *offset);
-        void z5ReadInt8Subarray(char *path, int8_t *array, unsigned int ndim, size_t *shape, size_t *offset);
+        void z5CreateInt8Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level);
+        void z5WriteInt8Subarray(char *path, int8_t *array, unsigned int ndim, size_t *count, size_t *start);
+        void z5ReadInt8Subarray(char *path, int8_t *array, unsigned int ndim, size_t *count, size_t *start);
 
         // int16_t
-        void z5CreateInt16Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level);
-        void z5WriteInt16Subarray(char *path, int16_t *array, unsigned int ndim, size_t *shape, size_t *offset);
-        void z5ReadInt16Subarray(char *path, int16_t *array, unsigned int ndim, size_t *shape, size_t *offset);
+        void z5CreateInt16Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level);
+        void z5WriteInt16Subarray(char *path, int16_t *array, unsigned int ndim, size_t *count, size_t *start);
+        void z5ReadInt16Subarray(char *path, int16_t *array, unsigned int ndim, size_t *count, size_t *start);
 
         // int32_t
-        void z5CreateInt32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level);
-        void z5WriteInt32Subarray(char *path, int32_t *array, unsigned int ndim, size_t *shape, size_t *offset);
-        void z5ReadInt32Subarray(char *path, int32_t *array, unsigned int ndim, size_t *shape, size_t *offset);
+        void z5CreateInt32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level);
+        void z5WriteInt32Subarray(char *path, int32_t *array, unsigned int ndim, size_t *count, size_t *start);
+        void z5ReadInt32Subarray(char *path, int32_t *array, unsigned int ndim, size_t *count, size_t *start);
 
         // int64
-        void z5CreateInt64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level);
-        void z5WriteInt64Subarray(char *path, long long int *array, unsigned int ndim, size_t *shape, size_t *offset);
-        void z5ReadInt64Subarray(char *path, long long int *array, unsigned int ndim, size_t *shape, size_t *offset);
+        void z5CreateInt64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level);
+        void z5WriteInt64Subarray(char *path, long long int *array, unsigned int ndim, size_t *count, size_t *start);
+        void z5ReadInt64Subarray(char *path, long long int *array, unsigned int ndim, size_t *count, size_t *start);
 
         // uint8_t
-        void z5CreateUInt8Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level);
-        void z5WriteUInt8Subarray(char *path, uint8_t *array, unsigned int ndim, size_t *shape, size_t *offset);
-        void z5ReadUInt8Subarray(char *path, uint8_t *array, unsigned int ndim, size_t *shape, size_t *offset);
+        void z5CreateUInt8Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level);
+        void z5WriteUInt8Subarray(char *path, uint8_t *array, unsigned int ndim, size_t *count, size_t *start);
+        void z5ReadUInt8Subarray(char *path, uint8_t *array, unsigned int ndim, size_t *count, size_t *start);
 
         // uint16_t
-        void z5CreateUInt16Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level);
-        void z5WriteUInt16Subarray(char *path, uint16_t *array, unsigned int ndim, size_t *shape, size_t *offset);
-        void z5ReadUInt16Subarray(char *path, uint16_t *array, unsigned int ndim, size_t *shape, size_t *offset);
+        void z5CreateUInt16Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level);
+        void z5WriteUInt16Subarray(char *path, uint16_t *array, unsigned int ndim, size_t *count, size_t *start);
+        void z5ReadUInt16Subarray(char *path, uint16_t *array, unsigned int ndim, size_t *count, size_t *start);
 
         // uint32_t
-        void z5CreateUInt32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level);
-        void z5WriteUInt32Subarray(char *path, uint32_t *array, unsigned int ndim, size_t *shape, size_t *offset);
-        void z5ReadUInt32Subarray(char *path, uint32_t *array, unsigned int ndim, size_t *shape, size_t *offset);
+        void z5CreateUInt32Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level);
+        void z5WriteUInt32Subarray(char *path, uint32_t *array, unsigned int ndim, size_t *count, size_t *start);
+        void z5ReadUInt32Subarray(char *path, uint32_t *array, unsigned int ndim, size_t *count, size_t *start);
 
         // uint64
-        void z5CreateUInt64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *chunks, int cuseZlib, int level);
-        void z5WriteUInt64Subarray(char *path, uint64_t *array, unsigned int ndim, size_t *shape, size_t *offset);
-        void z5ReadUInt64Subarray(char *path, uint64_t *array, unsigned int ndim, size_t *shape, size_t *offset);
+        void z5CreateUInt64Dataset(char *path, unsigned int ndim, size_t *shape, size_t *count, int cuseZlib, int level);
+        void z5WriteUInt64Subarray(char *path, uint64_t *array, unsigned int ndim, size_t *count, size_t *start);
+        void z5ReadUInt64Subarray(char *path, uint64_t *array, unsigned int ndim, size_t *count, size_t *start);
 
         size_t z5GetFileSize(char *path);