diff --git a/cache.js b/cache.js
index 0a7f4c7..43cc534 100644
--- a/cache.js
+++ b/cache.js
@@ -6,9 +6,6 @@ var DEFAULT_TTL = 300000;
 // 30 seconds in ms is the default load timeout
 var DEFAULT_TIMEOUT = 30000;
 
-var BPromise = require('bluebird');
-var _ = require('lodash');
-
 function handleError(cache, err) {
   cache.lastLoadError = err;
   if (cache.options.errorCallback) {
@@ -18,54 +15,75 @@ function handleError(cache, err) {
   return cache;
 }
 
-function callLoader(cache) {
-  try {
-    return BPromise.resolve(cache.options.loader());
-  } catch(ex) {
-    return BPromise.reject(ex);
+function load(cache, cb) {
+  if (!cache.loading) {
+    cache.loading = true;
+
+    var timeoutProtect = setTimeout(function() {
+      timeoutProtect = null;
+      cache.loading = false;
+      handleError(cache, new Error('Cache loading timeout hit at ' + cache.options.timeout + 'ms.'));
+    }, cache.options.timeout);
+
+    try {
+      cache.options.loader(function(err, loadData) {
+        if (timeoutProtect) {
+          clearTimeout(timeoutProtect);
+          cache.loading = false;
+          if (err) {
+            handleError(cache, err);
+            if (cb) cb(err);
+          } else {
+            cache.data = loadData;
+            if (cb) cb(null, loadData);
+          }
+        }
+      });
+    } catch (err) {
+      clearTimeout(timeoutProtect);
+      cache.loading = false;
+      handleError(cache, err);
+      if (cb) cb(err);
+    }
   }
 }
 
-function load(cache) {
-  if (!cache.loadPromise || !cache.loadPromise.isPending()) {
-    var startTime = process.hrtime();
-
-    cache.loadPromise = callLoader(cache)
-    .timeout(cache.options.timeout)
-    .then(function(loadData) {
-      cache.lastLoadRunTime = process.hrtime(startTime)[1]/1000000;
-      cache.data = loadData;
-      return cache;
-    }).catch(function(err) {
-      cache = handleError(cache, err);
-      return cache;
-    });
-  }
-  return cache.loadPromise;
-}
-
 function getData(cache, args) {
-  if (!cache.data) {
-    return cache.loadPromise.then(function(loadedCache) {
-      return callGetter(loadedCache, args);
-    });
-  }
-
-  return BPromise.resolve(cache).then(function(loadedCache) {
-    return callGetter(loadedCache, args);
-  });
-}
-
-function callGetter(cache, args) {
-  if (cache.options.getter) {
-    args.unshift(cache.data);
-    return cache.options.getter.apply(null, args);
-  } else {
-    return cache.data;
+  var cb = null;
+  try {
+    cb = args.pop();
+
+    if (typeof cb !== 'function') {
+      throw new Error('Last parameter needs to be a callback function.');
+    }
+
+    var waitLock = setInterval(function() {
+      if (!cache.loading) {
+        clearInterval(waitLock);
+
+        if (!cache.data && cache.lastLoadError) {
+          cb(cache.lastLoadError);
+        } else {
+          if (cache.options.getter) {
+            args.unshift(cache.data);
+            args.push(cb);
+            return cache.options.getter.apply(null, args);
+          } else {
+            return cb(null, cache.data);
+          }
+        }
+      }
+    }, 0);
+
+  } catch(err) {
+    if (cb) {
+      cb(err);
+    } else {
+       throw(err);
+    }
   }
 }
 
-
 function Cache(options) {
   var cache = {};
 
@@ -94,16 +112,16 @@ function Cache(options) {
   load(cache);
   cache.intervalId = setInterval(function() { load(cache); }, options.ttl);
 
-  cache.get = function() {
-    var args = [].slice.call(arguments);
-    return getData(cache, args);
-  };
+  return {
+    get: function() {
+      var args = [].slice.call(arguments);
+      return getData(cache, args);
+    },
 
-  cache.reload = function(cb) {
-    return load(cache);
+    reload: function(cb) {
+      return load(cache, cb);
+    }
   };
-
-  return cache;
 }
 
 module.exports = Cache;
diff --git a/package.json b/package.json
index fe62384..b016815 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "refresh-cache",
-  "version": "1.0.2",
+  "version": "2.0.0-beta",
   "description": "A simple Javascript cache that refreshes by calling the load function at a set refresh time.",
   "main": "cache.js",
   "scripts": {
@@ -26,12 +26,9 @@
   "devDependencies": {
     "coveralls": "^2.11.4",
     "istanbul": "^0.3.21",
+    "lodash": "^3.10.1",
     "mocha": "^2.3.3",
     "mocha-lcov-reporter": "^1.0.0",
     "must": "^0.13.1"
-  },
-  "dependencies": {
-    "bluebird": "^2.10.2",
-    "lodash": "^3.10.1"
   }
 }
diff --git a/test/cache_tests.js b/test/cache_tests.js
index 4e4b27c..dd5f618 100644
--- a/test/cache_tests.js
+++ b/test/cache_tests.js
@@ -1,72 +1,76 @@
 'use strict';
 
-var BPromise = require('bluebird');
 var _ = require('lodash');
 var expect = require('must');
 
 var Cache = require('../cache');
 
-function loadTests() {
-  return [
+function loadTests(cb) {
+  cb(null, [
     { id: 1, name: 'test 1' },
     { id: 2, name: 'test 2' },
     { id: 3, name: 'test 3' },
-  ];
+  ]);
 }
 
 describe('Cache Tests', function() {
 
-  it('loads and gets when calling get even before load',  function() {
+  it('loads and gets when calling get even before load',  function(done) {
     var cache = new Cache({
       loader: loadTests,
-      getter: function(tests, id) {
-        return _.find(tests, function(test) {
+      getter: function(tests, id, cb) {
+        cb(null, _.find(tests, function(test) {
           return test.id === id;
-        });
+        }));
       }
     });
 
     // call get with key that the getter function uses
-    return cache.get(2).then(function(testValue) {
+    return cache.get(2, function(err, testValue) {
+      expect(err).to.be.null();
       expect(testValue.id).to.equal(2);
       expect(testValue.name).to.equal('test 2');
+      done();
     });
   });
 
-  it('calling load then get pulls from cache without calling load again',  function() {
+  it('calling load then get pulls from cache without calling load again',  function(done) {
     var callCount = 0; // usedto count function calls
 
-    function countingLoader() {
+    function countingLoader(cb) {
       callCount++;
-      return loadTests();
+      return loadTests(cb);
     }
 
     var cache = new Cache({
       loader: countingLoader,
-      getter: function(tests, id) {
-        return _.find(tests, function(test) {
+      getter: function(tests, id, cb) {
+        cb(null, _.find(tests, function(test) {
           return test.id === id;
-        });
+        }));
       }
     });
 
-    return cache.reload().then(function() {
-      return cache.get(2);
-    }).then(function(testValue) {
-      expect(testValue.id).to.equal(2);
-      expect(testValue.name).to.equal('test 2');
-      expect(callCount).to.equal(1);
+    return cache.reload(function(err) {
+      expect(err).to.be.null();
+      return cache.get(2, function(err, testValue) {
+        expect(err).to.be.null();
+        expect(testValue.id).to.equal(2);
+        expect(testValue.name).to.equal('test 2');
+        expect(callCount).to.equal(2);
+        done();
+      });
     });
   });
 
-  it('once load is called it calls load ever refresh time',  function() {
+  it('once load is called it calls load ever refresh time',  function(done) {
     var count = 0;
     var currentData = [];
 
-    function appendTestLoader() {
+    function appendTestLoader(cb) {
       count++;
       currentData.push({ id: count, name: 'Test ' + count });
-      return currentData;
+      cb(null, currentData);
     }
 
     var cache = new Cache({
@@ -74,29 +78,32 @@ describe('Cache Tests', function() {
       ttl: 10 //sets refrest to 20 ms
     });
 
-    return BPromise.delay(50).then(function() { // wait 100 ms
-      return cache.get();
-    }).then(function(testData) {
-      // set timeout is exact sload was called at least 1 les then it should have been
-      expect(testData.length).to.be.gte(4);
-    });
+    setTimeout(function() {
+      return cache.get(function(err, testData) {
+        expect(err).to.be.null();
+        expect(testData.length).to.be.gte(4);
+        done();
+      });
+    }, 50);
   });
 
-  it('if load takes to long the error callback is called but data stays',  function() {
+  it('if load takes to long the error callback is called but data stays',  function(done) {
     var firstRun = true;
     var callCount = 0;
 
-    function timeoutAfterFirstRunLoad() {
-      var data = loadTests();
-
-      if (!firstRun) { // delay call 500 ms
-        return BPromise.delay(50).then(function() {
-          return data;
-        });
-      } else { // first run return data
-        firstRun = false;
-        return data;
-      }
+    function timeoutAfterFirstRunLoad(cb) {
+      loadTests(function(err, data) {
+        expect(err).to.be.null();
+
+        if (!firstRun) { // delay call 50 ms
+          setTimeout(function() {
+            cb(null, data);
+          }, 50);
+        } else { // first run return data
+          firstRun = false;
+          cb(null, data);
+        }
+      });
     }
 
     var cache = new Cache({
@@ -108,37 +115,37 @@ describe('Cache Tests', function() {
       }
     });
 
-    return BPromise.delay(50).then(function() {
+    setTimeout(function() {
       expect(callCount).to.be.gt(0);
-    });
+      done();
+    }, 50);
   });
 
-  it('a loader that always errors sets lastLoadError and calls errorCallback', function() {
+  it('erroring loader calls errorCallback and calls to get return the err', function(done) {
     var testerror;
     var cache = new Cache({
-      loader: function() { throw new Error('I have an issue.'); },
+      loader: function(cb) { cb(new Error('I have an issue.')); },
       errorCallback: function(err) {
         testerror = err;
       }
     });
 
-    return cache.get().then(function(data) {
-      expect(cache.lastLoadError).is.error('I have an issue.');
+    return cache.get(function(err, data) {
+      expect(err).is.error('I have an issue.');
       expect(testerror).is.error('I have an issue.');
+      done();
     });
   });
 
-  it('a loader that fails in promise on refresh load sets lastLoadError keeps reading old data', function() {
+  it('if load happened without an error at least once will return data on get', function(done) {
     var callCount = 0; // usedto count function calls
 
-    function errorAfterFirstLoadLoader() {
+    function errorAfterFirstLoadLoader(cb) {
       callCount++;
       if (callCount == 1) {
-        return loadTests();
+        return loadTests(cb);
       } else {
-        return BPromise.delay(5).then(function() {
-          throw new Error('We have issues.');
-        });
+        throw new Error('We have issues.');
       }
     }
 
@@ -147,39 +154,34 @@ describe('Cache Tests', function() {
       ttl: 10
     });
 
-    return BPromise.delay(50).then(function() {
-      return cache.get();
-    }).then(function(data) {
-      expect(data).to.be.an.array();
-      expect(cache.lastLoadError).to.be.an.error('We have issues.');
-    });
+    setTimeout(function() {
+      return cache.get(function(err, data) {
+        expect(err).to.be.null();
+        expect(data).to.be.an.array();
+        done();
+      });
+    }, 50);
   });
-
-  it('a loader that fails on refresh load sets lastLoadError keeps reading old data', function() {
-    var callCount = 0; // usedto count function calls
-
-    function errorAfterFirstLoadLoader() {
-      callCount++;
-      if (callCount == 1) {
-        return loadTests();
-      } else {
-        throw new Error('We have issues.');
-      }
-    }
-
+/* Working on this
+  it('calling reload mutiple times only reloads once', function(done) {
     var cache = new Cache({
-      loader: errorAfterFirstLoadLoader,
-      ttl: 10
+      loader: loadTests,
+      getter: function(tests, id, cb) {
+        cb(null, _.find(tests, function(test) {
+          return test.id === id;
+        }));
+      }
     });
 
-    return BPromise.delay(50).then(function() {
-      return cache.get();
-    }).then(function(data) {
-      expect(data).to.be.an.array();
-      expect(cache.lastLoadError).to.be.an.error('We have issues.');
+    // call get with key that the getter function uses
+    return cache.get(2, function(err, testValue) {
+      expect(err).to.be.null();
+      expect(testValue.id).to.equal(2);
+      expect(testValue.name).to.equal('test 2');
+      done();
     });
   });
-
+*/
   it('not passing loader throws expection',  function() {
     var error;
     try {