diff --git a/engine/src/flutter/impeller/renderer/BUILD.gn b/engine/src/flutter/impeller/renderer/BUILD.gn
index 0340164b956f2..861f2b5f5435f 100644
--- a/engine/src/flutter/impeller/renderer/BUILD.gn
+++ b/engine/src/flutter/impeller/renderer/BUILD.gn
@@ -104,6 +104,7 @@ template("renderer_unittests_component") {
     "blit_pass_unittests.cc",
     "capabilities_unittests.cc",
     "device_buffer_unittests.cc",
+    "pipeline_compile_queue_unittests.cc",
     "pipeline_descriptor_unittests.cc",
     "pipeline_library_unittests.cc",
     "pool_unittests.cc",
diff --git a/engine/src/flutter/impeller/renderer/backend/gles/BUILD.gn b/engine/src/flutter/impeller/renderer/backend/gles/BUILD.gn
index 38c9771b4be9e..93bad0d441972 100644
--- a/engine/src/flutter/impeller/renderer/backend/gles/BUILD.gn
+++ b/engine/src/flutter/impeller/renderer/backend/gles/BUILD.gn
@@ -24,6 +24,7 @@ impeller_component("gles_unittests") {
     "test/mock_gles.cc",
     "test/mock_gles.h",
     "test/mock_gles_unittests.cc",
+    "test/pipeline_compile_queue_gles_unittests.cc",
     "test/pipeline_library_gles_unittests.cc",
     "test/proc_table_gles_unittests.cc",
     "test/reactor_unittests.cc",
@@ -34,6 +35,7 @@ impeller_component("gles_unittests") {
   ]
   deps = [
     ":gles",
+    "//flutter/fml",
     "//flutter/impeller/playground:playground_test",
     "//flutter/testing:testing_lib",
   ]
@@ -68,6 +70,8 @@ impeller_component("gles") {
     "gpu_tracer_gles.h",
     "handle_gles.cc",
     "handle_gles.h",
+    "pipeline_compile_queue_gles.cc",
+    "pipeline_compile_queue_gles.h",
     "pipeline_gles.cc",
     "pipeline_gles.h",
     "pipeline_library_gles.cc",
diff --git a/engine/src/flutter/impeller/renderer/backend/gles/context_gles.cc b/engine/src/flutter/impeller/renderer/backend/gles/context_gles.cc
index 084b74d4e0ec5..070591eba3a7e 100644
--- a/engine/src/flutter/impeller/renderer/backend/gles/context_gles.cc
+++ b/engine/src/flutter/impeller/renderer/backend/gles/context_gles.cc
@@ -22,16 +22,19 @@ std::shared_ptr<ContextGLES> ContextGLES::Create(
     const Flags& flags,
     std::unique_ptr<ProcTableGLES> gl,
     const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries,
-    bool enable_gpu_tracing) {
-  return std::shared_ptr<ContextGLES>(new ContextGLES(
-      flags, std::move(gl), shader_libraries, enable_gpu_tracing));
+    bool enable_gpu_tracing,
+    fml::RefPtr<fml::TaskRunner> io_task_runner) {
+  return std::shared_ptr<ContextGLES>(
+      new ContextGLES(flags, std::move(gl), shader_libraries,
+                      enable_gpu_tracing, std::move(io_task_runner)));
 }
 
 ContextGLES::ContextGLES(
     const Flags& flags,
     std::unique_ptr<ProcTableGLES> gl,
     const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries_mappings,
-    bool enable_gpu_tracing)
+    bool enable_gpu_tracing,
+    fml::RefPtr<fml::TaskRunner> io_task_runner)
     : Context(flags) {
   reactor_ = std::make_shared<ReactorGLES>(std::move(gl));
   if (!reactor_->IsValid()) {
@@ -52,8 +55,8 @@ ContextGLES::ContextGLES(
 
   // Create the pipeline library.
   {
-    pipeline_library_ =
-        std::shared_ptr<PipelineLibraryGLES>(new PipelineLibraryGLES(reactor_));
+    pipeline_library_ = std::shared_ptr<PipelineLibraryGLES>(
+        new PipelineLibraryGLES(reactor_, std::move(io_task_runner)));
   }
 
   // Create allocators.
diff --git a/engine/src/flutter/impeller/renderer/backend/gles/context_gles.h b/engine/src/flutter/impeller/renderer/backend/gles/context_gles.h
index 44f2f873bb23e..a35d4ab9342d1 100644
--- a/engine/src/flutter/impeller/renderer/backend/gles/context_gles.h
+++ b/engine/src/flutter/impeller/renderer/backend/gles/context_gles.h
@@ -28,7 +28,8 @@ class ContextGLES final : public Context,
       const Flags& flags,
       std::unique_ptr<ProcTableGLES> gl,
       const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries,
-      bool enable_gpu_tracing);
+      bool enable_gpu_tracing,
+      fml::RefPtr<fml::TaskRunner> io_task_runner = nullptr);
 
   // |Context|
   ~ContextGLES() override;
@@ -64,7 +65,8 @@ class ContextGLES final : public Context,
       const Flags& flags,
       std::unique_ptr<ProcTableGLES> gl,
       const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries,
-      bool enable_gpu_tracing);
+      bool enable_gpu_tracing,
+      fml::RefPtr<fml::TaskRunner> io_task_runner = nullptr);
 
   // |Context|
   std::string DescribeGpuModel() const override;
diff --git a/engine/src/flutter/impeller/renderer/backend/gles/pipeline_compile_queue_gles.cc b/engine/src/flutter/impeller/renderer/backend/gles/pipeline_compile_queue_gles.cc
new file mode 100644
index 0000000000000..3e818c69b10c1
--- /dev/null
+++ b/engine/src/flutter/impeller/renderer/backend/gles/pipeline_compile_queue_gles.cc
@@ -0,0 +1,61 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "impeller/renderer/backend/gles/pipeline_compile_queue_gles.h"
+
+#include "flutter/fml/logging.h"
+#include "flutter/fml/trace_event.h"
+#include "impeller/base/validation.h"
+
+namespace impeller {
+
+std::shared_ptr<PipelineCompileQueueGLES> PipelineCompileQueueGLES::Create(
+    fml::RefPtr<fml::TaskRunner> worker_task_runner) {
+  if (!worker_task_runner) {
+    return nullptr;
+  }
+  return std::shared_ptr<PipelineCompileQueueGLES>(
+      new PipelineCompileQueueGLES(std::move(worker_task_runner)));
+}
+
+PipelineCompileQueueGLES::PipelineCompileQueueGLES(
+    fml::RefPtr<fml::TaskRunner> worker_task_runner)
+    : worker_task_runner_(std::move(worker_task_runner)) {}
+
+PipelineCompileQueueGLES::~PipelineCompileQueueGLES() = default;
+
+void PipelineCompileQueueGLES::OnJobAdded() {
+  Lock lock(processing_mutex_);
+  if (!is_processing_) {
+    is_processing_ = true;
+    DrainPendingJobs();
+  }
+}
+
+void PipelineCompileQueueGLES::PostJob(const fml::closure& job) {
+  if (!job) {
+    return;
+  }
+
+  worker_task_runner_->PostTask(job);
+}
+
+void PipelineCompileQueueGLES::DrainPendingJobs() {
+  PostJob([weak_queue = weak_from_this()]() {
+    if (auto queue = std::static_pointer_cast<PipelineCompileQueueGLES>(
+            weak_queue.lock())) {
+      queue->DoOneJob();
+      {
+        Lock lock(queue->processing_mutex_);
+        if (!queue->HasPendingJobs()) {
+          queue->is_processing_ = false;
+          return;
+        }
+      }
+      queue->DrainPendingJobs();
+    }
+  });
+}
+
+}  // namespace impeller
diff --git a/engine/src/flutter/impeller/renderer/backend/gles/pipeline_compile_queue_gles.h b/engine/src/flutter/impeller/renderer/backend/gles/pipeline_compile_queue_gles.h
new file mode 100644
index 0000000000000..902f9a2060c52
--- /dev/null
+++ b/engine/src/flutter/impeller/renderer/backend/gles/pipeline_compile_queue_gles.h
@@ -0,0 +1,42 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_IMPELLER_RENDERER_BACKEND_GLES_PIPELINE_COMPILE_QUEUE_GLES_H_
+#define FLUTTER_IMPELLER_RENDERER_BACKEND_GLES_PIPELINE_COMPILE_QUEUE_GLES_H_
+
+#include "flutter/fml/closure.h"
+#include "flutter/fml/task_runner.h"
+#include "impeller/base/thread.h"
+#include "impeller/renderer/pipeline_compile_queue.h"
+
+namespace impeller {
+
+class PipelineCompileQueueGLES : public PipelineCompileQueue {
+ public:
+  static std::shared_ptr<PipelineCompileQueueGLES> Create(
+      fml::RefPtr<fml::TaskRunner> worker_task_runner);
+
+  ~PipelineCompileQueueGLES() override;
+
+  PipelineCompileQueueGLES(const PipelineCompileQueueGLES&) = delete;
+
+  PipelineCompileQueueGLES& operator=(const PipelineCompileQueueGLES&) = delete;
+
+  void PostJob(const fml::closure& job) override;
+
+  void OnJobAdded() override;
+
+ private:
+  explicit PipelineCompileQueueGLES(
+      fml::RefPtr<fml::TaskRunner> worker_task_runner);
+  void DrainPendingJobs();
+
+  fml::RefPtr<fml::TaskRunner> worker_task_runner_;
+  Mutex processing_mutex_;
+  bool is_processing_ IPLR_GUARDED_BY(processing_mutex_) = false;
+};
+
+}  // namespace impeller
+
+#endif  // FLUTTER_IMPELLER_RENDERER_BACKEND_GLES_PIPELINE_COMPILE_QUEUE_GLES_H_
diff --git a/engine/src/flutter/impeller/renderer/backend/gles/pipeline_library_gles.cc b/engine/src/flutter/impeller/renderer/backend/gles/pipeline_library_gles.cc
index 240891dfc4b60..3cad5620e143c 100644
--- a/engine/src/flutter/impeller/renderer/backend/gles/pipeline_library_gles.cc
+++ b/engine/src/flutter/impeller/renderer/backend/gles/pipeline_library_gles.cc
@@ -16,8 +16,12 @@
 
 namespace impeller {
 
-PipelineLibraryGLES::PipelineLibraryGLES(std::shared_ptr<ReactorGLES> reactor)
-    : reactor_(std::move(reactor)) {}
+PipelineLibraryGLES::PipelineLibraryGLES(
+    std::shared_ptr<ReactorGLES> reactor,
+    fml::RefPtr<fml::TaskRunner> io_task_runner)
+    : reactor_(std::move(reactor)),
+      compile_queue_(
+          PipelineCompileQueueGLES::Create(std::move(io_task_runner))) {}
 
 static std::string GetShaderInfoLog(const ProcTableGLES& gl, GLuint shader) {
   GLint log_length = 0;
@@ -296,17 +300,34 @@ PipelineFuture<PipelineDescriptor> PipelineLibraryGLES::GetPipeline(
       PipelineFuture<PipelineDescriptor>{descriptor, promise->get_future()};
   pipelines_[descriptor] = pipeline_future;
 
-  const auto result = reactor_->AddOperation([promise,                       //
-                                              weak_this = weak_from_this(),  //
-                                              descriptor,                    //
-                                              vert_function,                 //
-                                              frag_function,                 //
-                                              threadsafe                     //
-  ](const ReactorGLES& reactor) {
-    promise->set_value(CreatePipeline(weak_this, descriptor, vert_function,
-                                      frag_function, threadsafe));
-  });
-  FML_CHECK(result);
+  auto weak_this = weak_from_this();
+  auto reactor = reactor_;
+  auto generation_task = [promise, weak_this, descriptor, vert_function,
+                          frag_function, threadsafe, reactor]() {
+    auto thiz = weak_this.lock();
+    if (!thiz) {
+      promise->set_value(nullptr);
+      return;
+    }
+    const auto result = reactor->AddOperation([promise,        //
+                                               weak_this,      //
+                                               descriptor,     //
+                                               vert_function,  //
+                                               frag_function,  //
+                                               threadsafe      //
+    ](const ReactorGLES& reactor) {
+      promise->set_value(CreatePipeline(weak_this, descriptor, vert_function,
+                                        frag_function, threadsafe));
+    });
+    FML_CHECK(result);
+  };
+
+  if (async && compile_queue_) {
+    compile_queue_->PostJobForDescriptor(descriptor,
+                                         std::move(generation_task));
+  } else {
+    generation_task();
+  }
 
   return pipeline_future;
 }
@@ -373,4 +394,8 @@ void PipelineLibraryGLES::SetProgramForKey(
   programs_[key] = std::move(program);
 }
 
+PipelineCompileQueue* PipelineLibraryGLES::GetPipelineCompileQueue() const {
+  return compile_queue_.get();
+}
+
 }  // namespace impeller
diff --git a/engine/src/flutter/impeller/renderer/backend/gles/pipeline_library_gles.h b/engine/src/flutter/impeller/renderer/backend/gles/pipeline_library_gles.h
index 25c51c8113d38..765cff60c7152 100644
--- a/engine/src/flutter/impeller/renderer/backend/gles/pipeline_library_gles.h
+++ b/engine/src/flutter/impeller/renderer/backend/gles/pipeline_library_gles.h
@@ -9,7 +9,9 @@
 #include <vector>
 
 #include "flutter/fml/hash_combine.h"
+#include "flutter/fml/task_runner.h"
 #include "impeller/base/thread.h"
+#include "impeller/renderer/backend/gles/pipeline_compile_queue_gles.h"
 #include "impeller/renderer/backend/gles/reactor_gles.h"
 #include "impeller/renderer/backend/gles/unique_handle_gles.h"
 #include "impeller/renderer/pipeline_library.h"
@@ -91,8 +93,10 @@ class PipelineLibraryGLES final
   PipelineMap pipelines_;
   Mutex programs_mutex_;
   ProgramMap programs_ IPLR_GUARDED_BY(programs_mutex_);
+  std::shared_ptr<PipelineCompileQueueGLES> compile_queue_;
 
-  explicit PipelineLibraryGLES(std::shared_ptr<ReactorGLES> reactor);
+  explicit PipelineLibraryGLES(std::shared_ptr<ReactorGLES> reactor,
+                               fml::RefPtr<fml::TaskRunner> io_task_runner);
 
   // |PipelineLibrary|
   bool IsValid() const override;
@@ -127,6 +131,8 @@ class PipelineLibraryGLES final
 
   void SetProgramForKey(const ProgramKey& key,
                         std::shared_ptr<UniqueHandleGLES> program);
+  // |PipelineLibrary|
+  PipelineCompileQueue* GetPipelineCompileQueue() const override;
 };
 
 }  // namespace impeller
diff --git a/engine/src/flutter/impeller/renderer/backend/gles/test/pipeline_compile_queue_gles_unittests.cc b/engine/src/flutter/impeller/renderer/backend/gles/test/pipeline_compile_queue_gles_unittests.cc
new file mode 100644
index 0000000000000..90cc636412e00
--- /dev/null
+++ b/engine/src/flutter/impeller/renderer/backend/gles/test/pipeline_compile_queue_gles_unittests.cc
@@ -0,0 +1,137 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "impeller/renderer/backend/gles/pipeline_compile_queue_gles.h"
+
+#include <atomic>
+#include <memory>
+#include <vector>
+
+#include "flutter/fml/synchronization/count_down_latch.h"
+#include "flutter/fml/task_runner.h"
+#include "flutter/fml/thread.h"
+#include "flutter/testing/testing.h"
+#include "impeller/renderer/pipeline_descriptor.h"
+
+namespace impeller {
+namespace testing {
+
+TEST(PipelineCompileQueueGLESTest, CreateReturnsNullWithNullTaskRunner) {
+  auto queue = PipelineCompileQueueGLES::Create(nullptr);
+  EXPECT_EQ(queue, nullptr);
+}
+
+TEST(PipelineCompileQueueGLESTest, CreateSucceedsWithValidTaskRunner) {
+  fml::Thread thread;
+  auto queue = PipelineCompileQueueGLES::Create(thread.GetTaskRunner());
+  EXPECT_NE(queue, nullptr);
+  thread.Join();
+}
+
+TEST(PipelineCompileQueueGLESTest, PostJobDoesNothingWithNullClosure) {
+  fml::Thread thread;
+  auto queue = PipelineCompileQueueGLES::Create(thread.GetTaskRunner());
+  ASSERT_NE(queue, nullptr);
+  queue->PostJob(nullptr);
+  thread.Join();
+}
+
+TEST(PipelineCompileQueueGLESTest, OnJobAddedProcessesJobsSequentially) {
+  fml::Thread thread;
+  auto queue = PipelineCompileQueueGLES::Create(thread.GetTaskRunner());
+  ASSERT_NE(queue, nullptr);
+
+  std::atomic<int> completed_jobs{0};
+  fml::CountDownLatch latch(3);
+
+  PipelineDescriptor desc1;
+  desc1.SetSampleCount(SampleCount::kCount1);
+  desc1.SetCullMode(CullMode::kNone);
+
+  PipelineDescriptor desc2;
+  desc2.SetSampleCount(SampleCount::kCount1);
+  desc2.SetCullMode(CullMode::kFrontFace);
+
+  PipelineDescriptor desc3;
+  desc3.SetSampleCount(SampleCount::kCount1);
+  desc3.SetCullMode(CullMode::kBackFace);
+
+  queue->PostJobForDescriptor(desc1, [&]() {
+    std::this_thread::sleep_for(std::chrono::milliseconds(80));
+    completed_jobs++;
+    latch.CountDown();
+  });
+
+  queue->PostJobForDescriptor(desc2, [&]() {
+    std::this_thread::sleep_for(std::chrono::milliseconds(80));
+    completed_jobs++;
+    latch.CountDown();
+  });
+
+  queue->PostJobForDescriptor(desc3, [&]() {
+    std::this_thread::sleep_for(std::chrono::milliseconds(80));
+    completed_jobs++;
+    latch.CountDown();
+  });
+
+  latch.Wait();
+
+  EXPECT_EQ(completed_jobs, 3);
+
+  thread.Join();
+}
+
+TEST(PipelineCompileQueueGLESTest,
+     PostJobForDescriptorWithDuplicateRunsEagerly) {
+  fml::Thread thread;
+  auto queue = PipelineCompileQueueGLES::Create(thread.GetTaskRunner());
+  ASSERT_NE(queue, nullptr);
+
+  std::atomic<int> first_job_count{0};
+  std::atomic<int> second_job_count{0};
+  fml::CountDownLatch latch(2);
+
+  PipelineDescriptor desc;
+
+  queue->PostJobForDescriptor(desc, [&]() {
+    first_job_count++;
+    latch.CountDown();
+  });
+
+  queue->PostJobForDescriptor(desc, [&]() {
+    second_job_count++;
+    latch.CountDown();
+  });
+
+  latch.Wait();
+
+  EXPECT_EQ(first_job_count, 1);
+  EXPECT_EQ(second_job_count, 1);
+  thread.Join();
+}
+
+TEST(PipelineCompileQueueGLESTest, IsProcessingResetsAfterAllJobsComplete) {
+  fml::Thread thread;
+  auto queue = PipelineCompileQueueGLES::Create(thread.GetTaskRunner());
+  ASSERT_NE(queue, nullptr);
+
+  fml::CountDownLatch latch(1);
+
+  queue->PostJobForDescriptor(PipelineDescriptor{},
+                              [&]() { latch.CountDown(); });
+
+  latch.Wait();
+
+  fml::CountDownLatch latch2(1);
+  queue->PostJobForDescriptor(PipelineDescriptor{},
+                              [&]() { latch2.CountDown(); });
+
+  latch2.Wait();
+
+  SUCCEED();
+  thread.Join();
+}
+
+}  // namespace testing
+}  // namespace impeller
diff --git a/engine/src/flutter/impeller/renderer/backend/vulkan/BUILD.gn b/engine/src/flutter/impeller/renderer/backend/vulkan/BUILD.gn
index 12fbcd6aea5ef..4e8604f724f4b 100644
--- a/engine/src/flutter/impeller/renderer/backend/vulkan/BUILD.gn
+++ b/engine/src/flutter/impeller/renderer/backend/vulkan/BUILD.gn
@@ -28,6 +28,7 @@ impeller_component("vulkan_unittests") {
     "test/mock_vulkan.cc",
     "test/mock_vulkan.h",
     "test/mock_vulkan_unittests.cc",
+    "test/pipeline_compile_queue_vulkan_unittests.cc",
     "test/sampler_library_vk_unittests.cc",
     "test/swapchain_unittests.cc",
   ]
@@ -80,6 +81,8 @@ impeller_component("vulkan") {
     "pipeline_cache_data_vk.h",
     "pipeline_cache_vk.cc",
     "pipeline_cache_vk.h",
+    "pipeline_compile_queue_vulkan.cc",
+    "pipeline_compile_queue_vulkan.h",
     "pipeline_library_vk.cc",
     "pipeline_library_vk.h",
     "pipeline_vk.cc",
diff --git a/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_compile_queue_vulkan.cc b/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_compile_queue_vulkan.cc
new file mode 100644
index 0000000000000..19c6a38510987
--- /dev/null
+++ b/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_compile_queue_vulkan.cc
@@ -0,0 +1,42 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "impeller/renderer/backend/vulkan/pipeline_compile_queue_vulkan.h"
+
+#include "flutter/fml/logging.h"
+#include "flutter/fml/trace_event.h"
+
+namespace impeller {
+
+std::shared_ptr<PipelineCompileQueueVulkan> PipelineCompileQueueVulkan::Create(
+    std::shared_ptr<fml::BasicTaskRunner> worker_task_runner) {
+  return std::shared_ptr<PipelineCompileQueueVulkan>(
+      new PipelineCompileQueueVulkan(std::move(worker_task_runner)));
+}
+
+PipelineCompileQueueVulkan::PipelineCompileQueueVulkan(
+    std::shared_ptr<fml::BasicTaskRunner> worker_task_runner)
+    : PipelineCompileQueue(),
+      worker_task_runner_(std::move(worker_task_runner)) {}
+
+PipelineCompileQueueVulkan::~PipelineCompileQueueVulkan() {}
+
+void PipelineCompileQueueVulkan::OnJobAdded() {
+  PostJob([weak_queue = weak_from_this()]() {
+    if (auto queue = std::static_pointer_cast<PipelineCompileQueueVulkan>(
+            weak_queue.lock())) {
+      queue->DoOneJob();
+    }
+  });
+}
+
+void PipelineCompileQueueVulkan::PostJob(const fml::closure& job) {
+  if (!job) {
+    return;
+  }
+
+  worker_task_runner_->PostTask(job);
+}
+
+}  // namespace impeller
diff --git a/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_compile_queue_vulkan.h b/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_compile_queue_vulkan.h
new file mode 100644
index 0000000000000..7bf6a0b92170d
--- /dev/null
+++ b/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_compile_queue_vulkan.h
@@ -0,0 +1,38 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_IMPELLER_RENDERER_BACKEND_VULKAN_PIPELINE_COMPILE_QUEUE_VULKAN_H_
+#define FLUTTER_IMPELLER_RENDERER_BACKEND_VULKAN_PIPELINE_COMPILE_QUEUE_VULKAN_H_
+
+#include "flutter/fml/closure.h"
+#include "flutter/fml/task_runner.h"
+#include "impeller/renderer/pipeline_compile_queue.h"
+
+namespace impeller {
+
+class PipelineCompileQueueVulkan : public PipelineCompileQueue {
+ public:
+  static std::shared_ptr<PipelineCompileQueueVulkan> Create(
+      std::shared_ptr<fml::BasicTaskRunner> worker_task_runner);
+
+  ~PipelineCompileQueueVulkan() override;
+
+  PipelineCompileQueueVulkan(const PipelineCompileQueueVulkan&) = delete;
+
+  PipelineCompileQueueVulkan& operator=(const PipelineCompileQueueVulkan&) =
+      delete;
+
+  void PostJob(const fml::closure& job) override;
+
+  void OnJobAdded() override;
+
+ private:
+  explicit PipelineCompileQueueVulkan(
+      std::shared_ptr<fml::BasicTaskRunner> worker_task_runner);
+  std::shared_ptr<fml::BasicTaskRunner> worker_task_runner_;
+};
+
+}  // namespace impeller
+
+#endif  // FLUTTER_IMPELLER_RENDERER_BACKEND_VULKAN_PIPELINE_COMPILE_QUEUE_VULKAN_H_
diff --git a/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_library_vk.cc b/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_library_vk.cc
index 0cbef862c2bd1..ed4c2d5bc39e2 100644
--- a/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_library_vk.cc
+++ b/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_library_vk.cc
@@ -27,7 +27,7 @@ PipelineLibraryVK::PipelineLibraryVK(
                                                    device_holder,
                                                    std::move(cache_directory))),
       worker_task_runner_(std::move(worker_task_runner)),
-      compile_queue_(PipelineCompileQueue::Create(worker_task_runner_)) {
+      compile_queue_(PipelineCompileQueueVulkan::Create(worker_task_runner_)) {
   FML_DCHECK(worker_task_runner_);
   if (!pso_cache_->IsValid() || !worker_task_runner_) {
     return;
diff --git a/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_library_vk.h b/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_library_vk.h
index 3ead3c7dc700d..4304db9b58293 100644
--- a/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_library_vk.h
+++ b/engine/src/flutter/impeller/renderer/backend/vulkan/pipeline_library_vk.h
@@ -13,10 +13,10 @@
 #include "impeller/base/thread.h"
 #include "impeller/renderer/backend/vulkan/compute_pipeline_vk.h"
 #include "impeller/renderer/backend/vulkan/pipeline_cache_vk.h"
+#include "impeller/renderer/backend/vulkan/pipeline_compile_queue_vulkan.h"
 #include "impeller/renderer/backend/vulkan/pipeline_vk.h"
 #include "impeller/renderer/backend/vulkan/vk.h"
 #include "impeller/renderer/pipeline.h"
-#include "impeller/renderer/pipeline_compile_queue.h"
 #include "impeller/renderer/pipeline_library.h"
 
 namespace impeller {
@@ -49,7 +49,7 @@ class PipelineLibraryVK final
   PipelineKey pipeline_key_ IPLR_GUARDED_BY(pipelines_mutex_) = 1;
   bool is_valid_ = false;
   bool cache_dirty_ = false;
-  std::shared_ptr<PipelineCompileQueue> compile_queue_;
+  std::shared_ptr<PipelineCompileQueueVulkan> compile_queue_;
 
   PipelineLibraryVK(
       const std::shared_ptr<DeviceHolderVK>& device_holder,
diff --git a/engine/src/flutter/impeller/renderer/backend/vulkan/test/pipeline_compile_queue_vulkan_unittests.cc b/engine/src/flutter/impeller/renderer/backend/vulkan/test/pipeline_compile_queue_vulkan_unittests.cc
new file mode 100644
index 0000000000000..6ee373535fd39
--- /dev/null
+++ b/engine/src/flutter/impeller/renderer/backend/vulkan/test/pipeline_compile_queue_vulkan_unittests.cc
@@ -0,0 +1,181 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "impeller/renderer/backend/vulkan/pipeline_compile_queue_vulkan.h"
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+#include "flutter/fml/synchronization/count_down_latch.h"
+#include "flutter/fml/task_runner.h"
+#include "flutter/testing/testing.h"
+#include "impeller/renderer/pipeline_descriptor.h"
+
+namespace impeller {
+namespace testing {
+
+TEST(PipelineCompileQueueVulkanTest, CreateSucceedsWithValidTaskRunner) {
+  auto loop = fml::ConcurrentMessageLoop::Create();
+  auto queue = PipelineCompileQueueVulkan::Create(loop->GetTaskRunner());
+  EXPECT_NE(queue, nullptr);
+}
+
+TEST(PipelineCompileQueueVulkanTest, PostJobDoesNothingWithNullClosure) {
+  auto loop = fml::ConcurrentMessageLoop::Create();
+  auto queue = PipelineCompileQueueVulkan::Create(loop->GetTaskRunner());
+  ASSERT_NE(queue, nullptr);
+
+  queue->PostJob(nullptr);
+}
+
+TEST(PipelineCompileQueueVulkanTest, OnJobAddedProcessesJobsInParallel) {
+  auto loop = fml::ConcurrentMessageLoop::Create();
+  auto queue = PipelineCompileQueueVulkan::Create(loop->GetTaskRunner());
+  ASSERT_NE(queue, nullptr);
+
+  std::atomic<int> concurrent_jobs{0};
+  std::atomic<int> max_concurrent{0};
+  fml::CountDownLatch latch(3);
+
+  PipelineDescriptor desc1;
+  desc1.SetSampleCount(SampleCount::kCount1);
+  desc1.SetCullMode(CullMode::kNone);
+
+  PipelineDescriptor desc2;
+  desc2.SetSampleCount(SampleCount::kCount1);
+  desc2.SetCullMode(CullMode::kFrontFace);
+
+  PipelineDescriptor desc3;
+  desc3.SetSampleCount(SampleCount::kCount1);
+  desc3.SetCullMode(CullMode::kBackFace);
+
+  queue->PostJobForDescriptor(desc1, [&]() {
+    int current = ++concurrent_jobs;
+    int prev_max = max_concurrent.load();
+    while (current > prev_max &&
+           !max_concurrent.compare_exchange_weak(prev_max, current)) {
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    concurrent_jobs--;
+    latch.CountDown();
+  });
+
+  queue->PostJobForDescriptor(desc2, [&]() {
+    int current = ++concurrent_jobs;
+    int prev_max = max_concurrent.load();
+    while (current > prev_max &&
+           !max_concurrent.compare_exchange_weak(prev_max, current)) {
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    concurrent_jobs--;
+    latch.CountDown();
+  });
+
+  queue->PostJobForDescriptor(desc3, [&]() {
+    int current = ++concurrent_jobs;
+    int prev_max = max_concurrent.load();
+    while (current > prev_max &&
+           !max_concurrent.compare_exchange_weak(prev_max, current)) {
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    concurrent_jobs--;
+    latch.CountDown();
+  });
+
+  latch.Wait();
+
+  EXPECT_GE(max_concurrent.load(), 1);
+}
+
+TEST(PipelineCompileQueueVulkanTest,
+     PostJobForDescriptorWithDuplicateRunsEagerly) {
+  auto loop = fml::ConcurrentMessageLoop::Create();
+  auto queue = PipelineCompileQueueVulkan::Create(loop->GetTaskRunner());
+  ASSERT_NE(queue, nullptr);
+
+  std::atomic<int> first_job_count{0};
+  std::atomic<int> second_job_count{0};
+  fml::CountDownLatch latch(2);
+
+  PipelineDescriptor desc;
+
+  queue->PostJobForDescriptor(desc, [&]() {
+    first_job_count++;
+    latch.CountDown();
+  });
+
+  queue->PostJobForDescriptor(desc, [&]() {
+    second_job_count++;
+    latch.CountDown();
+  });
+
+  latch.Wait();
+
+  EXPECT_EQ(first_job_count, 1);
+  EXPECT_EQ(second_job_count, 1);
+}
+
+TEST(PipelineCompileQueueVulkanTest, MultipleJobsCompleteSuccessfully) {
+  auto loop = fml::ConcurrentMessageLoop::Create();
+  auto queue = PipelineCompileQueueVulkan::Create(loop->GetTaskRunner());
+  ASSERT_NE(queue, nullptr);
+
+  std::atomic<int> completed_jobs{0};
+  fml::CountDownLatch latch(5);
+
+  PipelineDescriptor desc1;
+  desc1.SetSampleCount(SampleCount::kCount1);
+  desc1.SetCullMode(CullMode::kNone);
+
+  PipelineDescriptor desc2;
+  desc2.SetSampleCount(SampleCount::kCount1);
+  desc2.SetCullMode(CullMode::kFrontFace);
+
+  PipelineDescriptor desc3;
+  desc3.SetSampleCount(SampleCount::kCount1);
+  desc3.SetCullMode(CullMode::kBackFace);
+
+  PipelineDescriptor desc4;
+  desc4.SetSampleCount(SampleCount::kCount4);
+  desc4.SetCullMode(CullMode::kNone);
+
+  PipelineDescriptor desc5;
+  desc5.SetSampleCount(SampleCount::kCount4);
+  desc5.SetCullMode(CullMode::kFrontFace);
+
+  // Post 5 jobs with distinct descriptors
+  queue->PostJobForDescriptor(desc1, [&]() {
+    completed_jobs++;
+    latch.CountDown();
+  });
+
+  queue->PostJobForDescriptor(desc2, [&]() {
+    completed_jobs++;
+    latch.CountDown();
+  });
+
+  queue->PostJobForDescriptor(desc3, [&]() {
+    completed_jobs++;
+    latch.CountDown();
+  });
+
+  queue->PostJobForDescriptor(desc4, [&]() {
+    completed_jobs++;
+    latch.CountDown();
+  });
+
+  queue->PostJobForDescriptor(desc5, [&]() {
+    completed_jobs++;
+    latch.CountDown();
+  });
+
+  latch.Wait();
+
+  EXPECT_EQ(completed_jobs, 5);
+}
+
+}  // namespace testing
+}  // namespace impeller
diff --git a/engine/src/flutter/impeller/renderer/pipeline_compile_queue.cc b/engine/src/flutter/impeller/renderer/pipeline_compile_queue.cc
index 124e11e177346..da10b9be100b8 100644
--- a/engine/src/flutter/impeller/renderer/pipeline_compile_queue.cc
+++ b/engine/src/flutter/impeller/renderer/pipeline_compile_queue.cc
@@ -9,16 +9,6 @@
 
 namespace impeller {
 
-std::shared_ptr<PipelineCompileQueue> PipelineCompileQueue::Create(
-    std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner) {
-  return std::shared_ptr<PipelineCompileQueue>(
-      new PipelineCompileQueue(std::move(worker_task_runner)));
-}
-
-PipelineCompileQueue::PipelineCompileQueue(
-    std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner)
-    : worker_task_runner_(std::move(worker_task_runner)) {}
-
 PipelineCompileQueue::~PipelineCompileQueue() {
   FinishAllJobs();
 }
@@ -29,31 +19,33 @@ bool PipelineCompileQueue::PostJobForDescriptor(const PipelineDescriptor& desc,
     return false;
   }
 
-  {
-    Lock lock(pending_jobs_mutex_);
-    auto insertion_result = pending_jobs_.insert(std::make_pair(desc, job));
-    if (!insertion_result.second) {
-      // This bit is being extremely conservative. If insertion did not take
-      // place, someone gave the compile queue a job for the same description.
-      // This is highly unusual but technically not impossible. Just run the job
-      // eagerly.
-      FML_LOG(ERROR) << "Got multiple compile jobs for the same descriptor. "
+  if (!AddJob(desc, job)) {
+    // This bit is being extremely conservative. If insertion did not take
+    // place, someone gave the compile queue a job for the same description.
+    // This is highly unusual but technically not impossible. Just run the job
+    // eagerly.
+    FML_LOG(WARNING) << "Got multiple compile jobs for the same descriptor. "
                         "Running eagerly.";
-      // Don't invoke the job here has there are we have currently acquired a
-      // mutex.
-      worker_task_runner_->PostTask(job);
-      return true;
-    }
+    PostJob(job);
+    return true;
   }
 
-  worker_task_runner_->PostTask([weak_queue = weak_from_this()]() {
-    if (auto queue = weak_queue.lock()) {
-      queue->DoOneJob();
-    }
-  });
+  OnJobAdded();
   return true;
 }
 
+bool PipelineCompileQueue::AddJob(const PipelineDescriptor& desc,
+                                  const fml::closure& job) {
+  Lock lock(pending_jobs_mutex_);
+  auto insertion_result = pending_jobs_.insert(std::make_pair(desc, job));
+  return insertion_result.second;
+}
+
+bool PipelineCompileQueue::HasPendingJobs() {
+  Lock lock(pending_jobs_mutex_);
+  return !pending_jobs_.empty();
+}
+
 fml::closure PipelineCompileQueue::TakeNextJob() {
   Lock lock(pending_jobs_mutex_);
   if (pending_jobs_.empty()) {
diff --git a/engine/src/flutter/impeller/renderer/pipeline_compile_queue.h b/engine/src/flutter/impeller/renderer/pipeline_compile_queue.h
index d166679b3798f..f3ec4ed78e975 100644
--- a/engine/src/flutter/impeller/renderer/pipeline_compile_queue.h
+++ b/engine/src/flutter/impeller/renderer/pipeline_compile_queue.h
@@ -39,13 +39,12 @@ namespace impeller {
 ///             entirely optional. The queue skipping mechanism all assume the
 ///             optional availability of a compile queue.
 ///
-class PipelineCompileQueue final
+class PipelineCompileQueue
     : public std::enable_shared_from_this<PipelineCompileQueue> {
  public:
-  static std::shared_ptr<PipelineCompileQueue> Create(
-      std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner);
+  PipelineCompileQueue() = default;
 
-  ~PipelineCompileQueue();
+  virtual ~PipelineCompileQueue();
 
   PipelineCompileQueue(const PipelineCompileQueue&) = delete;
 
@@ -72,26 +71,34 @@ class PipelineCompileQueue final
   ///
   void PerformJobEagerly(const PipelineDescriptor& desc);
 
+ protected:
+  virtual void PostJob(const fml::closure& job) = 0;
+
+  //----------------------------------------------------------------------------
+  /// @brief      Called by PostJobForDescriptor after a job has been
+  ///             successfully added to the queue. Subclasses must implement
+  ///             this to define their scheduling strategy.
+  ///
+  ///             The default implementation for duplicate descriptors is to
+  ///             run the job eagerly. Subclasses can override this behavior
+  ///             by checking for duplicates before calling the base class.
+  ///
+  virtual void OnJobAdded() = 0;
+
+  void DoOneJob();
+  bool AddJob(const PipelineDescriptor& desc, const fml::closure& job);
+  bool HasPendingJobs();
+
  private:
-  std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner_;
   Mutex pending_jobs_mutex_;
-  size_t priorities_elevated_ = {};
-
   std::unordered_map<PipelineDescriptor,
                      fml::closure,
                      ComparableHash<PipelineDescriptor>,
                      ComparableEqual<PipelineDescriptor>>
       pending_jobs_ IPLR_GUARDED_BY(pending_jobs_mutex_);
-
-  explicit PipelineCompileQueue(
-      std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner);
-
+  size_t priorities_elevated_ = {};
   fml::closure TakeJob(const PipelineDescriptor& desc);
-
   fml::closure TakeNextJob();
-
-  void DoOneJob();
-
   void FinishAllJobs();
 };
 
diff --git a/engine/src/flutter/impeller/renderer/pipeline_compile_queue_unittests.cc b/engine/src/flutter/impeller/renderer/pipeline_compile_queue_unittests.cc
new file mode 100644
index 0000000000000..14be51dcd1556
--- /dev/null
+++ b/engine/src/flutter/impeller/renderer/pipeline_compile_queue_unittests.cc
@@ -0,0 +1,96 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "impeller/renderer/pipeline_compile_queue.h"
+
+#include <memory>
+
+#include "flutter/fml/closure.h"
+#include "flutter/testing/testing.h"
+
+namespace impeller {
+namespace testing {
+
+class TestPipelineCompileQueue : public PipelineCompileQueue {
+ public:
+  void PostJob(const fml::closure& job) override {
+    if (job) {
+      job();
+    }
+  }
+
+  void OnJobAdded() override {}
+
+  bool AddJobForTest(const PipelineDescriptor& desc, const fml::closure& job) {
+    return AddJob(desc, job);
+  }
+
+  bool HasPendingJobsForTest() { return HasPendingJobs(); }
+};
+
+TEST(PipelineCompileQueueTest, AddJobReturnsTrueForNewDescriptor) {
+  TestPipelineCompileQueue queue;
+  PipelineDescriptor desc;
+  bool job_executed = false;
+  fml::closure job = [&job_executed]() { job_executed = true; };
+
+  bool result = queue.AddJobForTest(desc, job);
+  EXPECT_TRUE(result);
+}
+
+TEST(PipelineCompileQueueTest, AddJobReturnsFalseForDuplicateDescriptor) {
+  TestPipelineCompileQueue queue;
+  PipelineDescriptor desc;
+  bool job1_executed = false;
+  bool job2_executed = false;
+  fml::closure job1 = [&job1_executed]() { job1_executed = true; };
+  fml::closure job2 = [&job2_executed]() { job2_executed = true; };
+
+  bool result1 = queue.AddJobForTest(desc, job1);
+  bool result2 = queue.AddJobForTest(desc, job2);
+
+  EXPECT_TRUE(result1);
+  EXPECT_FALSE(result2);
+}
+
+TEST(PipelineCompileQueueTest, HasPendingJobsReturnsCorrectState) {
+  TestPipelineCompileQueue queue;
+  PipelineDescriptor desc;
+  fml::closure job = []() {};
+
+  EXPECT_FALSE(queue.HasPendingJobsForTest());
+
+  queue.AddJobForTest(desc, job);
+  EXPECT_TRUE(queue.HasPendingJobsForTest());
+}
+
+TEST(PipelineCompileQueueTest, PerformJobEagerlyExecutesJob) {
+  TestPipelineCompileQueue queue;
+  PipelineDescriptor desc;
+  bool job_executed = false;
+  fml::closure job = [&job_executed]() { job_executed = true; };
+
+  queue.AddJobForTest(desc, job);
+  queue.PerformJobEagerly(desc);
+
+  EXPECT_TRUE(job_executed);
+  EXPECT_FALSE(queue.HasPendingJobsForTest());
+}
+
+TEST(PipelineCompileQueueTest, FinishAllJobsDrainsQueue) {
+  auto queue = std::make_shared<TestPipelineCompileQueue>();
+  PipelineDescriptor desc;
+  bool job_executed = false;
+  fml::closure job = [&job_executed]() { job_executed = true; };
+
+  queue->AddJobForTest(desc, job);
+  EXPECT_TRUE(queue->HasPendingJobsForTest());
+
+  queue.reset();
+
+  EXPECT_TRUE(job_executed);
+}
+
+}  // namespace testing
+}  // namespace impeller
diff --git a/engine/src/flutter/shell/common/shell_test_platform_view_gl.cc b/engine/src/flutter/shell/common/shell_test_platform_view_gl.cc
index 5ee5e7b18a935..c7da40ba45d1b 100644
--- a/engine/src/flutter/shell/common/shell_test_platform_view_gl.cc
+++ b/engine/src/flutter/shell/common/shell_test_platform_view_gl.cc
@@ -61,7 +61,8 @@ ShellTestPlatformViewGL::ShellTestPlatformViewGL(
       return;
     }
     impeller_context_ = impeller::ContextGLES::Create(
-        impeller::Flags{}, std::move(gl), ShaderLibraryMappings(), true);
+        impeller::Flags{}, std::move(gl), ShaderLibraryMappings(), true,
+        task_runners.GetIOTaskRunner());
   }
 }
 
diff --git a/engine/src/flutter/shell/platform/android/android_context_dynamic_impeller.cc b/engine/src/flutter/shell/platform/android/android_context_dynamic_impeller.cc
index 76d54efec8466..66898fc3e9330 100644
--- a/engine/src/flutter/shell/platform/android/android_context_dynamic_impeller.cc
+++ b/engine/src/flutter/shell/platform/android/android_context_dynamic_impeller.cc
@@ -139,9 +139,11 @@ GetActualRenderingAPIForImpeller(
 }  // namespace
 
 AndroidContextDynamicImpeller::AndroidContextDynamicImpeller(
-    const AndroidContext::ContextSettings& settings)
+    const AndroidContext::ContextSettings& settings,
+    fml::RefPtr<fml::TaskRunner> io_task_runner)
     : AndroidContext(AndroidRenderingAPI::kImpellerVulkan),
-      settings_(settings) {}
+      settings_(settings),
+      io_task_runner_(std::move(io_task_runner)) {}
 
 AndroidContextDynamicImpeller::~AndroidContextDynamicImpeller() = default;
 
@@ -185,7 +187,7 @@ void AndroidContextDynamicImpeller::SetupImpellerContext() {
   if (!vk_context_) {
     gl_context_ = std::make_shared<AndroidContextGLImpeller>(
         std::make_unique<impeller::egl::Display>(),
-        settings_.enable_gpu_tracing);
+        settings_.enable_gpu_tracing, io_task_runner_);
   }
 }
 
diff --git a/engine/src/flutter/shell/platform/android/android_context_dynamic_impeller.h b/engine/src/flutter/shell/platform/android/android_context_dynamic_impeller.h
index 4de037bfa77ba..b6e59b65d0dae 100644
--- a/engine/src/flutter/shell/platform/android/android_context_dynamic_impeller.h
+++ b/engine/src/flutter/shell/platform/android/android_context_dynamic_impeller.h
@@ -23,7 +23,8 @@ namespace flutter {
 class AndroidContextDynamicImpeller : public AndroidContext {
  public:
   explicit AndroidContextDynamicImpeller(
-      const AndroidContext::ContextSettings& settings);
+      const AndroidContext::ContextSettings& settings,
+      fml::RefPtr<fml::TaskRunner> io_task_runner);
 
   ~AndroidContextDynamicImpeller();
 
@@ -51,6 +52,7 @@ class AndroidContextDynamicImpeller : public AndroidContext {
   const AndroidContext::ContextSettings settings_;
   std::shared_ptr<AndroidContextGLImpeller> gl_context_;
   std::shared_ptr<AndroidContextVKImpeller> vk_context_;
+  fml::RefPtr<fml::TaskRunner> io_task_runner_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(AndroidContextDynamicImpeller);
 };
diff --git a/engine/src/flutter/shell/platform/android/android_context_gl_impeller.cc b/engine/src/flutter/shell/platform/android/android_context_gl_impeller.cc
index 79c0ec66bd25b..ce7bb0bf23eba 100644
--- a/engine/src/flutter/shell/platform/android/android_context_gl_impeller.cc
+++ b/engine/src/flutter/shell/platform/android/android_context_gl_impeller.cc
@@ -51,7 +51,8 @@ class AndroidContextGLImpeller::ReactorWorker final
 
 static std::shared_ptr<impeller::Context> CreateImpellerContext(
     const std::shared_ptr<impeller::ReactorGLES::Worker>& worker,
-    bool enable_gpu_tracing) {
+    bool enable_gpu_tracing,
+    fml::RefPtr<fml::TaskRunner> io_task_runner) {
   auto proc_table = std::make_unique<impeller::ProcTableGLES>(
       impeller::egl::CreateProcAddressResolver());
 
@@ -85,11 +86,11 @@ static std::shared_ptr<impeller::Context> CreateImpellerContext(
   auto context = impeller::ContextGLES::Create(
       impeller::Flags{}, std::move(proc_table),
       is_gles3 ? gles3_shader_mappings : gles2_shader_mappings,
-      enable_gpu_tracing);
+      enable_gpu_tracing, io_task_runner);
 #else
-  auto context =
-      impeller::ContextGLES::Create(impeller::Flags{}, std::move(proc_table),
-                                    gles2_shader_mappings, enable_gpu_tracing);
+  auto context = impeller::ContextGLES::Create(
+      impeller::Flags{}, std::move(proc_table), gles2_shader_mappings,
+      enable_gpu_tracing, io_task_runner);
 #endif  // !SLIMPELLER
 
   if (!context) {
@@ -107,10 +108,12 @@ static std::shared_ptr<impeller::Context> CreateImpellerContext(
 
 AndroidContextGLImpeller::AndroidContextGLImpeller(
     std::unique_ptr<impeller::egl::Display> display,
-    bool enable_gpu_tracing)
+    bool enable_gpu_tracing,
+    fml::RefPtr<fml::TaskRunner> io_task_runner)
     : AndroidContext(AndroidRenderingAPI::kImpellerOpenGLES),
       reactor_worker_(std::shared_ptr<ReactorWorker>(new ReactorWorker())),
-      display_(std::move(display)) {
+      display_(std::move(display)),
+      io_task_runner_(std::move(io_task_runner)) {
   if (!display_ || !display_->IsValid()) {
     FML_LOG(ERROR) << "Could not create context with invalid EGL display.";
     return;
@@ -174,8 +177,8 @@ AndroidContextGLImpeller::AndroidContextGLImpeller(
     return;
   }
 
-  auto impeller_context =
-      CreateImpellerContext(reactor_worker_, enable_gpu_tracing);
+  auto impeller_context = CreateImpellerContext(
+      reactor_worker_, enable_gpu_tracing, io_task_runner_);
 
   if (!impeller_context) {
     FML_LOG(ERROR) << "Could not create Impeller context.";
diff --git a/engine/src/flutter/shell/platform/android/android_context_gl_impeller.h b/engine/src/flutter/shell/platform/android/android_context_gl_impeller.h
index e6d68d8444e38..792c8236bb106 100644
--- a/engine/src/flutter/shell/platform/android/android_context_gl_impeller.h
+++ b/engine/src/flutter/shell/platform/android/android_context_gl_impeller.h
@@ -6,6 +6,7 @@
 #define FLUTTER_SHELL_PLATFORM_ANDROID_ANDROID_CONTEXT_GL_IMPELLER_H_
 
 #include "flutter/fml/macros.h"
+#include "flutter/fml/task_runner.h"
 #include "flutter/impeller/toolkit/egl/display.h"
 #include "flutter/shell/platform/android/context/android_context.h"
 
@@ -14,7 +15,8 @@ namespace flutter {
 class AndroidContextGLImpeller : public AndroidContext {
  public:
   AndroidContextGLImpeller(std::unique_ptr<impeller::egl::Display> display,
-                           bool enable_gpu_tracing);
+                           bool enable_gpu_tracing,
+                           fml::RefPtr<fml::TaskRunner> io_task_runner);
 
   ~AndroidContextGLImpeller();
 
@@ -42,6 +44,7 @@ class AndroidContextGLImpeller : public AndroidContext {
   std::unique_ptr<impeller::egl::Context> onscreen_context_;
   std::unique_ptr<impeller::egl::Context> offscreen_context_;
   bool is_valid_ = false;
+  fml::RefPtr<fml::TaskRunner> io_task_runner_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(AndroidContextGLImpeller);
 };
diff --git a/engine/src/flutter/shell/platform/android/platform_view_android.cc b/engine/src/flutter/shell/platform/android/platform_view_android.cc
index 02ed4df41e5c1..ed5b1f9a38a0c 100644
--- a/engine/src/flutter/shell/platform/android/platform_view_android.cc
+++ b/engine/src/flutter/shell/platform/android/platform_view_android.cc
@@ -108,7 +108,8 @@ static std::shared_ptr<flutter::AndroidContext> CreateAndroidContext(
     const flutter::TaskRunners& task_runners,
     AndroidRenderingAPI android_rendering_api,
     bool enable_opengl_gpu_tracing,
-    const AndroidContext::ContextSettings& settings) {
+    const AndroidContext::ContextSettings& settings,
+    fml::RefPtr<fml::TaskRunner> io_task_runner) {
   switch (android_rendering_api) {
 #if !SLIMPELLER
     case AndroidRenderingAPI::kSoftware:
@@ -123,11 +124,12 @@ static std::shared_ptr<flutter::AndroidContext> CreateAndroidContext(
       return std::make_unique<AndroidContextVKImpeller>(settings);
     case AndroidRenderingAPI::kImpellerOpenGLES:
       return std::make_unique<AndroidContextGLImpeller>(
-          std::make_unique<impeller::egl::Display>(),
-          enable_opengl_gpu_tracing);
+          std::make_unique<impeller::egl::Display>(), enable_opengl_gpu_tracing,
+          io_task_runner);
     case AndroidRenderingAPI::kImpellerAutoselect:
       // Determine if we're using GL or Vulkan.
-      return std::make_unique<AndroidContextDynamicImpeller>(settings);
+      return std::make_unique<AndroidContextDynamicImpeller>(settings,
+                                                             io_task_runner);
   }
   FML_UNREACHABLE();
 }
@@ -145,7 +147,8 @@ PlatformViewAndroid::PlatformViewAndroid(
               task_runners,
               rendering_api,
               delegate.OnPlatformViewGetSettings().enable_opengl_gpu_tracing,
-              CreateContextSettings(delegate.OnPlatformViewGetSettings()))) {}
+              CreateContextSettings(delegate.OnPlatformViewGetSettings()),
+              task_runners.GetIOTaskRunner())) {}
 
 PlatformViewAndroid::PlatformViewAndroid(
     PlatformView::Delegate& delegate,
diff --git a/engine/src/flutter/shell/platform/embedder/embedder.cc b/engine/src/flutter/shell/platform/embedder/embedder.cc
index 190eb63969f04..41970ce55c6d6 100644
--- a/engine/src/flutter/shell/platform/embedder/embedder.cc
+++ b/engine/src/flutter/shell/platform/embedder/embedder.cc
@@ -492,7 +492,8 @@ InferOpenGLPlatformViewCreationCallback(
               shell.GetTaskRunners(),  // task runners
               std::make_unique<flutter::EmbedderSurfaceGLImpeller>(
                   gl_dispatch_table, fbo_reset_after_present,
-                  view_embedder),       // embedder_surface
+                  view_embedder,  // embedder_surface
+                  shell.GetTaskRunners().GetIOTaskRunner()),  // io_task_runner
               platform_dispatch_table,  // embedder platform dispatch table
               view_embedder             // external view embedder
           );
diff --git a/engine/src/flutter/shell/platform/embedder/embedder_surface_gl_impeller.cc b/engine/src/flutter/shell/platform/embedder/embedder_surface_gl_impeller.cc
index 3832a69e3f3fc..42494a5575ce9 100644
--- a/engine/src/flutter/shell/platform/embedder/embedder_surface_gl_impeller.cc
+++ b/engine/src/flutter/shell/platform/embedder/embedder_surface_gl_impeller.cc
@@ -64,7 +64,8 @@ class ReactorWorker final : public impeller::ReactorGLES::Worker {
 EmbedderSurfaceGLImpeller::EmbedderSurfaceGLImpeller(
     EmbedderSurfaceGLSkia::GLDispatchTable gl_dispatch_table,
     bool fbo_reset_after_present,
-    std::shared_ptr<EmbedderExternalViewEmbedder> external_view_embedder)
+    std::shared_ptr<EmbedderExternalViewEmbedder> external_view_embedder,
+    fml::RefPtr<fml::TaskRunner> io_task_runner)
     : gl_dispatch_table_(std::move(gl_dispatch_table)),
       fbo_reset_after_present_(fbo_reset_after_present),
       external_view_embedder_(std::move(external_view_embedder)),
@@ -92,7 +93,7 @@ EmbedderSurfaceGLImpeller::EmbedderSurfaceGLImpeller(
 
   impeller_context_ = impeller::ContextGLES::Create(
       impeller::Flags{}, std::move(gl), shader_mappings,
-      /*enable_gpu_tracing=*/false);
+      /*enable_gpu_tracing=*/false, std::move(io_task_runner));
 
   if (!impeller_context_) {
     FML_LOG(ERROR) << "Could not create Impeller context.";
diff --git a/engine/src/flutter/shell/platform/embedder/embedder_surface_gl_impeller.h b/engine/src/flutter/shell/platform/embedder/embedder_surface_gl_impeller.h
index 274e1ccb38f70..73db083573347 100644
--- a/engine/src/flutter/shell/platform/embedder/embedder_surface_gl_impeller.h
+++ b/engine/src/flutter/shell/platform/embedder/embedder_surface_gl_impeller.h
@@ -30,7 +30,8 @@ class EmbedderSurfaceGLImpeller final : public EmbedderSurface,
   EmbedderSurfaceGLImpeller(
       EmbedderSurfaceGLSkia::GLDispatchTable gl_dispatch_table,
       bool fbo_reset_after_present,
-      std::shared_ptr<EmbedderExternalViewEmbedder> external_view_embedder);
+      std::shared_ptr<EmbedderExternalViewEmbedder> external_view_embedder,
+      fml::RefPtr<fml::TaskRunner> io_task_runner);
 
   ~EmbedderSurfaceGLImpeller() override;