diff --git a/include/mbgl/storage/network_status.hpp b/include/mbgl/storage/network_status.hpp
index cac2ae193..a1c417c4c 100644
--- a/include/mbgl/storage/network_status.hpp
+++ b/include/mbgl/storage/network_status.hpp
@@ -4,22 +4,24 @@
 #include <mutex>
 #include <set>
 
-typedef struct uv_async_s uv_async_t;
-
 namespace mbgl {
 
+namespace util {
+class AsyncTask;
+}
+
 class NetworkStatus {
 public:
     static void Reachable();
 
-    static void Subscribe(uv_async_t *async);
-    static void Unsubscribe(uv_async_t *async);
+    static void Subscribe(util::AsyncTask* async);
+    static void Unsubscribe(util::AsyncTask* async);
 
 private:
     static std::mutex mtx;
-    static std::set<uv_async_t *> observers;
+    static std::set<util::AsyncTask*> observers;
 };
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/platform/default/asset_request_fs.cpp b/platform/default/asset_request_fs.cpp
index 955f8d802..e86b8bd8d 100644
--- a/platform/default/asset_request_fs.cpp
+++ b/platform/default/asset_request_fs.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/storage/asset_context_base.hpp>
 #include <mbgl/storage/resource.hpp>
 #include <mbgl/storage/response.hpp>
+#include <mbgl/util/run_loop.hpp>
 #include <mbgl/util/util.hpp>
 #include <mbgl/util/url.hpp>
 #include <mbgl/util/uv.hpp>
@@ -17,7 +18,7 @@ class AssetRequest : public RequestBase {
     MBGL_STORE_THREAD(tid)
 
 public:
-    AssetRequest(const Resource&, Callback, uv_loop_t*, const std::string& assetRoot);
+    AssetRequest(const Resource&, Callback, const std::string& assetRoot);
     ~AssetRequest();
 
     void cancel() final;
@@ -40,9 +41,8 @@ public:
 class AssetFSContext : public AssetContextBase {
     RequestBase* createRequest(const Resource& resource,
                                RequestBase::Callback callback,
-                               uv_loop_t* loop,
                                const std::string& assetRoot) final {
-        return new AssetRequest(resource, callback, loop, assetRoot);
+        return new AssetRequest(resource, callback, assetRoot);
     }
 };
 
@@ -50,7 +50,7 @@ AssetRequest::~AssetRequest() {
     MBGL_VERIFY_THREAD(tid);
 }
 
-AssetRequest::AssetRequest(const Resource& resource_, Callback callback_, uv_loop_t* loop, const std::string& assetRoot_)
+AssetRequest::AssetRequest(const Resource& resource_, Callback callback_, const std::string& assetRoot_)
     : RequestBase(resource_, callback_),
       assetRoot(assetRoot_) {
     req.data = this;
@@ -65,6 +65,7 @@ AssetRequest::AssetRequest(const Resource& resource_, Callback callback_, uv_loo
         path = assetRoot + "/" + mbgl::util::percentDecode(url.substr(8));
     }
 
+    auto loop = static_cast<uv_loop_t*>(util::RunLoop::getLoopHandle());
     uv_fs_open(loop, &req, path.c_str(), O_RDONLY, S_IRUSR, fileOpened);
 }
 
@@ -217,7 +218,7 @@ void AssetRequest::cancel() {
     uv_cancel((uv_req_t *)&req);
 }
 
-std::unique_ptr<AssetContextBase> AssetContextBase::createContext(uv_loop_t*) {
+std::unique_ptr<AssetContextBase> AssetContextBase::createContext() {
     return std::make_unique<AssetFSContext>();
 }
 
diff --git a/platform/default/asset_request_zip.cpp b/platform/default/asset_request_zip.cpp
index b8007b569..fb7a9c4a3 100644
--- a/platform/default/asset_request_zip.cpp
+++ b/platform/default/asset_request_zip.cpp
@@ -6,6 +6,7 @@
 #include <mbgl/util/chrono.hpp>
 #include <mbgl/util/util.hpp>
 #include <mbgl/util/uv.hpp>
+#include <mbgl/util/run_loop.hpp>
 
 #include <uv.h>
 #include "uv_zip.h"
@@ -18,12 +19,11 @@ namespace mbgl {
 
 class AssetZipContext : public AssetContextBase {
 public:
-    explicit AssetZipContext(uv_loop_t *loop);
+    explicit AssetZipContext();
     ~AssetZipContext();
 
     RequestBase* createRequest(const Resource& resource,
                                RequestBase::Callback callback,
-                               uv_loop_t* loop,
                                const std::string& assetRoot) final;
 
     uv_zip_t *getHandle(const std::string &path);
@@ -34,7 +34,7 @@ public:
     uv_loop_t *loop;
 };
 
-AssetZipContext::AssetZipContext(uv_loop_t *loop_) : loop(loop_) {
+AssetZipContext::AssetZipContext() : loop(static_cast<uv_loop_t*>(util::RunLoop::getLoopHandle())) {
 }
 
 uv_zip_t *AssetZipContext::getHandle(const std::string &path) {
@@ -96,7 +96,6 @@ private:
 
 RequestBase* AssetZipContext::createRequest(const Resource& resource,
                                             RequestBase::Callback callback,
-                                            uv_loop_t*,
                                             const std::string& assetRoot) {
     return new AssetRequest(*this, resource, callback, assetRoot);
 }
@@ -260,8 +259,8 @@ void AssetRequest::cancel() {
     cancelled = true;
 }
 
-std::unique_ptr<AssetContextBase> AssetContextBase::createContext(uv_loop_t* loop) {
-    return std::make_unique<AssetZipContext>(loop);
+std::unique_ptr<AssetContextBase> AssetContextBase::createContext() {
+    return std::make_unique<AssetZipContext>();
 }
 
 }
diff --git a/src/mbgl/storage/asset_context_base.hpp b/src/mbgl/storage/asset_context_base.hpp
index cd7d9ff4a..4a6ca0b6f 100644
--- a/src/mbgl/storage/asset_context_base.hpp
+++ b/src/mbgl/storage/asset_context_base.hpp
@@ -3,18 +3,15 @@
 
 #include <mbgl/storage/request_base.hpp>
 
-typedef struct uv_loop_s uv_loop_t;
-
 namespace mbgl {
 
 class AssetContextBase {
 public:
-    static std::unique_ptr<AssetContextBase> createContext(uv_loop_t*);
+    static std::unique_ptr<AssetContextBase> createContext();
 
     virtual ~AssetContextBase() = default;
     virtual RequestBase* createRequest(const Resource&,
                                        RequestBase::Callback,
-                                       uv_loop_t*,
                                        const std::string& assetRoot) = 0;
 };
 
diff --git a/src/mbgl/storage/default_file_source.cpp b/src/mbgl/storage/default_file_source.cpp
index 439acd888..63a0e329f 100644
--- a/src/mbgl/storage/default_file_source.cpp
+++ b/src/mbgl/storage/default_file_source.cpp
@@ -78,21 +78,20 @@ void DefaultFileSource::cancel(const Resource& res, FileRequest* req) {
 // ----- Impl -----
 
 DefaultFileSource::Impl::Impl(FileCache* cache_, const std::string& root)
-    : loop(reinterpret_cast<uv_loop_t*>(util::RunLoop::getLoopHandle())),
-      cache(cache_),
+    : cache(cache_),
       assetRoot(root.empty() ? platform::assetRoot() : root),
-      assetContext(AssetContextBase::createContext(loop)),
-      httpContext(HTTPContextBase::createContext(loop)),
-      reachability(std::make_unique<uv::async>(loop, std::bind(&Impl::networkIsReachableAgain, this))) {
+      assetContext(AssetContextBase::createContext()),
+      httpContext(HTTPContextBase::createContext()),
+      reachability(std::bind(&Impl::networkIsReachableAgain, this)) {
     // Subscribe to network status changes, but make sure that this async handle doesn't keep the
     // loop alive; otherwise our app wouldn't terminate. After all, we only need status change
     // notifications when our app is still running.
-    NetworkStatus::Subscribe(reachability->get());
-    reachability->unref();
+    NetworkStatus::Subscribe(&reachability);
+    reachability.unref();
 }
 
 DefaultFileSource::Impl::~Impl() {
-    NetworkStatus::Unsubscribe(reachability->get());
+    NetworkStatus::Unsubscribe(&reachability);
 }
 
 void DefaultFileSource::Impl::networkIsReachableAgain() {
@@ -202,10 +201,10 @@ void DefaultFileSource::Impl::startRealRequest(DefaultFileRequestImpl& request)
 
     if (algo::starts_with(request.resource.url, "asset://")) {
         request.realRequest =
-            assetContext->createRequest(request.resource, callback, loop, assetRoot);
+            assetContext->createRequest(request.resource, callback, assetRoot);
     } else {
         request.realRequest =
-            httpContext->createRequest(request.resource, callback, loop, request.getResponse());
+            httpContext->createRequest(request.resource, callback, request.getResponse());
     }
 }
 
diff --git a/src/mbgl/storage/default_file_source_impl.hpp b/src/mbgl/storage/default_file_source_impl.hpp
index 771274b7a..9580d4e78 100644
--- a/src/mbgl/storage/default_file_source_impl.hpp
+++ b/src/mbgl/storage/default_file_source_impl.hpp
@@ -4,6 +4,7 @@
 #include <mbgl/storage/default_file_source.hpp>
 #include <mbgl/storage/asset_context_base.hpp>
 #include <mbgl/storage/http_context_base.hpp>
+#include <mbgl/util/async_task.hpp>
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/chrono.hpp>
 
@@ -101,12 +102,11 @@ private:
     void reschedule(DefaultFileRequestImpl&);
 
     std::unordered_map<Resource, std::unique_ptr<DefaultFileRequestImpl>, Resource::Hash> pending;
-    uv_loop_t* const loop;
     FileCache* const cache;
     const std::string assetRoot;
     const std::unique_ptr<AssetContextBase> assetContext;
     const std::unique_ptr<HTTPContextBase> httpContext;
-    const std::unique_ptr<uv::async> reachability;
+    util::AsyncTask reachability;
 };
 
 }
diff --git a/src/mbgl/storage/http_context_base.hpp b/src/mbgl/storage/http_context_base.hpp
index fd6e444ee..7fbef719f 100644
--- a/src/mbgl/storage/http_context_base.hpp
+++ b/src/mbgl/storage/http_context_base.hpp
@@ -4,7 +4,6 @@
 #include <mbgl/storage/request_base.hpp>
 #include <mbgl/storage/http_request_base.hpp>
 #include <mbgl/storage/network_status.hpp>
-#include <mbgl/util/uv_detail.hpp>
 
 #include <set>
 
@@ -12,12 +11,11 @@ namespace mbgl {
 
 class HTTPContextBase {
 public:
-    static std::unique_ptr<HTTPContextBase> createContext(uv_loop_t*);
+    static std::unique_ptr<HTTPContextBase> createContext();
 
     virtual ~HTTPContextBase() = default;
     virtual HTTPRequestBase* createRequest(const Resource&,
                                        RequestBase::Callback,
-                                       uv_loop_t*,
                                        std::shared_ptr<const Response>) = 0;
 };
 
diff --git a/src/mbgl/storage/network_status.cpp b/src/mbgl/storage/network_status.cpp
index 04b6937d9..11f89f073 100644
--- a/src/mbgl/storage/network_status.cpp
+++ b/src/mbgl/storage/network_status.cpp
@@ -1,6 +1,6 @@
 #include <mbgl/storage/network_status.hpp>
 
-#include <uv.h>
+#include <mbgl/util/async_task.hpp>
 
 // Example: Allocate a reachability object
 // Reachability* reach = [Reachability reachabilityForInternetConnection];
@@ -10,14 +10,14 @@
 namespace mbgl {
 
 std::mutex NetworkStatus::mtx;
-std::set<uv_async_t *> NetworkStatus::observers;
+std::set<util::AsyncTask *> NetworkStatus::observers;
 
-void NetworkStatus::Subscribe(uv_async_t *async) {
+void NetworkStatus::Subscribe(util::AsyncTask *async) {
     std::lock_guard<std::mutex> lock(NetworkStatus::mtx);
     observers.insert(async);
 }
 
-void NetworkStatus::Unsubscribe(uv_async_t *async) {
+void NetworkStatus::Unsubscribe(util::AsyncTask *async) {
     std::lock_guard<std::mutex> lock(NetworkStatus::mtx);
     observers.erase(async);
 }
@@ -25,7 +25,7 @@ void NetworkStatus::Unsubscribe(uv_async_t *async) {
 void NetworkStatus::Reachable() {
     std::lock_guard<std::mutex> lock(NetworkStatus::mtx);
     for (auto async : observers) {
-        uv_async_send(async);
+        async->send();
     }
 }