diff --git a/generate/input/callbacks.json b/generate/input/callbacks.json
@@ -96,7 +96,8 @@
       "type": "int",
       "noResults": 1,
       "success": 0,
-      "error": -1
+      "error": -1,
+      "throttle": 100
     }
   },
   "git_checkout_perfdata_cb": {
@@ -207,7 +208,8 @@
       "type": "int",
       "noResults": 1,
       "success": 0,
-      "error": -1
+      "error": -1,
+      "throttle": 100
     }
   },
   "git_diff_hunk_cb": {
@@ -560,7 +562,8 @@
       "type": "int",
       "noResults":0,
       "success": 0,
-      "error": -1
+      "error": -1,
+      "throttle": 100
     }
   },
   "git_stash_cb": {
@@ -670,7 +673,8 @@
       "type": "int",
       "noResults": 0,
       "success": 0,
-      "error": -1
+      "error": -1,
+      "throttle": 100
     }
   },
   "git_transport_cb": {

diff --git a/generate/templates/manual/include/async_baton.h b/generate/templates/manual/include/async_baton.h
@@ -4,6 +4,9 @@
 #include <uv.h>
 #include <nan.h>
 
+#include "lock_master.h"
+#include "functions/sleep_for_ms.h"
+
 // Base class for Batons used for callbacks (for example,
 // JS functions passed as callback parameters,
 // or field properties of configuration objects whose values are callbacks)
@@ -13,4 +16,33 @@ struct AsyncBaton {
   bool done;
 };
 
+template<typename ResultT>
+struct AsyncBatonWithResult : public AsyncBaton {
+  ResultT result;
+  ResultT defaultResult; // result returned if the callback doesn't return anything valid
+
+  AsyncBatonWithResult(const ResultT &defaultResult)
+    : defaultResult(defaultResult) {
+  }
+
+  ResultT ExecuteAsync(uv_async_cb asyncCallback) {
+    result = 0;
+    req.data = this;
+    done = false;
+
+    uv_async_init(uv_default_loop(), &req, asyncCallback);
+    {
+      LockMaster::TemporaryUnlock temporaryUnlock;
+
+      uv_async_send(&req);
+
+      while(!done) {
+        sleep_for_ms(1);
+      }
+    }
+
+    return result;
+  }
+};
+
 #endif
diff --git a/generate/templates/manual/include/callback_wrapper.h b/generate/templates/manual/include/callback_wrapper.h
@@ -1,17 +1,60 @@
 #ifndef CALLBACK_WRAPPER_H
 #define CALLBACK_WRAPPER_H
 
-#include <v8.h>
-#include <node.h>
-
-#include "nan.h"
+#include <nan.h>
+#include <uv.h>
 
 using namespace v8;
 using namespace node;
 
-struct CallbackWrapper {
+class CallbackWrapper {
   Nan::Callback* jsCallback;
-  void * payload;
+
+  // throttling data, used for callbacks that need to be throttled
+  int throttle; // in milliseconds - if > 0, calls to the JS callback will be throttled
+  uint64_t lastCallTime;
+
+public:
+  CallbackWrapper() {
+    jsCallback = NULL;
+    lastCallTime = 0;
+    throttle = 0;
+  }
+
+  ~CallbackWrapper() {
+    SetCallback(NULL);
+  }
+
+  bool HasCallback() {
+    return jsCallback != NULL;
+  }
+
+  Nan::Callback* GetCallback() {
+    return jsCallback;
+  }
+
+  void SetCallback(Nan::Callback* callback, int throttle = 0) {
+    if(jsCallback) {
+      delete jsCallback;
+    }
+    jsCallback = callback;
+    this->throttle = throttle;
+  }
+
+  bool WillBeThrottled() {
+    if(!throttle) {
+      return false;
+    }
+    // throttle if needed
+    uint64_t now = uv_hrtime();
+    if(lastCallTime > 0 && now < lastCallTime + throttle * 1000000) {
+      // throttled
+      return true;
+    } else {
+      lastCallTime = now;
+      return false;
+    }
+  }
 };
 
 #endif
diff --git a/generate/templates/manual/include/lock_master.h b/generate/templates/manual/include/lock_master.h
@@ -1,6 +1,8 @@
 #ifndef LOCK_MASTER_H
 #define LOCK_MASTER_H
 
+#include <git2.h>
+
 class LockMasterImpl;
 
 class LockMaster {

diff --git a/generate/templates/partials/callback_helpers.cc b/generate/templates/partials/callback_helpers.cc
@@ -6,28 +6,14 @@
     {{ arg.cType }} {{ arg.name}}{% if not arg.lastArg %},{% endif %}
   {% endeach %}
 ) {
-  {{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton* baton = new {{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton();
+  {{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton* baton =
+    new {{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton({{ cbFunction.return.noResults }});
 
   {% each cbFunction.args|argsInfo as arg %}
     baton->{{ arg.name }} = {{ arg.name }};
   {% endeach %}
 
-  baton->result = 0;
-  baton->req.data = baton;
-  baton->done = false;
-
-  uv_async_init(uv_default_loop(), &baton->req, (uv_async_cb) {{ cppFunctionName }}_{{ cbFunction.name }}_async);
-  {
-    LockMaster::TemporaryUnlock temporaryUnlock;
-
-    uv_async_send(&baton->req);
-
-    while(!baton->done) {
-      sleep_for_ms(1);
-    }
-  }
-
-  return baton->result;
+  return baton->ExecuteAsync((uv_async_cb) {{ cppFunctionName }}_{{ cbFunction.name }}_async);
 }
 
 void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_async(uv_async_t* req, int status) {
@@ -93,12 +79,12 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_async(uv_as
         baton->result = (int)result->ToNumber()->Value();
       }
       else {
-        baton->result = {{ cbFunction.return.noResults }};
+        baton->result = baton->defaultResult;
       }
       {% endif %}
     }
     else {
-      baton->result = {{ cbFunction.return.noResults }};
+      baton->result = baton->defaultResult;
     }
   {% endeach %}
 
@@ -127,12 +113,12 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_promiseComp
           baton->result = (int)result->ToNumber()->Value();
         }
         else {
-          baton->result = {{ cbFunction.return.noResults }};
+          baton->result = baton->defaultResult;
         }
         {% endif %}
       }
       else {
-        baton->result = {{ cbFunction.return.noResults }};
+        baton->result = baton->defaultResult;
       }
     {% endeach %}
   }

diff --git a/generate/templates/partials/field_accessors.cc b/generate/templates/partials/field_accessors.cc
@@ -11,8 +11,8 @@
         info.GetReturnValue().Set(Nan::New(wrapper->{{ field.name }}));
 
       {% elsif field.isCallbackFunction %}
-        if (wrapper->{{field.name}} != NULL) {
-          info.GetReturnValue().Set(wrapper->{{ field.name }}->GetFunction());
+        if (wrapper->{{field.name}}.HasCallback()) {
+          info.GetReturnValue().Set(wrapper->{{ field.name }}.GetCallback()->GetFunction());
         } else {
           info.GetReturnValue().SetUndefined();
         }
@@ -31,6 +31,7 @@
     }
 
     NAN_SETTER({{ cppClassName }}::Set{{ field.cppFunctionName }}) {
+      Nan::HandleScope scope;
 
       {{ cppClassName }} *wrapper = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This());
 
@@ -47,16 +48,35 @@
         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) {
-          delete wrapper->{{ field.name }};
-        }
+        Nan::Callback *callback = NULL;
+        int throttle = {%if field.return.throttle %}{{ field.return.throttle }}{%else%}0{%endif%};
 
         if (value->IsFunction()) {
+          callback = new Nan::Callback(value.As<Function>());
+        } else if (value->IsObject()) {
+          Local<Object> object = value.As<Object>();
+          Local<String> callbackKey;
+          Nan::MaybeLocal<Value> maybeObjectCallback = Nan::Get(object, Nan::New("callback").ToLocalChecked());
+          if (!maybeObjectCallback.IsEmpty()) {
+            Local<Value> objectCallback = maybeObjectCallback.ToLocalChecked();
+            if (objectCallback->IsFunction()) {
+              callback = new Nan::Callback(objectCallback.As<Function>());
+              Nan::MaybeLocal<Value> maybeObjectThrottle = Nan::Get(object, Nan::New("throttle").ToLocalChecked());
+              if(!maybeObjectThrottle.IsEmpty()) {
+                Local<Value> objectThrottle = maybeObjectThrottle.ToLocalChecked();
+                if (objectThrottle->IsNumber()) {
+                  throttle = (int)objectThrottle.As<Number>()->Value();
+                }
+              }
+            }
+          }
+        }
+        if (callback) {
           if (!wrapper->raw->{{ field.name }}) {
             wrapper->raw->{{ field.name }} = ({{ field.cType }}){{ field.name }}_cppCallback;
           }
 
-          wrapper->{{ field.name }} = new Nan::Callback(value.As<Function>());
+          wrapper->{{ field.name }}.SetCallback(callback, throttle);
         }
 
       {% elsif field.payloadFor %}
@@ -82,46 +102,42 @@
     }
 
     {% if field.isCallbackFunction %}
+      {{ cppClassName }}* {{ cppClassName }}::{{ field.name }}_getInstanceFromBaton({{ field.name|titleCase }}Baton* baton) {
+        return static_cast<{{ cppClassName }}*>(baton->{% each field.args|argsInfo as arg %}
+          {% if arg.payload == true %}{{arg.name}}{% elsif arg.lastArg %}{{arg.name}}{% endif %}
+        {% endeach %});
+      }
+
       {{ field.return.type }} {{ cppClassName }}::{{ field.name }}_cppCallback (
         {% each field.args|argsInfo as arg %}
           {{ arg.cType }} {{ arg.name}}{% if not arg.lastArg %},{% endif %}
         {% endeach %}
       ) {
-        {{ field.name|titleCase }}Baton* baton = new {{ field.name|titleCase }}Baton();
+        {{ field.name|titleCase }}Baton* baton =
+          new {{ field.name|titleCase }}Baton({{ field.return.noResults }});
 
         {% each field.args|argsInfo as arg %}
           baton->{{ arg.name }} = {{ arg.name }};
         {% endeach %}
 
-        baton->result = 0;
-        baton->req.data = baton;
-        baton->done = false;
-
-        uv_async_init(uv_default_loop(), &baton->req, (uv_async_cb) {{ field.name }}_async);
-        {
-          LockMaster::TemporaryUnlock temporaryUnlock;
-
-          uv_async_send(&baton->req);
+        {{ cppClassName }}* instance = {{ field.name }}_getInstanceFromBaton(baton);
 
-          while(!baton->done) {
-            sleep_for_ms(1);
-          }
+        if (instance->{{ field.name }}.WillBeThrottled()) {
+          return baton->defaultResult;
         }
 
-        return baton->result;
+        return baton->ExecuteAsync((uv_async_cb) {{ field.name }}_async);
       }
 
       void {{ cppClassName }}::{{ field.name }}_async(uv_async_t* req, int status) {
         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 %}
-          {% if arg.payload == true %}{{arg.name}}{% elsif arg.lastArg %}{{arg.name}}{% endif %}
-        {% endeach %});
+        {{ cppClassName }}* instance = {{ field.name }}_getInstanceFromBaton(baton);
 
-        if (instance->{{ field.name }}->IsEmpty()) {
+        if (instance->{{ field.name }}.GetCallback()->IsEmpty()) {
           {% if field.return.type == "int" %}
-            baton->result = {{ field.return.noResults }}; // no results acquired
+            baton->result = baton->defaultResult; // no results acquired
           {% endif %}
 
           baton->done = true;
@@ -163,7 +179,7 @@
         };
 
         Nan::TryCatch tryCatch;
-        Local<v8::Value> result = instance->{{ field.name }}->Call({{ field.args|jsArgsCount }}, argv);
+        Local<v8::Value> result = instance->{{ field.name }}.GetCallback()->Call({{ field.args|jsArgsCount }}, argv);
 
         uv_close((uv_handle_t*) &baton->req, NULL);
 
@@ -187,12 +203,12 @@
               baton->result = (int)result->ToNumber()->Value();
             }
             else {
-              baton->result = {{ field.return.noResults }};
+              baton->result = baton->defaultResult;
             }
             {% endif %}
           }
           else {
-            baton->result = {{ field.return.noResults }};
+            baton->result = baton->defaultResult;
           }
         {% endeach %}
         baton->done = true;
@@ -220,12 +236,12 @@
                 baton->result = (int)result->ToNumber()->Value();
               }
               else{
-                baton->result = {{ field.return.noResults }};
+                baton->result = baton->defaultResult;
               }
               {% endif %}
             }
             else {
-              baton->result = {{ field.return.noResults }};
+              baton->result = baton->defaultResult;
             }
           {% endeach %}
         }

diff --git a/generate/templates/templates/class_content.cc b/generate/templates/templates/class_content.cc
@@ -11,7 +11,6 @@ extern "C" {
 #include "../include/lock_master.h"
 #include "../include/functions/copy.h"
 #include "../include/{{ filename }}.h"
-#include "../include/functions/sleep_for_ms.h"
 
 {% each dependencies as dependency %}
   #include "{{ dependency }}"