diff --git a/binding.gyp b/binding.gyp
index 3a8aa558ab..ac79768630 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -27,6 +27,7 @@
                 'deps/oculus/src/*.cpp',
                 'deps/openvr/src/*.cpp',
                 'deps/exokit-bindings/leapmotion/src/*.cc',
+                'deps/exokit-bindings/zed/src/*.cc',
               ],
               'include_dirs': [
                 "<!(node -e \"console.log(require.resolve('nan').slice(0, -16))\")",
@@ -43,6 +44,8 @@
                 "<!(node -e \"console.log(require.resolve('native-oculus-deps').slice(0, -9) + '/Include')\")",
                 "<!(node -e \"console.log(require.resolve('native-openvr-deps').slice(0, -9) + '/headers')\")",
                 "<!(node -e \"console.log(require.resolve('leapmotion').slice(0, -9) + '/include')\")",
+                "C:\\Program Files (x86)\\ZED SDK\\include",
+                "C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v10.1\\include",
                 '<(module_root_dir)/deps/exokit-bindings',
                 '<(module_root_dir)/deps/exokit-bindings/utf8',
                 '<(module_root_dir)/deps/exokit-bindings/node',
@@ -64,6 +67,7 @@
                 '<(module_root_dir)/deps/oculus/include',
                 '<(module_root_dir)/deps/openvr/include',
                 '<(module_root_dir)/deps/exokit-bindings/leapmotion/include',
+                '<(module_root_dir)/deps/exokit-bindings/zed/include',
               ],
               'library_dirs': [
                 "<!(node -e \"console.log(require.resolve('native-graphics-deps').slice(0, -9) + '/lib/windows/glew')\")",
@@ -74,6 +78,8 @@
                 "<!(node -e \"console.log(require.resolve('native-oculus-deps').slice(0, -9) + '/Lib/Windows/x64/Release/VS2017')\")",
                 "<!(node -e \"console.log(require.resolve('native-openvr-deps').slice(0, -9) + '/lib/win64')\")",
                 "<!(node -e \"console.log(require.resolve('leapmotion').slice(0, -9) + '/lib/win')\")",
+                "C:\\Program Files (x86)\\ZED SDK\\lib",
+                "C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v10.1\\lib\\x64",
                 "<!(node -e \"console.log(require.resolve('native-browser-deps-windows').slice(0, -9) + '/lib2/windows')\")",
                 "<!(node -e \"console.log(require.resolve('native-webrtc-deps').slice(0, -9) + '/lib/windows')\")",
               ],
@@ -92,6 +98,9 @@
                 'swresample.lib',
                 'openvr_api.lib',
                 'Leap.lib',
+                'sl_zed64.lib',
+                'sl_core64.lib',
+                'cudart.lib',
                 'libcef.lib',
                 'libcef_dll_wrapper.lib',
                 'LibOVR.lib',
@@ -119,6 +128,8 @@
                     "<!(node -e \"console.log(require.resolve('native-oculus-deps').slice(0, -9) + '/Lib/Windows/x64/Release/VS2017')\")",
                     "<!(node -e \"console.log(require.resolve('native-openvr-deps').slice(0, -9) + '/bin/win64/openvr_api.dll')\")",
                     "<!(node -e \"console.log(require.resolve('leapmotion').slice(0, -9) + '/lib/win/Leap.dll')\")",
+                    "C:\\Program Files (x86)\\ZED SDK\\bin\\sl_zed64.dll",
+                    "C:\\Program Files (x86)\\ZED SDK\\bin\\sl_core64.dll",
                     "<!(node -e \"console.log(require.resolve('native-browser-deps-windows').slice(0, -9) + '/lib2/windows/libcef.dll')\")",
                     "<!(node -e \"console.log(require.resolve('native-browser-deps-windows').slice(0, -9) + '/lib2/windows/chrome_elf.dll')\")",
                     "<!(node -e \"console.log(require.resolve('native-browser-deps-windows').slice(0, -9) + '/lib2/windows/libEGL.dll')\")",
diff --git a/deps/exokit-bindings/bindings/include/bindings.h b/deps/exokit-bindings/bindings/include/bindings.h
index 5a73d16e4b..b00872e0c6 100644
--- a/deps/exokit-bindings/bindings/include/bindings.h
+++ b/deps/exokit-bindings/bindings/include/bindings.h
@@ -18,9 +18,10 @@
 #include <webrtc.h>
 // Stub out on Android for now until get libcef working on Android.
 #if !defined(ANDROID)
-  #include <browser.h>
+#include <browser.h>
 #endif
 #if _WIN32
+#include <zed.h>
 #include <leapmotion.h>
 #endif
 #if defined(LUMIN)
diff --git a/deps/exokit-bindings/zed/include/zed.h b/deps/exokit-bindings/zed/include/zed.h
new file mode 100644
index 0000000000..79f3e8dffc
--- /dev/null
+++ b/deps/exokit-bindings/zed/include/zed.h
@@ -0,0 +1,70 @@
+#ifndef _ZED_H_
+#define _ZED_H_
+
+#include <v8.h>
+#include <node.h>
+#include <nan.h>
+
+#include <defines.h>
+#include <windowsystem.h>
+
+#include <chrono>
+#include <thread>
+#include <mutex>
+
+#include <sl/Camera.hpp>
+#include <webgl.h>
+#include <cuda_gl_interop.h>
+
+using namespace v8;
+using namespace node;
+
+namespace zed {
+  
+bool cudaSafeCall(cudaError_t err);
+
+class Zed : public ObjectWrap {
+public:
+  static Local<Object> Initialize(Isolate *isolate);
+
+// protected:
+  Zed();
+  ~Zed();
+
+  static NAN_METHOD(New);
+  static NAN_METHOD(RequestPresent);
+  static NAN_METHOD(ExitPresent);
+  static NAN_METHOD(WaitGetPoses);
+
+  void Poll();
+
+  sl::Camera camera;
+  sl::Translation position;
+  sl::Orientation orientation;
+  sl::Mesh mesh;
+  sl::Mesh::chunkList chunks;
+  std::chrono::high_resolution_clock::time_point ts_last;
+  GLuint tex;
+  GLuint leftTex;
+  GLuint rightTex;
+  NATIVEwindow *window;
+  int textureWidth;
+  int textureHeight;
+  // cudaGraphicsResource *pcuImageRes;
+  sl::Mat leftImage;
+  sl::Mat rightImage;
+  cudaGraphicsResource *leftCudaImageResource;
+  cudaGraphicsResource *rightCudaImageResource;
+  // Nan::Persistent<Function> cbFn;
+  std::mutex mutex;
+  std::thread thread;
+  uv_async_t *async;
+  uv_sem_t reqSem;
+  Nan::Persistent<Array> result;
+};
+
+}
+
+Local<Object> makeZed();
+
+#endif
diff --git a/deps/exokit-bindings/zed/src/zed.cc b/deps/exokit-bindings/zed/src/zed.cc
new file mode 100644
index 0000000000..6222f11ffa
--- /dev/null
+++ b/deps/exokit-bindings/zed/src/zed.cc
@@ -0,0 +1,348 @@
+#include <zed.h>
+
+#include <exout>
+
+// using namespace sl;
+
+namespace zed {
+
+bool cudaSafeCall(cudaError_t err) {
+  if (err != cudaSuccess) {
+    printf("Cuda error [%d]: %s.\n", err, cudaGetErrorString(err));
+    return false;
+  }
+  return true;
+}
+
+Zed::Zed() : tex(0), leftTex(0), rightTex(0), window(nullptr), textureWidth(0), textureHeight(0), /*pcuImageRes(nullptr),*/ leftCudaImageResource(nullptr), rightCudaImageResource(nullptr) {}
+
+Zed::~Zed() {}
+
+NAN_METHOD(Zed::New) {
+  Local<Object> zedObj = info.This();
+  Zed *zed = new Zed();
+  zed->Wrap(zedObj);
+
+  info.GetReturnValue().Set(zedObj);
+}
+
+void RunInMainThread(uv_async_t *handle) {
+  Nan::HandleScope scope;
+
+  Zed *zed = (Zed *)handle->data;
+
+  Local<Array> result = Nan::New<Array>(zed->chunks.size());
+
+  Local<String> texStr = JS_STR("tex");
+  Local<Object> texObj = Nan::New<Object>();
+  texObj->Set(JS_STR("id"), JS_INT(zed->tex));
+
+  for (size_t i = 0; i < zed->chunks.size(); i++) {
+    size_t chunkIndex = zed->chunks[i];
+    sl::Chunk &chunk = zed->mesh[chunkIndex];
+    const sl::float3 &position = chunk.barycenter;
+    std::vector<sl::float3> &positions = chunk.vertices;
+    size_t numPositions = positions.size() * sizeof(positions[0]) / sizeof(float);
+    std::vector<sl::float3> &normals = chunk.normals;
+    size_t numNormals = normals.size() * sizeof(normals[0]) / sizeof(float);
+    std::vector<sl::float2> &uvs = chunk.uv;
+    size_t numUvs = uvs.size() * sizeof(uvs[0]) / sizeof(float);
+    std::vector<sl::uint3> &indices = chunk.triangles;
+    size_t numIndices = indices.size() * sizeof(indices[0]) / sizeof(uint32_t);
+
+    Local<Object> chunkObj = Nan::New<Object>();
+
+    Local<SharedArrayBuffer> arrayBuffer = SharedArrayBuffer::New(Isolate::GetCurrent(), numPositions*sizeof(float) + numNormals*sizeof(float) + numUvs*sizeof(float) + numIndices*sizeof(uint16_t));
+    unsigned char *arrayBufferData = (unsigned char *)arrayBuffer->GetContents().Data();
+    int index = 0;
+
+    chunkObj->Set(JS_STR("positionArray"), Float32Array::New(arrayBuffer, index, numPositions));
+    memcpy(arrayBufferData + index, positions.data(), numPositions*sizeof(float));
+    index += numPositions*sizeof(float);
+
+    chunkObj->Set(JS_STR("normalArray"), Float32Array::New(arrayBuffer, index, numNormals));
+    memcpy(arrayBufferData + index, normals.data(), numNormals*sizeof(float));
+    index += numNormals*sizeof(float);
+
+    chunkObj->Set(JS_STR("uvArray"), Float32Array::New(arrayBuffer, index, numUvs));
+    memcpy(arrayBufferData + index, uvs.data(), numUvs*sizeof(float));
+    index += numUvs*sizeof(float);
+
+    chunkObj->Set(JS_STR("indexArray"), Uint16Array::New(arrayBuffer, index, numIndices));
+    for (size_t i = 0; i < indices.size(); i++) {
+      sl::uint3 &indexVector = indices[i];
+      uint16_t *baseIndex = &(((uint16_t *)(arrayBufferData + index))[i*3]);
+      baseIndex[0] = (uint16_t)indexVector.x;
+      baseIndex[1] = (uint16_t)indexVector.y;
+      baseIndex[2] = (uint16_t)indexVector.z;
+    }
+    index += numUvs*sizeof(uint16_t);
+
+    chunkObj->Set(texStr, texObj);
+
+    result->Set(i, chunkObj);
+  }
+
+  zed->result.Reset(result);
+
+  uv_sem_post(&zed->reqSem);
+}
+
+NAN_METHOD(Zed::RequestPresent) {
+  Zed *zed = ObjectWrap::Unwrap<Zed>(info.This());
+
+  uv_loop_t *loop = windowsystembase::GetEventLoop();
+  zed->async = new uv_async_t();
+  uv_async_init(loop, zed->async, RunInMainThread);
+  zed->async->data = zed;
+  uv_sem_init(&zed->reqSem, 0);
+  zed->thread = std::thread([zed]() -> void {
+    // Setup configuration parameters for the ZED
+    sl::InitParameters parameters;
+    parameters.coordinate_units = sl::UNIT_METER;
+    parameters.coordinate_system = sl::COORDINATE_SYSTEM_RIGHT_HANDED_Y_UP; // OpenGL coordinates system
+
+    // Open the ZED
+    sl::ERROR_CODE zed_error = zed->camera.open(parameters);
+    if(zed_error != sl::ERROR_CODE::SUCCESS) {
+        std::cout << zed_error << std::endl;
+        zed->camera.close();
+        return;
+    }
+
+    sl::CameraParameters camLeft = zed->camera.getCameraInformation().calibration_parameters.left_cam;
+    sl::CameraParameters camRight = zed->camera.getCameraInformation().calibration_parameters.right_cam;
+
+    // sl::Mat image; // current left image
+
+    sl::SpatialMappingParameters spatial_mapping_parameters;
+    // sl::SPATIAL_MAPPING_STATE mapping_state = sl::SPATIAL_MAPPING_STATE_NOT_ENABLED;
+    // bool mapping_activated = false; // indicates if the spatial mapping is running or not
+    zed->ts_last = std::chrono::high_resolution_clock::now(); // time stamp of the last mesh request
+
+    // Enable positional tracking before starting spatial mapping
+    zed->camera.enableTracking();
+
+    {
+      sl::Transform init_pose;
+      zed->camera.resetTracking(init_pose);
+
+      // Configure Spatial Mapping parameters
+      spatial_mapping_parameters.resolution_meter = sl::SpatialMappingParameters::get(sl::SpatialMappingParameters::MAPPING_RESOLUTION_MEDIUM);
+      spatial_mapping_parameters.use_chunk_only = true;
+      spatial_mapping_parameters.save_texture = true;
+      spatial_mapping_parameters.map_type = sl::SpatialMappingParameters::SPATIAL_MAP_TYPE_MESH;
+      // Enable spatial mapping
+      try {
+        zed->camera.enableSpatialMapping(spatial_mapping_parameters);
+        std::cout << "Spatial Mapping will output a " << spatial_mapping_parameters.map_type << std::endl;
+      } catch(std::string e) {
+        std::cout <<"Error enabling Spatial Mapping "<< e << std::endl;
+      }
+    }
+
+    zed->window = windowsystem::CreateWindowHandle(1, 1, false);
+    windowsystem::SetCurrentWindowContext(zed->window);
+    // glGenTextures(1, &zed->tex);
+
+    {
+      glGenTextures(1, &zed->leftTex);
+      glBindTexture(GL_TEXTURE_2D, zed->leftTex);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, camLeft.image_size.width, camLeft.image_size.height, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
+      glBindTexture(GL_TEXTURE_2D, 0);
+
+      cudaSafeCall(cudaGraphicsGLRegisterImage(&zed->leftCudaImageResource, zed->leftTex, GL_TEXTURE_2D, cudaGraphicsRegisterFlagsWriteDiscard));
+      // cudaSafeCall(cudaGraphicsUnregisterResource(zed->leftCudaImageResource));
+    }
+    {
+      glGenTextures(1, &zed->rightTex);
+      glBindTexture(GL_TEXTURE_2D, zed->rightTex);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, camLeft.image_size.width, camLeft.image_size.height, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
+      glBindTexture(GL_TEXTURE_2D, 0);
+
+      cudaSafeCall(cudaGraphicsGLRegisterImage(&zed->rightCudaImageResource, zed->rightTex, GL_TEXTURE_2D, cudaGraphicsRegisterFlagsWriteDiscard));
+      // cudaSafeCall(cudaGraphicsUnregisterResource(zed->rightCudaImageResource));
+    }
+
+    for (;;) {
+      zed->Poll();
+    }
+  });
+  // zed->cbFn.Reset(localCbFn);
+  // cudaError_t cudaError = cudaGraphicsGLRegisterImage(&zed->pcuImageRes, zed->tex, GL_TEXTURE_2D, cudaGraphicsRegisterFlagsWriteDiscard);
+  // cudaError = cudaGraphicsUnregisterResource(zed->pcuImageRes);
+}
+
+NAN_METHOD(Zed::ExitPresent) {
+  Zed *zed = ObjectWrap::Unwrap<Zed>(info.This());
+
+  // image.free();
+  zed->mesh.clear();
+
+  zed->camera.disableSpatialMapping();
+  zed->camera.disableTracking();
+  zed->camera.close();
+}
+
+void Zed::Poll() {
+  Zed *zed = this;
+
+  if (zed->camera.grab() == sl::SUCCESS) {
+    // Update pose data (used for projection of the mesh over the current image)
+    sl::Pose pose;
+    sl::TRACKING_STATE tracking_state = zed->camera.getPosition(pose);
+    
+    // Retrieve image in GPU memory
+    zed->camera.retrieveImage(zed->leftImage, sl::VIEW_LEFT, sl::MEM_GPU);
+    zed->camera.retrieveImage(zed->rightImage, sl::VIEW_RIGHT, sl::MEM_GPU);
+
+    {
+      std::lock_guard<std::mutex> lock(zed->mutex);
+
+      zed->position = pose.getTranslation();
+      zed->orientation = pose.getOrientation();
+    }
+
+    // Compute elapse time since the last call of Camera::requestMeshAsync()
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - zed->ts_last).count();
+    // Ask for a mesh update if 500ms have spend since last request
+    if(duration > 500) {
+      zed->camera.requestSpatialMapAsync();
+      zed->ts_last = std::chrono::high_resolution_clock::now();
+    }
+
+    if(zed->camera.getSpatialMapRequestStatusAsync() == sl::SUCCESS) {
+      zed->camera.retrieveSpatialMapAsync(zed->mesh);
+
+      sl::MeshFilterParameters filter_params;
+      filter_params.set(sl::MeshFilterParameters::MESH_FILTER_MEDIUM);
+
+      // Filter the extracted mesh
+      // zed->mesh.filter(filter_params, true);
+
+      // zed->mesh.applyTexture(sl::MESH_TEXTURE_RGB);
+
+      {
+        cudaArray_t ArrIm;
+        cudaSafeCall(cudaGraphicsMapResources(1, &zed->leftCudaImageResource, 0));
+        cudaSafeCall(cudaGraphicsSubResourceGetMappedArray(&ArrIm, zed->leftCudaImageResource, 0, 0));
+        cudaSafeCall(cudaMemcpy2DToArray(ArrIm, 0, 0, zed->leftImage.getPtr<sl::uchar1>(sl::MEM_GPU), zed->leftImage.getStepBytes(sl::MEM_GPU), zed->leftImage.getPixelBytes()*zed->leftImage.getWidth(), zed->leftImage.getHeight(), cudaMemcpyDeviceToDevice));
+        cudaSafeCall(cudaGraphicsUnmapResources(1, &zed->leftCudaImageResource, 0));
+      }
+      {
+        cudaArray_t ArrIm;
+        cudaSafeCall(cudaGraphicsMapResources(1, &zed->rightCudaImageResource, 0));
+        cudaSafeCall(cudaGraphicsSubResourceGetMappedArray(&ArrIm, zed->rightCudaImageResource, 0, 0));
+        cudaSafeCall(cudaMemcpy2DToArray(ArrIm, 0, 0, zed->rightImage.getPtr<sl::uchar1>(sl::MEM_GPU), zed->rightImage.getStepBytes(sl::MEM_GPU), zed->rightImage.getPixelBytes()*zed->rightImage.getWidth(), zed->rightImage.getHeight(), cudaMemcpyDeviceToDevice));
+        cudaSafeCall(cudaGraphicsUnmapResources(1, &zed->rightCudaImageResource, 0));
+      }
+
+      /* sl::Texture &texture = zed->mesh.texture;
+      sl::Mat &textureMaterial = texture.data;
+      // sl::Resolution &textureResolution = textureMaterial.getResolution();
+      // sl::uchar1 *tex = textureMaterial.getPtr<sl::uchar1>(sl::MEM_GPU);
+
+      size_t width = textureMaterial.getWidth();
+      size_t height = textureMaterial.getHeight();
+      if (width != zed->textureWidth || height != zed->textureHeight) {
+        if (zed->pcuImageRes) {
+          cudaError_t cudaError = cudaGraphicsUnregisterResource(zed->pcuImageRes);
+          zed->pcuImageRes = nullptr;
+        }
+        
+        windowsystem::SetCurrentWindowContext(zed->window);
+
+        glBindTexture(GL_TEXTURE_2D, zed->tex);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
+
+        cudaError_t cudaError = cudaGraphicsGLRegisterImage(&zed->pcuImageRes, zed->tex, GL_TEXTURE_2D, cudaGraphicsRegisterFlagsWriteDiscard);
+
+        zed->textureWidth = width;
+        zed->textureHeight = height;
+      }
+
+      cudaArray_t arrIm;
+      cudaGraphicsMapResources(1, &zed->pcuImageRes, 0);
+      cudaGraphicsSubResourceGetMappedArray(&arrIm, zed->pcuImageRes, 0, 0);
+      cudaMemcpy2DToArray(arrIm, 0, 0, textureMaterial.getPtr<sl::uchar1>(sl::MEM_GPU), textureMaterial.getStepBytes(sl::MEM_GPU), width * sizeof(sl::uchar3), height, cudaMemcpyDeviceToDevice);
+      cudaGraphicsUnmapResources(1, &zed->pcuImageRes, 0); */
+
+      const float range = 5;
+      zed->chunks = zed->mesh.getSurroundingList(pose.pose_data, range);
+
+      if (zed->chunks.size() > 0) {
+        uv_async_send(zed->async);
+        uv_sem_wait(&zed->reqSem);
+      }
+
+      /* //Save as an OBJ file
+      bool error_save = zed->mesh.save("C:\\Users\\avaer\\Documents\\GitHub\\exokit\\mesh_gen.obj");
+      if(error_save) {
+        std::cout << ">> Mesh saved" << std::endl;
+      } else {
+        std::cout << ">> Failed to save mesh" << std::endl;
+      } */
+    }
+  }
+}
+
+NAN_METHOD(Zed::WaitGetPoses) {
+  Zed *zed = ObjectWrap::Unwrap<Zed>(info.This());
+  Local<Float32Array> position = Local<Float32Array>::Cast(info[0]);
+  Local<Float32Array> orientation = Local<Float32Array>::Cast(info[1]);
+
+  float *positions = (float *)((char *)position->Buffer()->GetContents().Data() + position->ByteOffset());
+  float *orientations = (float *)((char *)orientation->Buffer()->GetContents().Data() + orientation->ByteOffset());
+
+  {
+    std::lock_guard<std::mutex> lock(zed->mutex);
+
+    memcpy(positions, zed->position.v, 3*sizeof(float));
+    memcpy(orientations, zed->orientation.v, 4*sizeof(float));
+  }
+
+  if (!zed->result.IsEmpty()) {
+    Local<Array> result = Nan::New(zed->result);
+    zed->result.Reset();
+    info.GetReturnValue().Set(result);
+  } else {
+    info.GetReturnValue().Set(Nan::Null());
+  }
+}
+
+Local<Object> Zed::Initialize(Isolate *isolate) {
+  Nan::EscapableHandleScope scope;
+
+  // constructor
+  Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(New);
+  ctor->InstanceTemplate()->SetInternalFieldCount(1);
+  ctor->SetClassName(JS_STR("Zed"));
+
+  // prototype
+  Local<ObjectTemplate> proto = ctor->PrototypeTemplate();
+  Nan::SetMethod(proto, "RequestPresent", RequestPresent);
+  Nan::SetMethod(proto, "ExitPresent", ExitPresent);
+  Nan::SetMethod(proto, "WaitGetPoses", WaitGetPoses);
+
+  Local<Function> ctorFn = Nan::GetFunction(ctor).ToLocalChecked();
+
+  return scope.Escape(ctorFn);
+}
+
+}
+
+Local<Object> makeZed() {
+  Isolate *isolate = Isolate::GetCurrent();
+
+  Nan::EscapableHandleScope scope;
+
+  Local<Object> exports = zed::Zed::Initialize(isolate);
+
+  return scope.Escape(exports);
+}
\ No newline at end of file
diff --git a/examples/meshing_zed.html b/examples/meshing_zed.html
new file mode 100644
index 0000000000..394470a415
--- /dev/null
+++ b/examples/meshing_zed.html
@@ -0,0 +1,324 @@
+<html>
+   <meta charset="utf-8">
+   <meta http-equiv="X-UA-Compatible" content="IE=edge">
+   <meta name="viewport" content="width=device-width, initial-scale=1">
+   <meta name="theme-color" content="#008000"/>
+   <title>meshing_ml</title>
+   <link rel="manifest" href="meshing_ml_manifest.json">
+   <script>
+    if('serviceWorker' in navigator) {
+      navigator.serviceWorker.register('/meshing_ml_sw.js')
+        .then(function() {
+              console.log('Service Worker Registered');
+        });
+    }
+   </script>
+  <head>
+    <style>
+      body {
+        margin: 0;
+      }
+    </style>
+  </head>
+  <body>
+  <h1>meshing_ml</h1>
+  <script src="three.js"></script>
+  <script>
+    let container, scene, camera, display, cubeMesh, mesher;
+    // let mesher = null;
+
+    const localVector = new THREE.Vector3();
+    const localVector2 = new THREE.Vector3();
+    const localEuler = new THREE.Euler();
+    const localMatrix = new THREE.Matrix4();
+    // const localFloat32Array = new Float32Array(16);
+
+    /* const numCubes = 100;
+    const cubeSize = 0.2;
+    const cubeRange = 1;
+    const cubeGeometry = new THREE.BoxBufferGeometry(1, 1, 1); */
+    
+    const terrainMeshes = [];
+    const terrainMaterial = new THREE.ShaderMaterial({
+      uniforms: {},
+      vertexShader: `\
+        attribute vec3 barycentric;
+        varying vec3 vPosition;
+        varying vec3 vBC;
+        void main() {
+          vBC = barycentric;
+          vec4 modelViewPosition = modelViewMatrix * vec4(position, 1.0);
+          vPosition = modelViewPosition.xyz;
+          gl_Position = projectionMatrix * modelViewPosition;
+        }
+      `,
+      fragmentShader: `\
+        varying vec3 vPosition;
+        varying vec3 vBC;
+
+        vec3 color = vec3(0.984313725490196, 0.5490196078431373, 0.0);
+        vec3 lightDirection = vec3(0.0, 0.0, 1.0);
+
+        float edgeFactor() {
+          vec3 d = fwidth(vBC);
+          vec3 a3 = smoothstep(vec3(0.0), d*1.5, vBC);
+          return min(min(a3.x, a3.y), a3.z);
+        }
+
+        void main() {
+          float barycentricFactor = (0.2 + (1.0 - edgeFactor()) * 0.8);
+          vec3 xTangent = dFdx( vPosition );
+          vec3 yTangent = dFdy( vPosition );
+          vec3 faceNormal = normalize( cross( xTangent, yTangent ) );
+          float lightFactor = pow(dot(faceNormal, lightDirection), 2.0);
+          gl_FragColor = vec4(color * barycentricFactor * lightFactor, 1.0);
+        }
+      `,
+      polygonOffset: true,
+      polygonOffsetFactor: -1,
+      polygonOffsetUnits: -4,
+    });
+    const _getTerrainMesh = meshId => {
+      let terrainMesh = terrainMeshes.find(terrainMesh => terrainMesh.meshId === meshId);
+      if (!terrainMesh) {
+        terrainMesh = _makeTerrainMesh(meshId);
+        terrainMeshes.push(terrainMesh);
+        scene.add(terrainMesh);
+      }
+      return terrainMesh;
+    };
+    const _makeTerrainMesh = meshId => {
+      const geometry = new THREE.BufferGeometry();
+      const material = terrainMaterial;
+
+      const mesh = new THREE.Mesh(geometry, material);
+      mesh.matrixAutoUpdate = false;
+      mesh.frustumCulled = false;
+      mesh.meshId = meshId;
+      mesh.visible = false;
+      return mesh;
+    };
+    const _loadTerrainMesh = (terrainMesh, {transformMatrix, positionArray, normalArray, indexArray}) => {
+      if (indexArray.length > 0) {
+        terrainMesh.matrix.fromArray(transformMatrix);
+        terrainMesh.matrix.decompose(terrainMesh.position, terrainMesh.quaternion, terrainMesh.scale);
+        terrainMesh.updateMatrixWorld(true);
+
+        const {geometry} = terrainMesh;
+        // const attributes = renderer.getAttributes();
+
+        const positions = new Float32Array(indexArray.length*3);
+        const barycentrics = new Float32Array(indexArray.length*3);
+        for (let i = 0; i < indexArray.length; i += 3) {
+          const ai = indexArray[i];
+          const bi = indexArray[i+1];
+          const ci = indexArray[i+2];
+
+          const baseA = ai*3;
+          const baseB = bi*3;
+          const baseC = ci*3;
+
+          const baseIndex = i*3;
+          positions[baseIndex] = positionArray[baseA];
+          positions[baseIndex+1] = positionArray[baseA+1];
+          positions[baseIndex+2] = positionArray[baseA+2];
+          positions[baseIndex+3] = positionArray[baseB];
+          positions[baseIndex+4] = positionArray[baseB+1];
+          positions[baseIndex+5] = positionArray[baseB+2];
+          positions[baseIndex+6] = positionArray[baseC];
+          positions[baseIndex+7] = positionArray[baseC+1];
+          positions[baseIndex+8] = positionArray[baseC+2];
+
+          barycentrics[baseIndex] = 1;
+          barycentrics[baseIndex+1] = 0;
+          barycentrics[baseIndex+2] = 0;
+          barycentrics[baseIndex+3] = 0;
+          barycentrics[baseIndex+4] = 1;
+          barycentrics[baseIndex+5] = 0;
+          barycentrics[baseIndex+6] = 0;
+          barycentrics[baseIndex+7] = 0;
+          barycentrics[baseIndex+8] = 1;
+        }
+        geometry.addAttribute('position', new THREE.BufferAttribute(positions, 3));
+        geometry.addAttribute('barycentric', new THREE.BufferAttribute(barycentrics, 3));
+
+        terrainMesh.visible = true;
+      } else {
+        terrainMesh.visible = false;
+      }
+    };
+    const _removeTerrainMesh = terrainMesh => {
+      scene.remove(terrainMesh);
+      terrainMeshes.splice(terrainMeshes.indexOf(terrainMesh), 1);
+      terrainMesh.geometry.dispose();
+    };
+    /* const _clearTerrainMeshes = () => {
+      for (let i = 0; i < terrainMeshes.length; i++) {
+        _removeTerrainMesh(terrainMeshes[i]);
+      }
+      terrainMeshes.length = 0;
+    }; */
+    const _meshadd = e => {
+      console.log('mesh add', e.update.id);
+      _loadTerrainMesh(_getTerrainMesh(e.update.id), e.update);
+    };
+    const _meshupdate = e => {
+      console.log('mesh update', e.update.id);
+      _loadTerrainMesh(_getTerrainMesh(e.update.id), e.update, e.update.positionArray.length, e.update.normalArray.length, e.update.indexArray.length);
+    };
+    const _meshremove = e => {
+      console.log('mesh remove', e.update.id);
+      const index = terrainMeshes.findIndex(terrainMesh => terrainMesh.meshId === e.update.id);
+      if (index !== -1) {
+        const terrainMesh = terrainMeshes[index];
+        _removeTerrainMesh(terrainMesh);
+      }
+    };
+    /* const _onMesh = e => {
+      const {updates} = e;
+      for (let i = 0; i < updates.length; i++) {
+        const update = updates[i];
+        const {id, type} = update;
+
+        if (type === 'new' || type === 'update') {
+          _loadTerrainMesh(_getTerrainMesh(id), update);
+        } else if (type === 'unchanged') {
+          // nothing
+        } else {
+          const index = terrainMeshes.findIndex(terrainMesh => terrainMesh.meshId === id);
+          if (index !== -1) {
+            const terrainMesh = terrainMeshes[index];
+            _removeTerrainMesh(terrainMesh);
+            terrainMeshes.splice(index, 1);
+          }
+        }
+      }
+    }; */
+
+    function init() {
+      container = document.createElement('div');
+      document.body.appendChild(container);
+
+      scene = new THREE.Scene();
+      scene.matrixAutoUpdate = false;
+      // scene.background = new THREE.Color(0x3B3961);
+
+      camera = new THREE.PerspectiveCamera(60, window.innerWidth / window.innerHeight, 0.1, 1000);
+      // camera.position.set(0, 1, 0);
+      // camera.lookAt(new THREE.Vector3());
+      scene.add(camera);
+
+      const ambientLight = new THREE.AmbientLight(0x808080);
+      scene.add(ambientLight);
+
+      const directionalLight = new THREE.DirectionalLight(0xFFFFFF, 1);
+      directionalLight.position.set(1, 1, 1);
+      scene.add(directionalLight);
+      
+      cubeMesh = (() => {
+        const geometry = new THREE.BoxBufferGeometry(0.1, 0.1, 0.1);
+        const material = new THREE.MeshPhongMaterial({
+          color: 0xab47bc,
+        });
+        const mesh = new THREE.Mesh(geometry, material);
+        // mesh.position.x = parseFloat(query.x) || 0;
+        /* mesh.position.x = 0.05;
+        mesh.position.y = 1.55;
+        mesh.position.z = -1 + 0.05; */
+        // mesh.rotation.order = 'YXZ';
+        mesh.frustumCulled = false;
+        return mesh;
+      })();
+      scene.add(cubeMesh);
+
+      renderer = new THREE.WebGLRenderer({
+        antialias: true,
+        alpha: true,
+      });
+      renderer.setPixelRatio(window.devicePixelRatio);
+      renderer.setSize(window.innerWidth, window.innerHeight);
+
+      // window.browser.magicleap.RequestDepthPopulation(true);
+      // renderer.autoClear = false;
+
+      container.appendChild(renderer.domElement);
+
+      renderer.setAnimationLoop(animate);
+    }
+
+    function animate(time, frame) {
+      /* if (model) {
+        const animationTime = 4000;
+        const f = ((Date.now() % animationTime) / animationTime) * (Math.PI * 2);
+        model.quaternion.setFromUnitVectors(
+          new THREE.Vector3(0, 0, 1),
+          new THREE.Vector3(Math.cos(f), 0, Math.sin(f)).normalize()
+        );
+        model.updateMatrixWorld();
+      } */
+
+      if (mesher) {
+        cubeMesh.position.fromArray(mesher.position);
+        cubeMesh.quaternion.fromArray(mesher.orientation);
+      }
+
+      renderer.render(scene, renderer.vr.enabled ? renderer.vr.getCamera(camera) : camera);
+    }
+
+    init();
+
+    (async () => {
+      console.log('request device');
+      display = await navigator.xr.requestDevice();
+      console.log('request session');
+      const session = await display.requestSession({
+        exclusive: true,
+        /* extensions: {
+          meshing: true,
+        }, */
+      });
+
+      // console.log('request first frame');
+      session.requestAnimationFrame((timestamp, frame) => {
+        renderer.vr.setSession(session, {
+          frameOfReferenceType: 'stage',
+        });
+
+        const viewport = session.baseLayer.getViewport(frame.views[0]);
+        const width = viewport.width;
+        const height = viewport.height;
+
+        renderer.setSize(width * 2, height);
+
+        renderer.setAnimationLoop(null);
+
+        renderer.vr.enabled = true;
+        renderer.vr.setDevice(display);
+        renderer.vr.setAnimationLoop(animate);
+        
+        session.addEventListener('meshadd', _meshadd);
+        session.addEventListener('meshupdate', _meshupdate);
+        session.addEventListener('meshremove', _meshremove);
+        
+        mesher = window.zed.requestMeshing();
+        mesher.on('meshes', meshes => {
+          const oldMeshes = terrainMeshes.slice();
+          for (let i = 0; i < oldMeshes.length; i++) {
+            _removeTerrainMesh(oldMeshes[i]);
+          }
+          for (let i = 0; i < meshes.length; i++) {
+            const update = meshes[i];
+            update.id = Math.random() + '';
+            update.transformMatrix = localMatrix.identity().toArray(new Float32Array(16));
+            _meshadd({
+              update,
+            });
+          }
+        });
+
+        console.log('running!');
+      });
+    })();
+  </script>
+  </body>
+</html>
diff --git a/exokit.cpp b/exokit.cpp
index b944e789e8..545955e149 100644
--- a/exokit.cpp
+++ b/exokit.cpp
@@ -97,6 +97,9 @@ void InitExports(Local<Object> exports) {
   exports->Set(v8::String::NewFromUtf8(Isolate::GetCurrent(), "nativeMl"), ml);
 #endif
 
+  Local<Value> zed = makeZed();
+  exports->Set(v8::String::NewFromUtf8(Isolate::GetCurrent(), "nativeZed"), zed);
+
 #if defined(ANDROID)
 #define NATIVE_PLATFORM "android"
 #elif defined(LUMIN)
diff --git a/src/Window.js b/src/Window.js
index 636f10e8d5..6765fb7c40 100644
--- a/src/Window.js
+++ b/src/Window.js
@@ -99,6 +99,7 @@ const {
   nativeOculusVR,
   nativeOculusMobileVr,
   nativeMl,
+  nativeZed,
   nativeBrowser,
   nativeWindow,
 } = require('./native-bindings');
@@ -814,6 +815,18 @@ const _makeRequestAnimationFrame = window => (fn, priority = 0) => {
       }
     },
   };
+  let zedContext = null;
+  window.zed = {
+    requestMeshing(fn) {
+      zedContext = new nativeZed();
+      zedContext.RequestPresent(fn);
+      zedContext.emitter = new EventEmitter();
+      zedContext.emitter.position = new Float32Array(3);
+      zedContext.emitter.orientation = new Float32Array(4);
+      zedContext.emitter.orientation[3] = 1;
+      return zedContext.emitter;
+    },
+  };
   window.DOMParser = class DOMParser {
     parseFromString(htmlString, type) {
       const _recurse = node => {
@@ -1162,6 +1175,13 @@ const _makeRequestAnimationFrame = window => (fn, priority = 0) => {
       }
     }
 
+    if (zedContext) {
+      const meshes = zedContext.WaitGetPoses(zedContext.emitter.position, zedContext.emitter.orientation);
+      if (meshes) {
+        zedContext.emitter.emit('meshes', meshes);
+      }
+    }
+
     _tickLocalRafs();
     return _composeLocalLayers(layered);
   };