diff --git a/generate/input/callbacks.json b/generate/input/callbacks.json
@@ -455,7 +455,7 @@
     ],
     "return": {
       "type": "int",
-      "noResults": 1,
+      "noResults": 0,
       "success": 0,
       "error": -1
     }
@@ -495,7 +495,7 @@
     ],
     "return": {
       "type": "int",
-      "noResults": 1,
+      "noResults": 0,
       "success": 0,
       "error": -1
     }

diff --git a/generate/scripts/helpers.js b/generate/scripts/helpers.js
@@ -121,6 +121,7 @@ var Helpers = {
   processPayload: function(field, allFields) {
     if (field.name === "payload") {
       field.payloadFor = "*";
+      field.globalPayload = true;
       field.isOptional = true;
     }
     else {
@@ -302,6 +303,11 @@ var Helpers = {
     var argOverrides = fnOverrides.args || {};
     fnDef.args.forEach(function(arg) {
       Helpers.decorateArg(arg, fnDef.args, typeDef, fnDef, argOverrides[arg.name] || {}, enums);
+
+      // if a function has any callbacks then it MUST be async
+      if (arg.isCallbackFunction) {
+        fnDef.isAsync = true;
+      }
     });
 
     if (fnDef.return) {

diff --git a/generate/templates/filters/returns_info.js b/generate/templates/filters/returns_info.js
@@ -14,12 +14,12 @@ module.exports = function(fn, argReturnsOnly, isAsync) {
     return_info.parsedClassName = (return_info.cppClassName || '').toLowerCase() + "_t";
     return_info.returnNameOrName = return_info.returnName || return_info.name;
     return_info.jsOrCppClassName = return_info.jsClassName || return_info.cppClassName;
+    return_info.isOutParam = true;
 
     result.push(return_info);
   });
 
   if (!result.length
-      && !fn.isCallbackFunction
       && !argReturnsOnly
       && fn.return
       && !fn.return.isErrorCode

diff --git a/generate/templates/manual/src/str_array_converter.cc b/generate/templates/manual/src/str_array_converter.cc
@@ -30,7 +30,7 @@ git_strarray *StrArrayConverter::ConvertArray(Array *val) {
   git_strarray *result;
 
   for(int i = 0; i < count; i++) {
-    NanUtf8String entry(val->CloneElementAt(i));
+    NanUtf8String entry(val->Get(i));
     strings[i] = *entry;
   }
 

diff --git a/generate/templates/partials/async_function.cc b/generate/templates/partials/async_function.cc
@@ -12,21 +12,37 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+  {%each args|argsInfo as arg %}
+    {%if arg.globalPayload %}
+  {{ cppFunctionName }}_globalPayload* globalPayload = new {{ cppFunctionName }}_globalPayload;
+    {%endif%}
+  {%endeach%}
+
   {%each args|argsInfo as arg %}
     {%if not arg.isReturn %}
       {%if arg.isSelf %}
   baton->{{ arg.name }} = ObjectWrap::Unwrap<{{ arg.cppClassName }}>(args.This())->GetValue();
       {%elsif arg.isCallbackFunction %}
   if (!args[{{ arg.jsArg }}]->IsFunction()) {
     baton->{{ arg.name }} = NULL;
+        {%if arg.payload.globalPayload %}
+    globalPayload->{{ arg.name }} = NULL;
+        {%else%}
     baton->{{ arg.payload.name }} = NULL;
+        {%endif%}
   }
   else {
     baton->{{ arg.name}} = {{ cppFunctionName }}_{{ arg.name }}_cppCallback;
+        {%if arg.payload.globalPayload %}
+    globalPayload->{{ arg.name }} = new NanCallback(args[{{ arg.jsArg }}].As<Function>());
+        {%else%}
     baton->{{ arg.payload.name }} = new NanCallback(args[{{ arg.jsArg }}].As<Function>());
+        {%endif%}
   }
       {%elsif arg.payloadFor %}
-        {%-- payloads are ignored --%}
+        {%if arg.globalPayload %}
+  baton->{{ arg.name }} = globalPayload;
+        {%endif%}
       {%elsif arg.name %}
   {%partial convertFromV8 arg%}
         {%if not arg.payloadFor %}
@@ -134,7 +150,11 @@ void {{ cppClassName }}::{{ cppFunctionName }}Worker::HandleOKCallback() {
       free((void*)baton->{{ arg.name }});
     }
         {%elsif arg.isCallbackFunction %}
+          {%if not arg.payload.globalPayload %}
     delete baton->{{ arg.payload.name }};
+          {%endif%}
+        {%elsif arg.globalPayload %}
+    delete ({{ cppFunctionName}}_globalPayload*)baton->{{ arg.name }};
         {%else%}
     free((void*)baton->{{ arg.name }});
         {%endif%}
@@ -159,7 +179,11 @@ void {{ cppClassName }}::{{ cppFunctionName }}Worker::HandleOKCallback() {
     free((void *)baton->{{ arg.name }});
   }
     {%elsif arg.isCallbackFunction %}
-  delete (NanCallback *)baton->{{ arg.payload.name }};
+      {%if not arg.payload.globalPayload %}
+  delete baton->{{ arg.payload.name }};
+      {%endif%}
+    {%elsif arg.globalPayload %}
+  delete ({{ cppFunctionName}}_globalPayload*)baton->{{ arg.name }};
     {%endif%}
   {%endeach%}
 

diff --git a/generate/templates/partials/callback_helpers.cc b/generate/templates/partials/callback_helpers.cc
@@ -22,8 +22,10 @@
     this_thread::sleep_for(chrono::milliseconds(1));
   }
 
-  {% each cbFunction|returnsInfo true false as _return %}
+  {% each cbFunction|returnsInfo false true as _return %}
+    {% if _return.isOutParam %}
     *{{ _return.name }} = *baton->{{ _return.name }};
+    {% endif %}
   {% endeach %}
 
   return baton->result;
@@ -42,7 +44,11 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_asyncAfter(
 
   {% each cbFunction.args|argsInfo as arg %}
     {% if arg | isPayload %}
+      {% if cbFunction.payload.globalPayload %}
+  NanCallback* callback = (({{ cppFunctionName }}_globalPayload*)baton->{{ arg.name }})->{{ cbFunction.name }};
+      {% else %}
   NanCallback* callback = (NanCallback *)baton->{{ arg.name }};
+      {% endif %}
     {% endif %}
   {% endeach %}
 
@@ -84,18 +90,25 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_asyncAfter(
     }
   }
 
-  {{ cbFunction.return.type }} resultStatus;
-
-  {% each cbFunction|returnsInfo true false as _return %}
+  {% each cbFunction|returnsInfo false true as _return %}
     if (result.IsEmpty() || result->IsNativeError()) {
       baton->result = {{ cbFunction.return.error }};
     }
     else if (!result->IsNull() && !result->IsUndefined()) {
+      {% if _return.isOutParam %}
       {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
       wrapper->selfFreeing = false;
 
       baton->{{ _return.name }} = wrapper->GetRefValue();
       baton->result = {{ cbFunction.return.success }};
+      {% else %}
+      if (result->IsNumber()) {
+        baton->result = (int)result->ToNumber()->Value();
+      }
+      else {
+        baton->result = {{ cbFunction.return.noResults }};
+      }
+      {% endif %}
     }
     else {
       baton->result = {{ cbFunction.return.noResults }};
@@ -124,18 +137,26 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_asyncPromis
   if (isFulfilled->Value()) {
     NanCallback* resultFn = new NanCallback(promise->Get(NanNew("value")).As<Function>());
     Handle<v8::Value> result = resultFn->Call(0, argv);
-    {{ cbFunction.return.type }} resultStatus;
 
-    {% each cbFunction|returnsInfo true false as _return %}
+    {% each cbFunction|returnsInfo false true as _return %}
       if (result.IsEmpty() || result->IsNativeError()) {
         baton->result = {{ cbFunction.return.error }};
       }
       else if (!result->IsNull() && !result->IsUndefined()) {
+        {% if _return.isOutParam %}
         {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
         wrapper->selfFreeing = false;
 
         baton->{{ _return.name }} = wrapper->GetRefValue();
         baton->result = {{ cbFunction.return.success }};
+        {% else %}
+        if (result->IsNumber()) {
+          baton->result = (int)result->ToNumber()->Value();
+        }
+        else {
+          baton->result = {{ cbFunction.return.noResults }};
+        }
+        {% endif %}
       }
       else {
         baton->result = {{ cbFunction.return.noResults }};

diff --git a/generate/templates/partials/field_accessors.cc b/generate/templates/partials/field_accessors.cc
@@ -42,6 +42,10 @@
         wrapper->raw->{{ field.name }} = {% if not field.cType | isPointer %}*{% endif %}ObjectWrap::Unwrap<{{ field.cppClassName }}>(value->ToObject())->GetValue();
 
       {% elsif field.isCallbackFunction %}
+        if (wrapper->{{ field.name }} != NULL) {
+          delete wrapper->{{ field.name }};
+        }
+
         if (value->IsFunction()) {
           if (!wrapper->raw->{{ field.name }}) {
             wrapper->raw->{{ field.name }} = ({{ field.cType }}){{ field.name }}_cppCallback;
@@ -94,8 +98,10 @@
           this_thread::sleep_for(chrono::milliseconds(1));
         }
 
-        {% each field|returnsInfo true false as _return %}
+        {% each field|returnsInfo false true as _return %}
+          {% if _return.isOutParam %}
           *{{ _return.name }} = *baton->{{ _return.name }};
+          {% endif %}
         {% endeach %}
 
         return baton->result;
@@ -173,18 +179,25 @@
           }
         }
 
-        {{ field.return.type }} resultStatus;
-
-        {% each field|returnsInfo true false as _return %}
+        {% each field|returnsInfo false true as _return %}
           if (result.IsEmpty() || result->IsNativeError()) {
             baton->result = {{ field.return.error }};
           }
           else if (!result->IsNull() && !result->IsUndefined()) {
+            {% if _return.isOutParam %}
             {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
             wrapper->selfFreeing = false;
 
             baton->{{ _return.name }} = wrapper->GetRefValue();
             baton->result = {{ field.return.success }};
+            {% else %}
+            if (result->IsNumber()) {
+              baton->result = (int)result->ToNumber()->Value();
+            }
+            else {
+              baton->result = {{ field.return.noResults }};
+            }
+            {% endif %}
           }
           else {
             baton->result = {{ field.return.noResults }};
@@ -213,18 +226,26 @@
         if (isFulfilled->Value()) {
           NanCallback* resultFn = new NanCallback(promise->Get(NanNew("value")).As<Function>());
           Handle<v8::Value> result = resultFn->Call(0, argv);
-          {{ field.return.type }} resultStatus;
 
-          {% each field|returnsInfo true false as _return %}
+          {% each field|returnsInfo false true as _return %}
             if (result.IsEmpty() || result->IsNativeError()) {
               baton->result = {{ field.return.error }};
             }
             else if (!result->IsNull() && !result->IsUndefined()) {
+              {% if _return.isOutParam %}
               {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject());
               wrapper->selfFreeing = false;
 
               baton->{{ _return.name }} = wrapper->GetRefValue();
               baton->result = {{ field.return.success }};
+              {% else %}
+              if (result->IsNumber()) {
+                baton->result = (int)result->ToNumber()->Value();
+              }
+              else{
+                baton->result = {{ field.return.noResults }};
+              }
+              {% endif %}
             }
             else {
               baton->result = {{ field.return.noResults }};

diff --git a/generate/templates/partials/sync_function.cc b/generate/templates/partials/sync_function.cc
@@ -15,27 +15,20 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
   {%each args|argsInfo as arg %}
     {%if not arg.isSelf %}
       {%if not arg.isReturn %}
-        {%if not arg.isCallbackFunction %}
-          {%if not arg.payloadFor %}
-            {%partial convertFromV8 arg %}
-            {%if arg.saveArg %}
+        {%partial convertFromV8 arg %}
+        {%if arg.saveArg %}
   Handle<Object> {{ arg.name }}(args[{{ arg.jsArg }}]->ToObject());
   {{ cppClassName }} *thisObj = ObjectWrap::Unwrap<{{ cppClassName }}>(args.This());
 
   NanDisposePersistent(thisObj->{{ cppFunctionName }}_{{ arg.name }});
 
   NanAssignPersistent(thisObj->{{ cppFunctionName }}_{{ arg.name }}, {{ arg.name }});
-            {%endif%}
-          {%endif%}
         {%endif%}
       {%endif%}
     {%endif%}
   {%endeach%}
 
 {%each args|argsInfo as arg %}
-  {%if arg.isCallbackFunction %}
-NanCallback* {{ arg.name }}_callback = new NanCallback(args[{{ arg.jsArg }}].As<Function>());
-  {%endif%}
 {%endeach%}
 {%if .|hasReturns %}
   {{ return.cType }} result = {%endif%}{{ cFunctionName }}(
@@ -47,24 +40,13 @@ NanCallback* {{ arg.name }}_callback = new NanCallback(args[{{ arg.jsArg }}].As<
 ObjectWrap::Unwrap<{{ arg.cppClassName }}>(args.This())->GetValue()
     {%elsif arg.isReturn %}
 {{ arg.name }}
-    {%elsif arg.isCallbackFunction %}
-{{ cppFunctionName }}_{{ arg.name }}_cppCallback,
-{{ arg.name }}_callback
-    {%elsif arg.payloadFor %}
-{%-- payloads are handled inside of the callback condition --%}
     {%else%}
 from_{{ arg.name }}
     {%endif%}
     {%if not arg.lastArg %},{%endif%}
   {%endeach%}
   );
 
-{%each args|argsInfo as arg %}
-  {%if arg.isCallbackFunction %}
-delete {{ arg.name }}_callback;
-  {%endif%}
-{%endeach%}
-
 {%if return.isErrorCode %}
   if (result != GIT_OK) {
   {%each args|argsInfo as arg %}
@@ -120,5 +102,3 @@ delete {{ arg.name }}_callback;
   {%endif%}
 {%endif%}
 }
-
-{%partial callbackHelpers .%}
diff --git a/generate/templates/templates/class_header.h b/generate/templates/templates/class_header.h
@@ -135,17 +135,43 @@ class {{ cppClassName }} : public ObjectWrap {
     };
         {%endif%}
 
-        {%each function.args as arg %}
-          {%if arg.payloadFor %}
-
-    Persistent<Value> {{ function.cppFunctionName }}_{{ arg.name }};
-          {%endif%}
-        {%endeach%}
-
     static NAN_METHOD({{ function.cppFunctionName }});
       {%endif%}
     {%endeach%}
 
+    {%each functions as function%}
+      {%each function.args as arg %}
+        {% if arg.globalPayload %}
+
+    struct {{ function.cppFunctionName }}_globalPayload {
+          {%each function.args as arg %}
+            {%if arg.isCallbackFunction %}
+      NanCallback * {{ arg.name }};
+            {%endif%}
+          {%endeach%}
+
+      {{ function.cppFunctionName }}_globalPayload() {
+          {%each function.args as arg %}
+            {%if arg.isCallbackFunction %}
+        {{ arg.name }} = NULL;
+            {%endif%}
+          {%endeach%}
+      }
+
+      ~{{ function.cppFunctionName }}_globalPayload() {
+          {%each function.args as arg %}
+            {%if arg.isCallbackFunction %}
+        if ({{ arg.name }} != NULL) {
+          delete {{ arg.name }};
+        }
+            {%endif%}
+          {%endeach%}
+      }
+    };
+        {%endif%}
+      {%endeach%}
+    {%endeach%}
+
     {%if cType%}
     {{ cType }} *raw;
     {%endif%}