diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index 7073ba49c1..35280d5cd8 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -7,7 +7,11 @@ This file contains a high-level description of this package's evolution. Release
 
 ## 4.8.2 - TBD
 
+
 * [Bug Fix] Get "make distcheck" to work See [Github #/2343](https://github.com/Unidata/netcdf-c/pull/2343).
+* [Enhancement] Allow the read/write of JSON-valued Zarr attributes to allow
+for domain specific info such as used by GDAL/Zarr. See [Github #????](https://github.com/Unidata/netcdf-c/pull/????).
+* [Enhancement] Turn on the XArray convention for NCZarr files by default. WARNING, this means that the mode should explicitly specify nczarr" or "zarr" even if "xarray" or "noxarray" is specified. See [Github #2257](https://github.com/Unidata/netcdf-c/pull/2257).
 * [Enhancement] Update the documentation to match the current filter capabilities  See [Github #2249](https://github.com/Unidata/netcdf-c/pull/2249).
 * [Enhancement] Support installation of pre-built standard filters into user-specified location. See [Github #2318](https://github.com/Unidata/netcdf-c/pull/2318).
 * [Enhancement] Improve filter support. More specifically (1) add nc_inq_filter_avail to check if a filter is available, (2) add the notion of standard filters, (3) cleanup szip support to fix interaction with NCZarr. See [Github #2245](https://github.com/Unidata/netcdf-c/pull/2245).
diff --git a/docs/nczarr.md b/docs/nczarr.md
index 2582cb55c1..94b78e82cd 100644
--- a/docs/nczarr.md
+++ b/docs/nczarr.md
@@ -136,16 +136,18 @@ Note that It should be the case that zipping a _file_
 format directory tree will produce a file readable by the
 _zip_ storage format, and vice-versa.
 
-By default, _mode=zarr_ also supports the XArray _\_ARRAY\_DIMENSIONS_ convention. The _noxarray_ mode tells the library to disable the XArray support.
+By default, the XArray convention is supported and used for
+both NCZarr files and pure Zarr files. This
+means that every variable in the root group whose named dimensions
+are also in the root group will have an attribute called
+*\_ARRAY\_DIMENSIONS* that stores those dimension names.
+The _noxarray_ mode tells the library to disable the XArray support.
 
 The netcdf-c library is capable of inferring additional mode flags based on the flags it finds. Currently we have the following inferences.
-
-- _xarray_ => _zarr_
-- _noxarray_ => _zarr_
 - _zarr_ => _nczarr_
 
-So for example: ````...#mode=noxarray,zip```` is equivalent to this.
-````...#mode=nczarr,zarr,noxarray,zip
+So for example: ````...#mode=zarr,zip```` is equivalent to this.
+````...#mode=nczarr,zarr,zip
 ````
 <!--
 - log=&lt;output-stream&gt;: this control turns on logging output,
@@ -434,10 +436,13 @@ The value of this attribute is a list of dimension names (strings).
 An example might be ````["time", "lon", "lat"]````.
 It is essentially equivalent to the ````_NCZARR_ARRAY "dimrefs" list````, except that the latter uses fully qualified names so the referenced dimensions can be anywhere in the dataset.
 
-As of _netcdf-c_ version 4.8.1, The Xarray ''_ARRAY_DIMENSIONS'' attribute is supported.
-This attribute will be read/written by default, but can be suppressed if the mode value "noxarray" is specified.
+As of _netcdf-c_ version 4.8.2, The Xarray ''_ARRAY_DIMENSIONS'' attribute is supported for both NCZarr and pure Zarr.
+If possible, this attribute will be read/written by default,
+but can be suppressed if the mode value "noxarray" is specified.
 If detected, then these dimension names are used to define shared dimensions.
-Note that "noxarray" or "xarray" implies pure zarr format.
+The following conditions will cause ''_ARRAY_DIMENSIONS'' to not be written.
+* The variable is not in the root group,
+* Any dimension referenced by the variable is not in the root group.
 
 # Examples {#nczarr_examples}
 
diff --git a/docs/static-pages/software.html b/docs/static-pages/software.html
index 13f98a7533..e19b57d9a9 100644
--- a/docs/static-pages/software.html
+++ b/docs/static-pages/software.html
@@ -940,7 +940,7 @@ <h2><a id="gliderscope" name="gliderscope">Gliderccope</a></h2>
     Dr L. Mun Woo <mun.woo@uwa.edu.au>
     at ANFOG (Australian National Facility for Ocean Gliders)
     has developed
-    <a href="http://imos.org.au/facilities/oceangliders/glider-data/gliderscope/">Gliderscope</a>.
+    <a href="https://imos.org.au/gliderscope">Gliderscope</a>.
     Gliderscope is an IMOS (Integrated Marine Observing System)
     oceanographic software package allowing users quick easy visualisation
     of ocean glider data, via a convenient graphical user interface.
@@ -2008,7 +2008,7 @@ <h2><a id="netcdf_ninja" name="netcdf_ninja">NetCDF Ninja</a></h2>
     <p>
     Dr L. Mun Woo of University of Western Australia <mun.woo@uwa.edu.au>
     has developed
-    <a href="http://imos.org.au/facilities/oceangliders/glider-data/netcdfninja/">NetCDF Ninja</a>,
+    <a href="https://imos.org.au/netcdfninja">NetCDF Ninja</a>,
     a graphical user interface that allows users to browse all
     the metadata contained in netCDF files, scrutinise the data using an
     interactive graphical plot and even make small alterations or export
diff --git a/include/ncjson.h b/include/ncjson.h
index 86a91ef172..c065bc2ed1 100644
--- a/include/ncjson.h
+++ b/include/ncjson.h
@@ -56,9 +56,12 @@ struct NCJconst {int bval; long long ival; double dval; char* sval;};
 extern "C" {
 #endif
 
-/* Parse a JSON string */
+/* Parse a string to NCjson*/
 DLLEXPORT int NCJparse(const char* text, unsigned flags, NCjson** jsonp);
 
+/* Parse a counted string to NCjson*/
+DLLEXPORT int NCJparsen(size_t len, const char* text, unsigned flags, NCjson** jsonp);
+
 /* Reclaim a JSON tree */
 DLLEXPORT extern void NCJreclaim(NCjson* json);
 
diff --git a/libdispatch/dinfermodel.c b/libdispatch/dinfermodel.c
index e6d725fa51..d991b9e0f5 100644
--- a/libdispatch/dinfermodel.c
+++ b/libdispatch/dinfermodel.c
@@ -137,9 +137,9 @@ static const struct MACRODEF {
 {"dap4","mode",{"dap4",NULL}},
 {"s3","mode",{"s3","nczarr",NULL}},
 {"bytes","mode",{"bytes",NULL}},
-{"xarray","mode",{"nczarr","zarr","xarray",NULL}},
-{"noxarray","mode",{"nczarr","zarr","noxarray",NULL}},
-{"zarr","mode",{"nczarr","zarr","xarray",NULL}},
+{"xarray","mode",{"zarr", NULL}},
+{"noxarray","mode",{"nczarr", "noxarray", NULL}},
+{"zarr","mode",{"nczarr","zarr", NULL}},
 {NULL,NULL,{NULL}}
 };
 
@@ -149,9 +149,8 @@ static const struct MODEINFER {
     char* inference;
 } modeinferences[] = {
 {"zarr","nczarr"},
-{"zarr","xarray"},
 {"xarray","zarr"},
-{"noxarray","zarr"},
+{"noxarray","nczarr"},
 {NULL,NULL}
 };
 
diff --git a/libdispatch/ncjson.c b/libdispatch/ncjson.c
index e862175648..c0f85dd3f4 100644
--- a/libdispatch/ncjson.c
+++ b/libdispatch/ncjson.c
@@ -94,6 +94,7 @@ static int NCJyytext(NCJparser*, char* start, size_t pdlen);
 static void NCJreclaimArray(struct NCjlist*);
 static void NCJreclaimDict(struct NCjlist*);
 static int NCJunescape(NCJparser* parser);
+static int unescape1(int c);
 static int listappend(struct NCjlist* list, NCjson* element);
 
 #ifndef NETCDF_JSON_H
@@ -109,24 +110,28 @@ static int bytesappendc(NCJbuf* bufp, const char c);
 
 int
 NCJparse(const char* text, unsigned flags, NCjson** jsonp)
+{
+    return NCJparsen(strlen(text),text,flags,jsonp);
+}
+
+int
+NCJparsen(size_t len, const char* text, unsigned flags, NCjson** jsonp)
 {
     int stat = NCJ_OK;
-    size_t len;
     NCJparser* parser = NULL;
     NCjson* json = NULL;
 
     /* Need at least 1 character of input */
-    if(text == NULL || text[0] == '\0')
+    if(len == 0 || text == NULL)
 	{stat = NCJTHROW(NCJ_ERR); goto done;}
     if(jsonp == NULL) goto done;
     parser = calloc(1,sizeof(NCJparser));
     if(parser == NULL)
 	{stat = NCJTHROW(NCJ_ERR); goto done;}
-    len = strlen(text);
     parser->text = (char*)malloc(len+1+1);
     if(parser->text == NULL)
 	{stat = NCJTHROW(NCJ_ERR); goto done;}
-    strcpy(parser->text,text);
+    memcpy(parser->text,text,len);
     parser->text[len] = '\0';
     parser->text[len+1] = '\0';
     parser->pos = &parser->text[0];
@@ -334,16 +339,21 @@ NCJlex(NCJparser* parser)
 	c = *parser->pos;
 	if(c == '\0') {
 	    token = NCJ_EOF;
-	} else if(c <= ' ' || c == '\177') {
+	} else if(c <= ' ' || c == '\177') {/* ignore whitespace */
+	    parser->pos++;
+	    continue;
+	} else if(c == NCJ_ESCAPE) {
 	    parser->pos++;
-	    continue; /* ignore whitespace */
+	    c = *parser->pos;
+	    *parser->pos = unescape1(c);
+	    continue;
 	} else if(strchr(JSON_WORD, c) != NULL) {
 	    start = parser->pos;
 	    for(;;) {
 		c = *parser->pos++;
 		if(c == '\0' || strchr(JSON_WORD,c) == NULL) break; /* end of word */
 	    }
-	    /* Pushback c if not whitespace */
+	    /* Pushback c */
 	    parser->pos--;
 	    count = ((parser->pos) - start);
 	    if(NCJyytext(parser,start,count)) goto done;
@@ -604,6 +614,21 @@ NCJunescape(NCJparser* parser)
     return NCJTHROW(NCJ_OK);    
 }
 
+/* Unescape a single character */
+static int
+unescape1(int c)
+{
+    switch (c) {
+    case 'b': c = '\b'; break;
+    case 'f': c = '\f'; break;
+    case 'n': c = '\n'; break;
+    case 'r': c = '\r'; break;
+    case 't': c = '\t'; break;
+    default: c = c; break;/* technically not Json conformant */
+    }
+    return c;
+}
+
 #ifdef NCJDEBUG
 static char*
 tokenname(int token)
@@ -896,7 +921,7 @@ NCJunparseR(const NCjson* json, NCJbuf* buf, unsigned flags)
 	if(json->list.len > 0 && json->list.contents != NULL) {
 	    int shortlist = 0;
 	    for(i=0;!shortlist && i < json->list.len;i+=2) {
-		if(i > 0) bytesappendc(buf,NCJ_COMMA);
+		if(i > 0) {bytesappendc(buf,NCJ_COMMA);bytesappendc(buf,' ');};
 		NCJunparseR(json->list.contents[i],buf,flags); /* key */
 		bytesappendc(buf,NCJ_COLON);
 		bytesappendc(buf,' ');
@@ -945,7 +970,7 @@ escape(const char* text, NCJbuf* buf)
 	case '\n': replace = 'n'; break;
 	case '\r': replace = 'r'; break;
 	case '\t': replace = 't'; break;
-	case NCJ_QUOTE: replace = '\''; break;
+	case NCJ_QUOTE: replace = '\"'; break;
 	case NCJ_ESCAPE: replace = '\\'; break;
 	default: break;
 	}
diff --git a/libnczarr/zarr.c b/libnczarr/zarr.c
index afc06ddd16..671b0c2ace 100644
--- a/libnczarr/zarr.c
+++ b/libnczarr/zarr.c
@@ -384,14 +384,15 @@ applycontrols(NCZ_FILE_INFO_T* zinfo)
     }
     /* Process the modelist first */
     zinfo->controls.mapimpl = NCZM_DEFAULT;
+    zinfo->controls.flags |= FLAG_XARRAYDIMS; /* Always support XArray convention where possible */
     for(i=0;i<nclistlength(modelist);i++) {
         const char* p = nclistget(modelist,i);
-	if(strcasecmp(p,PUREZARRCONTROL)==0) zinfo->controls.flags |= (FLAG_PUREZARR|FLAG_XARRAYDIMS);
-	else if(strcasecmp(p,XARRAYCONTROL)==0) zinfo->controls.flags |= (FLAG_XARRAYDIMS|FLAG_PUREZARR); /*xarray=>zarr*/
-	else if(strcasecmp(p,NOXARRAYCONTROL)==0) {
+	if(strcasecmp(p,PUREZARRCONTROL)==0)
+	    zinfo->controls.flags |= (FLAG_PUREZARR);
+	else if(strcasecmp(p,XARRAYCONTROL)==0)
+	    zinfo->controls.flags |= FLAG_PUREZARR;
+	else if(strcasecmp(p,NOXARRAYCONTROL)==0)
 	    noflags |= FLAG_XARRAYDIMS;
-	    zinfo->controls.flags |= FLAG_PUREZARR; /*noxarray=>zarr*/
-	}
 	else if(strcasecmp(p,"zip")==0) zinfo->controls.mapimpl = NCZM_ZIP;
 	else if(strcasecmp(p,"file")==0) zinfo->controls.mapimpl = NCZM_FILE;
 	else if(strcasecmp(p,"s3")==0) zinfo->controls.mapimpl = NCZM_S3;
diff --git a/libnczarr/zsync.c b/libnczarr/zsync.c
index 7711032499..d42a311056 100644
--- a/libnczarr/zsync.c
+++ b/libnczarr/zsync.c
@@ -12,13 +12,17 @@
 
 #undef FILLONCLOSE
 
+/*mnemonics*/
+#define DICTOPEN '{'
+#define DICTCLOSE '}'
+
 /* Forward */
 static int ncz_collect_dims(NC_FILE_INFO_T* file, NC_GRP_INFO_T* grp, NCjson** jdimsp);
 static int ncz_sync_var(NC_FILE_INFO_T* file, NC_VAR_INFO_T* var, int isclose);
 
 static int ncz_jsonize_atts(NCindex* attlist, NCjson** jattrsp);
 static int load_jatts(NCZMAP* map, NC_OBJ* container, int nczarrv1, NCjson** jattrsp, NClist** atypes);
-static int zconvert(nc_type typeid, size_t typelen, void* dst, NCjson* src);
+static int zconvert(nc_type typeid, size_t typelen, NCjson* src, void* dst);
 static int computeattrinfo(const char* name, NClist* atypes, NCjson* values,
 		nc_type* typeidp, size_t* typelenp, size_t* lenp, void** datap);
 static int parse_group_content(NCjson* jcontent, NClist* dimdefs, NClist* varnames, NClist* subgrps);
@@ -37,6 +41,8 @@ static int computeattrdata(nc_type* typeidp, NCjson* values, size_t* typelenp, s
 static int inferattrtype(NCjson* values, nc_type* typeidp);
 static int mininttype(unsigned long long u64, int negative);
 static int computedimrefs(NC_FILE_INFO_T* file, NC_VAR_INFO_T* var, int purezarr, int xarray, int ndims, NClist* dimnames, size64_t* shapes, NC_DIM_INFO_T** dims);
+static int read_dict(NCjson* jdict, NCjson** jtextp);
+static int write_dict(size_t len, const void* data, NCjson** jsonp);
 
 /**************************************************/
 /**************************************************/
@@ -695,20 +701,33 @@ ncz_sync_atts(NC_FILE_INFO_T* file, NC_OBJ* container, NCindex* attlist, int isc
 
     if(container->sort == NCVAR) { 
         if(isrootgroup && isxarray) {
+	    int dimsinroot = 1;
 	    /* Insert the XARRAY _ARRAY_ATTRIBUTE attribute */
 	    if((stat = NCJnew(NCJ_ARRAY,&jdimrefs)))
 	        goto done;
-	    /* Walk the dimensions and capture the names */
+	    /* Walk the dimensions to check in root group */
 	    for(i=0;i<var->ndims;i++) {
 	        NC_DIM_INFO_T* dim = var->dim[i];
-		char* dimname = strdup(dim->hdr.name);
-		if(dimname == NULL) {stat = NC_ENOMEM; goto done;}
-	        NCJaddstring(jdimrefs,NCJ_STRING,dimname);
-   	        nullfree(dimname); dimname = NULL;
+		/* Verify that the dimension is in the root group */
+		if(dim->container && dim->container->parent != NULL) {
+		    dimsinroot = 0; /* dimension is not in root */
+		    break;
+		}
+	    }
+	    if(dimsinroot) {
+		/* Walk the dimensions and capture the names */
+		for(i=0;i<var->ndims;i++) {
+		    char* dimname;
+	            NC_DIM_INFO_T* dim = var->dim[i];
+		    dimname = strdup(dim->hdr.name);
+		    if(dimname == NULL) {stat = NC_ENOMEM; goto done;}
+	            NCJaddstring(jdimrefs,NCJ_STRING,dimname);
+   	            nullfree(dimname); dimname = NULL;
+		}
+	        /* Add the _ARRAY_DIMENSIONS attribute */
+	        if((stat = NCJinsert(jatts,NC_XARRAY_DIMS,jdimrefs))) goto done;
+	        jdimrefs = NULL;
 	    }
-	    /* Add the _ARRAY_DIMENSIONS attribute */
-	    if((stat = NCJinsert(jatts,NC_XARRAY_DIMS,jdimrefs))) goto done;
-	    jdimrefs = NULL;
         }
     }
     /* Add Quantize Attribute */
@@ -740,9 +759,11 @@ ncz_sync_atts(NC_FILE_INFO_T* file, NC_OBJ* container, NCindex* attlist, int isc
 	    /* Insert the _NCZARR_ATTR attribute */
             if((stat = NCJnew(NCJ_DICT,&jdict)))
                 goto done;
-            if((stat = NCJinsert(jdict,"types",jtypes))) goto done;
+	    if(jtypes != NULL)
+                {if((stat = NCJinsert(jdict,"types",jtypes))) goto done;}
             jtypes = NULL;
-            if((stat = NCJinsert(jatts,NCZ_V2_ATTR,jdict))) goto done;      
+	    if(jdict != NULL)
+                {if((stat = NCJinsert(jatts,NCZ_V2_ATTR,jdict))) goto done;}
             jdict = NULL;
 	}
         /* write .zattrs path */
@@ -776,6 +797,7 @@ ncz_sync_atts(NC_FILE_INFO_T* file, NC_OBJ* container, NCindex* attlist, int isc
 Note that this does not push to the file.
 Also note that attributes of length 1 are stored as singletons, not arrays.
 This is to be more consistent with pure zarr.
+Also implements the JSON dictionary convention.
 @param attlist - [in] the attributes to dictify
 @param jattrsp - [out] the json'ized att list
 @return NC_NOERR
@@ -785,7 +807,7 @@ static int
 ncz_jsonize_atts(NCindex* attlist, NCjson** jattrsp)
 {
     int stat = NC_NOERR;
-    int i;
+    int i, isdict;
     NCjson* jattrs = NULL;
     NCjson* akey = NULL;
     NCjson* jdata = NULL;
@@ -795,9 +817,18 @@ ncz_jsonize_atts(NCindex* attlist, NCjson** jattrsp)
     /* Iterate over the attribute list */
     for(i=0;i<ncindexsize(attlist);i++) {
 	NC_ATT_INFO_T* att = (NC_ATT_INFO_T*)ncindexith(attlist,i);
+	isdict = 0;
 	/* Create the attribute dict value*/
-	if((stat = NCZ_stringconvert(att->nc_typeid,att->len,att->data,&jdata)))
-	    goto done;
+	if(att->nc_typeid == NC_CHAR
+	   && ((char*)att->data)[0] == DICTOPEN
+   	   && ((char*)att->data)[att->len-1] == DICTCLOSE) {
+	    /* this is subject to the JSON dictionary convention? */
+	    if(write_dict(att->len,att->data,&jdata)==NC_NOERR) isdict=1;
+	}
+	if(!isdict) {
+	    if((stat = NCZ_stringconvert(att->nc_typeid,att->len,att->data,&jdata)))
+	        goto done;
+	}
 	if((stat = NCJinsert(jattrs,att->hdr.name,jdata))) goto done;
 	jdata = NULL;
     }
@@ -918,7 +949,7 @@ load_jatts(NCZMAP* map, NC_OBJ* container, int nczarrv1, NCjson** jattrsp, NClis
 
 /* Convert a json value to actual data values of an attribute. */
 static int
-zconvert(nc_type typeid, size_t typelen, void* dst0, NCjson* src)
+zconvert(nc_type typeid, size_t typelen, NCjson* src, void* dst0)
 {
     int stat = NC_NOERR;
     int i;
@@ -1004,6 +1035,7 @@ computeattrdata(nc_type* typeidp, NCjson* values, size_t* typelenp, size_t* lenp
     void* data = NULL;
     size_t typelen;
     nc_type typeid = NC_NAT;
+    NCjson* jtext = NULL;
     int reclaimvalues = 0;
 
     /* Get assumed type */
@@ -1011,12 +1043,20 @@ computeattrdata(nc_type* typeidp, NCjson* values, size_t* typelenp, size_t* lenp
     if(typeid == NC_NAT) if((stat = inferattrtype(values,&typeid))) goto done;
     if(typeid == NC_NAT) {stat = NC_EBADTYPE; goto done;}
 
+    if((stat = NC4_inq_atomic_type(typeid, NULL, &typelen)))
+        goto done;
+
     /* Collect the length of the attribute; might be a singleton  */
     switch (NCJsort(values)) {
-    case NCJ_DICT: stat = NC_ENCZARR; goto done;
     case NCJ_ARRAY:
 	count = NCJlength(values);
 	break;
+    case NCJ_DICT:
+	/* Apply the JSON dictionary convention and convert to string */
+	if((stat = read_dict(values,&jtext))) goto done;
+	values = jtext; jtext = NULL;
+	reclaimvalues = 1;
+	/* fall thru */
     case NCJ_STRING: /* requires special handling as an array of characters; also look out for empty string */
 	if(typeid == NC_CHAR) {
 	    count = strlen(NCJstring(values));
@@ -1029,10 +1069,8 @@ computeattrdata(nc_type* typeidp, NCjson* values, size_t* typelenp, size_t* lenp
 	break;
     }
 
-    if(count > 0) {
+    if(count > 0 && data == NULL) {
         /* Allocate data space */
-        if((stat = NC4_inq_atomic_type(typeid, NULL, &typelen)))
-	    goto done;
         if(typeid == NC_CHAR)
             data = malloc(typelen*(count+1));
         else
@@ -1040,7 +1078,7 @@ computeattrdata(nc_type* typeidp, NCjson* values, size_t* typelenp, size_t* lenp
         if(data == NULL)
 	    {stat = NC_ENOMEM; goto done;}
         /* convert to target type */
-        if((stat = zconvert(typeid, typelen, data, values)))
+        if((stat = zconvert(typeid, typelen, values, data)))
    	    goto done;
     }
     if(lenp) *lenp = count;
@@ -1079,7 +1117,9 @@ inferattrtype(NCjson* value, nc_type* typeidp)
     case NCJ_NULL:
         typeid = NC_CHAR;
 	return NC_NOERR;
-    case NCJ_DICT: /* fall thru */
+    case NCJ_DICT:
+    	typeid = NC_CHAR;
+	goto done;
     case NCJ_UNDEF:
 	return NC_EINVAL;
     default: /* atomic */
@@ -1453,7 +1493,7 @@ define_vars(NC_FILE_INFO_T* file, NC_GRP_INFO_T* grp, NClist* varnames)
 
     if(zinfo->controls.flags & FLAG_PUREZARR) purezarr = 1;
     if(zinfo->controls.flags & FLAG_NCZARR_V1) formatv1 = 1;
-    if(zinfo->controls.flags & FLAG_XARRAYDIMS) {purezarr = 1; xarray = 1;}
+    if(zinfo->controls.flags & FLAG_XARRAYDIMS) {xarray = 1;}
 
     /* Load each var in turn */
     for(i = 0; i < nclistlength(varnames); i++) {
@@ -2250,10 +2290,8 @@ computedimrefs(NC_FILE_INFO_T* file, NC_VAR_INFO_T* var, int purezarr, int xarra
 
     assert(zfile && zvar);
 
-    /* xarray => purezarr */
-    assert(!xarray || purezarr);
-
-    if(xarray) {/* Read in the attributes to get xarray dimdef attribute; Note that it might not exist */
+    if(purezarr && xarray) {/* Read in the attributes to get xarray dimdef attribute; Note that it might not exist */
+	/* Note that if xarray && !purezarr, then xarray will be superceded by the nczarr dimensions key */
         char zdimname[4096];
 	if(zvar->xarray == NULL) {
 	    assert(nclistlength(dimnames) == 0);
@@ -2289,42 +2327,48 @@ computedimrefs(NC_FILE_INFO_T* file, NC_VAR_INFO_T* var, int purezarr, int xarra
     return THROW(stat);
 }
 
-#if 0
-Not currently used
-Special compatibility case:
-       if the value of the attribute is a dictionary,
-       or an array with non-atomic values, then
-       then stringify it and pretend it is of char type.
-/* Return 1 if this json is not an
-atomic value or an array of atomic values.
-That is, it does not look like valid
-attribute data.
+/**
+Implement the JSON convention for dictionaries.
+
+Reading: If the value of the attribute is a dictionary, then stringify
+         it as the value and make the attribute be of type "char".
+
+Writing: if the attribute is of type char and looks like a JSON dictionary,
+	 then parse it as JSON and use that as its value in .zattrs.
 */
+
 static int
-iscomplexjson(NCjson* j)
+read_dict(NCjson* jdict, NCjson** jtextp)
 {
-    int i;
-    switch(NCJsort(j)) {
-    case NCJ_ARRAY:
-	/* verify that the elements of the array are not complex */
-	for(i=0;i<NCJlength(j);i++) {
-	    switch (NCJith(j,NCJsort(i)))) {
-	    case NCJ_DICT:
-    	    case NCJ_ARRAY:
-	    case NCJ_UNDEF:
-	    case NCJ_NULL:
-		return 1;
-	    default: break;
-	    }
-	}
-	return 0;
-    case NCJ_DICT:
-    case NCJ_UNDEF:
-    case NCJ_NULL:
-	break;
-    default:
-        return 0;
-    }
-    return 1;
+    int stat = NC_NOERR;
+    NCjson* jtext = NULL;
+    char* text = NULL;
+
+    if(jdict == NULL) {stat = NC_EINVAL; goto done;}
+    if(NCJsort(jdict) != NCJ_DICT)  {stat = NC_EINVAL; goto done;}
+    if(NCJunparse(jdict,0,&text)) {stat = NC_EINVAL; goto done;}
+    if(NCJnewstring(NCJ_STRING,text,&jtext)) {stat = NC_EINVAL; goto done;}
+    *jtextp = jtext; jtext = NULL;
+done:
+    NCJreclaim(jtext);
+    nullfree(text);
+    return stat;
 }
-#endif
+
+static int
+write_dict(size_t len, const void* data, NCjson** jsonp)
+{
+    int stat = NC_NOERR;
+    NCjson* jdict = NULL;
+
+    assert(jsonp != NULL);
+    if(NCJparsen(len,(char*)data,0,&jdict))
+        {stat = NC_EINVAL; goto done;}
+    if(NCJsort(jdict) != NCJ_DICT)
+        {stat = NC_EINVAL; goto done;}
+    *jsonp = jdict; jdict = NULL;
+done:
+    NCJreclaim(jdict);
+    return stat;
+}
+
diff --git a/nc_test4/tst_broken_files.c b/nc_test4/tst_broken_files.c
index 5812339133..f4b204e28a 100644
--- a/nc_test4/tst_broken_files.c
+++ b/nc_test4/tst_broken_files.c
@@ -31,8 +31,11 @@ main() {
         if(fwrite(TRUNCATED_FILE_CONTENT, sizeof(char), sizeof(TRUNCATED_FILE_CONTENT), fp) != sizeof(TRUNCATED_FILE_CONTENT)) ERR;
         fclose(fp);
 
-        int  ncid;
-        if (nc_open(FILE_NAME, 0, &ncid) != NC_EHDFERR) ERR;
+
+        int  ncid, stat;
+        stat = nc_open(FILE_NAME, 0, &ncid);
+        if (stat != NC_EHDFERR && stat != NC_ENOFILTER && stat != NC_ENOTNC) ERR;
+
     }
 
     {
diff --git a/ncdap_test/tst_utils.sh b/ncdap_test/tst_utils.sh
index c0a0e6af04..70ed9adb53 100644
--- a/ncdap_test/tst_utils.sh
+++ b/ncdap_test/tst_utils.sh
@@ -11,7 +11,10 @@ PARAMS="[log]"
 
 OCLOGFILE=/dev/null
 
-DUMPFLAGS=
+# Reduce the precision
+if test "x$FP_ISOSX" != x ; then
+DUMPFLAGS="-p7,14"
+fi
 
 # Locate directories
 testdata3="${srcdir}/testdata3"
diff --git a/nczarr_test/CMakeLists.txt b/nczarr_test/CMakeLists.txt
index 03db4557fb..ef31d15df1 100644
--- a/nczarr_test/CMakeLists.txt
+++ b/nczarr_test/CMakeLists.txt
@@ -73,7 +73,7 @@ IF(ENABLE_TESTS)
   BUILD_BIN_TEST(zmapio ${COMMONSRC})
   TARGET_INCLUDE_DIRECTORIES(zmapio PUBLIC ../libnczarr)
   BUILD_BIN_TEST(zhex)
-  BUILD_BIN_TEST(zisjson)
+  BUILD_BIN_TEST(zisjson ${COMMONSRC})
   TARGET_INCLUDE_DIRECTORIES(zisjson PUBLIC ../libnczarr)
   BUILD_BIN_TEST(zs3parse ${COMMONSRC})
   TARGET_INCLUDE_DIRECTORIES(zs3parse PUBLIC ../libnczarr)
@@ -108,6 +108,7 @@ IF(ENABLE_TESTS)
     add_sh_test(nczarr_test run_interop)
     add_sh_test(nczarr_test run_misc)
     add_sh_test(nczarr_test run_nczarr_fill)
+    add_sh_test(nczarr_test run_jsonconvention)
 
     BUILD_BIN_TEST(test_quantize ${TSTCOMMONSRC})
     add_sh_test(nczarr_test run_quantize)
diff --git a/nczarr_test/Makefile.am b/nczarr_test/Makefile.am
index 4eb2a2fc74..16059211c1 100644
--- a/nczarr_test/Makefile.am
+++ b/nczarr_test/Makefile.am
@@ -61,6 +61,7 @@ TESTS += run_purezarr.sh
 TESTS += run_interop.sh
 TESTS += run_misc.sh
 TESTS += run_nczarr_fill.sh
+TESTS += run_jsonconvention.sh
 
 endif
 
@@ -127,7 +128,8 @@ run_ut_map.sh run_ut_mapapi.sh run_ut_misc.sh run_ut_chunk.sh run_ncgen4.sh \
 run_nccopyz.sh run_fillonlyz.sh run_chunkcases.sh test_nczarr.sh run_perf_chunks1.sh run_s3_cleanup.sh \
 run_purezarr.sh run_interop.sh run_misc.sh \
 run_filter.sh run_specific_filters.sh \
-run_newformat.sh run_nczarr_fill.sh run_quantize.sh run_nczfilter.sh
+run_newformat.sh run_nczarr_fill.sh run_quantize.sh run_jsonconvention.sh
+
 
 EXTRA_DIST += \
 ref_ut_map_create.cdl ref_ut_map_writedata.cdl ref_ut_map_writemeta2.cdl ref_ut_map_writemeta.cdl \
@@ -146,7 +148,7 @@ ref_xarray.cdl ref_purezarr.cdl ref_purezarr_base.cdl ref_nczarr2zarr.cdl \
 ref_bzip2.cdl ref_filtered.cdl ref_multi.cdl \
 ref_any.cdl ref_oldformat.cdl ref_oldformat.zip ref_newformatpure.cdl \
 ref_groups.h5 ref_byte.zarr.zip ref_byte_fill_value_null.zarr.zip \
-ref_groups_regular.cdl ref_byte.cdl ref_byte_fill_value_null.cdl
+ref_groups_regular.cdl ref_byte.cdl ref_byte_fill_value_null.cdl ref_jsonconvention.cdl
 
 # Interoperability files
 EXTRA_DIST += ref_power_901_constants_orig.zip ref_power_901_constants.cdl ref_quotes_orig.zip ref_quotes.cdl 
diff --git a/nczarr_test/ref_jsonconvention.cdl b/nczarr_test/ref_jsonconvention.cdl
new file mode 100644
index 0000000000..c4a52b8104
--- /dev/null
+++ b/nczarr_test/ref_jsonconvention.cdl
@@ -0,0 +1,13 @@
+netcdf tmp_jsonconvention {
+dimensions:
+	d1 = 1 ;
+variables:
+	int v(d1) ;
+		v:varconvention = "{\n\"key1\": [1,2,3], \"key2\": {\"key3\": \"abc\"}}" ;
+
+// global attributes:
+		:grpconvention = "{\"key1\": [1,2,3], \n\"key2\": {\"key3\": \"abc\"}}" ;
+data:
+
+ v = _ ;
+}
diff --git a/nczarr_test/ref_newformatpure.cdl b/nczarr_test/ref_newformatpure.cdl
index 2f86124339..080df793f1 100644
--- a/nczarr_test/ref_newformatpure.cdl
+++ b/nczarr_test/ref_newformatpure.cdl
@@ -1,9 +1,10 @@
 netcdf ref_oldformat {
 dimensions:
+	lat = 8 ;
 	_zdim_8 = 8 ;
 	_zdim_10 = 10 ;
 variables:
-	int lat(_zdim_8) ;
+	int lat(lat) ;
 		lat:_FillValue = -1 ;
 		lat:lat_attr = "latitude" ;
 data:
diff --git a/nczarr_test/run_jsonconvention.sh b/nczarr_test/run_jsonconvention.sh
new file mode 100755
index 0000000000..7cf786a685
--- /dev/null
+++ b/nczarr_test/run_jsonconvention.sh
@@ -0,0 +1,31 @@
+#!/bin/sh
+
+if test "x$srcdir" = x ; then srcdir=`pwd`; fi 
+. ../test_common.sh
+
+. "$srcdir/test_nczarr.sh"
+
+# This shell script tests support for:
+# read/write using json convention
+
+set -e
+
+testcase() {
+zext=$1
+
+echo "*** Test: write then read using json convention"
+fileargs tmp_jsonconvention "mode=nczarr,$zext"
+deletemap $zext $file
+${NCGEN} -4 -b -o "$fileurl" $srcdir/ref_jsonconvention.cdl
+${NCDUMP} $fileurl > tmp_jsonconvention_${zext}.cdl
+# remove '\n' from ref file before comparing
+rm -f tmp_jsonconvention.cdl
+sed -e 's|\\n||g' < ${srcdir}/ref_jsonconvention.cdl > tmp_jsonconvention.cdl
+diff -b tmp_jsonconvention.cdl tmp_jsonconvention_${zext}.cdl
+}
+
+testcase file
+if test "x$FEATURE_NCZARR_ZIP" = xyes ; then testcase zip; fi
+if test "x$FEATURE_S3TESTS" = xyes ; then testcase s3; fi
+
+exit 0
diff --git a/nczarr_test/run_purezarr.sh b/nczarr_test/run_purezarr.sh
index a74760c916..b068994c19 100755
--- a/nczarr_test/run_purezarr.sh
+++ b/nczarr_test/run_purezarr.sh
@@ -15,7 +15,7 @@ testcase() {
 zext=$1
 
 echo "*** Test: pure zarr write then read; format=$zext"
-fileargs tmp_purezarr "mode=noxarray,$zext"
+fileargs tmp_purezarr "mode=zarr,noxarray,$zext"
 deletemap $zext $file
 ${NCGEN} -4 -b -o "$fileurl" $srcdir/ref_purezarr_base.cdl
 ${NCDUMP} $fileurl > tmp_purezarr_${zext}.cdl
@@ -27,9 +27,9 @@ fileargs tmp_xarray "mode=zarr,$zext"
 ${NCGEN} -4 -b -o "$fileurl" $srcdir/ref_purezarr_base.cdl
 ${NCDUMP} $fileurl > tmp_xarray_${zext}.cdl
 diff -b ${srcdir}/ref_xarray.cdl tmp_xarray_${zext}.cdl
-echo "*** Test: pure zarr reading nczarr; format=$zext"
-fileargs tmp_nczarr "mode=nczarr,$zext"
 
+echo "*** Test: pure zarr reading nczarr; format=$zext"
+fileargs tmp_nczarr "mode=nczarr,noxarray,$zext"
 deletemap $zext $file
 ${NCGEN} -4 -b -o "$fileurl" $srcdir/ref_whole.cdl
 fileargs tmp_nczarr "mode=zarr,$zext"
diff --git a/nczarr_test/zisjson.c b/nczarr_test/zisjson.c
index 186ae45f6c..e13c69f23f 100644
--- a/nczarr_test/zisjson.c
+++ b/nczarr_test/zisjson.c
@@ -7,36 +7,122 @@
    Output 1 or 0.
 */
 
-#include "config.h"
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
 
 #include "stdlib.h"
 #include "stdio.h"
+#include "string.h"
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
+#if defined(_WIN32) && !defined(__MINGW32__)
+#include "XGetopt.h"
+#else
+#include <getopt.h>
+#endif
+
 #include "netcdf.h"
 #include "nclist.h"
 #include "ncjson.h"
 
 #define MAXREAD 8192
 
+/* Command line options */
+struct Jsonpptions {
+    int trace;
+} jsonoptions;
+
+static const char*
+sortname(int thesort)
+{
+    switch(thesort) {
+    default: break;
+    case NCJ_INT: return "NCJ_INT";
+    case NCJ_DOUBLE: return "NCJ_DOUBLE";
+    case NCJ_BOOLEAN: return "NCJ_BOOLEAN";
+    case NCJ_STRING: return "NCJ_STRING";
+    case NCJ_DICT: return "NCJ_DICT";
+    case NCJ_ARRAY: return "NCJ_ARRAY";
+    case NCJ_NULL: return "NCJ_NULL";
+    }
+    return "?";
+}
+
+
+static void
+jsontrace(NCjson* json, int depth)
+{
+    int i;
+    if(json == NULL) goto done;
+    printf("[%d] sort=%s",depth,sortname(NCJsort(json)));
+    switch(NCJsort(json)) {
+    case NCJ_INT:
+    case NCJ_DOUBLE:
+    case NCJ_BOOLEAN:
+    case NCJ_STRING:
+	printf(" string=|%s|\n",NCJstring(json));
+	break;
+    case NCJ_NULL:
+	printf("\n");
+	break;
+    case NCJ_ARRAY:
+	printf("\n");
+	for(i=0;i<NCJlength(json);i++)
+	    jsontrace(NCJith(json,i),depth+1);
+	break;
+    case NCJ_DICT:
+	printf("\n");
+	for(i=0;i<NCJlength(json);i+=2) {
+	    jsontrace(NCJith(json,i),depth+1);
+	    jsontrace(NCJith(json,i+1),depth+1);
+	} break;
+    default: break;
+    }
+done:
+    return;
+}
+
 int
 main(int argc, char** argv)
 {
     int stat = NC_NOERR;
     char text[MAXREAD+1];
     NCjson* json = NULL;
-    int i, red;
+    int i, red, c;
     FILE* f = NULL;
 
-    if(argc > 1) {
-	/* use argv[1] as input */
-	f = fopen(argv[1],"r");
-	if(f == NULL) {fprintf(stderr,"No such file: %s\n",argv[1]); exit(1);}
-    } else
-        f = stdin;
+    nc_initialize();
+    memset((void*)&jsonoptions,0,sizeof(jsonoptions));
+
+    while ((c = getopt(argc, argv, "t")) != EOF) {
+	switch(c) {
+	case 't': jsonoptions.trace = 1; break;
+	case '?':
+	   fprintf(stderr,"unknown option\n");
+	   exit(1);
+	}
+    }	
+
+    /* get file argument */
+    argc -= optind;
+    argv += optind;
+
+    if (argc > 1) {
+	fprintf(stderr, "zisjson: only one input file argument permitted\n");
+	exit(1);
+    }
+    if (argc == 0)
+	f = stdin;
+    else {
+        /* use argv[0] as input */
+        f = fopen(argv[0],"r");
+        if(f == NULL) {fprintf(stderr,"No such file: %s\n",argv[1]); exit(1);}
+    }
 
     /* Read json from stdin */
     for(i=0;;i++) {
@@ -54,9 +140,12 @@ main(int argc, char** argv)
 	stat = NC_EEMPTY;
     } else {
         stat = NCJparse(text,0,&json);
-	NCJreclaim(json);
+	if(!stat) {
+	    if(jsonoptions.trace) jsontrace(json,0);
+	    NCJreclaim(json);
+	}
     }
-    printf("%d",(stat==NC_NOERR?1:0)); /* parse success|failure */    
+    printf("%d",(stat?0:1)); /* parse success|failure */    
     if(f != stdin) fclose(f);
     return 0;
 }