diff --git a/generate/input/libgit2-supplement.json b/generate/input/libgit2-supplement.json
index 742216f03..12ee8945b 100644
--- a/generate/input/libgit2-supplement.json
+++ b/generate/input/libgit2-supplement.json
@@ -2444,12 +2444,6 @@
           }
         }
       ],
-      [
-        "git_time_t",
-        {
-          "type": "enum"
-        }
-      ],
       [
         "git_trace_level_t",
         {
diff --git a/generate/scripts/helpers.js b/generate/scripts/helpers.js
index 15790983f..e278e1cc0 100644
--- a/generate/scripts/helpers.js
+++ b/generate/scripts/helpers.js
@@ -25,7 +25,8 @@ var cTypeMappings = {
   "uint32_t": "Number",
   "uint64_t": "Number",
   "double": "Number",
-  "git_object_size_t": "Number"
+  "git_object_size_t": "Number",
+  "git_time_t": "Number",
 }
 
 var collisionMappings = {
diff --git a/generate/templates/manual/filter_source/repo.cc b/generate/templates/manual/filter_source/repo.cc
index 78903d86b..eddcf8154 100644
--- a/generate/templates/manual/filter_source/repo.cc
+++ b/generate/templates/manual/filter_source/repo.cc
@@ -16,13 +16,13 @@ NAN_METHOD(GitFilterSource::Repo) {
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
-  baton->src = Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue();
+  baton->src = Nan::ObjectWrap::Unwrap<GitFilterSource>(info.Holder())->GetValue();
 
   Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   RepoWorker *worker = new RepoWorker(baton, callback, cleanupHandles);
 
-  worker->Reference<GitFilterSource>("src", info.This());
+  worker->Reference<GitFilterSource>("src", info.Holder());
 
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
diff --git a/generate/templates/manual/include/configurable_class_wrapper.h b/generate/templates/manual/include/configurable_class_wrapper.h
index 283eb7e44..ff83a3176 100644
--- a/generate/templates/manual/include/configurable_class_wrapper.h
+++ b/generate/templates/manual/include/configurable_class_wrapper.h
@@ -40,7 +40,7 @@ namespace nodegit {
 
     virtual ~ConfigurableClassWrapper() {
       if (raw != nullptr) {
-        delete raw;
+        free(raw);
         raw = nullptr;
       }
     }
diff --git a/generate/templates/manual/remote/ls.cc b/generate/templates/manual/remote/ls.cc
index 97c801c62..b22d87afd 100644
--- a/generate/templates/manual/remote/ls.cc
+++ b/generate/templates/manual/remote/ls.cc
@@ -9,12 +9,12 @@ NAN_METHOD(GitRemote::ReferenceList)
   baton->error_code = GIT_OK;
   baton->error = NULL;
   baton->out = new std::vector<git_remote_head*>;
-  baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
+  baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.Holder())->GetValue();
 
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   ReferenceListWorker *worker = new ReferenceListWorker(baton, callback, cleanupHandles);
-  worker->Reference<GitRemote>("remote", info.This());
+  worker->Reference<GitRemote>("remote", info.Holder());
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
   return;
diff --git a/generate/templates/manual/repository/get_references.cc b/generate/templates/manual/repository/get_references.cc
index 56bc12ac3..47db9f467 100644
--- a/generate/templates/manual/repository/get_references.cc
+++ b/generate/templates/manual/repository/get_references.cc
@@ -9,12 +9,12 @@ NAN_METHOD(GitRepository::GetReferences)
   baton->error_code = GIT_OK;
   baton->error = NULL;
   baton->out = new std::vector<git_reference *>;
-  baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.This())->GetValue();
+  baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.Holder())->GetValue();
 
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   GetReferencesWorker *worker = new GetReferencesWorker(baton, callback, cleanupHandles);
-  worker->Reference<GitRepository>("repo", info.This());
+  worker->Reference<GitRepository>("repo", info.Holder());
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
   return;
diff --git a/generate/templates/manual/repository/get_remotes.cc b/generate/templates/manual/repository/get_remotes.cc
index a7c316bb0..779dd37a2 100644
--- a/generate/templates/manual/repository/get_remotes.cc
+++ b/generate/templates/manual/repository/get_remotes.cc
@@ -9,12 +9,12 @@ NAN_METHOD(GitRepository::GetRemotes)
   baton->error_code = GIT_OK;
   baton->error = NULL;
   baton->out = new std::vector<git_remote *>;
-  baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.This())->GetValue();
+  baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.Holder())->GetValue();
 
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   GetRemotesWorker *worker = new GetRemotesWorker(baton, callback, cleanupHandles);
-  worker->Reference<GitRepository>("repo", info.This());
+  worker->Reference<GitRepository>("repo", info.Holder());
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
   return;
diff --git a/generate/templates/manual/repository/get_submodules.cc b/generate/templates/manual/repository/get_submodules.cc
index 069f6bdbc..1c79e6257 100644
--- a/generate/templates/manual/repository/get_submodules.cc
+++ b/generate/templates/manual/repository/get_submodules.cc
@@ -9,12 +9,12 @@ NAN_METHOD(GitRepository::GetSubmodules)
   baton->error_code = GIT_OK;
   baton->error = NULL;
   baton->out = new std::vector<git_submodule *>;
-  baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.This())->GetValue();
+  baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.Holder())->GetValue();
 
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   GetSubmodulesWorker *worker = new GetSubmodulesWorker(baton, callback, cleanupHandles);
-  worker->Reference<GitRepository>("repo", info.This());
+  worker->Reference<GitRepository>("repo", info.Holder());
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
   return;
diff --git a/generate/templates/manual/repository/refresh_references.cc b/generate/templates/manual/repository/refresh_references.cc
index 5ddaec57f..e6913fa98 100644
--- a/generate/templates/manual/repository/refresh_references.cc
+++ b/generate/templates/manual/repository/refresh_references.cc
@@ -244,10 +244,10 @@ class RefreshedRefModel {
   }
 
   ~RefreshedRefModel() {
-    if (fullName != NULL) { delete[] fullName; }
-    if (message != NULL) { delete[] message; }
+    if (fullName != NULL) { free(fullName); }
+    if (message != NULL) { free(message); }
     delete[] sha;
-    if (shorthand != NULL) { delete[] shorthand; }
+    if (shorthand != NULL) { free(shorthand); }
     if (tagOdbBuffer != NULL) { delete[] tagOdbBuffer; }
   }
 
@@ -344,8 +344,8 @@ class UpstreamModel {
   }
 
   ~UpstreamModel() {
-    if (downstreamFullName != NULL) { delete[] downstreamFullName; }
-    if (upstreamFullName != NULL) { delete[] upstreamFullName; }
+    if (downstreamFullName != NULL) { free(downstreamFullName); }
+    if (upstreamFullName != NULL) { free(upstreamFullName); }
   }
 
   char *downstreamFullName;
@@ -375,7 +375,7 @@ class RefreshReferencesData {
       delete upstreamInfo.back();
       upstreamInfo.pop_back();
     }
-    if (headRefFullName != NULL) { delete[] headRefFullName; }
+    if (headRefFullName != NULL) { free(headRefFullName); }
     if (cherrypick != NULL) { delete cherrypick; }
     if (merge != NULL) { delete merge; }
   }
@@ -416,12 +416,12 @@ NAN_METHOD(GitRepository::RefreshReferences)
   baton->error_code = GIT_OK;
   baton->error = NULL;
   baton->out = (void *)new RefreshReferencesData();
-  baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.This())->GetValue();
+  baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.Holder())->GetValue();
 
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   RefreshReferencesWorker *worker = new RefreshReferencesWorker(baton, callback, cleanupHandles);
-  worker->Reference<GitRepository>("repo", info.This());
+  worker->Reference<GitRepository>("repo", info.Holder());
   worker->Reference("signatureType", signatureType);
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
@@ -573,7 +573,7 @@ void GitRepository::RefreshReferencesWorker::Execute()
     if (isRemote) {
       char *remoteNameOfRef = getRemoteNameOfReference(reference);
       bool isFromExistingRemote = gitStrArrayContains(&remoteNames, remoteNameOfRef);
-      delete[] remoteNameOfRef;
+      free(remoteNameOfRef);
       if (!isFromExistingRemote) {
         git_reference_free(reference);
         continue;
diff --git a/generate/templates/manual/repository/statistics.cc b/generate/templates/manual/repository/statistics.cc
index f438bb5f8..2cc188ff9 100644
--- a/generate/templates/manual/repository/statistics.cc
+++ b/generate/templates/manual/repository/statistics.cc
@@ -1781,13 +1781,13 @@ NAN_METHOD(GitRepository::Statistics)
 
    baton->error_code = GIT_OK;
    baton->error = NULL;
-   baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.This())->GetValue();
+   baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.Holder())->GetValue();
    baton->out = static_cast<void *>(new RepoAnalysis(baton->repo));
    
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   StatisticsWorker *worker = new StatisticsWorker(baton, callback, cleanupHandles);
-  worker->Reference<GitRepository>("repo", info.This());
+  worker->Reference<GitRepository>("repo", info.Holder());
   nodegit::Context *nodegitContext =
     reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
diff --git a/generate/templates/manual/revwalk/commit_walk.cc b/generate/templates/manual/revwalk/commit_walk.cc
index 4fe60de9e..cec7ff2f0 100644
--- a/generate/templates/manual/revwalk/commit_walk.cc
+++ b/generate/templates/manual/revwalk/commit_walk.cc
@@ -139,11 +139,11 @@ NAN_METHOD(GitRevwalk::CommitWalk) {
   } else {
     baton->returnPlainObjects = false;
   }
-  baton->walk = Nan::ObjectWrap::Unwrap<GitRevwalk>(info.This())->GetValue();
+  baton->walk = Nan::ObjectWrap::Unwrap<GitRevwalk>(info.Holder())->GetValue();
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   CommitWalkWorker *worker = new CommitWalkWorker(baton, callback, cleanupHandles);
-  worker->Reference<GitRevwalk>("commitWalk", info.This());
+  worker->Reference<GitRevwalk>("commitWalk", info.Holder());
 
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
diff --git a/generate/templates/manual/revwalk/fast_walk.cc b/generate/templates/manual/revwalk/fast_walk.cc
index ce2d05a2d..2aa03620b 100644
--- a/generate/templates/manual/revwalk/fast_walk.cc
+++ b/generate/templates/manual/revwalk/fast_walk.cc
@@ -15,12 +15,12 @@ NAN_METHOD(GitRevwalk::FastWalk)
   baton->max_count = Nan::To<unsigned int>(info[0]).FromJust();
   baton->out = new std::vector<git_oid*>;
   baton->out->reserve(baton->max_count);
-  baton->walk = Nan::ObjectWrap::Unwrap<GitRevwalk>(info.This())->GetValue();
+  baton->walk = Nan::ObjectWrap::Unwrap<GitRevwalk>(info.Holder())->GetValue();
 
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   FastWalkWorker *worker = new FastWalkWorker(baton, callback, cleanupHandles);
-  worker->Reference<GitRevwalk>("fastWalk", info.This());
+  worker->Reference<GitRevwalk>("fastWalk", info.Holder());
 
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
diff --git a/generate/templates/manual/revwalk/file_history_walk.cc b/generate/templates/manual/revwalk/file_history_walk.cc
index 714d6f5db..25ac40ed8 100644
--- a/generate/templates/manual/revwalk/file_history_walk.cc
+++ b/generate/templates/manual/revwalk/file_history_walk.cc
@@ -31,6 +31,14 @@ class FileHistoryEvent {
     if (commit != NULL) {
       git_commit_free(commit);
     }
+
+    if(from != NULL) {
+      free((void *)from);
+    }
+
+    if(to != NULL) {
+      free((void *)to);
+    }
   }
 
   v8::Local<v8::Value> toJavascript() {
@@ -206,12 +214,12 @@ NAN_METHOD(GitRevwalk::FileHistoryWalk)
   baton->max_count = Nan::To<unsigned int>(info[1]).FromJust();
   baton->out = new std::vector<void *>;
   baton->out->reserve(baton->max_count);
-  baton->walk = Nan::ObjectWrap::Unwrap<GitRevwalk>(info.This())->GetValue();
+  baton->walk = Nan::ObjectWrap::Unwrap<GitRevwalk>(info.Holder())->GetValue();
 
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   FileHistoryWalkWorker *worker = new FileHistoryWalkWorker(baton, callback, cleanupHandles);
-  worker->Reference<GitRevwalk>("fileHistoryWalk", info.This());
+  worker->Reference<GitRevwalk>("fileHistoryWalk", info.Holder());
 
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
diff --git a/generate/templates/manual/src/context.cc b/generate/templates/manual/src/context.cc
index a4c9483dc..a02c40889 100644
--- a/generate/templates/manual/src/context.cc
+++ b/generate/templates/manual/src/context.cc
@@ -28,7 +28,7 @@ namespace nodegit {
     : isolate(isolate)
     , threadPool(10, node::GetCurrentEventLoop(isolate), this)
   {
-    Nan::HandleScope scopoe;
+    Nan::HandleScope scope;
     v8::Local<v8::Object> storage = Nan::New<v8::Object>();
     persistentStorage.Reset(storage);
     contexts[isolate] = this;
@@ -45,9 +45,7 @@ namespace nodegit {
   }
 
   Context *Context::GetCurrentContext() {
-    Nan::HandleScope scope;
-    v8::Local<v8::Context> context = Nan::GetCurrentContext();
-    v8::Isolate *isolate = context->GetIsolate();
+    v8::Isolate *isolate = v8::Isolate::GetCurrent();
     return contexts[isolate];
   }
 
diff --git a/generate/templates/manual/src/convenient_hunk.cc b/generate/templates/manual/src/convenient_hunk.cc
index 2d33e50b6..3fb095dc9 100644
--- a/generate/templates/manual/src/convenient_hunk.cc
+++ b/generate/templates/manual/src/convenient_hunk.cc
@@ -64,9 +64,9 @@ NAN_METHOD(ConvenientHunk::JSNewFunction) {
    }
 
   ConvenientHunk* object = new ConvenientHunk(static_cast<HunkData *>(Local<External>::Cast(info[0])->Value()));
-  object->Wrap(info.This());
+  object->Wrap(info.Holder());
 
-  info.GetReturnValue().Set(info.This());
+  info.GetReturnValue().Set(info.Holder());
 }
 
 Local<v8::Value> ConvenientHunk::New(void *raw) {
@@ -87,7 +87,7 @@ size_t ConvenientHunk::GetSize() {
 
 NAN_METHOD(ConvenientHunk::Size) {
   Local<v8::Value> to;
-  to = Nan::New<Number>(Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.This())->GetSize());
+  to = Nan::New<Number>(Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.Holder())->GetSize());
   info.GetReturnValue().Set(to);
 }
 
@@ -98,14 +98,14 @@ NAN_METHOD(ConvenientHunk::Lines) {
 
   LinesBaton *baton = new LinesBaton();
 
-  baton->hunk = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.This())->GetValue();
+  baton->hunk = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.Holder())->GetValue();
   baton->lines = new std::vector<git_diff_line *>;
   baton->lines->reserve(baton->hunk->numLines);
 
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[0]));
   LinesWorker *worker = new LinesWorker(baton, callback);
 
-  worker->Reference<ConvenientHunk>("hunk", info.This());
+  worker->Reference<ConvenientHunk>("hunk", info.Holder());
 
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
@@ -160,39 +160,39 @@ void ConvenientHunk::LinesWorker::HandleOKCallback() {
 
 NAN_METHOD(ConvenientHunk::OldStart) {
   Local<v8::Value> to;
-  int old_start = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.This())->GetValue()->hunk.old_start;
+  int old_start = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.Holder())->GetValue()->hunk.old_start;
   info.GetReturnValue().Set(Nan::New<Number>(old_start));
 }
 
 
 NAN_METHOD(ConvenientHunk::OldLines) {
   Local<v8::Value> to;
-  int old_lines = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.This())->GetValue()->hunk.old_lines;
+  int old_lines = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.Holder())->GetValue()->hunk.old_lines;
   info.GetReturnValue().Set(Nan::New<Number>(old_lines));
 }
 
 NAN_METHOD(ConvenientHunk::NewStart) {
   Local<v8::Value> to;
-  int new_start = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.This())->GetValue()->hunk.new_start;
+  int new_start = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.Holder())->GetValue()->hunk.new_start;
   info.GetReturnValue().Set(Nan::New<Number>(new_start));
 }
 
 NAN_METHOD(ConvenientHunk::NewLines) {
   Local<v8::Value> to;
-  int new_lines = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.This())->GetValue()->hunk.new_lines;
+  int new_lines = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.Holder())->GetValue()->hunk.new_lines;
   info.GetReturnValue().Set(Nan::New<Number>(new_lines));
 }
 
 NAN_METHOD(ConvenientHunk::HeaderLen) {
   Local<v8::Value> to;
-  size_t header_len = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.This())->GetValue()->hunk.header_len;
+  size_t header_len = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.Holder())->GetValue()->hunk.header_len;
   info.GetReturnValue().Set(Nan::New<Number>(header_len));
 }
 
 NAN_METHOD(ConvenientHunk::Header) {
   Local<v8::Value> to;
 
-  char *header = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.This())->GetValue()->hunk.header;
+  char *header = Nan::ObjectWrap::Unwrap<ConvenientHunk>(info.Holder())->GetValue()->hunk.header;
   if (header) {
     to = Nan::New<String>(header).ToLocalChecked();
   } else {
diff --git a/generate/templates/manual/src/convenient_patch.cc b/generate/templates/manual/src/convenient_patch.cc
index 22e6e6b49..771aede85 100644
--- a/generate/templates/manual/src/convenient_patch.cc
+++ b/generate/templates/manual/src/convenient_patch.cc
@@ -170,9 +170,9 @@ NAN_METHOD(ConvenientPatch::JSNewFunction) {
    }
 
   ConvenientPatch* object = new ConvenientPatch(static_cast<PatchData *>(Local<External>::Cast(info[0])->Value()));
-  object->Wrap(info.This());
+  object->Wrap(info.Holder());
 
-  info.GetReturnValue().Set(info.This());
+  info.GetReturnValue().Set(info.Holder());
 }
 
 Local<v8::Value> ConvenientPatch::New(void *raw) {
@@ -214,14 +214,14 @@ NAN_METHOD(ConvenientPatch::Hunks) {
 
   HunksBaton *baton = new HunksBaton();
 
-  baton->patch = Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetValue();
+  baton->patch = Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetValue();
   baton->hunks = new std::vector<HunkData *>;
   baton->hunks->reserve(baton->patch->numHunks);
 
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[0]));
   HunksWorker *worker = new HunksWorker(baton, callback);
 
-  worker->Reference<ConvenientPatch>("patch", info.This());
+  worker->Reference<ConvenientPatch>("patch", info.Holder());
 
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
@@ -300,7 +300,7 @@ NAN_METHOD(ConvenientPatch::LineStats) {
 
   Local<v8::Value> to;
   Local<Object> toReturn = Nan::New<Object>();
-  ConvenientLineStats stats = Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetLineStats();
+  ConvenientLineStats stats = Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetLineStats();
 
   to = Nan::New<Number>(stats.context);
   Nan::Set(toReturn, Nan::New("total_context").ToLocalChecked(), to);
@@ -315,7 +315,7 @@ NAN_METHOD(ConvenientPatch::LineStats) {
 NAN_METHOD(ConvenientPatch::Size) {
   Local<v8::Value> to;
 
-  to = Nan::New<Number>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetNumHunks());
+  to = Nan::New<Number>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetNumHunks());
 
   info.GetReturnValue().Set(to);
 }
@@ -325,7 +325,7 @@ NAN_METHOD(ConvenientPatch::OldFile) {
 
   Local<v8::Value> to;
   git_diff_file *old_file = (git_diff_file *)malloc(sizeof(git_diff_file));
-  *old_file = Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetOldFile();
+  *old_file = Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetOldFile();
 
   to = GitDiffFile::New(old_file, true);
 
@@ -337,7 +337,7 @@ NAN_METHOD(ConvenientPatch::NewFile) {
 
   Local<v8::Value> to;
   git_diff_file *new_file = (git_diff_file *)malloc(sizeof(git_diff_file));
-  *new_file = Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetNewFile();
+  *new_file = Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetNewFile();
   if (new_file != NULL) {
     to = GitDiffFile::New(new_file, true);
   } else {
@@ -349,7 +349,7 @@ NAN_METHOD(ConvenientPatch::NewFile) {
 
 NAN_METHOD(ConvenientPatch::Status) {
   Local<v8::Value> to;
-  to = Nan::New<Number>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus());
+  to = Nan::New<Number>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus());
   info.GetReturnValue().Set(to);
 }
 
@@ -357,67 +357,67 @@ NAN_METHOD(ConvenientPatch::IsUnmodified) {
   Nan::EscapableHandleScope scope;
 
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_UNMODIFIED);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_UNMODIFIED);
   info.GetReturnValue().Set(to);
 }
 
 NAN_METHOD(ConvenientPatch::IsAdded) {
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_ADDED);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_ADDED);
   info.GetReturnValue().Set(to);
 }
 
 NAN_METHOD(ConvenientPatch::IsDeleted) {
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_DELETED);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_DELETED);
   info.GetReturnValue().Set(to);
 }
 
 NAN_METHOD(ConvenientPatch::IsModified) {
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_MODIFIED);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_MODIFIED);
   info.GetReturnValue().Set(to);
 }
 
 NAN_METHOD(ConvenientPatch::IsRenamed) {
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_RENAMED);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_RENAMED);
   info.GetReturnValue().Set(to);
 }
 
 NAN_METHOD(ConvenientPatch::IsCopied) {
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_COPIED);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_COPIED);
   info.GetReturnValue().Set(to);
 }
 
 NAN_METHOD(ConvenientPatch::IsIgnored) {
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_IGNORED);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_IGNORED);
   info.GetReturnValue().Set(to);
 }
 
 NAN_METHOD(ConvenientPatch::IsUntracked) {
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_UNTRACKED);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_UNTRACKED);
   info.GetReturnValue().Set(to);
 }
 
 NAN_METHOD(ConvenientPatch::IsTypeChange) {
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_TYPECHANGE);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_TYPECHANGE);
   info.GetReturnValue().Set(to);
 }
 
 NAN_METHOD(ConvenientPatch::IsUnreadable) {
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_UNREADABLE);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_UNREADABLE);
   info.GetReturnValue().Set(to);
 }
 
 NAN_METHOD(ConvenientPatch::IsConflicted) {
   Local<v8::Value> to;
-  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.This())->GetStatus() == GIT_DELTA_CONFLICTED);
+  to = Nan::New<Boolean>(Nan::ObjectWrap::Unwrap<ConvenientPatch>(info.Holder())->GetStatus() == GIT_DELTA_CONFLICTED);
   info.GetReturnValue().Set(to);
 }
 
diff --git a/generate/templates/manual/src/nodegit_wrapper.cc b/generate/templates/manual/src/nodegit_wrapper.cc
index a790d7bc3..b687a200e 100644
--- a/generate/templates/manual/src/nodegit_wrapper.cc
+++ b/generate/templates/manual/src/nodegit_wrapper.cc
@@ -79,8 +79,8 @@ NAN_METHOD(NodeGitWrapper<Traits>::JSNewFunction) {
     );
   }
 
-  instance->Wrap(info.This());
-  info.GetReturnValue().Set(info.This());
+  instance->Wrap(info.Holder());
+  info.GetReturnValue().Set(info.Holder());
 }
 
 template<typename Traits>
diff --git a/generate/templates/manual/src/promise_completion.cc b/generate/templates/manual/src/promise_completion.cc
index d3e4f4426..75d7c483b 100644
--- a/generate/templates/manual/src/promise_completion.cc
+++ b/generate/templates/manual/src/promise_completion.cc
@@ -57,8 +57,8 @@ bool PromiseCompletion::ForwardIfPromise(v8::Local<v8::Value> result, nodegit::A
 // creates a new instance of PromiseCompletion, wrapped in a v8 object
 NAN_METHOD(PromiseCompletion::New) {
   PromiseCompletion *promiseCompletion = new PromiseCompletion();
-  promiseCompletion->Wrap(info.This());
-  info.GetReturnValue().Set(info.This());
+  promiseCompletion->Wrap(info.Holder());
+  info.GetReturnValue().Set(info.Holder());
 }
 
 // sets up a Promise to forward the promise result via the baton and callback
@@ -107,7 +107,7 @@ void PromiseCompletion::CallCallback(bool isFulfilled, const Nan::FunctionCallba
     resultOfPromise = info[0];
   }
 
-  PromiseCompletion *promiseCompletion = ObjectWrap::Unwrap<PromiseCompletion>(Nan::To<v8::Object>(info.This()).ToLocalChecked());
+  PromiseCompletion *promiseCompletion = ObjectWrap::Unwrap<PromiseCompletion>(Nan::To<v8::Object>(info.Holder()).ToLocalChecked());
 
   (*promiseCompletion->callback)(isFulfilled, promiseCompletion->baton, resultOfPromise);
 }
diff --git a/generate/templates/manual/src/str_array_converter.cc b/generate/templates/manual/src/str_array_converter.cc
index 732f16cf2..5d04c6562 100644
--- a/generate/templates/manual/src/str_array_converter.cc
+++ b/generate/templates/manual/src/str_array_converter.cc
@@ -65,7 +65,7 @@ git_strarray *StrArrayConverter::ConstructStrArray(int argc, char** argv) {
 
 void StrArrayConverter::ConvertInto(git_strarray *out, v8::Local<v8::Array> val) {
   out->count = val->Length();
-  out->strings = new char *[out->count];
+  out->strings = (char**) malloc(out->count * sizeof(char*));
   for (uint32_t i = 0; i < out->count; ++i) {
     Nan::Utf8String utf8String(Nan::Get(val, i).ToLocalChecked().As<v8::String>());
     out->strings[i] = strdup(*utf8String);
@@ -75,6 +75,6 @@ void StrArrayConverter::ConvertInto(git_strarray *out, v8::Local<v8::Array> val)
 void StrArrayConverter::ConvertInto(git_strarray *out, v8::Local<v8::String> val) {
   Nan::Utf8String utf8String(val);
   out->count = 1;
-  out->strings = new char *[1];
+  out->strings = (char**) malloc(out->count * sizeof(char*));
   out->strings[0] = strdup(*utf8String);
 }
diff --git a/generate/templates/manual/src/thread_pool.cc b/generate/templates/manual/src/thread_pool.cc
index 4cd5c095a..0aacdf280 100644
--- a/generate/templates/manual/src/thread_pool.cc
+++ b/generate/templates/manual/src/thread_pool.cc
@@ -657,9 +657,6 @@ namespace nodegit {
 
   // NOTE this should theoretically never be triggered during a cleanup operation
   void ThreadPoolImpl::RunLoopCallbacks() {
-    Nan::HandleScope scope;
-    v8::Local<v8::Context> context = Nan::GetCurrentContext();
-    node::CallbackScope callbackScope(context->GetIsolate(), Nan::New<v8::Object>(), {0, 0});
 
     std::unique_lock<std::mutex> lock(*jsThreadCallbackMutex);
     // get the next callback to run
@@ -719,10 +716,6 @@ namespace nodegit {
       orchestratorJobCondition.notify_all();
     }
 
-    Nan::HandleScope scope;
-    v8::Local<v8::Context> context = Nan::GetCurrentContext();
-    node::CallbackScope callbackScope(context->GetIsolate(), Nan::New<v8::Object>(), {0, 0});
-
     while (cancelledJobs.size()) {
       std::shared_ptr<Orchestrator::Job> cancelledJob = cancelledJobs.front();
       std::shared_ptr<Orchestrator::AsyncWorkJob> asyncWorkJob = std::static_pointer_cast<Orchestrator::AsyncWorkJob>(cancelledJob);
diff --git a/generate/templates/manual/src/wrapper.cc b/generate/templates/manual/src/wrapper.cc
index 3bad23c7d..377482ca0 100644
--- a/generate/templates/manual/src/wrapper.cc
+++ b/generate/templates/manual/src/wrapper.cc
@@ -39,9 +39,9 @@ NAN_METHOD(Wrapper::JSNewFunction) {
   }
 
   Wrapper* object = new Wrapper(External::Cast(*info[0])->Value());
-  object->Wrap(info.This());
+  object->Wrap(info.Holder());
 
-  info.GetReturnValue().Set(info.This());
+  info.GetReturnValue().Set(info.Holder());
 }
 
 Local<v8::Value> Wrapper::New(const void *raw) {
@@ -74,7 +74,7 @@ NAN_METHOD(Wrapper::ToBuffer) {
   Local<v8::Value> constructorArgs[1] = { Nan::New(len) };
   Local<Object> nodeBuffer = Nan::NewInstance(bufferConstructor, 1, constructorArgs).ToLocalChecked();
 
-  std::memcpy(node::Buffer::Data(nodeBuffer), Nan::ObjectWrap::Unwrap<Wrapper>(info.This())->GetValue(), len);
+  std::memcpy(node::Buffer::Data(nodeBuffer), Nan::ObjectWrap::Unwrap<Wrapper>(info.Holder())->GetValue(), len);
 
   info.GetReturnValue().Set(nodeBuffer);
 }
diff --git a/generate/templates/manual/tree/get_all_filepaths.cc b/generate/templates/manual/tree/get_all_filepaths.cc
index 758383980..839589e0c 100644
--- a/generate/templates/manual/tree/get_all_filepaths.cc
+++ b/generate/templates/manual/tree/get_all_filepaths.cc
@@ -43,14 +43,14 @@ NAN_METHOD(GitTree::GetAllFilepaths)
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
-  baton->tree = Nan::ObjectWrap::Unwrap<GitTree>(info.This())->GetValue();
+  baton->tree = Nan::ObjectWrap::Unwrap<GitTree>(info.Holder())->GetValue();
   baton->out = new std::vector<std::string>;
   baton->repo = git_tree_owner(baton->tree);
 
   Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
   std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
   GetAllFilepathsWorker *worker = new GetAllFilepathsWorker(baton, callback, cleanupHandles);
-  worker->Reference<GitTree>("tree", info.This());
+  worker->Reference<GitTree>("tree", info.Holder());
   nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
   nodegitContext->QueueWorker(worker);
 
diff --git a/generate/templates/partials/async_function.cc b/generate/templates/partials/async_function.cc
index a294043fa..deb37abf2 100644
--- a/generate/templates/partials/async_function.cc
+++ b/generate/templates/partials/async_function.cc
@@ -23,7 +23,7 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
   {%each args|argsInfo as arg %}
     {%if not arg.isReturn %}
       {%if arg.isSelf %}
-        baton->{{ arg.name }} = Nan::ObjectWrap::Unwrap<{{ arg.cppClassName }}>(info.This())->GetValue();
+        baton->{{ arg.name }} = Nan::ObjectWrap::Unwrap<{{ arg.cppClassName }}>(info.Holder())->GetValue();
       {%elsif arg.isCallbackFunction %}
         if (!info[{{ arg.jsArg }}]->IsFunction()) {
           baton->{{ arg.name }} = NULL;
@@ -56,7 +56,7 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
         {% if arg.cppClassName == 'Array' %}
           {
             v8::Local<v8::Array> tempArray = v8::Local<v8::Array>::Cast(info[{{ arg.jsArg }}]);
-            baton->{{ arg.name }} = new {{ arg.cType|unPointer }}[tempArray->Length()];
+            baton->{{ arg.name }} = ({{ arg.cType|unPointer }}*)malloc(sizeof({{ arg.cType|unPointer }}) * tempArray->Length());
             for (uint32_t i = 0; i < tempArray->Length(); ++i) {
               auto conversionResult = Configurable{{ arg.arrayElementCppClassName }}::fromJavascript(
                 nodegitContext,
@@ -64,12 +64,13 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
               );
 
               if (!conversionResult.result) {
-                delete[] baton->{{ arg.name }};
+                // TODO free previously allocated memory
+                free(baton->{{ arg.name }});
                 return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
               }
 
               auto convertedObject = conversionResult.result;
-              cleanupHandles["{{ arg.name }}"] = convertedObject;
+              cleanupHandles[std::string("{{ arg.name }}") + std::to_string(i)] = convertedObject;
               baton->{{ arg.name }}[i] = *convertedObject->GetValue();
             }
           }
@@ -109,7 +110,7 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
   {%each args|argsInfo as arg %}
     {%if not arg.isReturn %}
       {%if arg.isSelf %}
-        worker->Reference<{{ arg.cppClassName }}>("{{ arg.name }}", info.This());
+        worker->Reference<{{ arg.cppClassName }}>("{{ arg.name }}", info.Holder());
       {%elsif not arg.isCallbackFunction %}
         {%if  arg.isUnwrappable %}
           {% if arg.cppClassName == "Array" %}
diff --git a/generate/templates/partials/convert_to_v8.cc b/generate/templates/partials/convert_to_v8.cc
index ccba9b330..f24f86ecb 100644
--- a/generate/templates/partials/convert_to_v8.cc
+++ b/generate/templates/partials/convert_to_v8.cc
@@ -102,7 +102,7 @@
       {%if isAsync %}
       {% elsif ownedByThis %}
         {%-- If the owner of this object is "this", it will be retrievable from the info object in a sync method. --%}
-        Nan::Set(owners, owners->Length(), info.This());
+        Nan::Set(owners, owners->Length(), info.Holder());
       {% endif %}
       {% if ownerFn | toBool %}
         Nan::Set(
diff --git a/generate/templates/partials/field_accessors.cc b/generate/templates/partials/field_accessors.cc
index bcd5e5f87..26d454636 100644
--- a/generate/templates/partials/field_accessors.cc
+++ b/generate/templates/partials/field_accessors.cc
@@ -2,7 +2,7 @@
   {% if not field.ignore %}
     NAN_GETTER({{ cppClassName }}::Get{{ field.cppFunctionName }}) {
 
-      {{ cppClassName }} *wrapper = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This());
+      {{ cppClassName }} *wrapper = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.Holder());
 
       {% if field.isEnum %}
         info.GetReturnValue().Set(Nan::New((int)wrapper->GetValue()->{{ field.name }}));
@@ -24,7 +24,7 @@
     }
 
     NAN_SETTER({{ cppClassName }}::Set{{ field.cppFunctionName }}) {
-      {{ cppClassName }} *wrapper = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This());
+      {{ cppClassName }} *wrapper = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.Holder());
 
       {% if field.isEnum %}
         if (value->IsNumber()) {
diff --git a/generate/templates/partials/fields.cc b/generate/templates/partials/fields.cc
index d9478549e..31b035daa 100644
--- a/generate/templates/partials/fields.cc
+++ b/generate/templates/partials/fields.cc
@@ -5,7 +5,7 @@
       v8::Local<v8::Value> v8ConversionSlot;
 
       {% if field | isFixedLengthString %}
-      char* {{ field.name }} = (char *)Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This())->GetValue()->{{ field.name }};
+      char* {{ field.name }} = (char *)Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.Holder())->GetValue()->{{ field.name }};
       {% else %}
         {% if field.cType|isArrayType %}
           {{ field.cType|arrayTypeToPlainType }} *{{ field.name }} =
@@ -21,7 +21,7 @@
             {% endif %}
           {% endif %}
         {% endif %}
-        Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This())->GetValue()->{{ field.name }};
+        Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.Holder())->GetValue()->{{ field.name }};
       {% endif %}
 
       {% partial convertToV8 field %}
diff --git a/generate/templates/partials/sync_function.cc b/generate/templates/partials/sync_function.cc
index cf6febe67..9ace65b3b 100644
--- a/generate/templates/partials/sync_function.cc
+++ b/generate/templates/partials/sync_function.cc
@@ -18,7 +18,7 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
         {%partial convertFromV8 arg %}
         {%if arg.saveArg %}
           v8::Local<Object> {{ arg.name }}(Nan::To<v8::Object>(info[{{ arg.jsArg }}]).ToLocalChecked());
-          {{ cppClassName }} *thisObj = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This());
+          {{ cppClassName }} *thisObj = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.Holder());
 
           thisObj->{{ cppFunctionName }}_{{ arg.name }}.Reset({{ arg.name }});
         {%endif%}
@@ -28,7 +28,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 (Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This())->GetValue() != NULL) {
+    if (Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.Holder())->GetValue() != NULL) {
   {%endif%}
 
   git_error_clear();
@@ -41,7 +41,7 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
           {%if not arg.isReturn%}
             ,
             {%if arg.isSelf %}
-              Nan::ObjectWrap::Unwrap<{{ arg.cppClassName }}>(info.This())->GetValue()
+              Nan::ObjectWrap::Unwrap<{{ arg.cppClassName }}>(info.Holder())->GetValue()
             {%else%}
               from_{{ arg.name }}
             {%endif%}
@@ -57,7 +57,7 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
           {%if not arg.shouldAlloc %}&{%endif%}
         {%endif%}
         {%if arg.isSelf %}
-          Nan::ObjectWrap::Unwrap<{{ arg.cppClassName }}>(info.This())->GetValue()
+          Nan::ObjectWrap::Unwrap<{{ arg.cppClassName }}>(info.Holder())->GetValue()
         {%elsif arg.isReturn %}
           {{ arg.name }}
         {%else%}
@@ -88,7 +88,7 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
     {%endif%}
 
     {%if cppFunctionName == "Free" %}
-        Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This())->ClearValue();
+        Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.Holder())->ClearValue();
       } // lock master scope end
     {%endif%}
 
diff --git a/generate/templates/templates/nodegit.cc b/generate/templates/templates/nodegit.cc
index e43f8b2ae..afcfac228 100644
--- a/generate/templates/templates/nodegit.cc
+++ b/generate/templates/templates/nodegit.cc
@@ -101,9 +101,7 @@ NAN_MODULE_INIT(init) {
     , Nan::GetFunction(Nan::New<v8::FunctionTemplate>(GetNumberOfTrackedObjects)).ToLocalChecked()
   );
 
-  Nan::HandleScope scope;
-  Local<Context> context = Nan::GetCurrentContext();
-  Isolate *isolate = context->GetIsolate();
+  Isolate *isolate = v8::Isolate::GetCurrent();
   nodegit::Context *nodegitContext = new nodegit::Context(isolate);
 
   Wrapper::InitializeComponent(target, nodegitContext);
diff --git a/generate/templates/templates/struct_content.cc b/generate/templates/templates/struct_content.cc
index e2f01ca58..b3a910a40 100644
--- a/generate/templates/templates/struct_content.cc
+++ b/generate/templates/templates/struct_content.cc
@@ -118,10 +118,10 @@ Configurable{{ cppClassName }}::Configurable{{ cppClassName }}(nodegit::Context
   : nodegit::ConfigurableClassWrapper<{{ cppClassName }}Traits>(nodegitContext)
 {
   {% if ignoreInit == true %}
-    this->raw = new {{ cType }};
+    this->raw = ({{ cType }}*) malloc(sizeof({{ cType }}));
   {% else %}
     {{ cType }}{% if isExtendedStruct %}_extended{% endif %} wrappedValue = {{ cType|upper }}_INIT;
-    this->raw = ({{ cType }}*) malloc(sizeof({{ cType }}{% if isExtendedStruct %}_extended{% endif %}));
+    this->raw = ({{ cType }}*) new {{ cType }}{% if isExtendedStruct %}_extended{% endif %};
     memcpy(this->raw, &wrappedValue, sizeof({{ cType }}{% if isExtendedStruct %}_extended{% endif %}));
   {% endif %}
 }
@@ -132,12 +132,12 @@ Configurable{{ cppClassName }}::~Configurable{{ cppClassName }}() {
       {% if field.cppClassName == 'GitStrarray' %}
         if (this->raw->{{ field.name }}.count) {
           for (size_t i = 0; i < this->raw->{{ field.name }}.count; ++i) {
-            delete this->raw->{{ field.name }}.strings[i];
+            free(this->raw->{{ field.name }}.strings[i]);
           }
-          delete[] this->raw->{{ field.name }}.strings;
+          free(this->raw->{{ field.name }}.strings);
         }
       {% elsif field.cppClassName == 'String' %}
-        delete this->raw->{{ field.name }};
+        free((void*)this->raw->{{ field.name }});
       {% endif %}
     {% endif %}
   {% endeach %}