diff --git a/docs/release.rst b/docs/release.rst
index 7c73a02911..5929efb317 100644
--- a/docs/release.rst
+++ b/docs/release.rst
@@ -1,6 +1,20 @@
 Release notes
 =============
 
+.. _release_2.8.0:
+
+2.8.0
+-----
+
+V2 Specification Update
+~~~~~~~~~~~~~~~~~~~~~~~
+
+* Introduce optional dimension_separator .zarray key for nested chunks.
+  By :user:`Josh Moore <joshmoore>`; :issue:`715`, :issue:`716`.
+
+.. _release_2.7.0:
+
+
 .. _release_2.7.1:
 
 2.7.1
diff --git a/zarr/core.py b/zarr/core.py
index b6f82ff7d7..dded2fd74e 100644
--- a/zarr/core.py
+++ b/zarr/core.py
@@ -89,6 +89,7 @@ class Array:
     dtype
     compression
     compression_opts
+    dimension_separator
     fill_value
     order
     synchronizer
@@ -194,6 +195,7 @@ def _load_metadata_nosync(self):
             self._dtype = meta['dtype']
             self._fill_value = meta['fill_value']
             self._order = meta['order']
+            self._dimension_separator = meta.get('dimension_separator', '.')
 
             # setup compressor
             config = meta['compressor']
diff --git a/zarr/creation.py b/zarr/creation.py
index 6fbdaf04c1..d017ec921d 100644
--- a/zarr/creation.py
+++ b/zarr/creation.py
@@ -13,13 +13,14 @@
 from zarr.storage import (DirectoryStore, ZipStore, contains_array,
                           contains_group, default_compressor, init_array,
                           normalize_storage_path, FSStore)
+from zarr.util import normalize_dimension_separator
 
 
 def create(shape, chunks=True, dtype=None, compressor='default',
            fill_value=0, order='C', store=None, synchronizer=None,
            overwrite=False, path=None, chunk_store=None, filters=None,
            cache_metadata=True, cache_attrs=True, read_only=False,
-           object_codec=None, **kwargs):
+           object_codec=None, dimension_separator=None, **kwargs):
     """Create an array.
 
     Parameters
@@ -66,6 +67,9 @@ def create(shape, chunks=True, dtype=None, compressor='default',
         True if array should be protected against modification.
     object_codec : Codec, optional
         A codec to encode object arrays, only needed if dtype=object.
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
+        .. versionadded:: 2.8
 
     Returns
     -------
@@ -117,10 +121,16 @@ def create(shape, chunks=True, dtype=None, compressor='default',
     # API compatibility with h5py
     compressor, fill_value = _kwargs_compat(compressor, fill_value, kwargs)
 
+    # optional array metadata
+    if dimension_separator is None:
+        dimension_separator = getattr(store, "_dimension_separator", None)
+    dimension_separator = normalize_dimension_separator(dimension_separator)
+
     # initialize array metadata
     init_array(store, shape=shape, chunks=chunks, dtype=dtype, compressor=compressor,
                fill_value=fill_value, order=order, overwrite=overwrite, path=path,
-               chunk_store=chunk_store, filters=filters, object_codec=object_codec)
+               chunk_store=chunk_store, filters=filters, object_codec=object_codec,
+               dimension_separator=dimension_separator)
 
     # instantiate array
     z = Array(store, path=path, chunk_store=chunk_store, synchronizer=synchronizer,
diff --git a/zarr/hierarchy.py b/zarr/hierarchy.py
index 39dc82c724..89804d445b 100644
--- a/zarr/hierarchy.py
+++ b/zarr/hierarchy.py
@@ -783,6 +783,8 @@ def create_dataset(self, name, **kwargs):
             lifetime of the object. If False, array metadata will be reloaded
             prior to all data access and modification operations (may incur
             overhead depending on storage and data access pattern).
+        dimension_separator : {'.', '/'}, optional
+            Separator placed between the dimensions of a chunk.
 
         Returns
         -------
diff --git a/zarr/meta.py b/zarr/meta.py
index d1a1e43bbe..c8c5d77004 100644
--- a/zarr/meta.py
+++ b/zarr/meta.py
@@ -50,7 +50,9 @@ def decode_array_metadata(s: Union[MappingType, str]) -> MappingType[str, Any]:
             fill_value=fill_value,
             order=meta['order'],
             filters=meta['filters'],
+            dimension_separator=meta.get('dimension_separator', '.'),
         )
+
     except Exception as e:
         raise MetadataError('error decoding metadata: %s' % e)
     else:
@@ -62,6 +64,9 @@ def encode_array_metadata(meta: MappingType[str, Any]) -> bytes:
     sdshape = ()
     if dtype.subdtype is not None:
         dtype, sdshape = dtype.subdtype
+
+    dimension_separator = meta.get('dimension_separator')
+
     meta = dict(
         zarr_format=ZARR_FORMAT,
         shape=meta['shape'] + sdshape,
@@ -72,6 +77,10 @@ def encode_array_metadata(meta: MappingType[str, Any]) -> bytes:
         order=meta['order'],
         filters=meta['filters'],
     )
+
+    if dimension_separator:
+        meta['dimension_separator'] = dimension_separator
+
     return json_dumps(meta)
 
 
diff --git a/zarr/n5.py b/zarr/n5.py
index fa01005302..67e39357e7 100644
--- a/zarr/n5.py
+++ b/zarr/n5.py
@@ -355,6 +355,9 @@ def array_metadata_to_n5(array_metadata):
     compressor_config = compressor_config_to_n5(compressor_config)
     array_metadata['compression'] = compressor_config
 
+    if 'dimension_separator' in array_metadata:
+        del array_metadata['dimension_separator']
+
     return array_metadata
 
 
diff --git a/zarr/storage.py b/zarr/storage.py
index c332ee02f5..aa46e59e79 100644
--- a/zarr/storage.py
+++ b/zarr/storage.py
@@ -52,6 +52,7 @@
 )
 from zarr.meta import encode_array_metadata, encode_group_metadata
 from zarr.util import (buffer_size, json_loads, nolock, normalize_chunks,
+                       normalize_dimension_separator,
                        normalize_dtype, normalize_fill_value, normalize_order,
                        normalize_shape, normalize_storage_path, retry_call)
 
@@ -235,6 +236,7 @@ def init_array(
     chunk_store: MutableMapping = None,
     filters=None,
     object_codec=None,
+    dimension_separator=None,
 ):
     """Initialize an array store with the given configuration. Note that this is a low-level
     function and there should be no need to call this directly from user code.
@@ -267,6 +269,8 @@ def init_array(
         Sequence of filters to use to encode chunk data prior to compression.
     object_codec : Codec, optional
         A codec to encode object arrays, only needed if dtype=object.
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
 
     Examples
     --------
@@ -349,7 +353,8 @@ def init_array(
                          compressor=compressor, fill_value=fill_value,
                          order=order, overwrite=overwrite, path=path,
                          chunk_store=chunk_store, filters=filters,
-                         object_codec=object_codec)
+                         object_codec=object_codec,
+                         dimension_separator=dimension_separator)
 
 
 def _init_array_metadata(
@@ -365,6 +370,7 @@ def _init_array_metadata(
     chunk_store=None,
     filters=None,
     object_codec=None,
+    dimension_separator=None,
 ):
 
     # guard conditions
@@ -386,6 +392,11 @@ def _init_array_metadata(
     order = normalize_order(order)
     fill_value = normalize_fill_value(fill_value, dtype)
 
+    # optional array metadata
+    if dimension_separator is None:
+        dimension_separator = getattr(store, "_dimension_separator", None)
+    dimension_separator = normalize_dimension_separator(dimension_separator)
+
     # compressor prep
     if shape == ():
         # no point in compressing a 0-dimensional array, only a single value
@@ -433,7 +444,8 @@ def _init_array_metadata(
     # initialize metadata
     meta = dict(shape=shape, chunks=chunks, dtype=dtype,
                 compressor=compressor_config, fill_value=fill_value,
-                order=order, filters=filters_config)
+                order=order, filters=filters_config,
+                dimension_separator=dimension_separator)
     key = _path_to_prefix(path) + array_meta_key
     store[key] = encode_array_metadata(meta)
 
@@ -539,13 +551,14 @@ class MemoryStore(MutableMapping):
 
     """
 
-    def __init__(self, root=None, cls=dict):
+    def __init__(self, root=None, cls=dict, dimension_separator=None):
         if root is None:
             self.root = cls()
         else:
             self.root = root
         self.cls = cls
         self.write_mutex = Lock()
+        self._dimension_separator = dimension_separator
 
     def __getstate__(self):
         return self.root, self.cls
@@ -728,6 +741,8 @@ class DirectoryStore(MutableMapping):
         (e.g. 'foo' and 'FOO' will be treated as equivalent). This can be
         useful to avoid potential discrepancies between case-senstive and
         case-insensitive file system. Default value is False.
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
 
     Examples
     --------
@@ -774,7 +789,7 @@ class DirectoryStore(MutableMapping):
 
     """
 
-    def __init__(self, path, normalize_keys=False):
+    def __init__(self, path, normalize_keys=False, dimension_separator=None):
 
         # guard conditions
         path = os.path.abspath(path)
@@ -783,6 +798,7 @@ def __init__(self, path, normalize_keys=False):
 
         self.path = path
         self.normalize_keys = normalize_keys
+        self._dimension_separator = dimension_separator
 
     def _normalize_key(self, key):
         return key.lower() if self.normalize_keys else key
@@ -1012,30 +1028,44 @@ class FSStore(MutableMapping):
         like "s3://bucket/root"
     normalize_keys : bool
     key_separator : str
-        Character to use when constructing the target path strings
-        for data keys
+        public API for accessing dimension_separator. Never `None`
+        See dimension_separator for more information.
     mode : str
         "w" for writable, "r" for read-only
     exceptions : list of Exception subclasses
         When accessing data, any of these exceptions will be treated
         as a missing key
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
     storage_options : passed to the fsspec implementation
     """
 
     _META_KEYS = (attrs_key, group_meta_key, array_meta_key)
 
-    def __init__(self, url, normalize_keys=True, key_separator='.',
+    def __init__(self, url, normalize_keys=True, key_separator=None,
                  mode='w',
                  exceptions=(KeyError, PermissionError, IOError),
+                 dimension_separator=None,
                  **storage_options):
         import fsspec
         self.normalize_keys = normalize_keys
-        self.key_separator = key_separator
         self.map = fsspec.get_mapper(url, **storage_options)
         self.fs = self.map.fs  # for direct operations
         self.path = self.fs._strip_protocol(url)
         self.mode = mode
         self.exceptions = exceptions
+
+        # For backwards compatibility. Guaranteed to be non-None
+        if key_separator is not None:
+            dimension_separator = key_separator
+
+        self.key_separator = dimension_separator
+        if self.key_separator is None:
+            self.key_separator = "."
+
+        # Pass attributes to array creation
+        self._dimension_separator = dimension_separator
+
         if self.fs.exists(self.path) and not self.fs.isdir(self.path):
             raise FSPathExistNotDir(url)
 
@@ -1153,11 +1183,13 @@ class TempStore(DirectoryStore):
         (e.g. 'foo' and 'FOO' will be treated as equivalent). This can be
         useful to avoid potential discrepancies between case-senstive and
         case-insensitive file system. Default value is False.
-
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
     """
 
     # noinspection PyShadowingBuiltins
-    def __init__(self, suffix='', prefix='zarr', dir=None, normalize_keys=False):
+    def __init__(self, suffix='', prefix='zarr', dir=None, normalize_keys=False,
+                 dimension_separator=None):
         path = tempfile.mkdtemp(suffix=suffix, prefix=prefix, dir=dir)
         atexit.register(atexit_rmtree, path)
         super().__init__(path, normalize_keys=normalize_keys)
@@ -1192,6 +1224,9 @@ class NestedDirectoryStore(DirectoryStore):
         (e.g. 'foo' and 'FOO' will be treated as equivalent). This can be
         useful to avoid potential discrepancies between case-senstive and
         case-insensitive file system. Default value is False.
+    dimension_separator : {'/'}, optional
+        Separator placed between the dimensions of a chunk.
+        Only supports "/" unlike other implementations.
 
     Examples
     --------
@@ -1248,8 +1283,14 @@ class NestedDirectoryStore(DirectoryStore):
 
     """
 
-    def __init__(self, path, normalize_keys=False):
+    def __init__(self, path, normalize_keys=False, dimension_separator="/"):
         super().__init__(path, normalize_keys=normalize_keys)
+        if dimension_separator is None:
+            dimension_separator = "/"
+        elif dimension_separator != "/":
+            raise ValueError(
+                "NestedDirectoryStore only supports '/' as dimension_separator")
+        self._dimension_separator = dimension_separator
 
     def __getitem__(self, key):
         key = _nested_map_ckey(key)
@@ -1314,6 +1355,8 @@ class ZipStore(MutableMapping):
         One of 'r' to read an existing file, 'w' to truncate and write a new
         file, 'a' to append to an existing file, or 'x' to exclusively create
         and write a new file.
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
 
     Examples
     --------
@@ -1382,7 +1425,8 @@ class also supports the context manager protocol, which ensures the ``close()``
 
     """
 
-    def __init__(self, path, compression=zipfile.ZIP_STORED, allowZip64=True, mode='a'):
+    def __init__(self, path, compression=zipfile.ZIP_STORED, allowZip64=True, mode='a',
+                 dimension_separator=None):
 
         # store properties
         path = os.path.abspath(path)
@@ -1390,6 +1434,7 @@ def __init__(self, path, compression=zipfile.ZIP_STORED, allowZip64=True, mode='
         self.compression = compression
         self.allowZip64 = allowZip64
         self.mode = mode
+        self._dimension_separator = dimension_separator
 
         # Current understanding is that zipfile module in stdlib is not thread-safe,
         # and so locking is required for both read and write. However, this has not
@@ -1602,6 +1647,8 @@ class DBMStore(MutableMapping):
         used on Python 3, and :func:`anydbm.open` will be used on Python 2.
     write_lock: bool, optional
         Use a lock to prevent concurrent writes from multiple threads (True by default).
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.e
     **open_kwargs
         Keyword arguments to pass the `open` function.
 
@@ -1666,6 +1713,7 @@ class DBMStore(MutableMapping):
     """
 
     def __init__(self, path, flag='c', mode=0o666, open=None, write_lock=True,
+                 dimension_separator=None,
                  **open_kwargs):
         if open is None:
             import dbm
@@ -1685,6 +1733,7 @@ def __init__(self, path, flag='c', mode=0o666, open=None, write_lock=True,
         else:
             self.write_mutex = nolock
         self.open_kwargs = open_kwargs
+        self._dimension_separator = dimension_separator
 
     def __getstate__(self):
         try:
@@ -1786,6 +1835,8 @@ class LMDBStore(MutableMapping):
     buffers : bool, optional
         If True (default) use support for buffers, which should increase performance by
         reducing memory copies.
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
     **kwargs
         Keyword arguments passed through to the `lmdb.open` function.
 
@@ -1828,7 +1879,7 @@ class LMDBStore(MutableMapping):
 
     """
 
-    def __init__(self, path, buffers=True, **kwargs):
+    def __init__(self, path, buffers=True, dimension_separator=None, **kwargs):
         import lmdb
 
         # set default memory map size to something larger than the lmdb default, which is
@@ -1866,6 +1917,7 @@ def __init__(self, path, buffers=True, **kwargs):
         self.buffers = buffers
         self.path = path
         self.kwargs = kwargs
+        self._dimension_separator = dimension_separator
 
     def __getstate__(self):
         try:
@@ -2147,6 +2199,8 @@ class ABSStore(MutableMapping):
     blob_service_kwargs : dictionary
         Extra arguments to be passed into the azure blob client, for e.g. when
         using the emulator, pass in blob_service_kwargs={'is_emulated': True}.
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
 
     Notes
     -----
@@ -2154,12 +2208,13 @@ class ABSStore(MutableMapping):
     """
 
     def __init__(self, container, prefix='', account_name=None, account_key=None,
-                 blob_service_kwargs=None):
+                 blob_service_kwargs=None, dimension_separator=None):
         from azure.storage.blob import BlockBlobService
         self.container = container
         self.prefix = normalize_storage_path(prefix)
         self.account_name = account_name
         self.account_key = account_key
+        self._dimension_separator = dimension_separator
         if blob_service_kwargs is not None:
             self.blob_service_kwargs = blob_service_kwargs
         else:  # pragma: no cover
@@ -2301,6 +2356,8 @@ class SQLiteStore(MutableMapping):
     ----------
     path : string
         Location of database file.
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
     **kwargs
         Keyword arguments passed through to the `sqlite3.connect` function.
 
@@ -2324,9 +2381,11 @@ class SQLiteStore(MutableMapping):
         >>> store.close()  # don't forget to call this when you're done
     """
 
-    def __init__(self, path, **kwargs):
+    def __init__(self, path, dimension_separator=None, **kwargs):
         import sqlite3
 
+        self._dimension_separator = dimension_separator
+
         # normalize path
         if path != ':memory:':
             path = os.path.abspath(path)
@@ -2507,6 +2566,8 @@ class MongoDBStore(MutableMapping):
         Name of database
     collection : string
         Name of collection
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
     **kwargs
         Keyword arguments passed through to the `pymongo.MongoClient` function.
 
@@ -2520,11 +2581,12 @@ class MongoDBStore(MutableMapping):
     _value = 'value'
 
     def __init__(self, database='mongodb_zarr', collection='zarr_collection',
-                 **kwargs):
+                 dimension_separator=None, **kwargs):
         import pymongo
 
         self._database = database
         self._collection = collection
+        self._dimension_separator = dimension_separator
         self._kwargs = kwargs
 
         self.client = pymongo.MongoClient(**self._kwargs)
@@ -2585,14 +2647,17 @@ class RedisStore(MutableMapping):
     ----------
     prefix : string
         Name of prefix for Redis keys
+    dimension_separator : {'.', '/'}, optional
+        Separator placed between the dimensions of a chunk.
     **kwargs
         Keyword arguments passed through to the `redis.Redis` function.
 
     """
-    def __init__(self, prefix='zarr', **kwargs):
+    def __init__(self, prefix='zarr', dimension_separator=None, **kwargs):
         import redis
         self._prefix = prefix
         self._kwargs = kwargs
+        self._dimension_separator = dimension_separator
 
         self.client = redis.Redis(**kwargs)
 
diff --git a/zarr/tests/test_core.py b/zarr/tests/test_core.py
index eaa87800ef..6914cff87e 100644
--- a/zarr/tests/test_core.py
+++ b/zarr/tests/test_core.py
@@ -532,39 +532,52 @@ def test_setitem_data_not_shared(self):
         if hasattr(z.store, 'close'):
             z.store.close()
 
+    def expected(self):
+        return [
+            "063b02ff8d9d3bab6da932ad5828b506ef0a6578",
+            "f97b84dc9ffac807415f750100108764e837bb82",
+            "c7190ad2bea1e9d2e73eaa2d3ca9187be1ead261",
+            "14470724dca6c1837edddedc490571b6a7f270bc",
+            "2a1046dd99b914459b3e86be9dde05027a07d209",
+        ]
+
     def test_hexdigest(self):
+        found = []
+
         # Check basic 1-D array
         z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
-        assert '063b02ff8d9d3bab6da932ad5828b506ef0a6578' == z.hexdigest()
+        found.append(z.hexdigest())
         if hasattr(z.store, 'close'):
             z.store.close()
 
         # Check basic 1-D array with different type
         z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
-        assert 'f97b84dc9ffac807415f750100108764e837bb82' == z.hexdigest()
+        found.append(z.hexdigest())
         if hasattr(z.store, 'close'):
             z.store.close()
 
         # Check basic 2-D array
         z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
-        assert 'c7190ad2bea1e9d2e73eaa2d3ca9187be1ead261' == z.hexdigest()
+        found.append(z.hexdigest())
         if hasattr(z.store, 'close'):
             z.store.close()
 
         # Check basic 1-D array with some data
         z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
-        assert '14470724dca6c1837edddedc490571b6a7f270bc' == z.hexdigest()
+        found.append(z.hexdigest())
         if hasattr(z.store, 'close'):
             z.store.close()
 
         # Check basic 1-D array with attributes
         z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
-        assert '2a1046dd99b914459b3e86be9dde05027a07d209' == z.hexdigest()
+        found.append(z.hexdigest())
         if hasattr(z.store, 'close'):
             z.store.close()
 
+        self.expected() == found
+
     def test_resize_1d(self):
 
         z = self.create_array(shape=105, chunks=10, dtype='i4',
@@ -1650,6 +1663,15 @@ def create_array(read_only=False, **kwargs):
         return Array(store, read_only=read_only, cache_metadata=cache_metadata,
                      cache_attrs=cache_attrs)
 
+    def expected(self):
+        return [
+            "d174aa384e660eb51c6061fc8d20850c1159141f",
+            "125f00eea40032f16016b292f6767aa3928c00a7",
+            "1b52ead0ed889a781ebd4db077a29e35d513c1f3",
+            "719a88b34e362ff65df30e8f8810c1146ab72bc1",
+            "6e0abf30daf45de51593c227fb907759ca725551",
+        ]
+
 
 class TestArrayWithN5Store(TestArrayWithDirectoryStore):
 
@@ -1902,28 +1924,40 @@ def test_compressors(self):
             a2[:] = 1
             assert np.all(a2[:] == 1)
 
+    def expected(self):
+        return [
+            'c6b83adfad999fbd865057531d749d87cf138f58',
+            'a3d6d187536ecc3a9dd6897df55d258e2f52f9c5',
+            'ec2e008525ae09616dbc1d2408cbdb42532005c8',
+            'b63f031031dcd5248785616edcb2d6fe68203c28',
+            '0cfc673215a8292a87f3c505e2402ce75243c601',
+        ]
+
     def test_hexdigest(self):
+        found = []
         # Check basic 1-D array
         z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
-        assert 'c6b83adfad999fbd865057531d749d87cf138f58' == z.hexdigest()
+        found.append(z.hexdigest())
 
         # Check basic 1-D array with different type
         z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
-        assert 'a3d6d187536ecc3a9dd6897df55d258e2f52f9c5' == z.hexdigest()
+        found.append(z.hexdigest())
 
         # Check basic 2-D array
         z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
-        assert 'ec2e008525ae09616dbc1d2408cbdb42532005c8' == z.hexdigest()
+        found.append(z.hexdigest())
 
         # Check basic 1-D array with some data
         z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
-        assert 'b63f031031dcd5248785616edcb2d6fe68203c28' == z.hexdigest()
+        found.append(z.hexdigest())
 
         # Check basic 1-D array with attributes
         z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
-        assert '0cfc673215a8292a87f3c505e2402ce75243c601' == z.hexdigest()
+        found.append(z.hexdigest())
+
+        assert self.expected() == found
 
 
 class TestArrayWithDBMStore(TestArray):
diff --git a/zarr/tests/test_storage.py b/zarr/tests/test_storage.py
index a6598f2781..a34eb39933 100644
--- a/zarr/tests/test_storage.py
+++ b/zarr/tests/test_storage.py
@@ -5,7 +5,6 @@
 import pickle
 import shutil
 import tempfile
-import unittest
 from contextlib import contextmanager
 from pickle import PicklingError
 from zipfile import ZipFile
@@ -39,6 +38,20 @@ def does_not_raise():
     yield
 
 
+@pytest.fixture(params=[
+    (None, "."),
+    (".", "."),
+    ("/", "/"),
+])
+def dimension_separator_fixture(request):
+    return request.param
+
+
+def skip_if_nested_chunks(**kwargs):
+    if kwargs.get("dimension_separator") == "/":
+        pytest.skip("nested chunks are unsupported")
+
+
 class StoreTests(object):
     """Abstract store tests."""
 
@@ -371,8 +384,11 @@ def test_hierarchy(self):
         if hasattr(store, 'close'):
             store.close()
 
-    def test_init_array(self):
-        store = self.create_store()
+    def test_init_array(self, dimension_separator_fixture):
+
+        pass_dim_sep, want_dim_sep = dimension_separator_fixture
+
+        store = self.create_store(dimension_separator=pass_dim_sep)
         init_array(store, shape=1000, chunks=100)
 
         # check metadata
@@ -384,6 +400,8 @@ def test_init_array(self):
         assert np.dtype(None) == meta['dtype']
         assert default_compressor.get_config() == meta['compressor']
         assert meta['fill_value'] is None
+        # Missing MUST be assumed to be "."
+        assert meta.get('dimension_separator', ".") is want_dim_sep
 
         if hasattr(store, 'close'):
             store.close()
@@ -700,9 +718,10 @@ def _test_init_group_overwrite_chunk_store(self, order):
             chunk_store.close()
 
 
-class TestMappingStore(StoreTests, unittest.TestCase):
+class TestMappingStore(StoreTests):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
+        skip_if_nested_chunks(**kwargs)
         return dict()
 
     def test_set_invalid_content(self):
@@ -747,10 +766,11 @@ def setdel_hierarchy_checks(store):
     assert 'r/s' not in store
 
 
-class TestMemoryStore(StoreTests, unittest.TestCase):
+class TestMemoryStore(StoreTests):
 
-    def create_store(self):
-        return MemoryStore()
+    def create_store(self, **kwargs):
+        skip_if_nested_chunks(**kwargs)
+        return MemoryStore(**kwargs)
 
     def test_store_contains_bytes(self):
         store = self.create_store()
@@ -762,11 +782,13 @@ def test_setdel(self):
         setdel_hierarchy_checks(store)
 
 
-class TestDictStore(StoreTests, unittest.TestCase):
+class TestDictStore(StoreTests):
+
+    def create_store(self, **kwargs):
+        skip_if_nested_chunks(**kwargs)
 
-    def create_store(self):
         with pytest.warns(DeprecationWarning):
-            return DictStore()
+            return DictStore(**kwargs)
 
     def test_deprecated(self):
         store = self.create_store()
@@ -778,12 +800,14 @@ def test_pickle(self):
             super().test_pickle()
 
 
-class TestDirectoryStore(StoreTests, unittest.TestCase):
+class TestDirectoryStore(StoreTests):
+
+    def create_store(self, normalize_keys=False, **kwargs):
+        skip_if_nested_chunks(**kwargs)
 
-    def create_store(self, normalize_keys=False):
         path = tempfile.mkdtemp()
         atexit.register(atexit_rmtree, path)
-        store = DirectoryStore(path, normalize_keys=normalize_keys)
+        store = DirectoryStore(path, normalize_keys=normalize_keys, **kwargs)
         return store
 
     def test_filesystem_path(self):
@@ -863,20 +887,33 @@ def mock_walker_no_slash(_path):
 
 
 @pytest.mark.skipif(have_fsspec is False, reason="needs fsspec")
-class TestFSStore(StoreTests, unittest.TestCase):
+class TestFSStore(StoreTests):
 
-    def create_store(self, normalize_keys=False, key_separator="."):
+    def create_store(self, normalize_keys=False, dimension_separator="."):
         path = tempfile.mkdtemp()
         atexit.register(atexit_rmtree, path)
         store = FSStore(
             path,
             normalize_keys=normalize_keys,
-            key_separator=key_separator)
+            dimension_separator=dimension_separator)
         return store
 
-    def test_key_separator(self):
+    def test_init_array(self):
+        store = self.create_store()
+        init_array(store, shape=1000, chunks=100)
+
+        # check metadata
+        assert array_meta_key in store
+        meta = decode_array_metadata(store[array_meta_key])
+        assert ZARR_FORMAT == meta['zarr_format']
+        assert (1000,) == meta['shape']
+        assert (100,) == meta['chunks']
+        assert np.dtype(None) == meta['dtype']
+        assert meta['dimension_separator'] == "."
+
+    def test_dimension_separator(self):
         for x in (".", "/"):
-            store = self.create_store(key_separator=x)
+            store = self.create_store(dimension_separator=x)
             norm = store._normalize_key
             assert ".zarray" == norm(".zarray")
             assert ".zarray" == norm("/.zarray")
@@ -1022,6 +1059,22 @@ def test_s3_complex(self):
         assert (a[:] == -np.ones((8, 8, 8))).all()
 
 
+@pytest.mark.skipif(have_fsspec is False, reason="needs fsspec")
+class TestFSStoreWithKeySeparator(StoreTests):
+
+    def create_store(self, normalize_keys=False, key_separator=".", **kwargs):
+
+        # Since the user is passing key_separator, that will take priority.
+        skip_if_nested_chunks(**kwargs)
+
+        path = tempfile.mkdtemp()
+        atexit.register(atexit_rmtree, path)
+        return FSStore(
+            path,
+            normalize_keys=normalize_keys,
+            key_separator=key_separator)
+
+
 @pytest.fixture()
 def s3(request):
     # writable local S3 system
@@ -1063,14 +1116,28 @@ def s3(request):
     proc.wait()
 
 
-class TestNestedDirectoryStore(TestDirectoryStore, unittest.TestCase):
+class TestNestedDirectoryStore(TestDirectoryStore):
 
-    def create_store(self, normalize_keys=False):
+    def create_store(self, normalize_keys=False, **kwargs):
         path = tempfile.mkdtemp()
         atexit.register(atexit_rmtree, path)
-        store = NestedDirectoryStore(path, normalize_keys=normalize_keys)
+        store = NestedDirectoryStore(path, normalize_keys=normalize_keys, **kwargs)
         return store
 
+    def test_init_array(self):
+        store = self.create_store()
+        assert store._dimension_separator == "/"
+        init_array(store, shape=1000, chunks=100)
+
+        # check metadata
+        assert array_meta_key in store
+        meta = decode_array_metadata(store[array_meta_key])
+        assert ZARR_FORMAT == meta['zarr_format']
+        assert (1000,) == meta['shape']
+        assert (100,) == meta['chunks']
+        assert np.dtype(None) == meta['dtype']
+        assert meta['dimension_separator'] == "/"
+
     def test_chunk_nesting(self):
         store = self.create_store()
         # any path where last segment looks like a chunk key gets special handling
@@ -1084,7 +1151,29 @@ def test_chunk_nesting(self):
         assert b'zzz' == store['42']
 
 
-class TestN5Store(TestNestedDirectoryStore, unittest.TestCase):
+class TestNestedDirectoryStoreNone:
+
+    def test_value_error(self):
+        path = tempfile.mkdtemp()
+        atexit.register(atexit_rmtree, path)
+        store = NestedDirectoryStore(
+            path, normalize_keys=True,
+            dimension_separator=None)
+        assert store._dimension_separator == "/"
+
+
+class TestNestedDirectoryStoreWithWrongValue:
+
+    def test_value_error(self):
+        path = tempfile.mkdtemp()
+        atexit.register(atexit_rmtree, path)
+        with pytest.raises(ValueError):
+            NestedDirectoryStore(
+                path, normalize_keys=True,
+                dimension_separator=".")
+
+
+class TestN5Store(TestNestedDirectoryStore):
 
     def create_store(self, normalize_keys=False):
         path = tempfile.mkdtemp(suffix='.n5')
@@ -1200,12 +1289,12 @@ def test_filters(self):
 @pytest.mark.skipif(have_fsspec is False, reason="needs fsspec")
 class TestNestedFSStore(TestNestedDirectoryStore):
 
-    def create_store(self, normalize_keys=False, path=None):
+    def create_store(self, normalize_keys=False, path=None, **kwargs):
         if path is None:
             path = tempfile.mkdtemp()
         atexit.register(atexit_rmtree, path)
         store = FSStore(path, normalize_keys=normalize_keys,
-                        key_separator='/', auto_mkdir=True)
+                        dimension_separator='/', auto_mkdir=True, **kwargs)
         return store
 
     def test_numbered_groups(self):
@@ -1222,22 +1311,23 @@ def test_numbered_groups(self):
         zarr.open_group(store.path)["0"]
 
 
-class TestTempStore(StoreTests, unittest.TestCase):
+class TestTempStore(StoreTests):
 
-    def create_store(self):
-        return TempStore()
+    def create_store(self, **kwargs):
+        skip_if_nested_chunks(**kwargs)
+        return TempStore(**kwargs)
 
     def test_setdel(self):
         store = self.create_store()
         setdel_hierarchy_checks(store)
 
 
-class TestZipStore(StoreTests, unittest.TestCase):
+class TestZipStore(StoreTests):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
         path = tempfile.mktemp(suffix='.zip')
         atexit.register(os.remove, path)
-        store = ZipStore(path, mode='w')
+        store = ZipStore(path, mode='w', **kwargs)
         return store
 
     def test_mode(self):
@@ -1297,13 +1387,13 @@ def test_permissions(self):
         z.close()
 
 
-class TestDBMStore(StoreTests, unittest.TestCase):
+class TestDBMStore(StoreTests):
 
-    def create_store(self):
+    def create_store(self, dimension_separator=None):
         path = tempfile.mktemp(suffix='.anydbm')
         atexit.register(atexit_rmglob, path + '*')
         # create store using default dbm implementation
-        store = DBMStore(path, flag='n')
+        store = DBMStore(path, flag='n', dimension_separator=dimension_separator)
         return store
 
     def test_context_manager(self):
@@ -1315,55 +1405,55 @@ def test_context_manager(self):
 
 class TestDBMStoreDumb(TestDBMStore):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
         path = tempfile.mktemp(suffix='.dumbdbm')
         atexit.register(atexit_rmglob, path + '*')
 
         import dbm.dumb as dumbdbm
-        store = DBMStore(path, flag='n', open=dumbdbm.open)
+        store = DBMStore(path, flag='n', open=dumbdbm.open, **kwargs)
         return store
 
 
 class TestDBMStoreGnu(TestDBMStore):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
         gdbm = pytest.importorskip("dbm.gnu")
         path = tempfile.mktemp(suffix=".gdbm")  # pragma: no cover
         atexit.register(os.remove, path)  # pragma: no cover
         store = DBMStore(
-            path, flag="n", open=gdbm.open, write_lock=False
+            path, flag="n", open=gdbm.open, write_lock=False, **kwargs
         )  # pragma: no cover
         return store  # pragma: no cover
 
 
 class TestDBMStoreNDBM(TestDBMStore):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
         ndbm = pytest.importorskip("dbm.ndbm")
         path = tempfile.mktemp(suffix=".ndbm")  # pragma: no cover
         atexit.register(atexit_rmglob, path + "*")  # pragma: no cover
-        store = DBMStore(path, flag="n", open=ndbm.open)  # pragma: no cover
+        store = DBMStore(path, flag="n", open=ndbm.open, **kwargs)  # pragma: no cover
         return store  # pragma: no cover
 
 
 class TestDBMStoreBerkeleyDB(TestDBMStore):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
         bsddb3 = pytest.importorskip("bsddb3")
         path = tempfile.mktemp(suffix='.dbm')
         atexit.register(os.remove, path)
-        store = DBMStore(path, flag='n', open=bsddb3.btopen, write_lock=False)
+        store = DBMStore(path, flag='n', open=bsddb3.btopen, write_lock=False, **kwargs)
         return store
 
 
-class TestLMDBStore(StoreTests, unittest.TestCase):
+class TestLMDBStore(StoreTests):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
         pytest.importorskip("lmdb")
         path = tempfile.mktemp(suffix='.lmdb')
         atexit.register(atexit_rmtree, path)
         buffers = True
-        store = LMDBStore(path, buffers=buffers)
+        store = LMDBStore(path, buffers=buffers, **kwargs)
         return store
 
     def test_context_manager(self):
@@ -1373,13 +1463,13 @@ def test_context_manager(self):
             assert 2 == len(store)
 
 
-class TestSQLiteStore(StoreTests, unittest.TestCase):
+class TestSQLiteStore(StoreTests):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
         pytest.importorskip("sqlite3")
         path = tempfile.mktemp(suffix='.db')
         atexit.register(atexit_rmtree, path)
-        store = SQLiteStore(path)
+        store = SQLiteStore(path, **kwargs)
         return store
 
     def test_underscore_in_name(self):
@@ -1392,11 +1482,11 @@ def test_underscore_in_name(self):
         assert 'a_b' in store
 
 
-class TestSQLiteStoreInMemory(TestSQLiteStore, unittest.TestCase):
+class TestSQLiteStoreInMemory(TestSQLiteStore):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
         pytest.importorskip("sqlite3")
-        store = SQLiteStore(':memory:')
+        store = SQLiteStore(':memory:', **kwargs)
         return store
 
     def test_pickle(self):
@@ -1412,33 +1502,35 @@ def test_pickle(self):
 
 
 @skip_test_env_var("ZARR_TEST_MONGO")
-class TestMongoDBStore(StoreTests, unittest.TestCase):
+class TestMongoDBStore(StoreTests):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
         pytest.importorskip("pymongo")
         store = MongoDBStore(host='127.0.0.1', database='zarr_tests',
-                             collection='zarr_tests')
+                             collection='zarr_tests', **kwargs)
         # start with an empty store
         store.clear()
         return store
 
 
 @skip_test_env_var("ZARR_TEST_REDIS")
-class TestRedisStore(StoreTests, unittest.TestCase):
+class TestRedisStore(StoreTests):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
         # TODO: this is the default host for Redis on Travis,
         # we probably want to generalize this though
         pytest.importorskip("redis")
-        store = RedisStore(host='localhost', port=6379)
+        store = RedisStore(host='localhost', port=6379, **kwargs)
         # start with an empty store
         store.clear()
         return store
 
 
-class TestLRUStoreCache(StoreTests, unittest.TestCase):
+class TestLRUStoreCache(StoreTests):
 
-    def create_store(self):
+    def create_store(self, **kwargs):
+        # wrapper therefore no dimension_separator argument
+        skip_if_nested_chunks(**kwargs)
         return LRUStoreCache(dict(), max_size=2**27)
 
     def test_cache_values_no_max_size(self):
@@ -1831,9 +1923,9 @@ def test_format_compatibility():
 
 
 @skip_test_env_var("ZARR_TEST_ABS")
-class TestABSStore(StoreTests, unittest.TestCase):
+class TestABSStore(StoreTests):
 
-    def create_store(self, prefix=None):
+    def create_store(self, prefix=None, **kwargs):
         asb = pytest.importorskip("azure.storage.blob")
         blob_client = asb.BlockBlobService(is_emulated=True, socket_timeout=10)
         blob_client.delete_container("test")
@@ -1844,6 +1936,7 @@ def create_store(self, prefix=None):
             account_name="foo",
             account_key="bar",
             blob_service_kwargs={"is_emulated": True, "socket_timeout": 10},
+            **kwargs,
         )
         store.rmdir()
         return store
@@ -1880,7 +1973,7 @@ def test_hierarchy(self):
         return super().test_hierarchy()
 
 
-class TestConsolidatedMetadataStore(unittest.TestCase):
+class TestConsolidatedMetadataStore:
 
     def test_bad_format(self):
 
diff --git a/zarr/tests/test_util.py b/zarr/tests/test_util.py
index 10f5889f71..85928fc825 100644
--- a/zarr/tests/test_util.py
+++ b/zarr/tests/test_util.py
@@ -6,12 +6,21 @@
 
 from zarr.util import (guess_chunks, human_readable_size, info_html_report,
                        info_text_report, is_total_slice, normalize_chunks,
+                       normalize_dimension_separator,
                        normalize_fill_value, normalize_order,
                        normalize_resize_args, normalize_shape, retry_call,
                        tree_array_icon, tree_group_icon, tree_get_icon,
                        tree_widget)
 
 
+def test_normalize_dimension_separator():
+    assert None is normalize_dimension_separator(None)
+    assert '/' == normalize_dimension_separator('/')
+    assert '.' == normalize_dimension_separator('.')
+    with pytest.raises(ValueError):
+        normalize_dimension_separator('X')
+
+
 def test_normalize_shape():
     assert (100,) == normalize_shape((100,))
     assert (100,) == normalize_shape([100])
diff --git a/zarr/util.py b/zarr/util.py
index 82526ef8c1..a48cdfd6b9 100644
--- a/zarr/util.py
+++ b/zarr/util.py
@@ -13,7 +13,7 @@
 from numcodecs.registry import codec_registry
 from numcodecs.blosc import cbuffer_sizes, cbuffer_metainfo
 
-from typing import Any, Callable, Dict, Tuple, Union
+from typing import Any, Callable, Dict, Optional, Tuple, Union
 
 
 # codecs to use for object dtype convenience API
@@ -243,6 +243,14 @@ def normalize_order(order: str) -> str:
     return order
 
 
+def normalize_dimension_separator(sep: Optional[str]) -> Optional[str]:
+    if sep in (".", "/", None):
+        return sep
+    else:
+        raise ValueError(
+            "dimension_separator must be either '.' or '/', found: %r" % sep)
+
+
 def normalize_fill_value(fill_value, dtype: np.dtype):
 
     if fill_value is None: