diff --git a/package.json b/package.json
index 2e6ea66..e8df38f 100644
--- a/package.json
+++ b/package.json
@@ -12,7 +12,7 @@
     "dependencies": {
         "buffertools": "^2.1.2",
         "bindings": "^1.1.0",
-        "nan": "^1.3.0"
+        "nan": "~2.0.0"
     },
     "devDependencies": {
         "mocha": "~1.11.0",
diff --git a/src/cardreader.cpp b/src/cardreader.cpp
index 6661152..3623ddd 100644
--- a/src/cardreader.cpp
+++ b/src/cardreader.cpp
@@ -4,59 +4,59 @@
 using namespace v8;
 using namespace node;
 
-Persistent<Function> CardReader::constructor;
+Nan::Persistent<Function> CardReader::constructor;
 
 void CardReader::init(Handle<Object> target) {
 
      // Prepare constructor template
-    Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New);
-    tpl->SetClassName(NanNew("CardReader"));
+    Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+    tpl->SetClassName(Nan::New("CardReader").ToLocalChecked());
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
     // Symbol
-    NanAssignPersistent(name_symbol, NanNew("name"));
-    NanAssignPersistent(connected_symbol, NanNew("connected"));
+    name_symbol.Reset(Nan::New("name").ToLocalChecked());
+    connected_symbol.Reset(Nan::New("connected").ToLocalChecked());
 
     // Prototype
-    NanSetPrototypeTemplate(tpl, "get_status", NanNew<FunctionTemplate>(GetStatus));
-    NanSetPrototypeTemplate(tpl, "_connect", NanNew<FunctionTemplate>(Connect));
-    NanSetPrototypeTemplate(tpl, "_disconnect", NanNew<FunctionTemplate>(Disconnect));
-    NanSetPrototypeTemplate(tpl, "_transmit", NanNew<FunctionTemplate>(Transmit));
-    NanSetPrototypeTemplate(tpl, "_control", NanNew<FunctionTemplate>(Control));
-    NanSetPrototypeTemplate(tpl, "close", NanNew<FunctionTemplate>(Close));
+    Nan::SetPrototypeTemplate(tpl, "get_status", Nan::New<FunctionTemplate>(GetStatus));
+    Nan::SetPrototypeTemplate(tpl, "_connect", Nan::New<FunctionTemplate>(Connect));
+    Nan::SetPrototypeTemplate(tpl, "_disconnect", Nan::New<FunctionTemplate>(Disconnect));
+    Nan::SetPrototypeTemplate(tpl, "_transmit", Nan::New<FunctionTemplate>(Transmit));
+    Nan::SetPrototypeTemplate(tpl, "_control", Nan::New<FunctionTemplate>(Control));
+    Nan::SetPrototypeTemplate(tpl, "close", Nan::New<FunctionTemplate>(Close));
 
     // PCSCLite constants
     // Share Mode
-    NanSetPrototypeTemplate(tpl, "SCARD_SHARE_SHARED", NanNew(SCARD_SHARE_SHARED));
-    NanSetPrototypeTemplate(tpl, "SCARD_SHARE_EXCLUSIVE", NanNew(SCARD_SHARE_EXCLUSIVE));
-    NanSetPrototypeTemplate(tpl, "SCARD_SHARE_DIRECT", NanNew(SCARD_SHARE_DIRECT));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_SHARE_SHARED", Nan::New(SCARD_SHARE_SHARED));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_SHARE_EXCLUSIVE", Nan::New(SCARD_SHARE_EXCLUSIVE));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_SHARE_DIRECT", Nan::New(SCARD_SHARE_DIRECT));
 
     // Protocol
-    NanSetPrototypeTemplate(tpl, "SCARD_PROTOCOL_T0", NanNew(SCARD_PROTOCOL_T0));
-    NanSetPrototypeTemplate(tpl, "SCARD_PROTOCOL_T1", NanNew(SCARD_PROTOCOL_T1));
-    NanSetPrototypeTemplate(tpl, "SCARD_PROTOCOL_RAW", NanNew(SCARD_PROTOCOL_RAW));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_PROTOCOL_T0", Nan::New(SCARD_PROTOCOL_T0));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_PROTOCOL_T1", Nan::New(SCARD_PROTOCOL_T1));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_PROTOCOL_RAW", Nan::New(SCARD_PROTOCOL_RAW));
 
     //  State
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_UNAWARE", NanNew(SCARD_STATE_UNAWARE));
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_IGNORE", NanNew(SCARD_STATE_IGNORE));
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_CHANGED", NanNew(SCARD_STATE_CHANGED));
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_UNKNOWN", NanNew(SCARD_STATE_UNKNOWN));
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_UNAVAILABLE", NanNew(SCARD_STATE_UNAVAILABLE));
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_EMPTY", NanNew(SCARD_STATE_EMPTY));
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_PRESENT", NanNew(SCARD_STATE_PRESENT));
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_ATRMATCH", NanNew(SCARD_STATE_ATRMATCH));
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_EXCLUSIVE", NanNew(SCARD_STATE_EXCLUSIVE));
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_INUSE", NanNew(SCARD_STATE_INUSE));
-    NanSetPrototypeTemplate(tpl, "SCARD_STATE_MUTE", NanNew(SCARD_STATE_MUTE));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_UNAWARE", Nan::New(SCARD_STATE_UNAWARE));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_IGNORE", Nan::New(SCARD_STATE_IGNORE));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_CHANGED", Nan::New(SCARD_STATE_CHANGED));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_UNKNOWN", Nan::New(SCARD_STATE_UNKNOWN));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_UNAVAILABLE", Nan::New(SCARD_STATE_UNAVAILABLE));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_EMPTY", Nan::New(SCARD_STATE_EMPTY));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_PRESENT", Nan::New(SCARD_STATE_PRESENT));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_ATRMATCH", Nan::New(SCARD_STATE_ATRMATCH));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_EXCLUSIVE", Nan::New(SCARD_STATE_EXCLUSIVE));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_INUSE", Nan::New(SCARD_STATE_INUSE));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_STATE_MUTE", Nan::New(SCARD_STATE_MUTE));
 
     // Disconnect disposition
-    NanSetPrototypeTemplate(tpl, "SCARD_LEAVE_CARD", NanNew(SCARD_LEAVE_CARD));
-    NanSetPrototypeTemplate(tpl, "SCARD_RESET_CARD", NanNew(SCARD_RESET_CARD));
-    NanSetPrototypeTemplate(tpl, "SCARD_UNPOWER_CARD", NanNew(SCARD_UNPOWER_CARD));
-    NanSetPrototypeTemplate(tpl, "SCARD_EJECT_CARD", NanNew(SCARD_EJECT_CARD));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_LEAVE_CARD", Nan::New(SCARD_LEAVE_CARD));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_RESET_CARD", Nan::New(SCARD_RESET_CARD));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_UNPOWER_CARD", Nan::New(SCARD_UNPOWER_CARD));
+    Nan::SetPrototypeTemplate(tpl, "SCARD_EJECT_CARD", Nan::New(SCARD_EJECT_CARD));
 
-    NanAssignPersistent<Function>(constructor, tpl->GetFunction());
-    target->Set(NanNew("CardReader"), tpl->GetFunction());
+    constructor.Reset(tpl->GetFunction());
+    target->Set(Nan::New("CardReader").ToLocalChecked(), tpl->GetFunction());
 }
 
 CardReader::CardReader(const std::string &reader_name): m_card_context(0),
@@ -81,63 +81,63 @@ CardReader::~CardReader() {
 
 NAN_METHOD(CardReader::New) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
-    v8::String::Utf8Value reader_name(args[0]->ToString());
+    v8::String::Utf8Value reader_name(info[0]->ToString());
     CardReader* obj = new CardReader(*reader_name);
-    obj->Wrap(args.Holder());
-    NanObjectWrapHandle(obj)->Set(NanNew(name_symbol), args[0]->ToString());
-    NanObjectWrapHandle(obj)->Set(NanNew(connected_symbol), NanFalse());
+    obj->Wrap(info.Holder());
+    obj->handle()->Set(Nan::New(name_symbol), info[0]->ToString());
+    obj->handle()->Set(Nan::New(connected_symbol), Nan::False());
 
-    NanReturnValue(args.Holder());
+    info.GetReturnValue().Set(info.Holder());
 }
 
 NAN_METHOD(CardReader::GetStatus) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
-    CardReader* obj = ObjectWrap::Unwrap<CardReader>(args.This());
-    Local<Function> cb = Local<Function>::Cast(args[0]);
+    CardReader* obj = Nan::ObjectWrap::Unwrap<CardReader>(info.This());
+    Local<Function> cb = Local<Function>::Cast(info[0]);
 
     AsyncBaton *async_baton = new AsyncBaton();
     async_baton->async.data = async_baton;
-    NanAssignPersistent(async_baton->callback, cb);
+    async_baton->callback.Reset(cb);
     async_baton->reader = obj;
 
     uv_async_init(uv_default_loop(), &async_baton->async, (uv_async_cb)HandleReaderStatusChange);
     int ret = uv_thread_create(&obj->m_status_thread, HandlerFunction, async_baton);
     assert(ret == 0);
 
-    NanReturnUndefined();
+
 }
 
 NAN_METHOD(CardReader::Connect) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
     // The second argument is the length of the data to be received
-    if (!args[0]->IsUint32()) {
-        return NanThrowError("First argument must be an integer");
+    if (!info[0]->IsUint32()) {
+        return Nan::ThrowError("First argument must be an integer");
     }
 
-    if (!args[1]->IsUint32()) {
-        return NanThrowError("Second argument must be an integer");
+    if (!info[1]->IsUint32()) {
+        return Nan::ThrowError("Second argument must be an integer");
     }
 
-    if (!args[2]->IsFunction()) {
-        return NanThrowError("Third argument must be a callback function");
+    if (!info[2]->IsFunction()) {
+        return Nan::ThrowError("Third argument must be a callback function");
     }
 
     ConnectInput* ci = new ConnectInput();
-    ci->share_mode = args[0]->Uint32Value();
-    ci->pref_protocol = args[1]->Uint32Value();
-    Local<Function> cb = Local<Function>::Cast(args[2]);
+    ci->share_mode = info[0]->Uint32Value();
+    ci->pref_protocol = info[1]->Uint32Value();
+    Local<Function> cb = Local<Function>::Cast(info[2]);
 
     // This creates our work request, including the libuv struct.
     Baton* baton = new Baton();
     baton->request.data = baton;
-    NanAssignPersistent(baton->callback, cb);
-    baton->reader = ObjectWrap::Unwrap<CardReader>(args.This());
+    baton->callback.Reset(cb);
+    baton->reader = Nan::ObjectWrap::Unwrap<CardReader>(info.This());
     baton->input = ci;
 
     // Schedule our work request with libuv. Here you can specify the functions
@@ -149,30 +149,30 @@ NAN_METHOD(CardReader::Connect) {
                                reinterpret_cast<uv_after_work_cb>(AfterConnect));
     assert(status == 0);
 
-    NanReturnUndefined();
+
 }
 
 NAN_METHOD(CardReader::Disconnect) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
-    if (!args[0]->IsUint32()) {
-        return NanThrowError("First argument must be an integer");
+    if (!info[0]->IsUint32()) {
+        return Nan::ThrowError("First argument must be an integer");
     }
 
-    if (!args[1]->IsFunction()) {
-        return NanThrowError("Second argument must be a callback function");
+    if (!info[1]->IsFunction()) {
+        return Nan::ThrowError("Second argument must be a callback function");
     }
 
-    DWORD disposition = args[0]->Uint32Value();
-    Local<Function> cb = Local<Function>::Cast(args[1]);
+    DWORD disposition = info[0]->Uint32Value();
+    Local<Function> cb = Local<Function>::Cast(info[1]);
 
     // This creates our work request, including the libuv struct.
     Baton* baton = new Baton();
     baton->input = reinterpret_cast<void*>(new DWORD(disposition));
     baton->request.data = baton;
-    NanAssignPersistent(baton->callback, cb);
-    baton->reader = ObjectWrap::Unwrap<CardReader>(args.This());
+    baton->callback.Reset(cb);
+    baton->reader = Nan::ObjectWrap::Unwrap<CardReader>(info.This());
 
     // Schedule our work request with libuv. Here you can specify the functions
     // that should be executed in the threadpool and back in the main thread
@@ -183,43 +183,43 @@ NAN_METHOD(CardReader::Disconnect) {
                                reinterpret_cast<uv_after_work_cb>(AfterDisconnect));
     assert(status == 0);
 
-    NanReturnUndefined();
+
 }
 
 NAN_METHOD(CardReader::Transmit) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
     // The first argument is the buffer to be transmitted.
-    if (!Buffer::HasInstance(args[0])) {
-        return NanThrowError("First argument must be a Buffer");
+    if (!Buffer::HasInstance(info[0])) {
+        return Nan::ThrowError("First argument must be a Buffer");
     }
 
     // The second argument is the length of the data to be received
-    if (!args[1]->IsUint32()) {
-        return NanThrowError("Second argument must be an integer");
+    if (!info[1]->IsUint32()) {
+        return Nan::ThrowError("Second argument must be an integer");
     }
 
     // The third argument is the protocol to be used
-    if (!args[2]->IsUint32()) {
-        return NanThrowError("Third argument must be an integer");
+    if (!info[2]->IsUint32()) {
+        return Nan::ThrowError("Third argument must be an integer");
     }
 
     // The fourth argument is the callback function
-    if (!args[3]->IsFunction()) {
-        return NanThrowError("Fourth argument must be a callback function");
+    if (!info[3]->IsFunction()) {
+        return Nan::ThrowError("Fourth argument must be a callback function");
     }
 
-    Local<Object> buffer_data = args[0]->ToObject();
-    uint32_t out_len = args[1]->Uint32Value();
-    uint32_t protocol = args[2]->Uint32Value();
-    Local<Function> cb = Local<Function>::Cast(args[3]);
+    Local<Object> buffer_data = info[0]->ToObject();
+    uint32_t out_len = info[1]->Uint32Value();
+    uint32_t protocol = info[2]->Uint32Value();
+    Local<Function> cb = Local<Function>::Cast(info[3]);
 
     // This creates our work request, including the libuv struct.
     Baton* baton = new Baton();
     baton->request.data = baton;
-    NanAssignPersistent(baton->callback, cb);
-    baton->reader = ObjectWrap::Unwrap<CardReader>(args.This());
+    baton->callback.Reset(cb);
+    baton->reader = Nan::ObjectWrap::Unwrap<CardReader>(info.This());
     TransmitInput *ti = new TransmitInput();
     ti->card_protocol = protocol;
     ti->in_data = new unsigned char[Buffer::Length(buffer_data)];
@@ -238,43 +238,43 @@ NAN_METHOD(CardReader::Transmit) {
                                reinterpret_cast<uv_after_work_cb>(AfterTransmit));
     assert(status == 0);
 
-    NanReturnUndefined();
+
 }
 
 NAN_METHOD(CardReader::Control) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
     // The first argument is the buffer to be transmitted.
-    if (!Buffer::HasInstance(args[0])) {
-        return NanThrowError("First argument must be a Buffer");
+    if (!Buffer::HasInstance(info[0])) {
+        return Nan::ThrowError("First argument must be a Buffer");
     }
 
     // The second argument is the control code to be used
-    if (!args[1]->IsUint32()) {
-        return NanThrowError("Second argument must be an integer");
+    if (!info[1]->IsUint32()) {
+        return Nan::ThrowError("Second argument must be an integer");
     }
 
     // The third argument is output buffer
-    if (!Buffer::HasInstance(args[2])) {
-        return NanThrowError("Third argument must be a Buffer");
+    if (!Buffer::HasInstance(info[2])) {
+        return Nan::ThrowError("Third argument must be a Buffer");
     }
 
     // The fourth argument is the callback function
-    if (!args[3]->IsFunction()) {
-        return NanThrowError("Fourth argument must be a callback function");
+    if (!info[3]->IsFunction()) {
+        return Nan::ThrowError("Fourth argument must be a callback function");
     }
 
-    Local<Object> in_buf = args[0]->ToObject();
-    DWORD control_code = args[1]->Uint32Value();
-    Local<Object> out_buf = args[2]->ToObject();
-    Local<Function> cb = Local<Function>::Cast(args[3]);
+    Local<Object> in_buf = info[0]->ToObject();
+    DWORD control_code = info[1]->Uint32Value();
+    Local<Object> out_buf = info[2]->ToObject();
+    Local<Function> cb = Local<Function>::Cast(info[3]);
 
     // This creates our work request, including the libuv struct.
     Baton* baton = new Baton();
     baton->request.data = baton;
-    NanAssignPersistent(baton->callback, cb);
-    baton->reader = ObjectWrap::Unwrap<CardReader>(args.This());
+    baton->callback.Reset(cb);
+    baton->reader = Nan::ObjectWrap::Unwrap<CardReader>(info.This());
     ControlInput *ci = new ControlInput();
     ci->control_code = control_code;
     ci->in_data = Buffer::Data(in_buf);
@@ -292,15 +292,15 @@ NAN_METHOD(CardReader::Control) {
                                reinterpret_cast<uv_after_work_cb>(AfterControl));
     assert(status == 0);
 
-    NanReturnUndefined();
+
 }
 
 NAN_METHOD(CardReader::Close) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
     LONG result = SCARD_S_SUCCESS;
-    CardReader* obj = ObjectWrap::Unwrap<CardReader>(args.This());
+    CardReader* obj = Nan::ObjectWrap::Unwrap<CardReader>(info.This());
 
     uv_mutex_lock(&obj->m_mutex);
     if (obj->m_state == 0) {
@@ -317,12 +317,12 @@ NAN_METHOD(CardReader::Close) {
     assert(uv_thread_join(&obj->m_status_thread) == 0);
     obj->m_status_thread = 0;
 
-    NanReturnValue(NanNew<Number>(result));
+    info.GetReturnValue().Set(Nan::New<Number>(result));
 }
 
 void CardReader::HandleReaderStatusChange(uv_async_t *handle, int status) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
     AsyncBaton* async_baton = static_cast<AsyncBaton*>(handle->data);
     AsyncResult* ar = async_baton->async_result;
@@ -331,29 +331,29 @@ void CardReader::HandleReaderStatusChange(uv_async_t *handle, int status) {
         uv_close(reinterpret_cast<uv_handle_t*>(&async_baton->async), CloseCallback); // necessary otherwise UV will block
 
         /* Emit end event */
-        Handle<Value> argv[1] = {
-            NanNew("_end"), // event name
+        Local<Value> argv[1] = {
+            Nan::New("_end").ToLocalChecked(), // event name
         };
 
-        NanMakeCallback(NanObjectWrapHandle(async_baton->reader), "emit", 1, argv);
+        Nan::MakeCallback(async_baton->reader->handle(), "emit", 1, argv);
         return;
     }
 
     if (ar->result == SCARD_S_SUCCESS) {
         const unsigned argc = 3;
-        Handle<Value> argv[argc] = {
-            NanUndefined(), // argument
-            NanNew<Number>(ar->status),
-            NanNewBufferHandle(reinterpret_cast<char*>(ar->atr), ar->atrlen)
+        Local<Value> argv[argc] = {
+            Nan::Undefined(), // argument
+            Nan::New<Number>(ar->status),
+            Nan::NewBuffer(reinterpret_cast<char*>(ar->atr), ar->atrlen).ToLocalChecked()
         };
 
-        NanCallback(NanNew(async_baton->callback)).Call(argc, argv);
+        Nan::Callback(Nan::New(async_baton->callback)).Call(argc, argv);
     } else {
-        Local<Value> err = NanError(error_msg("SCardGetStatusChange", ar->result).c_str());
+        Local<Value> err = Nan::Error(error_msg("SCardGetStatusChange", ar->result).c_str());
         // Prepare the parameters for the callback function.
         const unsigned argc = 1;
-        Handle<Value> argv[argc] = { err };
-        NanCallback(NanNew(async_baton->callback)).Call(argc, argv);
+        Local<Value> argv[argc] = { err };
+        Nan::Callback(Nan::New(async_baton->callback)).Call(argc, argv);
     }
 }
 
@@ -442,30 +442,30 @@ void CardReader::DoConnect(uv_work_t* req) {
 
 void CardReader::AfterConnect(uv_work_t* req, int status) {
 
-    NanScope();
+    Nan::HandleScope scope;
     Baton* baton = static_cast<Baton*>(req->data);
     ConnectInput *ci = static_cast<ConnectInput*>(baton->input);
     ConnectResult *cr = static_cast<ConnectResult*>(baton->result);
 
     if (cr->result) {
-        Local<Value> err = NanError(error_msg("SCardConnect", cr->result).c_str());
+        Local<Value> err = Nan::Error(error_msg("SCardConnect", cr->result).c_str());
         // Prepare the parameters for the callback function.
         const unsigned argc = 1;
-        Handle<Value> argv[argc] = { err };
-        NanCallback(NanNew(baton->callback)).Call(argc, argv);
+        Local<Value> argv[argc] = { err };
+        Nan::Callback(Nan::New(baton->callback)).Call(argc, argv);
     } else {
-        NanObjectWrapHandle(baton->reader)->Set(NanNew(connected_symbol), NanTrue());
+        baton->reader->handle()->Set(Nan::New(connected_symbol), Nan::True());
         const unsigned argc = 2;
-        Handle<Value> argv[argc] = {
-            NanNull(),
-            NanNew<Number>(cr->card_protocol)
+        Local<Value> argv[argc] = {
+            Nan::Null(),
+            Nan::New<Number>(cr->card_protocol)
         };
 
-        NanCallback(NanNew(baton->callback)).Call(argc, argv);
+        Nan::Callback(Nan::New(baton->callback)).Call(argc, argv);
     }
 
     // The callback is a permanent handle, so we have to dispose of it manually.
-    NanDisposePersistent(baton->callback);
+    baton->callback.Reset();
     delete ci;
     delete cr;
     delete baton;
@@ -497,29 +497,29 @@ void CardReader::DoDisconnect(uv_work_t* req) {
 
 void CardReader::AfterDisconnect(uv_work_t* req, int status) {
 
-    NanScope();
+    Nan::HandleScope scope;
     Baton* baton = static_cast<Baton*>(req->data);
     LONG* result = reinterpret_cast<LONG*>(baton->result);
 
     if (*result) {
-        Local<Value> err = NanError(error_msg("SCardDisconnect", *result).c_str());
+        Local<Value> err = Nan::Error(error_msg("SCardDisconnect", *result).c_str());
 
         // Prepare the parameters for the callback function.
         const unsigned argc = 1;
-        Handle<Value> argv[argc] = { err };
-        NanCallback(NanNew(baton->callback)).Call(argc, argv);
+        Local<Value> argv[argc] = { err };
+        Nan::Callback(Nan::New(baton->callback)).Call(argc, argv);
     } else {
-        NanObjectWrapHandle(baton->reader)->Set(NanNew(connected_symbol), NanFalse());
+        baton->reader->handle()->Set(Nan::New(connected_symbol), Nan::False());
         const unsigned argc = 1;
-        Handle<Value> argv[argc] = {
-            NanNull()
+        Local<Value> argv[argc] = {
+            Nan::Null()
         };
 
-        NanCallback(NanNew(baton->callback)).Call(argc, argv);
+        Nan::Callback(Nan::New(baton->callback)).Call(argc, argv);
     }
 
     // The callback is a permanent handle, so we have to dispose of it manually.
-    NanDisposePersistent(baton->callback);
+    baton->callback.Reset();
     DWORD* disposition = reinterpret_cast<DWORD*>(baton->input);
     delete disposition;
     delete result;
@@ -557,31 +557,31 @@ void CardReader::DoTransmit(uv_work_t* req) {
 
 void CardReader::AfterTransmit(uv_work_t* req, int status) {
 
-    NanScope();
+    Nan::HandleScope scope;
     Baton* baton = static_cast<Baton*>(req->data);
     TransmitInput *ti = static_cast<TransmitInput*>(baton->input);
     TransmitResult *tr = static_cast<TransmitResult*>(baton->result);
 
     if (tr->result) {
-        Local<Value> err = NanError(error_msg("SCardTransmit", tr->result).c_str());
+        Local<Value> err = Nan::Error(error_msg("SCardTransmit", tr->result).c_str());
 
         // Prepare the parameters for the callback function.
         const unsigned argc = 1;
-        Handle<Value> argv[argc] = { err };
-        NanCallback(NanNew(baton->callback)).Call(argc, argv);
+        Local<Value> argv[argc] = { err };
+        Nan::Callback(Nan::New(baton->callback)).Call(argc, argv);
     } else {
         const unsigned argc = 2;
-        Handle<Value> argv[argc] = {
-            NanNull(),
-            NanNewBufferHandle(reinterpret_cast<char*>(tr->data), tr->len)
+        Local<Value> argv[argc] = {
+            Nan::Null(),
+            Nan::NewBuffer(reinterpret_cast<char*>(tr->data), tr->len).ToLocalChecked()
         };
 
-        NanCallback(NanNew(baton->callback)).Call(argc, argv);
+        Nan::Callback(Nan::New(baton->callback)).Call(argc, argv);
     }
 
 
     // The callback is a permanent handle, so we have to dispose of it manually.
-    NanDisposePersistent(baton->callback);
+    baton->callback.Reset();
     delete [] ti->in_data;
     delete ti;
     delete [] tr->data;
@@ -621,31 +621,31 @@ void CardReader::DoControl(uv_work_t* req) {
 
 void CardReader::AfterControl(uv_work_t* req, int status) {
 
-    NanScope();
+    Nan::HandleScope scope;
     Baton* baton = static_cast<Baton*>(req->data);
     ControlInput *ci = static_cast<ControlInput*>(baton->input);
     ControlResult *cr = static_cast<ControlResult*>(baton->result);
 
     if (cr->result) {
-        Local<Value> err = NanError(error_msg("SCardControl", cr->result).c_str());
+        Local<Value> err = Nan::Error(error_msg("SCardControl", cr->result).c_str());
 
         // Prepare the parameters for the callback function.
         const unsigned argc = 1;
-        Handle<Value> argv[argc] = { err };
-        NanCallback(NanNew(baton->callback)).Call(argc, argv);
+        Local<Value> argv[argc] = { err };
+        Nan::Callback(Nan::New(baton->callback)).Call(argc, argv);
     } else {
         const unsigned argc = 2;
-        Handle<Value> argv[argc] = {
-            NanNull(),
-            NanNew<Number>(cr->len)
+        Local<Value> argv[argc] = {
+            Nan::Null(),
+            Nan::New<Number>(cr->len)
         };
 
-        NanCallback(NanNew(baton->callback)).Call(argc, argv);
+        Nan::Callback(Nan::New(baton->callback)).Call(argc, argv);
     }
 
 
     // The callback is a permanent handle, so we have to dispose of it manually.
-    NanDisposePersistent(baton->callback);
+    baton->callback.Reset();
     delete ci;
     delete cr;
     delete baton;
@@ -657,7 +657,7 @@ void CardReader::CloseCallback(uv_handle_t *handle) {
     AsyncBaton* async_baton = static_cast<AsyncBaton*>(handle->data);
     AsyncResult* ar = async_baton->async_result;
     delete ar;
-    NanDisposePersistent(async_baton->callback);
+    async_baton->callback.Reset();
     SCardReleaseContext(async_baton->reader->m_status_card_context);
     delete async_baton;
 }
diff --git a/src/cardreader.h b/src/cardreader.h
index 77524dc..4677d0d 100644
--- a/src/cardreader.h
+++ b/src/cardreader.h
@@ -15,15 +15,15 @@
 #define MAX_ATR_SIZE 33
 #endif
 
-static v8::Persistent<v8::String> name_symbol;
-static v8::Persistent<v8::String> connected_symbol;
+static Nan::Persistent<v8::String> name_symbol;
+static Nan::Persistent<v8::String> connected_symbol;
 
-class CardReader: public node::ObjectWrap {
+class CardReader: public Nan::ObjectWrap {
 
     // We use a struct to store information about the asynchronous "work request".
     struct Baton {
         uv_work_t request;
-        v8::Persistent<v8::Function> callback;
+        Nan::Persistent<v8::Function> callback;
         CardReader *reader;
         void *input;
         void *result;
@@ -75,7 +75,7 @@ class CardReader: public node::ObjectWrap {
 
     struct AsyncBaton {
         uv_async_t async;
-        v8::Persistent<v8::Function> callback;
+        Nan::Persistent<v8::Function> callback;
         CardReader *reader;
         AsyncResult *async_result;
     };
@@ -92,7 +92,7 @@ class CardReader: public node::ObjectWrap {
 
         ~CardReader();
 
-        static v8::Persistent<v8::Function> constructor;
+        static Nan::Persistent<v8::Function> constructor;
 
         static NAN_METHOD(New);
         static NAN_METHOD(GetStatus);
diff --git a/src/pcsclite.cpp b/src/pcsclite.cpp
index 3a19d1b..e77bd85 100644
--- a/src/pcsclite.cpp
+++ b/src/pcsclite.cpp
@@ -4,20 +4,20 @@
 using namespace v8;
 using namespace node;
 
-Persistent<Function> PCSCLite::constructor;
+Nan::Persistent<Function> PCSCLite::constructor;
 
 void PCSCLite::init(Handle<Object> target) {
 
     // Prepare constructor template
-    Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New);
-    tpl->SetClassName(NanNew("PCSCLite"));
+    Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+    tpl->SetClassName(Nan::New("PCSCLite").ToLocalChecked());
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
     // Prototype
-    NanSetPrototypeTemplate(tpl, "start", NanNew<FunctionTemplate>(Start));
-    NanSetPrototypeTemplate(tpl, "close", NanNew<FunctionTemplate>(Close));
+    Nan::SetPrototypeTemplate(tpl, "start", Nan::New<FunctionTemplate>(Start));
+    Nan::SetPrototypeTemplate(tpl, "close", Nan::New<FunctionTemplate>(Close));
 
-    NanAssignPersistent<Function>(constructor, tpl->GetFunction());
-    target->Set(NanNew("PCSCLite"), tpl->GetFunction());
+    constructor.Reset(tpl->GetFunction());
+    target->Set(Nan::New("PCSCLite").ToLocalChecked(), tpl->GetFunction());
 }
 
 PCSCLite::PCSCLite(): m_card_context(0),
@@ -33,7 +33,7 @@ PCSCLite::PCSCLite(): m_card_context(0),
                                         NULL,
                                         &m_card_context);
     if (result != SCARD_S_SUCCESS) {
-        NanThrowError(error_msg("SCardEstablishContext", result).c_str());
+        Nan::ThrowError(error_msg("SCardEstablishContext", result).c_str());
     } else {
         m_card_reader_state.szReader = "\\\\?PnP?\\Notification";
         m_card_reader_state.dwCurrentState = SCARD_STATE_UNAWARE;
@@ -43,7 +43,7 @@ PCSCLite::PCSCLite(): m_card_context(0),
                                       1);
 
         if ((result != SCARD_S_SUCCESS) && (result != SCARD_E_TIMEOUT)) {
-            NanThrowError(error_msg("SCardGetStatusChange", result).c_str());
+            Nan::ThrowError(error_msg("SCardGetStatusChange", result).c_str());
         } else {
             m_pnp = !(m_card_reader_state.dwEventState & SCARD_STATE_UNKNOWN);
         }
@@ -63,36 +63,36 @@ PCSCLite::~PCSCLite() {
 }
 
 NAN_METHOD(PCSCLite::New) {
-    NanScope();
+    Nan::HandleScope scope;
     PCSCLite* obj = new PCSCLite();
-    obj->Wrap(args.Holder());
-    NanReturnValue(args.Holder());
+    obj->Wrap(info.Holder());
+    info.GetReturnValue().Set(info.Holder());
 }
 
 NAN_METHOD(PCSCLite::Start) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
-    PCSCLite* obj = ObjectWrap::Unwrap<PCSCLite>(args.This());
-    Local<Function> cb = Local<Function>::Cast(args[0]);
+    PCSCLite* obj = Nan::ObjectWrap::Unwrap<PCSCLite>(info.This());
+    Local<Function> cb = Local<Function>::Cast(info[0]);
 
     AsyncBaton *async_baton = new AsyncBaton();
     async_baton->async.data = async_baton;
-    NanAssignPersistent(async_baton->callback, cb);
+    async_baton->callback.Reset(cb);
     async_baton->pcsclite = obj;
 
     uv_async_init(uv_default_loop(), &async_baton->async, (uv_async_cb)HandleReaderStatusChange);
     int ret = uv_thread_create(&obj->m_status_thread, HandlerFunction, async_baton);
     assert(ret == 0);
 
-    NanReturnUndefined();
+
 }
 
 NAN_METHOD(PCSCLite::Close) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
-    PCSCLite* obj = ObjectWrap::Unwrap<PCSCLite>(args.This());
+    PCSCLite* obj = Nan::ObjectWrap::Unwrap<PCSCLite>(info.This());
 
     LONG result = SCARD_S_SUCCESS;
     if (obj->m_pnp) {
@@ -114,12 +114,12 @@ NAN_METHOD(PCSCLite::Close) {
     assert(uv_thread_join(&obj->m_status_thread) == 0);
     obj->m_status_thread = 0;
 
-    NanReturnValue(NanNew<Number>(result));
+    info.GetReturnValue().Set(Nan::New<Number>(result));
 }
 
 void PCSCLite::HandleReaderStatusChange(uv_async_t *handle, int status) {
 
-    NanScope();
+    Nan::HandleScope scope;
 
     AsyncBaton* async_baton = static_cast<AsyncBaton*>(handle->data);
     AsyncResult* ar = async_baton->async_result;
@@ -131,18 +131,18 @@ void PCSCLite::HandleReaderStatusChange(uv_async_t *handle, int status) {
 
     if ((ar->result == SCARD_S_SUCCESS) || (ar->result == (LONG)SCARD_E_NO_READERS_AVAILABLE)) {
         const unsigned argc = 2;
-        Handle<Value> argv[argc] = {
-            NanUndefined(), // argument
-            NanNewBufferHandle(ar->readers_name, ar->readers_name_length)
+        Local<Value> argv[argc] = {
+            Nan::Undefined(), // argument
+            Nan::NewBuffer(ar->readers_name, ar->readers_name_length).ToLocalChecked()
         };
 
-        NanCallback(NanNew(async_baton->callback)).Call(argc, argv);
+        Nan::Callback(Nan::New(async_baton->callback)).Call(argc, argv);
     } else {
-        Local<Value> err = NanError(error_msg("SCardListReaders", ar->result).c_str());
+        Local<Value> err = Nan::Error(error_msg("SCardListReaders", ar->result).c_str());
         // Prepare the parameters for the callback function.
         const unsigned argc = 1;
-        Handle<Value> argv[argc] = { err };
-        NanCallback(NanNew(async_baton->callback)).Call(argc, argv);
+        Local<Value> argv[argc] = { err };
+        Nan::Callback(Nan::New(async_baton->callback)).Call(argc, argv);
     }
 
     /* reset AsyncResult */
@@ -207,7 +207,7 @@ void PCSCLite::CloseCallback(uv_handle_t *handle) {
     AsyncResult* ar = async_baton->async_result;
     delete [] ar->readers_name;
     delete ar;
-    NanDisposePersistent(async_baton->callback);
+    async_baton->callback.Reset();
     delete async_baton;
 }
 
diff --git a/src/pcsclite.h b/src/pcsclite.h
index 267d423..7ef962b 100644
--- a/src/pcsclite.h
+++ b/src/pcsclite.h
@@ -9,7 +9,7 @@
 #include <winscard.h>
 #endif
 
-class PCSCLite: public node::ObjectWrap {
+class PCSCLite: public Nan::ObjectWrap {
 
     struct AsyncResult {
         LONG result;
@@ -20,7 +20,7 @@ class PCSCLite: public node::ObjectWrap {
 
     struct AsyncBaton {
         uv_async_t async;
-        v8::Persistent<v8::Function> callback;
+        Nan::Persistent<v8::Function> callback;
         PCSCLite *pcsclite;
         AsyncResult *async_result;
     };
@@ -35,7 +35,7 @@ class PCSCLite: public node::ObjectWrap {
 
         ~PCSCLite();
 
-        static v8::Persistent<v8::Function> constructor;
+        static Nan::Persistent<v8::Function> constructor;
         static NAN_METHOD(New);
         static NAN_METHOD(Start);
         static NAN_METHOD(Close);