diff --git a/impeller/aiks/canvas.cc b/impeller/aiks/canvas.cc
index 6ba4d87..59d4c0d 100644
--- a/impeller/aiks/canvas.cc
+++ b/impeller/aiks/canvas.cc
@@ -21,6 +21,23 @@
 
 namespace impeller {
 
+static bool UseColorSourceContents(
+    const std::shared_ptr<VerticesGeometry>& vertices,
+    const Paint::ColorSourceType& type) {
+  // If there are no vertex color or texture coordinates. Or if there
+  // are vertex coordinates then only if the contents are an image or
+  // a solid color.
+  if (vertices->HasVertexColors()) {
+    return false;
+  }
+  if (vertices->HasTextureCoordinates() &&
+      (type == Paint::ColorSourceType::kImage ||
+       type == Paint::ColorSourceType::kColor)) {
+    return true;
+  }
+  return !vertices->HasTextureCoordinates();
+}
+
 Canvas::Canvas() {
   Initialize();
 }
@@ -386,7 +403,9 @@
   entity.SetStencilDepth(GetStencilDepth());
   entity.SetBlendMode(paint.blend_mode);
 
-  if (!vertices->HasVertexColors()) {
+  // If there are no vertex color or texture coordinates. Or if there
+  // are vertex coordinates then only if the contents are an image.
+  if (UseColorSourceContents(vertices, paint.color_source_type)) {
     auto contents = paint.CreateContentsForGeometry(vertices);
     entity.SetContents(paint.WithFilters(std::move(contents)));
     GetCurrentPass().AddEntity(entity);
@@ -395,7 +414,27 @@
 
   auto src_paint = paint;
   src_paint.color = paint.color.WithAlpha(1.0);
-  auto src_contents = src_paint.CreateContentsForGeometry(vertices);
+
+  std::shared_ptr<Contents> src_contents =
+      src_paint.CreateContentsForGeometry(vertices);
+  if (vertices->HasTextureCoordinates() &&
+      paint.color_source_type != Paint::ColorSourceType::kImage) {
+    // If the color source has an intrinsic size, then we use that to
+    // create the src contents as a simplification. Otherwise we use
+    // the extent of the texture coordinates to determine how large
+    // the src contents should be. If neither has a value we fall back
+    // to using the geometry coverage data.
+    Rect src_coverage;
+    auto size = src_contents->ColorSourceSize();
+    if (size.has_value()) {
+      src_coverage = Rect::MakeXYWH(0, 0, size->width, size->height);
+    } else {
+      src_coverage = vertices->GetTextureCoordinateCoverge().value_or(
+          vertices->GetCoverage(Matrix{}).value());
+    }
+    src_contents =
+        src_paint.CreateContentsForGeometry(Geometry::MakeRect(src_coverage));
+  }
 
   auto contents = std::make_shared<VerticesContents>();
   contents->SetAlpha(paint.color.alpha);
diff --git a/impeller/display_list/display_list_dispatcher.cc b/impeller/display_list/display_list_dispatcher.cc
index 02e8516..1d5dba8 100644
--- a/impeller/display_list/display_list_dispatcher.cc
+++ b/impeller/display_list/display_list_dispatcher.cc
@@ -396,6 +396,13 @@
         contents->SetEndPoints(start_point, end_point);
         contents->SetTileMode(tile_mode);
         contents->SetEffectTransform(matrix);
+
+        std::vector<Point> bounds{start_point, end_point};
+        auto intrinsic_size =
+            Rect::MakePointBounds(bounds.begin(), bounds.end());
+        if (intrinsic_size.has_value()) {
+          contents->SetColorSourceSize(intrinsic_size->size);
+        }
         return contents;
       };
       return;
@@ -420,6 +427,14 @@
         contents->SetCenterAndRadius(center, radius);
         contents->SetTileMode(tile_mode);
         contents->SetEffectTransform(matrix);
+
+        auto radius_pt = Point(radius, radius);
+        std::vector<Point> bounds{center + radius_pt, center - radius_pt};
+        auto intrinsic_size =
+            Rect::MakePointBounds(bounds.begin(), bounds.end());
+        if (intrinsic_size.has_value()) {
+          contents->SetColorSourceSize(intrinsic_size->size);
+        }
         return contents;
       };
       return;
@@ -447,6 +462,7 @@
         contents->SetStops(stops);
         contents->SetTileMode(tile_mode);
         contents->SetEffectTransform(matrix);
+
         return contents;
       };
       return;
@@ -468,6 +484,7 @@
         contents->SetSamplerDescriptor(desc);
         contents->SetEffectTransform(matrix);
         contents->SetColorFilter(paint.color_filter);
+        contents->SetColorSourceSize(Size::Ceil(texture->GetSize()));
         return contents;
       };
       return;
diff --git a/impeller/display_list/display_list_unittests.cc b/impeller/display_list/display_list_unittests.cc
index 20e5e0c..a9e23ef 100644
--- a/impeller/display_list/display_list_unittests.cc
+++ b/impeller/display_list/display_list_unittests.cc
@@ -1151,6 +1151,60 @@
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }
 
+TEST_P(DisplayListTest, DrawVerticesLinearGradientWithTextureCoordinates) {
+  std::vector<SkPoint> positions = {SkPoint::Make(100, 300),
+                                    SkPoint::Make(200, 100),
+                                    SkPoint::Make(300, 300)};
+  std::vector<SkPoint> texture_coordinates = {SkPoint::Make(300, 100),
+                                              SkPoint::Make(100, 200),
+                                              SkPoint::Make(300, 300)};
+
+  auto vertices = flutter::DlVertices::Make(
+      flutter::DlVertexMode::kTriangles, 3, positions.data(),
+      texture_coordinates.data(), /*colors=*/nullptr);
+
+  std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
+                                          flutter::DlColor::kRed()};
+  const float stops[2] = {0.0, 1.0};
+
+  auto linear = flutter::DlColorSource::MakeLinear(
+      {100.0, 100.0}, {300.0, 300.0}, 2, colors.data(), stops,
+      flutter::DlTileMode::kRepeat);
+
+  flutter::DisplayListBuilder builder;
+  flutter::DlPaint paint;
+
+  paint.setColorSource(linear);
+  builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
+
+  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
+}
+
+TEST_P(DisplayListTest, DrawVerticesImageSourceWithTextureCoordinates) {
+  auto texture = CreateTextureForFixture("embarcadero.jpg");
+  auto dl_image = DlImageImpeller::Make(texture);
+  std::vector<SkPoint> positions = {SkPoint::Make(100, 300),
+                                    SkPoint::Make(200, 100),
+                                    SkPoint::Make(300, 300)};
+  std::vector<SkPoint> texture_coordinates = {
+      SkPoint::Make(0, 0), SkPoint::Make(100, 200), SkPoint::Make(200, 100)};
+
+  auto vertices = flutter::DlVertices::Make(
+      flutter::DlVertexMode::kTriangles, 3, positions.data(),
+      texture_coordinates.data(), /*colors=*/nullptr);
+
+  flutter::DisplayListBuilder builder;
+  flutter::DlPaint paint;
+
+  auto image_source = flutter::DlImageColorSource(
+      dl_image, flutter::DlTileMode::kRepeat, flutter::DlTileMode::kRepeat);
+
+  paint.setColorSource(&image_source);
+  builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
+
+  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
+}
+
 TEST_P(DisplayListTest, DrawVerticesSolidColorTrianglesWithIndices) {
   std::vector<SkPoint> positions = {
       SkPoint::Make(100, 300), SkPoint::Make(200, 100), SkPoint::Make(300, 300),
diff --git a/impeller/display_list/display_list_vertices_geometry.cc b/impeller/display_list/display_list_vertices_geometry.cc
index 52caeea..1966229 100644
--- a/impeller/display_list/display_list_vertices_geometry.cc
+++ b/impeller/display_list/display_list_vertices_geometry.cc
@@ -7,6 +7,7 @@
 #include "impeller/entity/contents/content_context.h"
 #include "impeller/entity/entity.h"
 #include "impeller/entity/position_color.vert.h"
+#include "impeller/entity/texture_fill.vert.h"
 #include "impeller/geometry/matrix.h"
 #include "impeller/geometry/path_builder.h"
 #include "impeller/geometry/point.h"
@@ -100,10 +101,38 @@
   }
 }
 
+std::optional<Rect> DLVerticesGeometry::GetTextureCoordinateCoverge() const {
+  if (!HasTextureCoordinates()) {
+    return std::nullopt;
+  }
+  auto vertex_count = vertices_->vertex_count();
+  auto* dl_texture_coordinates = vertices_->texture_coordinates();
+  if (vertex_count == 0) {
+    return std::nullopt;
+  }
+
+  auto left = dl_texture_coordinates[0].x();
+  auto top = dl_texture_coordinates[0].y();
+  auto right = dl_texture_coordinates[0].x();
+  auto bottom = dl_texture_coordinates[0].y();
+
+  for (auto i = 0; i < vertex_count; i++) {
+    left = std::min(left, dl_texture_coordinates[i].x());
+    top = std::min(top, dl_texture_coordinates[i].y());
+    right = std::max(right, dl_texture_coordinates[i].x());
+    bottom = std::max(bottom, dl_texture_coordinates[i].y());
+  }
+  return Rect::MakeLTRB(left, top, right, bottom);
+}
+
 bool DLVerticesGeometry::HasVertexColors() const {
   return vertices_->colors() != nullptr;
 }
 
+bool DLVerticesGeometry::HasTextureCoordinates() const {
+  return vertices_->texture_coordinates() != nullptr;
+}
+
 GeometryResult DLVerticesGeometry::GetPositionBuffer(
     const ContentContext& renderer,
     const Entity& entity,
@@ -225,12 +254,80 @@
 }
 
 GeometryResult DLVerticesGeometry::GetPositionUVBuffer(
+    Rect texture_coverage,
+    Matrix effect_transform,
     const ContentContext& renderer,
     const Entity& entity,
     RenderPass& pass) {
-  // TODO(jonahwilliams): support texture coordinates in vertices
-  // https://github.com/flutter/flutter/issues/109956
-  return {};
+  using VS = TexturePipeline::VertexShader;
+
+  auto index_count = normalized_indices_.size() == 0
+                         ? vertices_->index_count()
+                         : normalized_indices_.size();
+  auto vertex_count = vertices_->vertex_count();
+  auto* dl_indices = normalized_indices_.size() == 0
+                         ? vertices_->indices()
+                         : normalized_indices_.data();
+  auto* dl_vertices = vertices_->vertices();
+  auto* dl_texture_coordinates = vertices_->texture_coordinates();
+
+  auto size = texture_coverage.size;
+  auto origin = texture_coverage.origin;
+  std::vector<VS::PerVertexData> vertex_data(vertex_count);
+  {
+    for (auto i = 0; i < vertex_count; i++) {
+      auto sk_point = dl_vertices[i];
+      auto texture_coord = dl_texture_coordinates[i];
+      auto uv = effect_transform *
+                Point((texture_coord.x() - origin.x) / size.width,
+                      (texture_coord.y() - origin.y) / size.height);
+      // From experimentation we need to clamp these values to < 1.0 or else
+      // there can be flickering.
+      vertex_data[i] = {
+          .position = Point(sk_point.x(), sk_point.y()),
+          .texture_coords =
+              Point(std::clamp(uv.x, 0.0f, 1.0f - kEhCloseEnough),
+                    std::clamp(uv.y, 0.0f, 1.0f - kEhCloseEnough)),
+      };
+    }
+  }
+
+  size_t total_vtx_bytes = vertex_data.size() * sizeof(VS::PerVertexData);
+  size_t total_idx_bytes = index_count * sizeof(uint16_t);
+
+  DeviceBufferDescriptor buffer_desc;
+  buffer_desc.size = total_vtx_bytes + total_idx_bytes;
+  buffer_desc.storage_mode = StorageMode::kHostVisible;
+
+  auto buffer =
+      renderer.GetContext()->GetResourceAllocator()->CreateBuffer(buffer_desc);
+
+  if (!buffer->CopyHostBuffer(reinterpret_cast<uint8_t*>(vertex_data.data()),
+                              Range{0, total_vtx_bytes}, 0)) {
+    return {};
+  }
+  if (!buffer->CopyHostBuffer(
+          reinterpret_cast<uint8_t*>(const_cast<uint16_t*>(dl_indices)),
+          Range{0, total_idx_bytes}, total_vtx_bytes)) {
+    return {};
+  }
+
+  return GeometryResult{
+      .type = GetPrimitiveType(vertices_),
+      .vertex_buffer =
+          {
+              .vertex_buffer = {.buffer = buffer,
+                                .range = Range{0, total_vtx_bytes}},
+              .index_buffer = {.buffer = buffer,
+                               .range =
+                                   Range{total_vtx_bytes, total_idx_bytes}},
+              .index_count = index_count,
+              .index_type = IndexType::k16bit,
+          },
+      .transform = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
+                   entity.GetTransformation(),
+      .prevent_overdraw = false,
+  };
 }
 
 GeometryVertexType DLVerticesGeometry::GetVertexType() const {
@@ -238,6 +335,11 @@
   if (dl_colors != nullptr) {
     return GeometryVertexType::kColor;
   }
+  auto* dl_texture_coordinates = vertices_->texture_coordinates();
+  if (dl_texture_coordinates != nullptr) {
+    return GeometryVertexType::kUV;
+  }
+
   return GeometryVertexType::kPosition;
 }
 
diff --git a/impeller/display_list/display_list_vertices_geometry.h b/impeller/display_list/display_list_vertices_geometry.h
index 3ebfa89..9a668f9 100644
--- a/impeller/display_list/display_list_vertices_geometry.h
+++ b/impeller/display_list/display_list_vertices_geometry.h
@@ -32,7 +32,9 @@
                                         RenderPass& pass) override;
 
   // |VerticesGeometry|
-  GeometryResult GetPositionUVBuffer(const ContentContext& renderer,
+  GeometryResult GetPositionUVBuffer(Rect texture_coverage,
+                                     Matrix effect_transform,
+                                     const ContentContext& renderer,
                                      const Entity& entity,
                                      RenderPass& pass) override;
 
@@ -50,6 +52,12 @@
   // |VerticesGeometry|
   bool HasVertexColors() const override;
 
+  // |VerticesGeometry|
+  bool HasTextureCoordinates() const override;
+
+  // |VerticesGeometry|
+  std::optional<Rect> GetTextureCoordinateCoverge() const override;
+
  private:
   void NormalizeIndices();
 
diff --git a/impeller/entity/contents/content_context.cc b/impeller/entity/contents/content_context.cc
index 2799a91..fda3198 100644
--- a/impeller/entity/contents/content_context.cc
+++ b/impeller/entity/contents/content_context.cc
@@ -250,6 +250,8 @@
   texture_blend_pipelines_[{}] =
       CreateDefaultPipeline<BlendPipeline>(*context_);
   texture_pipelines_[{}] = CreateDefaultPipeline<TexturePipeline>(*context_);
+  position_uv_pipelines_[{}] =
+      CreateDefaultPipeline<PositionUVPipeline>(*context_);
   tiled_texture_pipelines_[{}] =
       CreateDefaultPipeline<TiledTexturePipeline>(*context_);
   gaussian_blur_pipelines_[{}] =
diff --git a/impeller/entity/contents/content_context.h b/impeller/entity/contents/content_context.h
index 65bd2a0..c5a5788 100644
--- a/impeller/entity/contents/content_context.h
+++ b/impeller/entity/contents/content_context.h
@@ -54,7 +54,6 @@
 
 #include "impeller/entity/position.vert.h"
 #include "impeller/entity/position_color.vert.h"
-#include "impeller/entity/position_uv.vert.h"
 
 #include "impeller/scene/scene_context.h"
 #include "impeller/typographer/glyph_atlas.h"
@@ -123,6 +122,8 @@
 using BlendPipeline = RenderPipelineT<BlendVertexShader, BlendFragmentShader>;
 using TexturePipeline =
     RenderPipelineT<TextureFillVertexShader, TextureFillFragmentShader>;
+using PositionUVPipeline =
+    RenderPipelineT<TextureFillVertexShader, TiledTextureFillFragmentShader>;
 using TiledTexturePipeline = RenderPipelineT<TiledTextureFillVertexShader,
                                              TiledTextureFillFragmentShader>;
 using GaussianBlurPipeline =
@@ -362,6 +363,11 @@
     return GetPipeline(texture_pipelines_, opts);
   }
 
+  std::shared_ptr<Pipeline<PipelineDescriptor>> GetPositionUVPipeline(
+      ContentContextOptions opts) const {
+    return GetPipeline(position_uv_pipelines_, opts);
+  }
+
   std::shared_ptr<Pipeline<PipelineDescriptor>> GetTiledTexturePipeline(
       ContentContextOptions opts) const {
     return GetPipeline(tiled_texture_pipelines_, opts);
@@ -626,6 +632,7 @@
   mutable Variants<RRectBlurPipeline> rrect_blur_pipelines_;
   mutable Variants<BlendPipeline> texture_blend_pipelines_;
   mutable Variants<TexturePipeline> texture_pipelines_;
+  mutable Variants<PositionUVPipeline> position_uv_pipelines_;
   mutable Variants<TiledTexturePipeline> tiled_texture_pipelines_;
   mutable Variants<GaussianBlurPipeline> gaussian_blur_pipelines_;
   mutable Variants<GaussianBlurDecalPipeline> gaussian_blur_decal_pipelines_;
diff --git a/impeller/entity/contents/contents.h b/impeller/entity/contents/contents.h
index 2c5f3ab..a4ff06b 100644
--- a/impeller/entity/contents/contents.h
+++ b/impeller/entity/contents/contents.h
@@ -75,9 +75,19 @@
   virtual bool ShouldRender(const Entity& entity,
                             const std::optional<Rect>& stencil_coverage) const;
 
+  /// @brief  Return the color source's intrinsic size, if available.
+  ///
+  /// For example, a gradient has a size based on its end and beginning points,
+  /// ignoring any tiling. Solid colors and runtime effects have no size.
+  std::optional<Size> ColorSourceSize() const { return color_source_size_; }
+
+  void SetColorSourceSize(Size size) { color_source_size_ = size; }
+
  protected:
 
  private:
+  std::optional<Size> color_source_size_;
+
   FML_DISALLOW_COPY_AND_ASSIGN(Contents);
 };
 
diff --git a/impeller/entity/contents/tiled_texture_contents.cc b/impeller/entity/contents/tiled_texture_contents.cc
index d50af65..d9e8a80 100644
--- a/impeller/entity/contents/tiled_texture_contents.cc
+++ b/impeller/entity/contents/tiled_texture_contents.cc
@@ -56,6 +56,13 @@
   if (texture_ == nullptr) {
     return true;
   }
+  // TODO(jonahwilliams): this is a special case for VerticesGeometry which
+  // implements GetPositionUVBuffer. The general geometry case does not use
+  // this method (see note below).
+  auto geometry = GetGeometry();
+  if (geometry->GetVertexType() == GeometryVertexType::kUV) {
+    return RenderVertices(renderer, entity, pass);
+  }
 
   using VS = TiledTextureFillVertexShader;
   using FS = TiledTextureFillFragmentShader;
@@ -67,7 +74,6 @@
 
   auto& host_buffer = pass.GetTransientsBuffer();
 
-  auto geometry = GetGeometry();
   auto geometry_result =
       GetGeometry()->GetPositionBuffer(renderer, entity, pass);
 
@@ -132,4 +138,72 @@
   return true;
 }
 
+bool TiledTextureContents::RenderVertices(const ContentContext& renderer,
+                                          const Entity& entity,
+                                          RenderPass& pass) const {
+  using VS = PositionUVPipeline::VertexShader;
+  using FS = PositionUVPipeline::FragmentShader;
+
+  const auto texture_size = texture_->GetSize();
+  if (texture_size.IsEmpty()) {
+    return true;
+  }
+
+  auto& host_buffer = pass.GetTransientsBuffer();
+
+  auto geometry_result = GetGeometry()->GetPositionUVBuffer(
+      Rect::MakeSize(texture_size), GetInverseMatrix(), renderer, entity, pass);
+
+  VS::FrameInfo frame_info;
+  frame_info.mvp = geometry_result.transform;
+
+  FS::FragInfo frag_info;
+  frag_info.texture_sampler_y_coord_scale = texture_->GetYCoordScale();
+  frag_info.x_tile_mode = static_cast<Scalar>(x_tile_mode_);
+  frag_info.y_tile_mode = static_cast<Scalar>(y_tile_mode_);
+  frag_info.alpha = GetAlpha();
+
+  Command cmd;
+  cmd.label = "PositionUV";
+  cmd.stencil_reference = entity.GetStencilDepth();
+
+  auto options = OptionsFromPassAndEntity(pass, entity);
+  if (geometry_result.prevent_overdraw) {
+    options.stencil_compare = CompareFunction::kEqual;
+    options.stencil_operation = StencilOperation::kIncrementClamp;
+  }
+  options.primitive_type = geometry_result.type;
+  cmd.pipeline = renderer.GetPositionUVPipeline(options);
+
+  cmd.BindVertices(geometry_result.vertex_buffer);
+  VS::BindFrameInfo(cmd, host_buffer.EmplaceUniform(frame_info));
+  FS::BindFragInfo(cmd, host_buffer.EmplaceUniform(frag_info));
+  if (color_filter_.has_value()) {
+    auto filtered_texture = CreateFilterTexture(renderer);
+    if (!filtered_texture.has_value()) {
+      return false;
+    }
+    FS::BindTextureSampler(
+        cmd, filtered_texture.value(),
+        renderer.GetContext()->GetSamplerLibrary()->GetSampler(
+            sampler_descriptor_));
+  } else {
+    FS::BindTextureSampler(
+        cmd, texture_,
+        renderer.GetContext()->GetSamplerLibrary()->GetSampler(
+            sampler_descriptor_));
+  }
+
+  if (!pass.AddCommand(std::move(cmd))) {
+    return false;
+  }
+
+  if (geometry_result.prevent_overdraw) {
+    auto restore = ClipRestoreContents();
+    restore.SetRestoreCoverage(GetCoverage(entity));
+    return restore.Render(renderer, entity, pass);
+  }
+  return true;
+}
+
 }  // namespace impeller
diff --git a/impeller/entity/contents/tiled_texture_contents.h b/impeller/entity/contents/tiled_texture_contents.h
index f1db94f..0f0c6b3 100644
--- a/impeller/entity/contents/tiled_texture_contents.h
+++ b/impeller/entity/contents/tiled_texture_contents.h
@@ -53,6 +53,10 @@
   std::optional<std::shared_ptr<Texture>> CreateFilterTexture(
       const ContentContext& renderer) const;
 
+  bool RenderVertices(const ContentContext& renderer,
+                      const Entity& entity,
+                      RenderPass& pass) const;
+
   std::shared_ptr<Texture> texture_;
   SamplerDescriptor sampler_descriptor_ = {};
   Entity::TileMode x_tile_mode_ = Entity::TileMode::kClamp;
diff --git a/impeller/entity/contents/vertices_contents.cc b/impeller/entity/contents/vertices_contents.cc
index a7b6c0d..de2954b 100644
--- a/impeller/entity/contents/vertices_contents.cc
+++ b/impeller/entity/contents/vertices_contents.cc
@@ -10,7 +10,6 @@
 #include "impeller/entity/contents/texture_contents.h"
 #include "impeller/entity/position.vert.h"
 #include "impeller/entity/position_color.vert.h"
-#include "impeller/entity/position_uv.vert.h"
 #include "impeller/entity/vertices.frag.h"
 #include "impeller/geometry/color.h"
 #include "impeller/renderer/formats.h"
@@ -48,23 +47,101 @@
   blend_mode_ = blend_mode;
 }
 
+const std::shared_ptr<Contents>& VerticesContents::GetSourceContents() const {
+  return src_contents_;
+}
+
 bool VerticesContents::Render(const ContentContext& renderer,
                               const Entity& entity,
                               RenderPass& pass) const {
   if (blend_mode_ == BlendMode::kClear) {
     return true;
   }
+  std::shared_ptr<Contents> src_contents = src_contents_;
+  if (geometry_->HasTextureCoordinates()) {
+    auto contents = std::make_shared<VerticesUVContents>(*this);
+    if (!geometry_->HasVertexColors()) {
+      contents->SetAlpha(alpha_);
+      return contents->Render(renderer, entity, pass);
+    }
+    src_contents = contents;
+  }
+
   auto dst_contents = std::make_shared<VerticesColorContents>(*this);
 
   auto contents = ColorFilterContents::MakeBlend(
       blend_mode_, {FilterInput::Make(dst_contents, false),
-                    FilterInput::Make(src_contents_, false)});
+                    FilterInput::Make(src_contents, false)});
   contents->SetAlpha(alpha_);
 
   return contents->Render(renderer, entity, pass);
 }
 
 //------------------------------------------------------
+// VerticesUVContents
+
+VerticesUVContents::VerticesUVContents(const VerticesContents& parent)
+    : parent_(parent) {}
+
+VerticesUVContents::~VerticesUVContents() {}
+
+std::optional<Rect> VerticesUVContents::GetCoverage(
+    const Entity& entity) const {
+  return parent_.GetCoverage(entity);
+}
+
+void VerticesUVContents::SetAlpha(Scalar alpha) {
+  alpha_ = alpha;
+}
+
+bool VerticesUVContents::Render(const ContentContext& renderer,
+                                const Entity& entity,
+                                RenderPass& pass) const {
+  using VS = TexturePipeline::VertexShader;
+  using FS = TexturePipeline::FragmentShader;
+
+  auto src_contents = parent_.GetSourceContents();
+
+  auto snapshot = src_contents->RenderToSnapshot(renderer, entity);
+  if (!snapshot.has_value()) {
+    return false;
+  }
+
+  Command cmd;
+  cmd.label = "VerticesUV";
+  auto& host_buffer = pass.GetTransientsBuffer();
+  auto geometry = parent_.GetGeometry();
+
+  auto coverage = src_contents->GetCoverage(Entity{});
+  if (!coverage.has_value()) {
+    return false;
+  }
+  auto geometry_result = geometry->GetPositionUVBuffer(
+      coverage.value(), Matrix(), renderer, entity, pass);
+  auto opts = OptionsFromPassAndEntity(pass, entity);
+  opts.primitive_type = geometry_result.type;
+  cmd.pipeline = renderer.GetTexturePipeline(opts);
+  cmd.stencil_reference = entity.GetStencilDepth();
+  cmd.BindVertices(geometry_result.vertex_buffer);
+
+  VS::FrameInfo frame_info;
+  frame_info.mvp = geometry_result.transform;
+  frame_info.texture_sampler_y_coord_scale =
+      snapshot->texture->GetYCoordScale();
+  VS::BindFrameInfo(cmd, host_buffer.EmplaceUniform(frame_info));
+
+  FS::FragInfo frag_info;
+  frag_info.alpha = alpha_ * snapshot->opacity;
+  FS::BindFragInfo(cmd, host_buffer.EmplaceUniform(frag_info));
+
+  FS::BindTextureSampler(cmd, snapshot->texture,
+                         renderer.GetContext()->GetSamplerLibrary()->GetSampler(
+                             snapshot->sampler_descriptor));
+
+  return pass.AddCommand(std::move(cmd));
+}
+
+//------------------------------------------------------
 // VerticesColorContents
 
 VerticesColorContents::VerticesColorContents(const VerticesContents& parent)
@@ -72,7 +149,6 @@
 
 VerticesColorContents::~VerticesColorContents() {}
 
-// |Contents|
 std::optional<Rect> VerticesColorContents::GetCoverage(
     const Entity& entity) const {
   return parent_.GetCoverage(entity);
@@ -82,7 +158,6 @@
   alpha_ = alpha;
 }
 
-// |Contents|
 bool VerticesColorContents::Render(const ContentContext& renderer,
                                    const Entity& entity,
                                    RenderPass& pass) const {
@@ -99,6 +174,7 @@
   auto opts = OptionsFromPassAndEntity(pass, entity);
   opts.primitive_type = geometry_result.type;
   cmd.pipeline = renderer.GetGeometryColorPipeline(opts);
+  cmd.stencil_reference = entity.GetStencilDepth();
   cmd.BindVertices(geometry_result.vertex_buffer);
 
   VS::FrameInfo frame_info;
diff --git a/impeller/entity/contents/vertices_contents.h b/impeller/entity/contents/vertices_contents.h
index b2459d5..88facd3 100644
--- a/impeller/entity/contents/vertices_contents.h
+++ b/impeller/entity/contents/vertices_contents.h
@@ -35,6 +35,8 @@
 
   std::shared_ptr<VerticesGeometry> GetGeometry() const;
 
+  const std::shared_ptr<Contents>& GetSourceContents() const;
+
   // |Contents|
   std::optional<Rect> GetCoverage(const Entity& entity) const override;
 
@@ -75,4 +77,27 @@
   FML_DISALLOW_COPY_AND_ASSIGN(VerticesColorContents);
 };
 
+class VerticesUVContents final : public Contents {
+ public:
+  explicit VerticesUVContents(const VerticesContents& parent);
+
+  ~VerticesUVContents() override;
+
+  // |Contents|
+  std::optional<Rect> GetCoverage(const Entity& entity) const override;
+
+  // |Contents|
+  bool Render(const ContentContext& renderer,
+              const Entity& entity,
+              RenderPass& pass) const override;
+
+  void SetAlpha(Scalar alpha);
+
+ private:
+  const VerticesContents& parent_;
+  Scalar alpha_ = 1.0;
+
+  FML_DISALLOW_COPY_AND_ASSIGN(VerticesUVContents);
+};
+
 }  // namespace impeller
diff --git a/impeller/entity/geometry.cc b/impeller/entity/geometry.cc
index c86eaa6..b610e03 100644
--- a/impeller/entity/geometry.cc
+++ b/impeller/entity/geometry.cc
@@ -17,6 +17,14 @@
 
 Geometry::~Geometry() = default;
 
+GeometryResult Geometry::GetPositionUVBuffer(Rect texture_coverage,
+                                             Matrix effect_transform,
+                                             const ContentContext& renderer,
+                                             const Entity& entity,
+                                             RenderPass& pass) {
+  return {};
+}
+
 // static
 std::unique_ptr<Geometry> Geometry::MakeFillPath(const Path& path) {
   return std::make_unique<FillPathGeometry>(path);
diff --git a/impeller/entity/geometry.h b/impeller/entity/geometry.h
index f595eee..edc59cd 100644
--- a/impeller/entity/geometry.h
+++ b/impeller/entity/geometry.h
@@ -65,6 +65,12 @@
                                            const Entity& entity,
                                            RenderPass& pass) = 0;
 
+  virtual GeometryResult GetPositionUVBuffer(Rect texture_coverage,
+                                             Matrix effect_transform,
+                                             const ContentContext& renderer,
+                                             const Entity& entity,
+                                             RenderPass& pass);
+
   virtual GeometryVertexType GetVertexType() const = 0;
 
   virtual std::optional<Rect> GetCoverage(const Matrix& transform) const = 0;
@@ -77,11 +83,11 @@
                                                 const Entity& entity,
                                                 RenderPass& pass) = 0;
 
-  virtual GeometryResult GetPositionUVBuffer(const ContentContext& renderer,
-                                             const Entity& entity,
-                                             RenderPass& pass) = 0;
-
   virtual bool HasVertexColors() const = 0;
+
+  virtual bool HasTextureCoordinates() const = 0;
+
+  virtual std::optional<Rect> GetTextureCoordinateCoverge() const = 0;
 };
 
 /// @brief A geometry that is created from a filled path object.