diff --git a/nan.h b/nan.h
index a5cd8955..dfc634b9 100644
--- a/nan.h
+++ b/nan.h
@@ -169,15 +169,12 @@ typedef v8::String::ExternalOneByteStringResource
 
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
 template<typename T>
-class NonCopyablePersistentTraits :
-    public v8::NonCopyablePersistentTraits<T> {};
+class NonCopyablePersistentTraits;
 template<typename T>
-class CopyablePersistentTraits :
-    public v8::CopyablePersistentTraits<T> {};
+class CopyablePersistentTraits;
 
 template<typename T>
-class PersistentBase :
-    public v8::PersistentBase<T> {};
+class PersistentBase;
 
 template<typename T, typename M = v8::NonCopyablePersistentTraits<T> >
 class Persistent;
diff --git a/nan_callbacks_12_inl.h b/nan_callbacks_12_inl.h
index b20d68fb..a6346bd6 100644
--- a/nan_callbacks_12_inl.h
+++ b/nan_callbacks_12_inl.h
@@ -35,7 +35,7 @@ class ReturnValue {
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) &&                       \
   (V8_MINOR_VERSION > 5 || (V8_MINOR_VERSION == 5 &&                           \
   defined(V8_BUILD_NUMBER) && V8_BUILD_NUMBER >= 8))))
-    value_.Set(handle);
+    value_.Set(handle.persistent);
 #else
     value_.Set(*reinterpret_cast<const v8::Persistent<S>*>(&handle));
     const_cast<Global<S> &>(handle).Reset();
diff --git a/nan_implementation_12_inl.h b/nan_implementation_12_inl.h
index a140f856..edd451a5 100644
--- a/nan_implementation_12_inl.h
+++ b/nan_implementation_12_inl.h
@@ -393,12 +393,12 @@ inline v8::Local<T> New(v8::Persistent<T, M> const& p) {
 
 template <typename T, typename M>
 inline v8::Local<T> New(Persistent<T, M> const& p) {
-  return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
+  return v8::Local<T>::New(v8::Isolate::GetCurrent(), p.persistent);
 }
 
 template <typename T>
 inline v8::Local<T> New(Global<T> const& p) {
-  return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
+  return v8::Local<T>::New(v8::Isolate::GetCurrent(), p.persistent);
 }
 
 #endif  // NAN_IMPLEMENTATION_12_INL_H_
diff --git a/nan_object_wrap.h b/nan_object_wrap.h
index 0685b020..5fe57283 100644
--- a/nan_object_wrap.h
+++ b/nan_object_wrap.h
@@ -62,7 +62,7 @@ class ObjectWrap {
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 
   inline void MakeWeak() {
-    persistent().v8::PersistentBase<v8::Object>::SetWeak(
+    persistent().persistent.v8::PersistentBase<v8::Object>::SetWeak(
         this, WeakCallback, v8::WeakCallbackType::kParameter);
     persistent().MarkIndependent();
   }
@@ -70,7 +70,7 @@ class ObjectWrap {
 #elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
 
   inline void MakeWeak() {
-    persistent().v8::PersistentBase<v8::Object>::SetWeak(this, WeakCallback);
+    persistent().persistent.v8::PersistentBase<v8::Object>::SetWeak(this, WeakCallback);
     persistent().MarkIndependent();
   }
 
diff --git a/nan_persistent_12_inl.h b/nan_persistent_12_inl.h
index f1fa193d..1c26f85b 100644
--- a/nan_persistent_12_inl.h
+++ b/nan_persistent_12_inl.h
@@ -9,28 +9,56 @@
 #ifndef NAN_PERSISTENT_12_INL_H_
 #define NAN_PERSISTENT_12_INL_H_
 
-template<typename T, typename M> class Persistent :
-    public v8::Persistent<T, M> {
+template<typename T> class PersistentBase {
+  v8::Persistent<T> persistent;
+
+  template<typename U>
+  friend v8::Local<U> New(const PersistentBase<U> &p);
+  template<typename U, typename M>
+  friend v8::Local<U> New(const Persistent<U, M> &p);
+  template<typename U>
+  friend v8::Local<U> New(const Global<U> &p);
+  template<typename S> friend class ReturnValue;
+
  public:
-  NAN_INLINE Persistent() : v8::Persistent<T, M>() {}
+  NAN_INLINE void Reset() {
+    persistent.Reset();
+  }
 
-  template<typename S> NAN_INLINE Persistent(v8::Local<S> that) :
-      v8::Persistent<T, M>(v8::Isolate::GetCurrent(), that) {}
+  template<typename S>
+  NAN_INLINE void Reset(const v8::Local<S> &other) {
+    TYPE_CHECK(T, S);
+    persistent.Reset(v8::Isolate::GetCurrent(), other);
+  }
 
-  template<typename S, typename M2>
-  NAN_INLINE Persistent(const v8::Persistent<S, M2> &that) :
-      v8::Persistent<T, M2>(v8::Isolate::GetCurrent(), that) {}
+    template<typename S>
+  NAN_INLINE void Reset(const PersistentBase<S> &other) {
+    TYPE_CHECK(T, S);
+    persistent.Reset(v8::Isolate::GetCurrent(), other.persistent);
+  }
 
-  NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
+  NAN_INLINE bool IsEmpty() const { return persistent.IsEmpty(); }
 
-  template <typename S>
-  NAN_INLINE void Reset(const v8::Local<S> &other) {
-    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  NAN_INLINE void Empty() { persistent.Empty(); }
+
+  template<typename S>
+  NAN_INLINE bool operator==(const PersistentBase<S> &that) {
+    return this->persistent == that.persistent;
   }
 
-  template <typename S>
-  NAN_INLINE void Reset(const v8::PersistentBase<S> &other) {
-    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  template<typename S>
+  NAN_INLINE bool operator==(const v8::Local<S> &that) {
+    return this->persistent == that;
+  }
+
+  template<typename S>
+  NAN_INLINE bool operator!=(const PersistentBase<S> &that) {
+    return !operator==(that);
+  }
+
+  template<typename S>
+  NAN_INLINE bool operator!=(const v8::Local<S> &that) {
+    return !operator==(that);
   }
 
   template<typename P>
@@ -39,6 +67,90 @@ template<typename T, typename M> class Persistent :
     , typename WeakCallbackInfo<P>::Callback callback
     , WeakCallbackType type);
 
+  NAN_INLINE void ClearWeak() { persistent.ClearWeak(); }
+
+  NAN_INLINE void MarkIndependent() { persistent.MarkIndependent(); }
+
+  NAN_INLINE bool IsIndependent() const { return persistent.IsIndependent(); }
+
+  NAN_INLINE bool IsNearDeath() const { return persistent.IsNearDeath(); }
+
+  NAN_INLINE bool IsWeak() const { return persistent.IsWeak(); }
+
+  NAN_INLINE v8::Local<T> Get() const {
+    return v8::Local<T>::New(v8::Isolate::GetCurrent(), persistent);
+  }
+
+ private:
+  NAN_INLINE PersistentBase() :
+      persistent() {}
+  NAN_INLINE explicit PersistentBase(v8::Persistent<T> that) {
+    std::memcpy(&that, &persistent, sizeof (v8::Persistent<T>));
+  }
+  NAN_INLINE explicit PersistentBase(v8::Local<T> that) :
+      persistent(v8::Isolate::GetCurrent(), that) { }
+  template<typename S, typename M> friend class Persistent;
+  template<typename S> friend class Global;
+  friend class ObjectWrap;
+};
+
+template<typename T>
+class NonCopyablePersistentTraits {
+ public:
+  typedef Persistent<T, NonCopyablePersistentTraits<T> >
+      NonCopyablePersistent;
+  static const bool kResetInDestructor = false;
+  template<typename S, typename M>
+  NAN_INLINE static void Copy(const Persistent<S, M> &source,
+                             NonCopyablePersistent *dest) {
+    Uncompilable<v8::Object>();
+  }
+
+  template<typename O> NAN_INLINE static void Uncompilable() {
+    TYPE_CHECK(O, v8::Primitive);
+  }
+};
+
+template<typename T>
+struct CopyablePersistentTraits {
+  typedef Persistent<T, CopyablePersistentTraits<T> > CopyablePersistent;
+  static const bool kResetInDestructor = true;
+  template<typename S, typename M>
+  static NAN_INLINE void Copy(const Persistent<S, M> &source,
+                             CopyablePersistent *dest) {}
+};
+
+template<typename T, typename M> class Persistent :
+    public PersistentBase<T> {
+ public:
+  NAN_INLINE Persistent() : PersistentBase<T>() {}
+
+  template<typename S> NAN_INLINE Persistent(v8::Local<S> that) :
+      PersistentBase<T>(that) {
+    TYPE_CHECK(T, S);
+  }
+
+  template<typename S, typename M2>
+  NAN_INLINE Persistent(const Persistent<S, M2> &that) :
+      PersistentBase<T>() {
+    Copy(that);
+  }
+
+  NAN_INLINE Persistent& operator=(const Persistent& that) { // NOLINT
+    Copy(that);
+    return *this;
+  }
+
+  template<typename S, typename M2>
+  NAN_INLINE Persistent& operator=(const Persistent<S, M2>& that) { // NOLINT
+    Copy(that);
+    return *this;
+  }
+
+  NAN_INLINE ~Persistent() {
+    if (M::kResetInDestructor) this->Reset();
+  }
+
  private:
   NAN_INLINE T *operator*() const { return *PersistentBase<T>::persistent; }
 
@@ -58,71 +170,97 @@ template<typename T, typename M> class Persistent :
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 template<typename T>
-class Global : public v8::Global<T> {
+class Global : public PersistentBase<T> {
  public:
-  NAN_INLINE Global() : v8::Global<T>() {}
-
-  template<typename S> NAN_INLINE Global(v8::Local<S> that) :
-    v8::Global<T>(v8::Isolate::GetCurrent(), that) {}
+  NAN_INLINE Global() : PersistentBase<T>() {}
 
-  template<typename S>
-  NAN_INLINE Global(const v8::PersistentBase<S> &that) :
-      v8::Global<S>(v8::Isolate::GetCurrent(), that) {}
-
-  NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
+  template <class S>
+  NAN_INLINE Global(v8::Local<S> that)
+      : PersistentBase<T>(that) {
+    TYPE_CHECK(T, S);
+  }
 
-  template <typename S>
-  NAN_INLINE void Reset(const v8::Local<S> &other) {
-    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  template <class S>
+  NAN_INLINE Global(const PersistentBase<S>& that)
+      : PersistentBase<T>(v8::Persistent<T>(v8::Isolate::GetCurrent(), that.persistent)) {
+    TYPE_CHECK(T, S);
   }
 
-  template <typename S>
-  NAN_INLINE void Reset(const v8::PersistentBase<S> &other) {
-    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  NAN_INLINE Global(Global&& other) : PersistentBase<T>(other.persistent) {
+    other.Empty();
   }
 
-  template<typename P>
-  NAN_INLINE void SetWeak(
-    P *parameter
-    , typename WeakCallbackInfo<P>::Callback callback
-    , WeakCallbackType type) {
-    reinterpret_cast<Persistent<T>*>(this)->SetWeak(
-        parameter, callback, type);
+  NAN_INLINE ~Global() { this->Reset(); }
+
+  template <class S>
+  NAN_INLINE Global& operator=(Global<S>&& rhs) {
+    TYPE_CHECK(T, S);
+     if (this != &rhs) {
+      std::memcpy(&rhs.persistent, &this->persistent, sizeof (v8::PersistentBase<S>));
+      rhs.Empty();
+    }
+    return *this;
   }
+
+  Global Pass() { return static_cast<Global&&>(*this); }
+
+ private:
+  Global(Global&) = delete;
+  void operator=(Global&) = delete;
 };
 #else
 template<typename T>
-class Global : public v8::UniquePersistent<T> {
- public:
-  NAN_INLINE Global() : v8::UniquePersistent<T>() {}
+class Global : public PersistentBase<T> {
+  struct RValue {
+    NAN_INLINE explicit RValue(Global* obj) : object(obj) {}
+    Global* object;
+  };
 
-  template<typename S> NAN_INLINE Global(v8::Local<S> that) :
-    v8::UniquePersistent<T>(v8::Isolate::GetCurrent(), that) {}
-
-  template<typename S>
-  NAN_INLINE Global(const v8::PersistentBase<S> &that) :
-      v8::UniquePersistent<S>(v8::Isolate::GetCurrent(), that) {}
-
-  NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
+ public:
+  NAN_INLINE Global() : PersistentBase<T>() { }
 
   template <typename S>
-  NAN_INLINE void Reset(const v8::Local<S> &other) {
-    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  NAN_INLINE Global(v8::Local<S> that)
+      : PersistentBase<T>(that) {
+    TYPE_CHECK(T, S);
   }
 
   template <typename S>
-  NAN_INLINE void Reset(const v8::PersistentBase<S> &other) {
-    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  NAN_INLINE Global(const PersistentBase<S> &that)
+    : PersistentBase<T>(v8::Persistent<T>(v8::Isolate::GetCurrent(), that.persistent)) {
+    TYPE_CHECK(T, S);
   }
 
-  template<typename P>
-  NAN_INLINE void SetWeak(
-    P *parameter
-    , typename WeakCallbackInfo<P>::Callback callback
-    , WeakCallbackType type) {
-    reinterpret_cast<Persistent<T>*>(this)->SetWeak(
-        parameter, callback, type);
+  /**
+   * Move constructor.
+   */
+  NAN_INLINE Global(RValue rvalue)
+    : PersistentBase<T>(rvalue.object->persistent) {
+    rvalue.object->Empty();
+  }
+
+  NAN_INLINE ~Global() { this->Reset(); }
+
+  /**
+   * Move via assignment.
+   */
+  template<typename S>
+  NAN_INLINE Global &operator=(Global<S> rhs) {
+    TYPE_CHECK(T, S);
+    std::memcpy(&rhs.persistent, &this->persistent, sizeof (v8::Persistent<T>));
+    rhs.Empty();
+    return *this;
   }
+
+  /**
+   * Cast operator for moves.
+   */
+  NAN_INLINE operator RValue() { return RValue(this); }
+
+  /**
+   * Pass allows returning uniques from functions, etc.
+   */
+  Global Pass() { return Global(RValue(this)); }
 };
 #endif
 
diff --git a/nan_persistent_pre_12_inl.h b/nan_persistent_pre_12_inl.h
index 8212f583..a19da8b3 100644
--- a/nan_persistent_pre_12_inl.h
+++ b/nan_persistent_pre_12_inl.h
@@ -99,6 +99,10 @@ class PersistentBase {
 
   NAN_INLINE bool IsWeak() const { return persistent.IsWeak(); }
 
+  NAN_INLINE v8::Local<T> Get() const {
+    return v8::Local<T>::New(persistent);
+  }
+
  private:
   NAN_INLINE explicit PersistentBase(v8::Persistent<T> that) :
       persistent(that) { }
@@ -203,7 +207,7 @@ class Global : public PersistentBase<T> {
 
   template <typename S>
   NAN_INLINE Global(const PersistentBase<S> &that)
-    : PersistentBase<T>(that) {
+    : PersistentBase<T>(v8::Persistent<T>::New(that.persistent)) {
     TYPE_CHECK(T, S);
   }
   /**
@@ -211,7 +215,7 @@ class Global : public PersistentBase<T> {
    */
   NAN_INLINE Global(RValue rvalue)
     : PersistentBase<T>(rvalue.object.persistent) {
-    rvalue.object->Reset();
+    rvalue.object->Clear();
   }
   NAN_INLINE ~Global() { this->Reset(); }
   /**
@@ -220,8 +224,8 @@ class Global : public PersistentBase<T> {
   template<typename S>
   NAN_INLINE Global &operator=(Global<S> rhs) {
     TYPE_CHECK(T, S);
-    this->Reset(rhs.persistent);
-    rhs.Reset();
+    this->persistent = rhs.persistent;
+    rhs.Clear();
     return *this;
   }
   /**
diff --git a/nan_weak.h b/nan_weak.h
index 0ea72350..11bfcdb7 100644
--- a/nan_weak.h
+++ b/nan_weak.h
@@ -243,9 +243,9 @@ WeakCallbackInfo<T> *WeakCallbackInfo<T>::unwrap(
 
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
-template<typename T, typename M>
+template<typename T>
 template<typename P>
-NAN_INLINE void Persistent<T, M>::SetWeak(
+NAN_INLINE void PersistentBase<T>::SetWeak(
     P *parameter
   , typename WeakCallbackInfo<P>::Callback callback
   , WeakCallbackType type) {
@@ -255,7 +255,7 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
         reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , parameter);
-    v8::PersistentBase<T>::SetWeak(
+    persistent.SetWeak(
         wcbd
       , WeakCallbackInfo<P>::invokeparameter
       , type);
@@ -274,16 +274,16 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
       , internal_fields[0]
       , internal_fields[1]);
     (*self)->SetAlignedPointerInInternalField(0, wcbd);
-    v8::PersistentBase<T>::SetWeak(
+    persistent.SetWeak(
         static_cast<WeakCallbackInfo<P>*>(0)
       , WeakCallbackInfo<P>::invoketwofield
       , type);
   }
 }
 #elif NODE_MODULE_VERSION > IOJS_1_1_MODULE_VERSION
-template<typename T, typename M>
+template<typename T>
 template<typename P>
-NAN_INLINE void Persistent<T, M>::SetWeak(
+NAN_INLINE void PersistentBase<T>::SetWeak(
     P *parameter
   , typename WeakCallbackInfo<P>::Callback callback
   , WeakCallbackType type) {
@@ -293,7 +293,7 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
         reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , parameter);
-    v8::PersistentBase<T>::SetPhantom(
+    persistent.SetPhantom(
         wcbd
       , WeakCallbackInfo<P>::invokeparameter);
   } else {
@@ -311,7 +311,7 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
       , internal_fields[0]
       , internal_fields[1]);
     (*self)->SetAlignedPointerInInternalField(0, wcbd);
-    v8::PersistentBase<T>::SetPhantom(
+    persistent.SetPhantom(
         static_cast<WeakCallbackInfo<P>*>(0)
       , WeakCallbackInfo<P>::invoketwofield
       , 0
@@ -319,9 +319,9 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
   }
 }
 #elif NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
-template<typename T, typename M>
+template<typename T>
 template<typename P>
-NAN_INLINE void Persistent<T, M>::SetWeak(
+NAN_INLINE void PersistentBase<T>::SetWeak(
     P *parameter
   , typename WeakCallbackInfo<P>::Callback callback
   , WeakCallbackType type) {
@@ -331,7 +331,7 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
         reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , parameter);
-    v8::PersistentBase<T>::SetPhantom(
+    persistent.SetPhantom(
         wcbd
       , WeakCallbackInfo<P>::invokeparameter);
   } else {
@@ -349,16 +349,16 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
       , internal_fields[0]
       , internal_fields[1]);
     (*self)->SetAlignedPointerInInternalField(0, wcbd);
-    v8::PersistentBase<T>::SetPhantom(
+    persistent.SetPhantom(
         WeakCallbackInfo<P>::invoketwofield
       , 0
       , count > 1 ? 1 : kNoInternalFieldIndex);
   }
 }
 #elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
-template<typename T, typename M>
+template<typename T>
 template<typename P>
-NAN_INLINE void Persistent<T, M>::SetWeak(
+NAN_INLINE void PersistentBase<T>::SetWeak(
     P *parameter
   , typename WeakCallbackInfo<P>::Callback callback
   , WeakCallbackType type) {
@@ -368,7 +368,7 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
         reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , parameter);
-    v8::PersistentBase<T>::SetWeak(wcbd, WeakCallbackInfo<P>::invoke);
+    persistent.SetWeak(wcbd, WeakCallbackInfo<P>::invoke);
   } else {
     v8::Local<T>* self = reinterpret_cast<v8::Local<T>*>(this);
     assert((*self)->IsObject());
@@ -383,7 +383,7 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
       , 0
       , internal_fields[0]
       , internal_fields[1]);
-    v8::PersistentBase<T>::SetWeak(wcbd, WeakCallbackInfo<P>::invoke);
+    persistent.SetWeak(wcbd, WeakCallbackInfo<P>::invoke);
   }
 }
 #else
diff --git a/test/cpp/persistent.cpp b/test/cpp/persistent.cpp
index 7a333b30..67d628bc 100644
--- a/test/cpp/persistent.cpp
+++ b/test/cpp/persistent.cpp
@@ -29,7 +29,7 @@ NAN_METHOD(Dispose1) {
 
 NAN_METHOD(ToPersistentAndBackAgain) {
   Persistent<v8::Object> persistent(info[0].As<v8::Object>());
-  v8::Local<v8::Object> object = New(persistent);
+  v8::Local<v8::Object> object = persistent.Get();
   persistent.Reset();
   memset(&persistent, -1, sizeof(persistent));  // Clobber it good.
   info.GetReturnValue().Set(object);