diff --git a/.travis.yml b/.travis.yml
index fcc0b97c..f362eac8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,5 @@
 language: java
+sudo: false
 jdk:
   - oraclejdk8
   - oraclejdk7
diff --git a/lib/nodeJavaBridge.js b/lib/nodeJavaBridge.js
index 534e2670..bb67c71d 100644
--- a/lib/nodeJavaBridge.js
+++ b/lib/nodeJavaBridge.js
@@ -190,6 +190,8 @@ function isWritable(prop) {
   // (e.g. for either .caller or .arguments).
   // It may be that checking desc.configurable is sufficient, but the specification doesn't make this definitive,
   // and there is no harm in checking both.
+  if (prop === 'caller' || prop === 'arguments') { return false; }
+  
   var desc = Object.getOwnPropertyDescriptor(function() {}, prop) || {};
   return desc.writable !== false &&  desc.configurable !== false;
 }
diff --git a/package.json b/package.json
index 9ec2b23d..7768fdc5 100644
--- a/package.json
+++ b/package.json
@@ -30,7 +30,7 @@
     "find-java-home": "0.1.2",
     "glob": "5.0.5",
     "lodash": "3.7.0",
-    "nan": "1.7.0"
+    "nan": "2.0.9"
   },
   "devDependencies": {
     "chalk": "1.0.0",
diff --git a/src/java.cpp b/src/java.cpp
index bcf4f88d..1ca252df 100644
--- a/src/java.cpp
+++ b/src/java.cpp
@@ -16,7 +16,7 @@
 
 long v8ThreadId;
 
-/*static*/ v8::Persistent<v8::FunctionTemplate> Java::s_ct;
+/*static*/ Nan::Persistent<v8::FunctionTemplate> Java::s_ct;
 /*static*/ std::string Java::s_nativeBindingLocation;
 
 void my_sleep(int dur) {
@@ -36,52 +36,52 @@ long my_getThreadId() {
 }
 
 /*static*/ void Java::Init(v8::Handle<v8::Object> target) {
-  NanScope();
+  Nan::HandleScope scope;
 
   v8ThreadId = my_getThreadId();
 
-  v8::Local<v8::FunctionTemplate> t = NanNew<v8::FunctionTemplate>(New);
-  NanAssignPersistent(s_ct, t);
+  v8::Local<v8::FunctionTemplate> t = Nan::New<v8::FunctionTemplate>(New);
+  s_ct.Reset(t);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(NanNew<v8::String>("Java"));
-
-  NODE_SET_PROTOTYPE_METHOD(t, "getClassLoader", getClassLoader);
-  NODE_SET_PROTOTYPE_METHOD(t, "newInstance", newInstance);
-  NODE_SET_PROTOTYPE_METHOD(t, "newInstanceSync", newInstanceSync);
-  NODE_SET_PROTOTYPE_METHOD(t, "newProxy", newProxy);
-  NODE_SET_PROTOTYPE_METHOD(t, "callStaticMethod", callStaticMethod);
-  NODE_SET_PROTOTYPE_METHOD(t, "callStaticMethodSync", callStaticMethodSync);
-  NODE_SET_PROTOTYPE_METHOD(t, "callMethod", callMethod);
-  NODE_SET_PROTOTYPE_METHOD(t, "callMethodSync", callMethodSync);
-  NODE_SET_PROTOTYPE_METHOD(t, "findClassSync", findClassSync);
-  NODE_SET_PROTOTYPE_METHOD(t, "newArray", newArray);
-  NODE_SET_PROTOTYPE_METHOD(t, "newByte", newByte);
-  NODE_SET_PROTOTYPE_METHOD(t, "newShort", newShort);
-  NODE_SET_PROTOTYPE_METHOD(t, "newLong", newLong);
-  NODE_SET_PROTOTYPE_METHOD(t, "newChar", newChar);
-  NODE_SET_PROTOTYPE_METHOD(t, "newFloat", newFloat);
-  NODE_SET_PROTOTYPE_METHOD(t, "newDouble", newDouble);
-  NODE_SET_PROTOTYPE_METHOD(t, "getStaticFieldValue", getStaticFieldValue);
-  NODE_SET_PROTOTYPE_METHOD(t, "setStaticFieldValue", setStaticFieldValue);
-  NODE_SET_PROTOTYPE_METHOD(t, "instanceOf", instanceOf);
-
-  target->Set(NanNew<v8::String>("Java"), t->GetFunction());
+  t->SetClassName(Nan::New<v8::String>("Java").ToLocalChecked());
+
+  Nan::SetPrototypeMethod(t, "getClassLoader", getClassLoader);
+  Nan::SetPrototypeMethod(t, "newInstance", newInstance);
+  Nan::SetPrototypeMethod(t, "newInstanceSync", newInstanceSync);
+  Nan::SetPrototypeMethod(t, "newProxy", newProxy);
+  Nan::SetPrototypeMethod(t, "callStaticMethod", callStaticMethod);
+  Nan::SetPrototypeMethod(t, "callStaticMethodSync", callStaticMethodSync);
+  Nan::SetPrototypeMethod(t, "callMethod", callMethod);
+  Nan::SetPrototypeMethod(t, "callMethodSync", callMethodSync);
+  Nan::SetPrototypeMethod(t, "findClassSync", findClassSync);
+  Nan::SetPrototypeMethod(t, "newArray", newArray);
+  Nan::SetPrototypeMethod(t, "newByte", newByte);
+  Nan::SetPrototypeMethod(t, "newShort", newShort);
+  Nan::SetPrototypeMethod(t, "newLong", newLong);
+  Nan::SetPrototypeMethod(t, "newChar", newChar);
+  Nan::SetPrototypeMethod(t, "newFloat", newFloat);
+  Nan::SetPrototypeMethod(t, "newDouble", newDouble);
+  Nan::SetPrototypeMethod(t, "getStaticFieldValue", getStaticFieldValue);
+  Nan::SetPrototypeMethod(t, "setStaticFieldValue", setStaticFieldValue);
+  Nan::SetPrototypeMethod(t, "instanceOf", instanceOf);
+
+  target->Set(Nan::New<v8::String>("Java").ToLocalChecked(), t->GetFunction());
 
   JavaProxyObject::init();
 }
 
 NAN_METHOD(Java::New) {
-  NanScope();
+  Nan::HandleScope scope;
 
   Java *self = new Java();
-  self->Wrap(args.This());
+  self->Wrap(info.This());
 
-  NanObjectWrapHandle(self)->Set(NanNew<v8::String>("classpath"), NanNew<v8::Array>());
-  NanObjectWrapHandle(self)->Set(NanNew<v8::String>("options"), NanNew<v8::Array>());
-  NanObjectWrapHandle(self)->Set(NanNew<v8::String>("nativeBindingLocation"), NanNew<v8::String>("Not Set"));
-  NanObjectWrapHandle(self)->Set(NanNew<v8::String>("asyncOptions"), NanNull());
+  self->handle()->Set(Nan::New<v8::String>("classpath").ToLocalChecked(), Nan::New<v8::Array>());
+  self->handle()->Set(Nan::New<v8::String>("options").ToLocalChecked(), Nan::New<v8::Array>());
+  self->handle()->Set(Nan::New<v8::String>("nativeBindingLocation").ToLocalChecked(), Nan::New<v8::String>("Not Set").ToLocalChecked());
+  self->handle()->Set(Nan::New<v8::String>("asyncOptions").ToLocalChecked(), Nan::Null());
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 Java::Java() {
@@ -106,7 +106,7 @@ v8::Local<v8::Value> Java::ensureJvm() {
     return result;
   }
 
-  return NanNull();
+  return Nan::Null();
 }
 
 void Java::configureAsync(v8::Local<v8::Value>& asyncOptions) {
@@ -119,7 +119,7 @@ void Java::configureAsync(v8::Local<v8::Value>& asyncOptions) {
   doAsync = false;
   doPromise = false;
 
-  v8::Local<v8::Value> suffixValue = asyncOptionsObj->Get(NanNew<v8::String>("syncSuffix"));
+  v8::Local<v8::Value> suffixValue = asyncOptionsObj->Get(Nan::New<v8::String>("syncSuffix").ToLocalChecked());
   if (suffixValue->IsString()) {
     v8::Local<v8::String> suffix = suffixValue->ToString();
     v8::String::Utf8Value utf8(suffix);
@@ -127,7 +127,7 @@ void Java::configureAsync(v8::Local<v8::Value>& asyncOptions) {
     doSync = true;
   }
 
-  suffixValue = asyncOptionsObj->Get(NanNew<v8::String>("asyncSuffix"));
+  suffixValue = asyncOptionsObj->Get(Nan::New<v8::String>("asyncSuffix").ToLocalChecked());
   if (suffixValue->IsString()) {
     v8::Local<v8::String> suffix = suffixValue->ToString();
     v8::String::Utf8Value utf8(suffix);
@@ -135,12 +135,12 @@ void Java::configureAsync(v8::Local<v8::Value>& asyncOptions) {
     doAsync = true;
   }
 
-  suffixValue = asyncOptionsObj->Get(NanNew<v8::String>("promiseSuffix"));
+  suffixValue = asyncOptionsObj->Get(Nan::New<v8::String>("promiseSuffix").ToLocalChecked());
   if (suffixValue->IsString()) {
     v8::Local<v8::String> suffix = suffixValue->ToString();
     v8::String::Utf8Value utf8(suffix);
     m_PromiseSuffix.assign(*utf8);
-    v8::Local<v8::Value> promisify = asyncOptionsObj->Get(NanNew<v8::String>("promisify"));
+    v8::Local<v8::Value> promisify = asyncOptionsObj->Get(Nan::New<v8::String>("promisify").ToLocalChecked());
     if (!promisify->IsFunction()) {
       fprintf(stderr, "asyncOptions.promisify must be a function");
       assert(promisify->IsFunction());
@@ -158,12 +158,11 @@ void Java::configureAsync(v8::Local<v8::Value>& asyncOptions) {
     assert(m_AsyncSuffix != m_PromiseSuffix);
   }
 
-  NanAssignPersistent(m_asyncOptions, asyncOptionsObj);
+  m_asyncOptions.Reset(asyncOptionsObj);
 }
 
 v8::Local<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
-
-  v8::Local<v8::Value> asyncOptions = NanObjectWrapHandle(this)->Get(NanNew<v8::String>("asyncOptions"));
+  v8::Local<v8::Value> asyncOptions = this->handle()->Get(Nan::New<v8::String>("asyncOptions").ToLocalChecked());
   if (asyncOptions->IsObject()) {
     configureAsync(asyncOptions);
   }
@@ -172,12 +171,12 @@ v8::Local<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
   std::ostringstream classPath;
   classPath << "-Djava.class.path=";
 
-  v8::Local<v8::Value> classPathValue = NanObjectWrapHandle(this)->Get(NanNew<v8::String>("classpath"));
+  v8::Local<v8::Value> classPathValue = this->handle()->Get(Nan::New<v8::String>("classpath").ToLocalChecked());
   if(!classPathValue->IsArray()) {
-    return NanTypeError("Classpath must be an array");
+    return Nan::TypeError("Classpath must be an array");
   }
-  v8::Handle<v8::Array> classPathArrayTemp = v8::Handle<v8::Array>::Cast(classPathValue);
-  NanAssignPersistent(m_classPathArray, classPathArrayTemp);
+  v8::Local<v8::Array> classPathArrayTemp = v8::Local<v8::Array>::Cast(classPathValue);
+  m_classPathArray.Reset(classPathArrayTemp);
   for(uint32_t i=0; i<classPathArrayTemp->Length(); i++) {
     if(i != 0) {
       #ifdef WIN32
@@ -188,7 +187,7 @@ v8::Local<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
     }
     v8::Local<v8::Value> arrayItemValue = classPathArrayTemp->Get(i);
     if(!arrayItemValue->IsString()) {
-      return NanTypeError("Classpath must only contain strings");
+      return Nan::TypeError("Classpath must only contain strings");
     }
     v8::Local<v8::String> arrayItem = arrayItemValue->ToString();
     v8::String::Utf8Value arrayItemStr(arrayItem);
@@ -196,17 +195,17 @@ v8::Local<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
   }
 
   // set the native binding location
-  v8::Local<v8::Value> v8NativeBindingLocation = NanObjectWrapHandle(this)->Get(NanNew<v8::String>("nativeBindingLocation"));
+  v8::Local<v8::Value> v8NativeBindingLocation = this->handle()->Get(Nan::New<v8::String>("nativeBindingLocation").ToLocalChecked());
   v8::String::Utf8Value nativeBindingLocationStr(v8NativeBindingLocation);
   s_nativeBindingLocation = *nativeBindingLocationStr;
 
   // get other options
-  v8::Local<v8::Value> optionsValue = NanObjectWrapHandle(this)->Get(NanNew<v8::String>("options"));
+  v8::Local<v8::Value> optionsValue = this->handle()->Get(Nan::New<v8::String>("options").ToLocalChecked());
   if(!optionsValue->IsArray()) {
-    return NanTypeError("options must be an array");
+    return Nan::TypeError("options must be an array");
   }
-  v8::Handle<v8::Array> optionsArrayTemp = v8::Handle<v8::Array>::Cast(optionsValue);
-  NanAssignPersistent(m_optionsArray, optionsArrayTemp);
+  v8::Local<v8::Array> optionsArrayTemp = v8::Local<v8::Array>::Cast(optionsValue);
+  m_optionsArray.Reset(optionsArrayTemp);
 
   // create vm options
   int vmOptionsCount = optionsArrayTemp->Length() + 1;
@@ -217,7 +216,7 @@ v8::Local<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
     v8::Local<v8::Value> arrayItemValue = optionsArrayTemp->Get(i);
     if(!arrayItemValue->IsString()) {
       delete[] vmOptions;
-      return NanTypeError("options must only contain strings");
+      return Nan::TypeError("options must only contain strings");
     }
     v8::Local<v8::String> arrayItem = arrayItemValue->ToString();
     v8::String::Utf8Value arrayItemStr(arrayItem);
@@ -253,50 +252,54 @@ v8::Local<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
 
   m_classLoader = getSystemClassLoader(*env);
 
-  v8::Local<v8::Value> onJvmCreated = NanObjectWrapHandle(this)->Get(NanNew<v8::String>("onJvmCreated"));
+  v8::Local<v8::Value> onJvmCreated = this->handle()->Get(Nan::New<v8::String>("onJvmCreated").ToLocalChecked());
 
   // TODO: this handles sets put doesn't prevent modifing the underlying data. So java.classpath.push will still work which is invalid.
-  NanObjectWrapHandle(this)->SetAccessor(NanNew<v8::String>("classpath"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
-  NanObjectWrapHandle(this)->SetAccessor(NanNew<v8::String>("options"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
-  NanObjectWrapHandle(this)->SetAccessor(NanNew<v8::String>("nativeBindingLocation"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
-  NanObjectWrapHandle(this)->SetAccessor(NanNew<v8::String>("asyncOptions"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
-  NanObjectWrapHandle(this)->SetAccessor(NanNew<v8::String>("onJvmCreated"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
+  Nan::SetAccessor(this->handle(), Nan::New<v8::String>("classpath").ToLocalChecked(), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
+  Nan::SetAccessor(this->handle(), Nan::New<v8::String>("options").ToLocalChecked(), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
+  Nan::SetAccessor(this->handle(), Nan::New<v8::String>("nativeBindingLocation").ToLocalChecked(), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
+  Nan::SetAccessor(this->handle(), Nan::New<v8::String>("asyncOptions").ToLocalChecked(), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
+  Nan::SetAccessor(this->handle(), Nan::New<v8::String>("onJvmCreated").ToLocalChecked(), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
 
   if (onJvmCreated->IsFunction()) {
     v8::Local<v8::Function> onJvmCreatedFunc = onJvmCreated.As<v8::Function>();
-    v8::Local<v8::Object> context = NanNew<v8::Object>();
+    v8::Local<v8::Object> context = Nan::New<v8::Object>();
     onJvmCreatedFunc->Call(context, 0, NULL);
   }
 
-  return NanNull();
+  return Nan::Null();
 }
 
 NAN_GETTER(Java::AccessorProhibitsOverwritingGetter) {
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  NanScope();
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  Nan::HandleScope scope;
   v8::String::Utf8Value nameStr(property);
   if(!strcmp("classpath", *nameStr)) {
-    NanReturnValue(self->m_classPathArray);
+    info.GetReturnValue().Set(Nan::New(self->m_classPathArray));
+    return;
   } else if(!strcmp("options", *nameStr)) {
-    NanReturnValue(self->m_optionsArray);
+    info.GetReturnValue().Set(Nan::New(self->m_optionsArray));
+    return;
   } else if(!strcmp("nativeBindingLocation", *nameStr)) {
-    NanReturnValue(NanNew<v8::String>(Java::s_nativeBindingLocation.c_str()));
+    info.GetReturnValue().Set(Nan::New(Java::s_nativeBindingLocation.c_str()).ToLocalChecked());
+    return;
   } else if(!strcmp("asyncOptions", *nameStr)) {
-    NanReturnValue(self->m_asyncOptions);
+    info.GetReturnValue().Set(Nan::New(self->m_asyncOptions));
+    return;
   } else if(!strcmp("onJvmCreated", *nameStr)) {
     // There is no good reason to get onJvmCreated, so just fall through to error below.
   }
 
   std::ostringstream errStr;
   errStr << "Invalid call to accessor " << *nameStr;
-  NanReturnValue(v8::Exception::Error(NanNew<v8::String>(errStr.str().c_str())));
+  info.GetReturnValue().Set(Nan::Error(errStr.str().c_str()));
 }
 
 NAN_SETTER(Java::AccessorProhibitsOverwritingSetter) {
   v8::String::Utf8Value nameStr(property);
   std::ostringstream errStr;
   errStr << "Cannot set " << *nameStr << " after calling any other java function.";
-  NanThrowError(errStr.str().c_str());
+  Nan::ThrowError(errStr.str().c_str());
 }
 
 void Java::destroyJVM(JavaVM** jvm, JNIEnv** env) {
@@ -306,11 +309,12 @@ void Java::destroyJVM(JavaVM** jvm, JNIEnv** env) {
 }
 
 NAN_METHOD(Java::getClassLoader) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
   v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
@@ -321,21 +325,22 @@ NAN_METHOD(Java::getClassLoader) {
   checkJavaException(env);
 
   jobject result = env->NewGlobalRef(classLoader);
-  NanReturnValue(javaToV8(self, env, result));
+  info.GetReturnValue().Set(javaToV8(self, env, result));
 }
 
 NAN_METHOD(Java::newInstance) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
   int argsStart = 0;
-  int argsEnd = args.Length();
+  int argsEnd = info.Length();
 
   // arguments
   ARGS_FRONT_CLASSNAME();
@@ -345,16 +350,18 @@ NAN_METHOD(Java::newInstance) {
   jclass clazz = javaFindClass(env, className);
   if(clazz == NULL) {
     EXCEPTION_CALL_CALLBACK(self, "Could not find class " << className.c_str());
-    NanReturnUndefined();
+    info.GetReturnValue().SetUndefined();
+    return;
   }
 
   // get method
-  jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
+  jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd);
   jobject method = javaFindConstructor(env, clazz, methodArgs);
   if(method == NULL) {
-    std::string msg = methodNotFoundToString(env, clazz, className, true, args, argsStart, argsEnd);
+    std::string msg = methodNotFoundToString(env, clazz, className, true, info, argsStart, argsEnd);
     EXCEPTION_CALL_CALLBACK(self, msg);
-    NanReturnUndefined();
+    info.GetReturnValue().SetUndefined();
+    return;
   }
 
   // run
@@ -365,17 +372,18 @@ NAN_METHOD(Java::newInstance) {
 }
 
 NAN_METHOD(Java::newInstanceSync) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
   int argsStart = 0;
-  int argsEnd = args.Length();
+  int argsEnd = info.Length();
 
   // arguments
   ARGS_FRONT_CLASSNAME();
@@ -385,34 +393,35 @@ NAN_METHOD(Java::newInstanceSync) {
   if(clazz == NULL) {
     std::ostringstream errStr;
     errStr << "Could not create class " << className.c_str();
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
   // find method
-  jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
+  jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd);
   jobject method = javaFindConstructor(env, clazz, methodArgs);
   if(method == NULL) {
-    std::string msg = methodNotFoundToString(env, clazz, className, true, args, argsStart, argsEnd);
-    return NanThrowError(javaExceptionToV8(self, env, msg));
+    std::string msg = methodNotFoundToString(env, clazz, className, true, info, argsStart, argsEnd);
+    return Nan::ThrowError(javaExceptionToV8(self, env, msg));
   }
 
   // run
-  v8::Handle<v8::Value> callback = NanNull();
+  v8::Local<v8::Value> callback = Nan::Null();
   NewInstanceBaton* baton = new NewInstanceBaton(self, clazz, method, methodArgs, callback);
-  v8::Handle<v8::Value> result = baton->runSync();
+  v8::Local<v8::Value> result = baton->runSync();
   delete baton;
   if(result->IsNativeError()) {
-    return NanThrowError(result);
+    return Nan::ThrowError(result);
   }
-  NanReturnValue(result);
+  info.GetReturnValue().Set(result);
 }
 
 NAN_METHOD(Java::newProxy) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
@@ -427,7 +436,7 @@ NAN_METHOD(Java::newProxy) {
   dynamicProxyData->markerEnd = DYNAMIC_PROXY_DATA_MARKER_END;
   dynamicProxyData->java = self;
   dynamicProxyData->interfaceName = interfaceName;
-  NanAssignPersistent(dynamicProxyData->functions, functions);
+  dynamicProxyData->functions.Reset(functions);
 
   // find NodeDynamicProxyClass
   std::string className = "node.NodeDynamicProxyClass";
@@ -436,19 +445,19 @@ NAN_METHOD(Java::newProxy) {
     std::ostringstream errStr;
     errStr << "Could not create class node/NodeDynamicProxyClass";
     delete dynamicProxyData;
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
   // find constructor
   jclass objectClazz = env->FindClass("java/lang/Object");
   jobjectArray methodArgs = env->NewObjectArray(2, objectClazz, NULL);
-  env->SetObjectArrayElement(methodArgs, 0, v8ToJava(env, NanNew<v8::String>(s_nativeBindingLocation.c_str())));
+  env->SetObjectArrayElement(methodArgs, 0, v8ToJava(env, Nan::New<v8::String>(s_nativeBindingLocation.c_str()).ToLocalChecked()));
   env->SetObjectArrayElement(methodArgs, 1, longToJavaLongObj(env, (long)dynamicProxyData));
   jobject method = javaFindConstructor(env, clazz, methodArgs);
   if(method == NULL) {
     std::ostringstream errStr;
     errStr << "Could not find constructor for class node/NodeDynamicProxyClass";
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
   // create the NodeDynamicProxyClass
@@ -462,7 +471,7 @@ NAN_METHOD(Java::newProxy) {
   if(env->ExceptionCheck()) {
     std::ostringstream errStr;
     errStr << "Error creating class";
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
   jclass dynamicInterface = javaFindClass(env, interfaceName);
@@ -470,14 +479,14 @@ NAN_METHOD(Java::newProxy) {
     std::ostringstream errStr;
     errStr << "Could not find interface ";
     errStr << interfaceName;
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
   jclass classClazz = env->FindClass("java/lang/Class");
   jobjectArray classArray = env->NewObjectArray(1, classClazz, NULL);
   if(classArray == NULL) {
     std::ostringstream errStr;
     errStr << "Could not create class array for Proxy";
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
   env->SetObjectArrayElement(classArray, 0, dynamicInterface);
 
@@ -496,7 +505,7 @@ NAN_METHOD(Java::newProxy) {
   if(classLoader == NULL) {
     std::ostringstream errStr;
     errStr << "Could not get classloader for Proxy";
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
   // create proxy instance
@@ -506,27 +515,28 @@ NAN_METHOD(Java::newProxy) {
   if(env->ExceptionCheck()) {
     std::ostringstream errStr;
     errStr << "Error creating java.lang.reflect.Proxy";
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
-  v8::Handle<v8::Value> result = javaToV8(self, env, proxyInstance, dynamicProxyData);
+  v8::Local<v8::Value> result = javaToV8(self, env, proxyInstance, dynamicProxyData);
 
-  NanAssignPersistent(dynamicProxyData->jsObject, result);
-  NanReturnValue(result);
+  dynamicProxyData->jsObject.Reset(result);
+  info.GetReturnValue().Set(result);
 }
 
 NAN_METHOD(Java::callStaticMethod) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
   int argsStart = 0;
-  int argsEnd = args.Length();
+  int argsEnd = info.Length();
 
   // arguments
   ARGS_FRONT_CLASSNAME();
@@ -537,16 +547,18 @@ NAN_METHOD(Java::callStaticMethod) {
   jclass clazz = javaFindClass(env, className);
   if(clazz == NULL) {
     EXCEPTION_CALL_CALLBACK(self, "Could not create class " << className.c_str());
-    NanReturnUndefined();
+    info.GetReturnValue().SetUndefined();
+    return;
   }
 
   // find method
-  jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
+  jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd);
   jobject method = javaFindMethod(env, clazz, methodName, methodArgs);
   if(method == NULL) {
-    std::string msg = methodNotFoundToString(env, clazz, methodName, false, args, argsStart, argsEnd);
+    std::string msg = methodNotFoundToString(env, clazz, methodName, false, info, argsStart, argsEnd);
     EXCEPTION_CALL_CALLBACK(self, msg);
-    NanReturnUndefined();
+    info.GetReturnValue().SetUndefined();
+    return;
   }
 
   // run
@@ -557,17 +569,18 @@ NAN_METHOD(Java::callStaticMethod) {
 }
 
 NAN_METHOD(Java::callStaticMethodSync) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
   int argsStart = 0;
-  int argsEnd = args.Length();
+  int argsEnd = info.Length();
 
   // arguments
   ARGS_FRONT_CLASSNAME();
@@ -578,95 +591,99 @@ NAN_METHOD(Java::callStaticMethodSync) {
   if(clazz == NULL) {
     std::ostringstream errStr;
     errStr << "Could not create class " << className.c_str();
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
   // find method
-  jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
+  jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd);
   jobject method = javaFindMethod(env, clazz, methodName, methodArgs);
   if(method == NULL) {
-    std::string msg = methodNotFoundToString(env, clazz, methodName, false, args, argsStart, argsEnd);
-    return NanThrowError(javaExceptionToV8(self, env, msg));
+    std::string msg = methodNotFoundToString(env, clazz, methodName, false, info, argsStart, argsEnd);
+    return Nan::ThrowError(javaExceptionToV8(self, env, msg));
   }
 
   // run
-  v8::Handle<v8::Value> callback = NanNull();
+  v8::Local<v8::Value> callback = Nan::Null();
   StaticMethodCallBaton* baton = new StaticMethodCallBaton(self, clazz, method, methodArgs, callback);
-  v8::Handle<v8::Value> result = baton->runSync();
+  v8::Local<v8::Value> result = baton->runSync();
   delete baton;
   if(result->IsNativeError()) {
-    return NanThrowError(result);
+    Nan::ThrowError(result);
+    return;
   }
-  NanReturnValue(result);
+  info.GetReturnValue().Set(result);
 }
 
 NAN_METHOD(Java::callMethodSync) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
   int argsStart = 0;
-  int argsEnd = args.Length();
+  int argsEnd = info.Length();
 
   // arguments
   ARGS_FRONT_OBJECT(instanceObj);
   ARGS_FRONT_STRING(methodName);
 
-  JavaObject* javaObj = node::ObjectWrap::Unwrap<JavaObject>(instanceObj);
+  JavaObject* javaObj = Nan::ObjectWrap::Unwrap<JavaObject>(instanceObj);
 
   // find method
   jclass clazz = javaObj->getClass();
-  jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
+  jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd);
   jobject method = javaFindMethod(env, clazz, methodName, methodArgs);
   if(method == NULL) {
-    std::string msg = methodNotFoundToString(env, clazz, methodName, false, args, argsStart, argsEnd);
-    return NanThrowError(javaExceptionToV8(self, env, msg));
+    std::string msg = methodNotFoundToString(env, clazz, methodName, false, info, argsStart, argsEnd);
+    return Nan::ThrowError(javaExceptionToV8(self, env, msg));
   }
 
   // run
-  v8::Handle<v8::Value> callback = NanNull();
+  v8::Local<v8::Value> callback = Nan::Null();
   InstanceMethodCallBaton* baton = new InstanceMethodCallBaton(self, javaObj, method, methodArgs, callback);
-  v8::Handle<v8::Value> result = baton->runSync();
+  v8::Local<v8::Value> result = baton->runSync();
   delete baton;
   if(result->IsNativeError()) {
-    return NanThrowError(result);
+    return Nan::ThrowError(result);
   }
-  NanReturnValue(result);
+  info.GetReturnValue().Set(result);
 }
 
 NAN_METHOD(Java::callMethod) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
   int argsStart = 0;
-  int argsEnd = args.Length();
+  int argsEnd = info.Length();
 
   // arguments
   ARGS_FRONT_OBJECT(instanceObj);
   ARGS_FRONT_STRING(methodName);
   ARGS_BACK_CALLBACK();
 
-  JavaObject* javaObj = node::ObjectWrap::Unwrap<JavaObject>(instanceObj);
+  JavaObject* javaObj = Nan::ObjectWrap::Unwrap<JavaObject>(instanceObj);
 
   // find method
   jclass clazz = javaObj->getClass();
-  jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
+  jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd);
   jobject method = javaFindMethod(env, clazz, methodName, methodArgs);
   if(method == NULL) {
-    std::string msg = methodNotFoundToString(env, clazz, methodName, false, args, argsStart, argsEnd);
+    std::string msg = methodNotFoundToString(env, clazz, methodName, false, info, argsStart, argsEnd);
     EXCEPTION_CALL_CALLBACK(self, msg);
-    NanReturnUndefined();
+    info.GetReturnValue().SetUndefined();
+    return;
   }
 
   // run
@@ -677,11 +694,12 @@ NAN_METHOD(Java::callMethod) {
 }
 
 NAN_METHOD(Java::findClassSync) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
@@ -696,20 +714,21 @@ NAN_METHOD(Java::findClassSync) {
   if(clazz == NULL) {
     std::ostringstream errStr;
     errStr << "Could not create class " << className.c_str();
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
   // run
-  v8::Handle<v8::Value> result = javaToV8(self, env, clazz);
-  NanReturnValue(result);
+  v8::Local<v8::Value> result = javaToV8(self, env, clazz);
+  info.GetReturnValue().Set(result);
 }
 
 NAN_METHOD(Java::newArray) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
@@ -720,12 +739,12 @@ NAN_METHOD(Java::newArray) {
   ARGS_FRONT_CLASSNAME();
 
   // argument - array
-  if(args.Length() < argsStart+1 || !args[argsStart]->IsArray()) {
+  if(info.Length() < argsStart+1 || !info[argsStart]->IsArray()) {
     std::ostringstream errStr;
     errStr << "Argument " << (argsStart+1) << " must be an array";
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>(errStr.str().c_str())));
+    return Nan::ThrowError(Nan::TypeError(errStr.str().c_str()));
   }
-  v8::Local<v8::Array> arrayObj = v8::Local<v8::Array>::Cast(args[argsStart]);
+  v8::Local<v8::Array> arrayObj = v8::Local<v8::Array>::Cast(info[argsStart]);
 
   // find class and method
   jarray results;
@@ -819,7 +838,7 @@ NAN_METHOD(Java::newArray) {
     if(clazz == NULL) {
       std::ostringstream errStr;
       errStr << "Could not create class " << className.c_str();
-      return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+      return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
     }
 
     // create array
@@ -833,189 +852,197 @@ NAN_METHOD(Java::newArray) {
         std::ostringstream errStr;
         v8::String::Utf8Value valStr(item);
         errStr << "Could not add item \"" << *valStr << "\" to array.";
-        return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+        return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
       }
     }
   }
 
-  NanReturnValue(JavaObject::New(self, results));
+  info.GetReturnValue().Set(JavaObject::New(self, results));
 }
 
 NAN_METHOD(Java::newByte) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
-  if(args.Length() != 1) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newByte only takes 1 argument")));
+  if(info.Length() != 1) {
+    return Nan::ThrowError(Nan::TypeError("newByte only takes 1 argument"));
   }
 
   // argument - value
-  if(!args[0]->IsNumber()) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number")));
+  if(!info[0]->IsNumber()) {
+    return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number"));
   }
 
-  v8::Local<v8::Number> val = args[0]->ToNumber();
+  v8::Local<v8::Number> val = info[0]->ToNumber();
 
   jclass clazz = env->FindClass("java/lang/Byte");
   jmethodID constructor = env->GetMethodID(clazz, "<init>", "(B)V");
   jobject newObj = env->NewObject(clazz, constructor, (jbyte)val->Value());
 
-  NanReturnValue(JavaObject::New(self, newObj));
+  info.GetReturnValue().Set(JavaObject::New(self, newObj));
+  return;
 }
 
 NAN_METHOD(Java::newShort) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
-  if(args.Length() != 1) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newShort only takes 1 argument")));
+  if(info.Length() != 1) {
+    return Nan::ThrowError(Nan::TypeError("newShort only takes 1 argument"));
   }
 
   // argument - value
-  if(!args[0]->IsNumber()) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number")));
+  if(!info[0]->IsNumber()) {
+    return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number"));
   }
 
-  v8::Local<v8::Number> val = args[0]->ToNumber();
+  v8::Local<v8::Number> val = info[0]->ToNumber();
 
   jclass clazz = env->FindClass("java/lang/Short");
   jmethodID constructor = env->GetMethodID(clazz, "<init>", "(S)V");
   jobject newObj = env->NewObject(clazz, constructor, (jshort)val->Value());
 
-  NanReturnValue(JavaObject::New(self, newObj));
+  info.GetReturnValue().Set(JavaObject::New(self, newObj));
 }
 
 NAN_METHOD(Java::newLong) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
-  if(args.Length() != 1) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newLong only takes 1 argument")));
+  if(info.Length() != 1) {
+    return Nan::ThrowError(Nan::TypeError("newLong only takes 1 argument"));
   }
 
   // argument - value
-  if(!args[0]->IsNumber()) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number")));
+  if(!info[0]->IsNumber()) {
+    return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number"));
   }
 
-  v8::Local<v8::Number> val = args[0]->ToNumber();
+  v8::Local<v8::Number> val = info[0]->ToNumber();
 
   jclass clazz = env->FindClass("java/lang/Long");
   jmethodID constructor = env->GetMethodID(clazz, "<init>", "(J)V");
   jobject newObj = env->NewObject(clazz, constructor, (jlong)val->Value());
 
-  NanReturnValue(JavaObject::New(self, newObj));
+  info.GetReturnValue().Set(JavaObject::New(self, newObj));
 }
 
 NAN_METHOD(Java::newChar) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
-  if(args.Length() != 1) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newChar only takes 1 argument")));
+  if(info.Length() != 1) {
+    return Nan::ThrowError(Nan::TypeError("newChar only takes 1 argument"));
   }
 
   // argument - value
   jchar charVal;
-  if(args[0]->IsNumber()) {
-    v8::Local<v8::Number> val = args[0]->ToNumber();
+  if(info[0]->IsNumber()) {
+    v8::Local<v8::Number> val = info[0]->ToNumber();
     charVal = (jchar)val->Value();
-  } else if(args[0]->IsString()) {
-    v8::Local<v8::String> val = args[0]->ToString();
+  } else if(info[0]->IsString()) {
+    v8::Local<v8::String> val = info[0]->ToString();
     if(val->Length() != 1) {
-      return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a string of 1 character.")));
+      return Nan::ThrowError(Nan::TypeError("Argument 1 must be a string of 1 character."));
     }
     std::string strVal = std::string(*v8::String::Utf8Value(val));
     charVal = (jchar)strVal[0];
   } else {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number or string")));
+    return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number or string"));
   }
 
   jclass clazz = env->FindClass("java/lang/Character");
   jmethodID constructor = env->GetMethodID(clazz, "<init>", "(C)V");
   jobject newObj = env->NewObject(clazz, constructor, charVal);
 
-  NanReturnValue(JavaObject::New(self, newObj));
+  info.GetReturnValue().Set(JavaObject::New(self, newObj));
 }
 
 NAN_METHOD(Java::newFloat) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
-  if(args.Length() != 1) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newFloat only takes 1 argument")));
-  } else if(!args[0]->IsNumber()) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number")));
+  if(info.Length() != 1) {
+    return Nan::ThrowError(Nan::TypeError("newFloat only takes 1 argument"));
+  } else if(!info[0]->IsNumber()) {
+    return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number"));
   }
-  v8::Local<v8::Number> val = args[0]->ToNumber();
+  v8::Local<v8::Number> val = info[0]->ToNumber();
 
   jclass clazz = env->FindClass("java/lang/Float");
   jmethodID constructor = env->GetMethodID(clazz, "<init>", "(F)V");
   jobject newObj = env->NewObject(clazz, constructor, (jfloat)val->Value());
 
-  NanReturnValue(JavaObject::New(self, newObj));
+  info.GetReturnValue().Set(JavaObject::New(self, newObj));
 }
 
 NAN_METHOD(Java::newDouble) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
 
-  if(args.Length() != 1) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newDouble only takes 1 argument")));
-  } else if(!args[0]->IsNumber()) {
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number")));
+  if(info.Length() != 1) {
+    return Nan::ThrowError(Nan::TypeError("newDouble only takes 1 argument"));
+  } else if(!info[0]->IsNumber()) {
+    return Nan::ThrowError(Nan::TypeError("Argument 1 must be a number"));
   }
-  v8::Local<v8::Number> val = args[0]->ToNumber();
+  v8::Local<v8::Number> val = info[0]->ToNumber();
 
   jclass clazz = env->FindClass("java/lang/Double");
   jmethodID constructor = env->GetMethodID(clazz, "<init>", "(D)V");
   jobject newObj = env->NewObject(clazz, constructor, (jdouble)val->Value());
 
-  NanReturnValue(JavaObject::New(self, newObj));
+  info.GetReturnValue().Set(JavaObject::New(self, newObj));
 }
 
 NAN_METHOD(Java::getStaticFieldValue) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
@@ -1031,7 +1058,7 @@ NAN_METHOD(Java::getStaticFieldValue) {
   if(clazz == NULL) {
     std::ostringstream errStr;
     errStr << "Could not create class " << className.c_str();
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
   // get the field
@@ -1039,7 +1066,7 @@ NAN_METHOD(Java::getStaticFieldValue) {
   if(field == NULL) {
     std::ostringstream errStr;
     errStr << "Could not find field " << fieldName.c_str() << " on class " << className.c_str();
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
   jclass fieldClazz = env->FindClass("java/lang/reflect/Field");
@@ -1050,18 +1077,19 @@ NAN_METHOD(Java::getStaticFieldValue) {
   if(env->ExceptionOccurred()) {
     std::ostringstream errStr;
     errStr << "Could not get field " << fieldName.c_str() << " on class " << className.c_str();
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
   }
 
-  NanReturnValue(javaToV8(self, env, val));
+  info.GetReturnValue().Set(javaToV8(self, env, val));
 }
 
 NAN_METHOD(Java::setStaticFieldValue) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
@@ -1073,12 +1101,13 @@ NAN_METHOD(Java::setStaticFieldValue) {
   ARGS_FRONT_STRING(fieldName);
 
   // argument - new value
-  if(args.Length() < argsStart+1) {
+  if(info.Length() < argsStart+1) {
     std::ostringstream errStr;
     errStr << "setStaticFieldValue requires " << (argsStart+1) << " arguments";
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>(errStr.str().c_str())));
+    Nan::ThrowError(Nan::TypeError(errStr.str().c_str()));
+    return;
   }
-  jobject newValue = v8ToJava(env, args[argsStart]);
+  jobject newValue = v8ToJava(env, info[argsStart]);
   argsStart++;
 
   // find the class
@@ -1086,7 +1115,8 @@ NAN_METHOD(Java::setStaticFieldValue) {
   if(clazz == NULL) {
     std::ostringstream errStr;
     errStr << "Could not create class " << className.c_str();
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return;
   }
 
   // get the field
@@ -1094,7 +1124,8 @@ NAN_METHOD(Java::setStaticFieldValue) {
   if(field == NULL) {
     std::ostringstream errStr;
     errStr << "Could not find field " << fieldName.c_str() << " on class " << className.c_str();
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return;
   }
 
   jclass fieldClazz = env->FindClass("java/lang/reflect/Field");
@@ -1107,18 +1138,20 @@ NAN_METHOD(Java::setStaticFieldValue) {
   if(env->ExceptionOccurred()) {
     std::ostringstream errStr;
     errStr << "Could not set field " << fieldName.c_str() << " on class " << className.c_str();
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return;
   }
 
-  NanReturnUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(Java::instanceOf) {
-  NanScope();
-  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
-  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  Nan::HandleScope scope;
+  Java* self = Nan::ObjectWrap::Unwrap<Java>(info.This());
+  v8::Local<v8::Value> ensureJvmResults = self->ensureJvm();
   if(!ensureJvmResults->IsNull()) {
-    NanReturnValue(ensureJvmResults);
+    info.GetReturnValue().Set(ensureJvmResults);
+    return;
   }
   JNIEnv* env = self->getJavaEnv();
   JavaScope javaScope(env);
@@ -1130,18 +1163,20 @@ NAN_METHOD(Java::instanceOf) {
   jobject instance = v8ToJava(env, obj);
   if (!instance) {
     // not even a Java object
-    NanReturnValue(NanNew<v8::Boolean>(false));
+    info.GetReturnValue().Set(Nan::New<v8::Boolean>(false));
+    return;
   }
 
   jclass clazz = javaFindClass(env, className);
   if(!clazz) {
     std::ostringstream errStr;
     errStr << "Could not find class " << className.c_str();
-    return NanThrowError(javaExceptionToV8(self, env, errStr.str()));
+    Nan::ThrowError(javaExceptionToV8(self, env, errStr.str()));
+    return;
   }
 
   jboolean res = env->IsInstanceOf(instance, clazz);
-  NanReturnValue(NanNew<v8::Boolean>(res));
+  info.GetReturnValue().Set(Nan::New<v8::Boolean>(res));
 }
 
 void EIO_CallJs(uv_work_t* req) {
@@ -1174,7 +1209,7 @@ void EIO_AfterCallJs(uv_work_t* req) {
     return;
   }
 
-  NanScope();
+  Nan::HandleScope scope;
   v8::Array* v8Args;
   v8::Function* fn;
   v8::Handle<v8::Value>* argv;
@@ -1183,8 +1218,8 @@ void EIO_AfterCallJs(uv_work_t* req) {
   v8::Local<v8::Value> v8Result;
   jobject javaResult;
 
-  v8::Local<v8::Object> dynamicProxyDataFunctions = NanNew(dynamicProxyData->functions);
-  v8::Local<v8::Value> fnObj = dynamicProxyDataFunctions->Get(NanNew<v8::String>(dynamicProxyData->methodName.c_str()));
+  v8::Local<v8::Object> dynamicProxyDataFunctions = Nan::New(dynamicProxyData->functions);
+  v8::Local<v8::Value> fnObj = dynamicProxyDataFunctions->Get(Nan::New<v8::String>(dynamicProxyData->methodName.c_str()).ToLocalChecked());
   if(fnObj->IsUndefined() || fnObj->IsNull()) {
     dynamicProxyData->throwableClass = "java/lang/NoSuchMethodError";
     dynamicProxyData->throwableMessage = "Could not find js function " + dynamicProxyData->methodName;
diff --git a/src/java.h b/src/java.h
index f83e7fc8..b9321bb0 100644
--- a/src/java.h
+++ b/src/java.h
@@ -14,7 +14,7 @@
 #define JNI_BEST_VERSION JNI_VERSION_1_6
 #endif
 
-class Java : public node::ObjectWrap {
+class Java : public Nan::ObjectWrap {
 public:
   static void Init(v8::Handle<v8::Object> target);
   JavaVM* getJvm() { return m_jvm; }
@@ -60,15 +60,15 @@ class Java : public node::ObjectWrap {
   static NAN_SETTER(AccessorProhibitsOverwritingSetter);
   v8::Local<v8::Value> ensureJvm();
 
-  static v8::Persistent<v8::FunctionTemplate> s_ct;
+  static Nan::Persistent<v8::FunctionTemplate> s_ct;
   JavaVM* m_jvm;
   JNIEnv* m_env; // can only be used safely by the main thread as this is the thread it belongs to
   jobject m_classLoader;
   std::string m_classPath;
   static std::string s_nativeBindingLocation;
-  v8::Persistent<v8::Array> m_classPathArray;
-  v8::Persistent<v8::Array> m_optionsArray;
-  v8::Persistent<v8::Object> m_asyncOptions;
+  Nan::Persistent<v8::Array> m_classPathArray;
+  Nan::Persistent<v8::Array> m_optionsArray;
+  Nan::Persistent<v8::Object> m_asyncOptions;
 
   std::string m_SyncSuffix;
   std::string m_AsyncSuffix;
diff --git a/src/javaObject.cpp b/src/javaObject.cpp
index ec73d075..0cdbe08d 100644
--- a/src/javaObject.cpp
+++ b/src/javaObject.cpp
@@ -5,13 +5,13 @@
 #include <sstream>
 #include <algorithm>
 
-/*static*/ std::map<std::string, v8::Persistent<v8::FunctionTemplate>*> JavaObject::sFunctionTemplates;
+/*static*/ std::map<std::string, Nan::Persistent<v8::FunctionTemplate>*> JavaObject::sFunctionTemplates;
 
 /*static*/ void JavaObject::Init(v8::Handle<v8::Object> target) {
 }
 
 /*static*/ v8::Local<v8::Object> JavaObject::New(Java *java, jobject obj) {
-  NanEscapableScope();
+  Nan::EscapableHandleScope scope;
 
   JNIEnv *env = java->getJavaEnv();
   JavaScope javaScope(env);
@@ -29,21 +29,21 @@
 
   v8::Local<v8::Function> promisify;
   if(java->DoPromise()) {
-    v8::Local<v8::Object> asyncOptions = NanObjectWrapHandle(java)->Get(NanNew<v8::String>("asyncOptions")).As<v8::Object>();
-    v8::Local<v8::Value> promisifyValue = asyncOptions->Get(NanNew<v8::String>("promisify"));
+    v8::Local<v8::Object> asyncOptions = java->handle()->Get(Nan::New<v8::String>("asyncOptions").ToLocalChecked()).As<v8::Object>();
+    v8::Local<v8::Value> promisifyValue = asyncOptions->Get(Nan::New<v8::String>("promisify").ToLocalChecked());
     promisify = promisifyValue.As<v8::Function>();
   }
 
   v8::Local<v8::FunctionTemplate> funcTemplate;
   if(sFunctionTemplates.find(className) != sFunctionTemplates.end()) {
     //printf("existing className: %s\n", className.c_str());
-    funcTemplate = NanNew(*sFunctionTemplates[className]);
+    funcTemplate = Nan::New(*sFunctionTemplates[className]);
   } else {
     //printf("create className: %s\n", className.c_str());
 
-    funcTemplate = NanNew<v8::FunctionTemplate>();
+    funcTemplate = Nan::New<v8::FunctionTemplate>();
     funcTemplate->InstanceTemplate()->SetInternalFieldCount(1);
-    funcTemplate->SetClassName(NanNew<v8::String>(className.c_str()));
+    funcTemplate->SetClassName(Nan::New<v8::String>(className.c_str()).ToLocalChecked());
 
     std::list<jobject> methods;
     javaReflectionGetMethods(env, objClazz, &methods, false);
@@ -54,18 +54,18 @@
       assert(!env->ExceptionCheck());
       std::string methodNameStr = javaToString(env, methodNameJava);
 
-      v8::Handle<v8::String> baseMethodName = NanNew<v8::String>(methodNameStr.c_str());
+      v8::Local<v8::String> baseMethodName = Nan::New<v8::String>(methodNameStr.c_str()).ToLocalChecked();
 
-      v8::Handle<v8::String> methodNameAsync = NanNew<v8::String>((methodNameStr + java->AsyncSuffix()).c_str());
-      v8::Local<v8::FunctionTemplate> methodCallTemplate = NanNew<v8::FunctionTemplate>(methodCall, baseMethodName);
+      v8::Local<v8::String> methodNameAsync = Nan::New<v8::String>((methodNameStr + java->AsyncSuffix()).c_str()).ToLocalChecked();
+      v8::Local<v8::FunctionTemplate> methodCallTemplate = Nan::New<v8::FunctionTemplate>(methodCall, baseMethodName);
       funcTemplate->PrototypeTemplate()->Set(methodNameAsync, methodCallTemplate->GetFunction());
 
-      v8::Handle<v8::String> methodNameSync = NanNew<v8::String>((methodNameStr + java->SyncSuffix()).c_str());
-      v8::Local<v8::FunctionTemplate> methodCallSyncTemplate = NanNew<v8::FunctionTemplate>(methodCallSync, baseMethodName);
+      v8::Local<v8::String> methodNameSync = Nan::New<v8::String>((methodNameStr + java->SyncSuffix()).c_str()).ToLocalChecked();
+      v8::Local<v8::FunctionTemplate> methodCallSyncTemplate = Nan::New<v8::FunctionTemplate>(methodCallSync, baseMethodName);
       funcTemplate->PrototypeTemplate()->Set(methodNameSync, methodCallSyncTemplate->GetFunction());
 
       if (java->DoPromise()) {
-        v8::Local<v8::Object> recv = NanNew<v8::Object>();
+        v8::Local<v8::Object> recv = Nan::New<v8::Object>();
         v8::Local<v8::Value> argv[] = { methodCallTemplate->GetFunction() };
         v8::Local<v8::Value> result = promisify->Call(recv, 1, argv);
         if (!result->IsFunction()) {
@@ -73,7 +73,7 @@
           assert(result->IsFunction());
         }
         v8::Local<v8::Function> promFunction = result.As<v8::Function>();
-        v8::Handle<v8::String> methodNamePromise = NanNew<v8::String>((methodNameStr + java->PromiseSuffix()).c_str());
+        v8::Local<v8::String> methodNamePromise = Nan::New<v8::String>((methodNameStr + java->PromiseSuffix()).c_str()).ToLocalChecked();
         funcTemplate->PrototypeTemplate()->Set(methodNamePromise, promFunction);
       }
     }
@@ -87,22 +87,22 @@
       checkJavaException(env);
       std::string fieldNameStr = javaToString(env, fieldNameJava);
 
-      v8::Handle<v8::String> fieldName = NanNew<v8::String>(fieldNameStr.c_str());
-      funcTemplate->InstanceTemplate()->SetAccessor(fieldName, fieldGetter, fieldSetter);
+      v8::Local<v8::String> fieldName = Nan::New<v8::String>(fieldNameStr.c_str()).ToLocalChecked();
+      Nan::SetAccessor(funcTemplate->InstanceTemplate(), fieldName, fieldGetter, fieldSetter);
     }
 
-    v8::Persistent<v8::FunctionTemplate>* persistentFuncTemplate = new v8::Persistent<v8::FunctionTemplate>();
-    NanAssignPersistent(*persistentFuncTemplate, funcTemplate);
+    Nan::Persistent<v8::FunctionTemplate>* persistentFuncTemplate = new Nan::Persistent<v8::FunctionTemplate>();
+    persistentFuncTemplate->Reset(funcTemplate);
     sFunctionTemplates[className] = persistentFuncTemplate;
   }
 
   v8::Local<v8::Function> ctor = funcTemplate->GetFunction();
   v8::Local<v8::Object> javaObjectObj = ctor->NewInstance();
-  javaObjectObj->SetHiddenValue(NanNew<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT), NanNew<v8::Boolean>(true));
+  javaObjectObj->SetHiddenValue(Nan::New<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked(), Nan::New<v8::Boolean>(true));
   JavaObject *self = new JavaObject(java, obj);
   self->Wrap(javaObjectObj);
 
-  return NanEscapeScope(javaObjectObj);
+  return scope.Escape(javaObjectObj);
 }
 
 JavaObject::JavaObject(Java *java, jobject obj) {
@@ -119,31 +119,32 @@ JavaObject::~JavaObject() {
 }
 
 NAN_METHOD(JavaObject::methodCall) {
-  NanScope();
-  JavaObject* self = node::ObjectWrap::Unwrap<JavaObject>(args.This());
+  Nan::HandleScope scope;
+  JavaObject* self = Nan::ObjectWrap::Unwrap<JavaObject>(info.This());
   JNIEnv *env = self->m_java->getJavaEnv();
   JavaScope javaScope(env);
 
-  v8::String::Utf8Value methodName(args.Data());
+  v8::String::Utf8Value methodName(info.Data());
   std::string methodNameStr = *methodName;
 
   int argsStart = 0;
-  int argsEnd = args.Length();
+  int argsEnd = info.Length();
 
   // arguments
   ARGS_BACK_CALLBACK();
 
   if(!callbackProvided && methodNameStr == "toString") {
-    return methodCallSync(args);
+    return methodCallSync(info);
   }
 
-  jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
+  jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd);
 
   jobject method = javaFindMethod(env, self->m_class, methodNameStr, methodArgs);
   if(method == NULL) {
-    std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, args, argsStart, argsEnd);
+    std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, info, argsStart, argsEnd);
     EXCEPTION_CALL_CALLBACK(self->m_java, msg);
-    NanReturnUndefined();
+    info.GetReturnValue().SetUndefined();
+    return;
   }
 
   // run
@@ -154,42 +155,44 @@ NAN_METHOD(JavaObject::methodCall) {
 }
 
 NAN_METHOD(JavaObject::methodCallSync) {
-  NanScope();
-  JavaObject* self = node::ObjectWrap::Unwrap<JavaObject>(args.This());
+  Nan::HandleScope scope;
+  JavaObject* self = Nan::ObjectWrap::Unwrap<JavaObject>(info.This());
   JNIEnv *env = self->m_java->getJavaEnv();
   JavaScope javaScope(env);
 
-  v8::String::Utf8Value methodName(args.Data());
+  v8::String::Utf8Value methodName(info.Data());
   std::string methodNameStr = *methodName;
 
   int argsStart = 0;
-  int argsEnd = args.Length();
+  int argsEnd = info.Length();
 
-  jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
+  jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd);
 
   jobject method = javaFindMethod(env, self->m_class, methodNameStr, methodArgs);
   if(method == NULL) {
-    std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, args, argsStart, argsEnd);
-    v8::Handle<v8::Value> ex = javaExceptionToV8(self->m_java, env, msg);
-    return NanThrowError(ex);
+    std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, info, argsStart, argsEnd);
+    v8::Local<v8::Value> ex = javaExceptionToV8(self->m_java, env, msg);
+    Nan::ThrowError(ex);
+    return;
   }
 
   // run
-  v8::Handle<v8::Value> callback = NanUndefined();
+  v8::Local<v8::Value> callback = Nan::Undefined();
   InstanceMethodCallBaton* baton = new InstanceMethodCallBaton(self->m_java, self, method, methodArgs, callback);
-  v8::Handle<v8::Value> result = baton->runSync();
+  v8::Local<v8::Value> result = baton->runSync();
   delete baton;
 
   if(result->IsNativeError()) {
-    return NanThrowError(result);
+    Nan::ThrowError(result);
+    return;
   }
 
-  NanReturnValue(result);
+  info.GetReturnValue().Set(result);
 }
 
 NAN_GETTER(JavaObject::fieldGetter) {
-  NanScope();
-  JavaObject* self = node::ObjectWrap::Unwrap<JavaObject>(args.This());
+  Nan::HandleScope scope;
+  JavaObject* self = Nan::ObjectWrap::Unwrap<JavaObject>(info.This());
   JNIEnv *env = self->m_java->getJavaEnv();
   JavaScope javaScope(env);
 
@@ -199,8 +202,9 @@ NAN_GETTER(JavaObject::fieldGetter) {
   if(field == NULL) {
     std::ostringstream errStr;
     errStr << "Could not find field " << propertyStr;
-    v8::Handle<v8::Value> ex = javaExceptionToV8(self->m_java, env, errStr.str());
-    return NanThrowError(ex);
+    v8::Local<v8::Value> ex = javaExceptionToV8(self->m_java, env, errStr.str());
+    Nan::ThrowError(ex);
+    return;
   }
 
   jclass fieldClazz = env->FindClass("java/lang/reflect/Field");
@@ -211,18 +215,19 @@ NAN_GETTER(JavaObject::fieldGetter) {
   if(env->ExceptionOccurred()) {
     std::ostringstream errStr;
     errStr << "Could not get field " << propertyStr;
-    v8::Handle<v8::Value> ex = javaExceptionToV8(self->m_java, env, errStr.str());
-    return NanThrowError(ex);
+    v8::Local<v8::Value> ex = javaExceptionToV8(self->m_java, env, errStr.str());
+    Nan::ThrowError(ex);
+    return;
   }
 
-  v8::Handle<v8::Value> result = javaToV8(self->m_java, env, val);
+  v8::Local<v8::Value> result = javaToV8(self->m_java, env, val);
 
-  NanReturnValue(result);
+  info.GetReturnValue().Set(result);
 }
 
 NAN_SETTER(JavaObject::fieldSetter) {
-  NanScope();
-  JavaObject* self = node::ObjectWrap::Unwrap<JavaObject>(args.This());
+  Nan::HandleScope scope;
+  JavaObject* self = Nan::ObjectWrap::Unwrap<JavaObject>(info.This());
   JNIEnv *env = self->m_java->getJavaEnv();
   JavaScope javaScope(env);
 
@@ -234,8 +239,8 @@ NAN_SETTER(JavaObject::fieldSetter) {
   if(field == NULL) {
     std::ostringstream errStr;
     errStr << "Could not find field " << propertyStr;
-    v8::Handle<v8::Value> error = javaExceptionToV8(self->m_java, env, errStr.str());
-    NanThrowError(error);
+    v8::Local<v8::Value> error = javaExceptionToV8(self->m_java, env, errStr.str());
+    Nan::ThrowError(error);
     return;
   }
 
@@ -249,38 +254,38 @@ NAN_SETTER(JavaObject::fieldSetter) {
   if(env->ExceptionOccurred()) {
     std::ostringstream errStr;
     errStr << "Could not set field " << propertyStr;
-    v8::Handle<v8::Value> error = javaExceptionToV8(self->m_java, env, errStr.str());
-    NanThrowError(error);
+    v8::Local<v8::Value> error = javaExceptionToV8(self->m_java, env, errStr.str());
+    Nan::ThrowError(error);
     return;
   }
 }
 
-/*static*/ v8::Persistent<v8::FunctionTemplate> JavaProxyObject::s_proxyCt;
+/*static*/ Nan::Persistent<v8::FunctionTemplate> JavaProxyObject::s_proxyCt;
 
 /*static*/ void JavaProxyObject::init() {
-  v8::Local<v8::FunctionTemplate> t = NanNew<v8::FunctionTemplate>();
-  NanAssignPersistent(s_proxyCt, t);
+  v8::Local<v8::FunctionTemplate> t = Nan::New<v8::FunctionTemplate>();
+  s_proxyCt.Reset(t);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(NanNew<v8::String>("NodeDynamicProxy"));
+  t->SetClassName(Nan::New<v8::String>("NodeDynamicProxy").ToLocalChecked());
 
-  v8::Handle<v8::String> methodName = NanNew<v8::String>("unref");
-  v8::Local<v8::FunctionTemplate> methodCallTemplate = NanNew<v8::FunctionTemplate>(doUnref);
+  v8::Local<v8::String> methodName = Nan::New<v8::String>("unref").ToLocalChecked();
+  v8::Local<v8::FunctionTemplate> methodCallTemplate = Nan::New<v8::FunctionTemplate>(doUnref);
   t->PrototypeTemplate()->Set(methodName, methodCallTemplate->GetFunction());
 
-  v8::Handle<v8::String> fieldName = NanNew<v8::String>("invocationHandler");
-  t->InstanceTemplate()->SetAccessor(fieldName, invocationHandlerGetter);
+  v8::Local<v8::String> fieldName = Nan::New<v8::String>("invocationHandler").ToLocalChecked();
+  Nan::SetAccessor(t->InstanceTemplate(), fieldName, invocationHandlerGetter);
 }
 
 v8::Local<v8::Object> JavaProxyObject::New(Java *java, jobject obj, DynamicProxyData* dynamicProxyData) {
-  NanEscapableScope();
+  Nan::EscapableHandleScope scope;
 
-  v8::Local<v8::Function> ctor = NanNew(s_proxyCt)->GetFunction();
+  v8::Local<v8::Function> ctor = Nan::New(s_proxyCt)->GetFunction();
   v8::Local<v8::Object> javaObjectObj = ctor->NewInstance();
-  javaObjectObj->SetHiddenValue(NanNew<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT), NanNew<v8::Boolean>(true));
+  javaObjectObj->SetHiddenValue(Nan::New<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked(), Nan::New<v8::Boolean>(true));
   JavaProxyObject *self = new JavaProxyObject(java, obj, dynamicProxyData);
   self->Wrap(javaObjectObj);
 
-  return NanEscapeScope(javaObjectObj);
+  return scope.Escape(javaObjectObj);
 }
 
 JavaProxyObject::JavaProxyObject(Java *java, jobject obj, DynamicProxyData* dynamicProxyData) : JavaObject(java, obj) {
@@ -294,19 +299,20 @@ JavaProxyObject::~JavaProxyObject() {
 }
 
 NAN_METHOD(JavaProxyObject::doUnref) {
-  JavaProxyObject* self = node::ObjectWrap::Unwrap<JavaProxyObject>(args.This());
+  JavaProxyObject* self = Nan::ObjectWrap::Unwrap<JavaProxyObject>(info.This());
   if (dynamicProxyDataVerify(self->m_dynamicProxyData)) {
     unref(self->m_dynamicProxyData);
   }
-  NanReturnUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_GETTER(JavaProxyObject::invocationHandlerGetter) {
- NanScope();
+ Nan::HandleScope scope;
 
- JavaProxyObject* self = node::ObjectWrap::Unwrap<JavaProxyObject>(args.This());
+ JavaProxyObject* self = Nan::ObjectWrap::Unwrap<JavaProxyObject>(info.This());
  if (!dynamicProxyDataVerify(self->m_dynamicProxyData)) {
-   return NanThrowError("dynamicProxyData has been destroyed or corrupted");
+   Nan::ThrowError("dynamicProxyData has been destroyed or corrupted");
+   return;
  }
- NanReturnValue(self->m_dynamicProxyData->functions);
+ info.GetReturnValue().Set(Nan::New(self->m_dynamicProxyData->functions));
 }
diff --git a/src/javaObject.h b/src/javaObject.h
index 7d30a6f3..bf9ab9ae 100644
--- a/src/javaObject.h
+++ b/src/javaObject.h
@@ -11,7 +11,7 @@
 
 class Java;
 
-class JavaObject : public node::ObjectWrap {
+class JavaObject : public Nan::ObjectWrap {
 public:
   static void Init(v8::Handle<v8::Object> target);
   static v8::Local<v8::Object> New(Java* java, jobject obj);
@@ -20,8 +20,8 @@ class JavaObject : public node::ObjectWrap {
   jobject getObject() { return m_obj; }
   jclass getClass() { return m_class; }
 
-  void Ref() { node::ObjectWrap::Ref(); }
-  void Unref() { node::ObjectWrap::Unref(); }
+  void Ref() { Nan::ObjectWrap::Ref(); }
+  void Unref() { Nan::ObjectWrap::Unref(); }
 
 protected:
   JavaObject(Java* java, jobject obj);
@@ -33,7 +33,7 @@ class JavaObject : public node::ObjectWrap {
   static NAN_GETTER(fieldGetter);
   static NAN_SETTER(fieldSetter);
 
-  static std::map<std::string, v8::Persistent<v8::FunctionTemplate>*> sFunctionTemplates;
+  static std::map<std::string, Nan::Persistent<v8::FunctionTemplate>*> sFunctionTemplates;
   Java* m_java;
   jobject m_obj;
   jclass m_class;
@@ -50,7 +50,7 @@ class JavaProxyObject : public JavaObject {
   static NAN_METHOD(doUnref);
   static NAN_GETTER(invocationHandlerGetter);
 
-  static v8::Persistent<v8::FunctionTemplate> s_proxyCt;
+  static Nan::Persistent<v8::FunctionTemplate> s_proxyCt;
   DynamicProxyData* m_dynamicProxyData;
 };
 
diff --git a/src/methodCallBaton.cpp b/src/methodCallBaton.cpp
index 1d0412e8..04fd7163 100644
--- a/src/methodCallBaton.cpp
+++ b/src/methodCallBaton.cpp
@@ -6,15 +6,15 @@
 
 jmethodID MethodCallBaton::m_methodInvokeMethodId = 0;
 
-NanCallback* toNanCallback(v8::Handle<v8::Value>& callback) {
+Nan::Callback* toNanCallback(v8::Local<v8::Value>& callback) {
   if(callback->IsFunction()) {
-    return new NanCallback(callback.As<v8::Function>());
+    return new Nan::Callback(callback.As<v8::Function>());
   }
   return NULL;
 }
 
-MethodCallBaton::MethodCallBaton(Java* java, jobject method, jarray args, v8::Handle<v8::Value>& callback) :
-  NanAsyncWorker(toNanCallback(callback)) {
+MethodCallBaton::MethodCallBaton(Java* java, jobject method, jarray args, v8::Local<v8::Value>& callback) :
+  Nan::AsyncWorker(toNanCallback(callback)) {
   JNIEnv *env = java->getJavaEnv();
   m_java = java;
   m_args = (jarray)env->NewGlobalRef(args);
@@ -52,10 +52,10 @@ jmethodID MethodCallBaton::getMethodInvokeMethodId(JNIEnv *env) {
 }
 
 void MethodCallBaton::run() {
-  NanAsyncQueueWorker(this);
+  Nan::AsyncQueueWorker(this);
 }
 
-v8::Handle<v8::Value> MethodCallBaton::runSync() {
+v8::Local<v8::Value> MethodCallBaton::runSync() {
   JNIEnv* env = m_java->getJavaEnv();
   ExecuteInternal(env);
   return resultsToV8(env);
@@ -70,20 +70,20 @@ void MethodCallBaton::Execute() {
 
 // callback from NanAsyncWorker. This will be on the v8 main thread
 void MethodCallBaton::WorkComplete() {
-  NanScope();
+  Nan::HandleScope scope;
 
   if(callback) {
     JNIEnv* env = javaGetEnv(this->m_java->getJvm(), this->m_java->getClassLoader());
     JavaScope javaScope(env);
-    v8::Handle<v8::Value> result = resultsToV8(env);
+    v8::Local<v8::Value> result = resultsToV8(env);
     if (result->IsNativeError()) {
-      v8::Handle<v8::Value> argv[] = {
+      v8::Local<v8::Value> argv[] = {
         result
       };
       callback->Call(1, argv);
     } else {
-      v8::Handle<v8::Value> argv[] = {
-        NanUndefined(),
+      v8::Local<v8::Value> argv[] = {
+        Nan::Undefined(),
         result
       };
       callback->Call(2, argv);
@@ -94,8 +94,8 @@ void MethodCallBaton::WorkComplete() {
   }
 }
 
-v8::Handle<v8::Value> MethodCallBaton::resultsToV8(JNIEnv *env) {
-  NanEscapableScope();
+v8::Local<v8::Value> MethodCallBaton::resultsToV8(JNIEnv *env) {
+  Nan::EscapableHandleScope scope;
 
   if(m_error) {
     jthrowable cause = m_error;
@@ -111,11 +111,11 @@ v8::Handle<v8::Value> MethodCallBaton::resultsToV8(JNIEnv *env) {
       checkJavaException(env);
     }
 
-    v8::Handle<v8::Value> err = javaExceptionToV8(m_java, env, cause, m_errorString);
-    return NanEscapeScope(err);
+    v8::Local<v8::Value> err = javaExceptionToV8(m_java, env, cause, m_errorString);
+    return scope.Escape(err);
   }
 
-  return NanEscapeScope(javaToV8(m_java, env, m_result));
+  return scope.Escape(javaToV8(m_java, 	env, m_result));
 }
 
 void NewInstanceBaton::ExecuteInternal(JNIEnv* env) {
@@ -198,7 +198,7 @@ NewInstanceBaton::NewInstanceBaton(
   jclass clazz,
   jobject method,
   jarray args,
-  v8::Handle<v8::Value>& callback) : MethodCallBaton(java, method, args, callback) {
+  v8::Local<v8::Value>& callback) : MethodCallBaton(java, method, args, callback) {
   JNIEnv *env = m_java->getJavaEnv();
   m_clazz = (jclass)env->NewGlobalRef(clazz);
 }
@@ -214,7 +214,7 @@ StaticMethodCallBaton::StaticMethodCallBaton(
   jclass clazz,
   jobject method,
   jarray args,
-  v8::Handle<v8::Value>& callback) : MethodCallBaton(java, method, args, callback) {
+  v8::Local<v8::Value>& callback) : MethodCallBaton(java, method, args, callback) {
   JNIEnv *env = m_java->getJavaEnv();
   m_clazz = (jclass)env->NewGlobalRef(clazz);
 }
@@ -230,7 +230,7 @@ InstanceMethodCallBaton::InstanceMethodCallBaton(
   JavaObject* obj,
   jobject method,
   jarray args,
-  v8::Handle<v8::Value>& callback) : MethodCallBaton(java, method, args, callback) {
+  v8::Local<v8::Value>& callback) : MethodCallBaton(java, method, args, callback) {
   m_javaObject = obj;
   m_javaObject->Ref();
 }
diff --git a/src/methodCallBaton.h b/src/methodCallBaton.h
index ff2fc051..504d00d8 100644
--- a/src/methodCallBaton.h
+++ b/src/methodCallBaton.h
@@ -12,16 +12,16 @@
 class Java;
 class JavaObject;
 
-class MethodCallBaton : public NanAsyncWorker {
+class MethodCallBaton : public Nan::AsyncWorker {
 public:
-  MethodCallBaton(Java* java, jobject method, jarray args, v8::Handle<v8::Value>& callback);
+  MethodCallBaton(Java* java, jobject method, jarray args, v8::Local<v8::Value>& callback);
   virtual ~MethodCallBaton();
 
   void run();
-  v8::Handle<v8::Value> runSync();
+  v8::Local<v8::Value> runSync();
 
 protected:
-  v8::Handle<v8::Value> resultsToV8(JNIEnv *env);
+  v8::Local<v8::Value> resultsToV8(JNIEnv *env);
   virtual void Execute();
   virtual void WorkComplete();
   virtual void ExecuteInternal(JNIEnv* env) = 0;
@@ -40,7 +40,7 @@ class MethodCallBaton : public NanAsyncWorker {
 
 class InstanceMethodCallBaton : public MethodCallBaton {
 public:
-  InstanceMethodCallBaton(Java* java, JavaObject* obj, jobject method, jarray args, v8::Handle<v8::Value>& callback);
+  InstanceMethodCallBaton(Java* java, JavaObject* obj, jobject method, jarray args, v8::Local<v8::Value>& callback);
   virtual ~InstanceMethodCallBaton();
 
 protected:
@@ -51,7 +51,7 @@ class InstanceMethodCallBaton : public MethodCallBaton {
 
 class NewInstanceBaton : public MethodCallBaton {
 public:
-  NewInstanceBaton(Java* java, jclass clazz, jobject method, jarray args, v8::Handle<v8::Value>& callback);
+  NewInstanceBaton(Java* java, jclass clazz, jobject method, jarray args, v8::Local<v8::Value>& callback);
   virtual ~NewInstanceBaton();
 
 protected:
@@ -62,7 +62,7 @@ class NewInstanceBaton : public MethodCallBaton {
 
 class StaticMethodCallBaton : public MethodCallBaton {
 public:
-  StaticMethodCallBaton(Java* java, jclass clazz, jobject method, jarray args, v8::Handle<v8::Value>& callback);
+  StaticMethodCallBaton(Java* java, jclass clazz, jobject method, jarray args, v8::Local<v8::Value>& callback);
   virtual ~StaticMethodCallBaton();
 
 protected:
diff --git a/src/utils.cpp b/src/utils.cpp
index f4f34eac..a28f9d4e 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -279,7 +279,7 @@ static std::string getArrayElementType(v8::Local<v8::Array> array, uint32_t arra
     }
     else if(arg->IsObject()) {
       v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(arg);
-      v8::Local<v8::Value> isJavaLong = obj->GetHiddenValue(NanNew<v8::String>(V8_HIDDEN_MARKER_JAVA_LONG));
+      v8::Local<v8::Value> isJavaLong = obj->GetHiddenValue(Nan::New<v8::String>(V8_HIDDEN_MARKER_JAVA_LONG).ToLocalChecked());
       if(!isJavaLong.IsEmpty() && isJavaLong->IsBoolean()) {
         types.insert(kLong);
       }
@@ -353,12 +353,12 @@ jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg) {
   if(arg->IsObject()) {
     v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(arg);
 
-    v8::Local<v8::Value> isJavaObject = obj->GetHiddenValue(NanNew<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT));
+    v8::Local<v8::Value> isJavaObject = obj->GetHiddenValue(Nan::New<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked());
     if(!isJavaObject.IsEmpty() && isJavaObject->IsBoolean()) {
       return v8ToJava_javaObject(env, obj);
     }
 
-    v8::Local<v8::Value> isJavaLong = obj->GetHiddenValue(NanNew<v8::String>(V8_HIDDEN_MARKER_JAVA_LONG));
+    v8::Local<v8::Value> isJavaLong = obj->GetHiddenValue(Nan::New<v8::String>(V8_HIDDEN_MARKER_JAVA_LONG).ToLocalChecked());
     if(!isJavaLong.IsEmpty() && isJavaLong->IsBoolean()) {
       return v8ToJava_javaLong(env, obj);
     }
@@ -371,7 +371,7 @@ jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg) {
 }
 
 jobject v8ToJava_javaObject(JNIEnv* env, v8::Local<v8::Object> obj) {
-  JavaObject* javaObject = node::ObjectWrap::Unwrap<JavaObject>(obj);
+  JavaObject* javaObject = Nan::ObjectWrap::Unwrap<JavaObject>(obj);
   return javaObject->getObject();
 }
 
@@ -387,14 +387,14 @@ void checkJavaException(JNIEnv* env) {
 }
 
 jobject v8ToJava_javaLong(JNIEnv* env, v8::Local<v8::Object> obj) {
-  jobject longValue = v8ToJava(env, obj->Get(NanNew<v8::String>("longValue")));
+  jobject longValue = v8ToJava(env, obj->Get(Nan::New<v8::String>("longValue").ToLocalChecked()));
   jclass longClazz = env->FindClass("java/lang/Long");
   jmethodID long_constructor = env->GetMethodID(longClazz, "<init>", "(Ljava/lang/String;)V");
   jobject jobj = env->NewObject(longClazz, long_constructor, longValue);
   return jobj;
 }
 
-jobjectArray v8ToJava(JNIEnv* env, _NAN_METHOD_ARGS_TYPE args, int start, int end) {
+jobjectArray v8ToJava(JNIEnv* env, Nan::NAN_METHOD_ARGS_TYPE args, int start, int end) {
   jclass clazz = env->FindClass("java/lang/Object");
   jobjectArray results = env->NewObjectArray(end-start, clazz, NULL);
 
@@ -426,22 +426,22 @@ std::string javaExceptionToString(JNIEnv* env, jthrowable ex) {
   return javaToString(env, strObj);
 }
 
-v8::Handle<v8::Value> javaExceptionToV8(Java* java, JNIEnv* env, jthrowable ex, const std::string& alternateMessage) {
+v8::Local<v8::Value> javaExceptionToV8(Java* java, JNIEnv* env, jthrowable ex, const std::string& alternateMessage) {
   std::ostringstream msg;
   msg << alternateMessage;
 
   if(ex) {
     msg << "\n" << javaExceptionToString(env, ex);
 
-    v8::Local<v8::Value> v8ex = v8::Exception::Error(NanNew<v8::String>(msg.str().c_str()));
-    ((v8::Object*)*v8ex)->Set(NanNew<v8::String>("cause"), javaToV8(java, env, ex));
+    v8::Local<v8::Value> v8ex = v8::Exception::Error(Nan::New<v8::String>(msg.str().c_str()).ToLocalChecked());
+    ((v8::Object*)*v8ex)->Set(Nan::New<v8::String>("cause").ToLocalChecked(), javaToV8(java, env, ex));
     return v8ex;
   }
 
-  return v8::Exception::Error(NanNew<v8::String>(msg.str().c_str()));
+  return v8::Exception::Error(Nan::New<v8::String>(msg.str().c_str()).ToLocalChecked());
 }
 
-v8::Handle<v8::Value> javaExceptionToV8(Java* java, JNIEnv* env, const std::string& alternateMessage) {
+v8::Local<v8::Value> javaExceptionToV8(Java* java, JNIEnv* env, const std::string& alternateMessage) {
   jthrowable ex = env->ExceptionOccurred();
   env->ExceptionClear();
   return javaExceptionToV8(java, env, ex, alternateMessage);
@@ -463,9 +463,9 @@ jvalueType javaGetArrayComponentType(JNIEnv *env, jobjectArray array) {
   return arrayComponentType;
 }
 
-v8::Handle<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArray) {
+v8::Local<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArray) {
   if(objArray == NULL) {
-    return NanNull();
+    return Nan::Null();
   }
 
   jvalueType arrayComponentType = javaGetArrayComponentType(env, objArray);
@@ -474,13 +474,13 @@ v8::Handle<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArr
   jsize arraySize = env->GetArrayLength(objArray);
   //printf("array size: %d\n", arraySize);
 
-  v8::Handle<v8::Array> result = NanNew<v8::Array>(arraySize);
+  v8::Local<v8::Array> result = Nan::New<v8::Array>(arraySize);
   switch(arrayComponentType) {
   case TYPE_INT:
     {
       jint* elems = env->GetIntArrayElements((jintArray)objArray, 0);
       for(jsize i=0; i<arraySize; i++) {
-        result->Set(i, NanNew<v8::Integer>(elems[i]));
+        result->Set(i, Nan::New<v8::Integer>(elems[i]));
       }
       env->ReleaseIntArrayElements((jintArray)objArray, elems, 0);
     }
@@ -490,7 +490,7 @@ v8::Handle<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArr
     {
       jbyte* elems = env->GetByteArrayElements((jbyteArray)objArray, 0);
       for(jsize i=0; i<arraySize; i++) {
-        result->Set(i, NanNew<v8::Number>(elems[i]));
+        result->Set(i, Nan::New<v8::Number>(elems[i]));
       }
       env->ReleaseByteArrayElements((jbyteArray)objArray, elems, 0);
     }
@@ -500,7 +500,7 @@ v8::Handle<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArr
     {
       jboolean* elems = env->GetBooleanArrayElements((jbooleanArray)objArray, 0);
       for(jsize i=0; i<arraySize; i++) {
-        result->Set(i, NanNew<v8::Boolean>(elems[i]));
+        result->Set(i, Nan::New<v8::Boolean>(elems[i]));
       }
       env->ReleaseBooleanArrayElements((jbooleanArray)objArray, elems, 0);
     }
@@ -510,7 +510,7 @@ v8::Handle<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArr
     {
       jshort* elems = env->GetShortArrayElements((jshortArray)objArray, 0);
       for(jsize i=0; i<arraySize; i++) {
-        result->Set(i, NanNew<v8::Number>(elems[i]));
+        result->Set(i, Nan::New<v8::Number>(elems[i]));
       }
       env->ReleaseShortArrayElements((jshortArray)objArray, elems, 0);
     }
@@ -520,7 +520,7 @@ v8::Handle<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArr
     {
       jdouble* elems = env->GetDoubleArrayElements((jdoubleArray)objArray, 0);
       for(jsize i=0; i<arraySize; i++) {
-        result->Set(i, NanNew<v8::Number>(elems[i]));
+        result->Set(i, Nan::New<v8::Number>(elems[i]));
       }
       env->ReleaseDoubleArrayElements((jdoubleArray)objArray, elems, 0);
     }
@@ -530,7 +530,7 @@ v8::Handle<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArr
     {
       jfloat* elems = env->GetFloatArrayElements((jfloatArray)objArray, 0);
       for(jsize i=0; i<arraySize; i++) {
-        result->Set(i, NanNew<v8::Number>(elems[i]));
+        result->Set(i, Nan::New<v8::Number>(elems[i]));
       }
       env->ReleaseFloatArrayElements((jfloatArray)objArray, elems, 0);
     }
@@ -559,13 +559,13 @@ v8::Handle<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArr
   return result;
 }
 
-v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj) {
+v8::Local<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj) {
   return javaToV8(java, env, obj, NULL);
 }
 
-v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProxyData* dynamicProxyData) {
+v8::Local<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProxyData* dynamicProxyData) {
   if(obj == NULL) {
-    return NanNull();
+    return Nan::Null();
   }
 
   jclass objClazz = env->GetObjectClass(obj);
@@ -576,18 +576,18 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProx
   switch(resultType) {
     case TYPE_ARRAY:
       {
-        v8::Handle<v8::Value> result = javaArrayToV8(java, env, (jobjectArray)obj);
+        v8::Local<v8::Value> result = javaArrayToV8(java, env, (jobjectArray)obj);
         return result;
       }
     case TYPE_VOID:
-      return NanUndefined();
+      return Nan::Undefined();
     case TYPE_BOOLEAN:
       {
         jclass booleanClazz = env->FindClass("java/lang/Boolean");
         jmethodID boolean_booleanValue = env->GetMethodID(booleanClazz, "booleanValue", "()Z");
         bool result = env->CallBooleanMethod(obj, boolean_booleanValue);
         assert(!env->ExceptionCheck());
-        return NanNew<v8::Boolean>(result);
+        return Nan::New<v8::Boolean>(result);
       }
     case TYPE_BYTE:
       {
@@ -595,7 +595,7 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProx
         jmethodID byte_byteValue = env->GetMethodID(byteClazz, "byteValue", "()B");
         jbyte result = env->CallByteMethod(obj, byte_byteValue);
         checkJavaException(env);
-        return NanNew<v8::Number>(result);
+        return Nan::New<v8::Number>(result);
       }
     case TYPE_LONG:
       {
@@ -604,10 +604,10 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProx
         jlong result = env->CallLongMethod(obj, long_longValue);
         checkJavaException(env);
         std::string strValue = javaObjectToString(env, obj);
-        v8::Local<v8::Value> v8Result = NanNew<v8::NumberObject>((double)result);
+        v8::Local<v8::Value> v8Result = Nan::New<v8::NumberObject>((double)result);
         v8::NumberObject* v8ResultNumberObject = v8::NumberObject::Cast(*v8Result);
-        v8ResultNumberObject->Set(NanNew<v8::String>("longValue"), NanNew<v8::String>(strValue.c_str()));
-        v8ResultNumberObject->SetHiddenValue(NanNew<v8::String>(V8_HIDDEN_MARKER_JAVA_LONG), NanNew<v8::Boolean>(true));
+        v8ResultNumberObject->Set(Nan::New<v8::String>("longValue").ToLocalChecked(), Nan::New<v8::String>(strValue.c_str()).ToLocalChecked());
+        v8ResultNumberObject->SetHiddenValue(Nan::New<v8::String>(V8_HIDDEN_MARKER_JAVA_LONG).ToLocalChecked(), Nan::New<v8::Boolean>(true));
         return v8Result;
       }
     case TYPE_INT:
@@ -616,7 +616,7 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProx
         jmethodID integer_intValue = env->GetMethodID(integerClazz, "intValue", "()I");
         jint result = env->CallIntMethod(obj, integer_intValue);
         checkJavaException(env);
-        return NanNew<v8::Integer>(result);
+        return Nan::New<v8::Integer>(result);
       }
     case TYPE_SHORT:
       {
@@ -624,7 +624,7 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProx
         jmethodID short_shortValue = env->GetMethodID(shortClazz, "shortValue", "()S");
         jshort result = env->CallShortMethod(obj, short_shortValue);
         assert(!env->ExceptionCheck());
-        return NanNew<v8::Integer>(result);
+        return Nan::New<v8::Integer>(result);
       }
     case TYPE_DOUBLE:
       {
@@ -632,7 +632,7 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProx
         jmethodID double_doubleValue = env->GetMethodID(doubleClazz, "doubleValue", "()D");
         jdouble result = env->CallDoubleMethod(obj, double_doubleValue);
         checkJavaException(env);
-        return NanNew<v8::Number>(result);
+        return Nan::New<v8::Number>(result);
       }
     case TYPE_FLOAT:
       {
@@ -640,10 +640,10 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProx
         jmethodID float_floatValue = env->GetMethodID(floatClazz, "floatValue", "()F");
         jfloat result = env->CallFloatMethod(obj, float_floatValue);
         assert(!env->ExceptionCheck());
-        return NanNew<v8::Number>(result);
+        return Nan::New<v8::Number>(result);
       }
     case TYPE_STRING:
-      return NanNew<v8::String>(javaObjectToString(env, obj).c_str());
+      return Nan::New<v8::String>(javaObjectToString(env, obj).c_str()).ToLocalChecked();
     case TYPE_OBJECT:
       if (dynamicProxyData != NULL) {
         return JavaProxyObject::New(java, obj, dynamicProxyData);
@@ -654,7 +654,7 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProx
       return JavaObject::New(java, obj);
   }
 
-  return NanUndefined();
+  return Nan::Undefined();
 }
 
 jobjectArray javaObjectArrayToClasses(JNIEnv *env, jobjectArray objs) {
@@ -741,7 +741,7 @@ int dynamicProxyDataVerify(DynamicProxyData* data) {
   return 0;
 }
 
-std::string methodNotFoundToString(JNIEnv *env, jclass clazz, std::string methodName, bool constructor, _NAN_METHOD_ARGS_TYPE args, int argStart, int argEnd) {
+std::string methodNotFoundToString(JNIEnv *env, jclass clazz, std::string methodName, bool constructor, Nan::NAN_METHOD_ARGS_TYPE args, int argStart, int argEnd) {
   std::ostringstream startOfMessage;
   std::ostringstream msg;
 
@@ -803,8 +803,8 @@ void unref(DynamicProxyData* dynamicProxyData) {
   if(!dynamicProxyDataVerify(dynamicProxyData)) {
     return;
   }
-  NanDisposePersistent(dynamicProxyData->jsObject);
-  NanDisposePersistent(dynamicProxyData->functions);
+  dynamicProxyData->jsObject.Reset();
+  dynamicProxyData->functions.Reset();
   dynamicProxyData->markerStart = 0;
   dynamicProxyData->markerEnd = 0;
   delete dynamicProxyData;
diff --git a/src/utils.h b/src/utils.h
index 19d22885..27353c69 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -34,8 +34,8 @@ struct DynamicProxyData {
   unsigned int markerStart;
   Java* java;
   std::string interfaceName;
-  v8::Persistent<v8::Object> functions;
-  v8::Persistent<v8::Value> jsObject;
+  Nan::Persistent<v8::Object> functions;
+  Nan::Persistent<v8::Value> jsObject;
   std::string methodName;
   jobjectArray args;
   jobject result;
@@ -61,15 +61,15 @@ JNIEnv* javaGetEnv(JavaVM* jvm, jobject classLoader);
 jobject getSystemClassLoader(JNIEnv *env);
 jvalueType javaGetArrayComponentType(JNIEnv *env, jobjectArray array);
 jvalueType javaGetType(JNIEnv *env, jclass type);
-jobjectArray v8ToJava(JNIEnv* env, _NAN_METHOD_ARGS_TYPE args, int start, int end);
+jobjectArray v8ToJava(JNIEnv* env, Nan::NAN_METHOD_ARGS_TYPE args, int start, int end);
 jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg);
-v8::Handle<v8::Value> javaExceptionToV8(Java* java, JNIEnv* env, const std::string& alternateMessage);
-v8::Handle<v8::Value> javaExceptionToV8(Java* java, JNIEnv* env, jthrowable ex, const std::string& alternateMessage);
+v8::Local<v8::Value> javaExceptionToV8(Java* java, JNIEnv* env, const std::string& alternateMessage);
+v8::Local<v8::Value> javaExceptionToV8(Java* java, JNIEnv* env, jthrowable ex, const std::string& alternateMessage);
 std::string javaExceptionToString(JNIEnv* env, jthrowable ex);
 void checkJavaException(JNIEnv* env);
-v8::Handle<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArray);
-v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj);
-v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProxyData* dynamicProxyData);
+v8::Local<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArray);
+v8::Local<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj);
+v8::Local<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProxyData* dynamicProxyData);
 jobjectArray javaObjectArrayToClasses(JNIEnv *env, jobjectArray objs);
 jobject longToJavaLongObj(JNIEnv *env, jlong l);
 jarray javaGetArgsForMethod(JNIEnv *env, jobject method, jarray args);
@@ -81,29 +81,31 @@ jobject javaFindMethod(JNIEnv *env, jclass clazz, std::string& methodName, jobje
 jobject javaFindConstructor(JNIEnv *env, jclass clazz, jobjectArray methodArgs);
 void javaCastArguments(JNIEnv *env, jobjectArray methodArgs, jobject method);
 
-std::string methodNotFoundToString(JNIEnv *env, jclass clazz, std::string methodName, bool constructor, _NAN_METHOD_ARGS_TYPE args, int argStart, int argEnd);
+std::string methodNotFoundToString(JNIEnv *env, jclass clazz, std::string methodName, bool constructor, Nan::NAN_METHOD_ARGS_TYPE args, int argStart, int argEnd);
 
 void unref(DynamicProxyData* dynamicProxyData);
 
 #define UNUSED_VARIABLE(var) var = var;
 
 #define ARGS_FRONT_OBJECT(ARGNAME) \
-  if(args.Length() < argsStart+1 || !args[argsStart]->IsObject()) {                          \
+  if(info.Length() < argsStart+1 || !info[argsStart]->IsObject()) {                          \
     std::ostringstream errStr;                                                               \
     errStr << "Argument " << (argsStart+1) << " must be an object";                          \
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>(errStr.str().c_str())));   \
+    Nan::ThrowError(Nan::TypeError(errStr.str().c_str()));                                   \
+    return;                                                                                  \
   }                                                                                          \
-  v8::Local<v8::Object> ARGNAME = v8::Local<v8::Object>::Cast(args[argsStart]);              \
+  v8::Local<v8::Object> ARGNAME = v8::Local<v8::Object>::Cast(info[argsStart]);              \
   argsStart++;
 
 #define ARGS_FRONT_STRING(ARGNAME) \
-  if(args.Length() < argsStart+1 || !args[argsStart]->IsString()) {                          \
+  if(info.Length() < argsStart+1 || !info[argsStart]->IsString()) {                          \
     std::ostringstream errStr;                                                               \
     errStr << "Argument " << (argsStart+1) << " must be a string";                           \
-    return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>(errStr.str().c_str())));   \
+    Nan::ThrowError(Nan::TypeError(errStr.str().c_str()));                                   \
+    return;                                                                                  \
   }                                                                                          \
-  v8::Local<v8::String> _##ARGNAME##_obj = v8::Local<v8::String>::Cast(args[argsStart]);     \
-  v8::String::Utf8Value _##ARGNAME##_val(_##ARGNAME##_obj);                                 \
+  v8::Local<v8::String> _##ARGNAME##_obj = v8::Local<v8::String>::Cast(info[argsStart]);     \
+  v8::String::Utf8Value _##ARGNAME##_val(_##ARGNAME##_obj);                                  \
   std::string ARGNAME = *_##ARGNAME##_val;                                                   \
   argsStart++;
 
@@ -111,13 +113,13 @@ void unref(DynamicProxyData* dynamicProxyData);
 
 #define ARGS_BACK_CALLBACK()                              \
   bool callbackProvided;                                  \
-  v8::Handle<v8::Value> callback;                         \
-  if(args[args.Length()-1]->IsFunction()) {               \
-    callback = args[argsEnd-1];                           \
+  v8::Local<v8::Value> callback;                          \
+  if(info[info.Length()-1]->IsFunction()) {               \
+    callback = info[argsEnd-1];                           \
     argsEnd--;                                            \
     callbackProvided = true;                              \
   } else {                                                \
-    callback = NanNull();                                 \
+    callback = Nan::Null();                               \
     callbackProvided = false;                             \
   }
 
@@ -127,16 +129,18 @@ void unref(DynamicProxyData* dynamicProxyData);
   v8::Handle<v8::Value> error = javaExceptionToV8(JAVA, env, errStr.str());             \
   v8::Handle<v8::Value> argv[2];                                                        \
   argv[0] = error;                                                                      \
-  argv[1] = NanUndefined();                                                            \
-  v8::Function::Cast(*callback)->Call(NanGetCurrentContext()->Global(), 2, argv);
+  argv[1] = Nan::Undefined();                                                           \
+  v8::Function::Cast(*callback)->Call(Nan::GetCurrentContext()->Global(), 2, argv);
 
 #define END_CALLBACK_FUNCTION(MSG) \
   if(callbackProvided) {                                     \
-    NanReturnUndefined();                                    \
+    info.GetReturnValue().SetUndefined();                    \
+    return;                                                  \
   } else {                                                   \
     std::ostringstream str;                                  \
     str << MSG;                                              \
-    NanReturnValue(NanNew<v8::String>(str.str().c_str()));      \
+    info.GetReturnValue().Set(Nan::New(str.str().c_str()).ToLocalChecked()); \
+    return;                                                  \
   }
 
 #ifndef UNUSED_VARIABLE