diff --git a/fuse-bindings.cc b/fuse-bindings.cc
index b2b133a..b84323c 100644
--- a/fuse-bindings.cc
+++ b/fuse-bindings.cc
@@ -15,6 +15,9 @@
 
 using namespace v8;
 
+#define LOCAL_STRING(s) Nan::New<String>(s).ToLocalChecked()
+#define LOOKUP_CALLBACK(map, name) map->Has(LOCAL_STRING(name)) ? new Nan::Callback(map->Get(LOCAL_STRING(name)).As<Function>()) : NULL
+
 enum bindings_ops_t {
   OP_INIT = 0,
   OP_ERROR,
@@ -51,8 +54,8 @@ enum bindings_ops_t {
   OP_DESTROY
 };
 
-static Persistent<Function> buffer_constructor;
-static NanCallback *callback_constructor;
+static Nan::Persistent<Function> buffer_constructor;
+static Nan::Callback *callback_constructor;
 static struct stat empty_stat;
 
 struct bindings_t {
@@ -72,41 +75,41 @@ struct bindings_t {
   uv_async_t async;
 
   // methods
-  NanCallback *ops_init;
-  NanCallback *ops_error;
-  NanCallback *ops_access;
-  NanCallback *ops_statfs;
-  NanCallback *ops_getattr;
-  NanCallback *ops_fgetattr;
-  NanCallback *ops_flush;
-  NanCallback *ops_fsync;
-  NanCallback *ops_fsyncdir;
-  NanCallback *ops_readdir;
-  NanCallback *ops_truncate;
-  NanCallback *ops_ftruncate;
-  NanCallback *ops_readlink;
-  NanCallback *ops_chown;
-  NanCallback *ops_chmod;
-  NanCallback *ops_mknod;
-  NanCallback *ops_setxattr;
-  NanCallback *ops_getxattr;
-  NanCallback *ops_open;
-  NanCallback *ops_opendir;
-  NanCallback *ops_read;
-  NanCallback *ops_write;
-  NanCallback *ops_release;
-  NanCallback *ops_releasedir;
-  NanCallback *ops_create;
-  NanCallback *ops_utimens;
-  NanCallback *ops_unlink;
-  NanCallback *ops_rename;
-  NanCallback *ops_link;
-  NanCallback *ops_symlink;
-  NanCallback *ops_mkdir;
-  NanCallback *ops_rmdir;
-  NanCallback *ops_destroy;
+  Nan::Callback *ops_init;
+  Nan::Callback *ops_error;
+  Nan::Callback *ops_access;
+  Nan::Callback *ops_statfs;
+  Nan::Callback *ops_getattr;
+  Nan::Callback *ops_fgetattr;
+  Nan::Callback *ops_flush;
+  Nan::Callback *ops_fsync;
+  Nan::Callback *ops_fsyncdir;
+  Nan::Callback *ops_readdir;
+  Nan::Callback *ops_truncate;
+  Nan::Callback *ops_ftruncate;
+  Nan::Callback *ops_readlink;
+  Nan::Callback *ops_chown;
+  Nan::Callback *ops_chmod;
+  Nan::Callback *ops_mknod;
+  Nan::Callback *ops_setxattr;
+  Nan::Callback *ops_getxattr;
+  Nan::Callback *ops_open;
+  Nan::Callback *ops_opendir;
+  Nan::Callback *ops_read;
+  Nan::Callback *ops_write;
+  Nan::Callback *ops_release;
+  Nan::Callback *ops_releasedir;
+  Nan::Callback *ops_create;
+  Nan::Callback *ops_utimens;
+  Nan::Callback *ops_unlink;
+  Nan::Callback *ops_rename;
+  Nan::Callback *ops_link;
+  Nan::Callback *ops_symlink;
+  Nan::Callback *ops_mkdir;
+  Nan::Callback *ops_rmdir;
+  Nan::Callback *ops_destroy;
 
-  NanCallback *callback;
+  Nan::Callback *callback;
 
   // method data
   bindings_ops_t op;
@@ -151,18 +154,19 @@ static void bindings_unmount (char *path) {
   mutex_unlock(&mutex);
 }
 
-
-#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
+#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION && NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION)
 NAN_INLINE v8::Local<v8::Object> bindings_buffer (char *data, size_t length) {
-  Local<Object> buf = NanNew(buffer_constructor)->NewInstance(0, NULL);
-  buf->Set(NanNew<String>("length"), NanNew<Number>(length));
+  Local<Object> buf = Nan::New(buffer_constructor)->NewInstance(0, NULL);
+  Local<String> k = LOCAL_STRING("length");
+  Local<Number> v = Nan::New<Number>(length);
+  buf->Set(k, v);
   buf->SetIndexedPropertiesToExternalArrayData((char *) data, kExternalUnsignedByteArray, length);
   return buf;
 }
 #else
 void noop (char *data, void *hint) {}
 NAN_INLINE v8::Local<v8::Object> bindings_buffer (char *data, size_t length) {
-  return NanNewBufferHandle(data, length, noop, NULL);
+  return Nan::NewBuffer(data, length, noop, NULL).ToLocalChecked();
 }
 #endif
 
@@ -675,7 +679,7 @@ static thread_fn_rtn_t bindings_thread (void *data) {
 #ifndef _WIN32
 NAN_INLINE static Local<Date> bindings_get_date (struct timespec *out) {
   int ms = (out->tv_nsec / 1000);
-  return NanNew<Date>(out->tv_sec * 1000 + ms);
+  return Nan::New<Date>(out->tv_sec * 1000 + ms).ToLocalChecked();
 }
 
 NAN_INLINE static void bindings_set_date (struct timespec *out, Local<Date> date) {
@@ -688,7 +692,7 @@ NAN_INLINE static void bindings_set_date (struct timespec *out, Local<Date> date
 }
 #else
 NAN_INLINE static Local<Date> bindings_get_date (time_t *out) {
-  return NanNew<Date>(*out * 1000.0);
+  return Nan::New<Date>(*out * 1000.0);
 }
 
 NAN_INLINE static void bindings_set_date (time_t *out, Local<Date> date) {
@@ -699,91 +703,90 @@ NAN_INLINE static void bindings_set_date (time_t *out, Local<Date> date) {
 #endif
 
 NAN_INLINE static void bindings_set_stat (struct stat *stat, Local<Object> obj) {
-  if (obj->Has(NanNew<String>("dev"))) stat->st_dev = obj->Get(NanNew<String>("dev"))->NumberValue();
-  if (obj->Has(NanNew<String>("ino"))) stat->st_ino = obj->Get(NanNew<String>("ino"))->NumberValue();
-  if (obj->Has(NanNew<String>("mode"))) stat->st_mode = obj->Get(NanNew<String>("mode"))->Uint32Value();
-  if (obj->Has(NanNew<String>("nlink"))) stat->st_nlink = obj->Get(NanNew<String>("nlink"))->NumberValue();
-  if (obj->Has(NanNew<String>("uid"))) stat->st_uid = obj->Get(NanNew<String>("uid"))->NumberValue();
-  if (obj->Has(NanNew<String>("gid"))) stat->st_gid = obj->Get(NanNew<String>("gid"))->NumberValue();
-  if (obj->Has(NanNew<String>("rdev"))) stat->st_rdev = obj->Get(NanNew<String>("rdev"))->NumberValue();
-  if (obj->Has(NanNew<String>("size"))) stat->st_size = obj->Get(NanNew<String>("size"))->NumberValue();
+  if (obj->Has(LOCAL_STRING("dev"))) stat->st_dev = obj->Get(LOCAL_STRING("dev"))->NumberValue();
+  if (obj->Has(LOCAL_STRING("ino"))) stat->st_ino = obj->Get(LOCAL_STRING("ino"))->NumberValue();
+  if (obj->Has(LOCAL_STRING("mode"))) stat->st_mode = obj->Get(LOCAL_STRING("mode"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("nlink"))) stat->st_nlink = obj->Get(LOCAL_STRING("nlink"))->NumberValue();
+  if (obj->Has(LOCAL_STRING("uid"))) stat->st_uid = obj->Get(LOCAL_STRING("uid"))->NumberValue();
+  if (obj->Has(LOCAL_STRING("gid"))) stat->st_gid = obj->Get(LOCAL_STRING("gid"))->NumberValue();
+  if (obj->Has(LOCAL_STRING("rdev"))) stat->st_rdev = obj->Get(LOCAL_STRING("rdev"))->NumberValue();
+  if (obj->Has(LOCAL_STRING("size"))) stat->st_size = obj->Get(LOCAL_STRING("size"))->NumberValue();
 #ifndef _WIN32
-  if (obj->Has(NanNew<String>("blocks"))) stat->st_blocks = obj->Get(NanNew<String>("blocks"))->NumberValue();
-  if (obj->Has(NanNew<String>("blksize"))) stat->st_blksize = obj->Get(NanNew<String>("blksize"))->NumberValue();
+  if (obj->Has(LOCAL_STRING("blocks"))) stat->st_blocks = obj->Get(LOCAL_STRING("blocks"))->NumberValue();
+  if (obj->Has(LOCAL_STRING("blksize"))) stat->st_blksize = obj->Get(LOCAL_STRING("blksize"))->NumberValue();
 #endif
 #ifdef __APPLE__
-  if (obj->Has(NanNew<String>("mtime"))) bindings_set_date(&stat->st_mtimespec, obj->Get(NanNew("mtime")).As<Date>());
-  if (obj->Has(NanNew<String>("ctime"))) bindings_set_date(&stat->st_ctimespec, obj->Get(NanNew("ctime")).As<Date>());
-  if (obj->Has(NanNew<String>("atime"))) bindings_set_date(&stat->st_atimespec, obj->Get(NanNew("atime")).As<Date>());
+  if (obj->Has(LOCAL_STRING("mtime"))) bindings_set_date(&stat->st_mtimespec, obj->Get(LOCAL_STRING("mtime")).As<Date>());
+  if (obj->Has(LOCAL_STRING("ctime"))) bindings_set_date(&stat->st_ctimespec, obj->Get(LOCAL_STRING("ctime")).As<Date>());
+  if (obj->Has(LOCAL_STRING("atime"))) bindings_set_date(&stat->st_atimespec, obj->Get(LOCAL_STRING("atime")).As<Date>());
 #elif defined(_WIN32)
-  if (obj->Has(NanNew<String>("mtime"))) bindings_set_date(&stat->st_mtime, obj->Get(NanNew("mtime")).As<Date>());
-  if (obj->Has(NanNew<String>("ctime"))) bindings_set_date(&stat->st_ctime, obj->Get(NanNew("ctime")).As<Date>());
-  if (obj->Has(NanNew<String>("atime"))) bindings_set_date(&stat->st_atime, obj->Get(NanNew("atime")).As<Date>());
+  if (obj->Has(LOCAL_STRING("mtime"))) bindings_set_date(&stat->st_mtime, obj->Get(LOCAL_STRING("mtime")).As<Date>());
+  if (obj->Has(LOCAL_STRING("ctime"))) bindings_set_date(&stat->st_ctime, obj->Get(LOCAL_STRING("ctime")).As<Date>());
+  if (obj->Has(LOCAL_STRING("atime"))) bindings_set_date(&stat->st_atime, obj->Get(LOCAL_STRING("atime")).As<Date>());
 #else
-  if (obj->Has(NanNew<String>("mtime"))) bindings_set_date(&stat->st_mtim, obj->Get(NanNew("mtime")).As<Date>());
-  if (obj->Has(NanNew<String>("ctime"))) bindings_set_date(&stat->st_ctim, obj->Get(NanNew("ctime")).As<Date>());
-  if (obj->Has(NanNew<String>("atime"))) bindings_set_date(&stat->st_atim, obj->Get(NanNew("atime")).As<Date>());
+  if (obj->Has(LOCAL_STRING("mtime"))) bindings_set_date(&stat->st_mtim, obj->Get(LOCAL_STRING("mtime")).As<Date>());
+  if (obj->Has(LOCAL_STRING("ctime"))) bindings_set_date(&stat->st_ctim, obj->Get(LOCAL_STRING("ctime")).As<Date>());
+  if (obj->Has(LOCAL_STRING("atime"))) bindings_set_date(&stat->st_atim, obj->Get(LOCAL_STRING("atime")).As<Date>());
 #endif
 }
 
 NAN_INLINE static void bindings_set_statfs (struct statvfs *statfs, Local<Object> obj) { // from http://linux.die.net/man/2/stat
-  if (obj->Has(NanNew<String>("bsize"))) statfs->f_bsize = obj->Get(NanNew<String>("bsize"))->Uint32Value();
-  if (obj->Has(NanNew<String>("frsize"))) statfs->f_frsize = obj->Get(NanNew<String>("frsize"))->Uint32Value();
-  if (obj->Has(NanNew<String>("blocks"))) statfs->f_blocks = obj->Get(NanNew<String>("blocks"))->Uint32Value();
-  if (obj->Has(NanNew<String>("bfree"))) statfs->f_bfree = obj->Get(NanNew<String>("bfree"))->Uint32Value();
-  if (obj->Has(NanNew<String>("bavail"))) statfs->f_bavail = obj->Get(NanNew<String>("bavail"))->Uint32Value();
-  if (obj->Has(NanNew<String>("files"))) statfs->f_files = obj->Get(NanNew<String>("files"))->Uint32Value();
-  if (obj->Has(NanNew<String>("ffree"))) statfs->f_ffree = obj->Get(NanNew<String>("ffree"))->Uint32Value();
-  if (obj->Has(NanNew<String>("favail"))) statfs->f_favail = obj->Get(NanNew<String>("favail"))->Uint32Value();
-  if (obj->Has(NanNew<String>("fsid"))) statfs->f_fsid = obj->Get(NanNew<String>("fsid"))->Uint32Value();
-  if (obj->Has(NanNew<String>("flag"))) statfs->f_flag = obj->Get(NanNew<String>("flag"))->Uint32Value();
-  if (obj->Has(NanNew<String>("namemax"))) statfs->f_namemax = obj->Get(NanNew<String>("namemax"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("bsize"))) statfs->f_bsize = obj->Get(LOCAL_STRING("bsize"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("frsize"))) statfs->f_frsize = obj->Get(LOCAL_STRING("frsize"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("blocks"))) statfs->f_blocks = obj->Get(LOCAL_STRING("blocks"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("bfree"))) statfs->f_bfree = obj->Get(LOCAL_STRING("bfree"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("bavail"))) statfs->f_bavail = obj->Get(LOCAL_STRING("bavail"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("files"))) statfs->f_files = obj->Get(LOCAL_STRING("files"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("ffree"))) statfs->f_ffree = obj->Get(LOCAL_STRING("ffree"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("favail"))) statfs->f_favail = obj->Get(LOCAL_STRING("favail"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("fsid"))) statfs->f_fsid = obj->Get(LOCAL_STRING("fsid"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("flag"))) statfs->f_flag = obj->Get(LOCAL_STRING("flag"))->Uint32Value();
+  if (obj->Has(LOCAL_STRING("namemax"))) statfs->f_namemax = obj->Get(LOCAL_STRING("namemax"))->Uint32Value();
 }
 
 NAN_INLINE static void bindings_set_dirs (bindings_t *b, Local<Array> dirs) {
+  Nan::HandleScope scope;
   for (uint32_t i = 0; i < dirs->Length(); i++) {
-    NanUtf8String dir(dirs->Get(i));
+    Nan::Utf8String dir(dirs->Get(i));
     if (b->filler(b->data, *dir, &empty_stat, 0)) break;
   }
 }
 
 NAN_METHOD(OpCallback) {
-  NanScope();
-
-  bindings_t *b = bindings_mounted[args[0]->Uint32Value()];
-  b->result = (args.Length() > 1 && args[1]->IsNumber()) ? args[1]->Uint32Value() : 0;
+  bindings_t *b = bindings_mounted[info[0]->Uint32Value()];
+  b->result = (info.Length() > 1 && info[1]->IsNumber()) ? info[1]->Uint32Value() : 0;
   bindings_current = NULL;
 
   if (!b->result) {
     switch (b->op) {
       case OP_STATFS: {
-        if (args.Length() > 2 && args[2]->IsObject()) bindings_set_statfs((struct statvfs *) b->data, args[2].As<Object>());
+        if (info.Length() > 2 && info[2]->IsObject()) bindings_set_statfs((struct statvfs *) b->data, info[2].As<Object>());
       }
       break;
 
       case OP_GETATTR:
       case OP_FGETATTR: {
-        if (args.Length() > 2 && args[2]->IsObject()) bindings_set_stat((struct stat *) b->data, args[2].As<Object>());
+        if (info.Length() > 2 && info[2]->IsObject()) bindings_set_stat((struct stat *) b->data, info[2].As<Object>());
       }
       break;
 
       case OP_READDIR: {
-        if (args.Length() > 2 && args[2]->IsArray()) bindings_set_dirs(b, args[2].As<Array>());
+        if (info.Length() > 2 && info[2]->IsArray()) bindings_set_dirs(b, info[2].As<Array>());
       }
       break;
 
       case OP_CREATE:
       case OP_OPEN:
       case OP_OPENDIR: {
-        if (args.Length() > 2 && args[2]->IsNumber()) {
-          b->info->fh = args[2].As<Number>()->Uint32Value();
+        if (info.Length() > 2 && info[2]->IsNumber()) {
+          b->info->fh = info[2].As<Number>()->Uint32Value();
         }
       }
       break;
 
       case OP_READLINK: {
-        if (args.Length() > 2 && args[2]->IsString()) {
-          NanUtf8String path(args[2]);
+        if (info.Length() > 2 && info[2]->IsString()) {
+          Nan::Utf8String path(info[2]);
           strcpy((char *) b->data, *path);
         }
       }
@@ -819,16 +822,15 @@ NAN_METHOD(OpCallback) {
   }
 
   semaphore_signal(&(b->semaphore));
-  NanReturnUndefined();
 }
 
-NAN_INLINE static void bindings_call_op (bindings_t *b, NanCallback *fn, int argc, Local<Value> *argv) {
+NAN_INLINE static void bindings_call_op (bindings_t *b, Nan::Callback *fn, int argc, Local<Value> *argv) {
   if (fn == NULL) semaphore_signal(&(b->semaphore));
   else fn->Call(argc, argv);
 }
 
 static void bindings_dispatch (uv_async_t* handle, int status) {
-  NanScope();
+  Nan::HandleScope scope;
 
   bindings_t *b = bindings_current = (bindings_t *) handle->data;
   Local<Function> callback = b->callback->GetFunction();
@@ -848,72 +850,72 @@ static void bindings_dispatch (uv_async_t* handle, int status) {
     return;
 
     case OP_STATFS: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), callback};
       bindings_call_op(b, b->ops_statfs, 2, tmp);
     }
     return;
 
     case OP_FGETATTR: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->info->fh), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->info->fh), callback};
       bindings_call_op(b, b->ops_fgetattr, 3, tmp);
     }
     return;
 
     case OP_GETATTR: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), callback};
       bindings_call_op(b, b->ops_getattr, 2, tmp);
     }
     return;
 
     case OP_READDIR: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), callback};
       bindings_call_op(b, b->ops_readdir, 2, tmp);
     }
     return;
 
     case OP_CREATE: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->mode), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->mode), callback};
       bindings_call_op(b, b->ops_create, 3, tmp);
     }
     return;
 
     case OP_TRUNCATE: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->length), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->length), callback};
       bindings_call_op(b, b->ops_truncate, 3, tmp);
     }
     return;
 
     case OP_FTRUNCATE: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->info->fh), NanNew<Number>(b->length), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->info->fh), Nan::New<Number>(b->length), callback};
       bindings_call_op(b, b->ops_ftruncate, 4, tmp);
     }
     return;
 
     case OP_ACCESS: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->mode), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->mode), callback};
       bindings_call_op(b, b->ops_access, 3, tmp);
     }
     return;
 
     case OP_OPEN: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->mode), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->mode), callback};
       bindings_call_op(b, b->ops_open, 3, tmp);
     }
     return;
 
     case OP_OPENDIR: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->mode), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->mode), callback};
       bindings_call_op(b, b->ops_opendir, 3, tmp);
     }
     return;
 
     case OP_WRITE: {
       Local<Value> tmp[] = {
-        NanNew<String>(b->path),
-        NanNew<Number>(b->info->fh),
+        LOCAL_STRING(b->path),
+        Nan::New<Number>(b->info->fh),
         bindings_buffer((char *) b->data, b->length),
-        NanNew<Number>(b->length),
-        NanNew<Number>(b->offset),
+        Nan::New<Number>(b->length), // TODO: remove me
+        Nan::New<Number>(b->offset),
         callback
       };
       bindings_call_op(b, b->ops_write, 6, tmp);
@@ -922,11 +924,11 @@ static void bindings_dispatch (uv_async_t* handle, int status) {
 
     case OP_READ: {
       Local<Value> tmp[] = {
-        NanNew<String>(b->path),
-        NanNew<Number>(b->info->fh),
+        LOCAL_STRING(b->path),
+        Nan::New<Number>(b->info->fh),
         bindings_buffer((char *) b->data, b->length),
-        NanNew<Number>(b->length),
-        NanNew<Number>(b->offset),
+        Nan::New<Number>(b->length), // TODO: remove me
+        Nan::New<Number>(b->offset),
         callback
       };
       bindings_call_op(b, b->ops_read, 6, tmp);
@@ -934,73 +936,73 @@ static void bindings_dispatch (uv_async_t* handle, int status) {
     return;
 
     case OP_RELEASE: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->info->fh), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->info->fh), callback};
       bindings_call_op(b, b->ops_release, 3, tmp);
     }
     return;
 
     case OP_RELEASEDIR: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->info->fh), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->info->fh), callback};
       bindings_call_op(b, b->ops_releasedir, 3, tmp);
     }
     return;
 
     case OP_UNLINK: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), callback};
       bindings_call_op(b, b->ops_unlink, 2, tmp);
     }
     return;
 
     case OP_RENAME: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<String>((char *) b->data), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), LOCAL_STRING((char *) b->data), callback};
       bindings_call_op(b, b->ops_rename, 3, tmp);
     }
     return;
 
     case OP_LINK: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<String>((char *) b->data), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), LOCAL_STRING((char *) b->data), callback};
       bindings_call_op(b, b->ops_link, 3, tmp);
     }
     return;
 
     case OP_SYMLINK: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<String>((char *) b->data), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), LOCAL_STRING((char *) b->data), callback};
       bindings_call_op(b, b->ops_symlink, 3, tmp);
     }
     return;
 
     case OP_CHMOD: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->mode), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->mode), callback};
       bindings_call_op(b, b->ops_chmod, 3, tmp);
     }
     return;
 
     case OP_MKNOD: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->mode), NanNew<Number>(b->dev), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->mode), Nan::New<Number>(b->dev), callback};
       bindings_call_op(b, b->ops_mknod, 4, tmp);
     }
     return;
 
     case OP_CHOWN: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->uid), NanNew<Number>(b->gid), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->uid), Nan::New<Number>(b->gid), callback};
       bindings_call_op(b, b->ops_chown, 4, tmp);
     }
     return;
 
     case OP_READLINK: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), callback};
       bindings_call_op(b, b->ops_readlink, 2, tmp);
     }
     return;
 
     case OP_SETXATTR: {
       Local<Value> tmp[] = {
-        NanNew<String>(b->path),
-        NanNew<String>(b->name),
+        LOCAL_STRING(b->path),
+        LOCAL_STRING(b->name),
         bindings_buffer((char *) b->data, b->length),
-        NanNew<Number>(b->length),
-        NanNew<Number>(b->offset),
-        NanNew<Number>(b->mode),
+        Nan::New<Number>(b->length),
+        Nan::New<Number>(b->offset),
+        Nan::New<Number>(b->mode),
         callback
       };
       bindings_call_op(b, b->ops_setxattr, 7, tmp);
@@ -1009,11 +1011,11 @@ static void bindings_dispatch (uv_async_t* handle, int status) {
 
     case OP_GETXATTR: {
       Local<Value> tmp[] = {
-        NanNew<String>(b->path),
-        NanNew<String>(b->name),
+        LOCAL_STRING(b->path),
+        LOCAL_STRING(b->name),
         bindings_buffer((char *) b->data, b->length),
-        NanNew<Number>(b->length),
-        NanNew<Number>(b->offset),
+        Nan::New<Number>(b->length),
+        Nan::New<Number>(b->offset),
         callback
       };
       bindings_call_op(b, b->ops_getxattr, 6, tmp);
@@ -1021,13 +1023,13 @@ static void bindings_dispatch (uv_async_t* handle, int status) {
     return;
 
     case OP_MKDIR: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->mode), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->mode), callback};
       bindings_call_op(b, b->ops_mkdir, 3, tmp);
     }
     return;
 
     case OP_RMDIR: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), callback};
       bindings_call_op(b, b->ops_rmdir, 2, tmp);
     }
     return;
@@ -1044,25 +1046,25 @@ static void bindings_dispatch (uv_async_t* handle, int status) {
 #else
       struct timespec *tv = (struct timespec *) b->data;
 #endif
-      Local<Value> tmp[] = {NanNew<String>(b->path), bindings_get_date(tv), bindings_get_date(tv + 1), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), bindings_get_date(tv), bindings_get_date(tv + 1), callback};
       bindings_call_op(b, b->ops_utimens, 4, tmp);
     }
     return;
 
     case OP_FLUSH: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->info->fh), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->info->fh), callback};
       bindings_call_op(b, b->ops_flush, 3, tmp);
     }
     return;
 
     case OP_FSYNC: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->info->fh), NanNew<Number>(b->mode), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->info->fh), Nan::New<Number>(b->mode), callback};
       bindings_call_op(b, b->ops_fsync, 4, tmp);
     }
     return;
 
     case OP_FSYNCDIR: {
-      Local<Value> tmp[] = {NanNew<String>(b->path), NanNew<Number>(b->info->fh), NanNew<Number>(b->mode), callback};
+      Local<Value> tmp[] = {LOCAL_STRING(b->path), Nan::New<Number>(b->info->fh), Nan::New<Number>(b->mode), callback};
       bindings_call_op(b, b->ops_fsyncdir, 4, tmp);
     }
     return;
@@ -1093,15 +1095,13 @@ static int bindings_alloc () {
 }
 
 NAN_METHOD(Mount) {
-  NanScope();
-
-  if (!args[0]->IsString()) return NanThrowError("mnt must be a string");
+  if (!info[0]->IsString()) return Nan::ThrowError("mnt must be a string");
 
   mutex_lock(&mutex);
   int index = bindings_alloc();
   mutex_unlock(&mutex);
 
-  if (index == -1) return NanThrowError("You cannot mount more than 1024 filesystem in one process");
+  if (index == -1) return Nan::ThrowError("You cannot mount more than 1024 filesystem in one process");
 
   mutex_lock(&mutex);
   bindings_t *b = bindings_mounted[index];
@@ -1110,53 +1110,53 @@ NAN_METHOD(Mount) {
   memset(&empty_stat, 0, sizeof(empty_stat));
   memset(b, 0, sizeof(bindings_t));
 
-  NanUtf8String path(args[0]);
-  Local<Object> ops = args[1].As<Object>();
+  Nan::Utf8String path(info[0]);
+  Local<Object> ops = info[1].As<Object>();
 
-  b->ops_init = ops->Has(NanNew<String>("init")) ? new NanCallback(ops->Get(NanNew<String>("init")).As<Function>()) : NULL;
-  b->ops_error = ops->Has(NanNew<String>("error")) ? new NanCallback(ops->Get(NanNew<String>("error")).As<Function>()) : NULL;
-  b->ops_access = ops->Has(NanNew<String>("access")) ? new NanCallback(ops->Get(NanNew<String>("access")).As<Function>()) : NULL;
-  b->ops_statfs = ops->Has(NanNew<String>("statfs")) ? new NanCallback(ops->Get(NanNew<String>("statfs")).As<Function>()) : NULL;
-  b->ops_getattr = ops->Has(NanNew<String>("getattr")) ? new NanCallback(ops->Get(NanNew<String>("getattr")).As<Function>()) : NULL;
-  b->ops_fgetattr = ops->Has(NanNew<String>("fgetattr")) ? new NanCallback(ops->Get(NanNew<String>("fgetattr")).As<Function>()) : NULL;
-  b->ops_flush = ops->Has(NanNew<String>("flush")) ? new NanCallback(ops->Get(NanNew<String>("flush")).As<Function>()) : NULL;
-  b->ops_fsync = ops->Has(NanNew<String>("fsync")) ? new NanCallback(ops->Get(NanNew<String>("fsync")).As<Function>()) : NULL;
-  b->ops_fsyncdir = ops->Has(NanNew<String>("fsyncdir")) ? new NanCallback(ops->Get(NanNew<String>("fsyncdir")).As<Function>()) : NULL;
-  b->ops_readdir = ops->Has(NanNew<String>("readdir")) ? new NanCallback(ops->Get(NanNew<String>("readdir")).As<Function>()) : NULL;
-  b->ops_truncate = ops->Has(NanNew<String>("truncate")) ? new NanCallback(ops->Get(NanNew<String>("truncate")).As<Function>()) : NULL;
-  b->ops_ftruncate = ops->Has(NanNew<String>("ftruncate")) ? new NanCallback(ops->Get(NanNew<String>("ftruncate")).As<Function>()) : NULL;
-  b->ops_readlink = ops->Has(NanNew<String>("readlink")) ? new NanCallback(ops->Get(NanNew<String>("readlink")).As<Function>()) : NULL;
-  b->ops_chown = ops->Has(NanNew<String>("chown")) ? new NanCallback(ops->Get(NanNew<String>("chown")).As<Function>()) : NULL;
-  b->ops_chmod = ops->Has(NanNew<String>("chmod")) ? new NanCallback(ops->Get(NanNew<String>("chmod")).As<Function>()) : NULL;
-  b->ops_mknod = ops->Has(NanNew<String>("mknod")) ? new NanCallback(ops->Get(NanNew<String>("mknod")).As<Function>()) : NULL;
-  b->ops_setxattr = ops->Has(NanNew<String>("setxattr")) ? new NanCallback(ops->Get(NanNew<String>("setxattr")).As<Function>()) : NULL;
-  b->ops_getxattr = ops->Has(NanNew<String>("getxattr")) ? new NanCallback(ops->Get(NanNew<String>("getxattr")).As<Function>()) : NULL;
-  b->ops_open = ops->Has(NanNew<String>("open")) ? new NanCallback(ops->Get(NanNew<String>("open")).As<Function>()) : NULL;
-  b->ops_opendir = ops->Has(NanNew<String>("opendir")) ? new NanCallback(ops->Get(NanNew<String>("opendir")).As<Function>()) : NULL;
-  b->ops_read = ops->Has(NanNew<String>("read")) ? new NanCallback(ops->Get(NanNew<String>("read")).As<Function>()) : NULL;
-  b->ops_write = ops->Has(NanNew<String>("write")) ? new NanCallback(ops->Get(NanNew<String>("write")).As<Function>()) : NULL;
-  b->ops_release = ops->Has(NanNew<String>("release")) ? new NanCallback(ops->Get(NanNew<String>("release")).As<Function>()) : NULL;
-  b->ops_releasedir = ops->Has(NanNew<String>("releasedir")) ? new NanCallback(ops->Get(NanNew<String>("releasedir")).As<Function>()) : NULL;
-  b->ops_create = ops->Has(NanNew<String>("create")) ? new NanCallback(ops->Get(NanNew<String>("create")).As<Function>()) : NULL;
-  b->ops_utimens = ops->Has(NanNew<String>("utimens")) ? new NanCallback(ops->Get(NanNew<String>("utimens")).As<Function>()) : NULL;
-  b->ops_unlink = ops->Has(NanNew<String>("unlink")) ? new NanCallback(ops->Get(NanNew<String>("unlink")).As<Function>()) : NULL;
-  b->ops_rename = ops->Has(NanNew<String>("rename")) ? new NanCallback(ops->Get(NanNew<String>("rename")).As<Function>()) : NULL;
-  b->ops_link = ops->Has(NanNew<String>("link")) ? new NanCallback(ops->Get(NanNew<String>("link")).As<Function>()) : NULL;
-  b->ops_symlink = ops->Has(NanNew<String>("symlink")) ? new NanCallback(ops->Get(NanNew<String>("symlink")).As<Function>()) : NULL;
-  b->ops_mkdir = ops->Has(NanNew<String>("mkdir")) ? new NanCallback(ops->Get(NanNew<String>("mkdir")).As<Function>()) : NULL;
-  b->ops_rmdir = ops->Has(NanNew<String>("rmdir")) ? new NanCallback(ops->Get(NanNew<String>("rmdir")).As<Function>()) : NULL;
-  b->ops_destroy = ops->Has(NanNew<String>("destroy")) ? new NanCallback(ops->Get(NanNew<String>("destroy")).As<Function>()) : NULL;
+  b->ops_init = LOOKUP_CALLBACK(ops, "init");
+  b->ops_error = LOOKUP_CALLBACK(ops, "error");
+  b->ops_access = LOOKUP_CALLBACK(ops, "access");
+  b->ops_statfs = LOOKUP_CALLBACK(ops, "statfs");
+  b->ops_getattr = LOOKUP_CALLBACK(ops, "getattr");
+  b->ops_fgetattr = LOOKUP_CALLBACK(ops, "fgetattr");
+  b->ops_flush = LOOKUP_CALLBACK(ops, "flush");
+  b->ops_fsync = LOOKUP_CALLBACK(ops, "fsync");
+  b->ops_fsyncdir = LOOKUP_CALLBACK(ops, "fsyncdir");
+  b->ops_readdir = LOOKUP_CALLBACK(ops, "readdir");
+  b->ops_truncate = LOOKUP_CALLBACK(ops, "truncate");
+  b->ops_ftruncate = LOOKUP_CALLBACK(ops, "ftruncate");
+  b->ops_readlink = LOOKUP_CALLBACK(ops, "readlink");
+  b->ops_chown = LOOKUP_CALLBACK(ops, "chown");
+  b->ops_chmod = LOOKUP_CALLBACK(ops, "chmod");
+  b->ops_mknod = LOOKUP_CALLBACK(ops, "mknod");
+  b->ops_setxattr = LOOKUP_CALLBACK(ops, "setxattr");
+  b->ops_getxattr = LOOKUP_CALLBACK(ops, "getxattr");
+  b->ops_open = LOOKUP_CALLBACK(ops, "open");
+  b->ops_opendir = LOOKUP_CALLBACK(ops, "opendir");
+  b->ops_read = LOOKUP_CALLBACK(ops, "read");
+  b->ops_write = LOOKUP_CALLBACK(ops, "write");
+  b->ops_release = LOOKUP_CALLBACK(ops, "release");
+  b->ops_releasedir = LOOKUP_CALLBACK(ops, "releasedir");
+  b->ops_create = LOOKUP_CALLBACK(ops, "create");
+  b->ops_utimens = LOOKUP_CALLBACK(ops, "utimens");
+  b->ops_unlink = LOOKUP_CALLBACK(ops, "unlink");
+  b->ops_rename = LOOKUP_CALLBACK(ops, "rename");
+  b->ops_link = LOOKUP_CALLBACK(ops, "link");
+  b->ops_symlink = LOOKUP_CALLBACK(ops, "symlink");
+  b->ops_mkdir = LOOKUP_CALLBACK(ops, "mkdir");
+  b->ops_rmdir = LOOKUP_CALLBACK(ops, "rmdir");
+  b->ops_destroy = LOOKUP_CALLBACK(ops, "destroy");
 
-  Local<Value> tmp[] = {NanNew<Number>(index), NanNew<FunctionTemplate>(OpCallback)->GetFunction()};
-  b->callback = new NanCallback(callback_constructor->Call(2, tmp).As<Function>());
+  Local<Value> tmp[] = {Nan::New<Number>(index), Nan::New<FunctionTemplate>(OpCallback)->GetFunction()};
+  b->callback = new Nan::Callback(callback_constructor->Call(2, tmp).As<Function>());
 
   strcpy(b->mnt, *path);
   strcpy(b->mntopts, "-o");
 
-  Local<Array> options = ops->Get(NanNew<String>("options")).As<Array>();
+  Local<Array> options = ops->Get(LOCAL_STRING("options")).As<Array>();
   if (options->IsArray()) {
     for (uint32_t i = 0; i < options->Length(); i++) {
-      NanUtf8String option(options->Get(i));
+      Nan::Utf8String option(options->Get(i));
       if (strcmp(b->mntopts, "-o")) strcat(b->mntopts, ",");
       strcat(b->mntopts, *option);
     }
@@ -1167,14 +1167,12 @@ NAN_METHOD(Mount) {
   b->async.data = b;
 
   thread_create(&(b->thread), bindings_thread, b);
-
-  NanReturnUndefined();
 }
 
-class UnmountWorker : public NanAsyncWorker {
+class UnmountWorker : public Nan::AsyncWorker {
  public:
-  UnmountWorker(NanCallback *callback, char *path)
-    : NanAsyncWorker(callback), path(path) {}
+  UnmountWorker(Nan::Callback *callback, char *path)
+    : Nan::AsyncWorker(callback), path(path) {}
   ~UnmountWorker() {}
 
   void Execute () {
@@ -1183,7 +1181,7 @@ class UnmountWorker : public NanAsyncWorker {
   }
 
   void HandleOKCallback () {
-    NanScope();
+    Nan::HandleScope scope;
     callback->Call(0, NULL);
   }
 
@@ -1192,49 +1190,39 @@ class UnmountWorker : public NanAsyncWorker {
 };
 
 NAN_METHOD(SetCallback) {
-  NanScope();
-  callback_constructor = new NanCallback(args[0].As<Function>());
-  NanReturnUndefined();
+  callback_constructor = new Nan::Callback(info[0].As<Function>());
 }
 
 NAN_METHOD(SetBuffer) {
-  NanScope();
-  NanAssignPersistent(buffer_constructor, args[0].As<Function>());
-  NanReturnUndefined();
+  buffer_constructor.Reset(info[0].As<Function>());
 }
 
 NAN_METHOD(PopulateContext) {
-  NanScope();
-  if (bindings_current == NULL) return NanThrowError("You have to call this inside a fuse operation");
+  if (bindings_current == NULL) return Nan::ThrowError("You have to call this inside a fuse operation");
 
-  Local<Object> ctx = args[0].As<Object>();
-  ctx->Set(NanNew<String>("uid"), NanNew(bindings_current->context_uid));
-  ctx->Set(NanNew<String>("gid"), NanNew(bindings_current->context_gid));
-  ctx->Set(NanNew<String>("pid"), NanNew(bindings_current->context_pid));
-
-  NanReturnUndefined();
+  Local<Object> ctx = info[0].As<Object>();
+  ctx->Set(LOCAL_STRING("uid"), Nan::New(bindings_current->context_uid));
+  ctx->Set(LOCAL_STRING("gid"), Nan::New(bindings_current->context_gid));
+  ctx->Set(LOCAL_STRING("pid"), Nan::New(bindings_current->context_pid));
 }
 
 NAN_METHOD(Unmount) {
-  NanScope();
-
-  if (!args[0]->IsString()) return NanThrowError("mnt must be a string");
-  NanUtf8String path(args[0]);
-  Local<Function> callback = args[1].As<Function>();
+  if (!info[0]->IsString()) return Nan::ThrowError("mnt must be a string");
+  Nan::Utf8String path(info[0]);
+  Local<Function> callback = info[1].As<Function>();
 
   char *path_alloc = (char *) malloc(1024);
   strcpy(path_alloc, *path);
 
-  NanAsyncQueueWorker(new UnmountWorker(new NanCallback(callback), path_alloc));
-  NanReturnUndefined();
+  Nan::AsyncQueueWorker(new UnmountWorker(new Nan::Callback(callback), path_alloc));
 }
 
 void Init(Handle<Object> exports) {
-  exports->Set(NanNew("setCallback"), NanNew<FunctionTemplate>(SetCallback)->GetFunction());
-  exports->Set(NanNew("setBuffer"), NanNew<FunctionTemplate>(SetBuffer)->GetFunction());
-  exports->Set(NanNew("mount"), NanNew<FunctionTemplate>(Mount)->GetFunction());
-  exports->Set(NanNew("unmount"), NanNew<FunctionTemplate>(Unmount)->GetFunction());
-  exports->Set(NanNew("populateContext"), NanNew<FunctionTemplate>(PopulateContext)->GetFunction());
+  exports->Set(LOCAL_STRING("setCallback"), Nan::New<FunctionTemplate>(SetCallback)->GetFunction());
+  exports->Set(LOCAL_STRING("setBuffer"), Nan::New<FunctionTemplate>(SetBuffer)->GetFunction());
+  exports->Set(LOCAL_STRING("mount"), Nan::New<FunctionTemplate>(Mount)->GetFunction());
+  exports->Set(LOCAL_STRING("unmount"), Nan::New<FunctionTemplate>(Unmount)->GetFunction());
+  exports->Set(LOCAL_STRING("populateContext"), Nan::New<FunctionTemplate>(PopulateContext)->GetFunction());
 }
 
 NODE_MODULE(fuse_bindings, Init)
diff --git a/package.json b/package.json
index 02e5820..ec6c1cb 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,7 @@
   "gypfile": true,
   "dependencies": {
     "bindings": "^1.2.1",
-    "nan": "^1.7.0",
+    "nan": "^2.0.9",
     "xtend": "^4.0.0"
   },
   "devDependencies": {