diff --git a/filament/src/details/Material.h b/filament/src/details/Material.h
index d0e9d1492ba6..d6cca777be29 100644
--- a/filament/src/details/Material.h
+++ b/filament/src/details/Material.h
@@ -154,7 +154,14 @@ class FMaterial : public Material {
 #if FILAMENT_ENABLE_MATDBG
         assert_invariant((size_t)variant.key < VARIANT_COUNT);
         std::unique_lock<utils::Mutex> lock(mActiveProgramsLock);
-        mActivePrograms.set(variant.key);
+        if (getMaterialDomain() == MaterialDomain::SURFACE) {
+            auto vert = Variant::filterVariantVertex(variant);
+            auto frag = Variant::filterVariantFragment(variant);
+            mActivePrograms.set(vert.key);
+            mActivePrograms.set(frag.key);
+        } else {
+            mActivePrograms.set(variant.key);
+        }
         lock.unlock();
 
         if (isSharedVariant(variant)) {
diff --git a/libs/matdbg/src/ApiHandler.cpp b/libs/matdbg/src/ApiHandler.cpp
index 80d00e23389c..3c53265317cf 100644
--- a/libs/matdbg/src/ApiHandler.cpp
+++ b/libs/matdbg/src/ApiHandler.cpp
@@ -336,7 +336,7 @@ bool ApiHandler::handleGet(CivetServer* server, struct mg_connection* conn) {
                 return error(__LINE__, uri);
             }
             bool const last = (++index) == mServer->mMaterialRecords.size();
-            mg_printf(conn, "\"%8.8x\": %s %s", pair.first, writer.getJsonString(),
+            mg_printf(conn, "\"%8.8x\": %s%s", pair.first, writer.getJsonString(),
                     last ? "" : ",");
         }
         mg_printf(conn, "}");
diff --git a/libs/matdbg/src/ShaderInfo.cpp b/libs/matdbg/src/ShaderInfo.cpp
index cba7bf648df9..632c20d71177 100644
--- a/libs/matdbg/src/ShaderInfo.cpp
+++ b/libs/matdbg/src/ShaderInfo.cpp
@@ -16,6 +16,8 @@
 
 #include <matdbg/ShaderInfo.h>
 
+#include "CommonWriter.h"
+
 #include <filaflat/ChunkContainer.h>
 #include <filaflat/DictionaryReader.h>
 #include <filaflat/MaterialChunk.h>
@@ -54,6 +56,11 @@ bool getShaderInfo(const ChunkContainer& container, ShaderInfo* info, ChunkType
         return true;
     }
 
+    MaterialDomain domain;
+    if (!read(container, ChunkType::MaterialDomain, reinterpret_cast<uint8_t*>(&domain))) {
+        return false;
+    }
+
     auto [start, end] = container.getChunkRange(chunkType);
     Unflattener unflattener(start, end);
 
@@ -84,6 +91,12 @@ bool getShaderInfo(const ChunkContainer& container, ShaderInfo* info, ChunkType
             return false;
         }
 
+        auto stage = ShaderStage(pipelineStageValue);
+        if (domain == MaterialDomain::SURFACE) {
+            variant = stage == ShaderStage::VERTEX ?
+                    Variant::filterVariantVertex(variant) :
+                    Variant::filterVariantFragment(variant);
+        }
         *info++ = {
             .shaderModel = ShaderModel(shaderModelValue),
             .variant = variant,
diff --git a/libs/matdbg/web/api.js b/libs/matdbg/web/api.js
index f16fec3a90ea..a6e62f788d52 100644
--- a/libs/matdbg/web/api.js
+++ b/libs/matdbg/web/api.js
@@ -68,11 +68,11 @@ async function fetchMatIds() {
 }
 
 async function queryActiveShaders() {
-    const activeMaterials = await _fetchJson("api/active");
+    const activeVariants = await _fetchJson("api/active");
     const actives = {};
-    for (matid in activeMaterials) {
-        const backend = activeMaterials[matid][0];
-        const variants = activeMaterials[matid].slice(1);
+    for (matid in activeVariants) {
+        const backend = activeVariants[matid][0];
+        const variants = activeVariants[matid].slice(1);
         actives[matid] = {
             backend, variants
         };
diff --git a/libs/matdbg/web/app.js b/libs/matdbg/web/app.js
index 58858daa3c9c..e9bad73a01eb 100644
--- a/libs/matdbg/web/app.js
+++ b/libs/matdbg/web/app.js
@@ -702,29 +702,19 @@ class MaterialSidePanel extends LitElement {
 
     updated(props) {
         if (props.has('database')) {
-            const items = [];
-
             // Names need not be unique, so we display a numeric suffix for non-unique names.
             // To achieve stable ordering of anonymous materials, we first sort by matid.
-            const labels = new Set();
             const matids = Object.keys(this.database).sort();
-            const duplicatedLabels = {};
-            for (const matid of matids) {
-                const name = this.database[matid].name || kUntitledPlaceholder;
-                if (labels.has(name)) {
-                    duplicatedLabels[name] = 0;
-                } else {
-                    labels.add(name);
-                }
-            }
+            const names = matids.map(matid => (this.database[matid].name || kUntitledPlaceholder));
+            const labelCount  = {};
+            names.forEach(name => labelCount[name] = (labelCount[name] || 0) + 1);
+            const duplicates = names.filter(name => labelCount[name] > 1);
 
             this.materials = matids.map((matid) => {
                 const material = this.database[matid];
                 let name = material.name || kUntitledPlaceholder;
-                if (name in duplicatedLabels) {
-                    const index = duplicatedLabels[name];
-                    duplicatedLabels[name] = index + 1;
-                    name = `${name} (${index})`;
+                if (duplicates.includes(name)) {
+                    name = `${name} (${labelCount[name]--})`;
                 }
                 return {
                     matid: matid,
@@ -938,8 +928,7 @@ class MatdbgViewer extends LitElement {
             }
         );
 
-        let materials = await fetchMaterials();
-        this.database = materials;
+        this.database = await fetchMaterials();
 
         // This is the user preferences stored in localStorage
         let hideInactiveVariantsVal = localStorage.getItem('option-hide-inactive-variants');
@@ -1070,8 +1059,8 @@ class MatdbgViewer extends LitElement {
                 const activeVariants = this.activeShaders[this.currentMaterial].variants;
                 const materialShaders = material[this.currentBackend];
                 for (let shader in materialShaders) {
-                    let ind = activeVariants.indexOf(+shader);
-                    if (ind >= 0) {
+                    const shaderVariant = materialShaders[shader].variant;
+                    if (activeVariants.indexOf(shaderVariant) >= 0) {
                         this.currentShaderIndex = +shader;
                         break;
                     }