diff --git a/.rive_head b/.rive_head
index e522539..a26e18d 100644
--- a/.rive_head
+++ b/.rive_head
@@ -1 +1 @@
-42c3f6efef8e6a992a5f8f1da9295800d73a13ea
+c0abfa2ee7f9bce6bae98a6bee32fcd811d36c64
diff --git a/renderer/include/rive/renderer/draw.hpp b/renderer/include/rive/renderer/draw.hpp
index 661aab9..be21425 100644
--- a/renderer/include/rive/renderer/draw.hpp
+++ b/renderer/include/rive/renderer/draw.hpp
@@ -246,10 +246,10 @@
         pixelLocalStorage, // InterlockMode::rasterOrdering and atomics
         clockwise,         // InterlockMode::clockwise
         clockwiseAtomic,   // InterlockMode::clockwiseAtomic
-        msaa,              // InterlockMode::msaa
+        depthStencil,      // InterlockMode::depthStencil
         featherAtlas, // Any InterlockMode may opt to use atlas coverage for
-                      // large feathers; msaa always has to use an atlas for
-                      // feathers.
+                      // large feathers; depthStencil always has to use an
+                      // atlas for feathers.
     };
 
     PathDraw(IAABB pixelBounds,
@@ -476,9 +476,9 @@
         // before the main subpass pushes the path to the renderContext.
         uint32_t m_prepassTessLocation = 0;
 
-        // Used in msaa mode. Multiple msaa subpasses use the same tesellation
-        // data.
-        uint32_t m_msaaTessLocation;
+        // Used in depthStencil mode. Multiple subpasses use the same
+        // tessellation data.
+        uint32_t m_depthStencilTessLocation;
     };
 
     // Used to guarantee m_pathRef doesn't change for the entire time we hold
diff --git a/renderer/include/rive/renderer/gpu.hpp b/renderer/include/rive/renderer/gpu.hpp
index b756c83..e34ec01 100644
--- a/renderer/include/rive/renderer/gpu.hpp
+++ b/renderer/include/rive/renderer/gpu.hpp
@@ -126,7 +126,8 @@
 struct PlatformFeatures
 {
     // Supported InterlockModes.
-    // FIXME: MSAA is implicit even though it isn't implemented on all backends.
+    // FIXME: depthStencil is implicit even though it isn't implemented on all
+    // backends.
     bool supportsRasterOrderingMode = false;
     bool supportsAtomicMode = false;
     bool supportsClockwiseMode = false;
@@ -134,10 +135,10 @@
     // (Only viable for frames that don't use advanced blend.)
     bool supportsClockwiseFixedFunctionMode = false;
     bool supportsClockwiseAtomicMode = false;
-    // Use KHR_blend_equation_advanced in msaa mode?
+    // Use KHR_blend_equation_advanced in depthStencil mode?
     bool supportsBlendAdvancedKHR = false;
     bool supportsBlendAdvancedCoherentKHR = false;
-    // Required for @ENABLE_CLIP_RECT in msaa mode.
+    // Required for @ENABLE_CLIP_RECT in depthStencil mode.
     bool supportsClipPlanes = false;
     // The backend supports dynamic state that allows Rive to collapse multiple
     // subpasses onto a single pipeline, namely:
@@ -670,44 +671,44 @@
     imageRect,
     imageMesh,
 
-    // MSAA strokes can't be merged with fills because they require their own
-    // dedicated stencil settings.
-    msaaStrokes,
+    // Strokes that use the depth buffer to work out coverage and avoid double
+    // hits.
+    depthStrokes,
 
-    // MSAA "fast" path: (effectively) single pass rendering.
-    msaaMidpointFanBorrowedCoverage,
-    msaaMidpointFans,
-    msaaMidpointFanStencilReset,
+    // depthStencil "fast" path: (almost) single pass rendering.
+    stencilMidpointFanBorrowedCoverage,
+    stencilMidpointFans,
+    stencilMidpointFanReset,
 
-    // Equivalent to msaaMidpointFanBorrowedCoverage + msaaMidpointFans +
-    // msaaMidpointFanStencilReset on a single pipeline, switching between them
+    // Equivalent to stencilMidpointFanBorrowedCoverage + stencilMidpointFans +
+    // stencilMidpointFanReset on a single pipeline, switching between them
     // with dynamic color/depth/stencil/cull state. Keeps the three passes on
     // one batch so the reorderer can still instance non-overlapping paths
     // together, while collapsing three pipeline binds into one.
-    msaaDynamicMidpointFans,
+    stencilDynamicMidpointFans,
 
     // Same as the midpoint-fan "fast" path, but submits outer-cubic patches
     // instead of midpoint-fan patches. These use the exact same depth/stencil
     // settings as their midpoint-fan counterparts; they just draw a different
     // patch of triangles. Used to fill paths via interior triangulation, whose
     // interior is smuggled via cubics (RETROFIT_TRI_STRIP_CONTOUR_FLAG).
-    msaaOuterCubicBorrowedCoverage,
-    msaaOuterCubics,
-    msaaOuterCubicStencilReset,
+    stencilOuterCubicBorrowedCoverage,
+    stencilOuterCubics,
+    stencilOuterCubicReset,
 
-    // The msaaDynamicMidpointFans equivalent for outer cubics: collapses
-    // msaaOuterCubicBorrowedCoverage + msaaOuterCubics +
-    // msaaOuterCubicStencilReset onto a single pipeline, switching between them
+    // The stencilDynamicMidpointFans equivalent for outer cubics: collapses
+    // stencilOuterCubicBorrowedCoverage + stencilOuterCubics +
+    // stencilOuterCubicReset onto a single pipeline, switching between them
     // with dynamic state. Same geometry as the outer-cubic passes above.
-    msaaDynamicOuterCubics,
+    stencilDynamicOuterCubics,
 
-    // MSAA "slow" path: stencil-then-cover.
-    msaaMidpointFanPathsStencil,
-    msaaMidpointFanPathsCover,
+    // depthStencil "slow" path: stencil-then-cover.
+    stencilMidpointFanWinding,
+    stencilMidpointFanCover,
 
     // Same as the midpoint-fan "slow" path, but submits outer-cubic patches.
-    msaaOuterCubicPathsStencil,
-    msaaOuterCubicPathsCover,
+    stencilOuterCubicWinding,
+    stencilOuterCubicCover,
 
     // Clear or intersect (based on DrawContents) the clip value.
     clipReset,
@@ -731,8 +732,8 @@
 {
     switch (drawType)
     {
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
             return true;
         case DrawType::midpointFanPatches:
         case DrawType::midpointFanCenterAAPatches:
@@ -741,17 +742,17 @@
         case DrawType::featherAtlasBlit:
         case DrawType::imageRect:
         case DrawType::imageMesh:
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
         case DrawType::clipReset:
         case DrawType::renderPassInitialize:
         case DrawType::renderPassResolve:
@@ -772,19 +773,19 @@
         case DrawType::outerCurvePatches:
         case DrawType::interiorTriangulation:
         case DrawType::featherAtlasBlit:
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
         case DrawType::clipReset:
         case DrawType::renderPassInitialize:
         case DrawType::renderPassResolve:
@@ -816,7 +817,7 @@
     // (winding or even/odd) with a "clockwise" fill rule, where only regions
     // with a positive winding number get filled.
     clockwiseAtomic,
-    msaa,
+    depthStencil,
 };
 constexpr static size_t INTERLOCK_MODE_COUNT = 5;
 // # of bits required to contain an InterlockMode.
@@ -889,7 +890,7 @@
                    // clip updates, so they need their own draw anyway and the
                    // ENABLE_NESTED_CLIPPING feature isn't necessary.
                    ~ShaderFeatures::ENABLE_NESTED_CLIPPING;
-        case InterlockMode::msaa:
+        case InterlockMode::depthStencil:
             return ShaderFeatures::ENABLE_CLIP_RECT |
                    ShaderFeatures::ENABLE_ADVANCED_BLEND |
                    ShaderFeatures::ENABLE_HSL_BLEND_MODES |
@@ -998,19 +999,19 @@
         case DrawType::midpointFanCenterAAPatches:
         case DrawType::outerCurvePatches:
         case DrawType::interiorTriangulation:
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
             mask = kAllShaderFeatures;
             break;
         case DrawType::clipReset:
@@ -1025,10 +1026,10 @@
                        ShaderFeatures::ENABLE_ADVANCED_BLEND |
                        ShaderFeatures::ENABLE_DITHER;
             }
-            else if (interlockMode == InterlockMode::msaa)
+            else if (interlockMode == InterlockMode::depthStencil)
             {
-                // MSAA mode only needs to initialize color, and only when
-                // preserving the render target but using a transient MSAA
+                // depthStencil mode only needs to initialize color, and only
+                // when preserving the render target but using a transient MSAA
                 // attachment.
                 mask = ShaderFeatures::ENABLE_DITHER;
             }
@@ -1049,7 +1050,7 @@
             else
             {
                 assert(interlockMode == InterlockMode::rasterOrdering ||
-                       interlockMode == InterlockMode::msaa);
+                       interlockMode == InterlockMode::depthStencil);
                 mask = ShaderFeatures::ENABLE_DITHER;
             }
             break;
@@ -1080,9 +1081,9 @@
     // Ensure that we haven't dropped features we care about somehow
     assert((requestedFeatures & outFeatures) == requestedFeatures);
 
-    // ENABLE_CLIP_RECT shouldn't be set if we're in MSAA mode without clip
-    // plane support.
-    if (interlockMode == InterlockMode::msaa &&
+    // ENABLE_CLIP_RECT shouldn't be set if we're in depthStencil mode without
+    // clip plane support.
+    if (interlockMode == InterlockMode::depthStencil &&
         !platformFeatures.supportsClipPlanes)
     {
         outFeatures &= ~ShaderFeatures::ENABLE_CLIP_RECT;
@@ -1123,8 +1124,8 @@
     const std::function<bool(DrawType, ShaderFeatures, ShaderMiscFlags)>&);
 
 // Flags indicating the contents of a draw. These don't affect shaders, but in
-// msaa mode they are needed to break up batching. (msaa needs different
-// stencil/blend state, depending on the DrawContents.)
+// depthStencil mode they are needed to break up batching. (depthStencil needs
+// different stencil/blend state, depending on the DrawContents.)
 //
 // These also affect the draw sort order, so we attempt associate more expensive
 // shader branch misses with higher flags.
@@ -1148,8 +1149,8 @@
 };
 
 // These are the only draw contents flags that apply to the pipeline state (and
-// they only matter for MSAA)
-constexpr static DrawContents DRAW_CONTENTS_FOR_MSAA_PIPELINE_STATE =
+// they only matter for depthStencil)
+constexpr static DrawContents DrawContentsForDepthStencilPipelineState =
     DrawContents::activeClip | DrawContents::clipUpdate |
     DrawContents::clockwiseFill | DrawContents::evenOddFill |
     DrawContents::opaquePaint;
@@ -1325,7 +1326,7 @@
     RenderTarget* renderTarget = nullptr;
     ShaderFeatures combinedShaderFeatures = ShaderFeatures::NONE;
     InterlockMode interlockMode = InterlockMode::rasterOrdering;
-    int msaaSampleCount = 0; // (0 unless interlockMode is msaa.)
+    int msaaSampleCount = 0; // (0 unless interlockMode is depthStencil.)
 
     LoadAction colorLoadAction = LoadAction::clear;
     ColorInt colorClearValue = 0; // When loadAction == LoadAction::clear.
@@ -1341,7 +1342,7 @@
     // As of now, each tile gets drawn in a separate render pass. The purpose of
     // these virtual tiles, for now, is to break the frame up into smaller
     // chunks so that Rive can be pre-empted by other rendering processes. This
-    // is only supported on Vulkan/non-msaa.
+    // is only supported on Vulkan/non-depthStencil.
     //
     // TODO: We could also explore a different type of virtual tiling that
     // reduces barriers in atomic mode, but that is not how this feature works
@@ -1611,7 +1612,7 @@
     // "0" indicates that the path is filled, not stroked.
     WRITEONLY float m_strokeRadius;
     WRITEONLY float m_featherRadius;
-    // InterlockMode::msaa.
+    // InterlockMode::depthStencil.
     WRITEONLY uint32_t m_zIndex;
     // Only used when rendering coverage via the atlas.
     WRITEONLY AtlasTransform m_featherAtlasTransform;
diff --git a/renderer/include/rive/renderer/render_context.hpp b/renderer/include/rive/renderer/render_context.hpp
index 500ddd5..89d77cd 100644
--- a/renderer/include/rive/renderer/render_context.hpp
+++ b/renderer/include/rive/renderer/render_context.hpp
@@ -106,9 +106,10 @@
         LoadAction loadAction = LoadAction::clear;
         ColorInt clearColor = 0;
         // If nonzero, the number of MSAA samples to use.
-        // Setting this to a nonzero value forces msaa mode.
+        // Setting this to a nonzero value forces depthStencil mode.
         uint32_t msaaSampleCount = 0;
-        // Use atomic mode (preferred) or msaa instead of rasterOrdering.
+        // Use atomic mode (preferred) or depthStencil instead of
+        // rasterOrdering.
         bool disableRasterOrdering = false;
         DitherMode ditherMode = DitherMode::interleavedGradientNoise;
         TriangulationThresholds triangulationThresholds;
@@ -118,7 +119,7 @@
         // As of now, each tile gets drawn in a separate render pass. The
         // purpose of these virtual tiles, for now, is to break the frame up
         // into smaller chunks so that Rive can be pre-empted by other rendering
-        // processes. This is only supported on Vulkan/non-msaa.
+        // processes. This is only supported on Vulkan/non-depthStencil.
         //
         // TODO: We could also explore a different type of virtual tiling that
         // reduces barriers in atomic mode, but that is not how this feature
@@ -917,8 +918,9 @@
         // prevents DrawBatches from being combined with the existing drawList.
         BarrierFlags m_pendingBarriers;
 
-        // Stateful Z index of the current draw being pushed. Used by msaa mode
-        // to avoid double hits and to reverse-sort opaque paths front to back.
+        // Stateful Z index of the current draw being pushed. Used by
+        // depthStencil mode to avoid double hits and to reverse-sort opaque
+        // paths front to back.
         uint32_t m_currentZIndex;
 
         RIVE_DEBUG_CODE(bool m_hasDoneLayout = false;)
diff --git a/renderer/include/rive/renderer/vulkan/render_target_vulkan.hpp b/renderer/include/rive/renderer/vulkan/render_target_vulkan.hpp
index 6111f9e..d46a8cf 100644
--- a/renderer/include/rive/renderer/vulkan/render_target_vulkan.hpp
+++ b/renderer/include/rive/renderer/vulkan/render_target_vulkan.hpp
@@ -78,7 +78,7 @@
         const vkutil::ImageAccess& dstAccessAfterCopy,
         const IAABB& copyBounds);
 
-    // InterlockMode::msaa.
+    // InterlockMode::depthStencil.
     vkutil::Texture2D* msaaColorTexture();
     vkutil::Texture2D* msaaDepthStencilTexture();
 
@@ -90,7 +90,7 @@
     // VK_ACCESS_INPUT_ATTACHMENT_READ_BIT
     rcp<vkutil::Texture2D> m_offscreenColorTexture;
 
-    // InterlockMode::msaa.
+    // InterlockMode::depthStencil.
     rcp<vkutil::Texture2D> m_msaaColorTexture;
     rcp<vkutil::Texture2D> m_msaaDepthStencilTexture;
 };
diff --git a/renderer/include/rive/renderer/webgpu/render_context_webgpu_impl.hpp b/renderer/include/rive/renderer/webgpu/render_context_webgpu_impl.hpp
index 8f4295d..3065f58 100644
--- a/renderer/include/rive/renderer/webgpu/render_context_webgpu_impl.hpp
+++ b/renderer/include/rive/renderer/webgpu/render_context_webgpu_impl.hpp
@@ -134,7 +134,7 @@
 
     // Specifies how to store MSAA color/depth/stencil attachments when ending
     // an MSAA render pass.
-    enum class MSAAEndType : bool
+    enum class DepthStencilEndType : bool
     {
         finish,
         breakForDstCopy,
@@ -147,7 +147,7 @@
     class DrawRenderPass;
     class PLSDrawRenderPass;
     class AtomicDrawRenderPass;
-    class MSAADrawRenderPass;
+    class DepthStencilDrawRenderPass;
 
     // Construct the DrawRenderPass for the flush's InterlockMode and begin it
     // (the MSAA pass may defer its begin until the first barrier).
diff --git a/renderer/shader_hotload/shader_hotload.cpp b/renderer/shader_hotload/shader_hotload.cpp
index a99ccf3..6578fa7 100644
--- a/renderer/shader_hotload/shader_hotload.cpp
+++ b/renderer/shader_hotload/shader_hotload.cpp
@@ -148,21 +148,22 @@
         riveSpirvPath / "init_clockwise_atomic_workaround.frag.spv",
         riveSpirvPath / "init_clockwise_atomic_workaround.fixedcolor_frag.spv",
 
-        riveSpirvPath / "draw_msaa_path.vert.spv",
-        riveSpirvPath / "draw_msaa_path.noclipdistance_vert.spv",
-        riveSpirvPath / "draw_msaa_path.frag.spv",
-        riveSpirvPath / "draw_msaa_path.fixedcolor_frag.spv",
-        riveSpirvPath / "draw_msaa_stencil.vert.spv",
-        riveSpirvPath / "draw_msaa_stencil.frag.spv",
-        riveSpirvPath / "draw_msaa_stencil.fixedcolor_frag.spv",
-        riveSpirvPath / "draw_msaa_atlas_blit.vert.spv",
-        riveSpirvPath / "draw_msaa_atlas_blit.noclipdistance_vert.spv",
-        riveSpirvPath / "draw_msaa_atlas_blit.frag.spv",
-        riveSpirvPath / "draw_msaa_atlas_blit.fixedcolor_frag.spv",
-        riveSpirvPath / "draw_msaa_image_mesh.vert.spv",
-        riveSpirvPath / "draw_msaa_image_mesh.noclipdistance_vert.spv",
-        riveSpirvPath / "draw_msaa_image_mesh.frag.spv",
-        riveSpirvPath / "draw_msaa_image_mesh.fixedcolor_frag.spv",
+        riveSpirvPath / "draw_depthstencil_path.vert.spv",
+        riveSpirvPath / "draw_depthstencil_path.noclipdistance_vert.spv",
+        riveSpirvPath / "draw_depthstencil_path.frag.spv",
+        riveSpirvPath / "draw_depthstencil_path.fixedcolor_frag.spv",
+        riveSpirvPath / "draw_depthstencil_triangles_nocolor.vert.spv",
+        riveSpirvPath / "draw_depthstencil_triangles_nocolor.frag.spv",
+        riveSpirvPath /
+            "draw_depthstencil_triangles_nocolor.fixedcolor_frag.spv",
+        riveSpirvPath / "draw_depthstencil_atlas_blit.vert.spv",
+        riveSpirvPath / "draw_depthstencil_atlas_blit.noclipdistance_vert.spv",
+        riveSpirvPath / "draw_depthstencil_atlas_blit.frag.spv",
+        riveSpirvPath / "draw_depthstencil_atlas_blit.fixedcolor_frag.spv",
+        riveSpirvPath / "draw_depthstencil_image_mesh.vert.spv",
+        riveSpirvPath / "draw_depthstencil_image_mesh.noclipdistance_vert.spv",
+        riveSpirvPath / "draw_depthstencil_image_mesh.frag.spv",
+        riveSpirvPath / "draw_depthstencil_image_mesh.fixedcolor_frag.spv",
         riveSpirvPath / "draw_fullscreen_quad.vert.spv",
         riveSpirvPath / "draw_input_attachment.frag.spv",
         riveSpirvPath / "draw_msaa_color_seed_attachment.frag.spv",
diff --git a/renderer/src/d3d/pipeline_manager.cpp b/renderer/src/d3d/pipeline_manager.cpp
index dfd23b9..5e1b352 100644
--- a/renderer/src/d3d/pipeline_manager.cpp
+++ b/renderer/src/d3d/pipeline_manager.cpp
@@ -101,19 +101,19 @@
             s << "#define " << GLSL_DRAW_RENDER_TARGET_UPDATE_BOUNDS << '\n';
             s << "#define " << GLSL_RESOLVE_PLS << '\n';
             break;
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
-        case DrawType::msaaOuterCubics:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
+        case DrawType::stencilOuterCubics:
         case DrawType::clipReset:
         case DrawType::renderPassInitialize:
             RIVE_UNREACHABLE();
@@ -150,19 +150,19 @@
                 break;
             case DrawType::imageRect:
             case DrawType::renderPassResolve:
-            case DrawType::msaaStrokes:
-            case DrawType::msaaMidpointFanBorrowedCoverage:
-            case DrawType::msaaDynamicMidpointFans:
-            case DrawType::msaaDynamicOuterCubics:
-            case DrawType::msaaMidpointFans:
-            case DrawType::msaaMidpointFanStencilReset:
-            case DrawType::msaaMidpointFanPathsStencil:
-            case DrawType::msaaMidpointFanPathsCover:
-            case DrawType::msaaOuterCubicBorrowedCoverage:
-            case DrawType::msaaOuterCubicStencilReset:
-            case DrawType::msaaOuterCubicPathsStencil:
-            case DrawType::msaaOuterCubicPathsCover:
-            case DrawType::msaaOuterCubics:
+            case DrawType::depthStrokes:
+            case DrawType::stencilMidpointFanBorrowedCoverage:
+            case DrawType::stencilDynamicMidpointFans:
+            case DrawType::stencilDynamicOuterCubics:
+            case DrawType::stencilMidpointFans:
+            case DrawType::stencilMidpointFanReset:
+            case DrawType::stencilMidpointFanWinding:
+            case DrawType::stencilMidpointFanCover:
+            case DrawType::stencilOuterCubicBorrowedCoverage:
+            case DrawType::stencilOuterCubicReset:
+            case DrawType::stencilOuterCubicWinding:
+            case DrawType::stencilOuterCubicCover:
+            case DrawType::stencilOuterCubics:
             case DrawType::clipReset:
             case DrawType::renderPassInitialize:
                 RIVE_UNREACHABLE();
diff --git a/renderer/src/d3d11/render_context_d3d_impl.cpp b/renderer/src/d3d11/render_context_d3d_impl.cpp
index 27ed8fe..e9cafde 100644
--- a/renderer/src/d3d11/render_context_d3d_impl.cpp
+++ b/renderer/src/d3d11/render_context_d3d_impl.cpp
@@ -308,19 +308,19 @@
             break;
         case DrawType::renderPassResolve:
             break;
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
-        case DrawType::msaaOuterCubics:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
+        case DrawType::stencilOuterCubics:
         case DrawType::clipReset:
         case DrawType::renderPassInitialize:
             RIVE_UNREACHABLE();
@@ -2290,19 +2290,19 @@
                 m_gpuContext->Draw(4, 0);
             }
             break;
-            case DrawType::msaaStrokes:
-            case DrawType::msaaMidpointFanBorrowedCoverage:
-            case DrawType::msaaDynamicMidpointFans:
-            case DrawType::msaaDynamicOuterCubics:
-            case DrawType::msaaMidpointFans:
-            case DrawType::msaaMidpointFanStencilReset:
-            case DrawType::msaaMidpointFanPathsStencil:
-            case DrawType::msaaMidpointFanPathsCover:
-            case DrawType::msaaOuterCubicBorrowedCoverage:
-            case DrawType::msaaOuterCubicStencilReset:
-            case DrawType::msaaOuterCubicPathsStencil:
-            case DrawType::msaaOuterCubicPathsCover:
-            case DrawType::msaaOuterCubics:
+            case DrawType::depthStrokes:
+            case DrawType::stencilMidpointFanBorrowedCoverage:
+            case DrawType::stencilDynamicMidpointFans:
+            case DrawType::stencilDynamicOuterCubics:
+            case DrawType::stencilMidpointFans:
+            case DrawType::stencilMidpointFanReset:
+            case DrawType::stencilMidpointFanWinding:
+            case DrawType::stencilMidpointFanCover:
+            case DrawType::stencilOuterCubicBorrowedCoverage:
+            case DrawType::stencilOuterCubicReset:
+            case DrawType::stencilOuterCubicWinding:
+            case DrawType::stencilOuterCubicCover:
+            case DrawType::stencilOuterCubics:
             case DrawType::clipReset:
             case DrawType::renderPassInitialize:
                 RIVE_UNREACHABLE();
diff --git a/renderer/src/d3d12/d3d12_pipeline_manager.cpp b/renderer/src/d3d12/d3d12_pipeline_manager.cpp
index b496c73..9a80dcf 100644
--- a/renderer/src/d3d12/d3d12_pipeline_manager.cpp
+++ b/renderer/src/d3d12/d3d12_pipeline_manager.cpp
@@ -133,19 +133,19 @@
             break;
         case DrawType::renderPassResolve:
             break;
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
-        case DrawType::msaaOuterCubics:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
+        case DrawType::stencilOuterCubics:
         case DrawType::clipReset:
         case DrawType::renderPassInitialize:
             RIVE_UNREACHABLE();
@@ -237,19 +237,19 @@
         case DrawType::renderPassResolve:
             rasterDesc.CullMode = D3D12_CULL_MODE_NONE;
             break;
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
-        case DrawType::msaaOuterCubics:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
+        case DrawType::stencilOuterCubics:
         case DrawType::clipReset:
         case DrawType::renderPassInitialize:
             break;
diff --git a/renderer/src/d3d12/render_context_d3d12_impl.cpp b/renderer/src/d3d12/render_context_d3d12_impl.cpp
index 877e0ec..900a8e3 100644
--- a/renderer/src/d3d12/render_context_d3d12_impl.cpp
+++ b/renderer/src/d3d12/render_context_d3d12_impl.cpp
@@ -2034,19 +2034,19 @@
                 break;
             }
 
-            case DrawType::msaaStrokes:
-            case DrawType::msaaMidpointFanBorrowedCoverage:
-            case DrawType::msaaDynamicMidpointFans:
-            case DrawType::msaaDynamicOuterCubics:
-            case DrawType::msaaMidpointFans:
-            case DrawType::msaaMidpointFanStencilReset:
-            case DrawType::msaaMidpointFanPathsStencil:
-            case DrawType::msaaMidpointFanPathsCover:
-            case DrawType::msaaOuterCubicBorrowedCoverage:
-            case DrawType::msaaOuterCubicStencilReset:
-            case DrawType::msaaOuterCubicPathsStencil:
-            case DrawType::msaaOuterCubicPathsCover:
-            case DrawType::msaaOuterCubics:
+            case DrawType::depthStrokes:
+            case DrawType::stencilMidpointFanBorrowedCoverage:
+            case DrawType::stencilDynamicMidpointFans:
+            case DrawType::stencilDynamicOuterCubics:
+            case DrawType::stencilMidpointFans:
+            case DrawType::stencilMidpointFanReset:
+            case DrawType::stencilMidpointFanWinding:
+            case DrawType::stencilMidpointFanCover:
+            case DrawType::stencilOuterCubicBorrowedCoverage:
+            case DrawType::stencilOuterCubicReset:
+            case DrawType::stencilOuterCubicWinding:
+            case DrawType::stencilOuterCubicCover:
+            case DrawType::stencilOuterCubics:
             case DrawType::clipReset:
             case DrawType::renderPassInitialize:
                 RIVE_UNREACHABLE();
diff --git a/renderer/src/draw.cpp b/renderer/src/draw.cpp
index 6e0521f..4e5921c 100644
--- a/renderer/src/draw.cpp
+++ b/renderer/src/draw.cpp
@@ -393,7 +393,7 @@
     if (paint->getFeather() != 0)
     {
         if (platformFeatures.alwaysFeatherToAtlas ||
-            interlockMode == gpu::InterlockMode::msaa ||
+            interlockMode == gpu::InterlockMode::depthStencil ||
             // Always switch to the atlas once we can render quarter-resultion.
             find_atlas_feather_scale_factor(
                 find_feather_radius(paint->getFeather()),
@@ -411,8 +411,8 @@
             return CoverageType::clockwise;
         case gpu::InterlockMode::clockwiseAtomic:
             return CoverageType::clockwiseAtomic;
-        case gpu::InterlockMode::msaa:
-            return CoverageType::msaa;
+        case gpu::InterlockMode::depthStencil:
+            return CoverageType::depthStencil;
     }
     RIVE_UNREACHABLE();
 }
@@ -663,22 +663,23 @@
         if (det < 0)
         {
             m_contourDirections =
-                (m_coverageType == CoverageType::msaa ||
+                (m_coverageType == CoverageType::depthStencil ||
                  m_coverageType == CoverageType::featherAtlas)
                     ? gpu::ContourDirections::reverse
                     : gpu::ContourDirections::forwardThenReverse;
-            m_contourFlags |= NEGATE_PATH_FILL_COVERAGE_FLAG; // ignored by msaa
+            // Ignored by depthStencil.
+            m_contourFlags |= NEGATE_PATH_FILL_COVERAGE_FLAG;
         }
         else
         {
             m_contourDirections =
-                (m_coverageType == CoverageType::msaa ||
+                (m_coverageType == CoverageType::depthStencil ||
                  m_coverageType == CoverageType::featherAtlas)
                     ? gpu::ContourDirections::forward
                     : gpu::ContourDirections::reverseThenForward;
         }
     }
-    else if (m_coverageType != CoverageType::msaa)
+    else if (m_coverageType != CoverageType::depthStencil)
     {
         // atomic and rasterOrdering fills need reverse AND forward triangles.
         if (frameDesc.clockwiseFillOverride &&
@@ -706,18 +707,18 @@
         if (initialFillRule == FillRule::nonZero ||
             frameDesc.clockwiseFillOverride)
         {
-            // Emit "nonZero" msaa fills in a direction such that the dominant
-            // triangle winding area is always clockwise. This maximizes pixel
-            // throughput since we will draw counterclockwise triangles twice
-            // and clockwise only once.
+            // Emit "nonZero" depthStencil fills in a direction such that the
+            // dominant triangle winding area is always clockwise. This
+            // maximizes pixel throughput since we will draw counterclockwise
+            // triangles twice and clockwise only once.
             m_contourDirections = m_pathRef->isClockwiseDominant(m_paintMatrix)
                                       ? gpu::ContourDirections::forward
                                       : gpu::ContourDirections::reverse;
         }
         else
         {
-            // "evenOdd" msaa fills just get drawn twice, so any direction is
-            // fine.
+            // "evenOdd" depthStencil fills just get drawn twice, so any
+            // direction is fine.
             m_contourDirections = gpu::ContourDirections::forward;
         }
     }
@@ -1547,7 +1548,7 @@
             }
             break;
 
-        case CoverageType::msaa:
+        case CoverageType::depthStencil:
         {
             if (isStroke())
             {
@@ -1563,20 +1564,23 @@
             else if (enums::is_flag_set(m_drawContents,
                                         gpu::DrawContents::evenOddFill))
             {
-                m_subpassCount = 2; // MSAA "slow" path: stencil-then-cover.
+                // depthStencil "slow" path: stencil-then-cover.
+                m_subpassCount = 2;
             }
             else if (platformFeatures.supportsPipelineDynamicState)
             {
-                // MSAA "fast" path, combined: the three subpasses (borrowed
-                // coverage, fans, stencil reset) collapse onto a single
-                // msaaDynamicMidpointFans draw that switches between them with
-                // dynamic color/depth/stencil/cull state. One batch keeps the
-                // reorderer able to instance non-overlapping paths together.
+                // depthStencil "fast" path, combined: the three subpasses
+                // (borrowed coverage, fans, stencil reset) collapse onto a
+                // single stencilDynamicMidpointFans draw that switches between
+                // them with dynamic color/depth/stencil/cull state. One batch
+                // keeps the reorderer able to instance non-overlapping paths
+                // together.
                 m_subpassCount = 1;
             }
             else
             {
-                // MSAA "fast" path: (effectively) single pass rendering.
+                // depthStencil "fast" path: (effectively) single pass
+                // rendering.
                 m_subpassCount = 3;
             }
             if (isOpaque())
@@ -1729,26 +1733,26 @@
             RIVE_UNREACHABLE();
         }
 
-        case CoverageType::msaa:
+        case CoverageType::depthStencil:
         {
             assert(m_prepassCount == 0 || m_subpassCount == 0);
             int passCount = m_prepassCount | m_subpassCount;
             int passIdx = subpassIndex + m_prepassCount;
             if (passIdx == 0)
             {
-                m_msaaTessLocation =
+                m_depthStencilTessLocation =
                     allocateTessellationVertices(flush, tessVertexCount);
                 pushTessellationData(flush,
                                      tessVertexCount,
-                                     m_msaaTessLocation);
+                                     m_depthStencilTessLocation);
             }
             assert(1 <= passCount && passCount <= 3);
             assert(passIdx < passCount);
             if (m_triangulator != nullptr)
             {
-                // MSAA interior triangulation: the path interior is filled by
-                // smuggling its triangles in with outerCubic patches, rather
-                // than introducing a distinct triangle-buffer draw.
+                // depthStencil interior triangulation: the path interior is
+                // filled by smuggling its triangles in with outerCubic patches,
+                // rather than introducing a distinct triangle-buffer draw.
                 gpu::DrawType outerCubicDrawType;
                 if (passCount == 1)
                 {
@@ -1756,82 +1760,87 @@
                                              gpu::kNestedClipUpdateMask))
                     {
                         outerCubicDrawType =
-                            gpu::DrawType::msaaOuterCubicPathsStencil;
+                            gpu::DrawType::stencilOuterCubicWinding;
                     }
                     else
                     {
                         assert(flush->platformFeatures()
                                    .supportsPipelineDynamicState);
                         outerCubicDrawType =
-                            gpu::DrawType::msaaDynamicOuterCubics;
+                            gpu::DrawType::stencilDynamicOuterCubics;
                     }
                 }
                 else
                 {
-                    constexpr static gpu::DrawType
-                        MsaaOuterCubicFillTypes[][3] = {
-                            // Slow path (passCount == 2): stencil-then-cover.
-                            {
-                                gpu::DrawType::msaaOuterCubicPathsStencil,
-                                gpu::DrawType::msaaOuterCubicPathsCover,
-                            },
-                            // Fast path (passCount == 3).
-                            {
-                                gpu::DrawType::msaaOuterCubicBorrowedCoverage,
-                                gpu::DrawType::msaaOuterCubics,
-                                gpu::DrawType::msaaOuterCubicStencilReset,
-                            },
-                        };
+                    constexpr static gpu::DrawType OuterCubicFillTypes[][3] = {
+                        // Slow path (passCount == 2): stencil-then-cover.
+                        {
+                            gpu::DrawType::stencilOuterCubicWinding,
+                            gpu::DrawType::stencilOuterCubicCover,
+                        },
+                        // Fast path (passCount == 3).
+                        {
+                            gpu::DrawType::stencilOuterCubicBorrowedCoverage,
+                            gpu::DrawType::stencilOuterCubics,
+                            gpu::DrawType::stencilOuterCubicReset,
+                        },
+                    };
                     outerCubicDrawType =
-                        MsaaOuterCubicFillTypes[passCount - 2][passIdx];
+                        OuterCubicFillTypes[passCount - 2][passIdx];
                 }
                 return &flush->pushOuterCubicsDraw(this,
                                                    outerCubicDrawType,
                                                    tessVertexCount,
-                                                   m_msaaTessLocation);
-            }
-            gpu::DrawType msaaDrawType;
-            if (passCount == 1)
-            {
-                if (isStroke())
-                {
-                    msaaDrawType = gpu::DrawType::msaaStrokes;
-                }
-                else if (enums::all_flags_set(m_drawContents,
-                                              gpu::kNestedClipUpdateMask))
-                {
-                    msaaDrawType = gpu::DrawType::msaaMidpointFanPathsStencil;
-                }
-                else
-                {
-                    assert(
-                        flush->platformFeatures().supportsPipelineDynamicState);
-                    msaaDrawType = gpu::DrawType::msaaDynamicMidpointFans;
-                }
+                                                   m_depthStencilTessLocation);
             }
             else
             {
-                constexpr static gpu::DrawType MSAAFillTypes[][3] = {
-                    // Slow path (passCount == 2): stencil-then-cover
+                gpu::DrawType depthStencilDrawType;
+                if (passCount == 1)
+                {
+                    if (isStroke())
                     {
-                        gpu::DrawType::msaaMidpointFanPathsStencil,
-                        gpu::DrawType::msaaMidpointFanPathsCover,
-                    },
+                        depthStencilDrawType = gpu::DrawType::depthStrokes;
+                    }
+                    else if (enums::all_flags_set(m_drawContents,
+                                                  gpu::kNestedClipUpdateMask))
+                    {
+                        depthStencilDrawType =
+                            gpu::DrawType::stencilMidpointFanWinding;
+                    }
+                    else
+                    {
+                        assert(flush->platformFeatures()
+                                   .supportsPipelineDynamicState);
+                        depthStencilDrawType =
+                            gpu::DrawType::stencilDynamicMidpointFans;
+                    }
+                }
+                else
+                {
+                    constexpr static gpu::DrawType MidpointFanFillTypes[][3] = {
+                        // Slow path (passCount == 2): stencil-then-cover
+                        {
+                            gpu::DrawType::stencilMidpointFanWinding,
+                            gpu::DrawType::stencilMidpointFanCover,
+                        },
 
-                    // Fast path (passCount == 3): (mostly) single pass
-                    // rendering.
-                    {
-                        gpu::DrawType::msaaMidpointFanBorrowedCoverage,
-                        gpu::DrawType::msaaMidpointFans,
-                        gpu::DrawType::msaaMidpointFanStencilReset,
-                    },
-                };
-                msaaDrawType = MSAAFillTypes[passCount - 2][passIdx];
+                        // Fast path (passCount == 3): (mostly) single pass
+                        // rendering.
+                        {
+                            gpu::DrawType::stencilMidpointFanBorrowedCoverage,
+                            gpu::DrawType::stencilMidpointFans,
+                            gpu::DrawType::stencilMidpointFanReset,
+                        },
+                    };
+                    depthStencilDrawType =
+                        MidpointFanFillTypes[passCount - 2][passIdx];
+                }
+                return &flush->pushMidpointFanDraw(this,
+                                                   depthStencilDrawType,
+                                                   tessVertexCount,
+                                                   m_depthStencilTessLocation);
             }
-            return &flush->pushMidpointFanDraw(this,
-                                               msaaDrawType,
-                                               tessVertexCount,
-                                               m_msaaTessLocation);
         }
 
         case CoverageType::featherAtlas:
@@ -2408,10 +2417,11 @@
     size_t patchCount = 0;
     size_t contourCount = 0;
     Vec2D p0 = {0, 0};
-    // A straight edge produces a single-segment cubic patch. In MSAA we draw
-    // only the patch interior (not the AA border), and that interior is
+    // A straight edge produces a single-segment cubic patch. In depthStencil we
+    // draw only the patch interior (not the AA border), and that interior is
     // degenerate for a single segment, so we skip these patches entirely.
-    const bool skipFlatOuterCubics = m_coverageType == CoverageType::msaa;
+    const bool skipFlatOuterCubics =
+        m_coverageType == CoverageType::depthStencil;
     // Only used on the "emit" pass (tessWriter != nullptr).
     uint32_t contourIDWithFlags = 0;
     for (const auto [verb, pts] : rawPath)
@@ -2585,10 +2595,11 @@
         // We also draw each "grout" triangle using an outerCubic patch.
         patchCount += m_triangulator->groutList().count();
 
-        if (m_coverageType == CoverageType::msaa)
+        if (m_coverageType == CoverageType::depthStencil)
         {
-            // MSAA fills the path interior by smuggling its triangles in with
-            // outerCubic patches (rather than a distinct triangle-buffer draw).
+            // depthStencil fills the path interior by smuggling its triangles
+            // in with outerCubic patches (rather than a distinct
+            // triangle-buffer draw).
             patchCount +=
                 m_triangulator->retrofitCubicPatchCount(m_pathFillRule);
         }
@@ -2607,9 +2618,9 @@
                 gpu::ContourDirectionsAreDoubleSided(m_contourDirections)
                     ? patchCount * OuterCubicPatchSegmentSpanPlusJoin * 2
                     : patchCount * OuterCubicPatchSegmentSpanPlusJoin;
-            if (m_coverageType != CoverageType::msaa)
+            if (m_coverageType != CoverageType::depthStencil)
             {
-                // In MSAA, the interior triangles are smuggled in with
+                // In depthStencil, the interior triangles are smuggled in with
                 // outerCubic patches (counted above) instead of being drawn
                 // from the triangle buffer.
                 m_resourceCounts.maxTriangleVertexCount +=
@@ -2629,7 +2640,7 @@
                                                   contourIDWithFlags);
             ++patchCount;
         }
-        if (m_coverageType == CoverageType::msaa)
+        if (m_coverageType == CoverageType::depthStencil)
         {
             // Smuggle the interior triangles in with outerCubic patches.
             patchCount += m_triangulator->polysToRetrofitCubicPatches(
diff --git a/renderer/src/gl/render_context_gl_impl.cpp b/renderer/src/gl/render_context_gl_impl.cpp
index 5509382..d5a49d7 100644
--- a/renderer/src/gl/render_context_gl_impl.cpp
+++ b/renderer/src/gl/render_context_gl_impl.cpp
@@ -31,7 +31,7 @@
 #include "generated/shaders/draw_clockwise_clip.frag.hpp"
 #include "generated/shaders/draw_image_mesh.vert.hpp"
 #include "generated/shaders/draw_mesh.frag.hpp"
-#include "generated/shaders/draw_msaa_object.frag.hpp"
+#include "generated/shaders/draw_depthstencil_object.frag.hpp"
 #include "generated/shaders/bezier_utils.glsl.hpp"
 #include "generated/shaders/tessellate.glsl.hpp"
 #include "generated/shaders/render_atlas.glsl.hpp"
@@ -63,19 +63,19 @@
         case gpu::DrawType::midpointFanPatches:
         case gpu::DrawType::midpointFanCenterAAPatches:
         case gpu::DrawType::outerCurvePatches:
-        case gpu::DrawType::msaaStrokes:
-        case gpu::DrawType::msaaMidpointFanBorrowedCoverage:
-        case gpu::DrawType::msaaDynamicMidpointFans:
-        case gpu::DrawType::msaaDynamicOuterCubics:
-        case gpu::DrawType::msaaMidpointFans:
-        case gpu::DrawType::msaaMidpointFanStencilReset:
-        case gpu::DrawType::msaaMidpointFanPathsStencil:
-        case gpu::DrawType::msaaMidpointFanPathsCover:
-        case gpu::DrawType::msaaOuterCubicBorrowedCoverage:
-        case gpu::DrawType::msaaOuterCubicStencilReset:
-        case gpu::DrawType::msaaOuterCubicPathsStencil:
-        case gpu::DrawType::msaaOuterCubicPathsCover:
-        case gpu::DrawType::msaaOuterCubics:
+        case gpu::DrawType::depthStrokes:
+        case gpu::DrawType::stencilMidpointFanBorrowedCoverage:
+        case gpu::DrawType::stencilDynamicMidpointFans:
+        case gpu::DrawType::stencilDynamicOuterCubics:
+        case gpu::DrawType::stencilMidpointFans:
+        case gpu::DrawType::stencilMidpointFanReset:
+        case gpu::DrawType::stencilMidpointFanWinding:
+        case gpu::DrawType::stencilMidpointFanCover:
+        case gpu::DrawType::stencilOuterCubicBorrowedCoverage:
+        case gpu::DrawType::stencilOuterCubicReset:
+        case gpu::DrawType::stencilOuterCubicWinding:
+        case gpu::DrawType::stencilOuterCubicCover:
+        case gpu::DrawType::stencilOuterCubics:
             return true;
         case gpu::DrawType::imageRect:
         case gpu::DrawType::imageMesh:
@@ -1678,7 +1678,7 @@
         {
             assert(enums::is_flag_set(kVertexShaderFeaturesMask, feature) ||
                    shaderType == GL_FRAGMENT_SHADER);
-            if (interlockMode == gpu::InterlockMode::msaa &&
+            if (interlockMode == gpu::InterlockMode::depthStencil &&
                 feature == gpu::ShaderFeatures::ENABLE_ADVANCED_BLEND &&
                 renderContextImpl->m_capabilities.KHR_blend_equation_advanced)
             {
@@ -1690,9 +1690,9 @@
             }
         }
     }
-    if (interlockMode == gpu::InterlockMode::msaa)
+    if (interlockMode == gpu::InterlockMode::depthStencil)
     {
-        defines.push_back(GLSL_RENDER_MODE_MSAA);
+        defines.push_back(GLSL_RENDER_MODE_DEPTH_STENCIL);
     }
     assert(renderContextImpl->platformFeatures().framebufferBottomUp);
     defines.push_back(GLSL_FRAMEBUFFER_BOTTOM_UP);
@@ -1705,19 +1705,19 @@
         case gpu::DrawType::midpointFanPatches:
         case gpu::DrawType::midpointFanCenterAAPatches:
         case gpu::DrawType::outerCurvePatches:
-        case gpu::DrawType::msaaStrokes:
-        case gpu::DrawType::msaaMidpointFanBorrowedCoverage:
-        case gpu::DrawType::msaaDynamicMidpointFans:
-        case gpu::DrawType::msaaDynamicOuterCubics:
-        case gpu::DrawType::msaaMidpointFans:
-        case gpu::DrawType::msaaMidpointFanStencilReset:
-        case gpu::DrawType::msaaMidpointFanPathsStencil:
-        case gpu::DrawType::msaaMidpointFanPathsCover:
-        case gpu::DrawType::msaaOuterCubicBorrowedCoverage:
-        case gpu::DrawType::msaaOuterCubicStencilReset:
-        case gpu::DrawType::msaaOuterCubicPathsStencil:
-        case gpu::DrawType::msaaOuterCubicPathsCover:
-        case gpu::DrawType::msaaOuterCubics:
+        case gpu::DrawType::depthStrokes:
+        case gpu::DrawType::stencilMidpointFanBorrowedCoverage:
+        case gpu::DrawType::stencilDynamicMidpointFans:
+        case gpu::DrawType::stencilDynamicOuterCubics:
+        case gpu::DrawType::stencilMidpointFans:
+        case gpu::DrawType::stencilMidpointFanReset:
+        case gpu::DrawType::stencilMidpointFanWinding:
+        case gpu::DrawType::stencilMidpointFanCover:
+        case gpu::DrawType::stencilOuterCubicBorrowedCoverage:
+        case gpu::DrawType::stencilOuterCubicReset:
+        case gpu::DrawType::stencilOuterCubicWinding:
+        case gpu::DrawType::stencilOuterCubicCover:
+        case gpu::DrawType::stencilOuterCubics:
             if (shaderType == GL_VERTEX_SHADER)
             {
                 defines.push_back(GLSL_ENABLE_INSTANCE_INDEX);
@@ -1806,19 +1806,19 @@
                     sources.push_back(gpu::glsl::draw_mesh_frag);
                     break;
                 case gpu::DrawType::imageRect:
-                case gpu::DrawType::msaaStrokes:
-                case gpu::DrawType::msaaMidpointFanBorrowedCoverage:
-                case gpu::DrawType::msaaDynamicMidpointFans:
-                case gpu::DrawType::msaaDynamicOuterCubics:
-                case gpu::DrawType::msaaMidpointFans:
-                case gpu::DrawType::msaaMidpointFanStencilReset:
-                case gpu::DrawType::msaaMidpointFanPathsStencil:
-                case gpu::DrawType::msaaMidpointFanPathsCover:
-                case gpu::DrawType::msaaOuterCubicBorrowedCoverage:
-                case gpu::DrawType::msaaOuterCubicStencilReset:
-                case gpu::DrawType::msaaOuterCubicPathsStencil:
-                case gpu::DrawType::msaaOuterCubicPathsCover:
-                case gpu::DrawType::msaaOuterCubics:
+                case gpu::DrawType::depthStrokes:
+                case gpu::DrawType::stencilMidpointFanBorrowedCoverage:
+                case gpu::DrawType::stencilDynamicMidpointFans:
+                case gpu::DrawType::stencilDynamicOuterCubics:
+                case gpu::DrawType::stencilMidpointFans:
+                case gpu::DrawType::stencilMidpointFanReset:
+                case gpu::DrawType::stencilMidpointFanWinding:
+                case gpu::DrawType::stencilMidpointFanCover:
+                case gpu::DrawType::stencilOuterCubicBorrowedCoverage:
+                case gpu::DrawType::stencilOuterCubicReset:
+                case gpu::DrawType::stencilOuterCubicWinding:
+                case gpu::DrawType::stencilOuterCubicCover:
+                case gpu::DrawType::stencilOuterCubics:
                 case gpu::DrawType::clipReset:
                 case gpu::DrawType::renderPassInitialize:
                 case gpu::DrawType::renderPassResolve:
@@ -1831,26 +1831,26 @@
             sources.push_back(gpu::glsl::atomic_draw);
             break;
 
-        case gpu::InterlockMode::msaa:
+        case gpu::InterlockMode::depthStencil:
             switch (drawType)
             {
-                case gpu::DrawType::msaaStrokes:
-                case gpu::DrawType::msaaMidpointFanBorrowedCoverage:
-                case gpu::DrawType::msaaDynamicMidpointFans:
-                case gpu::DrawType::msaaDynamicOuterCubics:
-                case gpu::DrawType::msaaMidpointFans:
-                case gpu::DrawType::msaaMidpointFanStencilReset:
-                case gpu::DrawType::msaaMidpointFanPathsStencil:
-                case gpu::DrawType::msaaMidpointFanPathsCover:
-                case gpu::DrawType::msaaOuterCubicBorrowedCoverage:
-                case gpu::DrawType::msaaOuterCubicStencilReset:
-                case gpu::DrawType::msaaOuterCubicPathsStencil:
-                case gpu::DrawType::msaaOuterCubicPathsCover:
-                case gpu::DrawType::msaaOuterCubics:
+                case gpu::DrawType::depthStrokes:
+                case gpu::DrawType::stencilMidpointFanBorrowedCoverage:
+                case gpu::DrawType::stencilDynamicMidpointFans:
+                case gpu::DrawType::stencilDynamicOuterCubics:
+                case gpu::DrawType::stencilMidpointFans:
+                case gpu::DrawType::stencilMidpointFanReset:
+                case gpu::DrawType::stencilMidpointFanWinding:
+                case gpu::DrawType::stencilMidpointFanCover:
+                case gpu::DrawType::stencilOuterCubicBorrowedCoverage:
+                case gpu::DrawType::stencilOuterCubicReset:
+                case gpu::DrawType::stencilOuterCubicWinding:
+                case gpu::DrawType::stencilOuterCubicCover:
+                case gpu::DrawType::stencilOuterCubics:
                 case gpu::DrawType::interiorTriangulation:
                     sources.push_back(gpu::glsl::draw_path_common);
                     sources.push_back(gpu::glsl::draw_path_vert);
-                    sources.push_back(gpu::glsl::draw_msaa_object_frag);
+                    sources.push_back(gpu::glsl::draw_depthstencil_object_frag);
                     break;
                 case gpu::DrawType::clipReset:
                     sources.push_back(gpu::glsl::stencil_draw);
@@ -1858,11 +1858,11 @@
                 case gpu::DrawType::featherAtlasBlit:
                     sources.push_back(gpu::glsl::draw_path_common);
                     sources.push_back(gpu::glsl::draw_path_vert);
-                    sources.push_back(gpu::glsl::draw_msaa_object_frag);
+                    sources.push_back(gpu::glsl::draw_depthstencil_object_frag);
                     break;
                 case gpu::DrawType::imageMesh:
                     sources.push_back(gpu::glsl::draw_image_mesh_vert);
-                    sources.push_back(gpu::glsl::draw_msaa_object_frag);
+                    sources.push_back(gpu::glsl::draw_depthstencil_object_frag);
                     break;
                 case gpu::DrawType::midpointFanPatches:
                 case gpu::DrawType::midpointFanCenterAAPatches:
@@ -2104,7 +2104,7 @@
                                      CONTOUR_BUFFER_IDX);
         }
     }
-    if (interlockMode == gpu::InterlockMode::msaa &&
+    if (interlockMode == gpu::InterlockMode::depthStencil &&
         enums::is_flag_set(shaderFeatures,
                            gpu::ShaderFeatures::ENABLE_ADVANCED_BLEND) &&
         !renderContextImpl->m_capabilities.KHR_blend_equation_advanced &&
@@ -2734,7 +2734,7 @@
 
     auto msaaResolveAction = RenderTargetGL::MSAAResolveAction::automatic;
     std::array<GLenum, 3> msaaDepthStencilColor;
-    if (desc.interlockMode != gpu::InterlockMode::msaa)
+    if (desc.interlockMode != gpu::InterlockMode::depthStencil)
     {
         assert(desc.msaaSampleCount == 0);
         assert(m_plsImpl != nullptr);
@@ -2817,7 +2817,7 @@
                 ? desc.combinedShaderFeatures
                 : batch.shaderFeatures;
         gpu::ShaderMiscFlags shaderMiscFlags = batch.shaderMiscFlags;
-        if (desc.interlockMode != gpu::InterlockMode::msaa)
+        if (desc.interlockMode != gpu::InterlockMode::depthStencil)
         {
             assert(m_plsImpl != nullptr);
             shaderMiscFlags |= m_plsImpl->shaderMiscFlags(desc, drawType);
@@ -2855,7 +2855,7 @@
                                 desc,
                                 m_platformFeatures,
                                 &pipelineState);
-        if (desc.interlockMode != gpu::InterlockMode::msaa)
+        if (desc.interlockMode != gpu::InterlockMode::depthStencil)
         {
             assert(m_plsImpl != nullptr);
             m_plsImpl->applyPipelineStateOverrides(batch,
@@ -2899,7 +2899,7 @@
             {
                 // Read back the framebuffer where we need a dstColor for
                 // blending.
-                assert(desc.interlockMode == gpu::InterlockMode::msaa);
+                assert(desc.interlockMode == gpu::InterlockMode::depthStencil);
                 assert(batch.dstReadList != nullptr);
                 renderTarget->bindDstColorFramebuffer(GL_DRAW_FRAMEBUFFER);
                 m_state->disableScissor();
@@ -2947,17 +2947,17 @@
             case DrawType::midpointFanPatches:
             case DrawType::midpointFanCenterAAPatches:
             case DrawType::outerCurvePatches:
-            case DrawType::msaaStrokes:
-            case DrawType::msaaMidpointFanBorrowedCoverage:
-            case DrawType::msaaMidpointFans:
-            case DrawType::msaaMidpointFanStencilReset:
-            case DrawType::msaaMidpointFanPathsStencil:
-            case DrawType::msaaMidpointFanPathsCover:
-            case DrawType::msaaOuterCubicBorrowedCoverage:
-            case DrawType::msaaOuterCubicStencilReset:
-            case DrawType::msaaOuterCubicPathsStencil:
-            case DrawType::msaaOuterCubicPathsCover:
-            case DrawType::msaaOuterCubics:
+            case DrawType::depthStrokes:
+            case DrawType::stencilMidpointFanBorrowedCoverage:
+            case DrawType::stencilMidpointFans:
+            case DrawType::stencilMidpointFanReset:
+            case DrawType::stencilMidpointFanWinding:
+            case DrawType::stencilMidpointFanCover:
+            case DrawType::stencilOuterCubicBorrowedCoverage:
+            case DrawType::stencilOuterCubicReset:
+            case DrawType::stencilOuterCubicWinding:
+            case DrawType::stencilOuterCubicCover:
+            case DrawType::stencilOuterCubics:
             {
                 m_state->bindVAO(m_drawVAO);
                 if (desc.interlockMode == gpu::InterlockMode::rasterOrdering)
@@ -2975,8 +2975,8 @@
                 break;
             }
 
-            case DrawType::msaaDynamicMidpointFans:
-            case DrawType::msaaDynamicOuterCubics:
+            case DrawType::stencilDynamicMidpointFans:
+            case DrawType::stencilDynamicOuterCubics:
             {
                 // Combined fast-path fill: borrowed coverage, main fill, and
                 // stencil reset are one batch sharing one program. Draw it
@@ -2984,9 +2984,10 @@
                 // passes use identical state to their midpoint-fan
                 // counterparts, so drive both from the midpoint-fan types.
                 m_state->bindVAO(m_drawVAO);
-                for (DrawType pass : {DrawType::msaaMidpointFanBorrowedCoverage,
-                                      DrawType::msaaMidpointFans,
-                                      DrawType::msaaMidpointFanStencilReset})
+                for (DrawType pass :
+                     {DrawType::stencilMidpointFanBorrowedCoverage,
+                      DrawType::stencilMidpointFans,
+                      DrawType::stencilMidpointFanReset})
                 {
                     gpu::PipelineState passState =
                         gpu::get_pipeline_state(pass,
@@ -3142,7 +3143,7 @@
         }
     }
 
-    if (desc.interlockMode != gpu::InterlockMode::msaa)
+    if (desc.interlockMode != gpu::InterlockMode::depthStencil)
     {
         m_plsImpl->deactivatePixelLocalStorage(this, desc);
     }
diff --git a/renderer/src/gpu.cpp b/renderer/src/gpu.cpp
index ca769e5..784b499 100644
--- a/renderer/src/gpu.cpp
+++ b/renderer/src/gpu.cpp
@@ -84,24 +84,24 @@
             };
             return make_span(types);
         }
-        case InterlockMode::msaa:
+        case InterlockMode::depthStencil:
         {
             static constexpr DrawType types[] = {
                 DrawType::featherAtlasBlit,
                 DrawType::imageMesh,
-                DrawType::msaaStrokes,
-                DrawType::msaaMidpointFanBorrowedCoverage,
-                DrawType::msaaMidpointFans,
-                DrawType::msaaMidpointFanStencilReset,
-                DrawType::msaaMidpointFanPathsStencil,
-                DrawType::msaaMidpointFanPathsCover,
-                DrawType::msaaDynamicMidpointFans,
-                DrawType::msaaOuterCubicBorrowedCoverage,
-                DrawType::msaaOuterCubics,
-                DrawType::msaaOuterCubicStencilReset,
-                DrawType::msaaDynamicOuterCubics,
-                DrawType::msaaOuterCubicPathsStencil,
-                DrawType::msaaOuterCubicPathsCover,
+                DrawType::depthStrokes,
+                DrawType::stencilMidpointFanBorrowedCoverage,
+                DrawType::stencilMidpointFans,
+                DrawType::stencilMidpointFanReset,
+                DrawType::stencilMidpointFanWinding,
+                DrawType::stencilMidpointFanCover,
+                DrawType::stencilDynamicMidpointFans,
+                DrawType::stencilOuterCubicBorrowedCoverage,
+                DrawType::stencilOuterCubics,
+                DrawType::stencilOuterCubicReset,
+                DrawType::stencilDynamicOuterCubics,
+                DrawType::stencilOuterCubicWinding,
+                DrawType::stencilOuterCubicCover,
                 DrawType::clipReset,
                 DrawType::renderPassInitialize,
                 DrawType::renderPassResolve,
@@ -168,19 +168,19 @@
         case DrawType::featherAtlasBlit:
         case DrawType::imageRect:
         case DrawType::imageMesh:
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
             break;
     }
 
@@ -189,7 +189,7 @@
         case InterlockMode::atomics:
         case InterlockMode::clockwise:
         case InterlockMode::clockwiseAtomic:
-        case InterlockMode::msaa:
+        case InterlockMode::depthStencil:
             outFlags |= ShaderMiscFlags::fixedFunctionColorOutput;
             break;
 
@@ -214,7 +214,7 @@
         (interlockMode == InterlockMode::clockwiseAtomic &&
          platformFeatures
              .clockwiseAtomicBorrowedCoverageBarrierNeedsRenderPassInit) ||
-        (interlockMode == InterlockMode::msaa &&
+        (interlockMode == InterlockMode::depthStencil &&
          platformFeatures.msaaColorPreserveNeedsDraw);
 
     for (auto drawType : get_valid_draw_types(interlockMode))
@@ -283,7 +283,7 @@
 
                 case InterlockMode::rasterOrdering:
                 case InterlockMode::clockwise:
-                case InterlockMode::msaa:
+                case InterlockMode::depthStencil:
                     break;
             }
 
@@ -352,19 +352,19 @@
         case DrawType::midpointFanPatches:
         case DrawType::midpointFanCenterAAPatches:
         case DrawType::outerCurvePatches:
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
             drawTypeKey = 0;
             break;
         case DrawType::interiorTriangulation:
@@ -381,19 +381,19 @@
             break;
         case DrawType::clipReset:
             assert(interlockMode == InterlockMode::clockwiseAtomic ||
-                   interlockMode == InterlockMode::msaa);
+                   interlockMode == InterlockMode::depthStencil);
             drawTypeKey = 7;
             break;
         case DrawType::renderPassInitialize:
             assert(interlockMode == InterlockMode::atomics ||
-                   interlockMode == InterlockMode::msaa ||
+                   interlockMode == InterlockMode::depthStencil ||
                    interlockMode == InterlockMode::clockwiseAtomic);
             drawTypeKey = 5;
             break;
         case DrawType::renderPassResolve:
             assert(interlockMode == InterlockMode::rasterOrdering ||
                    interlockMode == InterlockMode::atomics ||
-                   interlockMode == InterlockMode::msaa);
+                   interlockMode == InterlockMode::depthStencil);
             drawTypeKey = 6;
             break;
     }
@@ -1176,7 +1176,7 @@
                            DrawType drawType,
                            DrawContents drawContents)
 {
-    if (interlockMode != InterlockMode::msaa)
+    if (interlockMode != InterlockMode::depthStencil)
     {
         return {.depthTestEnabled = false, .depthWriteEnabled = false};
     }
@@ -1186,24 +1186,24 @@
         case DrawType::imageRect:
         case DrawType::imageMesh:
         case DrawType::featherAtlasBlit:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubicPathsStencil:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubicWinding:
         case DrawType::clipReset:
             return {.depthTestEnabled = true, .depthWriteEnabled = false};
             break;
 
-        case DrawType::msaaStrokes:
+        case DrawType::depthStrokes:
             return {.depthTestEnabled = true, .depthWriteEnabled = true};
             break;
 
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicCover:
             return {
                 .depthTestEnabled = true,
                 .depthWriteEnabled =
@@ -1211,8 +1211,8 @@
             };
             break;
 
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaOuterCubicStencilReset:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilOuterCubicReset:
             return {
                 .depthTestEnabled = true,
                 .depthWriteEnabled = enums::no_flags_set(
@@ -1239,9 +1239,9 @@
                              DrawContents drawContents)
 {
     bool areDrawContentsValid = true;
-    if (interlockMode != InterlockMode::msaa)
+    if (interlockMode != InterlockMode::depthStencil)
     {
-        // Only MSAA has any valid stencil types
+        // Only depthStencil has any valid stencil types
         return {StencilType::disabled,
                 DrawContents::none,
                 areDrawContentsValid};
@@ -1252,7 +1252,7 @@
         case DrawType::imageRect:
         case DrawType::imageMesh:
         case DrawType::featherAtlasBlit:
-        case DrawType::msaaStrokes:
+        case DrawType::depthStrokes:
             if (enums::is_flag_set(drawContents, DrawContents::activeClip))
             {
                 return {
@@ -1270,26 +1270,26 @@
                 };
             }
 
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
             return {
                 StencilType::borrowedCoverage,
                 DrawContents::activeClip,
                 areDrawContentsValid,
             };
 
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaOuterCubics:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilOuterCubics:
             return {
                 StencilType::forwardClippedByBackward,
                 DrawContents::activeClip | DrawContents::clipUpdate,
                 areDrawContentsValid,
             };
 
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaOuterCubicStencilReset:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilOuterCubicReset:
             return {
                 StencilType::backwardTriangleCleanup,
                 DrawContents::clockwiseFill | DrawContents::activeClip |
@@ -1297,8 +1297,8 @@
                 areDrawContentsValid,
             };
 
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaOuterCubicPathsStencil:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilOuterCubicWinding:
             areDrawContentsValid =
                 enums::is_flag_set(drawContents, DrawContents::evenOddFill) ||
                 enums::all_flags_set(drawContents, kNestedClipUpdateMask);
@@ -1308,8 +1308,8 @@
                 areDrawContentsValid,
             };
 
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicCover:
             areDrawContentsValid =
                 enums::is_flag_set(drawContents, DrawContents::evenOddFill);
             return {StencilType::evenOddDrawAndReset,
@@ -1350,7 +1350,7 @@
                                  DrawContents drawContents,
                                  PipelineState* pipelineState)
 {
-    if (interlockMode != InterlockMode::msaa)
+    if (interlockMode != InterlockMode::depthStencil)
     {
         pipelineState->stencilTestEnabled = false;
         pipelineState->stencilWriteMask = 0;
@@ -1558,17 +1558,17 @@
         case DrawType::outerCurvePatches:
         case DrawType::interiorTriangulation:
         case DrawType::featherAtlasBlit:
-        case DrawType::msaaStrokes:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaOuterCubics:
+        case DrawType::depthStrokes:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilOuterCubics:
         case DrawType::clipReset:
             return CullFace::counterclockwise;
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubicStencilReset:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubicReset:
             // clockwise is always the front face in Rive, but for a couple
             // draws we encode some stencil work in the counterclockwise face.
             // It's done this way because the cull face is often supported as
@@ -1579,10 +1579,10 @@
             return CullFace::clockwise;
         case DrawType::imageRect:
         case DrawType::imageMesh:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
         case DrawType::renderPassResolve:
         case DrawType::renderPassInitialize:
             return CullFace::none;
@@ -1658,7 +1658,7 @@
                 return BlendEquation::srcOver;
             }
 
-        case InterlockMode::msaa:
+        case InterlockMode::depthStencil:
             if (enums::is_flag_set(drawContents, DrawContents::opaquePaint))
             {
                 // ShaderMiscFlags::emulateDynamicColorWriteDisable suppresses
@@ -1692,8 +1692,8 @@
             else
             {
                 // When m_platformFeatures.supportsBlendAdvancedKHR is true in
-                // MSAA mode, the renderContext does not combine draws that have
-                // different blend modes.
+                // depthStencil mode, the renderContext does not combine draws
+                // that have different blend modes.
                 assert(drawType != DrawType::renderPassInitialize &&
                        drawType != DrawType::renderPassResolve);
                 return static_cast<BlendEquation>(blendMode);
@@ -1731,24 +1731,24 @@
             // storage can still be written when colorWriteEnabled is false.
             // Disable color writes when we're rendering only to PLS.
             return fixedFunctionColorOutput ||
-                   interlockMode == InterlockMode::msaa;
-        case DrawType::msaaStrokes:
+                   interlockMode == InterlockMode::depthStencil;
+        case DrawType::depthStrokes:
             return true;
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubicPathsStencil:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubicWinding:
         case DrawType::clipReset:
             return false;
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicCover:
             return !enums::is_flag_set(drawContents, DrawContents::clipUpdate);
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaOuterCubicStencilReset:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilOuterCubicReset:
             // For clockwise fill, disable color writes when cleaning up
             // backward triangles. Clockwise only fills in forward triangles.
             return enums::no_flags_set(drawContents,
@@ -1774,20 +1774,21 @@
                                         shaderMiscFlags);
 
     constexpr auto VALID_PIPELINE_DRAW_CONTENTS_BIT_COUNT =
-        math::count_set_bits(uint32_t(DRAW_CONTENTS_FOR_MSAA_PIPELINE_STATE));
+        math::count_set_bits(
+            uint32_t(DrawContentsForDepthStencilPipelineState));
 
-    const auto stencilInfo =
-        get_stencil_info(interlockMode,
-                         drawType,
-                         drawContents & DRAW_CONTENTS_FOR_MSAA_PIPELINE_STATE);
+    const auto stencilInfo = get_stencil_info(
+        interlockMode,
+        drawType,
+        drawContents & DrawContentsForDepthStencilPipelineState);
 
     const auto drawContentsMask =
-        (interlockMode == InterlockMode::msaa)
+        (interlockMode == InterlockMode::depthStencil)
             ? DrawContents(stencilInfo.drawContentsMask |
                            DrawContents::opaquePaint)
             : DrawContents::none;
 
-    assert((drawContentsMask & DRAW_CONTENTS_FOR_MSAA_PIPELINE_STATE) ==
+    assert((drawContentsMask & DrawContentsForDepthStencilPipelineState) ==
            drawContentsMask);
 
     const auto effectiveDrawContents =
@@ -1799,11 +1800,11 @@
         key,
         math::compact_bitmask_value(
             uint32_t(effectiveDrawContents),
-            uint32_t(DRAW_CONTENTS_FOR_MSAA_PIPELINE_STATE)),
+            uint32_t(DrawContentsForDepthStencilPipelineState)),
         VALID_PIPELINE_DRAW_CONTENTS_BIT_COUNT);
 
-    // Only MSAA cares about other blend modes during pipeline creation.
-    auto effectiveBlendMode = (interlockMode == InterlockMode::msaa &&
+    // Only depthStencil cares about other blend modes during pipeline creation.
+    auto effectiveBlendMode = (interlockMode == InterlockMode::depthStencil &&
                                platformFeatures.supportsBlendAdvancedKHR)
                                   ? blendMode
                                   : BlendMode::srcOver;
@@ -1857,10 +1858,10 @@
                                  rive::BlendMode blendMode,
                                  const PlatformFeatures& platformFeatures)
 {
-    // Only some DrawContents flags are relevant (and only for msaa at the
-    // moment)
-    drawContents &= (interlockMode == InterlockMode::msaa)
-                        ? DRAW_CONTENTS_FOR_MSAA_PIPELINE_STATE
+    // Only some DrawContents flags are relevant (and only for depthStencil at
+    // the moment)
+    drawContents &= (interlockMode == InterlockMode::depthStencil)
+                        ? DrawContentsForDepthStencilPipelineState
                         : DrawContents::none;
 
 #ifndef NDEBUG
@@ -1875,41 +1876,41 @@
         case DrawType::midpointFanCenterAAPatches:
         case DrawType::outerCurvePatches:
         case DrawType::interiorTriangulation:
-            assert(interlockMode != InterlockMode::msaa);
+            assert(interlockMode != InterlockMode::depthStencil);
             break;
 
         case DrawType::imageRect:
         case DrawType::renderPassResolve:
             assert(interlockMode == InterlockMode::rasterOrdering ||
                    interlockMode == InterlockMode::atomics ||
-                   interlockMode == InterlockMode::msaa);
+                   interlockMode == InterlockMode::depthStencil);
             break;
 
         case DrawType::renderPassInitialize:
             assert(interlockMode == InterlockMode::atomics ||
-                   interlockMode == InterlockMode::msaa ||
+                   interlockMode == InterlockMode::depthStencil ||
                    interlockMode == InterlockMode::clockwiseAtomic);
             break;
 
-        case DrawType::msaaStrokes:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
-            assert(interlockMode == InterlockMode::msaa);
+        case DrawType::depthStrokes:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
+            assert(interlockMode == InterlockMode::depthStencil);
             break;
 
         case DrawType::clipReset:
             assert(interlockMode == InterlockMode::clockwiseAtomic ||
-                   interlockMode == InterlockMode::msaa);
+                   interlockMode == InterlockMode::depthStencil);
             break;
     }
 #endif
diff --git a/renderer/src/metal/background_shader_compiler.mm b/renderer/src/metal/background_shader_compiler.mm
index 1cb0cdb..b1d3dc3 100644
--- a/renderer/src/metal/background_shader_compiler.mm
+++ b/renderer/src/metal/background_shader_compiler.mm
@@ -214,19 +214,19 @@
                 }
 #endif
                 break;
-            case DrawType::msaaStrokes:
-            case DrawType::msaaMidpointFanBorrowedCoverage:
-            case DrawType::msaaDynamicMidpointFans:
-            case DrawType::msaaDynamicOuterCubics:
-            case DrawType::msaaMidpointFans:
-            case DrawType::msaaMidpointFanStencilReset:
-            case DrawType::msaaMidpointFanPathsStencil:
-            case DrawType::msaaMidpointFanPathsCover:
-            case DrawType::msaaOuterCubicBorrowedCoverage:
-            case DrawType::msaaOuterCubicStencilReset:
-            case DrawType::msaaOuterCubicPathsStencil:
-            case DrawType::msaaOuterCubicPathsCover:
-            case DrawType::msaaOuterCubics:
+            case DrawType::depthStrokes:
+            case DrawType::stencilMidpointFanBorrowedCoverage:
+            case DrawType::stencilDynamicMidpointFans:
+            case DrawType::stencilDynamicOuterCubics:
+            case DrawType::stencilMidpointFans:
+            case DrawType::stencilMidpointFanReset:
+            case DrawType::stencilMidpointFanWinding:
+            case DrawType::stencilMidpointFanCover:
+            case DrawType::stencilOuterCubicBorrowedCoverage:
+            case DrawType::stencilOuterCubicReset:
+            case DrawType::stencilOuterCubicWinding:
+            case DrawType::stencilOuterCubicCover:
+            case DrawType::stencilOuterCubics:
             case DrawType::clipReset:
                 RIVE_UNREACHABLE();
         }
@@ -264,19 +264,19 @@
                     [source appendFormat:@"%s\n", gpu::glsl::draw_mesh_frag];
                     break;
                 case DrawType::imageRect:
-                case DrawType::msaaStrokes:
-                case DrawType::msaaMidpointFanBorrowedCoverage:
-                case DrawType::msaaDynamicMidpointFans:
-                case DrawType::msaaDynamicOuterCubics:
-                case DrawType::msaaMidpointFans:
-                case DrawType::msaaMidpointFanStencilReset:
-                case DrawType::msaaMidpointFanPathsStencil:
-                case DrawType::msaaMidpointFanPathsCover:
-                case DrawType::msaaOuterCubicBorrowedCoverage:
-                case DrawType::msaaOuterCubicStencilReset:
-                case DrawType::msaaOuterCubicPathsStencil:
-                case DrawType::msaaOuterCubicPathsCover:
-                case DrawType::msaaOuterCubics:
+                case DrawType::depthStrokes:
+                case DrawType::stencilMidpointFanBorrowedCoverage:
+                case DrawType::stencilDynamicMidpointFans:
+                case DrawType::stencilDynamicOuterCubics:
+                case DrawType::stencilMidpointFans:
+                case DrawType::stencilMidpointFanReset:
+                case DrawType::stencilMidpointFanWinding:
+                case DrawType::stencilMidpointFanCover:
+                case DrawType::stencilOuterCubicBorrowedCoverage:
+                case DrawType::stencilOuterCubicReset:
+                case DrawType::stencilOuterCubicWinding:
+                case DrawType::stencilOuterCubicCover:
+                case DrawType::stencilOuterCubics:
                 case DrawType::clipReset:
                 case DrawType::renderPassInitialize:
                 case DrawType::renderPassResolve:
diff --git a/renderer/src/metal/render_context_metal_impl.mm b/renderer/src/metal/render_context_metal_impl.mm
index b8f94f3..399b5ab 100644
--- a/renderer/src/metal/render_context_metal_impl.mm
+++ b/renderer/src/metal/render_context_metal_impl.mm
@@ -242,19 +242,19 @@
             case DrawType::imageMesh:
                 namespacePrefix = 'm';
                 break;
-            case DrawType::msaaStrokes:
-            case DrawType::msaaMidpointFanBorrowedCoverage:
-            case DrawType::msaaDynamicMidpointFans:
-            case DrawType::msaaDynamicOuterCubics:
-            case DrawType::msaaMidpointFans:
-            case DrawType::msaaMidpointFanStencilReset:
-            case DrawType::msaaMidpointFanPathsStencil:
-            case DrawType::msaaMidpointFanPathsCover:
-            case DrawType::msaaOuterCubicBorrowedCoverage:
-            case DrawType::msaaOuterCubicStencilReset:
-            case DrawType::msaaOuterCubicPathsStencil:
-            case DrawType::msaaOuterCubicPathsCover:
-            case DrawType::msaaOuterCubics:
+            case DrawType::depthStrokes:
+            case DrawType::stencilMidpointFanBorrowedCoverage:
+            case DrawType::stencilDynamicMidpointFans:
+            case DrawType::stencilDynamicOuterCubics:
+            case DrawType::stencilMidpointFans:
+            case DrawType::stencilMidpointFanReset:
+            case DrawType::stencilMidpointFanWinding:
+            case DrawType::stencilMidpointFanCover:
+            case DrawType::stencilOuterCubicBorrowedCoverage:
+            case DrawType::stencilOuterCubicReset:
+            case DrawType::stencilOuterCubicWinding:
+            case DrawType::stencilOuterCubicCover:
+            case DrawType::stencilOuterCubics:
             case DrawType::clipReset:
             case DrawType::renderPassInitialize:
             case DrawType::renderPassResolve:
@@ -361,7 +361,7 @@
 
                 case gpu::InterlockMode::clockwise:
                 case gpu::InterlockMode::clockwiseAtomic:
-                case gpu::InterlockMode::msaa:
+                case gpu::InterlockMode::depthStencil:
                     RIVE_UNREACHABLE();
             }
             return make_pipeline_state(gpu, desc);
@@ -1405,7 +1405,8 @@
 {
     assert(desc.interlockMode != gpu::InterlockMode::clockwise);
     assert(desc.interlockMode != gpu::InterlockMode::clockwiseAtomic);
-    assert(desc.interlockMode != gpu::InterlockMode::msaa); // TODO: msaa.
+    // TODO: depthStencil.
+    assert(desc.interlockMode != gpu::InterlockMode::depthStencil);
 
     auto* renderTarget = static_cast<RenderTargetMetal*>(desc.renderTarget);
     id<MTLCommandBuffer> commandBuffer =
@@ -2017,19 +2018,19 @@
                             vertexCount:4];
                 break;
             }
-            case DrawType::msaaStrokes:
-            case DrawType::msaaMidpointFanBorrowedCoverage:
-            case DrawType::msaaDynamicMidpointFans:
-            case DrawType::msaaDynamicOuterCubics:
-            case DrawType::msaaMidpointFans:
-            case DrawType::msaaMidpointFanStencilReset:
-            case DrawType::msaaMidpointFanPathsStencil:
-            case DrawType::msaaMidpointFanPathsCover:
-            case DrawType::msaaOuterCubicBorrowedCoverage:
-            case DrawType::msaaOuterCubicStencilReset:
-            case DrawType::msaaOuterCubicPathsStencil:
-            case DrawType::msaaOuterCubicPathsCover:
-            case DrawType::msaaOuterCubics:
+            case DrawType::depthStrokes:
+            case DrawType::stencilMidpointFanBorrowedCoverage:
+            case DrawType::stencilDynamicMidpointFans:
+            case DrawType::stencilDynamicOuterCubics:
+            case DrawType::stencilMidpointFans:
+            case DrawType::stencilMidpointFanReset:
+            case DrawType::stencilMidpointFanWinding:
+            case DrawType::stencilMidpointFanCover:
+            case DrawType::stencilOuterCubicBorrowedCoverage:
+            case DrawType::stencilOuterCubicReset:
+            case DrawType::stencilOuterCubicWinding:
+            case DrawType::stencilOuterCubicCover:
+            case DrawType::stencilOuterCubics:
             case DrawType::clipReset:
             {
                 RIVE_UNREACHABLE();
diff --git a/renderer/src/render_context.cpp b/renderer/src/render_context.cpp
index 73b503f..8574db6 100644
--- a/renderer/src/render_context.cpp
+++ b/renderer/src/render_context.cpp
@@ -384,7 +384,7 @@
 {
     if (frameDescriptor.msaaSampleCount != 0)
     {
-        return gpu::InterlockMode::msaa;
+        return gpu::InterlockMode::depthStencil;
     }
     if (frameDescriptor.clockwiseFillOverride)
     {
@@ -411,7 +411,7 @@
     {
         return gpu::InterlockMode::atomics;
     }
-    return gpu::InterlockMode::msaa;
+    return gpu::InterlockMode::depthStencil;
 }
 
 void RenderContext::beginFrame(const FrameDescriptor& frameDescriptor)
@@ -425,7 +425,7 @@
     m_frameDescriptor = frameDescriptor;
     m_frameInterlockMode =
         select_interlock_mode(m_frameDescriptor, platformFeatures());
-    if (m_frameInterlockMode == gpu::InterlockMode::msaa &&
+    if (m_frameInterlockMode == gpu::InterlockMode::depthStencil &&
         m_frameDescriptor.msaaSampleCount == 0)
     {
         // Use 4x MSAA if msaaSampleCount wasn't already specified.
@@ -456,7 +456,7 @@
 bool RenderContext::frameSupportsClipRects() const
 {
     assert(m_didBeginFrame);
-    return m_frameInterlockMode != gpu::InterlockMode::msaa ||
+    return m_frameInterlockMode != gpu::InterlockMode::depthStencil ||
            platformFeatures().supportsClipPlanes;
 }
 
@@ -546,9 +546,9 @@
         passCountInBatch += draws[i]->prepassCount() + draws[i]->subpassCount();
     }
 
-    // We can only reorder 32k draws at a time in atomic and msaa modes since
-    // the sort key addresses them with a signed 16-bit index. Make sure we
-    // don't exceed that limit.
+    // We can only reorder 32k draws at a time in atomic and depthStencil modes
+    // since the sort key addresses them with a signed 16-bit index. Make sure
+    // we don't exceed that limit.
     if (m_ctx->frameInterlockMode() != gpu::InterlockMode::rasterOrdering &&
         m_drawPassCount + passCountInBatch > kMaxReorderedDrawPassCount)
     {
@@ -1070,7 +1070,7 @@
             }
             return n;
         }
-        case gpu::InterlockMode::msaa:
+        case gpu::InterlockMode::depthStencil:
             return 0; // N/A
     }
     RIVE_UNREACHABLE();
@@ -1102,7 +1102,7 @@
                    !enums::is_flag_set(combinedDrawContents,
                                        gpu::DrawContents::advancedBlend);
 
-        case gpu::InterlockMode::msaa:
+        case gpu::InterlockMode::depthStencil:
             // Manual MSAA resolves read the framebuffer, so they can't use
             // fixedFunctionColorOutput.
             return !manuallyResolved &&
@@ -1675,13 +1675,13 @@
             // us better branching on the GPU.
             {.entry = SortEntry::blendMode, .bitCount = 4},
 
-            // msaa mode draws strokes, fills, and even/odd with different
-            // stencil settings.
+            // depthStencil mode draws strokes, fills, and even/odd with
+            // different stencil settings.
             {.entry = SortEntry::drawContents, .bitCount = 9},
 
-            // Finally, we need sorting by subpass. Without this, the MSAA
-            // subpasses (and maybe others) won't run in the correct order when
-            // allSubpassesInSameDrawGroup was true.
+            // Finally, we need sorting by subpass. Without this, the
+            // depthStencil subpasses (and maybe others) won't run in the
+            // correct order when allSubpassesInSameDrawGroup was true.
             {.entry = SortEntry::subpassIndex, .bitCount = 3},
         };
 
@@ -1787,7 +1787,8 @@
             // Otherwise, we put subpasses into different draw groups because it
             // yields better reordering.
             const bool allSubpassesInSameDrawGroup =
-                m_ctx->frameInterlockMode() == gpu::InterlockMode::msaa &&
+                m_ctx->frameInterlockMode() ==
+                    gpu::InterlockMode::depthStencil &&
                 !platformFeatures.supportsBlendAdvancedKHR &&
                 enums::is_flag_set(m_combinedDrawContents,
                                    gpu::DrawContents::advancedBlend);
@@ -1916,7 +1917,8 @@
                                     ImageSampler::LinearClamp(),
                                     BarrierFlags::none);
         }
-        else if (m_ctx->frameInterlockMode() == gpu::InterlockMode::msaa &&
+        else if (m_ctx->frameInterlockMode() ==
+                     gpu::InterlockMode::depthStencil &&
                  m_flushDesc.colorLoadAction ==
                      gpu::LoadAction::preserveRenderTarget &&
                  platformFeatures.msaaColorPreserveNeedsDraw)
@@ -2012,14 +2014,14 @@
                 break;
             }
 
-            case gpu::InterlockMode::msaa:
+            case gpu::InterlockMode::depthStencil:
             {
-                // MSAA mode can't batch draws that overlap because they both
-                // rely on the stencil buffer across subpasses. Stop batching
-                // every time the drawGroupIdx changes.
+                // depthStencil mode can't batch draws that overlap because they
+                // both rely on the stencil buffer across subpasses. Stop
+                // batching every time the drawGroupIdx changes.
                 int64_t needsBreakMask = keyBuilder.mask(SortEntry::drawGroup);
-                // MSAA mode draws clips, strokes, fills, and even/odd with
-                // different stencil settings, so these can't be batched.
+                // depthStencil mode draws clips, strokes, fills, and even/odd
+                // with different stencil settings, so these can't be batched.
                 needsBreakMask |= keyBuilder.mask(SortEntry::drawContents);
                 if (platformFeatures.supportsBlendAdvancedKHR)
                 {
@@ -2028,9 +2030,9 @@
                     // blend equation.
                     needsBreakMask |= keyBuilder.mask(SortEntry::blendMode);
                 }
-                // MSAA barriers only need to prevent batching of draws for now.
-                // If we also need a dstBlend barrier, that will be decided
-                // later.
+                // depthStencil barriers only need to prevent batching of draws
+                // for now. If we also need a dstBlend barrier, that will be
+                // decided later.
                 barriersForKeyDiffs.push_back(
                     {needsBreakMask, BarrierFlags::drawBatchBreak});
                 break;
@@ -2104,7 +2106,8 @@
             // differ".
             if ((m_ctx->frameInterlockMode() ==
                      gpu::InterlockMode::clockwiseAtomic ||
-                 m_ctx->frameInterlockMode() == gpu::InterlockMode::msaa) &&
+                 m_ctx->frameInterlockMode() ==
+                     gpu::InterlockMode::depthStencil) &&
                 subpassIndex == 0 && batch != nullptr)
             {
                 // Barriers at this level have to go on the first batch in the
@@ -2148,7 +2151,8 @@
                 assert(firstBatchInCurrentDrawGroup != nullptr);
 
                 if (draw->hasAdvancedBlend() &&
-                    (m_ctx->frameInterlockMode() != gpu::InterlockMode::msaa ||
+                    (m_ctx->frameInterlockMode() !=
+                         gpu::InterlockMode::depthStencil ||
                      !m_ctx->platformFeatures()
                           .supportsBlendAdvancedCoherentKHR))
                 {
@@ -2212,9 +2216,10 @@
                 else
                 {
                     assert(m_ctx->frameInterlockMode() ==
-                           gpu::InterlockMode::msaa);
+                           gpu::InterlockMode::depthStencil);
 
-                    // msaa doesn't mix srcOver draws with advanced blend draws.
+                    // depthStencil doesn't mix srcOver draws with advanced
+                    // blend draws.
                     assert(enums::is_flag_set(
                                batch->shaderFeatures,
                                gpu::ShaderFeatures::ENABLE_ADVANCED_BLEND) ==
@@ -3727,22 +3732,22 @@
             return kMidpointFanCenterAAPatchIndexCount;
         case DrawType::outerCurvePatches:
             return kOuterCurvePatchIndexCount;
-        case DrawType::msaaStrokes:
+        case DrawType::depthStrokes:
             return kMidpointFanPatchBorderIndexCount;
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
             return kMidpointFanPatchIndexCount -
                    kMidpointFanPatchBorderIndexCount;
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
             return kOuterCurvePatchIndexCount -
                    kOuterCurvePatchBorderIndexCount;
         case DrawType::interiorTriangulation:
@@ -3762,26 +3767,26 @@
     switch (drawType)
     {
         case DrawType::midpointFanPatches:
-        case DrawType::msaaStrokes:
+        case DrawType::depthStrokes:
             return kMidpointFanPatchBaseIndex;
         case DrawType::midpointFanCenterAAPatches:
             return kMidpointFanCenterAAPatchBaseIndex;
         case DrawType::outerCurvePatches:
             return kOuterCurvePatchBaseIndex;
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
             return kMidpointFanPatchBaseIndex +
                    kMidpointFanPatchBorderIndexCount;
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
             return kOuterCurvePatchBaseIndex + kOuterCurvePatchBorderIndexCount;
         case DrawType::interiorTriangulation:
         case DrawType::featherAtlasBlit:
@@ -3802,19 +3807,19 @@
         case DrawType::midpointFanPatches:
         case DrawType::midpointFanCenterAAPatches:
         case DrawType::outerCurvePatches:
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
             batch->indexCountPerInstance = patchIndexCount(drawType);
             batch->baseIndex = patchBaseIndex(drawType);
             break;
@@ -3870,7 +3875,7 @@
         }
     }
 
-    // In clockwiseAtomic and msaa modes, individual draws can use
+    // In clockwiseAtomic and depthStencil modes, individual draws can use
     // fixedFunctionColorOutput even if the render pass as a whole does not.
     if (m_ctx->frameInterlockMode() == gpu::InterlockMode::clockwiseAtomic)
     {
@@ -3881,7 +3886,7 @@
             shaderMiscFlags |= gpu::ShaderMiscFlags::fixedFunctionColorOutput;
         }
     }
-    else if (m_ctx->frameInterlockMode() == gpu::InterlockMode::msaa &&
+    else if (m_ctx->frameInterlockMode() == gpu::InterlockMode::depthStencil &&
              draw->blendMode() == BlendMode::srcOver)
     {
         shaderMiscFlags |= gpu::ShaderMiscFlags::fixedFunctionColorOutput;
@@ -3895,19 +3900,19 @@
         case DrawType::outerCurvePatches:
         case DrawType::interiorTriangulation:
         case DrawType::featherAtlasBlit:
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilOuterCubics:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
         case DrawType::clipReset:
             if (!m_drawList.empty() &&
                 !enums::is_flag_set(m_pendingBarriers,
@@ -3927,12 +3932,12 @@
                     currentBatch->baseElement + currentBatch->elementCount !=
                         baseElement)
                 {
-                    // In MSAA mode, multiple subpasses reference the same
-                    // tessellation data. Although rare, this breaks the
+                    // In depthStencil mode, multiple subpasses reference the
+                    // same tessellation data. Although rare, this breaks the
                     // guarantee we have in other modes that mergeable batches
                     // will always have contiguous patches.
                     assert(m_ctx->frameInterlockMode() ==
-                           gpu::InterlockMode::msaa);
+                           gpu::InterlockMode::depthStencil);
                     canMergeWithPreviousBatch = false;
                 }
 
@@ -3990,8 +3995,9 @@
         assert((batch->drawContents & gpu::DrawContents::featheredFill) ==
                (draw->drawContents() & gpu::DrawContents::featheredFill));
 
-        // msaa can't mix drawContents in a batch.
-        assert(m_ctx->frameInterlockMode() != gpu::InterlockMode::msaa ||
+        // depthStencil can't mix drawContents in a batch.
+        assert(m_ctx->frameInterlockMode() !=
+                   gpu::InterlockMode::depthStencil ||
                batch->drawContents == draw->drawContents());
 
         batch->shaderMiscFlags |= shaderMiscFlags;
diff --git a/renderer/src/rive_renderer.cpp b/renderer/src/rive_renderer.cpp
index e857216..f3e29a9 100644
--- a/renderer/src/rive_renderer.cpp
+++ b/renderer/src/rive_renderer.cpp
@@ -675,7 +675,7 @@
             : m_clipStack[clipIdxCurrentlyInClipBuffer].clipID;
     if (m_context->frameInterlockMode() ==
             gpu::InterlockMode::clockwiseAtomic ||
-        m_context->frameInterlockMode() == gpu::InterlockMode::msaa)
+        m_context->frameInterlockMode() == gpu::InterlockMode::depthStencil)
     {
         if (parentClipID == 0 && m_context->getClipContentID() != 0)
         {
@@ -792,7 +792,8 @@
 
         if (parentClipID != 0)
         {
-            if (m_context->frameInterlockMode() == gpu::InterlockMode::msaa)
+            if (m_context->frameInterlockMode() ==
+                gpu::InterlockMode::depthStencil)
             {
                 // When drawing nested stencil clips, we need to intersect them,
                 // which involves erasing the region of the current clip in the
diff --git a/renderer/src/shaders/Makefile b/renderer/src/shaders/Makefile
index aebd167..e36d962 100644
--- a/renderer/src/shaders/Makefile
+++ b/renderer/src/shaders/Makefile
@@ -198,17 +198,17 @@
 # MSAA shaders need separate builds with FIXED_FUNCTION_COLOR_OUTPUT and/or
 # DISABLE_CLIP_DISTANCE_FOR_UBERSHADERS, as well as builds for WebGPU.
 SPIRV_DRAW_MSAA_INPUTS := \
-    spirv/draw_msaa_atlas_blit.main \
-    spirv/draw_msaa_image_mesh.main \
-    spirv/draw_msaa_path.main \
-    spirv/draw_msaa_stencil.main \
+    spirv/draw_depthstencil_atlas_blit.main \
+    spirv/draw_depthstencil_image_mesh.main \
+    spirv/draw_depthstencil_path.main \
+    spirv/draw_depthstencil_triangles_nocolor.main \
 
 # WebGPU (compatibility mode) doesn't always support storage buffers in the
 # vertex shader. These files specifically need WebGPU "nossbo" build variants
 # that polyfill the buffers via textures.
 WEBGPU_NOSSBO_NOCLIPDISTANCE_INPUTS := \
-    spirv/draw_msaa_path.main \
-    spirv/draw_msaa_atlas_blit.main
+    spirv/draw_depthstencil_path.main \
+    spirv/draw_depthstencil_atlas_blit.main
 WEBGPU_NOSSBO_INPUTS := \
     $(WEBGPU_NOSSBO_NOCLIPDISTANCE_INPUTS) \
     spirv/tessellate.main \
@@ -427,8 +427,8 @@
                  %.webgpu_frag.spv \
                  %.webgpu_fixedcolor_frag.spv, \
                  $(SPIRV_OUTPUTS_BINARY))) \
-    $(OUT)/wgsl/draw_msaa_stencil.vert.wgsl \
-    $(OUT)/wgsl/draw_msaa_stencil.frag.wgsl \
+    $(OUT)/wgsl/draw_depthstencil_triangles_nocolor.vert.wgsl \
+    $(OUT)/wgsl/draw_depthstencil_triangles_nocolor.frag.wgsl \
     $(OUT)/wgsl/color_ramp.vert.wgsl \
     $(OUT)/wgsl/color_ramp.frag.wgsl
 
diff --git a/renderer/src/shaders/common.glsl b/renderer/src/shaders/common.glsl
index 9c3a777..2e6bfde 100644
--- a/renderer/src/shaders/common.glsl
+++ b/renderer/src/shaders/common.glsl
@@ -9,7 +9,7 @@
 #define PI_OVER_2 1.57079632679
 #define ONE_OVER_SQRT_2 0.70710678118 // 1/sqrt(2)
 
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
 #define AA_RADIUS float(.5)
 #else
 #define AA_RADIUS float(.0)
@@ -367,7 +367,7 @@
                   1.);
 }
 
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
 // Calculates the Manhattan distance in pixels from the given pixelPosition, to
 // the point at each edge of the clipRect where coverage = 0.
 //
@@ -399,7 +399,7 @@
     }
 }
 
-#else // !@RENDER_MODE_MSAA => @RENDER_MODE_MSAA
+#else // !@RENDER_MODE_DEPTH_STENCIL => @RENDER_MODE_DEPTH_STENCIL
 
 INLINE float normalize_z_index(uint zIndex)
 {
@@ -440,7 +440,7 @@
 }
 #endif // ENABLE_CLIP_RECT
 
-#endif // @RENDER_MODE_MSAA
+#endif // @RENDER_MODE_DEPTH_STENCIL
 #endif // VERTEX
 
 #ifdef @FRAGMENT
@@ -467,7 +467,7 @@
 
 // The Qualcomm compiler can't handle line breaks in #ifs.
 // clang-format off
-#if defined(@FRAGMENT) && defined(@RENDER_MODE_MSAA) && !defined(@FIXED_FUNCTION_COLOR_OUTPUT)
+#if defined(@FRAGMENT) && defined(@RENDER_MODE_DEPTH_STENCIL) && !defined(@FIXED_FUNCTION_COLOR_OUTPUT)
 // clang-format on
 INLINE half4 dst_color_fetch(half4x4 dstSamples, int sampleMask)
 {
@@ -491,4 +491,5 @@
         return ret;
     }
 }
-#endif // @FRAGMENT && @RENDER_MODE_MSAA && !@FIXED_FUNCTION_COLOR_OUTPUT
+#endif // @FRAGMENT && @RENDER_MODE_DEPTH_STENCIL &&
+       // !@FIXED_FUNCTION_COLOR_OUTPUT
diff --git a/renderer/src/shaders/draw_msaa_object.frag b/renderer/src/shaders/draw_depthstencil_object.frag
similarity index 100%
rename from renderer/src/shaders/draw_msaa_object.frag
rename to renderer/src/shaders/draw_depthstencil_object.frag
diff --git a/renderer/src/shaders/draw_image_mesh.vert b/renderer/src/shaders/draw_image_mesh.vert
index a3e96ea..5d8d83b 100644
--- a/renderer/src/shaders/draw_image_mesh.vert
+++ b/renderer/src/shaders/draw_image_mesh.vert
@@ -33,7 +33,7 @@
 #ifdef @ENABLE_CLIPPING
 @OPTIONALLY_FLAT VARYING(1, half, v_clipID);
 #endif
-#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_MSAA)
+#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_DEPTH_STENCIL)
 NO_PERSPECTIVE VARYING(2, float4, v_clipRect);
 #endif
 @OPTIONALLY_FLAT VARYING(3, half, v_imageOpacity);
@@ -80,7 +80,7 @@
 #ifdef @ENABLE_CLIPPING
     VARYING_INIT(v_clipID, half);
 #endif
-#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_MSAA)
+#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_DEPTH_STENCIL)
     VARYING_INIT(v_clipRect, float4);
 #endif
     VARYING_INIT(v_imageOpacity, half);
@@ -102,7 +102,7 @@
 #ifdef @ENABLE_CLIP_RECT
     if (@ENABLE_CLIP_RECT)
     {
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
         v_clipRect = find_clip_rect_coverage_distances(
             make_float2x2(@a_imageDrawClipRectInverseMatrix),
             @a_imageDrawTranslates.zw,
@@ -119,7 +119,7 @@
 #ifdef @POST_INVERT_Y
     pos.y = -pos.y;
 #endif
-#ifdef @RENDER_MODE_MSAA
+#ifdef @RENDER_MODE_DEPTH_STENCIL
     pos.z = normalize_z_index(@a_imageDrawPacked.w);
 #endif
 
@@ -132,7 +132,7 @@
 #ifdef @ENABLE_CLIPPING
     VARYING_PACK(v_clipID);
 #endif
-#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_MSAA)
+#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_DEPTH_STENCIL)
     VARYING_PACK(v_clipRect);
 #endif
     VARYING_PACK(v_imageOpacity);
diff --git a/renderer/src/shaders/draw_path.vert b/renderer/src/shaders/draw_path.vert
index 843a930..07ea508 100644
--- a/renderer/src/shaders/draw_path.vert
+++ b/renderer/src/shaders/draw_path.vert
@@ -48,14 +48,14 @@
 
 #ifdef @FEATHER_ATLAS_BLIT
 NO_PERSPECTIVE VARYING(1, float2, v_atlasCoord);
-#elif !defined(@RENDER_MODE_MSAA)
+#elif !defined(@RENDER_MODE_DEPTH_STENCIL)
 #ifdef @DRAW_INTERIOR_TRIANGLES
 @OPTIONALLY_FLAT VARYING(1, half, v_windingWeight);
 #else
 NO_PERSPECTIVE VARYING(2, COVERAGE_TYPE, v_coverages);
 #endif //@DRAW_INTERIOR_TRIANGLES
 @OPTIONALLY_FLAT VARYING(3, half, v_pathID);
-#endif // !@RENDER_MODE_MSAA
+#endif // !@RENDER_MODE_DEPTH_STENCIL
 
 #ifdef @ENABLE_CLIPPING
 #ifdef @FEATHER_ATLAS_BLIT
@@ -64,7 +64,7 @@
 @OPTIONALLY_FLAT VARYING(4, half2, v_clipIDs); // [clipID, outerClipID]
 #endif
 #endif // @ENABLE_CLIPPING
-#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_MSAA)
+#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_DEPTH_STENCIL)
 NO_PERSPECTIVE VARYING(5, float4, v_clipRect);
 #endif
 #ifdef @ENABLE_ADVANCED_BLEND
@@ -109,14 +109,14 @@
 
 #ifdef @FEATHER_ATLAS_BLIT
     VARYING_INIT(v_atlasCoord, float2);
-#elif !defined(@RENDER_MODE_MSAA)
+#elif !defined(@RENDER_MODE_DEPTH_STENCIL)
 #ifdef @DRAW_INTERIOR_TRIANGLES
     VARYING_INIT(v_windingWeight, half);
 #else
     VARYING_INIT(v_coverages, COVERAGE_TYPE);
 #endif //@DRAW_INTERIOR_TRIANGLES
     VARYING_INIT(v_pathID, half);
-#endif // !@RENDER_MODE_MSAA
+#endif // !@RENDER_MODE_DEPTH_STENCIL
 
 #ifdef @ENABLE_CLIPPING
 #ifdef @FEATHER_ATLAS_BLIT
@@ -125,7 +125,7 @@
     VARYING_INIT(v_clipIDs, half2);
 #endif
 #endif // @ENABLE_CLIPPING
-#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_MSAA)
+#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_DEPTH_STENCIL)
     VARYING_INIT(v_clipRect, float4);
 #endif
 #ifdef @ENABLE_ADVANCED_BLEND
@@ -139,7 +139,7 @@
     bool shouldDiscardVertex = false;
     uint pathID;
     float2 vertexPosition;
-#ifdef @RENDER_MODE_MSAA
+#ifdef @RENDER_MODE_DEPTH_STENCIL
     ushort pathZIndex;
 #endif
 
@@ -147,14 +147,14 @@
     vertexPosition =
         unpack_atlas_coverage_vertex(@a_triangleVertex,
                                      pathID,
-#ifdef @RENDER_MODE_MSAA
+#ifdef @RENDER_MODE_DEPTH_STENCIL
                                      pathZIndex,
 #endif
                                      v_atlasCoord VERTEX_CONTEXT_UNPACK);
 #elif defined(@DRAW_INTERIOR_TRIANGLES)
     vertexPosition = unpack_interior_triangle_vertex(@a_triangleVertex,
                                                      pathID
-#ifdef @RENDER_MODE_MSAA
+#ifdef @RENDER_MODE_DEPTH_STENCIL
                                                      ,
                                                      pathZIndex
 #else
@@ -170,7 +170,7 @@
                                         _instanceID,
                                         pathID,
                                         vertexPosition
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
                                         ,
                                         coverages
 #else
@@ -178,7 +178,7 @@
                                         pathZIndex
 #endif
                                             VERTEX_CONTEXT_UNPACK);
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
 #ifdef @ENABLE_FEATHER
     v_coverages = coverages;
 #else
@@ -189,7 +189,7 @@
 
     uint2 paintData = STORAGE_BUFFER_LOAD2(@paintBuffer, pathID);
 
-#if !defined(@FEATHER_ATLAS_BLIT) && !defined(@RENDER_MODE_MSAA)
+#if !defined(@FEATHER_ATLAS_BLIT) && !defined(@RENDER_MODE_DEPTH_STENCIL)
     // Encode the integral pathID as a "half" that we know the hardware will see
     // as a unique value in the fragment shader.
     v_pathID = id_bits_to_f16(pathID, uniforms.pathIDGranularity);
@@ -197,7 +197,7 @@
     // Indicate even-odd fill rule by making pathID negative.
     if ((paintData.x & PAINT_FLAG_EVEN_ODD_FILL) != 0u)
         v_pathID = -v_pathID;
-#endif // !@FEATHER_ATLAS_BLIT && !@RENDER_MODE_MSAA
+#endif // !@FEATHER_ATLAS_BLIT && !@RENDER_MODE_DEPTH_STENCIL
 
     uint paintType = paintData.x & 0xfu;
 #ifdef @ENABLE_CLIPPING
@@ -243,16 +243,16 @@
         float4 clipRectInverseTranslate =
             STORAGE_BUFFER_LOAD4(@paintAuxBuffer,
                                  pathID * PAINT_AUX_ENTRY_ELEMENT_COUNT + 3u);
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
         v_clipRect =
             find_clip_rect_coverage_distances(clipRectInverseMatrix,
                                               clipRectInverseTranslate.xy,
                                               fragCoord);
-#else  // !@RENDER_MODE_MSAA => @RENDER_MODE_MSAA
+#else  // !@RENDER_MODE_DEPTH_STENCIL => @RENDER_MODE_DEPTH_STENCIL
         set_clip_rect_plane_distances(clipRectInverseMatrix,
                                       clipRectInverseTranslate.xy,
                                       fragCoord CLIP_CONTEXT_UNPACK);
-#endif // @RENDER_MODE_MSAA
+#endif // @RENDER_MODE_DEPTH_STENCIL
     }
 #endif // ENABLE_CLIP_RECT
 
@@ -368,7 +368,7 @@
 #ifdef @POST_INVERT_Y
         pos.y = -pos.y;
 #endif
-#ifdef @RENDER_MODE_MSAA
+#ifdef @RENDER_MODE_DEPTH_STENCIL
         pos.z = normalize_z_index(pathZIndex);
 #elif defined(@RENDER_MODE_CLOCKWISE_ATOMIC)
         uint4 coverageData =
@@ -391,14 +391,14 @@
 #endif
 #ifdef @FEATHER_ATLAS_BLIT
     VARYING_PACK(v_atlasCoord);
-#elif !defined(@RENDER_MODE_MSAA)
+#elif !defined(@RENDER_MODE_DEPTH_STENCIL)
 #ifdef @DRAW_INTERIOR_TRIANGLES
     VARYING_PACK(v_windingWeight);
 #else
     VARYING_PACK(v_coverages);
 #endif //@DRAW_INTERIOR_TRIANGLES
     VARYING_PACK(v_pathID);
-#endif // !@RENDER_MODE_MSAA
+#endif // !@RENDER_MODE_DEPTH_STENCIL
 
 #ifdef @ENABLE_CLIPPING
 #ifdef @FEATHER_ATLAS_BLIT
@@ -407,7 +407,7 @@
     VARYING_PACK(v_clipIDs);
 #endif
 #endif // @ENABLE_CLIPPING
-#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_MSAA)
+#if defined(@ENABLE_CLIP_RECT) && !defined(@RENDER_MODE_DEPTH_STENCIL)
     VARYING_PACK(v_clipRect);
 #endif
 #ifdef @ENABLE_ADVANCED_BLEND
diff --git a/renderer/src/shaders/draw_path_common.glsl b/renderer/src/shaders/draw_path_common.glsl
index facf642..0571b9a 100644
--- a/renderer/src/shaders/draw_path_common.glsl
+++ b/renderer/src/shaders/draw_path_common.glsl
@@ -64,7 +64,7 @@
 TEXTURE_RGBA8(PER_DRAW_BINDINGS_SET, IMAGE_TEXTURE_IDX, @imageTexture);
 // The Qualcomm compiler can't handle line breaks in #ifs.
 // clang-format off
-#if defined(@RENDER_MODE_MSAA) && defined(@ENABLE_ADVANCED_BLEND) && !defined(@FIXED_FUNCTION_COLOR_OUTPUT)
+#if defined(@RENDER_MODE_DEPTH_STENCIL) && defined(@ENABLE_ADVANCED_BLEND) && !defined(@FIXED_FUNCTION_COLOR_OUTPUT)
 // clang-format on
 DST_COLOR_TEXTURE(@dstColorTexture);
 #endif
@@ -277,7 +277,7 @@
                                            int _instanceID,
                                            OUT(uint) outPathID,
                                            OUT(float2) outVertexPosition
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
                                            ,
                                            OUT(float4) outCoverages
 #else
@@ -514,7 +514,7 @@
         float2 vertexOffset =
             norm * (strokeRadius + aaRadius); // Bloat stroke width for AA.
 
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
         // Calculate the AA distance to both the outset and inset edges of the
         // stroke. The fragment shader will use whichever is lesser.
         float x = outset * (strokeRadius + aaRadius);
@@ -621,7 +621,7 @@
             float2 pt = abs(outset) * vertexOffset;
             float clipDistance = (clipAARadius - dot(pt, bisector)) /
                                  (bisectPixelWidth * (AA_RADIUS * 2.));
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
             if ((contourIDWithFlags & LEFT_JOIN_CONTOUR_FLAG) != 0u)
                 outCoverages.y = clipDistance;
             else
@@ -629,7 +629,7 @@
 #endif
         }
 
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
         outCoverages.xy *= globalCoverage;
 
         // Bias outCoverages.y slightly upwards in order to guarantee
@@ -653,7 +653,7 @@
     }
     else // This is a fill.
     {
-#ifndef @RENDER_MODE_MSAA
+#ifndef @RENDER_MODE_DEPTH_STENCIL
         // "outCoverages.y < 0" indicates to the fragment shader that this is
         // a fill, as opposed to a stroke.
         outCoverages = float4(fillCoverage, -1., .0, .0);
@@ -757,7 +757,7 @@
             // compiler that also negates Y.
             outCoverages *= float4(-1., +1., +1., +1.);
         }
-#endif // !RENDER_MODE_MSAA
+#endif // !RENDER_MODE_DEPTH_STENCIL
 
         // Place the fan point.
         if (vertexType == FAN_MIDPOINT_VERTEX)
@@ -774,7 +774,7 @@
 
     outVertexPosition = MUL(M, origin) + postTransformVertexOffset + translate;
 
-#ifdef @RENDER_MODE_MSAA
+#ifdef @RENDER_MODE_DEPTH_STENCIL
     uint4 pathData2 = STORAGE_BUFFER_LOAD4(@pathBuffer, outPathID * 4u + 2u);
     outPathZIndex = cast_uint_to_ushort(pathData2.r);
 #else
@@ -792,7 +792,7 @@
 #if defined(@VERTEX) && defined(@DRAW_INTERIOR_TRIANGLES)
 INLINE float2 unpack_interior_triangle_vertex(float3 triangleVertex,
                                               OUT(uint) outPathID
-#ifdef @RENDER_MODE_MSAA
+#ifdef @RENDER_MODE_DEPTH_STENCIL
                                               ,
                                               OUT(ushort) outPathZIndex
 #else
@@ -802,7 +802,7 @@
                                                   VERTEX_CONTEXT_DECL)
 {
     outPathID = floatBitsToUint(triangleVertex.z) & 0xffffu;
-#ifdef @RENDER_MODE_MSAA
+#ifdef @RENDER_MODE_DEPTH_STENCIL
     uint4 pathData2 = STORAGE_BUFFER_LOAD4(@pathBuffer, outPathID * 4u + 2u);
     outPathZIndex = cast_uint_to_ushort(pathData2.x);
 #else
@@ -823,14 +823,14 @@
 INLINE float2
 unpack_atlas_coverage_vertex(float3 triangleVertex,
                              OUT(uint) outPathID,
-#ifdef @RENDER_MODE_MSAA
+#ifdef @RENDER_MODE_DEPTH_STENCIL
                              OUT(ushort) outPathZIndex,
 #endif
                              OUT(float2) outAtlasCoord VERTEX_CONTEXT_DECL)
 {
     outPathID = floatBitsToUint(triangleVertex.z) & 0xffffu;
     uint4 pathData2 = STORAGE_BUFFER_LOAD4(@pathBuffer, outPathID * 4u + 2u);
-#ifdef @RENDER_MODE_MSAA
+#ifdef @RENDER_MODE_DEPTH_STENCIL
     outPathZIndex = cast_uint_to_ushort(pathData2.x);
 #endif
     float2 vertexPos = triangleVertex.xy;
diff --git a/renderer/src/shaders/glsl.glsl b/renderer/src/shaders/glsl.glsl
index 57e10e4..4d8e7df 100644
--- a/renderer/src/shaders/glsl.glsl
+++ b/renderer/src/shaders/glsl.glsl
@@ -81,13 +81,13 @@
 #endif
 
 // clang-format off
-#if defined(@RENDER_MODE_MSAA) && defined(@ENABLE_CLIP_RECT) && defined(GL_ES) && !defined(@DISABLE_CLIP_DISTANCE_FOR_UBERSHADERS)
+#if defined(@RENDER_MODE_DEPTH_STENCIL) && defined(@ENABLE_CLIP_RECT) && defined(GL_ES) && !defined(@DISABLE_CLIP_DISTANCE_FOR_UBERSHADERS)
 #ifdef GL_EXT_clip_cull_distance
 #extension GL_EXT_clip_cull_distance : require
 #elif defined(GL_ANGLE_clip_cull_distance)
 #extension GL_ANGLE_clip_cull_distance : require
 #endif
-#endif // RENDER_MODE_MSAA && ENABLE_CLIP_RECT && GL_ES && !DISABLE_CLIP_DISTANCE_FOR_UBERSHADERS
+#endif // RENDER_MODE_DEPTH_STENCIL && ENABLE_CLIP_RECT && GL_ES && !DISABLE_CLIP_DISTANCE_FOR_UBERSHADERS
 // clang-format on
 
 #if @GLSL_VERSION >= 310
@@ -178,8 +178,8 @@
     layout(binding = IDX) uniform highp itexture2D NAME
 #define TEXTURE_R32UI(SET, IDX, NAME)                                          \
     layout(binding = IDX) uniform highp utexture2D NAME
-#if defined(@FRAGMENT) && defined(@RENDER_MODE_MSAA)
-#endif // @FRAGMENT && @RENDER_MODE_MSAA
+#if defined(@FRAGMENT) && defined(@RENDER_MODE_DEPTH_STENCIL)
+#endif // @FRAGMENT && @RENDER_MODE_DEPTH_STENCIL
 #elif @GLSL_VERSION >= 310
 #define TEXTURE_RGBA32UI(SET, IDX, NAME)                                       \
     layout(binding = IDX) uniform highp usampler2D NAME
@@ -228,9 +228,9 @@
     texture(sampler2D(NAME, SAMPLER_NAME), COORD, LODBIAS)
 #define TEXTURE_SAMPLE_GRAD(NAME, SAMPLER_NAME, COORD, DDX, DDY)               \
     textureGrad(sampler2D(NAME, SAMPLER_NAME), COORD, DDX, DDY)
-#if defined(@FRAGMENT) && defined(@RENDER_MODE_MSAA)
+#if defined(@FRAGMENT) && defined(@RENDER_MODE_DEPTH_STENCIL)
 #extension GL_OES_sample_variables : require
-#endif // @FRAGMENT && @RENDER_MODE_MSAA
+#endif // @FRAGMENT && @RENDER_MODE_DEPTH_STENCIL
 
 #else // @TARGET_SPIRV -> !@TARGET_SPIRV
 
diff --git a/renderer/src/shaders/rhi.glsl b/renderer/src/shaders/rhi.glsl
index aee9efe..2ec6e67 100644
--- a/renderer/src/shaders/rhi.glsl
+++ b/renderer/src/shaders/rhi.glsl
@@ -204,7 +204,7 @@
 #define PLS_TEX2D $RWTexture2D
 #endif
 
-#if defined(@FRAGMENT) && defined(@RENDER_MODE_MSAA)
+#if defined(@FRAGMENT) && defined(@RENDER_MODE_DEPTH_STENCIL)
 
 #ifdef @SUPPORTS_SUBPASS_LOAD
 // Unreal reserves input attachment slot 0 for depth (see
@@ -228,7 +228,7 @@
 
 #define DST_COLOR_FETCH(NAME) NAME[_plsCoord]
 #endif
-#endif // @FRAGMENT && @RENDER_MODE_MSAA
+#endif // @FRAGMENT && @RENDER_MODE_DEPTH_STENCIL
 
 #define PLS_BLOCK_BEGIN
 #define PLS_BLOCK_END
diff --git a/renderer/src/shaders/specialization.glsl b/renderer/src/shaders/specialization.glsl
index 2473fbd..bf0f9c9 100644
--- a/renderer/src/shaders/specialization.glsl
+++ b/renderer/src/shaders/specialization.glsl
@@ -54,7 +54,7 @@
 #ifndef @TARGET_WGSL
 // Since SPIR-V can't omit declarations via specialization constants, only
 // define @EMULATE_DYNAMIC_COLOR_WRITE_DISABLE where it is used (i.e., MSAA).
-#if defined(@RENDER_MODE_MSAA)
+#if defined(@RENDER_MODE_DEPTH_STENCIL)
 #define @EMULATE_DYNAMIC_COLOR_WRITE_DISABLE EmulateDynamicColorWriteDisable
 #endif
 #endif
diff --git a/renderer/src/shaders/spirv/draw_msaa_atlas_blit.main b/renderer/src/shaders/spirv/draw_depthstencil_atlas_blit.main
similarity index 85%
rename from renderer/src/shaders/spirv/draw_msaa_atlas_blit.main
rename to renderer/src/shaders/spirv/draw_depthstencil_atlas_blit.main
index 117dac7..b369830 100644
--- a/renderer/src/shaders/spirv/draw_msaa_atlas_blit.main
+++ b/renderer/src/shaders/spirv/draw_depthstencil_atlas_blit.main
@@ -4,7 +4,7 @@
 #define OPTIONALLY_FLAT flat
 #define DRAW_INTERIOR_TRIANGLES
 #define FEATHER_ATLAS_BLIT
-#define RENDER_MODE_MSAA
+#define RENDER_MODE_DEPTH_STENCIL
 #include "glsl.minified.glsl"
 #include "constants.minified.glsl"
 #include "specialization.minified.glsl"
@@ -13,4 +13,4 @@
 #include "draw_path_common.minified.glsl"
 #include "advanced_blend.minified.glsl"
 #include "draw_path.minified.vert"
-#include "draw_msaa_object.minified.frag"
+#include "draw_depthstencil_object.minified.frag"
diff --git a/renderer/src/shaders/spirv/draw_msaa_image_mesh.main b/renderer/src/shaders/spirv/draw_depthstencil_image_mesh.main
similarity index 84%
rename from renderer/src/shaders/spirv/draw_msaa_image_mesh.main
rename to renderer/src/shaders/spirv/draw_depthstencil_image_mesh.main
index b589e58..6a3f69f 100644
--- a/renderer/src/shaders/spirv/draw_msaa_image_mesh.main
+++ b/renderer/src/shaders/spirv/draw_depthstencil_image_mesh.main
@@ -4,7 +4,7 @@
 #define OPTIONALLY_FLAT flat
 #define DRAW_IMAGE
 #define DRAW_IMAGE_MESH
-#define RENDER_MODE_MSAA
+#define RENDER_MODE_DEPTH_STENCIL
 #include "glsl.minified.glsl"
 #include "constants.minified.glsl"
 #include "specialization.minified.glsl"
@@ -12,4 +12,4 @@
 #include "common.minified.glsl"
 #include "advanced_blend.minified.glsl"
 #include "draw_image_mesh.minified.vert"
-#include "draw_msaa_object.minified.frag"
+#include "draw_depthstencil_object.minified.frag"
diff --git a/renderer/src/shaders/spirv/draw_msaa_path.main b/renderer/src/shaders/spirv/draw_depthstencil_path.main
similarity index 85%
rename from renderer/src/shaders/spirv/draw_msaa_path.main
rename to renderer/src/shaders/spirv/draw_depthstencil_path.main
index 026fc61..e10eaf9 100644
--- a/renderer/src/shaders/spirv/draw_msaa_path.main
+++ b/renderer/src/shaders/spirv/draw_depthstencil_path.main
@@ -4,7 +4,7 @@
 #define ENABLE_INSTANCE_INDEX
 #define OPTIONALLY_FLAT flat
 #define DRAW_PATH
-#define RENDER_MODE_MSAA
+#define RENDER_MODE_DEPTH_STENCIL
 #include "glsl.minified.glsl"
 #include "constants.minified.glsl"
 #include "specialization.minified.glsl"
@@ -13,4 +13,4 @@
 #include "draw_path_common.minified.glsl"
 #include "advanced_blend.minified.glsl"
 #include "draw_path.minified.vert"
-#include "draw_msaa_object.minified.frag"
+#include "draw_depthstencil_object.minified.frag"
diff --git a/renderer/src/shaders/spirv/draw_msaa_stencil.main b/renderer/src/shaders/spirv/draw_depthstencil_triangles_nocolor.main
similarity index 94%
rename from renderer/src/shaders/spirv/draw_msaa_stencil.main
rename to renderer/src/shaders/spirv/draw_depthstencil_triangles_nocolor.main
index 50ce106..769913d 100644
--- a/renderer/src/shaders/spirv/draw_msaa_stencil.main
+++ b/renderer/src/shaders/spirv/draw_depthstencil_triangles_nocolor.main
@@ -2,7 +2,7 @@
 #extension GL_GOOGLE_include_directive : require
 #extension GL_EXT_samplerless_texture_functions : require
 #define OPTIONALLY_FLAT flat
-#define RENDER_MODE_MSAA
+#define RENDER_MODE_DEPTH_STENCIL
 
 // This shader doesn't need ENABLE_CLIP_RECT functionality. Disable it so that 
 // it does not fail to compile on systems without ClipDistance support.
diff --git a/renderer/src/shaders/unreal/draw_msaa_atlas_blit.usf b/renderer/src/shaders/unreal/draw_depthstencil_atlas_blit.usf
similarity index 85%
rename from renderer/src/shaders/unreal/draw_msaa_atlas_blit.usf
rename to renderer/src/shaders/unreal/draw_depthstencil_atlas_blit.usf
index 637860c..96985c1 100644
--- a/renderer/src/shaders/unreal/draw_msaa_atlas_blit.usf
+++ b/renderer/src/shaders/unreal/draw_depthstencil_atlas_blit.usf
@@ -1,7 +1,7 @@
 #define OPTIONALLY_FLAT flat
 #define DRAW_INTERIOR_TRIANGLES 1
 #define FEATHER_ATLAS_BLIT 1
-#define RENDER_MODE_MSAA 1
+#define RENDER_MODE_DEPTH_STENCIL 1
 
 #if ENABLE_CLIP_RECT
 #define NEEDS_CLIP_DISTANCE 1
@@ -21,4 +21,4 @@
 #include "Generated/draw_path_common.minified.ush"
 #include "Generated/advanced_blend.minified.ush"
 #include "Generated/draw_path.minified.vert.ush"
-#include "Generated/draw_msaa_object.minified.frag.ush"
+#include "Generated/draw_depthstencil_object.minified.frag.ush"
diff --git a/renderer/src/shaders/unreal/draw_msaa_image_mesh.usf b/renderer/src/shaders/unreal/draw_depthstencil_image_mesh.usf
similarity index 84%
rename from renderer/src/shaders/unreal/draw_msaa_image_mesh.usf
rename to renderer/src/shaders/unreal/draw_depthstencil_image_mesh.usf
index 373ef7c..658a892 100644
--- a/renderer/src/shaders/unreal/draw_msaa_image_mesh.usf
+++ b/renderer/src/shaders/unreal/draw_depthstencil_image_mesh.usf
@@ -2,7 +2,7 @@
 #define DRAW_IMAGE 1
 #define DRAW_IMAGE_MESH 1
 #define SPLIT_UINT4_ATTRIBUTES 1
-#define RENDER_MODE_MSAA 1
+#define RENDER_MODE_DEPTH_STENCIL 1
 
 #if ENABLE_CLIP_RECT
 #define NEEDS_CLIP_DISTANCE 1
@@ -21,4 +21,4 @@
 #include "Generated/common.minified.ush"
 #include "Generated/advanced_blend.minified.ush"
 #include "Generated/draw_image_mesh.minified.vert.ush"
-#include "Generated/draw_msaa_object.minified.frag.ush"
+#include "Generated/draw_depthstencil_object.minified.frag.ush"
diff --git a/renderer/src/shaders/unreal/draw_msaa_path.usf b/renderer/src/shaders/unreal/draw_depthstencil_path.usf
similarity index 85%
rename from renderer/src/shaders/unreal/draw_msaa_path.usf
rename to renderer/src/shaders/unreal/draw_depthstencil_path.usf
index 21fe274..a85bc11 100644
--- a/renderer/src/shaders/unreal/draw_msaa_path.usf
+++ b/renderer/src/shaders/unreal/draw_depthstencil_path.usf
@@ -1,7 +1,7 @@
 #define ENABLE_INSTANCE_INDEX
 #define OPTIONALLY_FLAT flat
 #define DRAW_PATH 1
-#define RENDER_MODE_MSAA 1
+#define RENDER_MODE_DEPTH_STENCIL 1
 
 #if ENABLE_CLIP_RECT
 #define NEEDS_CLIP_DISTANCE 1
@@ -21,4 +21,4 @@
 #include "Generated/draw_path_common.minified.ush"
 #include "Generated/advanced_blend.minified.ush"
 #include "Generated/draw_path.minified.vert.ush"
-#include "Generated/draw_msaa_object.minified.frag.ush"
+#include "Generated/draw_depthstencil_object.minified.frag.ush"
diff --git a/renderer/src/shaders/unreal/draw_msaa_stencil.usf b/renderer/src/shaders/unreal/draw_depthstencil_triangles_nocolor.usf
similarity index 91%
rename from renderer/src/shaders/unreal/draw_msaa_stencil.usf
rename to renderer/src/shaders/unreal/draw_depthstencil_triangles_nocolor.usf
index f20abef..19edf85 100644
--- a/renderer/src/shaders/unreal/draw_msaa_stencil.usf
+++ b/renderer/src/shaders/unreal/draw_depthstencil_triangles_nocolor.usf
@@ -1,5 +1,5 @@
 #define OPTIONALLY_FLAT flat
-#define RENDER_MODE_MSAA 1
+#define RENDER_MODE_DEPTH_STENCIL 1
 #define NO_VARYING
 
 #include "parse_environment.ush"
diff --git a/renderer/src/vulkan/draw_pipeline_layout_vulkan.cpp b/renderer/src/vulkan/draw_pipeline_layout_vulkan.cpp
index d445545..3390589 100644
--- a/renderer/src/vulkan/draw_pipeline_layout_vulkan.cpp
+++ b/renderer/src/vulkan/draw_pipeline_layout_vulkan.cpp
@@ -45,7 +45,7 @@
         });
     }
 
-    if (interlockMode != gpu::InterlockMode::msaa)
+    if (interlockMode != gpu::InterlockMode::depthStencil)
     {
         plsLayoutBindings.push_back({
             .binding = CLIP_PLANE_IDX,
@@ -84,7 +84,7 @@
             .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
         });
     }
-    else if (interlockMode == gpu::InterlockMode::msaa)
+    else if (interlockMode == gpu::InterlockMode::depthStencil)
     {
         // TODO: pipeline layouts aren't currently keyed by loadAction, but if
         // they were, we could only include this binding with
@@ -173,7 +173,7 @@
         case gpu::InterlockMode::clockwiseAtomic:
             assert(subpassIndex == 0 || subpassIndex == 1);
             return 2; // color & clip.
-        case gpu::InterlockMode::msaa:
+        case gpu::InterlockMode::depthStencil:
             assert(0 <= subpassIndex && subpassIndex <= 2);
             return 1u;
     }
diff --git a/renderer/src/vulkan/draw_pipeline_layout_vulkan.hpp b/renderer/src/vulkan/draw_pipeline_layout_vulkan.hpp
index d1c7be4..5a098ed 100644
--- a/renderer/src/vulkan/draw_pipeline_layout_vulkan.hpp
+++ b/renderer/src/vulkan/draw_pipeline_layout_vulkan.hpp
@@ -41,9 +41,9 @@
     // remove a declaration.
     bool hasColorWriteDisablePushConstant() const
     {
-        // For now, only MSAA gets it -- specialization.glsl leaves
+        // For now, only depthStencil gets it -- specialization.glsl leaves
         // @EMULATE_DYNAMIC_COLOR_WRITE_DISABLE undefined elsewhere.
-        return m_interlockMode == gpu::InterlockMode::msaa;
+        return m_interlockMode == gpu::InterlockMode::depthStencil;
     }
 
     uint32_t colorAttachmentCount(uint32_t subpassIndex,
diff --git a/renderer/src/vulkan/draw_pipeline_vulkan.cpp b/renderer/src/vulkan/draw_pipeline_vulkan.cpp
index 8c5f0f6..b3d04da 100644
--- a/renderer/src/vulkan/draw_pipeline_vulkan.cpp
+++ b/renderer/src/vulkan/draw_pipeline_vulkan.cpp
@@ -106,9 +106,9 @@
 
     // pipeline_unique_key() keys on baked depth/stencil/cull/color state, so a
     // dynamic-state pipeline collides with the static pipelines that share its
-    // state (e.g. msaaDynamicMidpointFans vs. msaaMidpointFans). They need
-    // distinct pipelines -- one uses the dynamic-state layout, the other bakes
-    // -- so fold the layout choice into the key.
+    // state (e.g. stencilDynamicMidpointFans vs. stencilMidpointFans). They
+    // need distinct pipelines -- one uses the dynamic-state layout, the
+    // other bakes -- so fold the layout choice into the key.
     key = math::add_bits_to_key(
         key,
         uint64_t(gpu::drawTypeHasPipelineDynamicState(drawType)),
@@ -133,7 +133,7 @@
     }
 
     const uint32_t mainSubpassIdx =
-        (interlockMode == gpu::InterlockMode::msaa &&
+        (interlockMode == gpu::InterlockMode::depthStencil &&
          colorLoadAction == gpu::LoadAction::preserveRenderTarget)
             ? 1
             : 0;
@@ -149,19 +149,19 @@
         case gpu::DrawType::featherAtlasBlit:
         case gpu::DrawType::imageRect:
         case gpu::DrawType::imageMesh:
-        case gpu::DrawType::msaaStrokes:
-        case gpu::DrawType::msaaMidpointFanBorrowedCoverage:
-        case gpu::DrawType::msaaDynamicMidpointFans:
-        case gpu::DrawType::msaaDynamicOuterCubics:
-        case gpu::DrawType::msaaMidpointFans:
-        case gpu::DrawType::msaaMidpointFanStencilReset:
-        case gpu::DrawType::msaaMidpointFanPathsStencil:
-        case gpu::DrawType::msaaMidpointFanPathsCover:
-        case gpu::DrawType::msaaOuterCubicBorrowedCoverage:
-        case gpu::DrawType::msaaOuterCubicStencilReset:
-        case gpu::DrawType::msaaOuterCubicPathsStencil:
-        case gpu::DrawType::msaaOuterCubicPathsCover:
-        case gpu::DrawType::msaaOuterCubics:
+        case gpu::DrawType::depthStrokes:
+        case gpu::DrawType::stencilMidpointFanBorrowedCoverage:
+        case gpu::DrawType::stencilDynamicMidpointFans:
+        case gpu::DrawType::stencilDynamicOuterCubics:
+        case gpu::DrawType::stencilMidpointFans:
+        case gpu::DrawType::stencilMidpointFanReset:
+        case gpu::DrawType::stencilMidpointFanWinding:
+        case gpu::DrawType::stencilMidpointFanCover:
+        case gpu::DrawType::stencilOuterCubicBorrowedCoverage:
+        case gpu::DrawType::stencilOuterCubicReset:
+        case gpu::DrawType::stencilOuterCubicWinding:
+        case gpu::DrawType::stencilOuterCubicCover:
+        case gpu::DrawType::stencilOuterCubics:
         case gpu::DrawType::clipReset:
             return mainSubpassIdx;
         case gpu::DrawType::renderPassResolve:
@@ -478,7 +478,7 @@
     VkPipelineMultisampleStateCreateInfo msaaState = {
         .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .rasterizationSamples =
-            (interlockMode == gpu::InterlockMode::msaa &&
+            (interlockMode == gpu::InterlockMode::depthStencil &&
              props.drawType != gpu::DrawType::renderPassResolve)
                 ? VK_SAMPLE_COUNT_4_BIT
                 : VK_SAMPLE_COUNT_1_BIT,
@@ -520,7 +520,7 @@
         .pViewportState = &layout::SINGLE_VIEWPORT,
         .pRasterizationState = &pipelineRasterizationStateCreateInfo,
         .pMultisampleState = &msaaState,
-        .pDepthStencilState = interlockMode == gpu::InterlockMode::msaa
+        .pDepthStencilState = interlockMode == gpu::InterlockMode::depthStencil
                                   ? &depthStencilState
                                   : nullptr,
         .pColorBlendState = &pipelineColorBlendStateCreateInfo,
@@ -535,19 +535,19 @@
         case DrawType::midpointFanPatches:
         case DrawType::midpointFanCenterAAPatches:
         case DrawType::outerCurvePatches:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
+        case DrawType::stencilOuterCubics:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
             pipelineCreateInfo.pVertexInputState =
                 &layout::PATH_VERTEX_INPUT_STATE;
             pipelineCreateInfo.pInputAssemblyState =
diff --git a/renderer/src/vulkan/draw_shader_vulkan.cpp b/renderer/src/vulkan/draw_shader_vulkan.cpp
index 0d439ce..cf3703f 100644
--- a/renderer/src/vulkan/draw_shader_vulkan.cpp
+++ b/renderer/src/vulkan/draw_shader_vulkan.cpp
@@ -23,12 +23,13 @@
         enums::is_flag_set(shaderMiscFlags,
                            gpu::ShaderMiscFlags::fixedFunctionColorOutput);
 
-    if (type == Type::fragment && interlockMode == InterlockMode::msaa &&
+    if (type == Type::fragment &&
+        interlockMode == InterlockMode::depthStencil &&
         drawType != DrawType::renderPassInitialize &&
         drawType != DrawType::renderPassResolve)
     {
         // Fixed function color output and advanced blend are mutually exclusive
-        // and one of them should always be set in msaa mode.
+        // and one of them should always be set in depthStencil mode.
         assert(fixedFunctionColorOutput !=
                bool(shaderFeatures & ShaderFeatures::ENABLE_ADVANCED_BLEND));
     }
@@ -70,19 +71,19 @@
                     break;
 
                 case DrawType::imageRect:
-                case DrawType::msaaStrokes:
-                case DrawType::msaaMidpointFanBorrowedCoverage:
-                case DrawType::msaaDynamicMidpointFans:
-                case DrawType::msaaDynamicOuterCubics:
-                case DrawType::msaaMidpointFans:
-                case DrawType::msaaMidpointFanStencilReset:
-                case DrawType::msaaMidpointFanPathsStencil:
-                case DrawType::msaaMidpointFanPathsCover:
-                case DrawType::msaaOuterCubicBorrowedCoverage:
-                case DrawType::msaaOuterCubicStencilReset:
-                case DrawType::msaaOuterCubicPathsStencil:
-                case DrawType::msaaOuterCubicPathsCover:
-                case DrawType::msaaOuterCubics:
+                case DrawType::depthStrokes:
+                case DrawType::stencilMidpointFanBorrowedCoverage:
+                case DrawType::stencilDynamicMidpointFans:
+                case DrawType::stencilDynamicOuterCubics:
+                case DrawType::stencilMidpointFans:
+                case DrawType::stencilMidpointFanReset:
+                case DrawType::stencilMidpointFanWinding:
+                case DrawType::stencilMidpointFanCover:
+                case DrawType::stencilOuterCubicBorrowedCoverage:
+                case DrawType::stencilOuterCubicReset:
+                case DrawType::stencilOuterCubicWinding:
+                case DrawType::stencilOuterCubicCover:
+                case DrawType::stencilOuterCubics:
                 case DrawType::clipReset:
                 case DrawType::renderPassInitialize:
                     RIVE_UNREACHABLE();
@@ -153,19 +154,19 @@
                     }
                     break;
 
-                case DrawType::msaaStrokes:
-                case DrawType::msaaMidpointFanBorrowedCoverage:
-                case DrawType::msaaDynamicMidpointFans:
-                case DrawType::msaaDynamicOuterCubics:
-                case DrawType::msaaMidpointFans:
-                case DrawType::msaaMidpointFanStencilReset:
-                case DrawType::msaaMidpointFanPathsStencil:
-                case DrawType::msaaMidpointFanPathsCover:
-                case DrawType::msaaOuterCubicBorrowedCoverage:
-                case DrawType::msaaOuterCubicStencilReset:
-                case DrawType::msaaOuterCubicPathsStencil:
-                case DrawType::msaaOuterCubicPathsCover:
-                case DrawType::msaaOuterCubics:
+                case DrawType::depthStrokes:
+                case DrawType::stencilMidpointFanBorrowedCoverage:
+                case DrawType::stencilDynamicMidpointFans:
+                case DrawType::stencilDynamicOuterCubics:
+                case DrawType::stencilMidpointFans:
+                case DrawType::stencilMidpointFanReset:
+                case DrawType::stencilMidpointFanWinding:
+                case DrawType::stencilMidpointFanCover:
+                case DrawType::stencilOuterCubicBorrowedCoverage:
+                case DrawType::stencilOuterCubicReset:
+                case DrawType::stencilOuterCubicWinding:
+                case DrawType::stencilOuterCubicCover:
+                case DrawType::stencilOuterCubics:
                 case DrawType::clipReset:
                 case DrawType::renderPassInitialize:
                     RIVE_UNREACHABLE();
@@ -227,19 +228,19 @@
                     break;
 
                 case DrawType::imageRect:
-                case DrawType::msaaStrokes:
-                case DrawType::msaaMidpointFanBorrowedCoverage:
-                case DrawType::msaaDynamicMidpointFans:
-                case DrawType::msaaDynamicOuterCubics:
-                case DrawType::msaaMidpointFans:
-                case DrawType::msaaMidpointFanStencilReset:
-                case DrawType::msaaMidpointFanPathsStencil:
-                case DrawType::msaaMidpointFanPathsCover:
-                case DrawType::msaaOuterCubicBorrowedCoverage:
-                case DrawType::msaaOuterCubicStencilReset:
-                case DrawType::msaaOuterCubicPathsStencil:
-                case DrawType::msaaOuterCubicPathsCover:
-                case DrawType::msaaOuterCubics:
+                case DrawType::depthStrokes:
+                case DrawType::stencilMidpointFanBorrowedCoverage:
+                case DrawType::stencilDynamicMidpointFans:
+                case DrawType::stencilDynamicOuterCubics:
+                case DrawType::stencilMidpointFans:
+                case DrawType::stencilMidpointFanReset:
+                case DrawType::stencilMidpointFanWinding:
+                case DrawType::stencilMidpointFanCover:
+                case DrawType::stencilOuterCubicBorrowedCoverage:
+                case DrawType::stencilOuterCubicReset:
+                case DrawType::stencilOuterCubicWinding:
+                case DrawType::stencilOuterCubicCover:
+                case DrawType::stencilOuterCubics:
                 case DrawType::clipReset:
                 case DrawType::renderPassResolve:
                 case DrawType::renderPassInitialize:
@@ -376,26 +377,26 @@
                     break;
 
                 case DrawType::imageRect:
-                case DrawType::msaaStrokes:
-                case DrawType::msaaMidpointFanBorrowedCoverage:
-                case DrawType::msaaDynamicMidpointFans:
-                case DrawType::msaaDynamicOuterCubics:
-                case DrawType::msaaMidpointFans:
-                case DrawType::msaaMidpointFanStencilReset:
-                case DrawType::msaaMidpointFanPathsStencil:
-                case DrawType::msaaMidpointFanPathsCover:
-                case DrawType::msaaOuterCubicBorrowedCoverage:
-                case DrawType::msaaOuterCubicStencilReset:
-                case DrawType::msaaOuterCubicPathsStencil:
-                case DrawType::msaaOuterCubicPathsCover:
-                case DrawType::msaaOuterCubics:
+                case DrawType::depthStrokes:
+                case DrawType::stencilMidpointFanBorrowedCoverage:
+                case DrawType::stencilDynamicMidpointFans:
+                case DrawType::stencilDynamicOuterCubics:
+                case DrawType::stencilMidpointFans:
+                case DrawType::stencilMidpointFanReset:
+                case DrawType::stencilMidpointFanWinding:
+                case DrawType::stencilMidpointFanCover:
+                case DrawType::stencilOuterCubicBorrowedCoverage:
+                case DrawType::stencilOuterCubicReset:
+                case DrawType::stencilOuterCubicWinding:
+                case DrawType::stencilOuterCubicCover:
+                case DrawType::stencilOuterCubics:
                 case DrawType::renderPassResolve:
                     RIVE_UNREACHABLE();
             }
             break;
         }
 
-        case gpu::InterlockMode::msaa:
+        case gpu::InterlockMode::depthStencil:
         {
             switch (drawType)
             {
@@ -404,36 +405,39 @@
                 case DrawType::outerCurvePatches:
                     RIVE_UNREACHABLE();
 
-                case DrawType::msaaOuterCubicBorrowedCoverage:
-                case DrawType::msaaOuterCubicStencilReset:
-                case DrawType::msaaOuterCubicPathsStencil:
-                case DrawType::msaaOuterCubicPathsCover:
-                case DrawType::msaaOuterCubics:
-                case DrawType::msaaStrokes:
-                case DrawType::msaaMidpointFanBorrowedCoverage:
-                case DrawType::msaaDynamicMidpointFans:
-                case DrawType::msaaDynamicOuterCubics:
-                case DrawType::msaaMidpointFans:
-                case DrawType::msaaMidpointFanStencilReset:
-                case DrawType::msaaMidpointFanPathsStencil:
-                case DrawType::msaaMidpointFanPathsCover:
+                case DrawType::stencilOuterCubicBorrowedCoverage:
+                case DrawType::stencilOuterCubicReset:
+                case DrawType::stencilOuterCubicWinding:
+                case DrawType::stencilOuterCubicCover:
+                case DrawType::stencilOuterCubics:
+                case DrawType::depthStrokes:
+                case DrawType::stencilMidpointFanBorrowedCoverage:
+                case DrawType::stencilDynamicMidpointFans:
+                case DrawType::stencilDynamicOuterCubics:
+                case DrawType::stencilMidpointFans:
+                case DrawType::stencilMidpointFanReset:
+                case DrawType::stencilMidpointFanWinding:
+                case DrawType::stencilMidpointFanCover:
                     vertCode =
                         enums::is_flag_set(shaderFeatures,
                                            ShaderFeatures::ENABLE_CLIP_RECT)
-                            ? spirv::draw_msaa_path_vert
-                            : spirv::draw_msaa_path_noclipdistance_vert;
-                    fragCode = fixedFunctionColorOutput
-                                   ? spirv::draw_msaa_path_fixedcolor_frag
-                                   : spirv::draw_msaa_path_frag;
+                            ? spirv::draw_depthstencil_path_vert
+                            : spirv::draw_depthstencil_path_noclipdistance_vert;
+                    fragCode =
+                        fixedFunctionColorOutput
+                            ? spirv::draw_depthstencil_path_fixedcolor_frag
+                            : spirv::draw_depthstencil_path_frag;
                     break;
 
                 case DrawType::clipReset:
-                    vertCode = spirv::draw_msaa_stencil_vert;
-                    fragCode = spirv::draw_msaa_stencil_frag;
+                    vertCode = spirv::draw_depthstencil_triangles_nocolor_vert;
+                    fragCode = spirv::draw_depthstencil_triangles_nocolor_frag;
                     break;
 
                 case DrawType::interiorTriangulation:
-                    // Interior triangulation is not yet implemented for MSAA.
+                    // depthStencil interior triangles are smuggled in with
+                    // outerCubic patches instead of using the
+                    // interiorTriangulation draw type.
                     RIVE_UNREACHABLE();
                     break;
 
@@ -441,26 +445,32 @@
                     vertCode =
                         enums::is_flag_set(shaderFeatures,
                                            ShaderFeatures::ENABLE_CLIP_RECT)
-                            ? spirv::draw_msaa_atlas_blit_vert
-                            : spirv::draw_msaa_atlas_blit_noclipdistance_vert;
-                    fragCode = fixedFunctionColorOutput
-                                   ? spirv::draw_msaa_atlas_blit_fixedcolor_frag
-                                   : spirv::draw_msaa_atlas_blit_frag;
+                            ? spirv::draw_depthstencil_atlas_blit_vert
+                            : spirv::
+                                  draw_depthstencil_atlas_blit_noclipdistance_vert;
+                    fragCode =
+                        fixedFunctionColorOutput
+                            ? spirv::
+                                  draw_depthstencil_atlas_blit_fixedcolor_frag
+                            : spirv::draw_depthstencil_atlas_blit_frag;
                     break;
 
                 case DrawType::imageMesh:
                     vertCode =
                         enums::is_flag_set(shaderFeatures,
                                            ShaderFeatures::ENABLE_CLIP_RECT)
-                            ? spirv::draw_msaa_image_mesh_vert
-                            : spirv::draw_msaa_image_mesh_noclipdistance_vert;
-                    fragCode = fixedFunctionColorOutput
-                                   ? spirv::draw_msaa_image_mesh_fixedcolor_frag
-                                   : spirv::draw_msaa_image_mesh_frag;
+                            ? spirv::draw_depthstencil_image_mesh_vert
+                            : spirv::
+                                  draw_depthstencil_image_mesh_noclipdistance_vert;
+                    fragCode =
+                        fixedFunctionColorOutput
+                            ? spirv::
+                                  draw_depthstencil_image_mesh_fixedcolor_frag
+                            : spirv::draw_depthstencil_image_mesh_frag;
                     break;
 
                 case DrawType::renderPassInitialize:
-                    // MSAA render passes get initialized by drawing the
+                    // depthStencil render passes get initialized by drawing the
                     // previous contents into the framebuffer.
                     // (LoadAction::preserveRenderTarget only.)
                     vertCode = spirv::draw_fullscreen_quad_vert;
diff --git a/renderer/src/vulkan/pipeline_manager_vulkan.cpp b/renderer/src/vulkan/pipeline_manager_vulkan.cpp
index b20c429..f26756a 100644
--- a/renderer/src/vulkan/pipeline_manager_vulkan.cpp
+++ b/renderer/src/vulkan/pipeline_manager_vulkan.cpp
@@ -441,7 +441,7 @@
         case InterlockMode::clockwiseAtomic:
             return make_span(SRC_OVER_ONLY);
 
-        case InterlockMode::msaa:
+        case InterlockMode::depthStencil:
             // If this assert ever fires (i.e. if we ever support GPU fixed-
             // function advanced blend in Vulkan), we'll need to return a list
             // of all blend modes instead of just srcOver.
@@ -478,18 +478,18 @@
                 .colorLoadAction = colorLoadAction,
             };
 
-            // only MSAA has draw contents options that are relevant to pipeline
-            // creation
+            // only depthStencil has draw contents options that are relevant to
+            // pipeline creation
             const auto validDrawContents =
-                (interlockMode == InterlockMode::msaa)
-                    ? DRAW_CONTENTS_FOR_MSAA_PIPELINE_STATE
+                (interlockMode == InterlockMode::depthStencil)
+                    ? DrawContentsForDepthStencilPipelineState
                     : DrawContents::none;
 
             RenderPassOptionsVulkan fixedPassOptions =
                 RenderPassOptionsVulkan::none;
 
             if (interlockMode != InterlockMode::clockwiseAtomic &&
-                interlockMode != InterlockMode::msaa &&
+                interlockMode != InterlockMode::depthStencil &&
                 enums::is_flag_set(shaderMiscFlags,
                                    ShaderMiscFlags::fixedFunctionColorOutput))
             {
@@ -539,7 +539,7 @@
                     }
                     break;
 
-                case InterlockMode::msaa:
+                case InterlockMode::depthStencil:
                     validPassOptions |=
                         RenderPassOptionsVulkan::manuallyResolved |
                         RenderPassOptionsVulkan::msaaSeedFromOffscreenTexture;
@@ -548,9 +548,9 @@
                             shaderMiscFlags,
                             ShaderMiscFlags::fixedFunctionColorOutput))
                     {
-                        // Like clockwiseAtomic, msaa render passes are allowed
-                        // to not have this flag even if a specific shader
-                        // specifies it.
+                        // Like clockwiseAtomic, depthStencil render passes are
+                        // allowed to not have this flag even if a specific
+                        // shader specifies it.
                         validPassOptions |=
                             RenderPassOptionsVulkan::fixedFunctionColorOutput;
                     }
diff --git a/renderer/src/vulkan/render_context_vulkan_impl.cpp b/renderer/src/vulkan/render_context_vulkan_impl.cpp
index 6692df3..8a88254 100644
--- a/renderer/src/vulkan/render_context_vulkan_impl.cpp
+++ b/renderer/src/vulkan/render_context_vulkan_impl.cpp
@@ -1841,7 +1841,7 @@
                  VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT);
 #endif
     }
-    if (interlockMode == gpu::InterlockMode::msaa &&
+    if (interlockMode == gpu::InterlockMode::depthStencil &&
         !m_workarounds.avoidManualMSAAResolves)
     {
         if (!renderTargetUpdateBounds.contains(renderTarget->bounds()))
@@ -2277,7 +2277,7 @@
             clearValues.push_back({});
             break;
 
-        case gpu::InterlockMode::msaa:
+        case gpu::InterlockMode::depthStencil:
             assert(framebufferViews.size() == MSAA_DEPTH_STENCIL_IDX);
             framebufferViews.push_back(
                 renderTarget->msaaDepthStencilTexture()->vkImageView());
@@ -2427,14 +2427,14 @@
         // to handle manual resolving.
         renderPassOptions |= RenderPassOptionsVulkan::manuallyResolved;
     }
-    else if (desc.interlockMode == gpu::InterlockMode::msaa)
+    else if (desc.interlockMode == gpu::InterlockMode::depthStencil)
     {
         // Vulkan does not support partial MSAA resolves when using resolve
         // attachments.
         drawBounds = renderTarget->bounds();
     }
     // Vulkan builtin MSAA resolves don't support partial drawBounds.
-    assert(desc.interlockMode != gpu::InterlockMode::msaa ||
+    assert(desc.interlockMode != gpu::InterlockMode::depthStencil ||
            desc.manuallyResolved || drawBounds == renderTarget->bounds());
 
     const auto commandBuffer =
@@ -2461,19 +2461,19 @@
             case DrawType::midpointFanPatches:
             case DrawType::midpointFanCenterAAPatches:
             case DrawType::outerCurvePatches:
-            case DrawType::msaaOuterCubicBorrowedCoverage:
-            case DrawType::msaaOuterCubicStencilReset:
-            case DrawType::msaaOuterCubicPathsStencil:
-            case DrawType::msaaOuterCubicPathsCover:
-            case DrawType::msaaOuterCubics:
-            case DrawType::msaaStrokes:
-            case DrawType::msaaMidpointFanBorrowedCoverage:
-            case DrawType::msaaDynamicMidpointFans:
-            case DrawType::msaaDynamicOuterCubics:
-            case DrawType::msaaMidpointFans:
-            case DrawType::msaaMidpointFanStencilReset:
-            case DrawType::msaaMidpointFanPathsStencil:
-            case DrawType::msaaMidpointFanPathsCover:
+            case DrawType::stencilOuterCubicBorrowedCoverage:
+            case DrawType::stencilOuterCubicReset:
+            case DrawType::stencilOuterCubicWinding:
+            case DrawType::stencilOuterCubicCover:
+            case DrawType::stencilOuterCubics:
+            case DrawType::depthStrokes:
+            case DrawType::stencilMidpointFanBorrowedCoverage:
+            case DrawType::stencilDynamicMidpointFans:
+            case DrawType::stencilDynamicOuterCubics:
+            case DrawType::stencilMidpointFans:
+            case DrawType::stencilMidpointFanReset:
+            case DrawType::stencilMidpointFanWinding:
+            case DrawType::stencilMidpointFanCover:
                 pendingTessPatchCount += batch.elementCount;
                 break;
             case DrawType::clipReset:
@@ -3017,7 +3017,7 @@
     VkImageView msaaResolveImageView = VK_NULL_HANDLE;
     VkImageView msaaColorSeedImageView = VK_NULL_HANDLE;
 
-    if (desc.interlockMode == gpu::InterlockMode::msaa)
+    if (desc.interlockMode == gpu::InterlockMode::depthStencil)
     {
         colorImageView = renderTarget->msaaColorTexture()->vkImageView();
 
@@ -3374,11 +3374,11 @@
     // for now, is to break the frame up into smaller chunks so that Rive can be
     // pre-empted by other rendering processes.
     //
-    // This is not yet supported on MSAA.
+    // This is not yet supported on depthStencil.
     int32_t virtualTileWidth = drawBounds.width();
     int32_t virtualTileHeight = drawBounds.height();
     if (desc.virtualTileWidth != 0 && desc.virtualTileHeight != 0 &&
-        desc.interlockMode != gpu::InterlockMode::msaa)
+        desc.interlockMode != gpu::InterlockMode::depthStencil)
     {
         virtualTileWidth = desc.virtualTileWidth;
         virtualTileHeight = desc.virtualTileHeight;
@@ -3431,7 +3431,7 @@
                 }});
         }
 
-        if (desc.interlockMode != gpu::InterlockMode::msaa)
+        if (desc.interlockMode != gpu::InterlockMode::depthStencil)
         {
             m_vk->updateImageDescriptorSets(
                 inputAttachmentDescriptorSet,
@@ -3502,7 +3502,7 @@
 
         if (msaaColorSeedImageView != VK_NULL_HANDLE)
         {
-            assert(desc.interlockMode == gpu::InterlockMode::msaa &&
+            assert(desc.interlockMode == gpu::InterlockMode::depthStencil &&
                    desc.colorLoadAction ==
                        gpu::LoadAction::preserveRenderTarget);
             m_vk->updateImageDescriptorSets(
@@ -3600,7 +3600,7 @@
         assert(desc.interlockMode != gpu::InterlockMode::atomics);
 
         // MSAA never needs this copy. It handles resolves differently.
-        assert(desc.interlockMode != gpu::InterlockMode::msaa);
+        assert(desc.interlockMode != gpu::InterlockMode::depthStencil);
 
         constexpr static vkutil::ImageAccess ACCESS_COPY_FROM = {
             .pipelineStages = VK_PIPELINE_STAGE_TRANSFER_BIT,
@@ -3863,7 +3863,7 @@
                     (!desc.fixedFunctionColorOutput ||
                      enums::is_flag_set(batch.barriers,
                                         BarrierFlags::plsAtomic))) ||
-                   (desc.interlockMode == gpu::InterlockMode::msaa &&
+                   (desc.interlockMode == gpu::InterlockMode::depthStencil &&
                     (!desc.fixedFunctionColorOutput ||
                      // The MSAA init also reads the framebuffer.
                      batch.drawType == gpu::DrawType::renderPassInitialize)));
@@ -3953,17 +3953,17 @@
             case DrawType::midpointFanPatches:
             case DrawType::midpointFanCenterAAPatches:
             case DrawType::outerCurvePatches:
-            case DrawType::msaaOuterCubicBorrowedCoverage:
-            case DrawType::msaaOuterCubicStencilReset:
-            case DrawType::msaaOuterCubicPathsStencil:
-            case DrawType::msaaOuterCubicPathsCover:
-            case DrawType::msaaOuterCubics:
-            case DrawType::msaaStrokes:
-            case DrawType::msaaMidpointFanBorrowedCoverage:
-            case DrawType::msaaMidpointFans:
-            case DrawType::msaaMidpointFanStencilReset:
-            case DrawType::msaaMidpointFanPathsStencil:
-            case DrawType::msaaMidpointFanPathsCover:
+            case DrawType::stencilOuterCubicBorrowedCoverage:
+            case DrawType::stencilOuterCubicReset:
+            case DrawType::stencilOuterCubicWinding:
+            case DrawType::stencilOuterCubicCover:
+            case DrawType::stencilOuterCubics:
+            case DrawType::depthStrokes:
+            case DrawType::stencilMidpointFanBorrowedCoverage:
+            case DrawType::stencilMidpointFans:
+            case DrawType::stencilMidpointFanReset:
+            case DrawType::stencilMidpointFanWinding:
+            case DrawType::stencilMidpointFanCover:
             {
                 // Draw patches that connect the tessellation vertices.
                 m_vk->CmdBindVertexBuffers(
@@ -3997,8 +3997,8 @@
                 break;
             }
 
-            case DrawType::msaaDynamicMidpointFans:
-            case DrawType::msaaDynamicOuterCubics:
+            case DrawType::stencilDynamicMidpointFans:
+            case DrawType::stencilDynamicOuterCubics:
             {
                 pendingTessPatchCount -= batch.elementCount;
                 if (drawPipeline == nullptr)
@@ -4033,9 +4033,10 @@
                 // The outer-cubic passes use identical dynamic state to their
                 // midpoint-fan counterparts, so drive both modes from the
                 // midpoint-fan types.
-                for (DrawType pass : {DrawType::msaaMidpointFanBorrowedCoverage,
-                                      DrawType::msaaMidpointFans,
-                                      DrawType::msaaMidpointFanStencilReset})
+                for (DrawType pass :
+                     {DrawType::stencilMidpointFanBorrowedCoverage,
+                      DrawType::stencilMidpointFans,
+                      DrawType::stencilMidpointFanReset})
                 {
                     gpu::PipelineState pipelineState =
                         gpu::get_pipeline_state(pass,
diff --git a/renderer/src/vulkan/render_pass_vulkan.cpp b/renderer/src/vulkan/render_pass_vulkan.cpp
index ee50d1e..c2dda52 100644
--- a/renderer/src/vulkan/render_pass_vulkan.cpp
+++ b/renderer/src/vulkan/render_pass_vulkan.cpp
@@ -23,7 +23,7 @@
     switch (loadAction)
     {
         case gpu::LoadAction::preserveRenderTarget:
-            return (interlockMode == gpu::InterlockMode::msaa)
+            return (interlockMode == gpu::InterlockMode::depthStencil)
                        // In MSAA we need to implement the loadOp with a manual
                        // draw instead, since the MSAA attachment is transient
                        // and its color is seeded from the actual render target.
@@ -224,8 +224,9 @@
             ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
             : VK_IMAGE_LAYOUT_GENERAL;
     const VkSampleCountFlagBits msaaSampleCount =
-        (interlockMode == gpu::InterlockMode::msaa) ? VK_SAMPLE_COUNT_4_BIT
-                                                    : VK_SAMPLE_COUNT_1_BIT;
+        (interlockMode == gpu::InterlockMode::depthStencil)
+            ? VK_SAMPLE_COUNT_4_BIT
+            : VK_SAMPLE_COUNT_1_BIT;
     StackVector<VkAttachmentDescription, layout::MAX_RENDER_PASS_ATTACHMENTS>
         attachments;
     StackVector<VkAttachmentReference, PLS_PLANE_COUNT> colorAttachmentRefs;
@@ -247,7 +248,7 @@
                             RenderPassOptionsVulkan::manuallyResolved |
                                 RenderPassOptionsVulkan::
                                     atomicCoalescedResolveAndTransfer) ||
-                        interlockMode == gpu::InterlockMode::msaa)
+                        interlockMode == gpu::InterlockMode::depthStencil)
                            ? VK_ATTACHMENT_STORE_OP_DONT_CARE
                            : VK_ATTACHMENT_STORE_OP_STORE,
             // This could be VK_IMAGE_LAYOUT_UNDEFINED more often, but it would
@@ -262,7 +263,7 @@
                                      RenderPassOptionsVulkan::
                                          atomicCoalescedResolveAndTransfer) &&
                   loadAction != gpu::LoadAction::preserveRenderTarget) ||
-                 interlockMode == gpu::InterlockMode::msaa)
+                 interlockMode == gpu::InterlockMode::depthStencil)
                     ? VK_IMAGE_LAYOUT_UNDEFINED
                     : colorAttachmentLayout,
             .finalLayout = colorAttachmentLayout,
@@ -436,7 +437,7 @@
             resolveAttachmentRef = colorAttachmentRefs[0];
         }
     }
-    else if (interlockMode == gpu::InterlockMode::msaa)
+    else if (interlockMode == gpu::InterlockMode::depthStencil)
     {
         // DEPTH attachment.
         assert(attachments.size() == MSAA_DEPTH_STENCIL_IDX);
@@ -529,7 +530,7 @@
             inputAttachmentRefs.clear();
         }
     }
-    if (interlockMode == gpu::InterlockMode::msaa &&
+    if (interlockMode == gpu::InterlockMode::depthStencil &&
         loadAction == gpu::LoadAction::preserveRenderTarget)
     {
         msaaColorSeedInputAttachmentRef.push_back({
@@ -584,7 +585,7 @@
         };
 
     // MSAA color-load subpass.
-    if (interlockMode == gpu::InterlockMode::msaa &&
+    if (interlockMode == gpu::InterlockMode::depthStencil &&
         loadAction == gpu::LoadAction::preserveRenderTarget)
     {
         assert(msaaColorSeedInputAttachmentRef.size() ==
@@ -683,10 +684,10 @@
         // Without the extra color-load subpass we need an external dependency
         // into the main subpass
         auto externalInDep = EXTERNAL_COLOR_INPUT_DEPENDENCY;
-        if (interlockMode == gpu::InterlockMode::msaa)
+        if (interlockMode == gpu::InterlockMode::depthStencil)
         {
-            // for msaa where the main subpass is first, the external dependency
-            // additionally needs to cover depth/stencil.
+            // for depthStencil where the main subpass is first, the external
+            // dependency additionally needs to cover depth/stencil.
             externalInDep.srcStageMask |=
                 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
             externalInDep.dstStageMask |=
@@ -739,7 +740,7 @@
         .colorAttachmentCount = colorAttachmentRefs.size(),
         .pColorAttachments = colorAttachmentRefs.data(),
         .pResolveAttachments =
-            (interlockMode == gpu::InterlockMode::msaa &&
+            (interlockMode == gpu::InterlockMode::depthStencil &&
              !enums::is_flag_set(renderPassOptions,
                                  RenderPassOptionsVulkan::manuallyResolved))
                 ? &resolveAttachmentRef.value()
@@ -754,7 +755,7 @@
          !rasterOrderedAttachmentAccess) ||
         interlockMode == gpu::InterlockMode::atomics ||
         interlockMode == gpu::InterlockMode::clockwiseAtomic ||
-        (interlockMode == gpu::InterlockMode::msaa &&
+        (interlockMode == gpu::InterlockMode::depthStencil &&
          !enums::is_flag_set(
              renderPassOptions,
              RenderPassOptionsVulkan::fixedFunctionColorOutput)))
@@ -782,7 +783,7 @@
         });
     }
 
-    if (interlockMode == gpu::InterlockMode::msaa)
+    if (interlockMode == gpu::InterlockMode::depthStencil)
     {
         // Main subpass needs a separate external dependency for depth/stencil
         subpassDeps.push_back({
diff --git a/renderer/src/vulkan/render_pass_vulkan.hpp b/renderer/src/vulkan/render_pass_vulkan.hpp
index ef2c220..44c33ed 100644
--- a/renderer/src/vulkan/render_pass_vulkan.hpp
+++ b/renderer/src/vulkan/render_pass_vulkan.hpp
@@ -22,9 +22,9 @@
     // no advanced blend modes so we can use built-in hardware blending.
     fixedFunctionColorOutput = 1 << 0,
 
-    // rasterOrdering or msaa only: The render pass has a fullscreen draw at
-    // the end that resolves rendering data into the renderTarget. (e.g., by
-    // transferring color from offscreen or manually averaging MSAA.)
+    // rasterOrdering or depthStencil only: The render pass has a fullscreen
+    // draw at the end that resolves rendering data into the renderTarget.
+    // (e.g., by transferring color from offscreen or manually averaging MSAA.)
     manuallyResolved = 1 << 1,
 
     // rasterOrdering mode only: Store all transient attachments to memory
diff --git a/renderer/src/vulkan/vulkan_shaders.cpp b/renderer/src/vulkan/vulkan_shaders.cpp
index f0247ed..d596688 100644
--- a/renderer/src/vulkan/vulkan_shaders.cpp
+++ b/renderer/src/vulkan/vulkan_shaders.cpp
@@ -96,22 +96,22 @@
 #include "generated/shaders/spirv/init_clockwise_atomic_workaround.frag.h"
 #include "generated/shaders/spirv/init_clockwise_atomic_workaround.fixedcolor_frag.h"
 
-// InterlockMode::msaa shaders.
-#include "generated/shaders/spirv/draw_msaa_path.vert.h"
-#include "generated/shaders/spirv/draw_msaa_path.frag.h"
-#include "generated/shaders/spirv/draw_msaa_path.fixedcolor_frag.h"
-#include "generated/shaders/spirv/draw_msaa_path.noclipdistance_vert.h"
-#include "generated/shaders/spirv/draw_msaa_stencil.vert.h"
-#include "generated/shaders/spirv/draw_msaa_stencil.frag.h"
-#include "generated/shaders/spirv/draw_msaa_stencil.fixedcolor_frag.h"
-#include "generated/shaders/spirv/draw_msaa_atlas_blit.vert.h"
-#include "generated/shaders/spirv/draw_msaa_atlas_blit.frag.h"
-#include "generated/shaders/spirv/draw_msaa_atlas_blit.fixedcolor_frag.h"
-#include "generated/shaders/spirv/draw_msaa_atlas_blit.noclipdistance_vert.h"
-#include "generated/shaders/spirv/draw_msaa_image_mesh.vert.h"
-#include "generated/shaders/spirv/draw_msaa_image_mesh.frag.h"
-#include "generated/shaders/spirv/draw_msaa_image_mesh.fixedcolor_frag.h"
-#include "generated/shaders/spirv/draw_msaa_image_mesh.noclipdistance_vert.h"
+// InterlockMode::depthStencil shaders.
+#include "generated/shaders/spirv/draw_depthstencil_path.vert.h"
+#include "generated/shaders/spirv/draw_depthstencil_path.frag.h"
+#include "generated/shaders/spirv/draw_depthstencil_path.fixedcolor_frag.h"
+#include "generated/shaders/spirv/draw_depthstencil_path.noclipdistance_vert.h"
+#include "generated/shaders/spirv/draw_depthstencil_triangles_nocolor.vert.h"
+#include "generated/shaders/spirv/draw_depthstencil_triangles_nocolor.frag.h"
+#include "generated/shaders/spirv/draw_depthstencil_triangles_nocolor.fixedcolor_frag.h"
+#include "generated/shaders/spirv/draw_depthstencil_atlas_blit.vert.h"
+#include "generated/shaders/spirv/draw_depthstencil_atlas_blit.frag.h"
+#include "generated/shaders/spirv/draw_depthstencil_atlas_blit.fixedcolor_frag.h"
+#include "generated/shaders/spirv/draw_depthstencil_atlas_blit.noclipdistance_vert.h"
+#include "generated/shaders/spirv/draw_depthstencil_image_mesh.vert.h"
+#include "generated/shaders/spirv/draw_depthstencil_image_mesh.frag.h"
+#include "generated/shaders/spirv/draw_depthstencil_image_mesh.fixedcolor_frag.h"
+#include "generated/shaders/spirv/draw_depthstencil_image_mesh.noclipdistance_vert.h"
 #include "generated/shaders/spirv/draw_fullscreen_quad.vert.h"
 #include "generated/shaders/spirv/draw_input_attachment.frag.h"
 #include "generated/shaders/spirv/draw_msaa_color_seed_attachment.frag.h"
@@ -288,37 +288,38 @@
 rive::Span<const uint32_t> init_clockwise_atomic_workaround_fixedcolor_frag =
     rive::make_span(embedded::init_clockwise_atomic_workaround_fixedcolor_frag);
 
-// InterlockMode::msaa shaders.
-rive::Span<const uint32_t> draw_msaa_path_vert =
-    rive::make_span(embedded::draw_msaa_path_vert);
-rive::Span<const uint32_t> draw_msaa_path_noclipdistance_vert =
-    rive::make_span(embedded::draw_msaa_path_noclipdistance_vert);
-rive::Span<const uint32_t> draw_msaa_path_frag =
-    rive::make_span(embedded::draw_msaa_path_frag);
-rive::Span<const uint32_t> draw_msaa_path_fixedcolor_frag =
-    rive::make_span(embedded::draw_msaa_path_fixedcolor_frag);
-rive::Span<const uint32_t> draw_msaa_stencil_vert =
-    rive::make_span(embedded::draw_msaa_stencil_vert);
-rive::Span<const uint32_t> draw_msaa_stencil_frag =
-    rive::make_span(embedded::draw_msaa_stencil_frag);
-rive::Span<const uint32_t> draw_msaa_stencil_fixedcolor_frag =
-    rive::make_span(embedded::draw_msaa_stencil_fixedcolor_frag);
-rive::Span<const uint32_t> draw_msaa_atlas_blit_vert =
-    rive::make_span(embedded::draw_msaa_atlas_blit_vert);
-rive::Span<const uint32_t> draw_msaa_atlas_blit_noclipdistance_vert =
-    rive::make_span(embedded::draw_msaa_atlas_blit_noclipdistance_vert);
-rive::Span<const uint32_t> draw_msaa_atlas_blit_frag =
-    rive::make_span(embedded::draw_msaa_atlas_blit_frag);
-rive::Span<const uint32_t> draw_msaa_atlas_blit_fixedcolor_frag =
-    rive::make_span(embedded::draw_msaa_atlas_blit_fixedcolor_frag);
-rive::Span<const uint32_t> draw_msaa_image_mesh_vert =
-    rive::make_span(embedded::draw_msaa_image_mesh_vert);
-rive::Span<const uint32_t> draw_msaa_image_mesh_noclipdistance_vert =
-    rive::make_span(embedded::draw_msaa_image_mesh_noclipdistance_vert);
-rive::Span<const uint32_t> draw_msaa_image_mesh_frag =
-    rive::make_span(embedded::draw_msaa_image_mesh_frag);
-rive::Span<const uint32_t> draw_msaa_image_mesh_fixedcolor_frag =
-    rive::make_span(embedded::draw_msaa_image_mesh_fixedcolor_frag);
+// InterlockMode::depthStencil shaders.
+rive::Span<const uint32_t> draw_depthstencil_path_vert =
+    rive::make_span(embedded::draw_depthstencil_path_vert);
+rive::Span<const uint32_t> draw_depthstencil_path_noclipdistance_vert =
+    rive::make_span(embedded::draw_depthstencil_path_noclipdistance_vert);
+rive::Span<const uint32_t> draw_depthstencil_path_frag =
+    rive::make_span(embedded::draw_depthstencil_path_frag);
+rive::Span<const uint32_t> draw_depthstencil_path_fixedcolor_frag =
+    rive::make_span(embedded::draw_depthstencil_path_fixedcolor_frag);
+rive::Span<const uint32_t> draw_depthstencil_triangles_nocolor_vert =
+    rive::make_span(embedded::draw_depthstencil_triangles_nocolor_vert);
+rive::Span<const uint32_t> draw_depthstencil_triangles_nocolor_frag =
+    rive::make_span(embedded::draw_depthstencil_triangles_nocolor_frag);
+rive::Span<const uint32_t> draw_depthstencil_triangles_nocolor_fixedcolor_frag =
+    rive::make_span(
+        embedded::draw_depthstencil_triangles_nocolor_fixedcolor_frag);
+rive::Span<const uint32_t> draw_depthstencil_atlas_blit_vert =
+    rive::make_span(embedded::draw_depthstencil_atlas_blit_vert);
+rive::Span<const uint32_t> draw_depthstencil_atlas_blit_noclipdistance_vert =
+    rive::make_span(embedded::draw_depthstencil_atlas_blit_noclipdistance_vert);
+rive::Span<const uint32_t> draw_depthstencil_atlas_blit_frag =
+    rive::make_span(embedded::draw_depthstencil_atlas_blit_frag);
+rive::Span<const uint32_t> draw_depthstencil_atlas_blit_fixedcolor_frag =
+    rive::make_span(embedded::draw_depthstencil_atlas_blit_fixedcolor_frag);
+rive::Span<const uint32_t> draw_depthstencil_image_mesh_vert =
+    rive::make_span(embedded::draw_depthstencil_image_mesh_vert);
+rive::Span<const uint32_t> draw_depthstencil_image_mesh_noclipdistance_vert =
+    rive::make_span(embedded::draw_depthstencil_image_mesh_noclipdistance_vert);
+rive::Span<const uint32_t> draw_depthstencil_image_mesh_frag =
+    rive::make_span(embedded::draw_depthstencil_image_mesh_frag);
+rive::Span<const uint32_t> draw_depthstencil_image_mesh_fixedcolor_frag =
+    rive::make_span(embedded::draw_depthstencil_image_mesh_fixedcolor_frag);
 rive::Span<const uint32_t> draw_fullscreen_quad_vert =
     rive::make_span(embedded::draw_fullscreen_quad_vert);
 rive::Span<const uint32_t> draw_input_attachment_frag =
@@ -433,21 +434,26 @@
     spirv::init_clockwise_atomic_workaround_fixedcolor_frag =
         readNextBytecodeSpan();
 
-    spirv::draw_msaa_path_vert = readNextBytecodeSpan();
-    spirv::draw_msaa_path_noclipdistance_vert = readNextBytecodeSpan();
-    spirv::draw_msaa_path_frag = readNextBytecodeSpan();
-    spirv::draw_msaa_path_fixedcolor_frag = readNextBytecodeSpan();
-    spirv::draw_msaa_stencil_vert = readNextBytecodeSpan();
-    spirv::draw_msaa_stencil_frag = readNextBytecodeSpan();
-    spirv::draw_msaa_stencil_fixedcolor_frag = readNextBytecodeSpan();
-    spirv::draw_msaa_atlas_blit_vert = readNextBytecodeSpan();
-    spirv::draw_msaa_atlas_blit_noclipdistance_vert = readNextBytecodeSpan();
-    spirv::draw_msaa_atlas_blit_frag = readNextBytecodeSpan();
-    spirv::draw_msaa_atlas_blit_fixedcolor_frag = readNextBytecodeSpan();
-    spirv::draw_msaa_image_mesh_vert = readNextBytecodeSpan();
-    spirv::draw_msaa_image_mesh_noclipdistance_vert = readNextBytecodeSpan();
-    spirv::draw_msaa_image_mesh_frag = readNextBytecodeSpan();
-    spirv::draw_msaa_image_mesh_fixedcolor_frag = readNextBytecodeSpan();
+    spirv::draw_depthstencil_path_vert = readNextBytecodeSpan();
+    spirv::draw_depthstencil_path_noclipdistance_vert = readNextBytecodeSpan();
+    spirv::draw_depthstencil_path_frag = readNextBytecodeSpan();
+    spirv::draw_depthstencil_path_fixedcolor_frag = readNextBytecodeSpan();
+    spirv::draw_depthstencil_triangles_nocolor_vert = readNextBytecodeSpan();
+    spirv::draw_depthstencil_triangles_nocolor_frag = readNextBytecodeSpan();
+    spirv::draw_depthstencil_triangles_nocolor_fixedcolor_frag =
+        readNextBytecodeSpan();
+    spirv::draw_depthstencil_atlas_blit_vert = readNextBytecodeSpan();
+    spirv::draw_depthstencil_atlas_blit_noclipdistance_vert =
+        readNextBytecodeSpan();
+    spirv::draw_depthstencil_atlas_blit_frag = readNextBytecodeSpan();
+    spirv::draw_depthstencil_atlas_blit_fixedcolor_frag =
+        readNextBytecodeSpan();
+    spirv::draw_depthstencil_image_mesh_vert = readNextBytecodeSpan();
+    spirv::draw_depthstencil_image_mesh_noclipdistance_vert =
+        readNextBytecodeSpan();
+    spirv::draw_depthstencil_image_mesh_frag = readNextBytecodeSpan();
+    spirv::draw_depthstencil_image_mesh_fixedcolor_frag =
+        readNextBytecodeSpan();
     spirv::draw_fullscreen_quad_vert = readNextBytecodeSpan();
     spirv::draw_input_attachment_frag = readNextBytecodeSpan();
     spirv::draw_msaa_color_seed_attachment_frag = readNextBytecodeSpan();
diff --git a/renderer/src/vulkan/vulkan_shaders.hpp b/renderer/src/vulkan/vulkan_shaders.hpp
index 3fb1350..8071a87 100644
--- a/renderer/src/vulkan/vulkan_shaders.hpp
+++ b/renderer/src/vulkan/vulkan_shaders.hpp
@@ -106,22 +106,25 @@
 extern rive::Span<const uint32_t>
     init_clockwise_atomic_workaround_fixedcolor_frag;
 
-// InterlockMode::msaa shaders.
-extern rive::Span<const uint32_t> draw_msaa_path_vert;
-extern rive::Span<const uint32_t> draw_msaa_path_noclipdistance_vert;
-extern rive::Span<const uint32_t> draw_msaa_path_frag;
-extern rive::Span<const uint32_t> draw_msaa_path_fixedcolor_frag;
-extern rive::Span<const uint32_t> draw_msaa_stencil_vert;
-extern rive::Span<const uint32_t> draw_msaa_stencil_frag;
-extern rive::Span<const uint32_t> draw_msaa_stencil_fixedcolor_frag;
-extern rive::Span<const uint32_t> draw_msaa_atlas_blit_vert;
-extern rive::Span<const uint32_t> draw_msaa_atlas_blit_noclipdistance_vert;
-extern rive::Span<const uint32_t> draw_msaa_atlas_blit_frag;
-extern rive::Span<const uint32_t> draw_msaa_atlas_blit_fixedcolor_frag;
-extern rive::Span<const uint32_t> draw_msaa_image_mesh_vert;
-extern rive::Span<const uint32_t> draw_msaa_image_mesh_noclipdistance_vert;
-extern rive::Span<const uint32_t> draw_msaa_image_mesh_frag;
-extern rive::Span<const uint32_t> draw_msaa_image_mesh_fixedcolor_frag;
+// InterlockMode::depthStencil shaders.
+extern rive::Span<const uint32_t> draw_depthstencil_path_vert;
+extern rive::Span<const uint32_t> draw_depthstencil_path_noclipdistance_vert;
+extern rive::Span<const uint32_t> draw_depthstencil_path_frag;
+extern rive::Span<const uint32_t> draw_depthstencil_path_fixedcolor_frag;
+extern rive::Span<const uint32_t> draw_depthstencil_triangles_nocolor_vert;
+extern rive::Span<const uint32_t> draw_depthstencil_triangles_nocolor_frag;
+extern rive::Span<const uint32_t>
+    draw_depthstencil_triangles_nocolor_fixedcolor_frag;
+extern rive::Span<const uint32_t> draw_depthstencil_atlas_blit_vert;
+extern rive::Span<const uint32_t>
+    draw_depthstencil_atlas_blit_noclipdistance_vert;
+extern rive::Span<const uint32_t> draw_depthstencil_atlas_blit_frag;
+extern rive::Span<const uint32_t> draw_depthstencil_atlas_blit_fixedcolor_frag;
+extern rive::Span<const uint32_t> draw_depthstencil_image_mesh_vert;
+extern rive::Span<const uint32_t>
+    draw_depthstencil_image_mesh_noclipdistance_vert;
+extern rive::Span<const uint32_t> draw_depthstencil_image_mesh_frag;
+extern rive::Span<const uint32_t> draw_depthstencil_image_mesh_fixedcolor_frag;
 extern rive::Span<const uint32_t> draw_fullscreen_quad_vert;
 extern rive::Span<const uint32_t> draw_input_attachment_frag;
 extern rive::Span<const uint32_t> draw_msaa_color_seed_attachment_frag;
diff --git a/renderer/src/webgpu/render_context_webgpu_impl.cpp b/renderer/src/webgpu/render_context_webgpu_impl.cpp
index 214ffe9..6245881 100644
--- a/renderer/src/webgpu/render_context_webgpu_impl.cpp
+++ b/renderer/src/webgpu/render_context_webgpu_impl.cpp
@@ -54,25 +54,25 @@
 #include "generated/shaders/wgsl/atomic_init.webgpu_frag.hpp"
 #include "generated/shaders/wgsl/atomic_init.webgpu_fixedcolor_frag.hpp"
 
-// InterlockMode::msaa shaders.
-#include "generated/shaders/wgsl/draw_msaa_path.webgpu_vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_path.webgpu_noclipdistance_vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_path.webgpu_nossbo_vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_path.webgpu_nossbo_noclipdistance_vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_path.webgpu_frag.hpp"
-#include "generated/shaders/wgsl/draw_msaa_path.webgpu_fixedcolor_frag.hpp"
-#include "generated/shaders/wgsl/draw_msaa_atlas_blit.webgpu_vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_atlas_blit.webgpu_noclipdistance_vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_atlas_blit.webgpu_nossbo_vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_atlas_blit.webgpu_nossbo_noclipdistance_vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_atlas_blit.webgpu_frag.hpp"
-#include "generated/shaders/wgsl/draw_msaa_atlas_blit.webgpu_fixedcolor_frag.hpp"
-#include "generated/shaders/wgsl/draw_msaa_image_mesh.webgpu_vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_image_mesh.webgpu_noclipdistance_vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_image_mesh.webgpu_frag.hpp"
-#include "generated/shaders/wgsl/draw_msaa_image_mesh.webgpu_fixedcolor_frag.hpp"
-#include "generated/shaders/wgsl/draw_msaa_stencil.vert.hpp"
-#include "generated/shaders/wgsl/draw_msaa_stencil.frag.hpp"
+// InterlockMode::depthStencil shaders.
+#include "generated/shaders/wgsl/draw_depthstencil_path.webgpu_vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_path.webgpu_noclipdistance_vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_path.webgpu_nossbo_vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_path.webgpu_nossbo_noclipdistance_vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_path.webgpu_frag.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_path.webgpu_fixedcolor_frag.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_atlas_blit.webgpu_vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_atlas_blit.webgpu_noclipdistance_vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_atlas_blit.webgpu_nossbo_vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_atlas_blit.webgpu_nossbo_noclipdistance_vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_atlas_blit.webgpu_frag.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_atlas_blit.webgpu_fixedcolor_frag.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_image_mesh.webgpu_vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_image_mesh.webgpu_noclipdistance_vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_image_mesh.webgpu_frag.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_image_mesh.webgpu_fixedcolor_frag.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_triangles_nocolor.vert.hpp"
+#include "generated/shaders/wgsl/draw_depthstencil_triangles_nocolor.frag.hpp"
 
 #ifdef RIVE_DAWN
 #include <dawn/webgpu_cpp.h>
@@ -296,7 +296,7 @@
             return true;
         case rive::gpu::InterlockMode::atomics:
         case rive::gpu::InterlockMode::clockwiseAtomic:
-        case rive::gpu::InterlockMode::msaa:
+        case rive::gpu::InterlockMode::depthStencil:
             return false;
     }
     RIVE_UNREACHABLE();
@@ -1342,19 +1342,19 @@
                         addDefine(GLSL_DRAW_IMAGE);
                         addDefine(GLSL_DRAW_IMAGE_MESH);
                         break;
-                    case DrawType::msaaStrokes:
-                    case DrawType::msaaMidpointFanBorrowedCoverage:
-                    case DrawType::msaaDynamicMidpointFans:
-                    case DrawType::msaaDynamicOuterCubics:
-                    case DrawType::msaaMidpointFans:
-                    case DrawType::msaaMidpointFanStencilReset:
-                    case DrawType::msaaMidpointFanPathsStencil:
-                    case DrawType::msaaMidpointFanPathsCover:
-                    case DrawType::msaaOuterCubicBorrowedCoverage:
-                    case DrawType::msaaOuterCubicStencilReset:
-                    case DrawType::msaaOuterCubicPathsStencil:
-                    case DrawType::msaaOuterCubicPathsCover:
-                    case DrawType::msaaOuterCubics:
+                    case DrawType::depthStrokes:
+                    case DrawType::stencilMidpointFanBorrowedCoverage:
+                    case DrawType::stencilDynamicMidpointFans:
+                    case DrawType::stencilDynamicOuterCubics:
+                    case DrawType::stencilMidpointFans:
+                    case DrawType::stencilMidpointFanReset:
+                    case DrawType::stencilMidpointFanWinding:
+                    case DrawType::stencilMidpointFanCover:
+                    case DrawType::stencilOuterCubicBorrowedCoverage:
+                    case DrawType::stencilOuterCubicReset:
+                    case DrawType::stencilOuterCubicWinding:
+                    case DrawType::stencilOuterCubicCover:
+                    case DrawType::stencilOuterCubics:
                     case DrawType::clipReset:
                     case DrawType::renderPassInitialize:
                     case DrawType::renderPassResolve:
@@ -1434,19 +1434,19 @@
                         glsl << gpu::glsl::draw_mesh_frag << '\n';
                         break;
                     case DrawType::imageRect:
-                    case DrawType::msaaStrokes:
-                    case DrawType::msaaMidpointFanBorrowedCoverage:
-                    case DrawType::msaaDynamicMidpointFans:
-                    case DrawType::msaaDynamicOuterCubics:
-                    case DrawType::msaaMidpointFans:
-                    case DrawType::msaaMidpointFanStencilReset:
-                    case DrawType::msaaMidpointFanPathsStencil:
-                    case DrawType::msaaMidpointFanPathsCover:
-                    case DrawType::msaaOuterCubicBorrowedCoverage:
-                    case DrawType::msaaOuterCubicStencilReset:
-                    case DrawType::msaaOuterCubicPathsStencil:
-                    case DrawType::msaaOuterCubicPathsCover:
-                    case DrawType::msaaOuterCubics:
+                    case DrawType::depthStrokes:
+                    case DrawType::stencilMidpointFanBorrowedCoverage:
+                    case DrawType::stencilDynamicMidpointFans:
+                    case DrawType::stencilDynamicOuterCubics:
+                    case DrawType::stencilMidpointFans:
+                    case DrawType::stencilMidpointFanReset:
+                    case DrawType::stencilMidpointFanWinding:
+                    case DrawType::stencilMidpointFanCover:
+                    case DrawType::stencilOuterCubicBorrowedCoverage:
+                    case DrawType::stencilOuterCubicReset:
+                    case DrawType::stencilOuterCubicWinding:
+                    case DrawType::stencilOuterCubicCover:
+                    case DrawType::stencilOuterCubics:
                     case DrawType::clipReset:
                     case DrawType::renderPassInitialize:
                     case DrawType::renderPassResolve:
@@ -1564,26 +1564,26 @@
                                 : &wgsl::atomic_init_webgpu_frag;
                         break;
 
-                    case DrawType::msaaStrokes:
-                    case DrawType::msaaMidpointFanBorrowedCoverage:
-                    case DrawType::msaaDynamicMidpointFans:
-                    case DrawType::msaaDynamicOuterCubics:
-                    case DrawType::msaaMidpointFans:
-                    case DrawType::msaaMidpointFanStencilReset:
-                    case DrawType::msaaMidpointFanPathsStencil:
-                    case DrawType::msaaMidpointFanPathsCover:
-                    case DrawType::msaaOuterCubicBorrowedCoverage:
-                    case DrawType::msaaOuterCubicStencilReset:
-                    case DrawType::msaaOuterCubicPathsStencil:
-                    case DrawType::msaaOuterCubicPathsCover:
-                    case DrawType::msaaOuterCubics:
+                    case DrawType::depthStrokes:
+                    case DrawType::stencilMidpointFanBorrowedCoverage:
+                    case DrawType::stencilDynamicMidpointFans:
+                    case DrawType::stencilDynamicOuterCubics:
+                    case DrawType::stencilMidpointFans:
+                    case DrawType::stencilMidpointFanReset:
+                    case DrawType::stencilMidpointFanWinding:
+                    case DrawType::stencilMidpointFanCover:
+                    case DrawType::stencilOuterCubicBorrowedCoverage:
+                    case DrawType::stencilOuterCubicReset:
+                    case DrawType::stencilOuterCubicWinding:
+                    case DrawType::stencilOuterCubicCover:
+                    case DrawType::stencilOuterCubics:
                     case DrawType::clipReset:
                         RIVE_UNREACHABLE();
                 }
                 break;
             }
 
-            case gpu::InterlockMode::msaa:
+            case gpu::InterlockMode::depthStencil:
             {
                 switch (drawType)
                 {
@@ -1592,19 +1592,19 @@
                     case DrawType::outerCurvePatches:
                         RIVE_UNREACHABLE();
 
-                    case DrawType::msaaOuterCubicBorrowedCoverage:
-                    case DrawType::msaaOuterCubicStencilReset:
-                    case DrawType::msaaOuterCubicPathsStencil:
-                    case DrawType::msaaOuterCubicPathsCover:
-                    case DrawType::msaaOuterCubics:
-                    case DrawType::msaaStrokes:
-                    case DrawType::msaaMidpointFanBorrowedCoverage:
-                    case DrawType::msaaDynamicMidpointFans:
-                    case DrawType::msaaDynamicOuterCubics:
-                    case DrawType::msaaMidpointFans:
-                    case DrawType::msaaMidpointFanStencilReset:
-                    case DrawType::msaaMidpointFanPathsStencil:
-                    case DrawType::msaaMidpointFanPathsCover:
+                    case DrawType::stencilOuterCubicBorrowedCoverage:
+                    case DrawType::stencilOuterCubicReset:
+                    case DrawType::stencilOuterCubicWinding:
+                    case DrawType::stencilOuterCubicCover:
+                    case DrawType::stencilOuterCubics:
+                    case DrawType::depthStrokes:
+                    case DrawType::stencilMidpointFanBorrowedCoverage:
+                    case DrawType::stencilDynamicMidpointFans:
+                    case DrawType::stencilDynamicOuterCubics:
+                    case DrawType::stencilMidpointFans:
+                    case DrawType::stencilMidpointFanReset:
+                    case DrawType::stencilMidpointFanWinding:
+                    case DrawType::stencilMidpointFanCover:
                         if (context->m_capabilities
                                 .polyfillVertexStorageBuffers)
                         {
@@ -1612,9 +1612,10 @@
                                 enums::is_flag_set(
                                     shaderFeatures,
                                     ShaderFeatures::ENABLE_CLIP_RECT)
-                                    ? &wgsl::draw_msaa_path_webgpu_nossbo_vert
+                                    ? &wgsl::
+                                          draw_depthstencil_path_webgpu_nossbo_vert
                                     : &wgsl::
-                                          draw_msaa_path_webgpu_nossbo_noclipdistance_vert;
+                                          draw_depthstencil_path_webgpu_nossbo_noclipdistance_vert;
                         }
                         else
                         {
@@ -1622,24 +1623,28 @@
                                 enums::is_flag_set(
                                     shaderFeatures,
                                     ShaderFeatures::ENABLE_CLIP_RECT)
-                                    ? &wgsl::draw_msaa_path_webgpu_vert
+                                    ? &wgsl::draw_depthstencil_path_webgpu_vert
                                     : &wgsl::
-                                          draw_msaa_path_webgpu_noclipdistance_vert;
+                                          draw_depthstencil_path_webgpu_noclipdistance_vert;
                         }
                         fragmentShader =
                             fixedFunctionColorOutput
-                                ? &wgsl::draw_msaa_path_webgpu_fixedcolor_frag
-                                : &wgsl::draw_msaa_path_webgpu_frag;
+                                ? &wgsl::
+                                      draw_depthstencil_path_webgpu_fixedcolor_frag
+                                : &wgsl::draw_depthstencil_path_webgpu_frag;
                         break;
 
                     case DrawType::clipReset:
-                        vertexShader = &wgsl::draw_msaa_stencil_vert;
-                        fragmentShader = &wgsl::draw_msaa_stencil_frag;
+                        vertexShader =
+                            &wgsl::draw_depthstencil_triangles_nocolor_vert;
+                        fragmentShader =
+                            &wgsl::draw_depthstencil_triangles_nocolor_frag;
                         break;
 
                     case DrawType::interiorTriangulation:
-                        // Interior triangulation is not yet implemented for
-                        // MSAA.
+                        // depthStencil interior triangles are smuggled in with
+                        // outerCubic patches instead of using the
+                        // interiorTriangulation draw type.
                         RIVE_UNREACHABLE();
                         break;
 
@@ -1652,9 +1657,9 @@
                                     shaderFeatures,
                                     ShaderFeatures::ENABLE_CLIP_RECT)
                                     ? &wgsl::
-                                          draw_msaa_atlas_blit_webgpu_nossbo_vert
+                                          draw_depthstencil_atlas_blit_webgpu_nossbo_vert
                                     : &wgsl::
-                                          draw_msaa_atlas_blit_webgpu_nossbo_noclipdistance_vert;
+                                          draw_depthstencil_atlas_blit_webgpu_nossbo_noclipdistance_vert;
                         }
                         else
                         {
@@ -1662,34 +1667,38 @@
                                 enums::is_flag_set(
                                     shaderFeatures,
                                     ShaderFeatures::ENABLE_CLIP_RECT)
-                                    ? &wgsl::draw_msaa_atlas_blit_webgpu_vert
+                                    ? &wgsl::
+                                          draw_depthstencil_atlas_blit_webgpu_vert
                                     : &wgsl::
-                                          draw_msaa_atlas_blit_webgpu_noclipdistance_vert;
+                                          draw_depthstencil_atlas_blit_webgpu_noclipdistance_vert;
                         }
                         fragmentShader =
                             fixedFunctionColorOutput
                                 ? &wgsl::
-                                      draw_msaa_atlas_blit_webgpu_fixedcolor_frag
-                                : &wgsl::draw_msaa_atlas_blit_webgpu_frag;
+                                      draw_depthstencil_atlas_blit_webgpu_fixedcolor_frag
+                                : &wgsl::
+                                      draw_depthstencil_atlas_blit_webgpu_frag;
                         break;
 
                     case DrawType::imageMesh:
                         vertexShader =
                             enums::is_flag_set(shaderFeatures,
                                                ShaderFeatures::ENABLE_CLIP_RECT)
-                                ? &wgsl::draw_msaa_image_mesh_webgpu_vert
+                                ? &wgsl::
+                                      draw_depthstencil_image_mesh_webgpu_vert
                                 : &wgsl::
-                                      draw_msaa_image_mesh_webgpu_noclipdistance_vert;
+                                      draw_depthstencil_image_mesh_webgpu_noclipdistance_vert;
                         fragmentShader =
                             fixedFunctionColorOutput
                                 ? &wgsl::
-                                      draw_msaa_image_mesh_webgpu_fixedcolor_frag
-                                : &wgsl::draw_msaa_image_mesh_webgpu_frag;
+                                      draw_depthstencil_image_mesh_webgpu_fixedcolor_frag
+                                : &wgsl::
+                                      draw_depthstencil_image_mesh_webgpu_frag;
                         break;
 
                     case DrawType::renderPassInitialize:
-                        // MSAA render passes get initialized by drawing the
-                        // previous contents into the framebuffer.
+                        // depthStencil render passes get initialized by drawing
+                        // the previous contents into the framebuffer.
                         // (LoadAction::preserveRenderTarget only.)
                         vertexShader =
                             &wgsl::blit_texture_as_draw_filtered_webgpu_vert;
@@ -3162,19 +3171,19 @@
         case DrawType::midpointFanPatches:
         case DrawType::midpointFanCenterAAPatches:
         case DrawType::outerCurvePatches:
-        case DrawType::msaaOuterCubicBorrowedCoverage:
-        case DrawType::msaaOuterCubicStencilReset:
-        case DrawType::msaaOuterCubicPathsStencil:
-        case DrawType::msaaOuterCubicPathsCover:
-        case DrawType::msaaOuterCubics:
-        case DrawType::msaaStrokes:
-        case DrawType::msaaMidpointFanBorrowedCoverage:
-        case DrawType::msaaDynamicMidpointFans:
-        case DrawType::msaaDynamicOuterCubics:
-        case DrawType::msaaMidpointFans:
-        case DrawType::msaaMidpointFanStencilReset:
-        case DrawType::msaaMidpointFanPathsStencil:
-        case DrawType::msaaMidpointFanPathsCover:
+        case DrawType::stencilOuterCubicBorrowedCoverage:
+        case DrawType::stencilOuterCubicReset:
+        case DrawType::stencilOuterCubicWinding:
+        case DrawType::stencilOuterCubicCover:
+        case DrawType::stencilOuterCubics:
+        case DrawType::depthStrokes:
+        case DrawType::stencilMidpointFanBorrowedCoverage:
+        case DrawType::stencilDynamicMidpointFans:
+        case DrawType::stencilDynamicOuterCubics:
+        case DrawType::stencilMidpointFans:
+        case DrawType::stencilMidpointFanReset:
+        case DrawType::stencilMidpointFanWinding:
+        case DrawType::stencilMidpointFanCover:
         {
             attrs.push_back({
                 .format = WGPUVertexFormat_Float32x4,
@@ -3525,7 +3534,7 @@
             },
         .multisample =
             {
-                .count = interlockMode == gpu::InterlockMode::msaa
+                .count = interlockMode == gpu::InterlockMode::depthStencil
                              ? MSAA_SAMPLE_COUNT
                              : 1u,
                 .mask = 0xffffffff,
@@ -3534,7 +3543,7 @@
     };
 
     WGPUDepthStencilState depthStencilState;
-    if (interlockMode == gpu::InterlockMode::msaa)
+    if (interlockMode == gpu::InterlockMode::depthStencil)
     {
         depthStencilState = {
             .format = WGPUTextureFormat_Depth24PlusStencil8,
@@ -3617,10 +3626,11 @@
         {
             // Work around an issue in atomic mode where some gms render just a
             // little outside of the draw bounds (causing the texture preserve
-            // to fail). Don't do this in MSAA mode because it fails to restore
-            // properly
-            // TODO: Figure out why this fails in MSAA and also implement the
-            // clipScissor functionality to get scissor working more completely
+            // to fail). Don't do this in depthStencil mode because it
+            // fails to restore properly.
+            // TODO: Figure out why this fails in depthStencil and also
+            // implement the clipScissor functionality to get scissor working
+            // more completely
             m_encoder.SetScissorRect(m_desc.renderTargetUpdateBounds.left,
                                      m_desc.renderTargetUpdateBounds.top,
                                      m_desc.renderTargetUpdateBounds.width(),
@@ -3928,16 +3938,17 @@
     wgpu::BindGroup m_plsBindings;
 };
 
-// A Rive render pass that uses MSAA. It's restarted once per dstBlend barrier
-// (and may defer its initial begin until the first such barrier); the
-// attachment texture views don't change between restarts, so they're cached
-// once in the constructor and reused.
-class RenderContextWebGPUImpl::MSAADrawRenderPass : public DrawRenderPass
+// A Rive render pass that renders paths with the depth/stencil buffer. It's
+// restarted once per dstBlend barrier (and may defer its initial begin until
+// the first such barrier); the attachment texture views don't change between
+// restarts, so they're cached once in the constructor and reused.
+class RenderContextWebGPUImpl::DepthStencilDrawRenderPass
+    : public DrawRenderPass
 {
 public:
-    MSAADrawRenderPass(RenderContextWebGPUImpl* impl,
-                       const FlushDescriptor& desc,
-                       wgpu::CommandEncoder commandEncoder) :
+    DepthStencilDrawRenderPass(RenderContextWebGPUImpl* impl,
+                               const FlushDescriptor& desc,
+                               wgpu::CommandEncoder commandEncoder) :
         DrawRenderPass(impl, desc, commandEncoder),
         m_msaaColorTextureView(m_renderTarget->msaaColorTextureView()),
         m_targetTextureView(m_renderTarget->targetTextureView()),
@@ -3950,10 +3961,10 @@
         if (m_desc.drawList->empty() || m_desc.drawList->head()->drawType !=
                                             gpu::DrawType::renderPassInitialize)
         {
-            begin(MSAABeginType::primary,
+            begin(DepthStencilBeginType::primary,
                   (m_desc.firstDstBlendBarrier != nullptr)
-                      ? MSAAEndType::breakForDstCopy
-                      : MSAAEndType::finish);
+                      ? DepthStencilEndType::breakForDstCopy
+                      : DepthStencilEndType::finish);
         }
     }
 
@@ -3968,7 +3979,7 @@
         assert(!m_desc.fixedFunctionColorOutput ||
                batch.drawType == gpu::DrawType::renderPassInitialize);
 
-        MSAABeginType msaaBeginType;
+        DepthStencilBeginType beginType;
         if (batch.drawType == gpu::DrawType::renderPassInitialize)
         {
             assert(m_encoder == nullptr);
@@ -3982,7 +3993,7 @@
                 m_commandEncoder,
                 m_renderTarget->bounds());
 
-            msaaBeginType = MSAABeginType::primary;
+            beginType = DepthStencilBeginType::primary;
         }
         else
         {
@@ -4001,26 +4012,26 @@
                         draw->pixelBounds()));
             }
 
-            msaaBeginType = MSAABeginType::restartAfterDstCopy;
+            beginType = DepthStencilBeginType::restartAfterDstCopy;
         }
 
         // Restart the render pass after the copies are finished.
-        begin(msaaBeginType,
+        begin(beginType,
               (batch.nextDstBlendBarrier != nullptr)
-                  ? MSAAEndType::breakForDstCopy
-                  : MSAAEndType::finish);
+                  ? DepthStencilEndType::breakForDstCopy
+                  : DepthStencilEndType::finish);
     }
 
 private:
     // Specifies how to load MSAA color/depth/stencil attachments when beginning
     // an MSAA render pass.
-    enum class MSAABeginType : bool
+    enum class DepthStencilBeginType : bool
     {
         primary,
         restartAfterDstCopy,
     };
 
-    void begin(MSAABeginType msaaBeginType, MSAAEndType msaaEndType)
+    void begin(DepthStencilBeginType beginType, DepthStencilEndType endType)
     {
         // Our MSAA buffers are treated as completely transient (i.e.,
         // Clear/Discard) unless we have to do render pass breaks for dst
@@ -4030,12 +4041,13 @@
         // TODO: wgpu::LoadOp::ExpandResolveTexture for the color buffer when
         // supported.
         const auto msaaLoadOp =
-            msaaBeginType == MSAABeginType::restartAfterDstCopy
+            beginType == DepthStencilBeginType::restartAfterDstCopy
                 ? wgpu::LoadOp::Load
                 : wgpu::LoadOp::Clear;
-        const auto msaaStoreOp = (msaaEndType == MSAAEndType::breakForDstCopy)
-                                     ? wgpu::StoreOp::Store
-                                     : wgpu::StoreOp::Discard;
+        const auto msaaStoreOp =
+            (endType == DepthStencilEndType::breakForDstCopy)
+                ? wgpu::StoreOp::Store
+                : wgpu::StoreOp::Discard;
 
         wgpu::RenderPassColorAttachment msaaColorAttachment = {
             .view = m_msaaColorTextureView,
@@ -4058,7 +4070,7 @@
         };
 
         wgpu::RenderPassDescriptor renderPassDescriptor = {
-            .label = "RIVE_MSAA_RenderPass",
+            .label = "RIVE_DepthStencil_RenderPass",
             .colorAttachmentCount = 1,
             .colorAttachments = &msaaColorAttachment,
             .depthStencilAttachment = &msaaDepthStencilAttachment,
@@ -4083,9 +4095,11 @@
                                                       desc,
                                                       commandEncoder);
     }
-    if (desc.interlockMode == gpu::InterlockMode::msaa)
+    if (desc.interlockMode == gpu::InterlockMode::depthStencil)
     {
-        return std::make_unique<MSAADrawRenderPass>(this, desc, commandEncoder);
+        return std::make_unique<DepthStencilDrawRenderPass>(this,
+                                                            desc,
+                                                            commandEncoder);
     }
     return std::make_unique<PLSDrawRenderPass>(this, desc, commandEncoder);
 }
@@ -4230,7 +4244,7 @@
         },
         {
             .binding = DST_COLOR_TEXTURE_IDX,
-            .textureView = desc.interlockMode == gpu::InterlockMode::msaa &&
+            .textureView = desc.interlockMode == gpu::InterlockMode::depthStencil &&
                            !desc.fixedFunctionColorOutput
                                ? renderTarget->dstColorTextureView()
                                : m_nullTextureView,
@@ -4532,9 +4546,10 @@
     wgpu::BindGroup perFlushBindings =
         m_device.CreateBindGroup(&perFlushBindGroupDesc);
 
-    // The drawEncoder isn't necessarily created yet. (e.g., MSAA sometimes
-    // defers creation of the drawEncoder until the first barrier.) So defer
-    // binding the per-flush uniforms until we know the drawEncoder is valid.
+    // The drawEncoder isn't necessarily created yet. (e.g., depthStencil
+    // sometimes defers creation of the drawEncoder until the first barrier.) So
+    // defer binding the per-flush uniforms until we know the drawEncoder is
+    // valid.
     bool needsPerFlushBindings = true;
 
     wgpu::TextureView boundImageTextureView = {};
@@ -4586,11 +4601,12 @@
                 // be sampled here to seed the color buffer. No dst copy needed.
                 imageTextureView = renderTarget->targetTextureView();
             }
-            else if (desc.interlockMode == gpu::InterlockMode::msaa)
+            else if (desc.interlockMode == gpu::InterlockMode::depthStencil)
             {
-                // MSAA can't sample the target texture here because it's bound
-                // as the resolve target, so it seeds from the dstColorTexture
-                // (copied from the framebuffer previously) instead.
+                // depthStencil can't sample the target texture here because
+                // it's bound as the resolve target, so it seeds from the
+                // dstColorTexture (copied from the framebuffer previously)
+                // instead.
                 imageTextureView = renderTarget->dstColorTextureView();
             }
         }
@@ -4739,19 +4755,19 @@
             case DrawType::midpointFanPatches:
             case DrawType::midpointFanCenterAAPatches:
             case DrawType::outerCurvePatches:
-            case DrawType::msaaOuterCubicBorrowedCoverage:
-            case DrawType::msaaOuterCubicStencilReset:
-            case DrawType::msaaOuterCubicPathsStencil:
-            case DrawType::msaaOuterCubicPathsCover:
-            case DrawType::msaaOuterCubics:
-            case DrawType::msaaStrokes:
-            case DrawType::msaaMidpointFanBorrowedCoverage:
-            case DrawType::msaaDynamicMidpointFans:
-            case DrawType::msaaDynamicOuterCubics:
-            case DrawType::msaaMidpointFans:
-            case DrawType::msaaMidpointFanStencilReset:
-            case DrawType::msaaMidpointFanPathsStencil:
-            case DrawType::msaaMidpointFanPathsCover:
+            case DrawType::stencilOuterCubicBorrowedCoverage:
+            case DrawType::stencilOuterCubicReset:
+            case DrawType::stencilOuterCubicWinding:
+            case DrawType::stencilOuterCubicCover:
+            case DrawType::stencilOuterCubics:
+            case DrawType::depthStrokes:
+            case DrawType::stencilMidpointFanBorrowedCoverage:
+            case DrawType::stencilDynamicMidpointFans:
+            case DrawType::stencilDynamicOuterCubics:
+            case DrawType::stencilMidpointFans:
+            case DrawType::stencilMidpointFanReset:
+            case DrawType::stencilMidpointFanWinding:
+            case DrawType::stencilMidpointFanCover:
             {
                 // Draw PLS patches that connect the tessellation vertices.
                 drawEncoder.SetVertexBuffer(0, m_pathPatchVertexBuffer);
diff --git a/tests/gm/retrofitcubictristrips.cpp b/tests/gm/retrofitcubictristrips.cpp
index 04bf19e..8426ec8 100644
--- a/tests/gm/retrofitcubictristrips.cpp
+++ b/tests/gm/retrofitcubictristrips.cpp
@@ -87,7 +87,7 @@
         m_resourceCounts.contourCount = 1;
         m_resourceCounts.maxTessellatedSegmentCount = std::size(TriangleStrips);
         m_resourceCounts.outerCubicTessVertexCount =
-            context->frameInterlockMode() != gpu::InterlockMode::msaa
+            context->frameInterlockMode() != gpu::InterlockMode::depthStencil
                 ? gpu::OuterCubicPatchSegmentSpanPlusJoin *
                       std::size(TriangleStrips) * 2
                 : gpu::OuterCubicPatchSegmentSpanPlusJoin *
@@ -178,8 +178,8 @@
 
             return &flush->pushOuterCubicsDraw(
                 this,
-                m_coverageType == CoverageType::msaa
-                    ? gpu::DrawType::msaaOuterCubics
+                m_coverageType == CoverageType::depthStencil
+                    ? gpu::DrawType::stencilOuterCubics
                     : gpu::DrawType::outerCurvePatches,
                 tessVertexCount,
                 tessLocation,
diff --git a/tests/unit_tests/renderer/gpu_namespace_test.cpp b/tests/unit_tests/renderer/gpu_namespace_test.cpp
index f075d66..33311e5 100644
--- a/tests/unit_tests/renderer/gpu_namespace_test.cpp
+++ b/tests/unit_tests/renderer/gpu_namespace_test.cpp
@@ -167,7 +167,7 @@
         platformFeatures.supportsPipelineDynamicState =
             supportsPipelineDynamicState;
         std::set<gpu::DrawType> drawTypes;
-        gpu::ForEachUbershaderPermutation(gpu::InterlockMode::msaa,
+        gpu::ForEachUbershaderPermutation(gpu::InterlockMode::depthStencil,
                                           platformFeatures,
                                           [&drawTypes](gpu::DrawType drawType,
                                                        gpu::ShaderFeatures,
@@ -179,22 +179,24 @@
     };
 
     const std::set<gpu::DrawType> withDynamicState = enumerateDrawTypes(true);
-    CHECK(withDynamicState.count(gpu::DrawType::msaaDynamicMidpointFans) == 1);
-    CHECK(withDynamicState.count(gpu::DrawType::msaaDynamicOuterCubics) == 1);
+    CHECK(withDynamicState.count(gpu::DrawType::stencilDynamicMidpointFans) ==
+          1);
+    CHECK(withDynamicState.count(gpu::DrawType::stencilDynamicOuterCubics) ==
+          1);
 
     // Backends that can't switch depth/stencil/cull/color-write without
     // rebinding a pipeline never bind these, so they don't precompile them.
     const std::set<gpu::DrawType> withoutDynamicState =
         enumerateDrawTypes(false);
-    CHECK(withoutDynamicState.count(gpu::DrawType::msaaDynamicMidpointFans) ==
-          0);
-    CHECK(withoutDynamicState.count(gpu::DrawType::msaaDynamicOuterCubics) ==
+    CHECK(withoutDynamicState.count(
+              gpu::DrawType::stencilDynamicMidpointFans) == 0);
+    CHECK(withoutDynamicState.count(gpu::DrawType::stencilDynamicOuterCubics) ==
           0);
 
     // The passes they collapse are enumerated either way.
-    for (auto drawType : {gpu::DrawType::msaaMidpointFanBorrowedCoverage,
-                          gpu::DrawType::msaaMidpointFans,
-                          gpu::DrawType::msaaMidpointFanStencilReset})
+    for (auto drawType : {gpu::DrawType::stencilMidpointFanBorrowedCoverage,
+                          gpu::DrawType::stencilMidpointFans,
+                          gpu::DrawType::stencilMidpointFanReset})
     {
         CHECK(withDynamicState.count(drawType) == 1);
         CHECK(withoutDynamicState.count(drawType) == 1);