diff --git a/src/domain.cc b/src/domain.cc
index fb5b8ff..e34402e 100644
--- a/src/domain.cc
+++ b/src/domain.cc
@@ -306,7 +306,7 @@ NAN_METHOD(Domain::LookupById)
 NLV_WORKER_EXECUTE(Domain, LookupById)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
-  lookupHandle_ = virDomainLookupByID(parent_->handle_, id_);
+  lookupHandle_ = virDomainLookupByID(parent_->handle(), id_);
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
@@ -318,7 +318,7 @@ NLV_WORKER_EXECUTE(Domain, Create)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
   unsigned int flags = 0;
-  lookupHandle_ = virDomainCreateXML(parent_->handle_, value_.c_str(), flags);
+  lookupHandle_ = virDomainCreateXML(parent_->handle(), value_.c_str(), flags);
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
@@ -329,7 +329,7 @@ NLV_WORKER_METHOD_DEFINE(Domain)
 NLV_WORKER_EXECUTE(Domain, Define)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
-  lookupHandle_ = virDomainDefineXML(parent_->handle_, value_.c_str());
+  lookupHandle_ = virDomainDefineXML(parent_->handle(), value_.c_str());
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
@@ -348,7 +348,7 @@ NAN_METHOD(Domain::Save)
   std::string path(*Nan::Utf8String(info[0]->ToString()));
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new SaveWorker(callback, domain->handle_, path));
+  Nan::AsyncQueueWorker(new SaveWorker(callback, domain->handle(), path));
   return;
 }
 
@@ -382,7 +382,7 @@ NAN_METHOD(Domain::Restore)
   std::string path(*Nan::Utf8String(info[0]->ToString()));
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Hypervisor *hv = Nan::ObjectWrap::Unwrap<Hypervisor>(object);
-  Nan::AsyncQueueWorker(new RestoreWorker(callback, hv->handle_, path));
+  Nan::AsyncQueueWorker(new RestoreWorker(callback, hv->handle(), path));
   return;
 }
 
@@ -410,7 +410,7 @@ NAN_METHOD(Domain::CoreDump)
   std::string path(*Nan::Utf8String(info[0]->ToString()));
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new CoreDumpWorker(callback, domain->handle_, path));
+  Nan::AsyncQueueWorker(new CoreDumpWorker(callback, domain->handle(), path));
   return;
 }
 
@@ -723,7 +723,7 @@ NAN_METHOD(Domain::SetAutostart)
   bool autoStart = info[0]->IsTrue();
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new SetAutostartWorker(callback, domain->handle_, autoStart));
+  Nan::AsyncQueueWorker(new SetAutostartWorker(callback, domain->handle(), autoStart));
   return;
 }
 
@@ -752,7 +752,7 @@ NAN_METHOD(Domain::SetMaxMemory)
   // @todo this unsafe, also needs bounds checking!
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new SetMaxMemoryWorker(callback, domain->handle_, maxMemory));
+  Nan::AsyncQueueWorker(new SetMaxMemoryWorker(callback, domain->handle(), maxMemory));
   return;
 }
 
@@ -781,7 +781,7 @@ NAN_METHOD(Domain::SetMemory)
   // @todo this unsafe, also needs bounds checking!
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new SetMemoryWorker(callback, domain->handle_, memory));
+  Nan::AsyncQueueWorker(new SetMemoryWorker(callback, domain->handle(), memory));
   return;
 }
 
@@ -813,7 +813,7 @@ NAN_METHOD(Domain::ToXml)
     return;
   }
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new ToXmlWorker(callback, domain->handle_, flags));
+  Nan::AsyncQueueWorker(new ToXmlWorker(callback, domain->handle(), flags));
   return;
 }
 
@@ -858,7 +858,7 @@ NAN_METHOD(Domain::GetMetadata)
     return;
   }
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new GetMetadataWorker(callback, domain->handle_, type, namespace_uri, flags));
+  Nan::AsyncQueueWorker(new GetMetadataWorker(callback, domain->handle(), type, namespace_uri, flags));
   return;
 #endif
 }
@@ -921,7 +921,7 @@ NAN_METHOD(Domain::SetMetadata)
     return;
   }
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new SetMetadataWorker(callback, domain->handle_, type, null_metadata, metadata, namespace_key, namespace_uri, flags));
+  Nan::AsyncQueueWorker(new SetMetadataWorker(callback, domain->handle(), type, null_metadata, metadata, namespace_key, namespace_uri, flags));
   return;
 #endif
 }
@@ -1000,7 +1000,7 @@ NAN_METHOD(Domain::GetBlockInfo)
   std::string path(*Nan::Utf8String(info[0]->ToString()));
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new GetBlockInfoWorker(callback, domain->handle_, path));
+  Nan::AsyncQueueWorker(new GetBlockInfoWorker(callback, domain->handle(), path));
   return;
 }
 
@@ -1039,7 +1039,7 @@ NAN_METHOD(Domain::GetBlockStats)
   std::string path(*Nan::Utf8String(info[0]->ToString()));
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new GetBlockStatsWorker(callback, domain->handle_, path));
+  Nan::AsyncQueueWorker(new GetBlockStatsWorker(callback, domain->handle(), path));
   return;
 }
 
@@ -1137,7 +1137,7 @@ NAN_METHOD(Domain::GetInterfaceStats)
   std::string interface(*Nan::Utf8String(info[0]->ToString()));
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new GetInterfaceStatsWorker(callback, domain->handle_, interface));
+  Nan::AsyncQueueWorker(new GetInterfaceStatsWorker(callback, domain->handle(), interface));
   return;
 }
 
@@ -1313,7 +1313,7 @@ NAN_METHOD(Domain::AttachDevice)
   }
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new AttachDeviceWorker(callback, domain->handle_, xml, flags));
+  Nan::AsyncQueueWorker(new AttachDeviceWorker(callback, domain->handle(), xml, flags));
   return;
 }
 
@@ -1359,7 +1359,7 @@ NAN_METHOD(Domain::DetachDevice)
   }
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new DetachDeviceWorker(callback, domain->handle_, xml, flags));
+  Nan::AsyncQueueWorker(new DetachDeviceWorker(callback, domain->handle(), xml, flags));
   return;
 }
 
@@ -1405,7 +1405,7 @@ NAN_METHOD(Domain::UpdateDevice)
   }
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
-  Nan::AsyncQueueWorker(new UpdateDeviceWorker(callback, domain->handle_, xml, flags));
+  Nan::AsyncQueueWorker(new UpdateDeviceWorker(callback, domain->handle(), xml, flags));
   return;
 }
 
@@ -1500,7 +1500,7 @@ NAN_METHOD(Domain::SetVcpus)
   unsigned int count = info[0]->Int32Value();
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
-  Nan::AsyncQueueWorker(new SetVcpusWorker(callback, domain->handle_, count));
+  Nan::AsyncQueueWorker(new SetVcpusWorker(callback, domain->handle(), count));
   return;
 }
 
@@ -1534,7 +1534,7 @@ NAN_METHOD(Domain::BlockCommit)
   unsigned long bandwidth = info[3]->Int32Value();
   unsigned int flags = GetFlags(info[4]);
     
-  virDomainPtr domain = Nan::ObjectWrap::Unwrap<Domain>(info.This())->handle_;
+  virDomainPtr domain = Nan::ObjectWrap::Unwrap<Domain>(info.This())->handle();
   Worker::RunAsync(info, [=] (Worker::SetOnFinishedHandler onFinished) {
     if (virDomainBlockCommit(domain, path.c_str(), base.c_str(), top.c_str(), bandwidth, flags) < 0) {
       return virSaveLastError();
@@ -1558,7 +1558,7 @@ NAN_METHOD(Domain::BlockJobInfo)
   std::string path(*Nan::Utf8String(info[0]->ToString()));
   unsigned int flags = GetFlags(info[1]);
   
-  virDomainPtr domain = Nan::ObjectWrap::Unwrap<Domain>(info.This())->handle_;
+  virDomainPtr domain = Nan::ObjectWrap::Unwrap<Domain>(info.This())->handle();
   Worker::RunAsync(info, [=] (Worker::SetOnFinishedHandler onFinished) {
     virDomainBlockJobInfo info;
     int ret = virDomainGetBlockJobInfo(domain, path.c_str(), &info, flags);
@@ -1596,7 +1596,7 @@ NAN_METHOD(Domain::BlockJobAbort)
   std::string path(*Nan::Utf8String(info[0]->ToString()));
   unsigned int flags = GetFlags(info[1]);
   
-  virDomainPtr domain = Nan::ObjectWrap::Unwrap<Domain>(info.This())->handle_;
+  virDomainPtr domain = Nan::ObjectWrap::Unwrap<Domain>(info.This())->handle();
 
   Worker::RunAsync(info, [=] (Worker::SetOnFinishedHandler onFinished) {
     //abort_flags |= VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT;
@@ -1626,7 +1626,7 @@ NAN_METHOD(Domain::SendKeys)
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
-  Nan::AsyncQueueWorker(new SendKeysWorker(callback, domain->handle_, keys));
+  Nan::AsyncQueueWorker(new SendKeysWorker(callback, domain->handle(), keys));
   return;
 }
 
@@ -1689,9 +1689,9 @@ NAN_METHOD(Domain::Migrate)
     }
 
     Hypervisor *hypervisor = Nan::ObjectWrap::Unwrap<Hypervisor>(hyp_obj);
-    worker = new MigrateWorker(callback, domain->handle_, hypervisor->handle_);
+    worker = new MigrateWorker(callback, domain->handle(), hypervisor->handle());
   } else {
-    worker = new MigrateWorker(callback, domain->handle_, dest_uri);
+    worker = new MigrateWorker(callback, domain->handle(), dest_uri);
   }
 
   worker->setBandwidth(bandwidth);
@@ -1761,7 +1761,7 @@ NAN_METHOD(Domain::PinVcpu) {
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   Nan::Callback *callback = new Nan::Callback(info[2].As<Function>());
-  Nan::AsyncQueueWorker(new PinVcpuWorker(callback, domain->handle_, info[0]->Int32Value(), usables, vcpus));
+  Nan::AsyncQueueWorker(new PinVcpuWorker(callback, domain->handle(), info[0]->Int32Value(), usables, vcpus));
   return;
 }
 
@@ -1822,7 +1822,7 @@ NAN_METHOD(Domain::MemoryPeek)
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   Nan::Callback *callback = new Nan::Callback(info[3].As<Function>());
-  Nan::AsyncQueueWorker(new MemoryPeekWorker(callback, domain->handle_, start, size, flags));
+  Nan::AsyncQueueWorker(new MemoryPeekWorker(callback, domain->handle(), start, size, flags));
   return;
 }
 
@@ -1864,7 +1864,7 @@ NAN_METHOD(Domain::BlockPeek)
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   Nan::Callback *callback = new Nan::Callback(info[4].As<Function>());
-  Nan::AsyncQueueWorker(new BlockPeekWorker(callback, domain->handle_, path, start, size, flags));
+  Nan::AsyncQueueWorker(new BlockPeekWorker(callback, domain->handle(), path, start, size, flags));
   return;
 }
 
@@ -1908,7 +1908,7 @@ NAN_METHOD(Domain::RevertToSnapshot) {
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
-  Nan::AsyncQueueWorker(new RevertToSnapshotWorker(callback, domain->handle_, *Nan::Utf8String(info[0]->ToString())));
+  Nan::AsyncQueueWorker(new RevertToSnapshotWorker(callback, domain->handle(), *Nan::Utf8String(info[0]->ToString())));
   return;
 }
 
@@ -1951,7 +1951,7 @@ NAN_METHOD(Domain::TakeSnapshot) {
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   Nan::Callback *callback = new Nan::Callback(info[2].As<Function>());
-  Nan::AsyncQueueWorker(new TakeSnapshotWorker(callback, domain->handle_, *Nan::Utf8String(info[0]->ToString()), flags));
+  Nan::AsyncQueueWorker(new TakeSnapshotWorker(callback, domain->handle(), *Nan::Utf8String(info[0]->ToString()), flags));
   return;
 }
 
@@ -1979,7 +1979,7 @@ NAN_METHOD(Domain::DeleteSnapshot) {
   std::string name = *Nan::Utf8String(info[0]->ToString());
   unsigned int flags = GetFlags(info[1]);
 
-  auto domain = Nan::ObjectWrap::Unwrap<Domain>(info.This())->handle_;
+  auto domain = Nan::ObjectWrap::Unwrap<Domain>(info.This())->handle();
   //Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Worker::RunAsync(info, [=](Worker::SetOnFinishedHandler onFinished) {
     auto snapshot = virDomainSnapshotLookupByName(domain, name.c_str(), 0);
@@ -2008,7 +2008,7 @@ NAN_METHOD(Domain::LookupSnapshotByName) {
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
-  Nan::AsyncQueueWorker(new LookupSnapshotByNameWorker(callback, domain->handle_, *Nan::Utf8String(info[0]->ToString())));
+  Nan::AsyncQueueWorker(new LookupSnapshotByNameWorker(callback, domain->handle(), *Nan::Utf8String(info[0]->ToString())));
   return;
 }
 
@@ -2071,7 +2071,7 @@ NAN_METHOD(Domain::SetMigrationMaxDowntime) {
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
-  Nan::AsyncQueueWorker(new SetMigrationMaxDowntimeWorker(callback, domain->handle_, info[0]->Int32Value(), flags));
+  Nan::AsyncQueueWorker(new SetMigrationMaxDowntimeWorker(callback, domain->handle(), info[0]->Int32Value(), flags));
   return;
 }
 
@@ -2146,7 +2146,7 @@ NAN_METHOD(Domain::RegisterEvent)
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   int eventId = arg_obj->Get(Nan::New("evtype").ToLocalChecked())->Int32Value();
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
-  Nan::AsyncQueueWorker(new RegisterEventWorker(callback, domain->handle_, domain, eventId));
+  Nan::AsyncQueueWorker(new RegisterEventWorker(callback, domain->handle(), domain, eventId));
   return;
 }
 
@@ -2207,7 +2207,7 @@ NAN_METHOD(Domain::UnregisterEvent)
 
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
-  Nan::AsyncQueueWorker(new UnregisterEventWorker(callback, domain->handle_, info[0]->Int32Value()));
+  Nan::AsyncQueueWorker(new UnregisterEventWorker(callback, domain->handle(), info[0]->Int32Value()));
   return;
 }
 
@@ -2242,7 +2242,7 @@ NAN_METHOD(Domain::SetSchedulerParameters)
   Local<Object> newparams = info[0]->ToObject();
   Domain *domain = Nan::ObjectWrap::Unwrap<Domain>(info.This());
 
-  type = virDomainGetSchedulerType(domain->handle_, &nparams);
+  type = virDomainGetSchedulerType(domain->handle(), &nparams);
   if (type == NULL) {
     ThrowLastVirError();
     return info.GetReturnValue().Set(Nan::False());
@@ -2257,7 +2257,7 @@ NAN_METHOD(Domain::SetSchedulerParameters)
 
   memset(params, 0, sizeof(*params) * nparams);
 
-  ret = virDomainGetSchedulerParameters(domain->handle_, params, &nparams);
+  ret = virDomainGetSchedulerParameters(domain->handle(), params, &nparams);
   if(ret == -1) {
     ThrowLastVirError();
     free(params);
@@ -2294,7 +2294,7 @@ NAN_METHOD(Domain::SetSchedulerParameters)
     }
   }
 
-  ret = virDomainSetSchedulerParameters(domain->handle_, params, nparams);
+  ret = virDomainSetSchedulerParameters(domain->handle(), params, nparams);
   if (ret == -1) {
     ThrowLastVirError();
     free(params);
diff --git a/src/hypervisor.cc b/src/hypervisor.cc
index 3ebe001..e849129 100644
--- a/src/hypervisor.cc
+++ b/src/hypervisor.cc
@@ -265,8 +265,8 @@ NAN_METHOD(Hypervisor::Connect)
       return 0;
     };
     auth.cbdata = hv;
-    hv->handle_ = virConnectOpenAuth(uri.c_str(), &auth,
-                       hv->readOnly_ ? VIR_CONNECT_RO : 0);
+    hv->handle_.reset(virConnectOpenAuth(uri.c_str(), &auth,
+                       hv->readOnly_ ? VIR_CONNECT_RO : 0));
     return onFinished(PrimitiveReturnHandler(true));
   });
 }
@@ -297,7 +297,7 @@ NLV_WORKER_EXECUTE(Hypervisor, Disconnect)
   // }
 
   // assert(result == 0);
-  // hypervisor_->handle_ = NULL;
+  // hypervisor_->handle() = NULL;
 }
 
 #define HYPERVISOR_STRING_RETURN_EXECUTE(MethodName, Accessor)  \
@@ -437,7 +437,7 @@ NAN_METHOD(Hypervisor::GetMaxVcpus)
   std::string type(*Nan::Utf8String(info[0]));
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Hypervisor *hypervisor = Nan::ObjectWrap::Unwrap<Hypervisor>(info.This());
-  Nan::AsyncQueueWorker(new GetMaxVcpusWorker(callback, hypervisor->handle_, type));
+  Nan::AsyncQueueWorker(new GetMaxVcpusWorker(callback, hypervisor->handle(), type));
   return;
 }
 
@@ -482,7 +482,7 @@ NAN_METHOD(Hypervisor::SetKeepAlive)
   unsigned int count = info[1]->IntegerValue();
   Nan::Callback *callback = new Nan::Callback(info[2].As<Function>());
   Hypervisor *hypervisor = Nan::ObjectWrap::Unwrap<Hypervisor>(info.This());
-  Nan::AsyncQueueWorker(new SetKeepAliveWorker(callback, hypervisor->handle_, interval, count));
+  Nan::AsyncQueueWorker(new SetKeepAliveWorker(callback, hypervisor->handle(), interval, count));
   return;
 }
 
@@ -521,7 +521,7 @@ NAN_METHOD(Hypervisor::GetBaselineCPU)
 
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Hypervisor *hypervisor = Nan::ObjectWrap::Unwrap<Hypervisor>(info.This());
-  Nan::AsyncQueueWorker(new GetBaselineCPUWorker(callback, hypervisor->handle_, cpus, count, flags));
+  Nan::AsyncQueueWorker(new GetBaselineCPUWorker(callback, hypervisor->handle(), cpus, count, flags));
   return;
 }
 
@@ -557,7 +557,7 @@ NAN_METHOD(Hypervisor::CompareCPU)
   std::string cpu(*Nan::Utf8String(info[0]->ToString()));
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Hypervisor *hypervisor = Nan::ObjectWrap::Unwrap<Hypervisor>(info.This());
-  Nan::AsyncQueueWorker(new CompareCPUWorker(callback, hypervisor->handle_, cpu, flags));
+  Nan::AsyncQueueWorker(new CompareCPUWorker(callback, hypervisor->handle(), cpu, flags));
   return;
 }
 
@@ -714,7 +714,7 @@ NAN_METHOD(Hypervisor::ListNodeDevices)
   }
 
   Hypervisor *hypervisor = Nan::ObjectWrap::Unwrap<Hypervisor>(info.This());
-  Nan::AsyncQueueWorker(new ListNodeDevicesWorker(callback, hypervisor->handle_, capability));
+  Nan::AsyncQueueWorker(new ListNodeDevicesWorker(callback, hypervisor->handle(), capability));
   return;
 }
 
@@ -833,7 +833,7 @@ NAN_METHOD(Hypervisor::GetNodeMemoryStats)
   Hypervisor *hypervisor = Nan::ObjectWrap::Unwrap<Hypervisor>(info.This());
   int numCells = info[0]->IntegerValue();
   int flags = info[1]->IntegerValue();
-  Nan::AsyncQueueWorker(new GetNodeMemoryStatsWorker(callback, hypervisor->handle_, numCells, flags));
+  Nan::AsyncQueueWorker(new GetNodeMemoryStatsWorker(callback, hypervisor->handle(), numCells, flags));
   return;
 }
 
@@ -881,7 +881,7 @@ NAN_METHOD(Hypervisor::GetNodeCellsFreeMemory)
 
   Nan::Callback *callback = new Nan::Callback(info[2].As<Function>());
   Hypervisor *hypervisor = Nan::ObjectWrap::Unwrap<Hypervisor>(info.This());
-  Nan::AsyncQueueWorker(new GetNodeCellsFreeMemoryWorker(callback, hypervisor->handle_, startCell, maxCells));
+  Nan::AsyncQueueWorker(new GetNodeCellsFreeMemoryWorker(callback, hypervisor->handle(), startCell, maxCells));
   return;
 }
 
diff --git a/src/hypervisor.h b/src/hypervisor.h
index 64b3325..0caa026 100644
--- a/src/hypervisor.h
+++ b/src/hypervisor.h
@@ -99,7 +99,7 @@ class Hypervisor : public NLVObject<Hypervisor, virConnectPtr, HypervisorCleanup
   class DisconnectWorker : public NLVAsyncWorker<virConnectPtr> {
   public:
     DisconnectWorker(Nan::Callback *callback, Hypervisor *hypervisor)
-      : NLVAsyncWorker(callback, hypervisor->handle_), hypervisor_(hypervisor) {}
+      : NLVAsyncWorker(callback, hypervisor->handle()), hypervisor_(hypervisor) {}
     void Execute();
   private:
     Hypervisor *hypervisor_;
@@ -238,7 +238,6 @@ class Hypervisor : public NLVObject<Hypervisor, virConnectPtr, HypervisorCleanup
   private:
     virNodeInfo info_;
   };
-
 };
 
 }  // namespace NLV
diff --git a/src/interface.cc b/src/interface.cc
index 7cbabdc..85f476b 100644
--- a/src/interface.cc
+++ b/src/interface.cc
@@ -66,7 +66,7 @@ NLV_WORKER_METHOD_DEFINE(Interface)
 NLV_WORKER_EXECUTE(Interface, Define)
 {
   unsigned int flags = 0;
-  lookupHandle_ = virInterfaceDefineXML(parent_->handle_, value_.c_str(), flags);
+  lookupHandle_ = virInterfaceDefineXML(parent_->handle(), value_.c_str(), flags);
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
diff --git a/src/network.cc b/src/network.cc
index 92d2967..50aa0bc 100644
--- a/src/network.cc
+++ b/src/network.cc
@@ -80,7 +80,7 @@ NLV_WORKER_METHOD_CREATE(Network)
 NLV_WORKER_EXECUTE(Network, Create)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
-  lookupHandle_ = virNetworkCreateXML(parent_->handle_, value_.c_str());
+  lookupHandle_ = virNetworkCreateXML(parent_->handle(), value_.c_str());
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
@@ -91,7 +91,7 @@ NLV_WORKER_METHOD_DEFINE(Network)
 NLV_WORKER_EXECUTE(Network, Define)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
-  lookupHandle_ = virNetworkDefineXML(parent_->handle_, value_.c_str());
+  lookupHandle_ = virNetworkDefineXML(parent_->handle(), value_.c_str());
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
@@ -166,7 +166,7 @@ NAN_METHOD(Network::SetAutostart)
   bool autoStart = info[0]->IsTrue();
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Network *network = ObjectWrap::Unwrap<Network>(info.This());
-  Nan::AsyncQueueWorker(new SetAutostartWorker(callback, network->handle_, autoStart));
+  Nan::AsyncQueueWorker(new SetAutostartWorker(callback, network->handle(), autoStart));
   return;
 }
 
diff --git a/src/network_filter.cc b/src/network_filter.cc
index 0985004..1c47d23 100644
--- a/src/network_filter.cc
+++ b/src/network_filter.cc
@@ -75,7 +75,7 @@ NLV_WORKER_METHOD_DEFINE(NetworkFilter)
 NLV_WORKER_EXECUTE(NetworkFilter, Define)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
-  lookupHandle_ = virNWFilterDefineXML(parent_->handle_, value_.c_str());
+  lookupHandle_ = virNWFilterDefineXML(parent_->handle(), value_.c_str());
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
diff --git a/src/nlv_async_worker.h b/src/nlv_async_worker.h
index 658bb11..6136483 100644
--- a/src/nlv_async_worker.h
+++ b/src/nlv_async_worker.h
@@ -47,7 +47,6 @@ class NLVAsyncWorker : public NLVAsyncWorkerBase
 
 private:
   T handle_;
-
 };
 
 /**
@@ -279,7 +278,7 @@ class NLVTypedParameterReturnWorker : public NLVAsyncWorker<HandleType>
 
 #define NLV_LOOKUP_BY_VALUE_EXECUTE_IMPL(Class, Method, Accessor) \
   NLV_WORKER_EXECUTE(Class, Method) { \
-    lookupHandle_ = Accessor(parent_->handle_, value_.c_str());  \
+    lookupHandle_ = Accessor(parent_->handle_.get(), value_.c_str());  \
     if (lookupHandle_ == NULL) { \
       SetVirError(virSaveLastError()); \
       return; \
@@ -304,11 +303,8 @@ class NLVLookupInstanceByValueWorker : public NLVAsyncWorkerBase
     if (parentObject->IsObject()) {
       childObject->Set(Nan::New("_parent").ToLocalChecked(), parentObject);
     }
-
     InstanceClass *child = Nan::ObjectWrap::Unwrap<InstanceClass>(childObject);
-    NLVObjectBasePtr *childPtr = new NLVObjectBasePtr(child);
-    child->SetParentReference(childPtr);
-    parent_->children_.push_back(childPtr);
+    child->AddToParent(parent_);
     v8::Local<v8::Value> argv[] = { Nan::Null(), childObject };
     callback->Call(2, argv);
   }
diff --git a/src/nlv_object.h b/src/nlv_object.h
index 9220495..a1a863a 100644
--- a/src/nlv_object.h
+++ b/src/nlv_object.h
@@ -5,37 +5,15 @@
 #include <assert.h>
 
 #include <nan.h>
+#include <memory>
+#include <type_traits>
+#include <forward_list>
+
 using namespace node;
 using namespace v8;
 
 class NLVObjectBase;
 
-// hold a reference to a "child" object in a way that can be safely invalidated
-// if the child is destroyed by the GC before the parent.
-class NLVObjectBasePtr
-{
-public:
-  NLVObjectBasePtr(NLVObjectBase *ref) : ref_(ref), valid_(true) {}
-  bool IsValid() const { return valid_; }
-  NLVObjectBase* GetPointer() const {
-    if (!valid_) {
-      //Nan::ThrowReferenceError("attempt to access invalid NLVObjectBase pointer");
-      return NULL;
-    }
-
-    return ref_;
-  }
-
-  void SetInvalid() {
-    ref_ = NULL;
-    valid_ = false;
-  }
-
-protected:
-  NLVObjectBase *ref_;
-  bool valid_;
-};
-
 #define NLV_STRINGIFY0(v) #v
 #define NLV_STRINGIFY(v) NLV_STRINGIFY0(v)
 
@@ -48,36 +26,58 @@ class NLVObjectBasePtr
   friend class NLVObject;
 
 
-class NLVObjectBase : public Nan::ObjectWrap
+class NLVObjectBase : public Nan::ObjectWrap, public std::enable_shared_from_this<NLVObjectBase>
 {
 public:
+  void AddToParent(NLVObjectBase* parent) {
+    parent->PushChild(shared_from_this());
+  }
+  
+  void ClearChildren() {
+    for (auto& ptr: children_) {
+      if (auto object = ptr.lock()) {
+        object->ClearHandle();
+        object->ClearChildren();
+      }
+    }
+    children_.clear();
+  }
+
   virtual void ClearHandle() = 0;
-  virtual void ClearChildren() = 0;
-  virtual void SetParentReference(NLVObjectBasePtr *parentReference) = 0;
 
-  std::vector<NLVObjectBasePtr*> children_;
+  void PushChild(const std::shared_ptr<NLVObjectBase>& child) {
+    children_.emplace_front(child);
+  }
+  std::forward_list<std::weak_ptr<NLVObjectBase>> children_;
 };
 
 template <typename ParentClass, typename HandleType, typename CleanupHandler>
 class NLVObject : public NLVObjectBase
 {
+  std::shared_ptr<NLVObjectBase> selfPtr;
 public:
   typedef HandleType handle_type;
-
-  NLVObject(HandleType handle) : handle_(handle), parentReference_(NULL) {}
+  typedef typename std::remove_pointer<HandleType>::type HandleValue;
+    
+  NLVObject(HandleType handle) : handle_(handle, CleanupHandler::cleanup) {
+  }
+  
   ~NLVObject() {
-    // calling virtual ClearHandle() will break if overridden by subclasses
-    ClearHandle();
-    if (parentReference_ != NULL) {
-      parentReference_->SetInvalid();
-    }
+  }
+  
+  void RegisterSelf() {
+    selfPtr = shared_from_this();
   }
 
   static v8::Local<v8::Object> NewInstance(handle_type handle) {
     Nan::EscapableHandleScope scope;
     Local<Function> ctor = Nan::New<Function>(ParentClass::constructor);
     Local<Object> object = Nan::NewInstance(ctor).ToLocalChecked();
-    ParentClass *class_instance = new ParentClass(handle);
+    auto shared = std::shared_ptr<ParentClass>(new ParentClass(handle), [=](ParentClass*) {
+      // here we can now if GC has destroyed our object
+    });
+    ParentClass *class_instance = shared.get();
+    class_instance->RegisterSelf();
     class_instance->Wrap(object);
     return scope.Escape(object);
   }
@@ -87,8 +87,8 @@ class NLVObject : public NLVObjectBase
     return Nan::New(ParentClass::constructor_template)->HasInstance(val);
   }
 
-  HandleType handle() const {
-    return handle_;
+  const HandleType handle() const {
+    return handle_.get();
   }
 
   NAN_INLINE static ParentClass* Unwrap(v8::Local<v8::Object> val) {
@@ -121,38 +121,12 @@ class NLVObject : public NLVObjectBase
     return Unwrap(val)->handle();
   }
 
-  virtual void ClearHandle() {
-    if (handle_ != NULL) {
-      int result = CleanupHandler::cleanup(handle_);
-      assert(result == 0);
-      handle_ = NULL;
-    }
-  }
-
-  virtual void ClearChildren() {
-    std::vector<NLVObjectBasePtr*>::const_iterator it;
-    for (it = children_.begin(); it != children_.end(); ++it) {
-      NLVObjectBasePtr *ptr = *it;
-      if (ptr->IsValid()) {
-        NLVObjectBase *obj = ptr->GetPointer();
-        obj->ClearChildren();
-        obj->ClearHandle();
-        obj->SetParentReference(NULL);
-        delete ptr;
-      }
-    }
-
-    children_.clear();
-  }
-
-  virtual void SetParentReference(NLVObjectBasePtr *parentReference) {
-    parentReference_ = parentReference;
+  void ClearHandle() {
+    handle_.reset();
   }
 
 protected:
-  HandleType handle_;
-  NLVObjectBasePtr* parentReference_;
-
+  std::unique_ptr<HandleValue, decltype(&CleanupHandler::cleanup)> handle_;
 };
 
 namespace NLV {
diff --git a/src/node_device.cc b/src/node_device.cc
index d34e991..319496e 100644
--- a/src/node_device.cc
+++ b/src/node_device.cc
@@ -79,7 +79,7 @@ NLV_WORKER_EXECUTE(NodeDevice, Create)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
   unsigned int flags = 0;
-  lookupHandle_ = virNodeDeviceCreateXML(parent_->handle_, value_.c_str(), flags);
+  lookupHandle_ = virNodeDeviceCreateXML(parent_->handle(), value_.c_str(), flags);
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
diff --git a/src/secret.cc b/src/secret.cc
index cbd21dd..59ed199 100644
--- a/src/secret.cc
+++ b/src/secret.cc
@@ -33,7 +33,7 @@ NLV_WORKER_EXECUTE(Secret, Define)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
   unsigned int flags = 0;
-  lookupHandle_ = virSecretDefineXML(parent_->handle_, value_.c_str(), flags);
+  lookupHandle_ = virSecretDefineXML(parent_->handle(), value_.c_str(), flags);
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
@@ -93,7 +93,7 @@ NAN_METHOD(Secret::LookupByUsage)
 NLV_WORKER_EXECUTE(Secret, LookupByUsage)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
-  lookupHandle_ = virSecretLookupByUsage(parent_->handle_, usageType_, value_.c_str());
+  lookupHandle_ = virSecretLookupByUsage(parent_->handle(), usageType_, value_.c_str());
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
@@ -194,7 +194,7 @@ NAN_METHOD(Secret::SetValue)
   std::string value(*Nan::Utf8String(info[0]->ToString()));
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   Secret *secret = Nan::ObjectWrap::Unwrap<Secret>(info.This());
-  Nan::AsyncQueueWorker(new SetValueWorker(callback, secret->handle_, value));
+  Nan::AsyncQueueWorker(new SetValueWorker(callback, secret->handle(), value));
   return;
 }
 
diff --git a/src/storage_pool.cc b/src/storage_pool.cc
index 4f1fa45..b92f5b9 100644
--- a/src/storage_pool.cc
+++ b/src/storage_pool.cc
@@ -144,7 +144,7 @@ NLV_WORKER_EXECUTE(StoragePool, Create)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
   unsigned int flags = 0;
-  lookupHandle_ = virStoragePoolCreateXML(parent_->handle_, value_.c_str(), flags);
+  lookupHandle_ = virStoragePoolCreateXML(parent_->handle(), value_.c_str(), flags);
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
@@ -156,7 +156,7 @@ NLV_WORKER_EXECUTE(StoragePool, Define)
 {
   NLV_WORKER_ASSERT_PARENT_HANDLE();
   unsigned int flags = 0;
-  lookupHandle_ = virStoragePoolDefineXML(parent_->handle_, value_.c_str(), flags);
+  lookupHandle_ = virStoragePoolDefineXML(parent_->handle(), value_.c_str(), flags);
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
@@ -235,7 +235,7 @@ NAN_METHOD(StoragePool::Erase)
 
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   StoragePool *storagePool = ObjectWrap::Unwrap<StoragePool>(info.This());
-  Nan::AsyncQueueWorker(new EraseWorker(callback, storagePool->handle_, flags));
+  Nan::AsyncQueueWorker(new EraseWorker(callback, storagePool->handle(), flags));
   return;
 }
 
@@ -281,7 +281,7 @@ NAN_METHOD(StoragePool::SetAutostart)
   bool autoStart = info[0]->IsTrue();
   Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());
   StoragePool *storagePool = ObjectWrap::Unwrap<StoragePool>(info.This());
-  Nan::AsyncQueueWorker(new SetAutostartWorker(callback, storagePool->handle_, autoStart));
+  Nan::AsyncQueueWorker(new SetAutostartWorker(callback, storagePool->handle(), autoStart));
   return;
 }
 
@@ -401,7 +401,7 @@ NAN_METHOD(StoragePool::GetVolumes)
 
   Nan::Callback *callback = new Nan::Callback(info[0].As<Function>());
   StoragePool *storagePool = ObjectWrap::Unwrap<StoragePool>(info.This());
-  Nan::AsyncQueueWorker(new GetVolumesWorker(callback, storagePool->handle_));
+  Nan::AsyncQueueWorker(new GetVolumesWorker(callback, storagePool->handle()));
   return;
 }
 
diff --git a/src/storage_volume.cc b/src/storage_volume.cc
index 3b12a22..9925111 100644
--- a/src/storage_volume.cc
+++ b/src/storage_volume.cc
@@ -98,7 +98,7 @@ NAN_METHOD(StorageVolume::GetInfo)
 
   Nan::Callback *callback = new Nan::Callback(info[0].As<Function>());
   StorageVolume *storageVolume = Nan::ObjectWrap::Unwrap<StorageVolume>(info.This());
-  Nan::AsyncQueueWorker(new GetInfoWorker(callback, storageVolume->handle_));
+  Nan::AsyncQueueWorker(new GetInfoWorker(callback, storageVolume->handle()));
   return;
 }
 
@@ -280,7 +280,7 @@ NAN_METHOD(StorageVolume::Clone)
   StoragePool *sp = Nan::ObjectWrap::Unwrap<StoragePool>(object);
   StorageVolume *sv = Nan::ObjectWrap::Unwrap<StorageVolume>(info[0]->ToObject());
   Nan::Callback *callback = new Nan::Callback(info[2].As<Function>());
-  NLV::AsyncQueueWorker(new CloneWorker(callback, sp, xml, sv->handle_), info.This());
+  NLV::AsyncQueueWorker(new CloneWorker(callback, sp, xml, sv->handle()), info.This());
   return;
 }
 
@@ -289,7 +289,7 @@ NLV_WORKER_EXECUTE(StorageVolume, Clone)
   NLV_WORKER_ASSERT_PARENT_HANDLE();
   unsigned int flags = 0;
   lookupHandle_ =
-    virStorageVolCreateXMLFrom(parent_->handle_, value_.c_str(), cloneHandle_, flags);
+    virStorageVolCreateXMLFrom(parent_->handle(), value_.c_str(), cloneHandle_, flags);
   if (lookupHandle_ == NULL) {
     SetVirError(virSaveLastError());
     return;
diff --git a/src/worker.h b/src/worker.h
index 78c62b7..8f8d97d 100644
--- a/src/worker.h
+++ b/src/worker.h
@@ -58,17 +58,13 @@ namespace NLV {
       Local<Object> childObject = T::NewInstance(val);
       Local<Value> parentObject = worker->GetFromPersistent("parent");
       T* child = T::Unwrap(childObject);
-      NLVObjectBasePtr* childPtr = new NLVObjectBasePtr(child);
       if (parentObject->IsObject()) {
         childObject->Set(Nan::New("_parent").ToLocalChecked(), parentObject);
 
         auto parent = Nan::ObjectWrap::Unwrap<NLVObjectBase>(parentObject->ToObject());
-        if (parent) {
-          parent->children_.push_back(childPtr);
-        }
+        child->AddToParent(parent);
       }
 
-      child->SetParentReference(childPtr);
 
       if (try_catch.HasCaught()) {
         v8::Local<v8::Value> argv[] = { try_catch.Exception() };
diff --git a/src/worker_macros.h b/src/worker_macros.h
index 010bf24..c4adc3f 100644
--- a/src/worker_macros.h
+++ b/src/worker_macros.h
@@ -33,7 +33,7 @@
   NLV_WORKER_ASSERT_HANDLE("domain")
 
 #define NLV_WORKER_ASSERT_PARENT_HANDLE() \
-  if (parent_->handle_ == NULL) { \
+  if (parent_->handle() == NULL) { \
     SetErrorMessage("invalid parent"); \
     return; \
   }
@@ -48,7 +48,7 @@
     } \
     Nan::Callback *callback = new Nan::Callback(info[0].As<Function>());  \
     Class *object = Nan::ObjectWrap::Unwrap<Class>(info.This()); \
-    Nan::AsyncQueueWorker(new Method##Worker(callback, object->handle_));  \
+    Nan::AsyncQueueWorker(new Method##Worker(callback, object->handle()));  \
     return; \
   }
 
@@ -69,7 +69,7 @@
       return; \
     } \
     Class *object = Nan::ObjectWrap::Unwrap<Class>(info.This()); \
-    Nan::AsyncQueueWorker(new Method##Worker(callback, object->handle_, flags));  \
+    Nan::AsyncQueueWorker(new Method##Worker(callback, object->handle(), flags));  \
     return; \
   }