diff --git a/BUILD.gn b/BUILD.gn
index 9916427..9d290a0 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -452,6 +452,16 @@
         "src/dawn_native/vulkan/external_semaphore/SemaphoreServiceNull.cpp",
       ]
     }
+    if (build_with_chromium && is_fuchsia) {
+      # Necessary to ensure that the Vulkan libraries will be in the
+      # final Fuchsia package.
+      data_deps = [
+        # NOTE: The line below is a work around for http://crbug.com/1001081
+        "//third_party/fuchsia-sdk/sdk:trace_engine",
+        "//third_party/fuchsia-sdk:vulkan_base",
+        "//third_party/fuchsia-sdk:vulkan_validation",
+      ]
+    }
   }
 }
 
@@ -560,6 +570,47 @@
 }
 
 ###############################################################################
+# GLFW wrapping target
+###############################################################################
+
+# GLFW does not support Android or Fuchsia, so provide a small mock library
+# that can be linked into the Dawn tests on these platforms. Otherwise, use
+# the real library from third_party/.
+if (is_fuchsia) {
+  config("dawn_glfw_public_config") {
+    # Allow inclusion of <GLFW/glfw3.h>
+    configs = [ "third_party:glfw_public" ]
+
+    # The GLFW/glfw3.h header includes <GL/gl.h> by default, but the latter
+    # does not exist on Fuchsia. Defining GLFW_INCLUDE_NONE helps work around
+    # the issue, but it needs to be defined for any file that includes the
+    # header.
+    defines = [
+      "GLFW_INCLUDE_NONE",
+      "GLFW_INCLUDE_VULKAN",
+    ]
+  }
+
+  static_library("dawn_glfw") {
+    sources = [
+      # NOTE: The header below is required to pass "gn check".
+      "${dawn_glfw_dir}/include/GLFW/glfw3.h",
+      "src/utils/Glfw3Fuchsia.cpp",
+    ]
+    public_configs = [ ":dawn_glfw_public_config" ]
+    deps = [
+      "${dawn_root}/src/common",
+    ]
+  }
+} else {
+  group("dawn_glfw") {
+    public_deps = [
+      "third_party:glfw",
+    ]
+  }
+}
+
+###############################################################################
 # Utils for tests and samples
 ###############################################################################
 
@@ -613,9 +664,9 @@
   ]
 
   deps = [
+    ":dawn_glfw",
     ":libdawn_native",
     "${dawn_root}/src/common",
-    "third_party:glfw",
   ]
   libs = []
 
@@ -756,6 +807,7 @@
   testonly = true
 
   deps = [
+    ":dawn_glfw",
     ":dawn_utils",
     ":libdawn_native",
     ":libdawn_wire",
@@ -823,7 +875,7 @@
   }
 
   if (dawn_enable_opengl) {
-    deps += [ "third_party:glfw" ]
+    deps += [ ":dawn_glfw" ]
   }
 }
 
@@ -854,7 +906,7 @@
   }
 
   if (dawn_enable_opengl) {
-    deps += [ "third_party:glfw" ]
+    deps += [ ":dawn_glfw" ]
   }
 
   libs = []
@@ -890,7 +942,7 @@
   }
 
   if (dawn_enable_opengl) {
-    deps += [ "third_party:glfw" ]
+    deps += [ ":dawn_glfw" ]
   }
 }
 
@@ -930,7 +982,7 @@
   }
 
   if (dawn_enable_opengl) {
-    deps += [ "third_party:glfw" ]
+    deps += [ ":dawn_glfw" ]
   }
 }
 
@@ -974,12 +1026,12 @@
     # Export all of these as public deps so that `gn check` allows includes
     public_deps = [
       ":dawn_bindings",
+      ":dawn_glfw",
       ":dawn_utils",
       ":libdawn_native",
       ":libdawn_wire",
       "${dawn_root}/src/common",
       "${dawn_root}/src/dawn:libdawn",
-      "third_party:glfw",
     ]
     public_configs = [ "${dawn_root}/src/common:dawn_internal" ]
   }
diff --git a/scripts/dawn_features.gni b/scripts/dawn_features.gni
index a74942b..6897304 100644
--- a/scripts/dawn_features.gni
+++ b/scripts/dawn_features.gni
@@ -36,5 +36,5 @@
   dawn_enable_opengl = is_linux && !is_chromeos
 
   # Enables the compilation of Dawn's Vulkan backend
-  dawn_enable_vulkan = is_linux || is_win
+  dawn_enable_vulkan = is_linux || is_win || is_fuchsia
 }
diff --git a/src/common/BUILD.gn b/src/common/BUILD.gn
index 9093e82..2566b08 100644
--- a/src/common/BUILD.gn
+++ b/src/common/BUILD.gn
@@ -76,7 +76,7 @@
 # This GN file is discovered by all Chromium builds, but common doesn't support
 # all of Chromium's OSes so we explicitly make the target visible only on
 # systems we know Dawn is able to compile on.
-if (is_win || is_linux || is_mac) {
+if (is_win || is_linux || is_mac || is_fuchsia) {
   static_library("common") {
     sources = [
       "Assert.cpp",
diff --git a/src/dawn_native/vulkan/BackendVk.cpp b/src/dawn_native/vulkan/BackendVk.cpp
index dff6bbe..398569d 100644
--- a/src/dawn_native/vulkan/BackendVk.cpp
+++ b/src/dawn_native/vulkan/BackendVk.cpp
@@ -25,6 +25,8 @@
 const char kVulkanLibName[] = "libvulkan.so.1";
 #elif DAWN_PLATFORM_WINDOWS
 const char kVulkanLibName[] = "vulkan-1.dll";
+#elif DAWN_PLATFORM_FUCHSIA
+const char kVulkanLibName[] = "libvulkan.so";
 #else
 #    error "Unimplemented Vulkan backend platform"
 #endif
@@ -136,6 +138,11 @@
             }
         }
 
+        if (mGlobalInfo.fuchsiaImagePipeSwapchain) {
+            layersToRequest.push_back(kLayerNameFuchsiaImagePipeSwapchain);
+            usedKnobs.fuchsiaImagePipeSwapchain = true;
+        }
+
         // Always request all extensions used to create VkSurfaceKHR objects so that they are
         // always available for embedders looking to create VkSurfaceKHR on our VkInstance.
         if (mGlobalInfo.macosSurface) {
@@ -174,6 +181,10 @@
             extensionsToRequest.push_back(kExtensionNameKhrXlibSurface);
             usedKnobs.xlibSurface = true;
         }
+        if (mGlobalInfo.fuchsiaImagePipeSurface) {
+            extensionsToRequest.push_back(kExtensionNameFuchsiaImagePipeSurface);
+            usedKnobs.fuchsiaImagePipeSurface = true;
+        }
 
         VkApplicationInfo appInfo;
         appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
diff --git a/src/dawn_native/vulkan/VulkanFunctions.cpp b/src/dawn_native/vulkan/VulkanFunctions.cpp
index 0d36776..c6647a0 100644
--- a/src/dawn_native/vulkan/VulkanFunctions.cpp
+++ b/src/dawn_native/vulkan/VulkanFunctions.cpp
@@ -103,6 +103,12 @@
             GET_INSTANCE_PROC(GetPhysicalDeviceSurfacePresentModesKHR);
         }
 
+#ifdef VK_USE_PLATFORM_FUCHSIA
+        if (globalInfo.fuchsiaImagePipeSurface) {
+            GET_INSTANCE_PROC(CreateImagePipeSurfaceFUCHSIA);
+        }
+#endif
+
         return {};
     }
 
diff --git a/src/dawn_native/vulkan/VulkanFunctions.h b/src/dawn_native/vulkan/VulkanFunctions.h
index b1f24f1..8638a7b 100644
--- a/src/dawn_native/vulkan/VulkanFunctions.h
+++ b/src/dawn_native/vulkan/VulkanFunctions.h
@@ -106,6 +106,11 @@
         PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR
             GetPhysicalDeviceSparseImageFormatProperties2KHR = nullptr;
 
+#ifdef VK_USE_PLATFORM_FUCHSIA
+        // FUCHSIA_image_pipe_surface
+        PFN_vkCreateImagePipeSurfaceFUCHSIA CreateImagePipeSurfaceFUCHSIA = nullptr;
+#endif
+
         // ---------- Device procs
 
         // Core Vulkan 1.0
diff --git a/src/dawn_native/vulkan/VulkanInfo.cpp b/src/dawn_native/vulkan/VulkanInfo.cpp
index f4f0284..0e21bb0 100644
--- a/src/dawn_native/vulkan/VulkanInfo.cpp
+++ b/src/dawn_native/vulkan/VulkanInfo.cpp
@@ -27,6 +27,22 @@
     bool IsExtensionName(const VkExtensionProperties& extension, const char* name) {
         return strncmp(extension.extensionName, name, VK_MAX_EXTENSION_NAME_SIZE) == 0;
     }
+
+    bool EnumerateInstanceExtensions(const char* layerName,
+                                     const dawn_native::vulkan::VulkanFunctions& vkFunctions,
+                                     std::vector<VkExtensionProperties>* extensions) {
+        uint32_t count = 0;
+        VkResult result =
+            vkFunctions.EnumerateInstanceExtensionProperties(layerName, &count, nullptr);
+        if (result != VK_SUCCESS && result != VK_INCOMPLETE) {
+            return false;
+        }
+        extensions->resize(count);
+        result =
+            vkFunctions.EnumerateInstanceExtensionProperties(layerName, &count, extensions->data());
+        return (result == VK_SUCCESS);
+    }
+
 }  // namespace
 
 namespace dawn_native { namespace vulkan {
@@ -34,6 +50,7 @@
     const char kLayerNameLunargStandardValidation[] = "VK_LAYER_LUNARG_standard_validation";
     const char kLayerNameLunargVKTrace[] = "VK_LAYER_LUNARG_vktrace";
     const char kLayerNameRenderDocCapture[] = "VK_LAYER_RENDERDOC_Capture";
+    const char kLayerNameFuchsiaImagePipeSwapchain[] = "VK_LAYER_FUCHSIA_imagepipe_swapchain";
 
     const char kExtensionNameExtDebugMarker[] = "VK_EXT_debug_marker";
     const char kExtensionNameExtDebugReport[] = "VK_EXT_debug_report";
@@ -54,6 +71,7 @@
     const char kExtensionNameKhrWin32Surface[] = "VK_KHR_win32_surface";
     const char kExtensionNameKhrXcbSurface[] = "VK_KHR_xcb_surface";
     const char kExtensionNameKhrXlibSurface[] = "VK_KHR_xlib_surface";
+    const char kExtensionNameFuchsiaImagePipeSurface[] = "VK_FUCHSIA_imagepipe_surface";
 
     ResultOrError<VulkanGlobalInfo> GatherGlobalInfo(const Backend& backend) {
         VulkanGlobalInfo info = {};
@@ -86,22 +104,18 @@
                 if (IsLayerName(layer, kLayerNameRenderDocCapture)) {
                     info.renderDocCapture = true;
                 }
+                // Technical note: Fuchsia implements the swapchain through
+                // a layer (VK_LAYER_FUCHSIA_image_pipe_swapchain), which adds
+                // an instance extensions (VK_FUCHSIA_image_surface) to all ICDs.
+                if (IsLayerName(layer, kLayerNameFuchsiaImagePipeSwapchain)) {
+                    info.fuchsiaImagePipeSwapchain = true;
+                }
             }
         }
 
         // Gather the info about the instance extensions
         {
-            uint32_t count = 0;
-            VkResult result =
-                vkFunctions.EnumerateInstanceExtensionProperties(nullptr, &count, nullptr);
-            if (result != VK_SUCCESS && result != VK_INCOMPLETE) {
-                return DAWN_DEVICE_LOST_ERROR("vkEnumerateInstanceExtensionProperties");
-            }
-
-            info.extensions.resize(count);
-            result = vkFunctions.EnumerateInstanceExtensionProperties(nullptr, &count,
-                                                                      info.extensions.data());
-            if (result != VK_SUCCESS) {
+            if (!EnumerateInstanceExtensions(nullptr, vkFunctions, &info.extensions)) {
                 return DAWN_DEVICE_LOST_ERROR("vkEnumerateInstanceExtensionProperties");
             }
 
@@ -136,6 +150,27 @@
                 if (IsExtensionName(extension, kExtensionNameKhrXlibSurface)) {
                     info.xlibSurface = true;
                 }
+                if (IsExtensionName(extension, kExtensionNameFuchsiaImagePipeSurface)) {
+                    info.fuchsiaImagePipeSurface = true;
+                }
+            }
+        }
+
+        // Specific handling for the Fuchsia swapchain surface creation extension
+        // which is normally part of the Fuchsia-specific swapchain layer.
+        if (info.fuchsiaImagePipeSwapchain && !info.fuchsiaImagePipeSurface) {
+            std::vector<VkExtensionProperties> layer_extensions;
+            if (!EnumerateInstanceExtensions(kLayerNameFuchsiaImagePipeSwapchain, vkFunctions,
+                                             &layer_extensions)) {
+                return DAWN_DEVICE_LOST_ERROR("vkEnumerateInstanceExtensionProperties");
+            }
+
+            for (const auto& extension : layer_extensions) {
+                if (IsExtensionName(extension, kExtensionNameFuchsiaImagePipeSurface)) {
+                    info.fuchsiaImagePipeSurface = true;
+                    // For now, copy this to the global extension list.
+                    info.extensions.push_back(extension);
+                }
             }
         }
 
diff --git a/src/dawn_native/vulkan/VulkanInfo.h b/src/dawn_native/vulkan/VulkanInfo.h
index 48bcd9a..69b9f1f 100644
--- a/src/dawn_native/vulkan/VulkanInfo.h
+++ b/src/dawn_native/vulkan/VulkanInfo.h
@@ -28,6 +28,7 @@
     extern const char kLayerNameLunargStandardValidation[];
     extern const char kLayerNameLunargVKTrace[];
     extern const char kLayerNameRenderDocCapture[];
+    extern const char kLayerNameFuchsiaImagePipeSwapchain[];
 
     extern const char kExtensionNameExtDebugMarker[];
     extern const char kExtensionNameExtDebugReport[];
@@ -45,6 +46,7 @@
     extern const char kExtensionNameKhrWin32Surface[];
     extern const char kExtensionNameKhrXcbSurface[];
     extern const char kExtensionNameKhrXlibSurface[];
+    extern const char kExtensionNameFuchsiaImagePipeSurface[];
 
     // Global information - gathered before the instance is created
     struct VulkanGlobalKnobs {
@@ -52,6 +54,7 @@
         bool standardValidation = false;
         bool vktrace = false;
         bool renderDocCapture = false;
+        bool fuchsiaImagePipeSwapchain = false;
 
         // Extensions
         bool debugReport = false;
@@ -64,6 +67,7 @@
         bool win32Surface = false;
         bool xcbSurface = false;
         bool xlibSurface = false;
+        bool fuchsiaImagePipeSurface = false;
     };
 
     struct VulkanGlobalInfo : VulkanGlobalKnobs {
diff --git a/src/utils/Glfw3Fuchsia.cpp b/src/utils/Glfw3Fuchsia.cpp
new file mode 100644
index 0000000..cc8ed3b
--- /dev/null
+++ b/src/utils/Glfw3Fuchsia.cpp
@@ -0,0 +1,100 @@
+// Copyright 2019 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// A mock GLFW implementation that supports Fuchsia, but only implements
+// the functions called from Dawn.
+
+// NOTE: This must be included before GLFW/glfw3.h because the latter will
+// include <vulkan/vulkan.h> and "common/vulkan_platform.h" wants to be
+// the first header to do so for sanity reasons (e.g. undefining weird
+// macros on Windows and Linux).
+// clang-format off
+#include "common/vulkan_platform.h"
+#include "common/Assert.h"
+#include <GLFW/glfw3.h>
+// clang-format on
+
+#include <dlfcn.h>
+
+int glfwInit(void) {
+    return GLFW_TRUE;
+}
+
+void glfwDefaultWindowHints(void) {
+}
+
+void glfwWindowHint(int hint, int value) {
+    DAWN_UNUSED(hint);
+    DAWN_UNUSED(value);
+}
+
+struct GLFWwindow {
+    PFN_vkGetInstanceProcAddr GetInstanceProcAddress = nullptr;
+    void* vulkan_loader = nullptr;
+
+    GLFWwindow() {
+        vulkan_loader = ::dlopen("libvulkan.so", RTLD_NOW);
+        ASSERT(vulkan_loader != nullptr);
+        GetInstanceProcAddress = reinterpret_cast<PFN_vkGetInstanceProcAddr>(
+            dlsym(vulkan_loader, "vkGetInstanceProcAddr"));
+        ASSERT(GetInstanceProcAddress != nullptr);
+    }
+
+    ~GLFWwindow() {
+        if (vulkan_loader) {
+            ::dlclose(vulkan_loader);
+        }
+        vulkan_loader = nullptr;
+    }
+};
+
+GLFWwindow* glfwCreateWindow(int width,
+                             int height,
+                             const char* title,
+                             GLFWmonitor* monitor,
+                             GLFWwindow* share) {
+    ASSERT(monitor == nullptr);
+    ASSERT(share == nullptr);
+    DAWN_UNUSED(width);
+    DAWN_UNUSED(height);
+    DAWN_UNUSED(title);
+    return new GLFWwindow();
+}
+
+VkResult glfwCreateWindowSurface(VkInstance instance,
+                                 GLFWwindow* window,
+                                 const VkAllocationCallbacks* allocator,
+                                 VkSurfaceKHR* surface) {
+    // IMPORTANT: This assumes that the VkInstance was created with a Fuchsia
+    // swapchain layer enabled, as well as the corresponding extension that
+    // is queried here to perform the surface creation. Dawn should do all
+    // required steps in VulkanInfo.cpp, VulkanFunctions.cpp and BackendVk.cpp.
+
+    auto vkCreateImagePipeSurfaceFUCHSIA = reinterpret_cast<PFN_vkCreateImagePipeSurfaceFUCHSIA>(
+        window->GetInstanceProcAddress(instance, "vkCreateImagePipeSurfaceFUCHSIA"));
+    ASSERT(vkCreateImagePipeSurfaceFUCHSIA != nullptr);
+    if (!vkCreateImagePipeSurfaceFUCHSIA) {
+        *surface = VK_NULL_HANDLE;
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    const struct VkImagePipeSurfaceCreateInfoFUCHSIA create_info = {
+        VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
+        nullptr,            // pNext
+        0,                  // flags, ignored for now
+        ZX_HANDLE_INVALID,  // imagePipeHandle, a null handle matches the framebuffer.
+    };
+
+    return vkCreateImagePipeSurfaceFUCHSIA(instance, &create_info, nullptr, surface);
+}