diff --git a/.travis.yml b/.travis.yml
index 0bbc3aa9a..b60d95bae 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,7 @@
 env:
   matrix:
     - export NODE_VERSION="0.12"
-    - export NODE_VERSION="iojs-v2.5.0"
+    - export NODE_VERSION="4.0"
 matrix:
   fast_finish: true
 before_install:
diff --git a/appveyor.yml b/appveyor.yml
index 17a3dcb38..d47e25e9e 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -26,13 +26,10 @@ environment:
     # Node.js
     - nodejs_version: "0.12"
     # io.js
-    - nodejs_version: "2"
+    - nodejs_version: "3"
 
 matrix:
   fast_finish: true
-  allow_failures:
-    - nodejs_version: "0.10"
-    - nodejs_version: "2"
 
 # Get the latest stable version of Node 0.STABLE.latest
 install:
diff --git a/generate/templates/manual/include/callback_wrapper.h b/generate/templates/manual/include/callback_wrapper.h
index e02182f09..41552de3e 100644
--- a/generate/templates/manual/include/callback_wrapper.h
+++ b/generate/templates/manual/include/callback_wrapper.h
@@ -10,7 +10,7 @@ using namespace v8;
 using namespace node;
 
 struct CallbackWrapper {
-  NanCallback* jsCallback;
+  Nan::Callback* jsCallback;
   void * payload;
 };
 
diff --git a/generate/templates/manual/include/git_buf_converter.h b/generate/templates/manual/include/git_buf_converter.h
index ca2a502d8..e2ea08bba 100644
--- a/generate/templates/manual/include/git_buf_converter.h
+++ b/generate/templates/manual/include/git_buf_converter.h
@@ -10,7 +10,7 @@ using namespace v8;
 
 class StrArrayConverter {
   public:
-    static git_strarray *Convert (Handle<v8::Value> val);
+    static git_strarray *Convert (Local<v8::Value> val);
 };
 
 #endif
diff --git a/generate/templates/manual/include/macros.h b/generate/templates/manual/include/macros.h
deleted file mode 100644
index 80e63ab04..000000000
--- a/generate/templates/manual/include/macros.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef NODEGIT_PSUEDONAN_H_
-#if (NODE_MODULE_VERSION > 0x000B)
-// Node 0.11+ (0.11.3 and below won't compile with these)
-# define NodeGitPsueodoNanReturnEscapingValue(val) NanReturnValue(NanEscapeScope(val))
-
-#else
-// Node 0.8 and 0.10
-# define NodeGitPsueodoNanReturnEscapingValue(val) NanReturnValue(val)
-
-#endif
-
-#endif //NODEGIT_PSUEDONAN_H_
diff --git a/generate/templates/manual/include/str_array_converter.h b/generate/templates/manual/include/str_array_converter.h
index c0df65fc9..c3509f128 100644
--- a/generate/templates/manual/include/str_array_converter.h
+++ b/generate/templates/manual/include/str_array_converter.h
@@ -11,11 +11,11 @@ using namespace v8;
 class StrArrayConverter {
   public:
 
-    static git_strarray *Convert (Handle<v8::Value> val);
+    static git_strarray *Convert (Local<v8::Value> val);
 
   private:
     static git_strarray *ConvertArray(Array *val);
-    static git_strarray *ConvertString(Handle<String> val);
+    static git_strarray *ConvertString(Local<String> val);
     static git_strarray *AllocStrArray(const size_t count);
     static git_strarray *ConstructStrArray(int argc, char** argv);
 };
diff --git a/generate/templates/manual/include/wrapper.h b/generate/templates/manual/include/wrapper.h
index f429defbd..cd7c26ff0 100644
--- a/generate/templates/manual/include/wrapper.h
+++ b/generate/templates/manual/include/wrapper.h
@@ -13,14 +13,14 @@
 using namespace node;
 using namespace v8;
 
-class Wrapper : public ObjectWrap {
+class Wrapper : public Nan::ObjectWrap {
   public:
 
-    static Persistent<FunctionTemplate> constructor_template;
-    static void InitializeComponent (Handle<v8::Object> target);
+    static Nan::Persistent<FunctionTemplate> constructor_template;
+    static void InitializeComponent (Local<v8::Object> target);
 
     void *GetValue();
-    static Handle<v8::Value> New(void *raw);
+    static Local<v8::Value> New(void *raw);
 
   private:
     Wrapper(void *raw);
diff --git a/generate/templates/manual/src/git_buf_converter.cc b/generate/templates/manual/src/git_buf_converter.cc
index 7ab25a6b5..371f14336 100644
--- a/generate/templates/manual/src/git_buf_converter.cc
+++ b/generate/templates/manual/src/git_buf_converter.cc
@@ -9,7 +9,7 @@
 using namespace v8;
 using namespace node;
 
-git_buf *StrArrayConverter::Convert(Handle<v8::Value> val) {
+git_buf *StrArrayConverter::Convert(Local<v8::Value> val) {
   if (val->IsString() || val->IsStringObject()) {
     string v8String = ConvertString(val->ToString());
     const size_t size = sizeof(git_buf);
diff --git a/generate/templates/manual/src/str_array_converter.cc b/generate/templates/manual/src/str_array_converter.cc
index bea3a2e31..c66f901c3 100644
--- a/generate/templates/manual/src/str_array_converter.cc
+++ b/generate/templates/manual/src/str_array_converter.cc
@@ -9,7 +9,7 @@
 using namespace v8;
 using namespace node;
 
-git_strarray *StrArrayConverter::Convert(Handle<v8::Value> val) {
+git_strarray *StrArrayConverter::Convert(Local<v8::Value> val) {
   if (!val->BooleanValue()) {
     return NULL;
   }
@@ -37,16 +37,16 @@ git_strarray *StrArrayConverter::ConvertArray(Array *val) {
   git_strarray *result = AllocStrArray(val->Length());
 
   for(size_t i = 0; i < result->count; i++) {
-    NanUtf8String entry(val->Get(i));
+    Nan::Utf8String entry(val->Get(i));
     result->strings[i] = strdup(*entry);
   }
 
   return result;
 }
 
-git_strarray* StrArrayConverter::ConvertString(Handle<String> val) {
+git_strarray* StrArrayConverter::ConvertString(Local<String> val) {
   char *strings[1];
-  NanUtf8String utf8String(val);
+  Nan::Utf8String utf8String(val);
 
   strings[0] = *utf8String;
 
diff --git a/generate/templates/manual/src/wrapper.cc b/generate/templates/manual/src/wrapper.cc
index 8966bb6fa..0bcc9a745 100644
--- a/generate/templates/manual/src/wrapper.cc
+++ b/generate/templates/manual/src/wrapper.cc
@@ -16,42 +16,41 @@ Wrapper::Wrapper(void *raw) {
   this->raw = raw;
 }
 
-void Wrapper::InitializeComponent(Handle<v8::Object> target) {
-  NanScope();
+void Wrapper::InitializeComponent(Local<v8::Object> target) {
+  Nan::HandleScope scope;
 
-  Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(JSNewFunction);
+  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
 
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
-  tpl->SetClassName(NanNew<String>("Wrapper"));
+  tpl->SetClassName(Nan::New("Wrapper").ToLocalChecked());
 
-  NODE_SET_PROTOTYPE_METHOD(tpl, "toBuffer", ToBuffer);
+  Nan::SetPrototypeMethod(tpl, "toBuffer", ToBuffer);
 
-  NanAssignPersistent(constructor_template, tpl);
-  target->Set(NanNew<String>("Wrapper"), tpl->GetFunction());
+  constructor_template.Reset(tpl);
+  Nan::Set(target, Nan::New("Wrapper").ToLocalChecked(), Nan::GetFunction(tpl).ToLocalChecked());
 }
 
 NAN_METHOD(Wrapper::JSNewFunction) {
-  NanScope();
 
-  if (args.Length() == 0 || !args[0]->IsExternal()) {
-    return NanThrowError("void * is required.");
+  if (info.Length() == 0 || !info[0]->IsExternal()) {
+    return Nan::ThrowError("void * is required.");
   }
 
-  Wrapper* object = new Wrapper(External::Cast(*args[0])->Value());
-  object->Wrap(args.This());
+  Wrapper* object = new Wrapper(External::Cast(*info[0])->Value());
+  object->Wrap(info.This());
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
-Handle<v8::Value> Wrapper::New(void *raw) {
-  NanEscapableScope();
+Local<v8::Value> Wrapper::New(void *raw) {
+  Nan::EscapableHandleScope scope;
 
-  Handle<v8::Value> argv[1] = { NanNew<External>((void *)raw) };
+  Local<v8::Value> argv[1] = { Nan::New<External>((void *)raw) };
   Local<Object> instance;
-  Local<FunctionTemplate> constructorHandle = NanNew(constructor_template);
-  instance = constructorHandle->GetFunction()->NewInstance(1, argv);
+  Local<FunctionTemplate> constructorHandle = Nan::New(constructor_template);
+  instance = Nan::NewInstance(Nan::GetFunction(constructorHandle).ToLocalChecked(), 1, argv).ToLocalChecked();
 
-  return NanEscapeScope(instance);
+  return scope.Escape(instance);
 }
 
 void *Wrapper::GetValue() {
@@ -59,24 +58,23 @@ void *Wrapper::GetValue() {
 }
 
 NAN_METHOD(Wrapper::ToBuffer) {
-  NanScope();
 
-  if(args.Length() == 0 || !args[0]->IsNumber()) {
-    return NanThrowError("Number is required.");
+  if(info.Length() == 0 || !info[0]->IsNumber()) {
+    return Nan::ThrowError("Number is required.");
   }
 
-  int len = args[0]->ToNumber()->Value();
+  int len = info[0]->ToNumber()->Value();
 
   Local<Function> bufferConstructor = Local<Function>::Cast(
-    NanGetCurrentContext()->Global()->Get(NanNew<String>("Buffer")));
+    Nan::Get(Nan::GetCurrentContext()->Global(), Nan::New("Buffer").ToLocalChecked()).ToLocalChecked());
 
-  Handle<v8::Value> constructorArgs[1] = { NanNew<Integer>(len) };
-  Local<Object> nodeBuffer = bufferConstructor->NewInstance(1, constructorArgs);
+  Local<v8::Value> constructorArgs[1] = { Nan::New(len) };
+  Local<Object> nodeBuffer = Nan::NewInstance(bufferConstructor, 1, constructorArgs).ToLocalChecked();
 
-  std::memcpy(node::Buffer::Data(nodeBuffer), ObjectWrap::Unwrap<Wrapper>(args.This())->GetValue(), len);
+  std::memcpy(node::Buffer::Data(nodeBuffer), Nan::ObjectWrap::Unwrap<Wrapper>(info.This())->GetValue(), len);
 
-  NanReturnValue(nodeBuffer);
+  info.GetReturnValue().Set(nodeBuffer);
 }
 
 
-Persistent<FunctionTemplate> Wrapper::constructor_template;
+Nan::Persistent<FunctionTemplate> Wrapper::constructor_template;
diff --git a/generate/templates/partials/async_function.cc b/generate/templates/partials/async_function.cc
index 503befe85..a754d20d7 100644
--- a/generate/templates/partials/async_function.cc
+++ b/generate/templates/partials/async_function.cc
@@ -1,10 +1,9 @@
 
 {%partial doc .%}
 NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
-  NanScope();
   {%partial guardArguments .%}
-  if (args.Length() == {{args|jsArgsCount}} || !args[{{args|jsArgsCount}}]->IsFunction()) {
-    return NanThrowError("Callback is required and must be a Function.");
+  if (info.Length() == {{args|jsArgsCount}} || !info[{{args|jsArgsCount}}]->IsFunction()) {
+    return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
   {{ cppFunctionName }}Baton* baton = new {{ cppFunctionName }}Baton;
@@ -26,9 +25,9 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
   {%each args|argsInfo as arg %}
     {%if not arg.isReturn %}
       {%if arg.isSelf %}
-  baton->{{ arg.name }} = ObjectWrap::Unwrap<{{ arg.cppClassName }}>(args.This())->GetValue();
+  baton->{{ arg.name }} = Nan::ObjectWrap::Unwrap<{{ arg.cppClassName }}>(info.This())->GetValue();
       {%elsif arg.isCallbackFunction %}
-  if (!args[{{ arg.jsArg }}]->IsFunction()) {
+  if (!info[{{ arg.jsArg }}]->IsFunction()) {
     baton->{{ arg.name }} = NULL;
         {%if arg.payload.globalPayload %}
     globalPayload->{{ arg.name }} = NULL;
@@ -39,9 +38,9 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
   else {
     baton->{{ arg.name}} = {{ cppFunctionName }}_{{ arg.name }}_cppCallback;
         {%if arg.payload.globalPayload %}
-    globalPayload->{{ arg.name }} = new NanCallback(args[{{ arg.jsArg }}].As<Function>());
+    globalPayload->{{ arg.name }} = new Nan::Callback(info[{{ arg.jsArg }}].As<Function>());
         {%else%}
-    baton->{{ arg.payload.name }} = new NanCallback(args[{{ arg.jsArg }}].As<Function>());
+    baton->{{ arg.payload.name }} = new Nan::Callback(info[{{ arg.jsArg }}].As<Function>());
         {%endif%}
   }
       {%elsif arg.payloadFor %}
@@ -53,7 +52,7 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
         {%if not arg.payloadFor %}
   baton->{{ arg.name }} = from_{{ arg.name }};
           {%if arg | isOid %}
-  baton->{{ arg.name }}NeedsFree = args[{{ arg.jsArg }}]->IsString();
+  baton->{{ arg.name }}NeedsFree = info[{{ arg.jsArg }}]->IsString();
           {%endif%}
         {%endif%}
       {%endif%}
@@ -62,21 +61,21 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
     {%endif%}
   {%endeach%}
 
-  NanCallback *callback = new NanCallback(Local<Function>::Cast(args[{{args|jsArgsCount}}]));
+  Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[{{args|jsArgsCount}}]));
   {{ cppFunctionName }}Worker *worker = new {{ cppFunctionName }}Worker(baton, callback);
   {%each args|argsInfo as arg %}
     {%if not arg.isReturn %}
       {%if arg.isSelf %}
-  worker->SaveToPersistent("{{ arg.name }}", args.This());
+  worker->SaveToPersistent("{{ arg.name }}", info.This());
       {%elsif not arg.isCallbackFunction %}
-  if (!args[{{ arg.jsArg }}]->IsUndefined() && !args[{{ arg.jsArg }}]->IsNull())
-    worker->SaveToPersistent("{{ arg.name }}", args[{{ arg.jsArg }}]->ToObject());
+  if (!info[{{ arg.jsArg }}]->IsUndefined() && !info[{{ arg.jsArg }}]->IsNull())
+    worker->SaveToPersistent("{{ arg.name }}", info[{{ arg.jsArg }}]->ToObject());
       {%endif%}
     {%endif%}
   {%endeach%}
 
-  NanAsyncQueueWorker(worker);
-  NanReturnUndefined();
+  Nan::AsyncQueueWorker(worker);
+  return;
 }
 
 void {{ cppClassName }}::{{ cppFunctionName }}Worker::Execute() {
@@ -110,31 +109,31 @@ void {{ cppClassName }}::{{ cppFunctionName }}Worker::Execute() {
 void {{ cppClassName }}::{{ cppFunctionName }}Worker::HandleOKCallback() {
   if (baton->error_code == GIT_OK) {
     {%if not .|returnsCount %}
-    Handle<v8::Value> result = NanUndefined();
+    Local<v8::Value> result = Nan::Undefined();
     {%else%}
-    Handle<v8::Value> to;
+    Local<v8::Value> to;
       {%if .|returnsCount > 1 %}
-    Handle<Object> result = NanNew<Object>();
+    Local<Object> result = Nan::New<Object>();
       {%endif%}
       {%each .|returnsInfo 0 1 as _return %}
         {%partial convertToV8 _return %}
         {%if .|returnsCount > 1 %}
-    result->Set(NanNew<String>("{{ _return.returnNameOrName }}"), to);
+    Nan::Set(result, Nan::New("{{ _return.returnNameOrName }}").ToLocalChecked(), to);
         {%endif%}
       {%endeach%}
       {%if .|returnsCount == 1 %}
-    Handle<v8::Value> result = to;
+    Local<v8::Value> result = to;
       {%endif%}
     {%endif%}
-    Handle<v8::Value> argv[2] = {
-      NanNull(),
+    Local<v8::Value> argv[2] = {
+      Nan::Null(),
       result
     };
     callback->Call(2, argv);
   } else {
     if (baton->error) {
-      Handle<v8::Value> argv[1] = {
-        NanError(baton->error->message)
+      Local<v8::Value> argv[1] = {
+        Nan::Error(baton->error->message)
       };
       callback->Call(1, argv);
       if (baton->error->message)
diff --git a/generate/templates/partials/callback_helpers.cc b/generate/templates/partials/callback_helpers.cc
index 8c1d34651..f5bd75dfa 100644
--- a/generate/templates/partials/callback_helpers.cc
+++ b/generate/templates/partials/callback_helpers.cc
@@ -33,16 +33,16 @@
 }
 
 void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_async(uv_async_t* req, int status) {
-  NanScope();
+  Nan::HandleScope scope;
 
   {{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton* baton = static_cast<{{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton*>(req->data);
 
   {% each cbFunction.args|argsInfo as arg %}
     {% if arg | isPayload %}
       {% if cbFunction.payload.globalPayload %}
-  NanCallback* callback = (({{ cppFunctionName }}_globalPayload*)baton->{{ arg.name }})->{{ cbFunction.name }};
+  Nan::Callback* callback = (({{ cppFunctionName }}_globalPayload*)baton->{{ arg.name }})->{{ cbFunction.name }};
       {% else %}
-  NanCallback* callback = (NanCallback *)baton->{{ arg.name }};
+  Nan::Callback* callback = (Nan::Callback *)baton->{{ arg.name }};
       {% endif %}
     {% endif %}
   {% endeach %}
@@ -52,33 +52,35 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_async(uv_as
       {% if arg | isPayload %}
         {%-- payload is always the last arg --%}
         // payload is null because we can use closure scope in javascript
-        NanUndefined()
+        Nan::Undefined()
       {% elsif arg.isJsArg %}
         {% if arg.isEnum %}
-          NanNew((int)baton->{{ arg.name }}),
+          Nan::New((int)baton->{{ arg.name }}),
         {% elsif arg.isLibgitType %}
-          NanNew({{ arg.cppClassName }}::New((void *)baton->{{ arg.name }}, false)),
+          {{ arg.cppClassName }}::New((void *)baton->{{ arg.name }}, false),
         {% elsif arg.cType == "size_t" %}
-          // HACK: NAN should really have an overload for NanNew to support size_t
-          NanNew((unsigned int)baton->{{ arg.name }}),
+          // HACK: NAN should really have an overload for Nan::New to support size_t
+          Nan::New((unsigned int)baton->{{ arg.name }}),
+        {% elsif arg.cppClassName == 'String' %}
+          Nan::New(baton->{{ arg.name }}).ToLocalChecked(),
         {% else %}
-          NanNew(baton->{{ arg.name }}),
+          Nan::New(baton->{{ arg.name }}),
         {% endif %}
       {% endif %}
     {% endeach %}
   };
 
-  TryCatch tryCatch;
-  Handle<v8::Value> result = callback->Call({{ cbFunction.args|jsArgsCount }}, argv);
+  Nan::TryCatch tryCatch;
+  Local<v8::Value> result = callback->Call({{ cbFunction.args|jsArgsCount }}, argv);
 
-  if (result->IsObject() && result->ToObject()->Has(NanNew("then"))) {
-    Handle<v8::Value> thenProp = result->ToObject()->Get(NanNew("then"));
+  if (result->IsObject() && Nan::Has(result->ToObject(), Nan::New("then").ToLocalChecked()).FromJust()) {
+    Local<v8::Value> thenProp = Nan::Get(result->ToObject(), Nan::New("then").ToLocalChecked()).ToLocalChecked();
 
     if (thenProp->IsFunction()) {
       // we can be reasonbly certain that the result is a promise
       Local<Object> promise = result->ToObject();
 
-      NanAssignPersistent(baton->promise, promise);
+      baton->promise.Reset(promise);
 
       uv_close((uv_handle_t*) &baton->req, NULL);
       uv_async_init(uv_default_loop(), &baton->req, (uv_async_cb) {{ cppFunctionName }}_{{ cbFunction.name }}_asyncPromisePolling);
@@ -93,7 +95,7 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_async(uv_as
     }
     else if (!result->IsNull() && !result->IsUndefined()) {
       {% if _return.isOutParam %}
-      {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
+      {{ _return.cppClassName }}* wrapper = Nan::ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
       wrapper->selfFreeing = false;
 
       baton->{{ _return.name }} = wrapper->GetRefValue();
@@ -117,11 +119,11 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_async(uv_as
 }
 
 void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_asyncPromisePolling(uv_async_t* req, int status) {
-  NanScope();
+  Nan::HandleScope scope;
 
   {{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton* baton = static_cast<{{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton*>(req->data);
-  Local<Object> promise = NanNew<Object>(baton->promise);
-  NanCallback* isPendingFn = new NanCallback(promise->Get(NanNew("isPending")).As<Function>());
+  Local<Object> promise = Nan::New<Object>(baton->promise);
+  Nan::Callback* isPendingFn = new Nan::Callback(Nan::Get(promise, Nan::New("isPending").ToLocalChecked()).ToLocalChecked().As<Function>());
   Local<Value> argv[1]; // MSBUILD won't assign an array of length 0
   Local<Boolean> isPending = isPendingFn->Call(promise, 0, argv)->ToBoolean();
 
@@ -130,12 +132,12 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_asyncPromis
     return;
   }
 
-  NanCallback* isFulfilledFn = new NanCallback(promise->Get(NanNew("isFulfilled")).As<Function>());
+  Nan::Callback* isFulfilledFn = new Nan::Callback(Nan::Get(promise, Nan::New("isFulfilled").ToLocalChecked()).ToLocalChecked().As<Function>());
   Local<Boolean> isFulfilled = isFulfilledFn->Call(promise, 0, argv)->ToBoolean();
 
   if (isFulfilled->Value()) {
-    NanCallback* resultFn = new NanCallback(promise->Get(NanNew("value")).As<Function>());
-    Handle<v8::Value> result = resultFn->Call(promise, 0, argv);
+    Nan::Callback* resultFn = new Nan::Callback(Nan::Get(promise, Nan::New("value").ToLocalChecked()).ToLocalChecked().As<Function>());
+    Local<v8::Value> result = resultFn->Call(promise, 0, argv);
 
     {% each cbFunction|returnsInfo false true as _return %}
       if (result.IsEmpty() || result->IsNativeError()) {
@@ -143,7 +145,7 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_asyncPromis
       }
       else if (!result->IsNull() && !result->IsUndefined()) {
         {% if _return.isOutParam %}
-        {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
+        {{ _return.cppClassName }}* wrapper = Nan::ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
         wrapper->selfFreeing = false;
 
         baton->{{ _return.name }} = wrapper->GetRefValue();
diff --git a/generate/templates/partials/convert_from_v8.cc b/generate/templates/partials/convert_from_v8.cc
index 3d71b6339..fc85edf7d 100644
--- a/generate/templates/partials/convert_from_v8.cc
+++ b/generate/templates/partials/convert_from_v8.cc
@@ -8,57 +8,57 @@
     {% elsif cppClassName == 'GitBuf' %}
     {%-- Print nothing --%}
     {%else%}
-    if (args[{{ jsArg }}]->Is{{ cppClassName|cppToV8 }}()) {
+    if (info[{{ jsArg }}]->Is{{ cppClassName|cppToV8 }}()) {
       {%endif%}
     {%endif%}
   {%if cppClassName == 'String'%}
 
-  String::Utf8Value {{ name }}(args[{{ jsArg }}]->ToString());
+  String::Utf8Value {{ name }}(info[{{ jsArg }}]->ToString());
   from_{{ name }} = ({{ cType }}) strdup(*{{ name }});
   {%elsif cppClassName == 'GitStrarray' %}
 
-  from_{{ name }} = StrArrayConverter::Convert(args[{{ jsArg }}]);
+  from_{{ name }} = StrArrayConverter::Convert(info[{{ jsArg }}]);
   {%elsif  cppClassName == 'GitBuf' %}
 
-  from_{{ name }} = GitBufConverter::Convert(args[{{ jsArg }}]);
+  from_{{ name }} = GitBufConverter::Convert(info[{{ jsArg }}]);
   {%elsif cppClassName == 'Wrapper'%}
 
-  String::Utf8Value {{ name }}(args[{{ jsArg }}]->ToString());
+  String::Utf8Value {{ name }}(info[{{ jsArg }}]->ToString());
   from_{{ name }} = ({{ cType }}) strdup(*{{ name }});
   {%elsif cppClassName == 'Array'%}
 
-  Array *tmp_{{ name }} = Array::Cast(*args[{{ jsArg }}]);
+  Array *tmp_{{ name }} = Array::Cast(*info[{{ jsArg }}]);
   from_{{ name }} = ({{ cType }})malloc(tmp_{{ name }}->Length() * sizeof({{ cType|replace '**' '*' }}));
       for (unsigned int i = 0; i < tmp_{{ name }}->Length(); i++) {
     {%--
       // FIXME: should recursively call convertFromv8.
     --%}
-      from_{{ name }}[i] = ObjectWrap::Unwrap<{{ arrayElementCppClassName }}>(tmp_{{ name }}->Get(NanNew<Number>(static_cast<double>(i)))->ToObject())->GetValue();
+      from_{{ name }}[i] = Nan::ObjectWrap::Unwrap<{{ arrayElementCppClassName }}>(tmp_{{ name }}->Get(Nan::New(static_cast<double>(i)))->ToObject())->GetValue();
       }
   {%elsif cppClassName == 'Function'%}
   {%elsif cppClassName == 'Buffer'%}
 
-  from_{{ name }} = Buffer::Data(args[{{ jsArg }}]->ToObject());
+  from_{{ name }} = Buffer::Data(info[{{ jsArg }}]->ToObject());
   {%elsif cppClassName|isV8Value %}
 
     {%if cType|isPointer %}
-  *from_{{ name }} = ({{ cType|unPointer }}) {{ cast }} {%if isEnum %}(int){%endif%} args[{{ jsArg }}]->To{{ cppClassName }}()->Value();
+  *from_{{ name }} = ({{ cType|unPointer }}) {{ cast }} {%if isEnum %}(int){%endif%} info[{{ jsArg }}]->To{{ cppClassName }}()->Value();
     {%else%}
-  from_{{ name }} = ({{ cType }}) {{ cast }} {%if isEnum %}(int){%endif%} args[{{ jsArg }}]->To{{ cppClassName }}()->Value();
+  from_{{ name }} = ({{ cType }}) {{ cast }} {%if isEnum %}(int){%endif%} info[{{ jsArg }}]->To{{ cppClassName }}()->Value();
     {%endif%}
   {%elsif cppClassName == 'GitOid'%}
-  if (args[{{ jsArg }}]->IsString()) {
+  if (info[{{ jsArg }}]->IsString()) {
     // Try and parse in a string to a git_oid
-    String::Utf8Value oidString(args[{{ jsArg }}]->ToString());
+    String::Utf8Value oidString(info[{{ jsArg }}]->ToString());
     git_oid *oidOut = (git_oid *)malloc(sizeof(git_oid));
 
     if (git_oid_fromstr(oidOut, (const char *) strdup(*oidString)) != GIT_OK) {
       free(oidOut);
 
       if (giterr_last()) {
-        return NanThrowError(giterr_last()->message);
+        return Nan::ThrowError(giterr_last()->message);
       } else {
-        return NanThrowError("Unknown Error");
+        return Nan::ThrowError("Unknown Error");
       }
     }
 
@@ -70,23 +70,23 @@
   }
   else {
     {%if cType|isDoublePointer %}
-    from_{{ name }} = ObjectWrap::Unwrap<{{ cppClassName }}>(args[{{ jsArg }}]->ToObject())->GetRefValue();
+    from_{{ name }} = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info[{{ jsArg }}]->ToObject())->GetRefValue();
     {%else%}
-    from_{{ name }} = ObjectWrap::Unwrap<{{ cppClassName }}>(args[{{ jsArg }}]->ToObject())->GetValue();
+    from_{{ name }} = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info[{{ jsArg }}]->ToObject())->GetValue();
     {%endif%}
   }
   {%else%}
     {%if cType|isDoublePointer %}
-  from_{{ name }} = ObjectWrap::Unwrap<{{ cppClassName }}>(args[{{ jsArg }}]->ToObject())->GetRefValue();
+  from_{{ name }} = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info[{{ jsArg }}]->ToObject())->GetRefValue();
     {%else%}
-  from_{{ name }} = ObjectWrap::Unwrap<{{ cppClassName }}>(args[{{ jsArg }}]->ToObject())->GetValue();
+  from_{{ name }} = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info[{{ jsArg }}]->ToObject())->GetValue();
     {%endif%}
   {%endif%}
 
   {%if isBoolean %}
   }
   else {
-    from_{{ name }} = args[{{ jsArg }}]->IsTrue() ? 1 : 0;
+    from_{{ name }} = info[{{ jsArg }}]->IsTrue() ? 1 : 0;
   }
   {%elsif isOptional %}
     {%if cppClassName != 'GitStrarray'%}
diff --git a/generate/templates/partials/convert_to_v8.cc b/generate/templates/partials/convert_to_v8.cc
index 4d7b848f0..bfe40dde6 100644
--- a/generate/templates/partials/convert_to_v8.cc
+++ b/generate/templates/partials/convert_to_v8.cc
@@ -2,15 +2,15 @@
 {% if cppClassName == 'String' %}
   if ({{= parsedName =}}){
     {% if size %}
-      to = NanNew<String>({{= parsedName =}}, {{ size }});
+      to = Nan::New<String>({{= parsedName =}}, {{ size }}).ToLocalChecked();
     {% elsif cType == 'char **' %}
-      to = NanNew<String>(*{{= parsedName =}});
+      to = Nan::New<String>(*{{= parsedName =}}).ToLocalChecked();
     {% else %}
-      to = NanNew<String>({{= parsedName =}});
+      to = Nan::New<String>({{= parsedName =}}).ToLocalChecked();
     {% endif %}
   }
   else {
-    to = NanNull();
+    to = Nan::Null();
   }
 
   {% if freeFunctionName %}
@@ -20,34 +20,34 @@
 {% elsif cppClassName|isV8Value %}
 
   {% if isCppClassIntType %}
-    to = NanNew<{{ cppClassName }}>(({{ parsedClassName }}){{= parsedName =}});
+    to = Nan::New<{{ cppClassName }}>(({{ parsedClassName }}){{= parsedName =}});
   {% else %}
-    to = NanNew<{{ cppClassName }}>({% if needsDereference %}*{% endif %}{{= parsedName =}});
+    to = Nan::New<{{ cppClassName }}>({% if needsDereference %}*{% endif %}{{= parsedName =}});
   {% endif %}
 
 {% elsif cppClassName == 'External' %}
 
-  to = NanNew<External>((void *){{= parsedName =}});
+  to = Nan::New<External>((void *){{= parsedName =}});
 
 {% elsif cppClassName == 'Array' %}
 
   {%-- // FIXME this is not general purpose enough. --%}
   {% if size %}
-    Local<Array> tmpArray = NanNew<Array>({{= parsedName =}}->{{ size }});
+    Local<Array> tmpArray = Nan::New<Array>({{= parsedName =}}->{{ size }});
     for (unsigned int i = 0; i < {{= parsedName =}}->{{ size }}; i++) {
-      tmpArray->Set(NanNew<Number>(i), NanNew<String>({{= parsedName =}}->{{ key }}[i]));
+      Nan::Set(tmpArray, Nan::New<Number>(i), Nan::New<String>({{= parsedName =}}->{{ key }}[i]).ToLocalChecked());
     }
   {% else %}
-    Local<Array> tmpArray = NanNew<Array>({{= parsedName =}});
+    Local<Array> tmpArray = Nan::New<Array>({{= parsedName =}});
   {% endif %}
 
   to = tmpArray;
 {% elsif cppClassName == 'GitBuf' %}
   if ({{= parsedName =}}) {
-    to = NanNew<String>({{= parsedName =}}->ptr, {{= parsedName = }}->size);
+    to = Nan::New<String>({{= parsedName =}}->ptr, {{= parsedName = }}->size).ToLocalChecked();
   }
   else {
-    to = NanNull();
+    to = Nan::Null();
   }
 {% else %}
   {% if copy %}
@@ -65,7 +65,7 @@
     {% endif %}
   }
   else {
-    to = NanNull();
+    to = Nan::Null();
   }
 
 {% endif %}
diff --git a/generate/templates/partials/field_accessors.cc b/generate/templates/partials/field_accessors.cc
index 9426ea07b..bc8058dcf 100644
--- a/generate/templates/partials/field_accessors.cc
+++ b/generate/templates/partials/field_accessors.cc
@@ -1,49 +1,46 @@
 {% each fields|fieldsInfo as field %}
   {% if not field.ignore %}
     NAN_GETTER({{ cppClassName }}::Get{{ field.cppFunctionName }}) {
-      NanScope();
 
-      {{ cppClassName }} *wrapper = ObjectWrap::Unwrap<{{ cppClassName }}>(args.This());
+      {{ cppClassName }} *wrapper = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This());
 
       {% if field.isEnum %}
-        NanReturnValue(NanNew((int)wrapper->GetValue()->{{ field.name }}));
+        info.GetReturnValue().Set(Nan::New((int)wrapper->GetValue()->{{ field.name }}));
 
       {% elsif field.isLibgitType | or field.payloadFor %}
-        NanReturnValue(NanNew(wrapper->{{ field.name }}));
+        info.GetReturnValue().Set(Nan::New(wrapper->{{ field.name }}));
 
       {% elsif field.isCallbackFunction %}
-        NanReturnValue(wrapper->{{ field.name }}->GetFunction());
+        info.GetReturnValue().Set(wrapper->{{ field.name }}->GetFunction());
 
       {% elsif field.cppClassName == 'String' %}
         if (wrapper->GetValue()->{{ field.name }}) {
-          NanReturnValue(NanNew<String>(wrapper->GetValue()->{{ field.name }}));
+          info.GetReturnValue().Set(Nan::New<String>(wrapper->GetValue()->{{ field.name }}).ToLocalChecked());
         }
         else {
-          NanReturnUndefined();
+          return;
         }
 
       {% elsif field.cppClassName|isV8Value %}
-        NanReturnValue(NanNew<{{ field.cppClassName }}>(wrapper->GetValue()->{{ field.name }}));
+        info.GetReturnValue().Set(Nan::New<{{ field.cppClassName }}>(wrapper->GetValue()->{{ field.name }}));
       {% endif %}
     }
 
     NAN_SETTER({{ cppClassName }}::Set{{ field.cppFunctionName }}) {
-      NanScope();
 
-      {{ cppClassName }} *wrapper = ObjectWrap::Unwrap<{{ cppClassName }}>(args.This());
+      {{ cppClassName }} *wrapper = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This());
 
       {% if field.isEnum %}
         if (value->IsNumber()) {
-          wrapper->GetValue()->{{ field.name }} = ({{ field.cType }}) value->Int32Value();
+          wrapper->GetValue()->{{ field.name }} = ({{ field.cType }}) Nan::To<int32_t>(value).FromJust();
         }
 
       {% elsif field.isLibgitType %}
-        Handle<Object> {{ field.name }}(value->ToObject());
-        NanDisposePersistent(wrapper->{{ field.name }});
+        Local<Object> {{ field.name }}(value->ToObject());
 
-        NanAssignPersistent(wrapper->{{ field.name }}, {{ field.name }});
+        wrapper->{{ field.name }}.Reset({{ field.name }});
 
-        wrapper->raw->{{ field.name }} = {% if not field.cType | isPointer %}*{% endif %}{% if field.cppClassName == 'GitStrarray' %}StrArrayConverter::Convert({{ field.name }}->ToObject()){% else %}ObjectWrap::Unwrap<{{ field.cppClassName }}>({{ field.name }}->ToObject())->GetValue(){% endif %};
+        wrapper->raw->{{ field.name }} = {% if not field.cType | isPointer %}*{% endif %}{% if field.cppClassName == 'GitStrarray' %}StrArrayConverter::Convert({{ field.name }}->ToObject()){% else %}Nan::ObjectWrap::Unwrap<{{ field.cppClassName }}>({{ field.name }}->ToObject())->GetValue(){% endif %};
 
       {% elsif field.isCallbackFunction %}
         if (wrapper->{{ field.name }} != NULL) {
@@ -55,11 +52,11 @@
             wrapper->raw->{{ field.name }} = ({{ field.cType }}){{ field.name }}_cppCallback;
           }
 
-          wrapper->{{ field.name }} = new NanCallback(value.As<Function>());
+          wrapper->{{ field.name }} = new Nan::Callback(value.As<Function>());
         }
 
       {% elsif field.payloadFor %}
-        NanAssignPersistent(wrapper->{{ field.name }}, value);
+        wrapper->{{ field.name }}.Reset(value);
 
       {% elsif field.cppClassName == 'String' %}
         if (wrapper->GetValue()->{{ field.name }}) {
@@ -75,7 +72,7 @@
 
       {% else %}
         if (value->IsNumber()) {
-          wrapper->GetValue()->{{ field.name }} = ({{ field.cType }}) value->Int32Value();
+          wrapper->GetValue()->{{ field.name }} = ({{ field.cType }}) Nan::To<int32_t>(value).FromJust();
         }
       {% endif %}
     }
@@ -113,7 +110,7 @@
       }
 
       void {{ cppClassName }}::{{ field.name }}_async(uv_async_t* req, int status) {
-        NanScope();
+        Nan::HandleScope scope;
 
         {{ field.name|titleCase }}Baton* baton = static_cast<{{ field.name|titleCase }}Baton*>(req->data);
         {{ cppClassName }}* instance = static_cast<{{ cppClassName }}*>(baton->{% each field.args|argsInfo as arg %}
@@ -145,33 +142,35 @@
           {% each field.args|argsInfo as arg %}
             {% if arg.name == "payload" %}
               {%-- payload is always the last arg --%}
-              NanNew(instance->{{ fields|payloadFor field.name }})
+              Nan::New(instance->{{ fields|payloadFor field.name }})
             {% elsif arg.isJsArg %}
               {% if arg.isEnum %}
-                NanNew((int)baton->{{ arg.name }}),
+                Nan::New((int)baton->{{ arg.name }}),
               {% elsif arg.isLibgitType %}
-                NanNew({{ arg.cppClassName }}::New((void *)baton->{{ arg.name }}, false)),
+                {{ arg.cppClassName }}::New((void *)baton->{{ arg.name }}, false),
               {% elsif arg.cType == "size_t" %}
-                // HACK: NAN should really have an overload for NanNew to support size_t
-                NanNew((unsigned int)baton->{{ arg.name }}),
+                // HACK: NAN should really have an overload for Nan::New to support size_t
+                Nan::New((unsigned int)baton->{{ arg.name }}),
+              {% elsif arg.cppClassName == 'String' %}
+                Nan::New(baton->{{ arg.name }}).ToLocalChecked(),
               {% else %}
-                NanNew(baton->{{ arg.name }}),
+                Nan::New(baton->{{ arg.name }}),
               {% endif %}
             {% endif %}
           {% endeach %}
         };
 
-        TryCatch tryCatch;
-        Handle<v8::Value> result = instance->{{ field.name }}->Call({{ field.args|jsArgsCount }}, argv);
+        Nan::TryCatch tryCatch;
+        Local<v8::Value> result = instance->{{ field.name }}->Call({{ field.args|jsArgsCount }}, argv);
 
-        if (result->IsObject() && result->ToObject()->Has(NanNew("then"))) {
-          Handle<v8::Value> thenProp = result->ToObject()->Get(NanNew("then"));
+        if (result->IsObject() && Nan::Has(result->ToObject(), Nan::New("then").ToLocalChecked()).FromJust()) {
+          Local<v8::Value> thenProp = Nan::Get(result->ToObject(), Nan::New("then").ToLocalChecked()).ToLocalChecked();
 
           if (thenProp->IsFunction()) {
             // we can be reasonbly certain that the result is a promise
             Local<Object> promise = result->ToObject();
 
-            NanAssignPersistent(baton->promise, promise);
+            baton->promise.Reset(promise);
 
             uv_close((uv_handle_t*) &baton->req, NULL);
             uv_async_init(uv_default_loop(), &baton->req, (uv_async_cb) {{ field.name }}_asyncPromisePolling);
@@ -186,7 +185,7 @@
           }
           else if (!result->IsNull() && !result->IsUndefined()) {
             {% if _return.isOutParam %}
-            {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
+            {{ _return.cppClassName }}* wrapper = Nan::ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
             wrapper->selfFreeing = false;
 
             baton->{{ _return.name }} = wrapper->GetRefValue();
@@ -209,11 +208,12 @@
       }
 
       void {{ cppClassName }}::{{ field.name }}_asyncPromisePolling(uv_async_t* req, int status) {
-        NanScope();
+        Nan::HandleScope scope;
 
         {{ field.name|titleCase }}Baton* baton = static_cast<{{ field.name|titleCase }}Baton*>(req->data);
-        Local<Object> promise = NanNew<Object>(baton->promise);
-        NanCallback* isPendingFn = new NanCallback(promise->Get(NanNew("isPending")).As<Function>());
+        Local<Object> promise = Nan::New<Object>(baton->promise);
+
+        Nan::Callback* isPendingFn = new Nan::Callback(Nan::Get(promise, Nan::New("isPending").ToLocalChecked()).ToLocalChecked().As<Function>());
         Local<Value> argv[1]; // MSBUILD won't assign an array of length 0
         Local<Boolean> isPending = isPendingFn->Call(promise, 0, argv)->ToBoolean();
 
@@ -222,12 +222,12 @@
           return;
         }
 
-        NanCallback* isFulfilledFn = new NanCallback(promise->Get(NanNew("isFulfilled")).As<Function>());
+        Nan::Callback* isFulfilledFn = new Nan::Callback(Nan::Get(promise, Nan::New("isFulfilled").ToLocalChecked()).ToLocalChecked().As<Function>());
         Local<Boolean> isFulfilled = isFulfilledFn->Call(promise, 0, argv)->ToBoolean();
 
         if (isFulfilled->Value()) {
-          NanCallback* resultFn = new NanCallback(promise->Get(NanNew("value")).As<Function>());
-          Handle<v8::Value> result = resultFn->Call(promise, 0, argv);
+          Nan::Callback* resultFn = new Nan::Callback(Nan::Get(promise, Nan::New("value").ToLocalChecked()).ToLocalChecked().As<Function>());
+          Local<v8::Value> result = resultFn->Call(promise, 0, argv);
 
           {% each field|returnsInfo false true as _return %}
             if (result.IsEmpty() || result->IsNativeError()) {
@@ -235,7 +235,7 @@
             }
             else if (!result->IsNull() && !result->IsUndefined()) {
               {% if _return.isOutParam %}
-              {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
+              {{ _return.cppClassName }}* wrapper = Nan::ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
               wrapper->selfFreeing = false;
 
               baton->{{ _return.name }} = wrapper->GetRefValue();
diff --git a/generate/templates/partials/fields.cc b/generate/templates/partials/fields.cc
index 56dc04eff..ae3aeae44 100644
--- a/generate/templates/partials/fields.cc
+++ b/generate/templates/partials/fields.cc
@@ -1,11 +1,10 @@
 {% each fields|fieldsInfo as field %}
   {% if not field.ignore %}
     NAN_METHOD({{ cppClassName }}::{{ field.cppFunctionName }}) {
-      NanScope();
-      Handle<v8::Value> to;
+      Local<v8::Value> to;
 
       {% if field | isFixedLengthString %}
-      char* {{ field.name }} = (char *)ObjectWrap::Unwrap<{{ cppClassName }}>(args.This())->GetValue()->{{ field.name }};
+      char* {{ field.name }} = (char *)Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This())->GetValue()->{{ field.name }};
       {% else %}
       {{ field.cType }}
         {% if not field.cppClassName|isV8Value %}
@@ -19,11 +18,11 @@
         &
           {% endif %}
         {% endif %}
-        ObjectWrap::Unwrap<{{ cppClassName }}>(args.This())->GetValue()->{{ field.name }};
+        Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This())->GetValue()->{{ field.name }};
       {% endif %}
 
       {% partial convertToV8 field %}
-      NanReturnValue(to);
+      info.GetReturnValue().Set(to);
     }
   {% endif %}
 {% endeach %}
diff --git a/generate/templates/partials/guard_arguments.cc b/generate/templates/partials/guard_arguments.cc
index 9d3b21f0c..bcfc33284 100644
--- a/generate/templates/partials/guard_arguments.cc
+++ b/generate/templates/partials/guard_arguments.cc
@@ -4,21 +4,21 @@
     {%if not arg.isOptional%}
       {%if not arg.payloadFor %}
         {%if arg | isOid %}
-  if (args.Length() == {{arg.jsArg}}
-    || (!args[{{arg.jsArg}}]->IsObject() && !args[{{arg.jsArg}}]->IsString())) {
-    return NanThrowError("{{arg.jsClassName}} {{arg.name}} is required.");
+  if (info.Length() == {{arg.jsArg}}
+    || (!info[{{arg.jsArg}}]->IsObject() && !info[{{arg.jsArg}}]->IsString())) {
+    return Nan::ThrowError("{{arg.jsClassName}} {{arg.name}} is required.");
   }
         {%elsif arg.isCallbackFunction %}
-  if (args.Length() == {{arg.jsArg}} || !args[{{arg.jsArg}}]->IsFunction()) {
-    return NanThrowError("{{arg.jsClassName}} {{arg.name}} is required.");
+  if (info.Length() == {{arg.jsArg}} || !info[{{arg.jsArg}}]->IsFunction()) {
+    return Nan::ThrowError("{{arg.jsClassName}} {{arg.name}} is required.");
   }
         {%elsif arg.cppClassName == "GitStrarray" %}
-  if (args.Length() == {{arg.jsArg}} || !args[{{arg.jsArg}}]->BooleanValue()) {
-    return NanThrowError("Array, String Object, or string {{arg.name}} is required.");
+  if (info.Length() == {{arg.jsArg}} || !(Nan::To<bool>(info[{{arg.jsArg}}]).FromJust())) {
+    return Nan::ThrowError("Array, String Object, or string {{arg.name}} is required.");
   }
         {%else%}
-  if (args.Length() == {{arg.jsArg}} || !args[{{arg.jsArg}}]->Is{{arg.cppClassName|cppToV8}}()) {
-    return NanThrowError("{{arg.jsClassName}} {{arg.name}} is required.");
+  if (info.Length() == {{arg.jsArg}} || !info[{{arg.jsArg}}]->Is{{arg.cppClassName|cppToV8}}()) {
+    return Nan::ThrowError("{{arg.jsClassName}} {{arg.name}} is required.");
   }
 
         {%endif%}
diff --git a/generate/templates/partials/sync_function.cc b/generate/templates/partials/sync_function.cc
index cf9ab11f2..b3b6adf71 100644
--- a/generate/templates/partials/sync_function.cc
+++ b/generate/templates/partials/sync_function.cc
@@ -1,7 +1,7 @@
 
 {%partial doc .%}
 NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
-  NanEscapableScope();
+  Nan::EscapableHandleScope scope;
   {%partial guardArguments .%}
 
   {%each .|returnsInfo 'true' as _return %}
@@ -17,12 +17,10 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
       {%if not arg.isReturn %}
         {%partial convertFromV8 arg %}
         {%if arg.saveArg %}
-  Handle<Object> {{ arg.name }}(args[{{ arg.jsArg }}]->ToObject());
-  {{ cppClassName }} *thisObj = ObjectWrap::Unwrap<{{ cppClassName }}>(args.This());
+  Local<Object> {{ arg.name }}(info[{{ arg.jsArg }}]->ToObject());
+  {{ cppClassName }} *thisObj = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This());
 
-  NanDisposePersistent(thisObj->{{ cppFunctionName }}_{{ arg.name }});
-
-  NanAssignPersistent(thisObj->{{ cppFunctionName }}_{{ arg.name }}, {{ arg.name }});
+  thisObj->{{ cppFunctionName }}_{{ arg.name }}.Reset({{ arg.name }});
         {%endif%}
       {%endif%}
     {%endif%}
@@ -33,7 +31,7 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
 
 {%-- Inside a free call, if the value is already free'd don't do it again.--%}
 {% if cppFunctionName == "Free" %}
-if (ObjectWrap::Unwrap<{{ cppClassName }}>(args.This())->GetValue() != NULL) {
+if (Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This())->GetValue() != NULL) {
 {% endif %}
 
 {%if .|hasReturnValue %}
@@ -43,7 +41,7 @@ if (ObjectWrap::Unwrap<{{ cppClassName }}>(args.This())->GetValue() != NULL) {
       {%if not arg.shouldAlloc %}&{%endif%}
     {%endif%}
     {%if arg.isSelf %}
-ObjectWrap::Unwrap<{{ arg.cppClassName }}>(args.This())->GetValue()
+Nan::ObjectWrap::Unwrap<{{ arg.cppClassName }}>(info.This())->GetValue()
     {%elsif arg.isReturn %}
 {{ arg.name }}
     {%else%}
@@ -59,58 +57,58 @@ from_{{ arg.name }}
     {%if arg.shouldAlloc %}
     free({{ arg.name }});
     {%elsif arg | isOid %}
-    if (args[{{ arg.jsArg }}]->IsString()) {
+    if (info[{{ arg.jsArg }}]->IsString()) {
       free({{ arg.name }});
     }
     {%endif%}
   {%endeach%}
 
     if (giterr_last()) {
-      return NanThrowError(giterr_last()->message);
+      return Nan::ThrowError(giterr_last()->message);
     } else {
-      return NanThrowError("Unknown Error");
+      return Nan::ThrowError("Unknown Error");
     }
   }
 {%endif%}
 
 {% if cppFunctionName == "Free" %}
-  ObjectWrap::Unwrap<{{ cppClassName }}>(args.This())->ClearValue();
+  Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This())->ClearValue();
 }
 {% endif %}
 
 
 {%each args|argsInfo as arg %}
   {%if arg | isOid %}
-  if (args[{{ arg.jsArg }}]->IsString()) {
+  if (info[{{ arg.jsArg }}]->IsString()) {
     free((void *)from_{{ arg.name }});
   }
   {%endif%}
 {%endeach%}
 
 {%if not .|returnsCount %}
-  NanReturnUndefined();
+  return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
 {%else%}
   {%if return.cType | isPointer %}
   // null checks on pointers
   if (!result) {
-    NodeGitPsueodoNanReturnEscapingValue(NanUndefined());
+    return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
   }
   {%endif%}
 
-  Handle<v8::Value> to;
+  Local<v8::Value> to;
   {%if .|returnsCount > 1 %}
-  Handle<Object> toReturn = NanNew<Object>();
+  Local<Object> toReturn = Nan::New<Object>();
   {%endif%}
   {%each .|returnsInfo as _return %}
     {%partial convertToV8 _return %}
     {%if .|returnsCount > 1 %}
-  toReturn->Set(NanNew<String>("{{ _return.returnNameOrName }}"), to);
+  Nan::Set(toReturn, Nan::New("{{ _return.returnNameOrName }}").ToLocalChecked(), to);
     {%endif%}
   {%endeach%}
   {%if .|returnsCount == 1 %}
-  NodeGitPsueodoNanReturnEscapingValue(to);
+  return info.GetReturnValue().Set(scope.Escape(to));
   {%else%}
-  NodeGitPsueodoNanReturnEscapingValue(toReturn);
+  return info.GetReturnValue().Set(scope.Escape(toReturn));
   {%endif%}
 {%endif%}
 }
diff --git a/generate/templates/templates/class_content.cc b/generate/templates/templates/class_content.cc
index c95c67214..86d2aada4 100644
--- a/generate/templates/templates/class_content.cc
+++ b/generate/templates/templates/class_content.cc
@@ -12,7 +12,6 @@ extern "C" {
 }
 
 #include "../include/functions/copy.h"
-#include "../include/macros.h"
 #include "../include/{{ filename }}.h"
 
 {% each dependencies as dependency %}
@@ -47,7 +46,7 @@ using namespace node;
         {% each function.args as arg %}
           {% if arg.saveArg %}
 
-      NanDisposePersistent({{ function.cppFunctionName }}_{{ arg.name }});
+      {{ function.cppFunctionName }}_{{ arg.name }}).Reset();
 
           {% endif %}
         {% endeach %}
@@ -56,56 +55,55 @@ using namespace node;
 
   }
 
-  void {{ cppClassName }}::InitializeComponent(Handle<v8::Object> target) {
-    NanScope();
+  void {{ cppClassName }}::InitializeComponent(Local<v8::Object> target) {
+    Nan::HandleScope scope;
 
-    Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(JSNewFunction);
+    Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
 
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
-    tpl->SetClassName(NanNew<String>("{{ jsClassName }}"));
+    tpl->SetClassName(Nan::New("{{ jsClassName }}").ToLocalChecked());
 
     {% each functions as function %}
       {% if not function.ignore %}
         {% if function.isPrototypeMethod %}
-          NODE_SET_PROTOTYPE_METHOD(tpl, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }});
+          Nan::SetPrototypeMethod(tpl, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }});
         {% else %}
-          NODE_SET_METHOD(tpl, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }});
+          Nan::SetMethod(tpl, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }});
         {% endif %}
       {% endif %}
     {% endeach %}
 
     {% each fields as field %}
       {% if not field.ignore %}
-        NODE_SET_PROTOTYPE_METHOD(tpl, "{{ field.jsFunctionName }}", {{ field.cppFunctionName }});
+        Nan::SetPrototypeMethod(tpl, "{{ field.jsFunctionName }}", {{ field.cppFunctionName }});
       {% endif %}
     {% endeach %}
 
-    Local<Function> _constructor_template = tpl->GetFunction();
-    NanAssignPersistent(constructor_template, _constructor_template);
-    target->Set(NanNew<String>("{{ jsClassName }}"), _constructor_template);
+    Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+    constructor_template.Reset(_constructor_template);
+    Nan::Set(target, Nan::New("{{ jsClassName }}").ToLocalChecked(), _constructor_template);
   }
 
   NAN_METHOD({{ cppClassName }}::JSNewFunction) {
-    NanScope();
 
-    if (args.Length() == 0 || !args[0]->IsExternal()) {
+    if (info.Length() == 0 || !info[0]->IsExternal()) {
       {% if createFunctionName %}
-        return NanThrowError("A new {{ cppClassName }} cannot be instantiated. Use {{ jsCreateFunctionName }} instead.");
+        return Nan::ThrowError("A new {{ cppClassName }} cannot be instantiated. Use {{ jsCreateFunctionName }} instead.");
       {% else %}
-        return NanThrowError("A new {{ cppClassName }} cannot be instantiated.");
+        return Nan::ThrowError("A new {{ cppClassName }} cannot be instantiated.");
       {% endif %}
     }
 
-    {{ cppClassName }}* object = new {{ cppClassName }}(static_cast<{{ cType }} *>(Handle<External>::Cast(args[0])->Value()), args[1]->BooleanValue());
-    object->Wrap(args.This());
+    {{ cppClassName }}* object = new {{ cppClassName }}(static_cast<{{ cType }} *>(Local<External>::Cast(info[0])->Value()), Nan::To<bool>(info[1]).FromJust());
+    object->Wrap(info.This());
 
-    NanReturnValue(args.This());
+    info.GetReturnValue().Set(info.This());
   }
 
-  Handle<v8::Value> {{ cppClassName }}::New(void *raw, bool selfFreeing) {
-    NanEscapableScope();
-    Handle<v8::Value> argv[2] = { NanNew<External>((void *)raw), NanNew<Boolean>(selfFreeing) };
-    return NanEscapeScope(NanNew<Function>({{ cppClassName }}::constructor_template)->NewInstance(2, argv));
+  Local<v8::Value> {{ cppClassName }}::New(void *raw, bool selfFreeing) {
+    Nan::EscapableHandleScope scope;
+    Local<v8::Value> argv[2] = { Nan::New<External>((void *)raw), Nan::New(selfFreeing) };
+    return scope.Escape(Nan::NewInstance(Nan::New({{ cppClassName }}::constructor_template), 2, argv).ToLocalChecked());
   }
 
   {{ cType }} *{{ cppClassName }}::GetValue() {
@@ -122,18 +120,18 @@ using namespace node;
 
 {% else %}
 
-  void {{ cppClassName }}::InitializeComponent(Handle<v8::Object> target) {
-    NanScope();
+  void {{ cppClassName }}::InitializeComponent(Local<v8::Object> target) {
+    Nan::HandleScope scope;
 
-    Local<Object> object = NanNew<Object>();
+    Local<Object> object = Nan::New<Object>();
 
     {% each functions as function %}
       {% if not function.ignore %}
-        NODE_SET_METHOD(object, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }});
+        Nan::SetMethod(object, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }});
       {% endif %}
     {% endeach %}
 
-    target->Set(NanNew<String>("{{ jsClassName }}"), object);
+    Nan::Set(target, Nan::New<String>("{{ jsClassName }}").ToLocalChecked(), object);
   }
 
 {% endif %}
@@ -151,5 +149,5 @@ using namespace node;
 {% partial fields . %}
 
 {% if not cTypeIsUndefined %}
-  Persistent<Function> {{ cppClassName }}::constructor_template;
+  Nan::Persistent<Function> {{ cppClassName }}::constructor_template;
 {% endif %}
diff --git a/generate/templates/templates/class_header.h b/generate/templates/templates/class_header.h
index d7f903f26..b4ad0f4ae 100644
--- a/generate/templates/templates/class_header.h
+++ b/generate/templates/templates/class_header.h
@@ -29,18 +29,18 @@ struct {{ cType }} {
 using namespace node;
 using namespace v8;
 
-class {{ cppClassName }} : public ObjectWrap {
+class {{ cppClassName }} : public Nan::ObjectWrap {
   public:
 
-    static Persistent<Function> constructor_template;
-    static void InitializeComponent (Handle<v8::Object> target);
+    static Nan::Persistent<Function> constructor_template;
+    static void InitializeComponent (Local<v8::Object> target);
 
     {%if cType%}
     {{ cType }} *GetValue();
     {{ cType }} **GetRefValue();
     void ClearValue();
 
-    static Handle<v8::Value> New(void *raw, bool selfFreeing);
+    static Local<v8::Value> New(void *raw, bool selfFreeing);
     {%endif%}
     bool selfFreeing;
 
@@ -66,7 +66,7 @@ class {{ cppClassName }} : public ObjectWrap {
 
       uv_async_t req;
       {{ arg.return.type }} result;
-      Persistent<Object> promise;
+      Nan::Persistent<Object> promise;
       bool done;
     };
           {% endif %}
@@ -87,7 +87,7 @@ class {{ cppClassName }} : public ObjectWrap {
       {% if not function.ignore %}
         {% each function.args as arg %}
           {% if arg.saveArg %}
-    Persistent<Object> {{ function.cppFunctionName }}_{{ arg.name }};
+    Nan::Persistent<Object> {{ function.cppFunctionName }}_{{ arg.name }};
           {% endif %}
         {% endeach %}
       {% endif %}
@@ -119,12 +119,12 @@ class {{ cppClassName }} : public ObjectWrap {
         {%endif%}
       {%endeach%}
     };
-    class {{ function.cppFunctionName }}Worker : public NanAsyncWorker {
+    class {{ function.cppFunctionName }}Worker : public Nan::AsyncWorker {
       public:
         {{ function.cppFunctionName }}Worker(
             {{ function.cppFunctionName }}Baton *_baton,
-            NanCallback *callback
-        ) : NanAsyncWorker(callback)
+            Nan::Callback *callback
+        ) : Nan::AsyncWorker(callback)
           , baton(_baton) {};
         ~{{ function.cppFunctionName }}Worker() {};
         void Execute();
@@ -146,7 +146,7 @@ class {{ cppClassName }} : public ObjectWrap {
     struct {{ function.cppFunctionName }}_globalPayload {
           {%each function.args as arg %}
             {%if arg.isCallbackFunction %}
-      NanCallback * {{ arg.name }};
+      Nan::Callback * {{ arg.name }};
             {%endif%}
           {%endeach%}
 
diff --git a/generate/templates/templates/nodegit.cc b/generate/templates/templates/nodegit.cc
index 9bd2dd89b..47f835227 100644
--- a/generate/templates/templates/nodegit.cc
+++ b/generate/templates/templates/nodegit.cc
@@ -11,8 +11,8 @@
   {% endif %}
 {% endeach %}
 
-extern "C" void init(Handle<v8::Object> target) {
-  NanScope();
+extern "C" void init(Local<v8::Object> target) {
+  Nan::HandleScope scope;
 
   Wrapper::InitializeComponent(target);
   {% each %}
diff --git a/generate/templates/templates/struct_content.cc b/generate/templates/templates/struct_content.cc
index 4e7b862ba..94c276dd8 100644
--- a/generate/templates/templates/struct_content.cc
+++ b/generate/templates/templates/struct_content.cc
@@ -72,7 +72,7 @@ void {{ cppClassName }}::ConstructFields() {
             &this->raw->{{ field.name }},
             false
           )->ToObject();
-          NanAssignPersistent(this->{{ field.name }}, {{ field.name }}Temp);
+          this->{{ field.name }}.Reset({{ field.name }}Temp);
 
         {% elsif field.isCallbackFunction %}
 
@@ -83,56 +83,55 @@ void {{ cppClassName }}::ConstructFields() {
           this->{{ field.name }} = NULL;
         {% elsif field.payloadFor %}
 
-          Local<Value> {{ field.name }} = NanUndefined();
-          NanAssignPersistent(this->{{ field.name }}, {{ field.name }});
+          Local<Value> {{ field.name }} = Nan::Undefined();
+          this->{{ field.name }}.Reset({{ field.name }});
         {% endif %}
       {% endif %}
     {% endif %}
   {% endeach %}
 }
 
-void {{ cppClassName }}::InitializeComponent(Handle<v8::Object> target) {
-  NanScope();
+void {{ cppClassName }}::InitializeComponent(Local<v8::Object> target) {
+  Nan::HandleScope scope;
 
-  Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(JSNewFunction);
+  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
 
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
-  tpl->SetClassName(NanNew<String>("{{ jsClassName }}"));
+  tpl->SetClassName(Nan::New("{{ jsClassName }}").ToLocalChecked());
 
   {% each fields as field %}
     {% if not field.ignore %}
     {% if not field | isPayload %}
-      tpl->InstanceTemplate()->SetAccessor(NanNew<String>("{{ field.jsFunctionName }}"), Get{{ field.cppFunctionName}}, Set{{ field.cppFunctionName}});
+      Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("{{ field.jsFunctionName }}").ToLocalChecked(), Get{{ field.cppFunctionName}}, Set{{ field.cppFunctionName}});
     {% endif %}
     {% endif %}
   {% endeach %}
 
-  Local<Function> _constructor_template = tpl->GetFunction();
-  NanAssignPersistent(constructor_template, _constructor_template);
-  target->Set(NanNew<String>("{{ jsClassName }}"), _constructor_template);
+  Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+  constructor_template.Reset(_constructor_template);
+  Nan::Set(target, Nan::New("{{ jsClassName }}").ToLocalChecked(), _constructor_template);
 }
 
 NAN_METHOD({{ cppClassName }}::JSNewFunction) {
-  NanScope();
   {{ cppClassName }}* instance;
 
-  if (args.Length() == 0 || !args[0]->IsExternal()) {
+  if (info.Length() == 0 || !info[0]->IsExternal()) {
     instance = new {{ cppClassName }}();
   }
   else {
-    instance = new {{ cppClassName }}(static_cast<{{ cType }}*>(Handle<External>::Cast(args[0])->Value()), args[1]->BooleanValue());
+    instance = new {{ cppClassName }}(static_cast<{{ cType }}*>(Local<External>::Cast(info[0])->Value()), Nan::To<bool>(info[1]).FromJust());
   }
 
-  instance->Wrap(args.This());
+  instance->Wrap(info.This());
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
-Handle<v8::Value> {{ cppClassName }}::New(void* raw, bool selfFreeing) {
-  NanEscapableScope();
+Local<v8::Value> {{ cppClassName }}::New(void* raw, bool selfFreeing) {
+  Nan::EscapableHandleScope scope;
 
-  Handle<v8::Value> argv[2] = { NanNew<External>((void *)raw), NanNew<Boolean>(selfFreeing) };
-  return NanEscapeScope(NanNew<Function>({{ cppClassName }}::constructor_template)->NewInstance(2, argv));
+  Local<v8::Value> argv[2] = { Nan::New<External>((void *)raw), Nan::New<Boolean>(selfFreeing) };
+  return scope.Escape(Nan::NewInstance(Nan::New({{ cppClassName }}::constructor_template), 2, argv).ToLocalChecked());
 }
 
 {{ cType }} *{{ cppClassName }}::GetValue() {
@@ -149,4 +148,4 @@ void {{ cppClassName }}::ClearValue() {
 
 {% partial fieldAccessors . %}
 
-Persistent<Function> {{ cppClassName }}::constructor_template;
+Nan::Persistent<Function> {{ cppClassName }}::constructor_template;
diff --git a/generate/templates/templates/struct_header.h b/generate/templates/templates/struct_header.h
index 471e6e31e..1b7c2786d 100644
--- a/generate/templates/templates/struct_header.h
+++ b/generate/templates/templates/struct_header.h
@@ -18,17 +18,17 @@ extern "C" {
 using namespace node;
 using namespace v8;
 
-class {{ cppClassName }} : public ObjectWrap {
+class {{ cppClassName }} : public Nan::ObjectWrap {
   public:
     {{ cppClassName }}({{ cType }}* raw, bool selfFreeing);
-    static Persistent<Function> constructor_template;
-    static void InitializeComponent (Handle<v8::Object> target);
+    static Nan::Persistent<Function> constructor_template;
+    static void InitializeComponent (Local<v8::Object> target);
 
     {{ cType }} *GetValue();
     {{ cType }} **GetRefValue();
     void ClearValue();
 
-    static Handle<v8::Value> New(void *raw, bool selfFreeing);
+    static Local<v8::Value> New(void *raw, bool selfFreeing);
 
     bool selfFreeing;
 
@@ -53,7 +53,7 @@ class {{ cppClassName }} : public ObjectWrap {
 
             uv_async_t req;
             {{ field.return.type }} result;
-            Persistent<Object> promise;
+            Nan::Persistent<Object> promise;
             bool done;
           };
         {% endif %}
@@ -72,11 +72,11 @@ class {{ cppClassName }} : public ObjectWrap {
       {% if not field.ignore %}
         {% if not field.isEnum %}
           {% if field.isLibgitType %}
-            Persistent<Object> {{ field.name }};
+            Nan::Persistent<Object> {{ field.name }};
           {% elsif field.isCallbackFunction %}
-            NanCallback* {{ field.name }};
+            Nan::Callback* {{ field.name }};
           {% elsif field.payloadFor %}
-            Persistent<Value> {{ field.name }};
+            Nan::Persistent<Value> {{ field.name }};
           {% endif %}
         {% endif %}
 
diff --git a/lifecycleScripts/install.js b/lifecycleScripts/install.js
index 84a30d32a..4107383f4 100644
--- a/lifecycleScripts/install.js
+++ b/lifecycleScripts/install.js
@@ -79,7 +79,7 @@ function build() {
   var prefix = "";
   var target = "";
   var debug = (process.env.BUILD_DEBUG ? " --debug" : "");
-  var builder = "pangyp";
+  var builder = "node-gyp";
   var distUrl = "";
 
   if (asVersion) {
diff --git a/package.json b/package.json
index cd9a70f09..955bd7b0f 100644
--- a/package.json
+++ b/package.json
@@ -53,9 +53,9 @@
     "lcov-result-merger": "^1.0.2",
     "lodash": "^3.8.0",
     "mocha": "^2.2.4",
-    "nan": "^1.8.4",
+    "nan": "^2.0.9",
+    "node-gyp": "^3.0.1",
     "nw-gyp": "^0.12.4",
-    "pangyp": "^2.2.1",
     "request": "^2.55.0",
     "tar": "^2.1.0"
   },
@@ -81,16 +81,16 @@
     "cov": "npm run cppcov && npm run filtercov && npm run mergecov",
     "mocha": "mocha test/runner test/tests",
     "mochaDebug": "mocha --debug-brk test/runner test/tests",
-    "test": "npm run lint && (iojs --expose-gc test || node --expose-gc test)",
+    "test": "npm run lint && node --expose-gc test",
     "generateJson": "node generate/scripts/generateJson",
     "generateNativeCode": "node generate/scripts/generateNativeCode",
     "generateMissingTests": "node generate/scripts/generateMissingTests",
     "prepublish": "node lifecycleScripts/prepareForBuild.js",
     "install": "node lifecycleScripts/install",
     "installDebug": "BUILD_DEBUG=true npm install",
-    "recompile": "pangyp configure build",
-    "rebuild": "node generate && pangyp configure build",
-    "recompileDebug": "pangyp configure --debug build",
-    "rebuildDebug": "node generate && pangyp configure --debug build"
+    "recompile": "node-gyp configure build",
+    "rebuild": "node generate && node-gyp configure build",
+    "recompileDebug": "node-gyp configure --debug build",
+    "rebuildDebug": "node generate && node-gyp configure --debug build"
   }
 }