diff --git a/src/extension/mapml/src/main/java/org/geoserver/mapml/MapMLDocumentBuilder.java b/src/extension/mapml/src/main/java/org/geoserver/mapml/MapMLDocumentBuilder.java
index f852427ab56..1e72e9f9135 100644
--- a/src/extension/mapml/src/main/java/org/geoserver/mapml/MapMLDocumentBuilder.java
+++ b/src/extension/mapml/src/main/java/org/geoserver/mapml/MapMLDocumentBuilder.java
@@ -15,6 +15,7 @@
 import static org.geoserver.mapml.MapMLHTMLOutput.PREVIEW_TCRS_MAP;
 import static org.geoserver.mapml.template.MapMLMapTemplate.MAPML_PREVIEW_HEAD_FTL;
 import static org.geoserver.mapml.template.MapMLMapTemplate.MAPML_XML_HEAD_FTL;
+import static org.geoserver.wms.capabilities.DimensionHelper.getDataType;
 
 import freemarker.template.TemplateMethodModelEx;
 import java.io.IOException;
@@ -26,6 +27,7 @@
 import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
@@ -33,12 +35,17 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.TreeSet;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import javax.servlet.http.HttpServletRequest;
+import org.apache.commons.lang3.StringUtils;
+import org.geoserver.catalog.Catalog;
+import org.geoserver.catalog.CoverageInfo;
+import org.geoserver.catalog.CoverageStoreInfo;
 import org.geoserver.catalog.DimensionInfo;
 import org.geoserver.catalog.FeatureTypeInfo;
 import org.geoserver.catalog.LayerGroupInfo;
@@ -49,6 +56,7 @@
 import org.geoserver.catalog.ResourceInfo;
 import org.geoserver.catalog.StyleInfo;
 import org.geoserver.catalog.impl.LayerGroupStyle;
+import org.geoserver.catalog.util.ReaderDimensionsAccessor;
 import org.geoserver.config.GeoServer;
 import org.geoserver.gwc.GWC;
 import org.geoserver.gwc.layer.GeoServerTileLayer;
@@ -84,12 +92,14 @@
 import org.geoserver.wms.WMSInfo;
 import org.geoserver.wms.WMSMapContent;
 import org.geoserver.wms.capabilities.CapabilityUtil;
+import org.geoserver.wms.capabilities.DimensionHelper;
 import org.geoserver.wms.featureinfo.FeatureTemplate;
 import org.geotools.api.feature.simple.SimpleFeatureType;
 import org.geotools.api.referencing.FactoryException;
 import org.geotools.api.referencing.crs.CoordinateReferenceSystem;
 import org.geotools.api.referencing.operation.TransformException;
 import org.geotools.api.style.Style;
+import org.geotools.coverage.grid.io.GridCoverage2DReader;
 import org.geotools.geometry.jts.ReferencedEnvelope;
 import org.geotools.referencing.CRS;
 import org.geotools.referencing.crs.DefaultGeographicCRS;
@@ -97,6 +107,7 @@
 import org.geotools.renderer.crs.ProjectionHandlerFinder;
 import org.geotools.util.NumberRange;
 import org.geotools.util.logging.Logging;
+import org.geowebcache.filter.parameters.ParameterFilter;
 import org.geowebcache.grid.GridSubset;
 import org.locationtech.jts.geom.Envelope;
 
@@ -171,13 +182,6 @@ public class MapMLDocumentBuilder {
     private Boolean isMultiExtent = MAPML_MULTILAYER_AS_MULTIEXTENT_DEFAULT;
     private MapMLMapTemplate mapMLMapTemplate = new MapMLMapTemplate();
 
-    static {
-        PREVIEW_TCRS_MAP.put("OSMTILE", new TiledCRS("OSMTILE"));
-        PREVIEW_TCRS_MAP.put("CBMTILE", new TiledCRS("CBMTILE"));
-        PREVIEW_TCRS_MAP.put("APSTILE", new TiledCRS("APSTILE"));
-        PREVIEW_TCRS_MAP.put("WGS84", new TiledCRS("WGS84"));
-    }
-
     /**
      * Constructor
      *
@@ -1009,10 +1013,6 @@ private List<Extent> prepareExtents() throws IOException {
         List<Extent> extents = new ArrayList<>();
         for (MapMLLayerMetadata mapMLLayerMetadata : mapMLLayerMetadataList) {
             Extent extent = new Extent();
-            if (isMultiExtent) {
-                extent.setHidden(null); // not needed for multi-extent
-                extent.setLabel(mapMLLayerMetadata.layerTitle);
-            }
             extent.setUnits(projType);
             extentList = extent.getInputOrDatalistOrLink();
 
@@ -1054,12 +1054,27 @@ private List<Extent> prepareExtents() throws IOException {
             String dimension = layerMeta.get("mapml.dimension", String.class);
             prepareExtentForLayer(mapMLLayerMetadata, dimension);
             generateTemplatedLinks(mapMLLayerMetadata);
+            if (isMultiExtent || isSingleLayerWithDimensionOptions(mapMLLayerMetadataList)) {
+                extent.setHidden(null); // not needed for multi-extent
+                extent.setLabel(mapMLLayerMetadata.layerTitle);
+            }
             extents.add(extent);
         }
 
         return extents;
     }
 
+    private boolean isSingleLayerWithDimensionOptions(
+            List<MapMLLayerMetadata> mapMLLayerMetadataList) {
+        if (mapMLLayerMetadataList.size() == 1) {
+            MapMLLayerMetadata metadata = mapMLLayerMetadataList.get(0);
+            return metadata.isTimeEnabled()
+                    || metadata.isElevationEnabled()
+                    || StringUtils.isNotBlank(metadata.getCustomDimension());
+        }
+        return false;
+    }
+
     /**
      * Prepare the extent for a layer
      *
@@ -1074,49 +1089,136 @@ private void prepareExtentForLayer(MapMLLayerMetadata mapMLLayerMetadata, String
         }
         LayerInfo layerInfo = mapMLLayerMetadata.getLayerInfo();
         ResourceInfo resourceInfo = layerInfo.getResource();
+        if (resourceInfo instanceof FeatureTypeInfo) {
+            prepareFeatureExtent((FeatureTypeInfo) resourceInfo, mapMLLayerMetadata, dimension);
+        } else if (resourceInfo instanceof CoverageInfo) {
+            prepareCoverageExtent((CoverageInfo) resourceInfo, mapMLLayerMetadata, dimension);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void prepareFeatureExtent(
+            FeatureTypeInfo typeInfo, MapMLLayerMetadata layerMetadata, String dimension)
+            throws IOException {
+        MetadataMap metadataMap = typeInfo.getMetadata();
+        DimensionOptions options;
         if ("Time".equalsIgnoreCase(dimension)) {
-            if (resourceInfo instanceof FeatureTypeInfo) {
-                FeatureTypeInfo typeInfo = (FeatureTypeInfo) resourceInfo;
-                DimensionInfo timeInfo =
-                        typeInfo.getMetadata().get(ResourceInfo.TIME, DimensionInfo.class);
-                if (timeInfo.isEnabled()) {
-                    mapMLLayerMetadata.setTimeEnabled(true);
-                    Set<Date> dates = wms.getFeatureTypeTimes(typeInfo);
-                    Select select = new Select();
-                    select.setId("time");
-                    select.setName("time");
-                    extentList.add(select);
-                    List<Option> options = select.getOptions();
-                    for (Date date : dates) {
-                        Option o = new Option();
-                        o.setContent(new SimpleDateFormat(DATE_FORMAT).format(date));
-                        options.add(o);
-                    }
-                }
+            options = initOptions(layerMetadata, metadataMap, ResourceInfo.TIME);
+            if (options.isAvailable()) {
+                options.addDates(wms.getFeatureTypeTimes(typeInfo));
             }
         } else if ("Elevation".equalsIgnoreCase(dimension)) {
-            if (resourceInfo instanceof FeatureTypeInfo) {
-                FeatureTypeInfo typeInfo = (FeatureTypeInfo) resourceInfo;
-                DimensionInfo elevInfo =
-                        typeInfo.getMetadata().get(ResourceInfo.ELEVATION, DimensionInfo.class);
-                if (elevInfo.isEnabled()) {
-                    mapMLLayerMetadata.setElevationEnabled(true);
-                    Set<Double> elevs = wms.getFeatureTypeElevations(typeInfo);
-                    Select select = new Select();
-                    select.setId("elevation");
-                    select.setName("elevation");
-                    extentList.add(select);
-                    List<Option> options = select.getOptions();
-                    for (Double elev : elevs) {
-                        Option o = new Option();
-                        o.setContent(elev.toString());
-                        options.add(o);
+            options = initOptions(layerMetadata, metadataMap, ResourceInfo.ELEVATION);
+            if (options.isAvailable()) {
+                options.addDoubles(wms.getFeatureTypeElevations(typeInfo));
+            }
+        } else {
+            options = initOptions(layerMetadata, metadataMap, dimension);
+            if (options.isAvailable()) {
+                DimensionInfo info = options.getInfo();
+                final TreeSet<Object> values = wms.getDimensionValues(typeInfo, info);
+                final Optional<Class<?>> dataTypeOpt = getDataType(values);
+                if (dataTypeOpt.isPresent()) {
+                    final Class<?> type = dataTypeOpt.get();
+                    if (Date.class.isAssignableFrom(type)) {
+                        options.addDates((Collection<Date>) (Collection<?>) values);
+                    } else if (Number.class.isAssignableFrom(type)) {
+                        options.addNumbers((Collection<Number>) (Collection<?>) values);
+                    } else {
+                        final List<String> valuesList =
+                                values.stream()
+                                        .filter(x -> x != null)
+                                        .map(x -> x.toString())
+                                        .collect(Collectors.toList());
+                        options.addStrings(valuesList);
                     }
                 }
             }
         }
     }
 
+    private void prepareCoverageExtent(
+            CoverageInfo cvInfo, MapMLLayerMetadata layerMetadata, String dimension)
+            throws IOException {
+        MetadataMap metadataMap = cvInfo.getMetadata();
+        DimensionOptions options;
+        DimensionInfo dimInfo;
+        ReaderDimensionsAccessor accessor;
+        if ("Time".equalsIgnoreCase(dimension)) {
+            options = initOptions(layerMetadata, metadataMap, ResourceInfo.TIME);
+            if (options.isAvailable()) {
+                dimInfo = options.getInfo();
+                accessor = getAccessor(cvInfo);
+                DimensionHelper.TemporalDimensionRasterHelper helper =
+                        new DimensionHelper.TemporalDimensionRasterHelper(dimInfo, accessor);
+
+                TreeSet<Object> domain = helper.getDomain();
+                String values = helper.getRepresentation(domain);
+                Collection<String> dates = Arrays.asList(values.split(","));
+                options.addStrings(dates);
+            }
+
+        } else if ("elevation".equalsIgnoreCase(dimension)) {
+            options = initOptions(layerMetadata, metadataMap, ResourceInfo.ELEVATION);
+            if (options.isAvailable()) {
+                dimInfo = options.getInfo();
+                accessor = getAccessor(cvInfo);
+
+                DimensionHelper.ElevationDimensionRasterHelper helper =
+                        new DimensionHelper.ElevationDimensionRasterHelper(dimInfo, accessor);
+
+                TreeSet<Object> domain = helper.getDomain();
+                String values = helper.getRepresentation(domain);
+                Collection<String> elevations = Arrays.asList(values.split(","));
+                options.addStrings(elevations);
+            }
+        }
+        /*
+        TODO:
+        custom dimensions setting is not trivial due to the custom_dimension_ prefix.
+        We need to properly manage it and make sure the options are properly propagated
+        */
+    }
+
+    private ReaderDimensionsAccessor getAccessor(CoverageInfo cvInfo) throws IOException {
+        GridCoverage2DReader reader = null;
+        Catalog catalog = cvInfo.getCatalog();
+        if (catalog == null)
+            throw new ServiceException(
+                    "Unable to acquire catalog resource for coverage: " + cvInfo.getName());
+
+        CoverageStoreInfo csinfo = cvInfo.getStore();
+        if (csinfo == null)
+            throw new ServiceException(
+                    "Unable to acquire coverage store resource for coverage: " + cvInfo.getName());
+
+        try {
+            reader = (GridCoverage2DReader) cvInfo.getGridCoverageReader(null, null);
+        } catch (Throwable t) {
+            LOGGER.log(
+                    Level.SEVERE,
+                    "Unable to acquire a reader for this coverage with format: "
+                            + csinfo.getFormat().getName(),
+                    t);
+        }
+        if (reader == null) {
+            throw new ServiceException(
+                    "Unable to acquire a reader for this coverage with format: "
+                            + csinfo.getFormat().getName());
+        }
+        ReaderDimensionsAccessor accessor = new ReaderDimensionsAccessor(reader);
+        return accessor;
+    }
+
+    private DimensionOptions initOptions(
+            MapMLLayerMetadata mapMLLayerMetadata, MetadataMap metadata, String dimName) {
+        DimensionOptions options = new DimensionOptions(mapMLLayerMetadata, metadata, dimName);
+        if (options.isAvailable()) {
+            extentList.add(options.getSelect());
+        }
+        return options;
+    }
+
     /**
      * Generate the JAXB Extent object contents: inputs and templated client links
      *
@@ -1222,13 +1324,10 @@ private void generateWMTSClientLinks(MapMLLayerMetadata mapMLLayerMetadata) {
         } else {
             params.put("format", imageFormat);
         }
-        if (mapMLLayerMetadata.isTimeEnabled()) {
-            params.put("time", "{time}");
-        }
-        if (mapMLLayerMetadata.isElevationEnabled()) {
-            params.put("elevation", "{elevation}");
-        }
-        if (cqlFilter.isPresent()) params.put("cql_filter", mapMLLayerMetadata.getCqlFilter());
+        setTimeParam(mapMLLayerMetadata, params, gstl);
+        setElevationParam(mapMLLayerMetadata, params, gstl);
+        setCustomDimensionParam(mapMLLayerMetadata, params, gstl);
+        setCqlFilterParam(mapMLLayerMetadata, params);
         String urlTemplate = "";
         try {
             urlTemplate =
@@ -1345,13 +1444,10 @@ private void generateTiledWMSClientLinks(MapMLLayerMetadata mapMLLayerMetadata)
         params.put("layers", mapMLLayerMetadata.getLayerName());
         params.put("language", this.request.getLocale().getLanguage());
         params.put("styles", mapMLLayerMetadata.getStyleName());
-        if (mapMLLayerMetadata.isTimeEnabled()) {
-            params.put("time", "{time}");
-        }
-        if (mapMLLayerMetadata.isElevationEnabled()) {
-            params.put("elevation", "{elevation}");
-        }
-        if (cqlFilter.isPresent()) params.put("cql_filter", mapMLLayerMetadata.getCqlFilter());
+        setTimeParam(mapMLLayerMetadata, params, null);
+        setElevationParam(mapMLLayerMetadata, params, null);
+        setCustomDimensionParam(mapMLLayerMetadata, params, null);
+        setCqlFilterParam(mapMLLayerMetadata, params);
         params.put("bbox", "{txmin},{tymin},{txmax},{tymax}");
         if (mapMLLayerMetadata.isUseFeatures()) {
             params.put("format", MAPML_MIME_TYPE);
@@ -1493,13 +1589,10 @@ public void generateWMSClientLinks(MapMLLayerMetadata mapMLLayerMetadata) {
         params.put("crs", projType.getCRSCode());
         params.put("layers", mapMLLayerMetadata.getLayerName());
         params.put("styles", mapMLLayerMetadata.getStyleName());
-        if (cqlFilter.isPresent()) params.put("cql_filter", mapMLLayerMetadata.getCqlFilter());
-        if (mapMLLayerMetadata.isTimeEnabled()) {
-            params.put("time", "{time}");
-        }
-        if (mapMLLayerMetadata.isElevationEnabled()) {
-            params.put("elevation", "{elevation}");
-        }
+        setCqlFilterParam(mapMLLayerMetadata, params);
+        setTimeParam(mapMLLayerMetadata, params, null);
+        setElevationParam(mapMLLayerMetadata, params, null);
+        setCustomDimensionParam(mapMLLayerMetadata, params, null);
         params.put("bbox", "{xmin},{ymin},{xmax},{ymax}");
         if (mapMLLayerMetadata.isUseFeatures()) {
             params.put("format", MAPML_MIME_TYPE);
@@ -1647,12 +1740,10 @@ private void generateWMSQueryClientLinks(MapMLLayerMetadata mapMLLayerMetadata)
         if (mapMLLayerMetadata.getCqlFilter() != null) {
             params.put("cql_filter", mapMLLayerMetadata.getCqlFilter());
         }
-        if (mapMLLayerMetadata.isTimeEnabled()) {
-            params.put("time", "{time}");
-        }
-        if (mapMLLayerMetadata.isElevationEnabled()) {
-            params.put("elevation", "{elevation}");
-        }
+        setTimeParam(mapMLLayerMetadata, params, null);
+        setElevationParam(mapMLLayerMetadata, params, null);
+        setCustomDimensionParam(mapMLLayerMetadata, params, null);
+
         if (mapMLLayerMetadata.isUseTiles()) {
             params.put("bbox", "{txmin},{tymin},{txmax},{tymax}");
             params.put("width", "256");
@@ -1679,6 +1770,59 @@ private void generateWMSQueryClientLinks(MapMLLayerMetadata mapMLLayerMetadata)
         extentList.add(queryLink);
     }
 
+    private void setCqlFilterParam(
+            MapMLLayerMetadata mapMLLayerMetadata, HashMap<String, String> params) {
+        if (cqlFilter.isPresent()) {
+            params.put("cql_filter", mapMLLayerMetadata.getCqlFilter());
+        }
+    }
+
+    private void setElevationParam(
+            MapMLLayerMetadata mapMLLayerMetadata,
+            HashMap<String, String> params,
+            GeoServerTileLayer tileLayer) {
+        if (mapMLLayerMetadata.isElevationEnabled()
+                && checkTileLayerParam(tileLayer, "elevation")) {
+            params.put("elevation", "{elevation}");
+        }
+    }
+
+    private void setTimeParam(
+            MapMLLayerMetadata mapMLLayerMetadata,
+            HashMap<String, String> params,
+            GeoServerTileLayer tileLayer) {
+        if (mapMLLayerMetadata.isTimeEnabled() && checkTileLayerParam(tileLayer, "time")) {
+            params.put("time", "{time}");
+        }
+    }
+
+    private void setCustomDimensionParam(
+            MapMLLayerMetadata mapMLLayerMetadata,
+            HashMap<String, String> params,
+            GeoServerTileLayer tileLayer) {
+        String customDimension = mapMLLayerMetadata.getCustomDimension();
+        if (StringUtils.isNotBlank(customDimension)
+                && checkTileLayerParam(tileLayer, customDimension)) {
+            params.put(customDimension, "{" + customDimension + "}");
+        }
+    }
+
+    private boolean checkTileLayerParam(GeoServerTileLayer tileLayer, String name) {
+        // If no GeoServerTileLayer has been provided, we don't need to check it and
+        // we can set the param.
+        if (tileLayer == null) return true;
+        // If a GeoServerTileLayer has been provided, we need to check if it contains
+        // a filter to deal with that specific dimension and only in that case we add
+        // the param.
+        List<ParameterFilter> paramFilters = tileLayer.getParameterFilters();
+        for (ParameterFilter param : paramFilters) {
+            if (name.equalsIgnoreCase(param.getKey())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /**
      * Get the MapML HTML document
      *
@@ -2088,6 +2232,81 @@ public void setTitle(String title) {
         }
     }
 
+    static class DimensionOptions {
+
+        DimensionInfo info;
+        List<Option> options;
+        Select select;
+        boolean available;
+
+        public DimensionOptions(
+                MapMLLayerMetadata mapMLLayerMetadata, MetadataMap metadata, String name) {
+            info = metadata.get(name, DimensionInfo.class);
+            if (info != null && info.isEnabled()) {
+                if ("elevation".equalsIgnoreCase(name)) {
+                    mapMLLayerMetadata.setElevationEnabled(true);
+                } else if ("time".equalsIgnoreCase(name)) {
+                    mapMLLayerMetadata.setTimeEnabled(true);
+                } else {
+                    mapMLLayerMetadata.setCustomDimension(name);
+                }
+                available = true;
+                select = new Select();
+                select.setId(name);
+                select.setName(name);
+                options = select.getOptions();
+            }
+        }
+
+        public DimensionInfo getInfo() {
+            return info;
+        }
+
+        public List<Option> getOptions() {
+            return options;
+        }
+
+        public Select getSelect() {
+            return select;
+        }
+
+        public boolean isAvailable() {
+            return available;
+        }
+
+        public void addStrings(Collection<String> values) {
+            for (String value : values) {
+                Option o = new Option();
+                o.setContent(value);
+                options.add(o);
+            }
+        }
+
+        public void addDates(Collection<Date> dates) {
+            for (Date date : dates) {
+                Option o = new Option();
+                o.setContent(new SimpleDateFormat(DATE_FORMAT).format(date));
+                options.add(o);
+            }
+        }
+
+        public void addDoubles(Collection<Double> values) {
+            for (Double value : values) {
+                Option o = new Option();
+                o.setContent(value.toString());
+                options.add(o);
+            }
+        }
+
+        public void addNumbers(Collection<Number> values) {
+            for (Number value : values) {
+                Option o = new Option();
+                o.setContent(value.toString());
+                options.add(o);
+            }
+        }
+    }
+
     /** MapML layer metadata */
     static class MapMLLayerMetadata {
         private String cqlFilter;
@@ -2110,6 +2329,7 @@ static class MapMLLayerMetadata {
 
         private boolean timeEnabled;
         private boolean elevationEnabled;
+        private String customDimension;
 
         private ReferencedEnvelope bbbox;
 
@@ -2241,6 +2461,24 @@ public void setTimeEnabled(boolean timeEnabled) {
             this.timeEnabled = timeEnabled;
         }
 
+        /**
+         * get the layer's enabled custom dimension (if any)
+         *
+         * @return customDimension
+         */
+        public String getCustomDimension() {
+            return customDimension;
+        }
+
+        /**
+         * set the enabled customDimension
+         *
+         * @param customDimension
+         */
+        public void setCustomDimension(String customDimension) {
+            this.customDimension = customDimension;
+        }
+
         /**
          * get if the layer has a tile layer
          *
diff --git a/src/extension/mapml/src/test/java/org/geoserver/mapml/MapMLDimensionsTest.java b/src/extension/mapml/src/test/java/org/geoserver/mapml/MapMLDimensionsTest.java
index 68b103f5d66..793b94b3a82 100644
--- a/src/extension/mapml/src/test/java/org/geoserver/mapml/MapMLDimensionsTest.java
+++ b/src/extension/mapml/src/test/java/org/geoserver/mapml/MapMLDimensionsTest.java
@@ -16,6 +16,7 @@
 import org.custommonkey.xmlunit.XMLUnit;
 import org.custommonkey.xmlunit.XpathEngine;
 import org.geoserver.catalog.Catalog;
+import org.geoserver.catalog.CoverageInfo;
 import org.geoserver.catalog.DimensionInfo;
 import org.geoserver.catalog.DimensionPresentation;
 import org.geoserver.catalog.FeatureTypeInfo;
@@ -23,13 +24,14 @@
 import org.geoserver.catalog.ResourceInfo;
 import org.geoserver.config.GeoServerInfo;
 import org.geoserver.data.test.SystemTestData;
-import org.geoserver.wms.WMSDimensionsTestSupport;
+import org.geoserver.wms.wms_1_3.DimensionsVectorGetMap_1_3Test;
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.mock.web.MockHttpServletRequest;
+import org.w3c.dom.Document;
 
 /** @author prushforth */
-public class MapMLDimensionsTest extends WMSDimensionsTestSupport {
+public class MapMLDimensionsTest extends DimensionsVectorGetMap_1_3Test {
     private XpathEngine xpath;
 
     @Before
@@ -107,27 +109,7 @@ public void testElevationList() throws Exception {
         // doesn't test the web interface, but the does test the mechanism
         // the web interface uses to signal dimenion for mapml
         layerMeta = catalog.getLayerByName(getLayerId(V_TIME_ELEVATION)).getResource();
-        MetadataMap mm = layerMeta.getMetadata();
-        mm.put("mapml.dimension", "elevation");
-        catalog.save(layerMeta);
-
-        doc = getMapML(path);
-        assertXpathEvaluatesTo("1", "count(//html:map-link[@rel='image'][@tref])", doc);
-        url = new URL(xpath.evaluate("//html:map-link[@rel='image']/@tref", doc));
-        vars = parseQuery(url);
-        assertTrue(vars.get("elevation").equalsIgnoreCase("{elevation}"));
-
-        assertXpathEvaluatesTo("1", "count(//html:map-link[@rel='query'][@tref])", doc);
-        url = new URL(xpath.evaluate("//html:map-link[@rel='query']/@tref", doc));
-        vars = parseQuery(url);
-        assertTrue(vars.get("elevation").equalsIgnoreCase("{elevation}"));
-
-        assertXpathEvaluatesTo(
-                "1", "count(//html:map-select[@name='elevation'][@id='elevation'])", doc);
-        assertXpathEvaluatesTo(
-                "4",
-                "count(//html:map-select[@name='elevation'][@id='elevation']/html:map-option)",
-                doc);
+        assertMapMlDocumentHasDimension(catalog, layerMeta, path, "elevation", "4");
     }
 
     @Test
@@ -177,24 +159,192 @@ public void testTimeList() throws Exception {
         // doesn't test the web interface, but the does test the mechanism
         // the web interface uses to signal dimenion for mapml
         layerMeta = catalog.getLayerByName(getLayerId(V_TIME_ELEVATION)).getResource();
+        assertMapMlDocumentHasDimension(catalog, layerMeta, path, "time", "4");
+    }
+
+    @Test
+    public void testCustomDimensions() throws Exception {
+        Catalog catalog = getCatalog();
+        String dimensionName = "dim_custom";
+        ResourceInfo layerMeta = catalog.getLayerByName(getLayerId(V_TIME_ELEVATION)).getResource();
+
+        assertTrue(layerMeta instanceof FeatureTypeInfo);
+
+        FeatureTypeInfo typeInfo = (FeatureTypeInfo) layerMeta;
+        // layer has no dimension yet
+        assertNull(typeInfo.getMetadata().get(dimensionName, DimensionInfo.class));
+        setupVectorDimension(
+                dimensionName, "elevation", DimensionPresentation.LIST, null, UNITS, UNIT_SYMBOL);
+
+        // re-query the catalog for the updated info
+        typeInfo =
+                (FeatureTypeInfo)
+                        catalog.getLayerByName(getLayerId(V_TIME_ELEVATION)).getResource();
+        // get the diminsion info fromt the metadata map
+        DimensionInfo info = typeInfo.getMetadata().get(dimensionName, DimensionInfo.class);
+        // prove it's enabled, but not yet known to mapml
+        assertTrue(info.isEnabled());
+
+        // get the mapml doc for the layer
+        String path =
+                "wms?LAYERS="
+                        + getLayerId(V_TIME_ELEVATION)
+                        + "&STYLES=&FORMAT="
+                        + MapMLConstants.MAPML_MIME_TYPE
+                        + "&SERVICE=WMS&VERSION=1.3.0"
+                        + "&REQUEST=GetMap"
+                        + "&SRS=EPSG:3857"
+                        + "&BBOX=0,0,1,1"
+                        + "&WIDTH=150"
+                        + "&HEIGHT=150"
+                        + "&format_options="
+                        + MapMLConstants.MAPML_WMS_MIME_TYPE_OPTION
+                        + ":image/png";
+        org.w3c.dom.Document doc = getMapML(path);
+        // assure us it's actually working as a document
+        assertXpathEvaluatesTo("1", "count(//html:map-link[@rel='image'][@tref])", doc);
+        URL url = new URL(xpath.evaluate("//html:map-link[@rel='image']/@tref", doc));
+        // assert that there's no variable nor URL template variable
+        HashMap<String, String> vars = parseQuery(url);
+        assertNull(vars.get(dimensionName));
+        assertXpathEvaluatesTo("0", "count(//html:map-select[@name='dim_custom'])", doc);
+        // update the layer metadata to indicate the dimension is known to mapml
+        // doesn't test the web interface, but the does test the mechanism
+        // the web interface uses to signal dimension for mapml
+        layerMeta = catalog.getLayerByName(getLayerId(V_TIME_ELEVATION)).getResource();
+        assertMapMlDocumentHasDimension(catalog, layerMeta, path, dimensionName, "4");
+    }
+
+    @Test
+    public void testRasterTimeList() throws Exception {
+        Catalog catalog = getCatalog();
+        ResourceInfo layerMeta = catalog.getLayerByName(getLayerId(WATTEMP)).getResource();
+        assertTrue(layerMeta instanceof CoverageInfo);
+        CoverageInfo coverageInfo = (CoverageInfo) layerMeta;
+        // layer has no dimension yet
+        assertNull(coverageInfo.getMetadata().get(ResourceInfo.TIME, DimensionInfo.class));
+        setupRasterDimension(
+                WATTEMP, ResourceInfo.TIME, DimensionPresentation.LIST, null, null, null);
+
+        // re-query the catalog for the updated info
+        coverageInfo = (CoverageInfo) catalog.getLayerByName(getLayerId(WATTEMP)).getResource();
+        // get the dimension info from the metadata map
+        DimensionInfo timeInfo =
+                coverageInfo.getMetadata().get(ResourceInfo.TIME, DimensionInfo.class);
+        // prove it's enabled, but not yet known to mapml
+        assertTrue(timeInfo.isEnabled());
+
+        // get the mapml doc for the layer
+        String path =
+                "wms?LAYERS="
+                        + getLayerId(WATTEMP)
+                        + "&STYLES=&FORMAT="
+                        + MapMLConstants.MAPML_MIME_TYPE
+                        + "&SERVICE=WMS&VERSION=1.3.0"
+                        + "&REQUEST=GetMap"
+                        + "&SRS=EPSG:3857"
+                        + "&BBOX=0,0,1,1"
+                        + "&WIDTH=150"
+                        + "&HEIGHT=150"
+                        + "&format_options="
+                        + MapMLConstants.MAPML_WMS_MIME_TYPE_OPTION
+                        + ":image/png";
+        org.w3c.dom.Document doc = getMapML(path);
+        // assure us it's actually working as a document
+        assertXpathEvaluatesTo("1", "count(//html:map-link[@rel='image'][@tref])", doc);
+        URL url = new URL(xpath.evaluate("//html:map-link[@rel='image']/@tref", doc));
+        // assert that there's no elevation variable nor URL template variable
+        HashMap<String, String> vars = parseQuery(url);
+        assertNull(vars.get("elevation"));
+        assertXpathEvaluatesTo("0", "count(//html:map-select[@name='time'])", doc);
+        // update the layer metadata to indicate the dimension is known to mapml
+        // doesn't test the web interface, but the does test the mechanism
+        // the web interface uses to signal dimenion for mapml
+        layerMeta = catalog.getLayerByName(getLayerId(WATTEMP)).getResource();
+        assertMapMlDocumentHasDimension(catalog, layerMeta, path, "time", "2");
+    }
+
+    @Test
+    public void testRasterElevationList() throws Exception {
+        Catalog catalog = getCatalog();
+        ResourceInfo layerMeta = catalog.getLayerByName(getLayerId(WATTEMP)).getResource();
+        assertTrue(layerMeta instanceof CoverageInfo);
+        CoverageInfo coverageInfo = (CoverageInfo) layerMeta;
+        // layer has no dimension yet
+        assertNull(coverageInfo.getMetadata().get(ResourceInfo.ELEVATION, DimensionInfo.class));
+        setupRasterDimension(
+                WATTEMP, ResourceInfo.ELEVATION, DimensionPresentation.LIST, null, null, null);
+
+        // re-query the catalog for the updated info
+        coverageInfo = (CoverageInfo) catalog.getLayerByName(getLayerId(WATTEMP)).getResource();
+        // get the dimension info from the metadata map
+        DimensionInfo elevationInfo =
+                coverageInfo.getMetadata().get(ResourceInfo.ELEVATION, DimensionInfo.class);
+        // prove it's enabled, but not yet known to mapml
+        assertTrue(elevationInfo.isEnabled());
+
+        // get the mapml doc for the layer
+        String path =
+                "wms?LAYERS="
+                        + getLayerId(WATTEMP)
+                        + "&STYLES=&FORMAT="
+                        + MapMLConstants.MAPML_MIME_TYPE
+                        + "&SERVICE=WMS&VERSION=1.3.0"
+                        + "&REQUEST=GetMap"
+                        + "&SRS=EPSG:3857"
+                        + "&BBOX=0,0,1,1"
+                        + "&WIDTH=150"
+                        + "&HEIGHT=150"
+                        + "&format_options="
+                        + MapMLConstants.MAPML_WMS_MIME_TYPE_OPTION
+                        + ":image/png";
+        org.w3c.dom.Document doc = getMapML(path);
+        // assure us it's actually working as a document
+        assertXpathEvaluatesTo("1", "count(//html:map-link[@rel='image'][@tref])", doc);
+        URL url = new URL(xpath.evaluate("//html:map-link[@rel='image']/@tref", doc));
+        // assert that there's no time variable nor URL template variable
+        HashMap<String, String> vars = parseQuery(url);
+        assertNull(vars.get("time"));
+        assertXpathEvaluatesTo("0", "count(//html:map-select[@name='elevation'])", doc);
+        // update the layer metadata to indicate the dimension is known to mapml
+        // doesn't test the web interface, but the does test the mechanism
+        // the web interface uses to signal dimension for mapml
+        layerMeta = catalog.getLayerByName(getLayerId(WATTEMP)).getResource();
+        assertMapMlDocumentHasDimension(catalog, layerMeta, path, "elevation", "2");
+    }
+
+    private void assertMapMlDocumentHasDimension(
+            Catalog catalog,
+            ResourceInfo layerMeta,
+            String path,
+            String dimension,
+            String expectedCount)
+            throws Exception {
         MetadataMap mm = layerMeta.getMetadata();
-        mm.put("mapml.dimension", "time");
+        mm.put("mapml.dimension", dimension);
         catalog.save(layerMeta);
-
-        doc = getMapML(path);
+        Document doc = getMapML(path);
         assertXpathEvaluatesTo("1", "count(//html:map-link[@rel='image'][@tref])", doc);
-        url = new URL(xpath.evaluate("//html:map-link[@rel='image']/@tref", doc));
-        vars = parseQuery(url);
-        assertTrue(vars.get("time").equalsIgnoreCase("{time}"));
+        URL url = new URL(xpath.evaluate("//html:map-link[@rel='image']/@tref", doc));
+        HashMap<String, String> vars = parseQuery(url);
+        assertTrue(vars.get(dimension).equalsIgnoreCase("{" + dimension + "}"));
 
         assertXpathEvaluatesTo("1", "count(//html:map-link[@rel='query'][@tref])", doc);
         url = new URL(xpath.evaluate("//html:map-link[@rel='query']/@tref", doc));
         vars = parseQuery(url);
-        assertTrue(vars.get("time").equalsIgnoreCase("{time}"));
-
-        assertXpathEvaluatesTo("1", "count(//html:map-select[@name='time'][@id='time'])", doc);
+        assertTrue(vars.get(dimension).equalsIgnoreCase("{" + dimension + "}"));
+        assertXpathEvaluatesTo(
+                "1",
+                "count(//html:map-select[@name='" + dimension + "'][@id='" + dimension + "'])",
+                doc);
         assertXpathEvaluatesTo(
-                "4", "count(//html:map-select[@name='time'][@id='time']/html:map-option)", doc);
+                expectedCount,
+                "count(//html:map-select[@name='"
+                        + dimension
+                        + "'][@id='"
+                        + dimension
+                        + "']/html:map-option)",
+                doc);
     }
 
     /**
diff --git a/src/wms/src/main/java/org/geoserver/wms/capabilities/DimensionHelper.java b/src/wms/src/main/java/org/geoserver/wms/capabilities/DimensionHelper.java
index 0a8b8b994b9..4de8fbbb046 100644
--- a/src/wms/src/main/java/org/geoserver/wms/capabilities/DimensionHelper.java
+++ b/src/wms/src/main/java/org/geoserver/wms/capabilities/DimensionHelper.java
@@ -59,6 +59,104 @@
  */
 public abstract class DimensionHelper {
 
+    public static class ElevationDimensionRasterHelper {
+
+        private final DimensionInfo elevationInfo;
+        private final ReaderDimensionsAccessor accessor;
+
+        public ElevationDimensionRasterHelper(
+                DimensionInfo elevationInfo, ReaderDimensionsAccessor accessor) {
+            this.elevationInfo = elevationInfo;
+            this.accessor = accessor;
+        }
+
+        public TreeSet<Object> getDomain() throws IOException {
+            TreeSet<Object> elevations = null;
+            try {
+                if (elevationInfo.getPresentation() != DimensionPresentation.LIST) {
+                    String startValue = elevationInfo.getStartValue();
+                    String endValue = elevationInfo.getEndValue();
+                    if (!StringUtils.isEmpty(startValue) && !StringUtils.isEmpty(endValue)) {
+                        elevations = new TreeSet<>();
+                        elevations.add(Double.parseDouble(startValue));
+                        elevations.add(Double.parseDouble(endValue));
+                    } else {
+                        Double minValue = accessor.getMinElevation();
+                        if (minValue != null) {
+                            elevations = new TreeSet<>();
+                            elevations.add(minValue);
+                            elevations.add(accessor.getMaxElevation());
+                        }
+                    }
+                }
+                if (elevations == null) {
+                    throw new Exception(
+                            "The \"List\" presentation of the elevation dimension has been selected");
+                }
+            } catch (Exception ex) {
+                if (LOGGER.isLoggable(Level.FINE)) {
+                    LOGGER.log(Level.FINE, "Dimension has not been extracted. The reason: ", ex);
+                }
+                elevations = accessor.getElevationDomain();
+            }
+            return elevations;
+        }
+
+        public String getRepresentation(TreeSet<Object> elevations) {
+            return getNumberRepresentation(elevationInfo, elevations);
+        }
+    }
+
+    public static class TemporalDimensionRasterHelper {
+
+        private final DimensionInfo timeInfo;
+        private final ReaderDimensionsAccessor accessor;
+
+        public TemporalDimensionRasterHelper(
+                DimensionInfo timeInfo, ReaderDimensionsAccessor accessor) {
+            this.timeInfo = timeInfo;
+            this.accessor = accessor;
+        }
+
+        public TreeSet<Object> getDomain() throws IOException {
+            TreeSet<Object> temporalDomain = null;
+
+            try {
+                if (timeInfo.getPresentation() != DimensionPresentation.LIST) {
+                    String startValue = timeInfo.getStartValue();
+                    String endValue = timeInfo.getEndValue();
+                    if (startValue != null && endValue != null) {
+                        temporalDomain = new TreeSet<>();
+                        temporalDomain.add(parseTimeRangeValue(startValue));
+                        temporalDomain.add(parseTimeRangeValue(endValue));
+                    } else {
+                        Date minValue = accessor.getMinTime();
+                        if (minValue != null) {
+                            temporalDomain = new TreeSet<>();
+                            temporalDomain.add(minValue);
+                            temporalDomain.add(accessor.getMaxTime());
+                        }
+                    }
+                }
+                if (temporalDomain == null) {
+                    throw new Exception(
+                            "The \"List\" presentation of the temporal dimension has been selected");
+                }
+            } catch (Exception ex) {
+                if (LOGGER.isLoggable(Level.FINE)) {
+                    LOGGER.log(Level.FINE, "Dimension has not been extracted. The reason: ", ex);
+                }
+                temporalDomain = accessor.getTimeDomain();
+            }
+            return temporalDomain;
+        }
+
+        /** Builds the proper presentation given the current */
+        public String getRepresentation(TreeSet<? extends Object> values) {
+            return getTemporalDomainRepresentation(timeInfo, values);
+        }
+    }
+
     static final Logger LOGGER = Logging.getLogger(DimensionHelper.class);
     public static final String NEAREST_VALUE = "nearestValue";
     public static final String NAME = "name";
@@ -180,7 +278,7 @@ void handleCustomDimensionVector(
         }
     }
 
-    Optional<Class<?>> getDataType(Set<Object> values) {
+    public static Optional<Class<?>> getDataType(Set<Object> values) {
         return values.stream().filter(x -> x != null).findFirst().map(Object::getClass);
     }
 
@@ -339,35 +437,11 @@ void handleRasterLayerDimensions(final LayerInfo layer) throws RuntimeException,
     private void handleElevationDimensionRaster(
             CoverageInfo cvInfo, DimensionInfo elevInfo, ReaderDimensionsAccessor dimensions)
             throws IOException {
-        TreeSet<Object> elevations = null;
-        try {
-            if (elevInfo.getPresentation() != DimensionPresentation.LIST) {
-                String startValue = elevInfo.getStartValue();
-                String endValue = elevInfo.getEndValue();
-                if (!StringUtils.isEmpty(startValue) && !StringUtils.isEmpty(endValue)) {
-                    elevations = new TreeSet<>();
-                    elevations.add(Double.parseDouble(startValue));
-                    elevations.add(Double.parseDouble(endValue));
-                } else {
-                    Double minValue = dimensions.getMinElevation();
-                    if (minValue != null) {
-                        elevations = new TreeSet<>();
-                        elevations.add(minValue);
-                        elevations.add(dimensions.getMaxElevation());
-                    }
-                }
-            }
-            if (elevations == null) {
-                throw new Exception(
-                        "The \"List\" presentation of the elevation dimension has been selected");
-            }
-        } catch (Exception ex) {
-            if (LOGGER.isLoggable(Level.FINE)) {
-                LOGGER.log(Level.FINE, "Dimension has not been extracted. The reason: ", ex);
-            }
-            elevations = dimensions.getElevationDomain();
-        }
-        String elevationMetadata = getNumberRepresentation(elevInfo, elevations);
+        ElevationDimensionRasterHelper elevationDimensionRH =
+                new ElevationDimensionRasterHelper(elevInfo, dimensions);
+        TreeSet<Object> elevations = elevationDimensionRH.getDomain();
+        String elevationMetadata = elevationDimensionRH.getRepresentation(elevations);
+
         String defaultValue = getDefaultValueRepresentation(cvInfo, ResourceInfo.ELEVATION, "0");
         writeElevationDimension(
                 elevations,
@@ -393,34 +467,9 @@ private String getDefaultValueRepresentation(
     private void handleTimeDimensionRaster(
             CoverageInfo cvInfo, DimensionInfo timeInfo, ReaderDimensionsAccessor dimension)
             throws IOException {
-        TreeSet<Object> temporalDomain = null;
-        try {
-            if (timeInfo.getPresentation() != DimensionPresentation.LIST) {
-                String startValue = timeInfo.getStartValue();
-                String endValue = timeInfo.getEndValue();
-                if (startValue != null && endValue != null) {
-                    temporalDomain = new TreeSet<>();
-                    temporalDomain.add(parseTimeRangeValue(startValue));
-                    temporalDomain.add(parseTimeRangeValue(endValue));
-                } else {
-                    Date minValue = dimension.getMinTime();
-                    if (minValue != null) {
-                        temporalDomain = new TreeSet<>();
-                        temporalDomain.add(minValue);
-                        temporalDomain.add(dimension.getMaxTime());
-                    }
-                }
-            }
-            if (temporalDomain == null) {
-                throw new Exception(
-                        "The \"List\" presentation of the temporal dimension has been selected");
-            }
-        } catch (Exception ex) {
-            if (LOGGER.isLoggable(Level.FINE)) {
-                LOGGER.log(Level.FINE, "Dimension has not been extracted. The reason: ", ex);
-            }
-            temporalDomain = dimension.getTimeDomain();
-        }
+        TemporalDimensionRasterHelper temporalDimensionRH =
+                new TemporalDimensionRasterHelper(timeInfo, dimension);
+        TreeSet<Object> temporalDomain = temporalDimensionRH.getDomain();
         String timeMetadata = getTemporalDomainRepresentation(timeInfo, temporalDomain);
         String defaultValue =
                 getDefaultValueRepresentation(
@@ -485,7 +534,7 @@ private void declareWMS11Dimensions(
     }
 
     @SuppressWarnings("PMD.UnnecessaryWrapperObjectCreation")
-    protected String getNumberRepresentation(
+    protected static String getNumberRepresentation(
             DimensionInfo dimension, TreeSet<? extends Object> values) {
         String elevationMetadata = null;
 
@@ -567,21 +616,20 @@ protected String getNumberRepresentation(
         return elevationMetadata;
     }
 
-    private boolean isDecimal(Class<?> typeBinding) {
+    private static boolean isDecimal(Class<?> typeBinding) {
         return Float.class.isAssignableFrom(typeBinding)
                 || Double.class.isAssignableFrom(typeBinding)
                 || BigDecimal.class.isAssignableFrom(typeBinding);
     }
 
-    /** Builds the proper presentation given the current */
-    String getTemporalDomainRepresentation(
-            DimensionInfo dimension, TreeSet<? extends Object> values) {
+    static String getTemporalDomainRepresentation(
+            DimensionInfo timeInfo, TreeSet<? extends Object> values) {
         String timeMetadata = null;
 
         final StringBuilder buff = new StringBuilder();
         final ISO8601Formatter df = new ISO8601Formatter();
 
-        if (DimensionPresentation.LIST == dimension.getPresentation()) {
+        if (DimensionPresentation.LIST == timeInfo.getPresentation()) {
             for (Object date : values) {
                 buff.append(df.format(date));
                 buff.append(",");
@@ -591,21 +639,21 @@ String getTemporalDomainRepresentation(
                             .replaceAll("\\[", "")
                             .replaceAll("\\]", "")
                             .replaceAll(" ", "");
-        } else if (DimensionPresentation.CONTINUOUS_INTERVAL == dimension.getPresentation()) {
+        } else if (DimensionPresentation.CONTINUOUS_INTERVAL == timeInfo.getPresentation()) {
             DateRange interval = getMinMaxTimeInterval(values);
             buff.append(df.format(interval.getMinValue()));
             buff.append("/");
             buff.append(df.format(interval.getMaxValue()));
             buff.append("/PT1S");
             timeMetadata = buff.toString();
-        } else if (DimensionPresentation.DISCRETE_INTERVAL == dimension.getPresentation()) {
+        } else if (DimensionPresentation.DISCRETE_INTERVAL == timeInfo.getPresentation()) {
             DateRange interval = getMinMaxTimeInterval(values);
             buff.append(df.format(interval.getMinValue()));
             buff.append("/");
             buff.append(df.format(interval.getMaxValue()));
             buff.append("/");
 
-            final BigDecimal resolution = dimension.getResolution();
+            final BigDecimal resolution = timeInfo.getResolution();
             if (resolution != null) {
                 // resolution has been provided
                 buff.append(new DefaultPeriodDuration(resolution.longValue()).toString());
@@ -633,7 +681,7 @@ String getTemporalDomainRepresentation(
     }
 
     /** Builds a single time range from the domain, be it made of Date or TimeRange objects */
-    private DateRange getMinMaxTimeInterval(TreeSet<? extends Object> values) {
+    private static DateRange getMinMaxTimeInterval(TreeSet<? extends Object> values) {
         Object minValue = values.first();
         Object maxValue = values.last();
         Date min, max;
@@ -652,7 +700,8 @@ private DateRange getMinMaxTimeInterval(TreeSet<? extends Object> values) {
 
     /** Builds a single Z range from the domain, be it made of Number or NumberRange objects */
     @SuppressWarnings("unchecked")
-    private NumberRange<? extends Number> getMinMaxZInterval(TreeSet<? extends Object> values) {
+    private static NumberRange<? extends Number> getMinMaxZInterval(
+            TreeSet<? extends Object> values) {
         Object minValue = values.first();
         Object maxValue = values.last();
         Number min, max;
@@ -670,7 +719,7 @@ private NumberRange<? extends Number> getMinMaxZInterval(TreeSet<? extends Objec
     }
 
     /** Returns true if all the values in the set are Date instances */
-    private boolean allDates(TreeSet<? extends Object> values) {
+    private static boolean allDates(TreeSet<? extends Object> values) {
         for (Object value : values) {
             if (!(value instanceof Date)) {
                 return false;
@@ -681,7 +730,7 @@ private boolean allDates(TreeSet<? extends Object> values) {
     }
 
     /** Returns true if all the values in the set are Number instances */
-    private boolean allNumbers(TreeSet<? extends Object> values) {
+    private static boolean allNumbers(TreeSet<? extends Object> values) {
         for (Object value : values) {
             if (!(value instanceof Number)) {
                 return false;