diff --git a/BUILD.gn b/BUILD.gn
index 91b64f5..ea12460 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -745,10 +745,15 @@
   target = "dawn_wire"
   outputs = [
     "dawn_wire/TypeTraits_autogen.h",
-    "dawn_wire/WireServer.cpp",
     "dawn_wire/WireCmd_autogen.h",
-    "dawn_wire/WireClient.cpp",
     "dawn_wire/WireCmd_autogen.cpp",
+    "dawn_wire/WireServer.cpp",
+    "dawn_wire/client/ApiObjects_autogen.h",
+    "dawn_wire/client/ApiProcs_autogen.cpp",
+    "dawn_wire/client/ApiProcs_autogen.h",
+    "dawn_wire/client/ClientHandlers_autogen.cpp",
+    "dawn_wire/client/ClientPrototypes_autogen.inl",
+    "dawn_wire/client/Device_autogen.h",
   ]
 }
 
@@ -764,8 +769,19 @@
   configs = [ ":dawn_internal" ]
   sources = get_target_outputs(":libdawn_wire_gen")
   sources += [
+    "src/dawn_wire/DawnWire.cpp",
     "src/dawn_wire/WireDeserializeAllocator.cpp",
     "src/dawn_wire/WireDeserializeAllocator.h",
+    "src/dawn_wire/client/ApiObjects.h",
+    "src/dawn_wire/client/ApiProcs.cpp",
+    "src/dawn_wire/client/Buffer.cpp",
+    "src/dawn_wire/client/Buffer.h",
+    "src/dawn_wire/client/Client.cpp",
+    "src/dawn_wire/client/Client.h",
+    "src/dawn_wire/client/ClientHandlers.cpp",
+    "src/dawn_wire/client/Fence.cpp",
+    "src/dawn_wire/client/Fence.h",
+    "src/dawn_wire/client/ObjectAllocator.h",
   ]
 
   # Make headers publically visible
diff --git a/generator/main.py b/generator/main.py
index 32cf516..59fd37d 100644
--- a/generator/main.py
+++ b/generator/main.py
@@ -379,11 +379,16 @@
             },
             additional_params
         ]
+        renders.append(FileRender('dawn_wire/TypeTraits.h', 'dawn_wire/TypeTraits_autogen.h', wire_params))
         renders.append(FileRender('dawn_wire/WireCmd.h', 'dawn_wire/WireCmd_autogen.h', wire_params))
         renders.append(FileRender('dawn_wire/WireCmd.cpp', 'dawn_wire/WireCmd_autogen.cpp', wire_params))
-        renders.append(FileRender('dawn_wire/TypeTraits.h', 'dawn_wire/TypeTraits_autogen.h', wire_params))
-        renders.append(FileRender('dawn_wire/WireClient.cpp', 'dawn_wire/WireClient.cpp', wire_params))
         renders.append(FileRender('dawn_wire/WireServer.cpp', 'dawn_wire/WireServer.cpp', wire_params))
+        renders.append(FileRender('dawn_wire/client/ApiObjects.h', 'dawn_wire/client/ApiObjects_autogen.h', wire_params))
+        renders.append(FileRender('dawn_wire/client/ApiProcs.cpp', 'dawn_wire/client/ApiProcs_autogen.cpp', wire_params))
+        renders.append(FileRender('dawn_wire/client/ApiProcs.h', 'dawn_wire/client/ApiProcs_autogen.h', wire_params))
+        renders.append(FileRender('dawn_wire/client/ClientHandlers.cpp', 'dawn_wire/client/ClientHandlers_autogen.cpp', wire_params))
+        renders.append(FileRender('dawn_wire/client/ClientPrototypes.inl', 'dawn_wire/client/ClientPrototypes_autogen.inl', wire_params))
+        renders.append(FileRender('dawn_wire/client/Device.h', 'dawn_wire/client/Device_autogen.h', wire_params))
 
     return renders
 
diff --git a/generator/templates/dawn_wire/WireClient.cpp b/generator/templates/dawn_wire/WireClient.cpp
deleted file mode 100644
index 9f8dd49..0000000
--- a/generator/templates/dawn_wire/WireClient.cpp
+++ /dev/null
@@ -1,747 +0,0 @@
-//* Copyright 2017 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.
-
-#include "dawn_wire/Wire.h"
-#include "dawn_wire/WireCmd_autogen.h"
-#include "dawn_wire/WireDeserializeAllocator.h"
-
-#include "common/Assert.h"
-#include "common/SerialMap.h"
-
-#include <cstring>
-#include <cstdlib>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace dawn_wire {
-
-    //* Client side implementation of the API, will serialize everything to memory to send to the server side.
-    namespace client {
-
-        class Device;
-
-        struct BuilderCallbackData {
-            bool Call(dawnBuilderErrorStatus status, const char* message) {
-                if (canCall && callback != nullptr) {
-                    canCall = true;
-                    callback(status, message, userdata1, userdata2);
-                    return true;
-                }
-
-                return false;
-            }
-
-            //* For help with development, prints all builder errors by default.
-            dawnBuilderErrorCallback callback = nullptr;
-            dawnCallbackUserdata userdata1 = 0;
-            dawnCallbackUserdata userdata2 = 0;
-            bool canCall = true;
-        };
-
-        //* All non-Device objects of the client side have:
-        //*  - A pointer to the device to get where to serialize commands
-        //*  - The external reference count
-        //*  - An ID that is used to refer to this object when talking with the server side
-        struct ObjectBase {
-            ObjectBase(Device* device, uint32_t refcount, uint32_t id)
-                :device(device), refcount(refcount), id(id) {
-            }
-
-            Device* device;
-            uint32_t refcount;
-            uint32_t id;
-
-            BuilderCallbackData builderCallback;
-        };
-
-        {% for type in by_category["object"] if not type.name.CamelCase() in client_special_objects %}
-            struct {{type.name.CamelCase()}} : ObjectBase {
-                using ObjectBase::ObjectBase;
-            };
-        {% endfor %}
-
-        struct Buffer : ObjectBase {
-            using ObjectBase::ObjectBase;
-
-            ~Buffer() {
-                //* Callbacks need to be fired in all cases, as they can handle freeing resources
-                //* so we call them with "Unknown" status.
-                ClearMapRequests(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN);
-
-                if (mappedData) {
-                    free(mappedData);
-                }
-            }
-
-            void ClearMapRequests(dawnBufferMapAsyncStatus status) {
-                for (auto& it : requests) {
-                    if (it.second.isWrite) {
-                        it.second.writeCallback(status, nullptr, it.second.userdata);
-                    } else {
-                        it.second.readCallback(status, nullptr, it.second.userdata);
-                    }
-                }
-                requests.clear();
-            }
-
-            //* We want to defer all the validation to the server, which means we could have multiple
-            //* map request in flight at a single time and need to track them separately.
-            //* On well-behaved applications, only one request should exist at a single time.
-            struct MapRequestData {
-                dawnBufferMapReadCallback readCallback = nullptr;
-                dawnBufferMapWriteCallback writeCallback = nullptr;
-                dawnCallbackUserdata userdata = 0;
-                uint32_t size = 0;
-                bool isWrite = false;
-            };
-            std::map<uint32_t, MapRequestData> requests;
-            uint32_t requestSerial = 0;
-
-            //* Only one mapped pointer can be active at a time because Unmap clears all the in-flight requests.
-            void* mappedData = nullptr;
-            size_t mappedDataSize = 0;
-            bool isWriteMapped = false;
-        };
-
-        struct Fence : ObjectBase {
-            using ObjectBase::ObjectBase;
-
-            ~Fence() {
-                //* Callbacks need to be fired in all cases, as they can handle freeing resources
-                //* so we call them with "Unknown" status.
-                for (auto& request : requests.IterateAll()) {
-                    request.completionCallback(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, request.userdata);
-                }
-                requests.Clear();
-            }
-
-            void CheckPassedFences() {
-                for (auto& request : requests.IterateUpTo(completedValue)) {
-                    request.completionCallback(DAWN_FENCE_COMPLETION_STATUS_SUCCESS,
-                                               request.userdata);
-                }
-                requests.ClearUpTo(completedValue);
-            }
-
-            struct OnCompletionData {
-                dawnFenceOnCompletionCallback completionCallback = nullptr;
-                dawnCallbackUserdata userdata = 0;
-            };
-            uint64_t signaledValue = 0;
-            uint64_t completedValue = 0;
-            SerialMap<OnCompletionData> requests;
-        };
-
-        //* TODO(cwallez@chromium.org): Do something with objects before they are destroyed ?
-        //*  - Call still uncalled builder callbacks
-        template<typename T>
-        class ObjectAllocator {
-            public:
-                struct ObjectAndSerial {
-                    ObjectAndSerial(std::unique_ptr<T> object, uint32_t serial)
-                        : object(std::move(object)), serial(serial) {
-                    }
-                    std::unique_ptr<T> object;
-                    uint32_t serial;
-                };
-
-                ObjectAllocator(Device* device) : mDevice(device) {
-                    // ID 0 is nullptr
-                    mObjects.emplace_back(nullptr, 0);
-                }
-
-                ObjectAndSerial* New() {
-                    uint32_t id = GetNewId();
-                    T* result = new T(mDevice, 1, id);
-                    auto object = std::unique_ptr<T>(result);
-
-                    if (id >= mObjects.size()) {
-                        ASSERT(id == mObjects.size());
-                        mObjects.emplace_back(std::move(object), 0);
-                    } else {
-                        ASSERT(mObjects[id].object == nullptr);
-                        //* TODO(cwallez@chromium.org): investigate if overflows could cause bad things to happen
-                        mObjects[id].serial++;
-                        mObjects[id].object = std::move(object);
-                    }
-
-                    return &mObjects[id];
-                }
-                void Free(T* obj) {
-                    FreeId(obj->id);
-                    mObjects[obj->id].object = nullptr;
-                }
-
-                T* GetObject(uint32_t id) {
-                    if (id >= mObjects.size()) {
-                        return nullptr;
-                    }
-                    return mObjects[id].object.get();
-                }
-
-                uint32_t GetSerial(uint32_t id) {
-                    if (id >= mObjects.size()) {
-                        return 0;
-                    }
-                    return mObjects[id].serial;
-                }
-
-            private:
-                uint32_t GetNewId() {
-                    if (mFreeIds.empty()) {
-                        return mCurrentId ++;
-                    }
-                    uint32_t id = mFreeIds.back();
-                    mFreeIds.pop_back();
-                    return id;
-                }
-                void FreeId(uint32_t id) {
-                    mFreeIds.push_back(id);
-                }
-
-                // 0 is an ID reserved to represent nullptr
-                uint32_t mCurrentId = 1;
-                std::vector<uint32_t> mFreeIds;
-                std::vector<ObjectAndSerial> mObjects;
-                Device* mDevice;
-        };
-
-        //* The client wire uses the global Dawn device to store its global data such as the serializer
-        //* and the object id allocators.
-        class Device : public ObjectBase, public ObjectIdProvider {
-            public:
-                Device(CommandSerializer* serializer)
-                    : ObjectBase(this, 1, 1),
-                    {% for type in by_category["object"] if not type.name.canonical_case() == "device" %}
-                        {{type.name.camelCase()}}(this),
-                    {% endfor %}
-                    mSerializer(serializer) {
-                }
-
-                void* GetCmdSpace(size_t size) {
-                    return mSerializer->GetCmdSpace(size);
-                }
-
-                {% for type in by_category["object"] if not type.name.canonical_case() == "device" %}
-                    ObjectAllocator<{{type.name.CamelCase()}}> {{type.name.camelCase()}};
-                {% endfor %}
-
-                // Implementation of the ObjectIdProvider interface
-                {% for type in by_category["object"] %}
-                    ObjectId GetId({{as_cType(type.name)}} object) const final {
-                        return reinterpret_cast<{{as_wireType(type)}}>(object)->id;
-                    }
-                    ObjectId GetOptionalId({{as_cType(type.name)}} object) const final {
-                        if (object == nullptr) {
-                            return 0;
-                        }
-                        return GetId(object);
-                    }
-                {% endfor %}
-
-                void HandleError(const char* message) {
-                    if (errorCallback) {
-                        errorCallback(message, errorUserdata);
-                    }
-                }
-
-                dawnDeviceErrorCallback errorCallback = nullptr;
-                dawnCallbackUserdata errorUserdata;
-
-            private:
-               CommandSerializer* mSerializer = nullptr;
-        };
-
-        //* Implementation of the client API functions.
-        {% for type in by_category["object"] %}
-            {% set Type = type.name.CamelCase() %}
-            {% set cType = as_cType(type.name) %}
-
-            {% for method in type.methods %}
-                {% set Suffix = as_MethodSuffix(type.name, method.name) %}
-                {% if Suffix not in client_side_commands %}
-                    {{as_cType(method.return_type.name)}} Client{{Suffix}}(
-                        {{-cType}} cSelf
-                        {%- for arg in method.arguments -%}
-                            , {{as_annotated_cType(arg)}}
-                        {%- endfor -%}
-                    ) {
-                        auto self = reinterpret_cast<{{as_wireType(type)}}>(cSelf);
-                        Device* device = self->device;
-                        {{Suffix}}Cmd cmd;
-
-                        //* Create the structure going on the wire on the stack and fill it with the value
-                        //* arguments so it can compute its size.
-                        cmd.self = cSelf;
-
-                        //* For object creation, store the object ID the client will use for the result.
-                        {% if method.return_type.category == "object" %}
-                            auto* allocation = self->device->{{method.return_type.name.camelCase()}}.New();
-
-                            {% if type.is_builder %}
-                                //* We are in GetResult, so the callback that should be called is the
-                                //* currently set one. Copy it over to the created object and prevent the
-                                //* builder from calling the callback on destruction.
-                                allocation->object->builderCallback = self->builderCallback;
-                                self->builderCallback.canCall = false;
-                            {% endif %}
-
-                            cmd.result = ObjectHandle{allocation->object->id, allocation->serial};
-                        {% endif %}
-
-                        {% for arg in method.arguments %}
-                            cmd.{{as_varName(arg.name)}} = {{as_varName(arg.name)}};
-                        {% endfor %}
-
-                        //* Allocate space to send the command and copy the value args over.
-                        size_t requiredSize = cmd.GetRequiredSize();
-                        char* allocatedBuffer = static_cast<char*>(device->GetCmdSpace(requiredSize));
-                        cmd.Serialize(allocatedBuffer, *device);
-
-                        {% if method.return_type.category == "object" %}
-                            return reinterpret_cast<{{as_cType(method.return_type.name)}}>(allocation->object.get());
-                        {% endif %}
-                    }
-                {% endif %}
-            {% endfor %}
-
-            {% if type.is_builder %}
-                void Client{{as_MethodSuffix(type.name, Name("set error callback"))}}({{cType}} cSelf,
-                                                                                      dawnBuilderErrorCallback callback,
-                                                                                      dawnCallbackUserdata userdata1,
-                                                                                      dawnCallbackUserdata userdata2) {
-                    {{Type}}* self = reinterpret_cast<{{Type}}*>(cSelf);
-                    self->builderCallback.callback = callback;
-                    self->builderCallback.userdata1 = userdata1;
-                    self->builderCallback.userdata2 = userdata2;
-                }
-            {% endif %}
-
-            {% if not type.name.canonical_case() == "device" %}
-                //* When an object's refcount reaches 0, notify the server side of it and delete it.
-                void Client{{as_MethodSuffix(type.name, Name("release"))}}({{cType}} cObj) {
-                    {{Type}}* obj = reinterpret_cast<{{Type}}*>(cObj);
-                    obj->refcount --;
-
-                    if (obj->refcount > 0) {
-                        return;
-                    }
-
-                    obj->builderCallback.Call(DAWN_BUILDER_ERROR_STATUS_UNKNOWN, "Unknown");
-
-                    DestroyObjectCmd cmd;
-                    cmd.objectType = ObjectType::{{type.name.CamelCase()}};
-                    cmd.objectId = obj->id;
-
-                    size_t requiredSize = cmd.GetRequiredSize();
-                    char* allocatedBuffer = static_cast<char*>(obj->device->GetCmdSpace(requiredSize));
-                    cmd.Serialize(allocatedBuffer);
-
-                    obj->device->{{type.name.camelCase()}}.Free(obj);
-                }
-
-                void Client{{as_MethodSuffix(type.name, Name("reference"))}}({{cType}} cObj) {
-                    {{Type}}* obj = reinterpret_cast<{{Type}}*>(cObj);
-                    obj->refcount ++;
-                }
-            {% endif %}
-        {% endfor %}
-
-        void ClientBufferMapReadAsync(dawnBuffer cBuffer, uint32_t start, uint32_t size, dawnBufferMapReadCallback callback, dawnCallbackUserdata userdata) {
-            Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
-
-            uint32_t serial = buffer->requestSerial++;
-            ASSERT(buffer->requests.find(serial) == buffer->requests.end());
-
-            Buffer::MapRequestData request;
-            request.readCallback = callback;
-            request.userdata = userdata;
-            request.size = size;
-            request.isWrite = false;
-            buffer->requests[serial] = request;
-
-            BufferMapAsyncCmd cmd;
-            cmd.bufferId = buffer->id;
-            cmd.requestSerial = serial;
-            cmd.start = start;
-            cmd.size = size;
-            cmd.isWrite = false;
-
-            size_t requiredSize = cmd.GetRequiredSize();
-            char* allocatedBuffer = static_cast<char*>(buffer->device->GetCmdSpace(requiredSize));
-            cmd.Serialize(allocatedBuffer);
-        }
-
-        void ClientBufferMapWriteAsync(dawnBuffer cBuffer, uint32_t start, uint32_t size, dawnBufferMapWriteCallback callback, dawnCallbackUserdata userdata) {
-            Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
-
-            uint32_t serial = buffer->requestSerial++;
-            ASSERT(buffer->requests.find(serial) == buffer->requests.end());
-
-            Buffer::MapRequestData request;
-            request.writeCallback = callback;
-            request.userdata = userdata;
-            request.size = size;
-            request.isWrite = true;
-            buffer->requests[serial] = request;
-
-            BufferMapAsyncCmd cmd;
-            cmd.bufferId = buffer->id;
-            cmd.requestSerial = serial;
-            cmd.start = start;
-            cmd.size = size;
-            cmd.isWrite = true;
-
-            size_t requiredSize = cmd.GetRequiredSize();
-            char* allocatedBuffer = static_cast<char*>(buffer->device->GetCmdSpace(requiredSize));
-            cmd.Serialize(allocatedBuffer);
-        }
-
-        uint64_t ClientFenceGetCompletedValue(dawnFence cSelf) {
-            auto fence = reinterpret_cast<Fence*>(cSelf);
-            return fence->completedValue;
-        }
-
-        void ClientFenceOnCompletion(dawnFence cFence,
-                                     uint64_t value,
-                                     dawnFenceOnCompletionCallback callback,
-                                     dawnCallbackUserdata userdata) {
-            Fence* fence = reinterpret_cast<Fence*>(cFence);
-            if (value > fence->signaledValue) {
-                fence->device->HandleError("Value greater than fence signaled value");
-                callback(DAWN_FENCE_COMPLETION_STATUS_ERROR, userdata);
-                return;
-            }
-
-            if (value <= fence->completedValue) {
-                callback(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata);
-                return;
-            }
-
-            Fence::OnCompletionData request;
-            request.completionCallback = callback;
-            request.userdata = userdata;
-            fence->requests.Enqueue(std::move(request), value);
-        }
-
-        void ProxyClientBufferUnmap(dawnBuffer cBuffer) {
-            Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
-
-            //* Invalidate the local pointer, and cancel all other in-flight requests that would turn into
-            //* errors anyway (you can't double map). This prevents race when the following happens, where
-            //* the application code would have unmapped a buffer but still receive a callback:
-            //*  - Client -> Server: MapRequest1, Unmap, MapRequest2
-            //*  - Server -> Client: Result of MapRequest1
-            //*  - Unmap locally on the client
-            //*  - Server -> Client: Result of MapRequest2
-            if (buffer->mappedData) {
-
-                // If the buffer was mapped for writing, send the update to the data to the server
-                if (buffer->isWriteMapped) {
-                    BufferUpdateMappedDataCmd cmd;
-                    cmd.bufferId = buffer->id;
-                    cmd.dataLength = static_cast<uint32_t>(buffer->mappedDataSize);
-                    cmd.data = reinterpret_cast<const uint8_t*>(buffer->mappedData);
-
-                    size_t requiredSize = cmd.GetRequiredSize();
-                    char* allocatedBuffer = static_cast<char*>(buffer->device->GetCmdSpace(requiredSize));
-                    cmd.Serialize(allocatedBuffer);
-                }
-
-                free(buffer->mappedData);
-                buffer->mappedData = nullptr;
-            }
-            buffer->ClearMapRequests(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN);
-
-            ClientBufferUnmap(cBuffer);
-        }
-
-        dawnFence ProxyClientDeviceCreateFence(dawnDevice cSelf,
-                                               dawnFenceDescriptor const* descriptor) {
-            dawnFence cFence = ClientDeviceCreateFence(cSelf, descriptor);
-            Fence* fence = reinterpret_cast<Fence*>(cFence);
-            fence->signaledValue = descriptor->initialValue;
-            fence->completedValue = descriptor->initialValue;
-            return cFence;
-        }
-
-        void ProxyClientQueueSignal(dawnQueue cQueue, dawnFence cFence, uint64_t signalValue) {
-            Fence* fence = reinterpret_cast<Fence*>(cFence);
-            if (signalValue <= fence->signaledValue) {
-                fence->device->HandleError("Fence value less than or equal to signaled value");
-                return;
-            }
-            fence->signaledValue = signalValue;
-            ClientQueueSignal(cQueue, cFence, signalValue);
-        }
-
-        void ClientDeviceReference(dawnDevice) {
-        }
-
-        void ClientDeviceRelease(dawnDevice) {
-        }
-
-        void ClientDeviceSetErrorCallback(dawnDevice cSelf, dawnDeviceErrorCallback callback, dawnCallbackUserdata userdata) {
-            Device* self = reinterpret_cast<Device*>(cSelf);
-            self->errorCallback = callback;
-            self->errorUserdata = userdata;
-        }
-
-        // Some commands don't have a custom wire format, but need to be handled manually to update
-        // some client-side state tracking. For these we have two functions:
-        //  - An autogenerated Client{{suffix}} method that sends the command on the wire
-        //  - A manual ProxyClient{{suffix}} method that will be inserted in the proctable instead of
-        //    the autogenerated one, and that will have to call Client{{suffix}}
-        dawnProcTable GetProcs() {
-            dawnProcTable table;
-            {% for type in by_category["object"] %}
-                {% for method in native_methods(type) %}
-                    {% set suffix = as_MethodSuffix(type.name, method.name) %}
-                    {% if suffix in client_proxied_commands %}
-                        table.{{as_varName(type.name, method.name)}} = ProxyClient{{suffix}};
-                    {% else %}
-                        table.{{as_varName(type.name, method.name)}} = Client{{suffix}};
-                    {% endif %}
-                {% endfor %}
-            {% endfor %}
-            return table;
-        }
-
-        class Client : public CommandHandler {
-            public:
-                Client(Device* device) : mDevice(device) {
-                }
-
-                const char* HandleCommands(const char* commands, size_t size) override {
-                    while (size >= sizeof(ReturnWireCmd)) {
-                        ReturnWireCmd cmdId = *reinterpret_cast<const ReturnWireCmd*>(commands);
-
-                        bool success = false;
-                        switch (cmdId) {
-                            {% for command in cmd_records["return command"] %}
-                                case ReturnWireCmd::{{command.name.CamelCase()}}:
-                                    success = Handle{{command.name.CamelCase()}}(&commands, &size);
-                                    break;
-                            {% endfor %}
-                            default:
-                                success = false;
-                        }
-
-                        if (!success) {
-                            return nullptr;
-                        }
-                        mAllocator.Reset();
-                    }
-
-                    if (size != 0) {
-                        return nullptr;
-                    }
-
-                    return commands;
-                }
-
-            private:
-                Device* mDevice = nullptr;
-                WireDeserializeAllocator mAllocator;
-
-                bool HandleDeviceErrorCallback(const char** commands, size_t* size) {
-                    ReturnDeviceErrorCallbackCmd cmd;
-                    DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
-
-                    if (deserializeResult == DeserializeResult::FatalError) {
-                        return false;
-                    }
-
-                    DAWN_ASSERT(cmd.message != nullptr);
-                    mDevice->HandleError(cmd.message);
-
-                    return true;
-                }
-
-                {% for type in by_category["object"] if type.is_builder %}
-                    {% set Type = type.name.CamelCase() %}
-                    bool Handle{{Type}}ErrorCallback(const char** commands, size_t* size) {
-                        Return{{Type}}ErrorCallbackCmd cmd;
-                        DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
-
-                        if (deserializeResult == DeserializeResult::FatalError) {
-                            return false;
-                        }
-
-                        DAWN_ASSERT(cmd.message != nullptr);
-
-                        auto* builtObject = mDevice->{{type.built_type.name.camelCase()}}.GetObject(cmd.builtObject.id);
-                        uint32_t objectSerial = mDevice->{{type.built_type.name.camelCase()}}.GetSerial(cmd.builtObject.id);
-
-                        //* The object might have been deleted or a new object created with the same ID.
-                        if (builtObject == nullptr || objectSerial != cmd.builtObject.serial) {
-                            return true;
-                        }
-
-                        bool called = builtObject->builderCallback.Call(static_cast<dawnBuilderErrorStatus>(cmd.status), cmd.message);
-
-                        // Unhandled builder errors are forwarded to the device
-                        if (!called && cmd.status != DAWN_BUILDER_ERROR_STATUS_SUCCESS && cmd.status != DAWN_BUILDER_ERROR_STATUS_UNKNOWN) {
-                            mDevice->HandleError(("Unhandled builder error: " + std::string(cmd.message)).c_str());
-                        }
-
-                        return true;
-                    }
-                {% endfor %}
-
-                bool HandleBufferMapReadAsyncCallback(const char** commands, size_t* size) {
-                    ReturnBufferMapReadAsyncCallbackCmd cmd;
-                    DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
-
-                    if (deserializeResult == DeserializeResult::FatalError) {
-                        return false;
-                    }
-
-                    auto* buffer = mDevice->buffer.GetObject(cmd.buffer.id);
-                    uint32_t bufferSerial = mDevice->buffer.GetSerial(cmd.buffer.id);
-
-                    //* The buffer might have been deleted or recreated so this isn't an error.
-                    if (buffer == nullptr || bufferSerial != cmd.buffer.serial) {
-                        return true;
-                    }
-
-                    //* The requests can have been deleted via an Unmap so this isn't an error.
-                    auto requestIt = buffer->requests.find(cmd.requestSerial);
-                    if (requestIt == buffer->requests.end()) {
-                        return true;
-                    }
-
-                    //* It is an error for the server to call the read callback when we asked for a map write
-                    if (requestIt->second.isWrite) {
-                        return false;
-                    }
-
-                    auto request = requestIt->second;
-                    //* Delete the request before calling the callback otherwise the callback could be fired a
-                    //* second time. If, for example, buffer.Unmap() is called inside the callback.
-                    buffer->requests.erase(requestIt);
-
-                    //* On success, we copy the data locally because the IPC buffer isn't valid outside of this function
-                    if (cmd.status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
-                        //* The server didn't send the right amount of data, this is an error and could cause
-                        //* the application to crash if we did call the callback.
-                        if (request.size != cmd.dataLength) {
-                            return false;
-                        }
-
-                        ASSERT(cmd.data != nullptr);
-
-                        if (buffer->mappedData != nullptr) {
-                            return false;
-                        }
-
-                        buffer->isWriteMapped = false;
-                        buffer->mappedDataSize = request.size;
-                        buffer->mappedData = malloc(request.size);
-                        memcpy(buffer->mappedData, cmd.data, request.size);
-
-                        request.readCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status), buffer->mappedData, request.userdata);
-                    } else {
-                        request.readCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status), nullptr, request.userdata);
-                    }
-
-                    return true;
-                }
-
-                bool HandleBufferMapWriteAsyncCallback(const char** commands, size_t* size) {
-                    ReturnBufferMapWriteAsyncCallbackCmd cmd;
-                    DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
-
-                    if (deserializeResult == DeserializeResult::FatalError) {
-                        return false;
-                    }
-
-                    auto* buffer = mDevice->buffer.GetObject(cmd.buffer.id);
-                    uint32_t bufferSerial = mDevice->buffer.GetSerial(cmd.buffer.id);
-
-                    //* The buffer might have been deleted or recreated so this isn't an error.
-                    if (buffer == nullptr || bufferSerial != cmd.buffer.serial) {
-                        return true;
-                    }
-
-                    //* The requests can have been deleted via an Unmap so this isn't an error.
-                    auto requestIt = buffer->requests.find(cmd.requestSerial);
-                    if (requestIt == buffer->requests.end()) {
-                        return true;
-                    }
-
-                    //* It is an error for the server to call the write callback when we asked for a map read
-                    if (!requestIt->second.isWrite) {
-                        return false;
-                    }
-
-                    auto request = requestIt->second;
-                    //* Delete the request before calling the callback otherwise the callback could be fired a second time. If, for example, buffer.Unmap() is called inside the callback.
-                    buffer->requests.erase(requestIt);
-
-                    //* On success, we copy the data locally because the IPC buffer isn't valid outside of this function
-                    if (cmd.status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
-                        if (buffer->mappedData != nullptr) {
-                            return false;
-                        }
-
-                        buffer->isWriteMapped = true;
-                        buffer->mappedDataSize = request.size;
-                        buffer->mappedData = malloc(request.size);
-                        memset(buffer->mappedData, 0, request.size);
-
-                        request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status), buffer->mappedData, request.userdata);
-                    } else {
-                        request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status), nullptr, request.userdata);
-                    }
-
-                    return true;
-                }
-
-                bool HandleFenceUpdateCompletedValue(const char** commands, size_t* size) {
-                    ReturnFenceUpdateCompletedValueCmd cmd;
-                    DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
-
-                    if (deserializeResult == DeserializeResult::FatalError) {
-                        return false;
-                    }
-
-                    auto* fence = mDevice->fence.GetObject(cmd.fence.id);
-                    uint32_t fenceSerial = mDevice->fence.GetSerial(cmd.fence.id);
-
-                    //* The fence might have been deleted or recreated so this isn't an error.
-                    if (fence == nullptr || fenceSerial != cmd.fence.serial) {
-                        return true;
-                    }
-
-                    fence->completedValue = cmd.value;
-                    fence->CheckPassedFences();
-                    return true;
-                }
-        };
-
-    }
-
-    CommandHandler* NewClientDevice(dawnProcTable* procs, dawnDevice* device, CommandSerializer* serializer) {
-        auto clientDevice = new client::Device(serializer);
-
-        *device = reinterpret_cast<dawnDeviceImpl*>(clientDevice);
-        *procs = client::GetProcs();
-
-        return new client::Client(clientDevice);
-    }
-
-}  // namespace dawn_wire
diff --git a/generator/templates/dawn_wire/client/ApiObjects.h b/generator/templates/dawn_wire/client/ApiObjects.h
new file mode 100644
index 0000000..5c2ae3f
--- /dev/null
+++ b/generator/templates/dawn_wire/client/ApiObjects.h
@@ -0,0 +1,26 @@
+//* 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.
+
+#ifndef DAWNWIRE_CLIENT_APIOBJECTS_AUTOGEN_H_
+#define DAWNWIRE_CLIENT_APIOBJECTS_AUTOGEN_H_
+
+namespace dawn_wire { namespace client {
+    {% for type in by_category["object"] if not type.name.CamelCase() in client_special_objects %}
+        struct {{type.name.CamelCase()}} : ObjectBase {
+            using ObjectBase::ObjectBase;
+        };
+    {% endfor %}
+}}  // namespace dawn_wire::client
+
+#endif  // DAWNWIRE_CLIENT_APIOBJECTS_AUTOGEN_H_
diff --git a/generator/templates/dawn_wire/client/ApiProcs.cpp b/generator/templates/dawn_wire/client/ApiProcs.cpp
new file mode 100644
index 0000000..9544e93
--- /dev/null
+++ b/generator/templates/dawn_wire/client/ApiProcs.cpp
@@ -0,0 +1,135 @@
+//* 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.
+
+#include "dawn_wire/client/ApiObjects.h"
+#include "dawn_wire/client/ApiProcs_autogen.h"
+#include "dawn_wire/client/Client.h"
+#include "dawn_wire/client/Device_autogen.h"
+
+namespace dawn_wire { namespace client {
+    //* Implementation of the client API functions.
+    {% for type in by_category["object"] %}
+        {% set Type = type.name.CamelCase() %}
+        {% set cType = as_cType(type.name) %}
+
+        {% for method in type.methods %}
+            {% set Suffix = as_MethodSuffix(type.name, method.name) %}
+            {% if Suffix not in client_side_commands %}
+                {{as_cType(method.return_type.name)}} Client{{Suffix}}(
+                    {{-cType}} cSelf
+                    {%- for arg in method.arguments -%}
+                        , {{as_annotated_cType(arg)}}
+                    {%- endfor -%}
+                ) {
+                    auto self = reinterpret_cast<{{as_wireType(type)}}>(cSelf);
+                    Device* device = self->device;
+                    {{Suffix}}Cmd cmd;
+
+                    //* Create the structure going on the wire on the stack and fill it with the value
+                    //* arguments so it can compute its size.
+                    cmd.self = cSelf;
+
+                    //* For object creation, store the object ID the client will use for the result.
+                    {% if method.return_type.category == "object" %}
+                        auto* allocation = self->device->{{method.return_type.name.camelCase()}}.New();
+
+                        {% if type.is_builder %}
+                            //* We are in GetResult, so the callback that should be called is the
+                            //* currently set one. Copy it over to the created object and prevent the
+                            //* builder from calling the callback on destruction.
+                            allocation->object->builderCallback = self->builderCallback;
+                            self->builderCallback.canCall = false;
+                        {% endif %}
+
+                        cmd.result = ObjectHandle{allocation->object->id, allocation->serial};
+                    {% endif %}
+
+                    {% for arg in method.arguments %}
+                        cmd.{{as_varName(arg.name)}} = {{as_varName(arg.name)}};
+                    {% endfor %}
+
+                    //* Allocate space to send the command and copy the value args over.
+                    size_t requiredSize = cmd.GetRequiredSize();
+                    char* allocatedBuffer = static_cast<char*>(device->GetCmdSpace(requiredSize));
+                    cmd.Serialize(allocatedBuffer, *device);
+
+                    {% if method.return_type.category == "object" %}
+                        return reinterpret_cast<{{as_cType(method.return_type.name)}}>(allocation->object.get());
+                    {% endif %}
+                }
+            {% endif %}
+        {% endfor %}
+
+        {% if type.is_builder %}
+            void Client{{as_MethodSuffix(type.name, Name("set error callback"))}}({{cType}} cSelf,
+                                                                                  dawnBuilderErrorCallback callback,
+                                                                                  dawnCallbackUserdata userdata1,
+                                                                                  dawnCallbackUserdata userdata2) {
+                {{Type}}* self = reinterpret_cast<{{Type}}*>(cSelf);
+                self->builderCallback.callback = callback;
+                self->builderCallback.userdata1 = userdata1;
+                self->builderCallback.userdata2 = userdata2;
+            }
+        {% endif %}
+
+        {% if not type.name.canonical_case() == "device" %}
+            //* When an object's refcount reaches 0, notify the server side of it and delete it.
+            void Client{{as_MethodSuffix(type.name, Name("release"))}}({{cType}} cObj) {
+                {{Type}}* obj = reinterpret_cast<{{Type}}*>(cObj);
+                obj->refcount --;
+
+                if (obj->refcount > 0) {
+                    return;
+                }
+
+                obj->builderCallback.Call(DAWN_BUILDER_ERROR_STATUS_UNKNOWN, "Unknown");
+
+                DestroyObjectCmd cmd;
+                cmd.objectType = ObjectType::{{type.name.CamelCase()}};
+                cmd.objectId = obj->id;
+
+                size_t requiredSize = cmd.GetRequiredSize();
+                char* allocatedBuffer = static_cast<char*>(obj->device->GetCmdSpace(requiredSize));
+                cmd.Serialize(allocatedBuffer);
+
+                obj->device->{{type.name.camelCase()}}.Free(obj);
+            }
+
+            void Client{{as_MethodSuffix(type.name, Name("reference"))}}({{cType}} cObj) {
+                {{Type}}* obj = reinterpret_cast<{{Type}}*>(cObj);
+                obj->refcount ++;
+            }
+        {% endif %}
+    {% endfor %}
+
+    //* Some commands don't have a custom wire format, but need to be handled manually to update
+    //* some client-side state tracking. For these we have two functions:
+    //*  - An autogenerated Client{{suffix}} method that sends the command on the wire
+    //*  - A manual ProxyClient{{suffix}} method that will be inserted in the proctable instead of
+    //*    the autogenerated one, and that will have to call Client{{suffix}}
+    dawnProcTable GetProcs() {
+        dawnProcTable table;
+        {% for type in by_category["object"] %}
+            {% for method in native_methods(type) %}
+                {% set suffix = as_MethodSuffix(type.name, method.name) %}
+                {% if suffix in client_proxied_commands %}
+                    table.{{as_varName(type.name, method.name)}} = ProxyClient{{suffix}};
+                {% else %}
+                    table.{{as_varName(type.name, method.name)}} = Client{{suffix}};
+                {% endif %}
+            {% endfor %}
+        {% endfor %}
+        return table;
+    }
+}}  // namespace dawn_wire::client
diff --git a/generator/templates/dawn_wire/client/ApiProcs.h b/generator/templates/dawn_wire/client/ApiProcs.h
new file mode 100644
index 0000000..91489f2
--- /dev/null
+++ b/generator/templates/dawn_wire/client/ApiProcs.h
@@ -0,0 +1,46 @@
+//* 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.
+
+#ifndef DAWNWIRE_CLIENT_APIPROCS_AUTOGEN_H_
+#define DAWNWIRE_CLIENT_APIPROCS_AUTOGEN_H_
+
+#include <dawn/dawn.h>
+
+namespace dawn_wire { namespace client {
+
+    //* Dawn API
+    {% for type in by_category["object"] %}
+        {% set cType = as_cType(type.name) %}
+        {% for method in native_methods(type) %}
+            {% set Suffix = as_MethodSuffix(type.name, method.name) %}
+            {% if Suffix in client_proxied_commands %}
+                 {{as_cType(method.return_type.name)}} ProxyClient{{Suffix}}(
+                  {{-cType}} cSelf
+                  {%- for arg in method.arguments -%}
+                      , {{as_annotated_cType(arg)}}
+                  {%- endfor -%}
+                );
+            {% endif %}
+            {{as_cType(method.return_type.name)}} Client{{Suffix}}(
+              {{-cType}} cSelf
+              {%- for arg in method.arguments -%}
+                  , {{as_annotated_cType(arg)}}
+              {%- endfor -%}
+            );
+        {% endfor %}
+    {% endfor %}
+
+}}  // namespace dawn_wire::client
+
+#endif  // DAWNWIRE_CLIENT_APIPROCS_AUTOGEN_H_
diff --git a/generator/templates/dawn_wire/client/ClientHandlers.cpp b/generator/templates/dawn_wire/client/ClientHandlers.cpp
new file mode 100644
index 0000000..31a8081
--- /dev/null
+++ b/generator/templates/dawn_wire/client/ClientHandlers.cpp
@@ -0,0 +1,81 @@
+//* 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.
+
+#include "common/Assert.h"
+#include "dawn_wire/client/Client.h"
+#include "dawn_wire/client/Device_autogen.h"
+
+#include <string>
+
+namespace dawn_wire { namespace client {
+    {% for type in by_category["object"] if type.is_builder %}
+        {% set Type = type.name.CamelCase() %}
+        bool Client::Handle{{Type}}ErrorCallback(const char** commands, size_t* size) {
+            Return{{Type}}ErrorCallbackCmd cmd;
+            DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
+
+            if (deserializeResult == DeserializeResult::FatalError) {
+                return false;
+            }
+
+            DAWN_ASSERT(cmd.message != nullptr);
+
+            auto* builtObject = mDevice->{{type.built_type.name.camelCase()}}.GetObject(cmd.builtObject.id);
+            uint32_t objectSerial = mDevice->{{type.built_type.name.camelCase()}}.GetSerial(cmd.builtObject.id);
+
+            //* The object might have been deleted or a new object created with the same ID.
+            if (builtObject == nullptr || objectSerial != cmd.builtObject.serial) {
+                return true;
+            }
+
+            bool called = builtObject->builderCallback.Call(static_cast<dawnBuilderErrorStatus>(cmd.status), cmd.message);
+
+            // Unhandled builder errors are forwarded to the device
+            if (!called && cmd.status != DAWN_BUILDER_ERROR_STATUS_SUCCESS && cmd.status != DAWN_BUILDER_ERROR_STATUS_UNKNOWN) {
+                mDevice->HandleError(("Unhandled builder error: " + std::string(cmd.message)).c_str());
+            }
+
+            return true;
+        }
+    {% endfor %}
+
+    const char* Client::HandleCommands(const char* commands, size_t size) {
+        while (size >= sizeof(ReturnWireCmd)) {
+            ReturnWireCmd cmdId = *reinterpret_cast<const ReturnWireCmd*>(commands);
+
+            bool success = false;
+            switch (cmdId) {
+                {% for command in cmd_records["return command"] %}
+                    {% set Suffix = command.name.CamelCase() %}
+                    case ReturnWireCmd::{{Suffix}}:
+                        success = Handle{{Suffix}}(&commands, &size);
+                        break;
+                {% endfor %}
+                default:
+                    success = false;
+            }
+
+            if (!success) {
+                return nullptr;
+            }
+            mAllocator.Reset();
+        }
+
+        if (size != 0) {
+            return nullptr;
+        }
+
+        return commands;
+    }
+}}  // namespace dawn_wire::client
diff --git a/generator/templates/dawn_wire/client/ClientPrototypes.inl b/generator/templates/dawn_wire/client/ClientPrototypes.inl
new file mode 100644
index 0000000..5d64d85
--- /dev/null
+++ b/generator/templates/dawn_wire/client/ClientPrototypes.inl
@@ -0,0 +1,18 @@
+//* 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.
+
+//* Return command handlers
+{% for command in cmd_records["return command"] %}
+    bool Handle{{command.name.CamelCase()}}(const char** commands, size_t* size);
+{% endfor %}
diff --git a/generator/templates/dawn_wire/client/Device.h b/generator/templates/dawn_wire/client/Device.h
new file mode 100644
index 0000000..796383a
--- /dev/null
+++ b/generator/templates/dawn_wire/client/Device.h
@@ -0,0 +1,73 @@
+//* 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.
+
+#ifndef DAWNWIRE_CLIENT_DEVICE_AUTOGEN_H_
+#define DAWNWIRE_CLIENT_DEVICE_AUTOGEN_H_
+
+#include <dawn/dawn.h>
+
+#include "dawn_wire/Wire.h"
+#include "dawn_wire/WireCmd_autogen.h"
+#include "dawn_wire/client/ApiObjects.h"
+#include "dawn_wire/client/ObjectAllocator.h"
+
+namespace dawn_wire { namespace client {
+    //* The client wire uses the global Dawn device to store its global data such as the serializer
+    //* and the object id allocators.
+    class Device : public ObjectBase, public ObjectIdProvider {
+        public:
+            Device(CommandSerializer* serializer)
+                : ObjectBase(this, 1, 1),
+                {% for type in by_category["object"] if not type.name.canonical_case() == "device" %}
+                    {{type.name.camelCase()}}(this),
+                {% endfor %}
+                mSerializer(serializer) {
+            }
+
+            void* GetCmdSpace(size_t size) {
+                return mSerializer->GetCmdSpace(size);
+            }
+
+            {% for type in by_category["object"] if not type.name.canonical_case() == "device" %}
+                ObjectAllocator<{{type.name.CamelCase()}}> {{type.name.camelCase()}};
+            {% endfor %}
+
+            // Implementation of the ObjectIdProvider interface
+            {% for type in by_category["object"] %}
+                ObjectId GetId({{as_cType(type.name)}} object) const final {
+                    return reinterpret_cast<{{as_wireType(type)}}>(object)->id;
+                }
+                ObjectId GetOptionalId({{as_cType(type.name)}} object) const final {
+                    if (object == nullptr) {
+                        return 0;
+                    }
+                    return GetId(object);
+                }
+            {% endfor %}
+
+            void HandleError(const char* message) {
+                if (errorCallback) {
+                    errorCallback(message, errorUserdata);
+                }
+            }
+
+            dawnDeviceErrorCallback errorCallback = nullptr;
+            dawnCallbackUserdata errorUserdata;
+
+        private:
+            CommandSerializer* mSerializer = nullptr;
+    };
+}}  // namespace dawn_wire::client
+
+#endif  // DAWNWIRE_CLIENT_DEVICE_AUTOGEN_H_
diff --git a/src/dawn_wire/DawnWire.cpp b/src/dawn_wire/DawnWire.cpp
new file mode 100644
index 0000000..7e50273
--- /dev/null
+++ b/src/dawn_wire/DawnWire.cpp
@@ -0,0 +1,29 @@
+// 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.
+
+#include "dawn_wire/client/Client.h"
+#include "dawn_wire/client/Device_autogen.h"
+
+namespace dawn_wire {
+    CommandHandler* NewClientDevice(dawnProcTable* procs,
+                                    dawnDevice* device,
+                                    CommandSerializer* serializer) {
+        auto clientDevice = new client::Device(serializer);
+
+        *device = reinterpret_cast<dawnDeviceImpl*>(clientDevice);
+        *procs = client::GetProcs();
+
+        return new client::Client(clientDevice);
+    }
+}  // namespace dawn_wire
diff --git a/src/dawn_wire/client/ApiObjects.h b/src/dawn_wire/client/ApiObjects.h
new file mode 100644
index 0000000..c7a52c3
--- /dev/null
+++ b/src/dawn_wire/client/ApiObjects.h
@@ -0,0 +1,25 @@
+// 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.
+
+#ifndef DAWNWIRE_CLIENT_APIOBJECTS_H_
+#define DAWNWIRE_CLIENT_APIOBJECTS_H_
+
+#include "dawn_wire/client/ObjectBase.h"
+
+#include "dawn_wire/client/Buffer.h"
+#include "dawn_wire/client/Fence.h"
+
+#include "dawn_wire/client/ApiObjects_autogen.h"
+
+#endif  // DAWNWIRE_CLIENT_APIOBJECTS_H_
diff --git a/src/dawn_wire/client/ApiProcs.cpp b/src/dawn_wire/client/ApiProcs.cpp
new file mode 100644
index 0000000..99f620a
--- /dev/null
+++ b/src/dawn_wire/client/ApiProcs.cpp
@@ -0,0 +1,172 @@
+// 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.
+
+#include "dawn_wire/client/ApiProcs_autogen.h"
+#include "dawn_wire/client/Device_autogen.h"
+
+namespace dawn_wire { namespace client {
+
+    void ClientBufferMapReadAsync(dawnBuffer cBuffer,
+                                  uint32_t start,
+                                  uint32_t size,
+                                  dawnBufferMapReadCallback callback,
+                                  dawnCallbackUserdata userdata) {
+        Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
+
+        uint32_t serial = buffer->requestSerial++;
+        ASSERT(buffer->requests.find(serial) == buffer->requests.end());
+
+        Buffer::MapRequestData request;
+        request.readCallback = callback;
+        request.userdata = userdata;
+        request.size = size;
+        request.isWrite = false;
+        buffer->requests[serial] = request;
+
+        BufferMapAsyncCmd cmd;
+        cmd.bufferId = buffer->id;
+        cmd.requestSerial = serial;
+        cmd.start = start;
+        cmd.size = size;
+        cmd.isWrite = false;
+
+        size_t requiredSize = cmd.GetRequiredSize();
+        char* allocatedBuffer = static_cast<char*>(buffer->device->GetCmdSpace(requiredSize));
+        cmd.Serialize(allocatedBuffer);
+    }
+
+    void ClientBufferMapWriteAsync(dawnBuffer cBuffer,
+                                   uint32_t start,
+                                   uint32_t size,
+                                   dawnBufferMapWriteCallback callback,
+                                   dawnCallbackUserdata userdata) {
+        Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
+
+        uint32_t serial = buffer->requestSerial++;
+        ASSERT(buffer->requests.find(serial) == buffer->requests.end());
+
+        Buffer::MapRequestData request;
+        request.writeCallback = callback;
+        request.userdata = userdata;
+        request.size = size;
+        request.isWrite = true;
+        buffer->requests[serial] = request;
+
+        BufferMapAsyncCmd cmd;
+        cmd.bufferId = buffer->id;
+        cmd.requestSerial = serial;
+        cmd.start = start;
+        cmd.size = size;
+        cmd.isWrite = true;
+
+        size_t requiredSize = cmd.GetRequiredSize();
+        char* allocatedBuffer = static_cast<char*>(buffer->device->GetCmdSpace(requiredSize));
+        cmd.Serialize(allocatedBuffer);
+    }
+
+    uint64_t ClientFenceGetCompletedValue(dawnFence cSelf) {
+        auto fence = reinterpret_cast<Fence*>(cSelf);
+        return fence->completedValue;
+    }
+
+    void ClientFenceOnCompletion(dawnFence cFence,
+                                 uint64_t value,
+                                 dawnFenceOnCompletionCallback callback,
+                                 dawnCallbackUserdata userdata) {
+        Fence* fence = reinterpret_cast<Fence*>(cFence);
+        if (value > fence->signaledValue) {
+            fence->device->HandleError("Value greater than fence signaled value");
+            callback(DAWN_FENCE_COMPLETION_STATUS_ERROR, userdata);
+            return;
+        }
+
+        if (value <= fence->completedValue) {
+            callback(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata);
+            return;
+        }
+
+        Fence::OnCompletionData request;
+        request.completionCallback = callback;
+        request.userdata = userdata;
+        fence->requests.Enqueue(std::move(request), value);
+    }
+
+    void ProxyClientBufferUnmap(dawnBuffer cBuffer) {
+        Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
+
+        // Invalidate the local pointer, and cancel all other in-flight requests that would
+        // turn into
+        // errors anyway (you can't double map). This prevents race when the following happens,
+        // where
+        // the application code would have unmapped a buffer but still receive a callback:
+        //  - Client -> Server: MapRequest1, Unmap, MapRequest2
+        //  - Server -> Client: Result of MapRequest1
+        //  - Unmap locally on the client
+        //  - Server -> Client: Result of MapRequest2
+        if (buffer->mappedData) {
+            // If the buffer was mapped for writing, send the update to the data to the server
+            if (buffer->isWriteMapped) {
+                BufferUpdateMappedDataCmd cmd;
+                cmd.bufferId = buffer->id;
+                cmd.dataLength = static_cast<uint32_t>(buffer->mappedDataSize);
+                cmd.data = reinterpret_cast<const uint8_t*>(buffer->mappedData);
+
+                size_t requiredSize = cmd.GetRequiredSize();
+                char* allocatedBuffer =
+                    static_cast<char*>(buffer->device->GetCmdSpace(requiredSize));
+                cmd.Serialize(allocatedBuffer);
+            }
+
+            free(buffer->mappedData);
+            buffer->mappedData = nullptr;
+        }
+        buffer->ClearMapRequests(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN);
+
+        ClientBufferUnmap(cBuffer);
+    }
+
+    dawnFence ProxyClientDeviceCreateFence(dawnDevice cSelf,
+                                           dawnFenceDescriptor const* descriptor) {
+        dawnFence cFence = ClientDeviceCreateFence(cSelf, descriptor);
+        Fence* fence = reinterpret_cast<Fence*>(cFence);
+        fence->signaledValue = descriptor->initialValue;
+        fence->completedValue = descriptor->initialValue;
+        return cFence;
+    }
+
+    void ProxyClientQueueSignal(dawnQueue cQueue, dawnFence cFence, uint64_t signalValue) {
+        Fence* fence = reinterpret_cast<Fence*>(cFence);
+        if (signalValue <= fence->signaledValue) {
+            fence->device->HandleError("Fence value less than or equal to signaled value");
+            return;
+        }
+        fence->signaledValue = signalValue;
+        ClientQueueSignal(cQueue, cFence, signalValue);
+    }
+
+    void ClientDeviceReference(dawnDevice) {
+    }
+
+    void ClientDeviceRelease(dawnDevice) {
+    }
+
+    void ClientDeviceSetErrorCallback(dawnDevice cSelf,
+                                      dawnDeviceErrorCallback callback,
+                                      dawnCallbackUserdata userdata) {
+        Device* self = reinterpret_cast<Device*>(cSelf);
+        self->errorCallback = callback;
+        self->errorUserdata = userdata;
+    }
+
+}}  // namespace dawn_wire::client
diff --git a/src/dawn_wire/client/Buffer.cpp b/src/dawn_wire/client/Buffer.cpp
new file mode 100644
index 0000000..aa82c0e
--- /dev/null
+++ b/src/dawn_wire/client/Buffer.cpp
@@ -0,0 +1,40 @@
+// 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.
+
+#include "dawn_wire/client/Buffer.h"
+
+namespace dawn_wire { namespace client {
+
+    Buffer::~Buffer() {
+        // Callbacks need to be fired in all cases, as they can handle freeing resources
+        // so we call them with "Unknown" status.
+        ClearMapRequests(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN);
+
+        if (mappedData) {
+            free(mappedData);
+        }
+    }
+
+    void Buffer::ClearMapRequests(dawnBufferMapAsyncStatus status) {
+        for (auto& it : requests) {
+            if (it.second.isWrite) {
+                it.second.writeCallback(status, nullptr, it.second.userdata);
+            } else {
+                it.second.readCallback(status, nullptr, it.second.userdata);
+            }
+        }
+        requests.clear();
+    }
+
+}}  // namespace dawn_wire::client
diff --git a/src/dawn_wire/client/Buffer.h b/src/dawn_wire/client/Buffer.h
new file mode 100644
index 0000000..3561bc6
--- /dev/null
+++ b/src/dawn_wire/client/Buffer.h
@@ -0,0 +1,54 @@
+// 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.
+
+#ifndef DAWNWIRE_CLIENT_BUFFER_H_
+#define DAWNWIRE_CLIENT_BUFFER_H_
+
+#include <dawn/dawn.h>
+
+#include "dawn_wire/client/ObjectBase.h"
+
+#include <map>
+
+namespace dawn_wire { namespace client {
+
+    struct Buffer : ObjectBase {
+        using ObjectBase::ObjectBase;
+
+        ~Buffer();
+        void ClearMapRequests(dawnBufferMapAsyncStatus status);
+
+        // We want to defer all the validation to the server, which means we could have multiple
+        // map request in flight at a single time and need to track them separately.
+        // On well-behaved applications, only one request should exist at a single time.
+        struct MapRequestData {
+            dawnBufferMapReadCallback readCallback = nullptr;
+            dawnBufferMapWriteCallback writeCallback = nullptr;
+            dawnCallbackUserdata userdata = 0;
+            uint32_t size = 0;
+            bool isWrite = false;
+        };
+        std::map<uint32_t, MapRequestData> requests;
+        uint32_t requestSerial = 0;
+
+        // Only one mapped pointer can be active at a time because Unmap clears all the in-flight
+        // requests.
+        void* mappedData = nullptr;
+        size_t mappedDataSize = 0;
+        bool isWriteMapped = false;
+    };
+
+}}  // namespace dawn_wire::client
+
+#endif  // DAWNWIRE_CLIENT_BUFFER_H_
diff --git a/src/dawn_wire/client/Client.cpp b/src/dawn_wire/client/Client.cpp
new file mode 100644
index 0000000..6921fa9
--- /dev/null
+++ b/src/dawn_wire/client/Client.cpp
@@ -0,0 +1,22 @@
+// 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.
+
+#include "dawn_wire/client/Client.h"
+
+namespace dawn_wire { namespace client {
+
+    Client::Client(Device* device) : mDevice(device) {
+    }
+
+}}  // namespace dawn_wire::client
diff --git a/src/dawn_wire/client/Client.h b/src/dawn_wire/client/Client.h
new file mode 100644
index 0000000..cf975e8
--- /dev/null
+++ b/src/dawn_wire/client/Client.h
@@ -0,0 +1,43 @@
+// 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.
+
+#ifndef DAWNWIRE_CLIENT_CLIENT_H_
+#define DAWNWIRE_CLIENT_CLIENT_H_
+
+#include <dawn_wire/Wire.h>
+
+#include "dawn_wire/WireCmd_autogen.h"
+#include "dawn_wire/WireDeserializeAllocator.h"
+
+namespace dawn_wire { namespace client {
+
+    class Device;
+
+    class Client : public CommandHandler {
+      public:
+        Client(Device* device);
+        const char* HandleCommands(const char* commands, size_t size);
+
+      private:
+#include "dawn_wire/client/ClientPrototypes_autogen.inl"
+
+        Device* mDevice;
+        WireDeserializeAllocator mAllocator;
+    };
+
+    dawnProcTable GetProcs();
+
+}}  // namespace dawn_wire::client
+
+#endif  // DAWNWIRE_CLIENT_CLIENT_H_
diff --git a/src/dawn_wire/client/ClientHandlers.cpp b/src/dawn_wire/client/ClientHandlers.cpp
new file mode 100644
index 0000000..dc64ec2
--- /dev/null
+++ b/src/dawn_wire/client/ClientHandlers.cpp
@@ -0,0 +1,172 @@
+// 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.
+
+#include "common/Assert.h"
+#include "dawn_wire/client/Client.h"
+#include "dawn_wire/client/Device_autogen.h"
+
+namespace dawn_wire { namespace client {
+
+    bool Client::HandleDeviceErrorCallback(const char** commands, size_t* size) {
+        ReturnDeviceErrorCallbackCmd cmd;
+        DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
+
+        if (deserializeResult == DeserializeResult::FatalError) {
+            return false;
+        }
+
+        DAWN_ASSERT(cmd.message != nullptr);
+        mDevice->HandleError(cmd.message);
+
+        return true;
+    }
+
+    bool Client::HandleBufferMapReadAsyncCallback(const char** commands, size_t* size) {
+        ReturnBufferMapReadAsyncCallbackCmd cmd;
+        DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
+
+        if (deserializeResult == DeserializeResult::FatalError) {
+            return false;
+        }
+
+        auto* buffer = mDevice->buffer.GetObject(cmd.buffer.id);
+        uint32_t bufferSerial = mDevice->buffer.GetSerial(cmd.buffer.id);
+
+        // The buffer might have been deleted or recreated so this isn't an error.
+        if (buffer == nullptr || bufferSerial != cmd.buffer.serial) {
+            return true;
+        }
+
+        // The requests can have been deleted via an Unmap so this isn't an error.
+        auto requestIt = buffer->requests.find(cmd.requestSerial);
+        if (requestIt == buffer->requests.end()) {
+            return true;
+        }
+
+        // It is an error for the server to call the read callback when we asked for a map write
+        if (requestIt->second.isWrite) {
+            return false;
+        }
+
+        auto request = requestIt->second;
+        // Delete the request before calling the callback otherwise the callback could be fired a
+        // second time. If, for example, buffer.Unmap() is called inside the callback.
+        buffer->requests.erase(requestIt);
+
+        // On success, we copy the data locally because the IPC buffer isn't valid outside of this
+        // function
+        if (cmd.status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
+            // The server didn't send the right amount of data, this is an error and could cause
+            // the application to crash if we did call the callback.
+            if (request.size != cmd.dataLength) {
+                return false;
+            }
+
+            ASSERT(cmd.data != nullptr);
+
+            if (buffer->mappedData != nullptr) {
+                return false;
+            }
+
+            buffer->isWriteMapped = false;
+            buffer->mappedDataSize = request.size;
+            buffer->mappedData = malloc(request.size);
+            memcpy(buffer->mappedData, cmd.data, request.size);
+
+            request.readCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status),
+                                 buffer->mappedData, request.userdata);
+        } else {
+            request.readCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status), nullptr,
+                                 request.userdata);
+        }
+
+        return true;
+    }
+
+    bool Client::HandleBufferMapWriteAsyncCallback(const char** commands, size_t* size) {
+        ReturnBufferMapWriteAsyncCallbackCmd cmd;
+        DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
+
+        if (deserializeResult == DeserializeResult::FatalError) {
+            return false;
+        }
+
+        auto* buffer = mDevice->buffer.GetObject(cmd.buffer.id);
+        uint32_t bufferSerial = mDevice->buffer.GetSerial(cmd.buffer.id);
+
+        // The buffer might have been deleted or recreated so this isn't an error.
+        if (buffer == nullptr || bufferSerial != cmd.buffer.serial) {
+            return true;
+        }
+
+        // The requests can have been deleted via an Unmap so this isn't an error.
+        auto requestIt = buffer->requests.find(cmd.requestSerial);
+        if (requestIt == buffer->requests.end()) {
+            return true;
+        }
+
+        // It is an error for the server to call the write callback when we asked for a map read
+        if (!requestIt->second.isWrite) {
+            return false;
+        }
+
+        auto request = requestIt->second;
+        // Delete the request before calling the callback otherwise the callback could be fired a
+        // second time. If, for example, buffer.Unmap() is called inside the callback.
+        buffer->requests.erase(requestIt);
+
+        // On success, we copy the data locally because the IPC buffer isn't valid outside of this
+        // function
+        if (cmd.status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
+            if (buffer->mappedData != nullptr) {
+                return false;
+            }
+
+            buffer->isWriteMapped = true;
+            buffer->mappedDataSize = request.size;
+            buffer->mappedData = malloc(request.size);
+            memset(buffer->mappedData, 0, request.size);
+
+            request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status),
+                                  buffer->mappedData, request.userdata);
+        } else {
+            request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status), nullptr,
+                                  request.userdata);
+        }
+
+        return true;
+    }
+
+    bool Client::HandleFenceUpdateCompletedValue(const char** commands, size_t* size) {
+        ReturnFenceUpdateCompletedValueCmd cmd;
+        DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
+
+        if (deserializeResult == DeserializeResult::FatalError) {
+            return false;
+        }
+
+        auto* fence = mDevice->fence.GetObject(cmd.fence.id);
+        uint32_t fenceSerial = mDevice->fence.GetSerial(cmd.fence.id);
+
+        // The fence might have been deleted or recreated so this isn't an error.
+        if (fence == nullptr || fenceSerial != cmd.fence.serial) {
+            return true;
+        }
+
+        fence->completedValue = cmd.value;
+        fence->CheckPassedFences();
+        return true;
+    }
+
+}}  // namespace dawn_wire::client
diff --git a/src/dawn_wire/client/Fence.cpp b/src/dawn_wire/client/Fence.cpp
new file mode 100644
index 0000000..497b714
--- /dev/null
+++ b/src/dawn_wire/client/Fence.cpp
@@ -0,0 +1,35 @@
+// 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.
+
+#include "dawn_wire/client/Fence.h"
+
+namespace dawn_wire { namespace client {
+
+    Fence::~Fence() {
+        // Callbacks need to be fired in all cases, as they can handle freeing resources
+        // so we call them with "Unknown" status.
+        for (auto& request : requests.IterateAll()) {
+            request.completionCallback(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, request.userdata);
+        }
+        requests.Clear();
+    }
+
+    void Fence::CheckPassedFences() {
+        for (auto& request : requests.IterateUpTo(completedValue)) {
+            request.completionCallback(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, request.userdata);
+        }
+        requests.ClearUpTo(completedValue);
+    }
+
+}}  // namespace dawn_wire::client
diff --git a/src/dawn_wire/client/Fence.h b/src/dawn_wire/client/Fence.h
new file mode 100644
index 0000000..dd17b7c
--- /dev/null
+++ b/src/dawn_wire/client/Fence.h
@@ -0,0 +1,42 @@
+// 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.
+
+#ifndef DAWNWIRE_CLIENT_FENCE_H_
+#define DAWNWIRE_CLIENT_FENCE_H_
+
+#include <dawn/dawn.h>
+
+#include "common/SerialMap.h"
+#include "dawn_wire/client/ObjectBase.h"
+
+namespace dawn_wire { namespace client {
+
+    struct Fence : ObjectBase {
+        using ObjectBase::ObjectBase;
+
+        ~Fence();
+        void CheckPassedFences();
+
+        struct OnCompletionData {
+            dawnFenceOnCompletionCallback completionCallback = nullptr;
+            dawnCallbackUserdata userdata = 0;
+        };
+        uint64_t signaledValue = 0;
+        uint64_t completedValue = 0;
+        SerialMap<OnCompletionData> requests;
+    };
+
+}}  // namespace dawn_wire::client
+
+#endif  // DAWNWIRE_CLIENT_FENCE_H_
diff --git a/src/dawn_wire/client/ObjectAllocator.h b/src/dawn_wire/client/ObjectAllocator.h
new file mode 100644
index 0000000..c50307c
--- /dev/null
+++ b/src/dawn_wire/client/ObjectAllocator.h
@@ -0,0 +1,103 @@
+// 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.
+
+#ifndef DAWNWIRE_CLIENT_OBJECTALLOCATOR_H_
+#define DAWNWIRE_CLIENT_OBJECTALLOCATOR_H_
+
+#include "common/Assert.h"
+
+#include <memory>
+#include <vector>
+
+namespace dawn_wire { namespace client {
+
+    class Device;
+
+    // TODO(cwallez@chromium.org): Do something with objects before they are destroyed ?
+    //  - Call still uncalled builder callbacks
+    template <typename T>
+    class ObjectAllocator {
+      public:
+        struct ObjectAndSerial {
+            ObjectAndSerial(std::unique_ptr<T> object, uint32_t serial)
+                : object(std::move(object)), serial(serial) {
+            }
+            std::unique_ptr<T> object;
+            uint32_t serial;
+        };
+
+        ObjectAllocator(Device* device) : mDevice(device) {
+            // ID 0 is nullptr
+            mObjects.emplace_back(nullptr, 0);
+        }
+
+        ObjectAndSerial* New() {
+            uint32_t id = GetNewId();
+            T* result = new T(mDevice, 1, id);
+            auto object = std::unique_ptr<T>(result);
+
+            if (id >= mObjects.size()) {
+                ASSERT(id == mObjects.size());
+                mObjects.emplace_back(std::move(object), 0);
+            } else {
+                ASSERT(mObjects[id].object == nullptr);
+                // TODO(cwallez@chromium.org): investigate if overflows could cause bad things to
+                // happen
+                mObjects[id].serial++;
+                mObjects[id].object = std::move(object);
+            }
+
+            return &mObjects[id];
+        }
+        void Free(T* obj) {
+            FreeId(obj->id);
+            mObjects[obj->id].object = nullptr;
+        }
+
+        T* GetObject(uint32_t id) {
+            if (id >= mObjects.size()) {
+                return nullptr;
+            }
+            return mObjects[id].object.get();
+        }
+
+        uint32_t GetSerial(uint32_t id) {
+            if (id >= mObjects.size()) {
+                return 0;
+            }
+            return mObjects[id].serial;
+        }
+
+      private:
+        uint32_t GetNewId() {
+            if (mFreeIds.empty()) {
+                return mCurrentId++;
+            }
+            uint32_t id = mFreeIds.back();
+            mFreeIds.pop_back();
+            return id;
+        }
+        void FreeId(uint32_t id) {
+            mFreeIds.push_back(id);
+        }
+
+        // 0 is an ID reserved to represent nullptr
+        uint32_t mCurrentId = 1;
+        std::vector<uint32_t> mFreeIds;
+        std::vector<ObjectAndSerial> mObjects;
+        Device* mDevice;
+    };
+}}  // namespace dawn_wire::client
+
+#endif  // DAWNWIRE_CLIENT_OBJECTALLOCATOR_H_
diff --git a/src/dawn_wire/client/ObjectBase.h b/src/dawn_wire/client/ObjectBase.h
new file mode 100644
index 0000000..70005f2
--- /dev/null
+++ b/src/dawn_wire/client/ObjectBase.h
@@ -0,0 +1,60 @@
+// 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.
+
+#ifndef DAWNWIRE_CLIENT_OBJECTBASE_H_
+#define DAWNWIRE_CLIENT_OBJECTBASE_H_
+
+#include <dawn/dawn.h>
+
+namespace dawn_wire { namespace client {
+
+    class Device;
+
+    struct BuilderCallbackData {
+        bool Call(dawnBuilderErrorStatus status, const char* message) {
+            if (canCall && callback != nullptr) {
+                canCall = true;
+                callback(status, message, userdata1, userdata2);
+                return true;
+            }
+
+            return false;
+        }
+
+        // For help with development, prints all builder errors by default.
+        dawnBuilderErrorCallback callback = nullptr;
+        dawnCallbackUserdata userdata1 = 0;
+        dawnCallbackUserdata userdata2 = 0;
+        bool canCall = true;
+    };
+
+    // All non-Device objects of the client side have:
+    //  - A pointer to the device to get where to serialize commands
+    //  - The external reference count
+    //  - An ID that is used to refer to this object when talking with the server side
+    struct ObjectBase {
+        ObjectBase(Device* device, uint32_t refcount, uint32_t id)
+            : device(device), refcount(refcount), id(id) {
+        }
+
+        Device* device;
+        uint32_t refcount;
+        uint32_t id;
+
+        BuilderCallbackData builderCallback;
+    };
+
+}}  // namespace dawn_wire::client
+
+#endif  // DAWNWIRE_CLIENT_OBJECTBASE_H_