diff --git a/impeller/entity/contents/content_context.h b/impeller/entity/contents/content_context.h
index ecebcccf3bc77..bd4dfb7ad3d47 100644
--- a/impeller/entity/contents/content_context.h
+++ b/impeller/entity/contents/content_context.h
@@ -96,149 +96,165 @@ namespace impeller {
 
 #ifdef IMPELLER_DEBUG
 using CheckerboardPipeline =
-    RenderPipelineT<CheckerboardVertexShader, CheckerboardFragmentShader>;
+    RenderPipelineHandle<CheckerboardVertexShader, CheckerboardFragmentShader>;
 #endif  // IMPELLER_DEBUG
 
 using LinearGradientFillPipeline =
-    RenderPipelineT<GradientFillVertexShader, LinearGradientFillFragmentShader>;
+    RenderPipelineHandle<GradientFillVertexShader,
+                         LinearGradientFillFragmentShader>;
 using SolidFillPipeline =
-    RenderPipelineT<SolidFillVertexShader, SolidFillFragmentShader>;
+    RenderPipelineHandle<SolidFillVertexShader, SolidFillFragmentShader>;
 using RadialGradientFillPipeline =
-    RenderPipelineT<GradientFillVertexShader, RadialGradientFillFragmentShader>;
+    RenderPipelineHandle<GradientFillVertexShader,
+                         RadialGradientFillFragmentShader>;
 using ConicalGradientFillPipeline =
-    RenderPipelineT<GradientFillVertexShader,
-                    ConicalGradientFillFragmentShader>;
+    RenderPipelineHandle<GradientFillVertexShader,
+                         ConicalGradientFillFragmentShader>;
 using SweepGradientFillPipeline =
-    RenderPipelineT<GradientFillVertexShader, SweepGradientFillFragmentShader>;
+    RenderPipelineHandle<GradientFillVertexShader,
+                         SweepGradientFillFragmentShader>;
 using LinearGradientSSBOFillPipeline =
-    RenderPipelineT<GradientFillVertexShader,
-                    LinearGradientSsboFillFragmentShader>;
+    RenderPipelineHandle<GradientFillVertexShader,
+                         LinearGradientSsboFillFragmentShader>;
 using ConicalGradientSSBOFillPipeline =
-    RenderPipelineT<GradientFillVertexShader,
-                    ConicalGradientSsboFillFragmentShader>;
+    RenderPipelineHandle<GradientFillVertexShader,
+                         ConicalGradientSsboFillFragmentShader>;
 using RadialGradientSSBOFillPipeline =
-    RenderPipelineT<GradientFillVertexShader,
-                    RadialGradientSsboFillFragmentShader>;
+    RenderPipelineHandle<GradientFillVertexShader,
+                         RadialGradientSsboFillFragmentShader>;
 using SweepGradientSSBOFillPipeline =
-    RenderPipelineT<GradientFillVertexShader,
-                    SweepGradientSsboFillFragmentShader>;
+    RenderPipelineHandle<GradientFillVertexShader,
+                         SweepGradientSsboFillFragmentShader>;
 using RRectBlurPipeline =
-    RenderPipelineT<RrectBlurVertexShader, RrectBlurFragmentShader>;
-using BlendPipeline = RenderPipelineT<BlendVertexShader, BlendFragmentShader>;
+    RenderPipelineHandle<RrectBlurVertexShader, RrectBlurFragmentShader>;
+using BlendPipeline =
+    RenderPipelineHandle<BlendVertexShader, BlendFragmentShader>;
 using TexturePipeline =
-    RenderPipelineT<TextureFillVertexShader, TextureFillFragmentShader>;
+    RenderPipelineHandle<TextureFillVertexShader, TextureFillFragmentShader>;
 using TextureStrictSrcPipeline =
-    RenderPipelineT<TextureFillVertexShader,
-                    TextureFillStrictSrcFragmentShader>;
-using PositionUVPipeline =
-    RenderPipelineT<TextureFillVertexShader, TiledTextureFillFragmentShader>;
+    RenderPipelineHandle<TextureFillVertexShader,
+                         TextureFillStrictSrcFragmentShader>;
+using PositionUVPipeline = RenderPipelineHandle<TextureFillVertexShader,
+                                                TiledTextureFillFragmentShader>;
 using TiledTexturePipeline =
-    RenderPipelineT<TextureFillVertexShader, TiledTextureFillFragmentShader>;
+    RenderPipelineHandle<TextureFillVertexShader,
+                         TiledTextureFillFragmentShader>;
 using KernelDecalPipeline =
-    RenderPipelineT<KernelVertexShader, KernelDecalFragmentShader>;
+    RenderPipelineHandle<KernelVertexShader, KernelDecalFragmentShader>;
 using KernelPipeline =
-    RenderPipelineT<KernelVertexShader, KernelNodecalFragmentShader>;
+    RenderPipelineHandle<KernelVertexShader, KernelNodecalFragmentShader>;
 using BorderMaskBlurPipeline =
-    RenderPipelineT<BorderMaskBlurVertexShader, BorderMaskBlurFragmentShader>;
+    RenderPipelineHandle<BorderMaskBlurVertexShader,
+                         BorderMaskBlurFragmentShader>;
 using MorphologyFilterPipeline =
-    RenderPipelineT<MorphologyFilterVertexShader,
-                    MorphologyFilterFragmentShader>;
+    RenderPipelineHandle<MorphologyFilterVertexShader,
+                         MorphologyFilterFragmentShader>;
 using ColorMatrixColorFilterPipeline =
-    RenderPipelineT<FilterVertexShader, ColorMatrixColorFilterFragmentShader>;
+    RenderPipelineHandle<FilterVertexShader,
+                         ColorMatrixColorFilterFragmentShader>;
 using LinearToSrgbFilterPipeline =
-    RenderPipelineT<FilterVertexShader, LinearToSrgbFilterFragmentShader>;
+    RenderPipelineHandle<FilterVertexShader, LinearToSrgbFilterFragmentShader>;
 using SrgbToLinearFilterPipeline =
-    RenderPipelineT<FilterVertexShader, SrgbToLinearFilterFragmentShader>;
+    RenderPipelineHandle<FilterVertexShader, SrgbToLinearFilterFragmentShader>;
 using GlyphAtlasPipeline =
-    RenderPipelineT<GlyphAtlasVertexShader, GlyphAtlasFragmentShader>;
+    RenderPipelineHandle<GlyphAtlasVertexShader, GlyphAtlasFragmentShader>;
 using GlyphAtlasColorPipeline =
-    RenderPipelineT<GlyphAtlasVertexShader, GlyphAtlasColorFragmentShader>;
+    RenderPipelineHandle<GlyphAtlasVertexShader, GlyphAtlasColorFragmentShader>;
 using PorterDuffBlendPipeline =
-    RenderPipelineT<PorterDuffBlendVertexShader, PorterDuffBlendFragmentShader>;
-using ClipPipeline = RenderPipelineT<ClipVertexShader, ClipFragmentShader>;
+    RenderPipelineHandle<PorterDuffBlendVertexShader,
+                         PorterDuffBlendFragmentShader>;
+using ClipPipeline = RenderPipelineHandle<ClipVertexShader, ClipFragmentShader>;
 
 using GeometryColorPipeline =
-    RenderPipelineT<PositionColorVertexShader, VerticesFragmentShader>;
+    RenderPipelineHandle<PositionColorVertexShader, VerticesFragmentShader>;
 using YUVToRGBFilterPipeline =
-    RenderPipelineT<FilterVertexShader, YuvToRgbFilterFragmentShader>;
+    RenderPipelineHandle<FilterVertexShader, YuvToRgbFilterFragmentShader>;
 
 // Advanced blends
-using BlendColorPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
+using BlendColorPipeline = RenderPipelineHandle<AdvancedBlendVertexShader,
+                                                AdvancedBlendFragmentShader>;
 using BlendColorBurnPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
+    RenderPipelineHandle<AdvancedBlendVertexShader,
+                         AdvancedBlendFragmentShader>;
 using BlendColorDodgePipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
-using BlendDarkenPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
+    RenderPipelineHandle<AdvancedBlendVertexShader,
+                         AdvancedBlendFragmentShader>;
+using BlendDarkenPipeline = RenderPipelineHandle<AdvancedBlendVertexShader,
+                                                 AdvancedBlendFragmentShader>;
 using BlendDifferencePipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
+    RenderPipelineHandle<AdvancedBlendVertexShader,
+                         AdvancedBlendFragmentShader>;
 using BlendExclusionPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
+    RenderPipelineHandle<AdvancedBlendVertexShader,
+                         AdvancedBlendFragmentShader>;
 using BlendHardLightPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
-using BlendHuePipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
-using BlendLightenPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
+    RenderPipelineHandle<AdvancedBlendVertexShader,
+                         AdvancedBlendFragmentShader>;
+using BlendHuePipeline = RenderPipelineHandle<AdvancedBlendVertexShader,
+                                              AdvancedBlendFragmentShader>;
+using BlendLightenPipeline = RenderPipelineHandle<AdvancedBlendVertexShader,
+                                                  AdvancedBlendFragmentShader>;
 using BlendLuminosityPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
-using BlendMultiplyPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
-using BlendOverlayPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
+    RenderPipelineHandle<AdvancedBlendVertexShader,
+                         AdvancedBlendFragmentShader>;
+using BlendMultiplyPipeline = RenderPipelineHandle<AdvancedBlendVertexShader,
+                                                   AdvancedBlendFragmentShader>;
+using BlendOverlayPipeline = RenderPipelineHandle<AdvancedBlendVertexShader,
+                                                  AdvancedBlendFragmentShader>;
 using BlendSaturationPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
-using BlendScreenPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
+    RenderPipelineHandle<AdvancedBlendVertexShader,
+                         AdvancedBlendFragmentShader>;
+using BlendScreenPipeline = RenderPipelineHandle<AdvancedBlendVertexShader,
+                                                 AdvancedBlendFragmentShader>;
 using BlendSoftLightPipeline =
-    RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>;
+    RenderPipelineHandle<AdvancedBlendVertexShader,
+                         AdvancedBlendFragmentShader>;
 // Framebuffer Advanced Blends
 using FramebufferBlendColorPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendColorBurnPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendColorDodgePipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendDarkenPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendDifferencePipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendExclusionPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendHardLightPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendHuePipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendLightenPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendLuminosityPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendMultiplyPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendOverlayPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendSaturationPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendScreenPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 using FramebufferBlendSoftLightPipeline =
-    RenderPipelineT<FramebufferBlendVertexShader,
-                    FramebufferBlendFragmentShader>;
+    RenderPipelineHandle<FramebufferBlendVertexShader,
+                         FramebufferBlendFragmentShader>;
 
 /// Geometry Pipelines
 using PointsComputeShaderPipeline = ComputePipelineBuilder<PointsComputeShader>;
@@ -246,11 +262,12 @@ using UvComputeShaderPipeline = ComputePipelineBuilder<UvComputeShader>;
 
 #ifdef IMPELLER_ENABLE_OPENGLES
 using TextureExternalPipeline =
-    RenderPipelineT<TextureFillVertexShader, TextureFillExternalFragmentShader>;
+    RenderPipelineHandle<TextureFillVertexShader,
+                         TextureFillExternalFragmentShader>;
 
 using TiledTextureExternalPipeline =
-    RenderPipelineT<TextureFillVertexShader,
-                    TiledTextureFillExternalFragmentShader>;
+    RenderPipelineHandle<TextureFillVertexShader,
+                         TiledTextureFillExternalFragmentShader>;
 #endif  // IMPELLER_ENABLE_OPENGLES
 
 // A struct used to isolate command buffer storage from the content
@@ -836,18 +853,31 @@ class ContentContext {
                              RuntimeEffectPipelineKey::Equal>
       runtime_effect_pipelines_;
 
-  template <class PipelineT>
+  /// Holds multiple Pipelines associated with the same PipelineHandle types.
+  ///
+  /// For example, it may have multiple
+  /// RenderPipelineHandle<SolidFillVertexShader, SolidFillFragmentShader>
+  /// instances for different blend modes. From them you can access the
+  /// Pipeline.
+  ///
+  /// See also:
+  ///  - impeller::ContentContextOptions - options from which variants are
+  ///    created.
+  ///  - impeller::Pipeline::CreateVariant
+  ///  - impeller::RenderPipelineHandle<> - The type of objects this typically
+  ///    contains.
+  template <class PipelineHandleT>
   class Variants {
    public:
     Variants() = default;
 
     void Set(const ContentContextOptions& options,
-             std::unique_ptr<PipelineT> pipeline) {
+             std::unique_ptr<PipelineHandleT> pipeline) {
       pipelines_[options] = std::move(pipeline);
     }
 
     void SetDefault(const ContentContextOptions& options,
-                    std::unique_ptr<PipelineT> pipeline) {
+                    std::unique_ptr<PipelineHandleT> pipeline) {
       default_options_ = options;
       Set(options, std::move(pipeline));
     }
@@ -855,24 +885,24 @@ class ContentContext {
     void CreateDefault(const Context& context,
                        const ContentContextOptions& options,
                        const std::initializer_list<Scalar>& constants = {}) {
-      auto desc =
-          PipelineT::Builder::MakeDefaultPipelineDescriptor(context, constants);
+      auto desc = PipelineHandleT::Builder::MakeDefaultPipelineDescriptor(
+          context, constants);
       if (!desc.has_value()) {
         VALIDATION_LOG << "Failed to create default pipeline.";
         return;
       }
       options.ApplyToPipelineDescriptor(*desc);
-      SetDefault(options, std::make_unique<PipelineT>(context, desc));
+      SetDefault(options, std::make_unique<PipelineHandleT>(context, desc));
     }
 
-    PipelineT* Get(const ContentContextOptions& options) const {
+    PipelineHandleT* Get(const ContentContextOptions& options) const {
       if (auto found = pipelines_.find(options); found != pipelines_.end()) {
         return found->second.get();
       }
       return nullptr;
     }
 
-    PipelineT* GetDefault() const {
+    PipelineHandleT* GetDefault() const {
       if (!default_options_.has_value()) {
         return nullptr;
       }
@@ -884,7 +914,7 @@ class ContentContext {
    private:
     std::optional<ContentContextOptions> default_options_;
     std::unordered_map<ContentContextOptions,
-                       std::unique_ptr<PipelineT>,
+                       std::unique_ptr<PipelineHandleT>,
                        ContentContextOptions::Hash,
                        ContentContextOptions::Equal>
         pipelines_;
@@ -1004,9 +1034,10 @@ class ContentContext {
     return pipeline->WaitAndGet();
   }
 
-  template <class TypedPipeline>
-  TypedPipeline* CreateIfNeeded(Variants<TypedPipeline>& container,
-                                ContentContextOptions opts) const {
+  template <class RenderPipelineHandleT>
+  RenderPipelineHandleT* CreateIfNeeded(
+      Variants<RenderPipelineHandleT>& container,
+      ContentContextOptions opts) const {
     if (!IsValid()) {
       return nullptr;
     }
@@ -1015,17 +1046,17 @@ class ContentContext {
       opts.wireframe = true;
     }
 
-    if (TypedPipeline* found = container.Get(opts)) {
+    if (RenderPipelineHandleT* found = container.Get(opts)) {
       return found;
     }
 
-    TypedPipeline* prototype = container.GetDefault();
+    RenderPipelineHandleT* default_handle = container.GetDefault();
 
-    // The prototype must always be initialized in the constructor.
-    FML_CHECK(prototype != nullptr);
+    // The default must always be initialized in the constructor.
+    FML_CHECK(default_handle != nullptr);
 
     std::shared_ptr<Pipeline<PipelineDescriptor>> pipeline =
-        prototype->WaitAndGet();
+        default_handle->WaitAndGet();
     if (!pipeline) {
       return nullptr;
     }
@@ -1037,8 +1068,8 @@ class ContentContext {
           desc.SetLabel(
               SPrintF("%s V#%zu", desc.GetLabel().c_str(), variants_count));
         });
-    std::unique_ptr<TypedPipeline> variant =
-        std::make_unique<TypedPipeline>(std::move(variant_future));
+    std::unique_ptr<RenderPipelineHandleT> variant =
+        std::make_unique<RenderPipelineHandleT>(std::move(variant_future));
     container.Set(opts, std::move(variant));
     return container.Get(opts);
   }
diff --git a/impeller/renderer/pipeline.h b/impeller/renderer/pipeline.h
index 7bed0902d2b48..c6b407467c67a 100644
--- a/impeller/renderer/pipeline.h
+++ b/impeller/renderer/pipeline.h
@@ -88,8 +88,14 @@ PipelineFuture<ComputePipelineDescriptor> CreatePipelineFuture(
     const Context& context,
     std::optional<ComputePipelineDescriptor> desc);
 
+/// Holds a reference to a Pipeline used for rendering while also maintaining
+/// the vertex shader and fragment shader types at compile-time.
+///
+/// See also:
+///   - impeller::ContentContext::Variants - the typical container for
+///     RenderPipelineHandles.
 template <class VertexShader_, class FragmentShader_>
-class RenderPipelineT {
+class RenderPipelineHandle {
   static_assert(
       ShaderStageCompatibilityChecker<VertexShader_, FragmentShader_>::Check(),
       "The output slots for the fragment shader don't have matches in the "
@@ -100,16 +106,16 @@ class RenderPipelineT {
   using FragmentShader = FragmentShader_;
   using Builder = PipelineBuilder<VertexShader, FragmentShader>;
 
-  explicit RenderPipelineT(const Context& context)
-      : RenderPipelineT(CreatePipelineFuture(
+  explicit RenderPipelineHandle(const Context& context)
+      : RenderPipelineHandle(CreatePipelineFuture(
             context,
             Builder::MakeDefaultPipelineDescriptor(context))) {}
 
-  explicit RenderPipelineT(const Context& context,
-                           std::optional<PipelineDescriptor> desc)
-      : RenderPipelineT(CreatePipelineFuture(context, desc)) {}
+  explicit RenderPipelineHandle(const Context& context,
+                                std::optional<PipelineDescriptor> desc)
+      : RenderPipelineHandle(CreatePipelineFuture(context, desc)) {}
 
-  explicit RenderPipelineT(PipelineFuture<PipelineDescriptor> future)
+  explicit RenderPipelineHandle(PipelineFuture<PipelineDescriptor> future)
       : pipeline_future_(std::move(future)) {}
 
   std::shared_ptr<Pipeline<PipelineDescriptor>> WaitAndGet() {
@@ -132,28 +138,29 @@ class RenderPipelineT {
   std::shared_ptr<Pipeline<PipelineDescriptor>> pipeline_;
   bool did_wait_ = false;
 
-  RenderPipelineT(const RenderPipelineT&) = delete;
+  RenderPipelineHandle(const RenderPipelineHandle&) = delete;
 
-  RenderPipelineT& operator=(const RenderPipelineT&) = delete;
+  RenderPipelineHandle& operator=(const RenderPipelineHandle&) = delete;
 };
 
 template <class ComputeShader_>
-class ComputePipelineT {
+class ComputePipelineHandle {
  public:
   using ComputeShader = ComputeShader_;
   using Builder = ComputePipelineBuilder<ComputeShader>;
 
-  explicit ComputePipelineT(const Context& context)
-      : ComputePipelineT(CreatePipelineFuture(
+  explicit ComputePipelineHandle(const Context& context)
+      : ComputePipelineHandle(CreatePipelineFuture(
             context,
             Builder::MakeDefaultPipelineDescriptor(context))) {}
 
-  explicit ComputePipelineT(
+  explicit ComputePipelineHandle(
       const Context& context,
       std::optional<ComputePipelineDescriptor> compute_desc)
-      : ComputePipelineT(CreatePipelineFuture(context, compute_desc)) {}
+      : ComputePipelineHandle(CreatePipelineFuture(context, compute_desc)) {}
 
-  explicit ComputePipelineT(PipelineFuture<ComputePipelineDescriptor> future)
+  explicit ComputePipelineHandle(
+      PipelineFuture<ComputePipelineDescriptor> future)
       : pipeline_future_(std::move(future)) {}
 
   std::shared_ptr<Pipeline<ComputePipelineDescriptor>> WaitAndGet() {
@@ -172,9 +179,9 @@ class ComputePipelineT {
   std::shared_ptr<Pipeline<ComputePipelineDescriptor>> pipeline_;
   bool did_wait_ = false;
 
-  ComputePipelineT(const ComputePipelineT&) = delete;
+  ComputePipelineHandle(const ComputePipelineHandle&) = delete;
 
-  ComputePipelineT& operator=(const ComputePipelineT&) = delete;
+  ComputePipelineHandle& operator=(const ComputePipelineHandle&) = delete;
 };
 
 }  // namespace impeller
diff --git a/impeller/scene/scene_context.h b/impeller/scene/scene_context.h
index 4c99e99867213..48ff7b8ec9458 100644
--- a/impeller/scene/scene_context.h
+++ b/impeller/scene/scene_context.h
@@ -125,13 +125,13 @@ class SceneContext {
   /// If a pipeline could not be created, returns nullptr.
   std::unique_ptr<PipelineVariants> MakePipelineVariants(Context& context) {
     auto pipeline =
-        PipelineVariantsT<RenderPipelineT<VertexShader, FragmentShader>>(
+        PipelineVariantsT<RenderPipelineHandle<VertexShader, FragmentShader>>(
             context);
     if (!pipeline.IsValid()) {
       return nullptr;
     }
     return std::make_unique<
-        PipelineVariantsT<RenderPipelineT<VertexShader, FragmentShader>>>(
+        PipelineVariantsT<RenderPipelineHandle<VertexShader, FragmentShader>>>(
         std::move(pipeline));
   }