diff --git a/Makefile b/Makefile
index a4f68303..a29287b4 100644
--- a/Makefile
+++ b/Makefile
@@ -47,6 +47,7 @@ LINT_SOURCES = \
 	test/cpp/morenews.cpp \
 	test/cpp/converters.cpp \
 	test/cpp/isolatedata.cpp \
+	test/cpp/global.cpp \
 	test/cpp/makecallback.cpp \
 	test/cpp/morenews.cpp \
 	test/cpp/multifile1.cpp \
diff --git a/nan_callbacks_12_inl.h b/nan_callbacks_12_inl.h
index bea12c71..6774813a 100644
--- a/nan_callbacks_12_inl.h
+++ b/nan_callbacks_12_inl.h
@@ -38,7 +38,6 @@ class ReturnValue {
     value_.Set(handle);
 #else
     value_.Set(*reinterpret_cast<const v8::Persistent<S>*>(&handle));
-    const_cast<Global<S> &>(handle).Reset();
 #endif
   }
 
diff --git a/nan_callbacks_pre_12_inl.h b/nan_callbacks_pre_12_inl.h
index 5e2b8e2b..352b94ac 100644
--- a/nan_callbacks_pre_12_inl.h
+++ b/nan_callbacks_pre_12_inl.h
@@ -40,7 +40,6 @@ class ReturnValue {
     TYPE_CHECK(T, S);
     value_->Dispose();
     *value_ = v8::Persistent<T>::New(handle.persistent);
-    const_cast<Global<S> &>(handle).Reset();
   }
 
   // Fast primitive setters
diff --git a/nan_maybe_pre_43_inl.h b/nan_maybe_pre_43_inl.h
index c5386875..3d72f61b 100644
--- a/nan_maybe_pre_43_inl.h
+++ b/nan_maybe_pre_43_inl.h
@@ -16,10 +16,11 @@ class MaybeLocal {
 
   template<typename S>
 # if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
-  inline MaybeLocal(v8::Local<S> that) : val_(that) {}
+  inline MaybeLocal(v8::Local<S> that) :  // NOLINT(runtime/explicit)
+      val_(that) {}
 # else
-  inline MaybeLocal(v8::Local<S> that) :
-      val_(*reinterpret_cast<v8::Local<T>*>(&that)) {}
+  inline MaybeLocal(v8::Local<S> that) :  // NOLINT(runtime/explicit)
+      val_(*reinterpret_cast<v8::Local<T>*>(&that)) { TYPE_CHECK(T, S); }
 # endif
 
   inline bool IsEmpty() const { return val_.IsEmpty(); }
diff --git a/nan_persistent_12_inl.h b/nan_persistent_12_inl.h
index eb4ff109..89a38c9c 100644
--- a/nan_persistent_12_inl.h
+++ b/nan_persistent_12_inl.h
@@ -14,25 +14,31 @@ template<typename T, typename M> class Persistent :
  public:
   inline Persistent() : v8::Persistent<T, M>() {}
 
-  template<typename S> inline Persistent(v8::Local<S> that) :
+  template<typename S> inline explicit Persistent(v8::Local<S> that) :
       v8::Persistent<T, M>(v8::Isolate::GetCurrent(), that) {}
 
   template<typename S, typename M2>
-  inline Persistent(const v8::Persistent<S, M2> &that) :
+  inline explicit Persistent(const v8::Persistent<S, M2> &that) :
       v8::Persistent<T, M2>(v8::Isolate::GetCurrent(), that) {}
 
   inline void Reset() { v8::PersistentBase<T>::Reset(); }
 
-  template <typename S>
+  template<typename S>
   inline void Reset(const v8::Local<S> &other) {
     v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
   }
 
-  template <typename S>
+  template<typename S>
   inline void Reset(const v8::PersistentBase<S> &other) {
     v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
   }
 
+#if NODE_MODULE_VERSION == NODE_0_12_MODULE_VERSION
+  inline void Empty() {
+    v8::Persistent<T, M>::ClearAndLeak();
+  }
+#endif
+
   template<typename P>
   inline void SetWeak(
     P *parameter
@@ -40,8 +46,6 @@ template<typename T, typename M> class Persistent :
     , WeakCallbackType type);
 
  private:
-  inline T *operator*() const { return *PersistentBase<T>::persistent; }
-
   template<typename S, typename M2>
   inline void Copy(const Persistent<S, M2> &that) {
     TYPE_CHECK(T, S);
@@ -62,11 +66,11 @@ class Global : public v8::Global<T> {
  public:
   inline Global() : v8::Global<T>() {}
 
-  template<typename S> inline Global(v8::Local<S> that) :
+  template<typename S> inline explicit Global(v8::Local<S> that) :
     v8::Global<T>(v8::Isolate::GetCurrent(), that) {}
 
   template<typename S>
-  inline Global(const v8::PersistentBase<S> &that) :
+  inline explicit Global(const v8::PersistentBase<S> &that) :
       v8::Global<S>(v8::Isolate::GetCurrent(), that) {}
 
   inline void Reset() { v8::PersistentBase<T>::Reset(); }
@@ -81,47 +85,80 @@ class Global : public v8::Global<T> {
     v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
   }
 
+  Global Pass() { return static_cast<Global&&>(*this); }  // NOLINT(build/c++11)
+
   template<typename P>
   inline void SetWeak(
     P *parameter
     , typename WeakCallbackInfo<P>::Callback callback
     , WeakCallbackType type) {
-    reinterpret_cast<Persistent<T>*>(this)->SetWeak(
-        parameter, callback, type);
+    static_cast<Persistent<T>*>(static_cast<v8::PersistentBase<T>*>(this))->
+        SetWeak(parameter, callback, type);
   }
 };
 #else
 template<typename T>
 class Global : public v8::UniquePersistent<T> {
+  struct RValue {
+    inline explicit RValue(v8::UniquePersistent<T> *obj) : object_(obj) {}
+    v8::UniquePersistent<T> *object_;
+  };
+
  public:
   inline Global() : v8::UniquePersistent<T>() {}
 
-  template<typename S> inline Global(v8::Local<S> that) :
+  template<typename S> inline explicit Global(v8::Local<S> that) :
     v8::UniquePersistent<T>(v8::Isolate::GetCurrent(), that) {}
 
   template<typename S>
-  inline Global(const v8::PersistentBase<S> &that) :
+  inline explicit Global(const v8::PersistentBase<S> &that) :
       v8::UniquePersistent<S>(v8::Isolate::GetCurrent(), that) {}
 
   inline void Reset() { v8::PersistentBase<T>::Reset(); }
 
-  template <typename S>
+  template<typename S>
   inline void Reset(const v8::Local<S> &other) {
     v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
   }
 
-  template <typename S>
+  template<typename S>
   inline void Reset(const v8::PersistentBase<S> &other) {
     v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
   }
 
+#if NODE_MODULE_VERSION == NODE_0_12_MODULE_VERSION
+  inline void Empty() {
+    static_cast<v8::Persistent<T>*>(static_cast<v8::PersistentBase<T>*>(this))->
+        ClearAndLeak();
+  }
+#endif
+
+  inline Global(RValue rvalue) {  // NOLINT(runtime/explicit)
+    std::memcpy(this, rvalue.object_, sizeof (*rvalue.object_));
+# if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
+    rvalue.object_->Empty();
+# else
+    static_cast<v8::Persistent<T>*>(static_cast<v8::PersistentBase<T>*>(
+        rvalue.object_))->ClearAndLeak();
+# endif
+  }
+
+  template<typename S>
+  inline Global &operator=(v8::UniquePersistent<S> other) {
+    return static_cast<Global&>(v8::UniquePersistent<S>::operator=(other));
+  }
+
+  inline operator RValue() { return RValue(this); }
+
+  Global Pass() { return Global(RValue(this)); }
+
   template<typename P>
   inline void SetWeak(
     P *parameter
     , typename WeakCallbackInfo<P>::Callback callback
     , WeakCallbackType type) {
-    reinterpret_cast<Persistent<T>*>(this)->SetWeak(
-        parameter, callback, type);
+    static_cast<Persistent<T>*>(static_cast<v8::PersistentBase<T>*>(this))
+        ->SetWeak(parameter, callback, type);
   }
 };
 #endif
diff --git a/nan_persistent_pre_12_inl.h b/nan_persistent_pre_12_inl.h
index d466e34c..88f3a81c 100644
--- a/nan_persistent_pre_12_inl.h
+++ b/nan_persistent_pre_12_inl.h
@@ -196,32 +196,35 @@ class Global : public PersistentBase<T> {
   inline Global() : PersistentBase<T>(0) { }
 
   template <typename S>
-  inline Global(v8::Local<S> that)
+  inline explicit Global(v8::Local<S> that)
       : PersistentBase<T>(v8::Persistent<T>::New(that)) {
     TYPE_CHECK(T, S);
   }
 
   template <typename S>
-  inline Global(const PersistentBase<S> &that)
-    : PersistentBase<T>(that) {
+  inline explicit Global(const PersistentBase<S> &that) :
+      PersistentBase<T>(that) {
     TYPE_CHECK(T, S);
   }
   /**
    * Move constructor.
    */
-  inline Global(RValue rvalue)
+  inline Global(RValue rvalue)  // NOLINT(runtime/explicit)
     : PersistentBase<T>(rvalue.object->persistent) {
-    rvalue.object->Reset();
+    rvalue.object->Empty();
   }
   inline ~Global() { this->Reset(); }
   /**
    * Move via assignment.
    */
   template<typename S>
-  inline Global &operator=(Global<S> rhs) {
+  inline Global &operator=(Global<S> other) {
     TYPE_CHECK(T, S);
-    this->Reset(rhs.persistent);
-    rhs.Reset();
+    if (!this->persistent.IsEmpty()) {
+      this->persistent.Dispose();
+    }
+    this->persistent = other.persistent;
+    other.Empty();
     return *this;
   }
   /**
diff --git a/test/binding.gyp b/test/binding.gyp
index afc2882c..bd548835 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -148,4 +148,8 @@
         "target_name" : "typedarrays"
       , "sources"     : [ "cpp/typedarrays.cpp" ]
     }
+    , {
+        "target_name" : "global"
+      , "sources"     : [ "cpp/global.cpp" ]
+    }
 ]}
diff --git a/test/cpp/global.cpp b/test/cpp/global.cpp
new file mode 100644
index 00000000..112f7c8b
--- /dev/null
+++ b/test/cpp/global.cpp
@@ -0,0 +1,75 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2016 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#include <nan.h>
+
+using namespace Nan;  // NOLINT(build/namespaces)
+
+template<typename T> Global<T> passer(v8::Local<T> handle) {
+  return Global<T>(handle).Pass();
+}
+
+NAN_METHOD(PassGlobal) {
+  info.GetReturnValue().Set(passer(New(42)));
+}
+
+NAN_METHOD(EmptyGlobal) {
+  Global<v8::String> g(New("value").ToLocalChecked());
+  bool b1 = !g.IsEmpty();
+  g.Empty();  // this will leak, never do it
+  info.GetReturnValue().Set(b1 && g.IsEmpty());
+}
+
+NAN_METHOD(MoveConstructGlobal) {
+  Global<v8::String> g(Global<v8::String>(New("value").ToLocalChecked()));
+  info.GetReturnValue().Set(!g.IsEmpty());
+}
+
+NAN_METHOD(CopyConstructGlobal) {
+  Persistent<v8::String> p(New("value").ToLocalChecked());
+  bool b1 = !p.IsEmpty();
+  Global<v8::String> g(p);
+  bool b2 = !p.IsEmpty();
+  p.Reset();
+  info.GetReturnValue().Set(b1 && b2 && !g.IsEmpty());
+}
+
+NAN_METHOD(MoveAssignGlobal) {
+  Global<v8::String> g = passer(New("value").ToLocalChecked());
+  info.GetReturnValue().Set(!g.IsEmpty());
+}
+
+NAN_MODULE_INIT(Init) {
+  Set(target
+    , New<v8::String>("passGlobal").ToLocalChecked()
+    , GetFunction(New<v8::FunctionTemplate>(PassGlobal))
+        .ToLocalChecked()
+  );
+  Set(target
+    , New<v8::String>("emptyGlobal").ToLocalChecked()
+    , GetFunction(New<v8::FunctionTemplate>(EmptyGlobal))
+        .ToLocalChecked()
+  );
+  Set(target
+    , New<v8::String>("moveConstructGlobal").ToLocalChecked()
+    , GetFunction(New<v8::FunctionTemplate>(MoveConstructGlobal))
+        .ToLocalChecked()
+  );
+  Set(target
+    , New<v8::String>("copyConstructGlobal").ToLocalChecked()
+    , GetFunction(New<v8::FunctionTemplate>(CopyConstructGlobal))
+        .ToLocalChecked()
+  );
+  Set(target
+    , New<v8::String>("moveAssignGlobal").ToLocalChecked()
+    , GetFunction(New<v8::FunctionTemplate>(MoveAssignGlobal))
+        .ToLocalChecked()
+  );
+}
+
+NODE_MODULE(global, Init)
diff --git a/test/cpp/persistent.cpp b/test/cpp/persistent.cpp
index e28b17ce..4d3504a3 100644
--- a/test/cpp/persistent.cpp
+++ b/test/cpp/persistent.cpp
@@ -12,6 +12,7 @@
 using namespace Nan;  // NOLINT(build/namespaces)
 
 static Persistent<v8::String> persistentTest1;
+static Persistent<v8::String> persistentTest2;
 
 NAN_METHOD(Save1) {
   persistentTest1.Reset(info[0].As<v8::String>());
@@ -55,6 +56,39 @@ NAN_METHOD(PassGlobal) {
   info.GetReturnValue().Set(passer(New(42)));
 }
 
+NAN_METHOD(EmptyPersistent) {
+  persistentTest2.Reset(New("value").ToLocalChecked());
+  bool b1 = !persistentTest2.IsEmpty();
+  persistentTest2.Empty();  // this will leak, never do it
+  info.GetReturnValue().Set(b1 && persistentTest2.IsEmpty());
+}
+
+NAN_METHOD(EmptyGlobal) {
+  Global<v8::String> g(New("value").ToLocalChecked());
+  bool b1 = !g.IsEmpty();
+  g.Empty();  // this will leak, never do it
+  info.GetReturnValue().Set(b1 && g.IsEmpty());
+}
+
+NAN_METHOD(MoveConstructGlobal) {
+  Global<v8::String> g(Global<v8::String>(New("value").ToLocalChecked()));
+  info.GetReturnValue().Set(!g.IsEmpty());
+}
+
+NAN_METHOD(CopyConstructGlobal) {
+  Persistent<v8::String> p(New("value").ToLocalChecked());
+  bool b1 = !p.IsEmpty();
+  Global<v8::String> g(p);
+  bool b2 = !p.IsEmpty();
+  p.Reset();
+  info.GetReturnValue().Set(b1 && b2 && !g.IsEmpty());
+}
+
+NAN_METHOD(MoveAssignGlobal) {
+  Global<v8::String> g = passer(New("value").ToLocalChecked());
+  info.GetReturnValue().Set(!g.IsEmpty());
+}
+
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("save1").ToLocalChecked()
@@ -88,6 +122,31 @@ NAN_MODULE_INIT(Init) {
     , GetFunction(New<v8::FunctionTemplate>(PassGlobal))
         .ToLocalChecked()
   );
+  Set(target
+    , New<v8::String>("emptyPersistent").ToLocalChecked()
+    , GetFunction(New<v8::FunctionTemplate>(EmptyPersistent))
+        .ToLocalChecked()
+  );
+  Set(target
+    , New<v8::String>("emptyGlobal").ToLocalChecked()
+    , GetFunction(New<v8::FunctionTemplate>(EmptyGlobal))
+        .ToLocalChecked()
+  );
+  Set(target
+    , New<v8::String>("moveConstructGlobal").ToLocalChecked()
+    , GetFunction(New<v8::FunctionTemplate>(MoveConstructGlobal))
+        .ToLocalChecked()
+  );
+  Set(target
+    , New<v8::String>("copyConstructGlobal").ToLocalChecked()
+    , GetFunction(New<v8::FunctionTemplate>(CopyConstructGlobal))
+        .ToLocalChecked()
+  );
+  Set(target
+    , New<v8::String>("moveAssignGlobal").ToLocalChecked()
+    , GetFunction(New<v8::FunctionTemplate>(MoveAssignGlobal))
+        .ToLocalChecked()
+  );
 }
 
 NODE_MODULE(persistent, Init)
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index fcf7960a..cc0ad509 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -11,6 +11,7 @@
 using namespace Nan;  // NOLINT(build/namespaces)
 
 static Persistent<v8::Function> cb;
+static Global<v8::Function> gcb;
 
 void weakCallback(
     const WeakCallbackInfo<int> &data) {  // NOLINT(runtime/references)
@@ -30,16 +31,35 @@ v8::Local<v8::String> wrap(v8::Local<v8::Function> func) {
   return scope.Escape(lstring);
 }
 
+v8::Local<v8::String> gwrap(v8::Local<v8::Function> func) {
+  EscapableHandleScope scope;
+  v8::Local<v8::String> lstring = New<v8::String>("result").ToLocalChecked();
+  int *parameter = new int(42);
+  gcb.Reset(func);
+  gcb.SetWeak(parameter, weakCallback, WeakCallbackType::kParameter);
+  assert(gcb.IsWeak());
+  return scope.Escape(lstring);
+}
+
 NAN_METHOD(Hustle) {
   cb.Reset(info[1].As<v8::Function>());
   info.GetReturnValue().Set(wrap(info[0].As<v8::Function>()));
 }
 
+NAN_METHOD(HustleGlobal) {
+  cb.Reset(info[1].As<v8::Function>());
+  info.GetReturnValue().Set(gwrap(info[0].As<v8::Function>()));
+}
+
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("hustle").ToLocalChecked()
     , New<v8::FunctionTemplate>(Hustle)->GetFunction()
   );
+  Set(target
+    , New<v8::String>("hustleGlobal").ToLocalChecked()
+    , New<v8::FunctionTemplate>(HustleGlobal)->GetFunction()
+  );
 }
 
 NODE_MODULE(weak, Init)
diff --git a/test/js/global-test.js b/test/js/global-test.js
new file mode 100644
index 00000000..eea19c05
--- /dev/null
+++ b/test/js/global-test.js
@@ -0,0 +1,28 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2016 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+const test     = require('tap').test
+    , testRoot = require('path').resolve(__dirname, '..')
+    , bindings = require('bindings')({ module_root: testRoot, bindings: 'global' });
+
+test('global', function (t) {
+  t.plan(10);
+
+  var global_ = bindings;
+  t.type(global_.passGlobal, 'function');
+  t.type(global_.emptyGlobal, 'function');
+  t.type(global_.moveConstructGlobal, 'function');
+  t.type(global_.copyConstructGlobal, 'function');
+  t.type(global_.moveAssignGlobal, 'function');
+
+  t.equal(global_.passGlobal(), 42, 'pass global');
+  t.ok(global_.emptyGlobal());
+  t.ok(global_.moveConstructGlobal());
+  t.ok(global_.copyConstructGlobal());
+  t.ok(global_.moveAssignGlobal());
+});
diff --git a/test/js/persistent-test.js b/test/js/persistent-test.js
index b7dd33ff..3707d912 100644
--- a/test/js/persistent-test.js
+++ b/test/js/persistent-test.js
@@ -20,7 +20,9 @@ test('persistent', function (t) {
   t.type(persistent.toPersistentAndBackAgain, 'function');
   t.type(persistent.persistentToPersistent, 'function');
   t.type(persistent.copyablePersistent, 'function');
-  t.type(persistent.passGlobal, 'function');
+  t.type(persistent.emptyPersistent, 'function');
+
+  t.ok(persistent.emptyPersistent());
 
   t.deepEqual(persistent.toPersistentAndBackAgain({ x: 42 }), { x: 42 });
 
@@ -30,8 +32,6 @@ test('persistent', function (t) {
   t.equal(persistent.get1(), 'a string to save');
   t.equal(persistent.copyablePersistent(), 'a string to save');
 
-  t.equal(persistent.passGlobal(), 42, 'pass global');
-
   setTimeout(function () {
     t.equal(persistent.get1(), 'a string to save');
     persistent.dispose1();
diff --git a/test/js/weak-test.js b/test/js/weak-test.js
index 5c91590a..4c842aaa 100644
--- a/test/js/weak-test.js
+++ b/test/js/weak-test.js
@@ -11,10 +11,11 @@ const test     = require('tap').test
     , bindings = require('bindings')({ module_root: testRoot, bindings: 'weak' });
 
 test('weak', function (t) {
-  t.plan(3);
+  t.plan(6);
 
   var weak = bindings, count = 0;
   t.type(weak.hustle, 'function');
+  t.type(weak.hustleGlobal, 'function');
 
   weak.hustle(function () {}, function (val) {
     t.equal(val, 42);
@@ -27,5 +28,20 @@ test('weak', function (t) {
   // do not run weak callback
   gc();
 
+  t.equal(count, 1);
+
+	count = 0;
+
+  weak.hustleGlobal(function () {}, function (val) {
+    t.equal(val, 42);
+    count++;
+  });
+
+  // run weak callback, should dispose
+  gc();
+
+  // do not run weak callback
+  gc();
+
   t.equal(count, 1);
 });