diff --git a/CMakeLists.txt b/CMakeLists.txt
index c670d7ac7..804a045c7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,7 +27,7 @@ else()
 endif()
 
 if(NOT WIN32)
-  set(CMAKE_CXX_FLAGS "-std=c++11")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
   set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libstdc++")
 endif()
 if(USE_LIBCXX)
diff --git a/autowiring/AutoInjectable.h b/autowiring/AutoInjectable.h
index a954d2718..1920ee7f5 100644
--- a/autowiring/AutoInjectable.h
+++ b/autowiring/AutoInjectable.h
@@ -3,13 +3,15 @@
 #include "AutoFuture.h"
 #include "CoreContext.h"
 
-class AutoInjectableExpressionBase
-{
+class AutoInjectableExpressionBase {
 public:
-  virtual ~AutoInjectableExpressionBase(void) {}
+  AutoInjectableExpressionBase(void);
+  virtual ~AutoInjectableExpressionBase(void);
   virtual void operator()(AutoFuture* pFuture) const = 0;
 };
 
+extern template class std::shared_ptr<AutoInjectableExpressionBase>;
+
 /// <summary>
 /// An expression type, which generally encapsulates a single injection operation
 /// </summary>
@@ -99,29 +101,11 @@ class AutoInjectableExpressionFn:
 class AutoInjectable
 {
 public:
-  AutoInjectable(AutoInjectableExpressionBase* pValue = nullptr) :
-    pValue(pValue),
-    pFLink(nullptr)
-  {}
-
-  AutoInjectable(AutoInjectable&& rhs):
-    pValue(rhs.pValue),
-    pFLink(rhs.pFLink)
-  {
-    rhs.pFLink = nullptr;
-  }
-
-  AutoInjectable(const AutoInjectable &rhs) :
-    pValue(rhs.pValue),
-    pFLink(rhs.pFLink ? new AutoInjectable(*rhs.pFLink) : nullptr)
-  {
-  }
+  AutoInjectable(AutoInjectableExpressionBase* pValue = nullptr);
+  AutoInjectable(AutoInjectable&& rhs);
+  AutoInjectable(const AutoInjectable &rhs);
 
-  ~AutoInjectable()
-  {
-    delete pFLink;
-    pFLink = nullptr;
-  }
+  ~AutoInjectable();
 
   /// <summary>
   /// Primary injection operation, injects this injectable's payload into the current context
diff --git a/autowiring/AutoPacket.h b/autowiring/AutoPacket.h
index 73a976e3a..35d6cd168 100644
--- a/autowiring/AutoPacket.h
+++ b/autowiring/AutoPacket.h
@@ -19,6 +19,7 @@
 #include STL_UNORDERED_MAP
 #include EXCEPTION_PTR_HEADER
 
+class AutoPacket;
 class AutoPacketFactory;
 class AutoPacketProfiler;
 struct AutoFilterDescriptor;
@@ -40,6 +41,7 @@ class AutoPacket:
 {
 private:
   AutoPacket(const AutoPacket& rhs) = delete;
+  AutoPacket(AutoPacket&&) = delete;
   AutoPacket(AutoPacketFactory& factory, const std::shared_ptr<Object>& outstanding);
 
 public:
diff --git a/autowiring/AutoPacketFactory.h b/autowiring/AutoPacketFactory.h
index 90320b23d..d443e96c5 100644
--- a/autowiring/AutoPacketFactory.h
+++ b/autowiring/AutoPacketFactory.h
@@ -12,9 +12,9 @@
 #include TYPE_TRAITS_HEADER
 #include STL_UNORDERED_SET
 
+struct AdjacencyEntry;
 class Deferred;
 class DispatchQueue;
-struct AdjacencyEntry;
 
 /// <summary>
 /// A configurable factory class for pipeline packets with a built-in object pool
@@ -227,3 +227,9 @@ class AutoPacketFactory:
   /// <returns>the number of outstanding AutoPackets</returns>
   size_t GetOutstanding(void) const { return m_packets.GetOutstanding(); }
 };
+
+// Extern explicit template instantiation declarations added to prevent
+// exterior instantation of internally used template instances
+extern template class RegType<AutoPacketFactory>;
+extern template struct SlotInformationStump<AutoPacketFactory, false>;
+extern template const std::shared_ptr<AutoPacketFactory>& SharedPointerSlot::as<AutoPacketFactory>(void) const;
diff --git a/autowiring/AutowiringEvents.h b/autowiring/AutowiringEvents.h
index e48b90e02..324dc4851 100644
--- a/autowiring/AutowiringEvents.h
+++ b/autowiring/AutowiringEvents.h
@@ -1,5 +1,6 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #pragma once
+#include "EventRegistry.h"
 #include TYPE_INDEX_HEADER
 
 struct ObjectTraits;
@@ -11,10 +12,16 @@ class CoreContext;
 /// </summary
 class AutowiringEvents {
 public:
+  AutowiringEvents(void);
+  virtual ~AutowiringEvents(void);
+  
   virtual void NewContext(CoreContext&)=0;
   virtual void ExpiredContext(CoreContext&)=0;
   virtual void NewObject(CoreContext&, const ObjectTraits&)=0;
   virtual void EventFired(CoreContext&, const std::type_info&)=0;
 };
 
-
+// Extern explicit template instantiation declarations added to prevent
+// exterior instantation of internally used template instances
+extern template class RegEvent<AutowiringEvents>;
+extern template class TypeUnifierComplex<AutowiringEvents>;
diff --git a/autowiring/BasicThread.h b/autowiring/BasicThread.h
index a6e81d9a1..dca27dcdc 100644
--- a/autowiring/BasicThread.h
+++ b/autowiring/BasicThread.h
@@ -43,8 +43,7 @@ class BasicThread:
 public:
   /// <param name="pName">An optional name for this thread</param>
   BasicThread(const char* pName = nullptr);
-
-  virtual ~BasicThread(void) {}
+  virtual ~BasicThread(void);
 
 protected:
   // Internally held thread status block.  This has to be a shared pointer because we need to signal
diff --git a/autowiring/BoltBase.h b/autowiring/BoltBase.h
index 6960387ee..3da64cff0 100644
--- a/autowiring/BoltBase.h
+++ b/autowiring/BoltBase.h
@@ -1,5 +1,6 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #pragma once
+#include TYPE_INDEX_HEADER
 
 class CoreContext;
 
@@ -13,7 +14,8 @@ typedef const std::type_info*const* t_TypeInfoVector;
 class BoltBase
 {
 public:
-  virtual ~BoltBase(void) {}
+  BoltBase(void);
+  virtual ~BoltBase(void);
 
   /// <summary>
   /// Returns a null-termianted list of one (or more) sigil types that this bolt cares about
diff --git a/autowiring/CallExtractor.h b/autowiring/CallExtractor.h
index b26c230cb..4f8c7a462 100644
--- a/autowiring/CallExtractor.h
+++ b/autowiring/CallExtractor.h
@@ -33,7 +33,7 @@ struct CallExtractor<RetType (*)(Args...)>:
 
     // Handoff
     ((t_pfn)pfn)(
-      auto_arg<Args>(autoPacket.shared_from_this(), *satisfaction.source<typename auto_arg<Args>::base_type>())...
+      auto_arg<Args>(autoPacket.shared_from_this(), *satisfaction.source(typeid(typename auto_arg<Args>::base_type)))...
     );
   }
 };
@@ -60,7 +60,7 @@ struct CallExtractor<void (T::*)(Args...)>:
 
     // Handoff
     (((T*) pObj)->*memFn)(
-      auto_arg<Args>(autoPacket.shared_from_this(), *satisfaction.source<typename auto_arg<Args>::base_type>())...
+      auto_arg<Args>(autoPacket.shared_from_this(), *satisfaction.source(typeid(typename auto_arg<Args>::base_type)))...
     );
   }
 };
@@ -82,7 +82,7 @@ struct CallExtractor<void (T::*)(Args...) const> :
 
     // Handoff
     (((const T*) pObj)->*memFn)(
-      auto_arg<Args>(autoPacket.shared_from_this(), *satisfaction.source<typename auto_arg<Args>::base_type>())...
+      auto_arg<Args>(autoPacket.shared_from_this(), *satisfaction.source(typeid(typename auto_arg<Args>::base_type)))...
     );
   }
 };
@@ -113,7 +113,7 @@ struct CallExtractor<Deferred (T::*)(Args...)>:
     // and will therefore have the same lifecycle as the AutoPacket.
     *(T*) pObj += [pObj, pAutoPacket, &satisfaction] {
       (((T*) pObj)->*memFn)(
-        auto_arg<Args>(pAutoPacket, *satisfaction.source<typename auto_arg<Args>::base_type>())...
+        auto_arg<Args>(pAutoPacket, *satisfaction.source(typeid(typename auto_arg<Args>::base_type)))...
       );
     };
   }
diff --git a/autowiring/CoreRunnable.h b/autowiring/CoreRunnable.h
index 4bdca837a..53cc712b3 100644
--- a/autowiring/CoreRunnable.h
+++ b/autowiring/CoreRunnable.h
@@ -6,6 +6,9 @@ class Object;
 
 class CoreRunnable {
 public:
+  CoreRunnable(void);
+  virtual ~CoreRunnable(void);
+  
   /// <summary>
   /// Causes this runnable to begin processing
   /// </summary>
diff --git a/autowiring/CoreThread.h b/autowiring/CoreThread.h
index bc6c76029..c98969505 100644
--- a/autowiring/CoreThread.h
+++ b/autowiring/CoreThread.h
@@ -19,8 +19,7 @@ class CoreThread:
 public:
   /// <param name="pName">An optional name for this thread</param>
   CoreThread(const char* pName = nullptr);
-
-  virtual ~CoreThread(void) {}
+  virtual ~CoreThread(void);
 
 protected:
   void DEPRECATED(Ready(void) const, "Do not call this method, the concept of thread readiness is now deprecated") {}
diff --git a/autowiring/CreationRules.h b/autowiring/CreationRules.h
index 409e57f2e..9146a9e9a 100644
--- a/autowiring/CreationRules.h
+++ b/autowiring/CreationRules.h
@@ -18,9 +18,35 @@ struct is_injectable
 /// <summary>
 /// Simple structure to centralize knowledge about how to create types with various declarations
 /// </summary>
-struct CreationRules {
+namespace CreationRules {
+  template<void* (*)(size_t)>
+  struct alloc_fn {};
+  
+  template<typename U>
+  U* Allocate(alloc_fn<&U::operator new>*) {
+    return (U*) U::operator new(sizeof(U));
+  }
+  
+  template<typename U>
+  U* Allocate(...) {
+    return (U*) ::operator new(sizeof(U));
+  }
+  
+  template<void(*)(void*)>
+  struct free_fn {};
+  
+  template<typename U>
+  void Free(void* ptr, free_fn<&U::operator delete>*) {
+    U::operator delete(ptr);
+  }
+  
+  template<typename U>
+  void Free(void* ptr, ...) {
+    ::operator delete(ptr);
+  }
+  
   template<typename U, typename... Args>
-  static typename std::enable_if<has_static_new<U, Args...>::value, U*>::type New(Args&&... args) {
+  typename std::enable_if<has_static_new<U, Args...>::value, U*>::type New(Args&&... args) {
     auto retVal = U::New(std::forward<Args>(args)...);
     static_assert(
       std::is_convertible<decltype(retVal), U*>::value,
@@ -30,7 +56,7 @@ struct CreationRules {
   }
 
   template<typename U, typename... Args>
-  static typename std::enable_if<!has_static_new<U, Args...>::value, U*>::type New(Args&&... args) {
+  typename std::enable_if<!has_static_new<U, Args...>::value, U*>::type New(Args&&... args) {
     static_assert(!std::is_abstract<U>::value, "Cannot create a type which is abstract");
     static_assert(!has_static_new<U, Args...>::value, "Can't inject member with arguments if it has a static New");
 
@@ -54,30 +80,4 @@ struct CreationRules {
       throw;
     }
   }
-
-  template<void* (*)(size_t)>
-  struct alloc_fn {};
-
-  template<typename U>
-  static U* Allocate(alloc_fn<&U::operator new>*) {
-    return (U*) U::operator new(sizeof(U));
-  }
-
-  template<typename U>
-  static U* Allocate(...) {
-    return (U*) ::operator new(sizeof(U));
-  }
-
-  template<void(*)(void*)>
-  struct free_fn {};
-
-  template<typename U>
-  static void Free(void* ptr, free_fn<&U::operator delete>*) {
-    U::operator delete(ptr);
-  }
-
-  template<typename U>
-  static void Free(void* ptr, ...) {
-    ::operator delete(ptr);
-  }
-};
+}
diff --git a/autowiring/DataFlow.h b/autowiring/DataFlow.h
index ef5a46a6d..ef2215de4 100644
--- a/autowiring/DataFlow.h
+++ b/autowiring/DataFlow.h
@@ -32,12 +32,11 @@ namespace autowiring {
     public std::unordered_map<std::type_index, const std::type_info*>
   {
   public:
-    template<class Arg>
-    const std::type_info* source() const {
-      std::unordered_map<std::type_index, const std::type_info*>::const_iterator itr = find(typeid(Arg));
+    const std::type_info* source(const std::type_index& arg) const {
+      std::unordered_map<std::type_index, const std::type_info*>::const_iterator itr = find(arg);
       if (itr != end())
         return itr->second;
       return &typeid(void);
     }
   };
-}
\ No newline at end of file
+}
diff --git a/autowiring/DispatchQueue.h b/autowiring/DispatchQueue.h
index 0c6008fd2..c3e0602d3 100644
--- a/autowiring/DispatchQueue.h
+++ b/autowiring/DispatchQueue.h
@@ -14,7 +14,11 @@ class DispatchQueue;
 /// </summary>
 class dispatch_aborted_exception:
   public std::exception
-{};
+{
+public:
+  dispatch_aborted_exception(void);
+  virtual ~dispatch_aborted_exception(void);
+};
 
 /// <summary>
 /// This is an asynchronous queue of zero-argument functions
diff --git a/autowiring/EventRegistry.h b/autowiring/EventRegistry.h
index 2fba550cc..6bdba81f3 100644
--- a/autowiring/EventRegistry.h
+++ b/autowiring/EventRegistry.h
@@ -1,13 +1,11 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #pragma once
 #include "TypeIdentifier.h"
+#include "JunctionBox.h"
 #include TYPE_TRAITS_HEADER
 #include STL_TUPLE_HEADER
 #include MEMORY_HEADER
 
-template<class T>
-class JunctionBox;
-
 class JunctionBoxBase;
 
 struct EventRegistryEntry {
diff --git a/autowiring/ExceptionFilter.h b/autowiring/ExceptionFilter.h
index 5ff84a965..de3af8cd1 100644
--- a/autowiring/ExceptionFilter.h
+++ b/autowiring/ExceptionFilter.h
@@ -1,9 +1,9 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #pragma once
-
 #include FUNCTIONAL_HEADER
 
 class JunctionBoxBase;
+class Object;
 
 /// <summary>
 /// Implements an exception filter type, invoked when an unhandled exception is thrown
@@ -47,7 +47,8 @@ class JunctionBoxBase;
 class ExceptionFilter
 {
 public:
-  virtual ~ExceptionFilter(void) {}
+  ExceptionFilter(void);
+  virtual ~ExceptionFilter(void);
 
   /// <summary>
   /// This method is invoked when an exception has been thrown by CoreThread::Run
diff --git a/autowiring/Object.h b/autowiring/Object.h
index 1c3628e68..f3efa08fa 100644
--- a/autowiring/Object.h
+++ b/autowiring/Object.h
@@ -7,5 +7,6 @@
 /// </summary>
 class Object {
 public:
-  virtual ~Object(void) {}
+  Object(void);
+  virtual ~Object(void);
 };
diff --git a/autowiring/TypeIdentifier.h b/autowiring/TypeIdentifier.h
index 2f277893d..403bb6790 100644
--- a/autowiring/TypeIdentifier.h
+++ b/autowiring/TypeIdentifier.h
@@ -1,8 +1,7 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #pragma once
 #include TYPE_INDEX_HEADER
-
-class Object;
+#include "Object.h"
 
 // Checks if an Object* listens to a event T;
 struct TypeIdentifierBase {
diff --git a/autowiring/auto_arg.h b/autowiring/auto_arg.h
index 9797e9637..1eaf51421 100644
--- a/autowiring/auto_arg.h
+++ b/autowiring/auto_arg.h
@@ -207,7 +207,11 @@ class auto_arg<AutoPacket&>
 {
 protected:
   /// Sigil to distinguish AutoPacket&
-  class first_call_sigil {};
+  class first_call_sigil {
+  public:
+    first_call_sigil(void);
+    virtual ~first_call_sigil(void);
+  };
 
   std::shared_ptr<AutoPacket> m_packet;
 
@@ -254,7 +258,11 @@ class auto_arg<const AutoPacket&>
 {
 protected:
   /// Sigil to distinguish const AutoPacket&
-  class final_call_sigil {};
+  class final_call_sigil {
+  public:
+    final_call_sigil(void);
+    virtual ~final_call_sigil(void);
+  };
 
   std::shared_ptr<AutoPacket> m_packet;
 
diff --git a/autowiring/autowiring_error.h b/autowiring/autowiring_error.h
index 1d0ef0c29..3117ee861 100644
--- a/autowiring/autowiring_error.h
+++ b/autowiring/autowiring_error.h
@@ -6,9 +6,8 @@ class autowiring_error:
   public std::exception
 {
 public:
-  autowiring_error(const char* what):
-    m_what(what)
-  {}
+  autowiring_error(const char* what);
+  virtual ~autowiring_error(void);
 
 private:
   const char* m_what;
diff --git a/src/autonet/AutoNetServerImpl.hpp b/src/autonet/AutoNetServerImpl.hpp
index 2bb9f2ad1..108309263 100644
--- a/src/autonet/AutoNetServerImpl.hpp
+++ b/src/autonet/AutoNetServerImpl.hpp
@@ -19,7 +19,7 @@ struct TypeIdentifierBase;
 
 class AutoNetServerImpl:
   public AutoNetServer,
-  public AutowiringEvents
+  public virtual AutowiringEvents
 {
 public:
   AutoNetServerImpl();
diff --git a/src/autowiring/AutoInjectable.cpp b/src/autowiring/AutoInjectable.cpp
index 9486b1ceb..0c321c84f 100644
--- a/src/autowiring/AutoInjectable.cpp
+++ b/src/autowiring/AutoInjectable.cpp
@@ -1,7 +1,29 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
-
+#include "stdafx.h"
 #include "AutoInjectable.h"
 
-AutoInjectable::AutoInjectable(){}
+AutoInjectableExpressionBase::AutoInjectableExpressionBase(void){}
+AutoInjectableExpressionBase::~AutoInjectableExpressionBase(void){}
+template class std::shared_ptr<AutoInjectableExpressionBase>;
+
+AutoInjectable::AutoInjectable(AutoInjectableExpressionBase* pValue) :
+  pValue(pValue),
+  pFLink(nullptr)
+{}
+
+AutoInjectable::AutoInjectable(AutoInjectable&& rhs):
+  pValue(rhs.pValue),
+  pFLink(rhs.pFLink)
+{
+  rhs.pFLink = nullptr;
+}
+
+AutoInjectable::AutoInjectable(const AutoInjectable &rhs) :
+  pValue(rhs.pValue),
+  pFLink(rhs.pFLink ? new AutoInjectable(*rhs.pFLink) : nullptr)
+{}
 
-AutoInjectable::~AutoInjectable(){}
+AutoInjectable::~AutoInjectable() {
+  delete pFLink;
+  pFLink = nullptr;
+}
diff --git a/src/autowiring/AutoPacketFactory.cpp b/src/autowiring/AutoPacketFactory.cpp
index 53fad0937..e803c21e0 100644
--- a/src/autowiring/AutoPacketFactory.cpp
+++ b/src/autowiring/AutoPacketFactory.cpp
@@ -330,3 +330,7 @@ void AutoPacketFactory::PipeAllData(const std::type_info* nodeOutType, const std
   }
   Invalidate();
 }
+
+template class RegType<AutoPacketFactory>;
+template struct SlotInformationStump<AutoPacketFactory, false>;
+template const std::shared_ptr<AutoPacketFactory>& SharedPointerSlot::as<AutoPacketFactory>(void) const;
diff --git a/src/autowiring/AutowiringEvents.cpp b/src/autowiring/AutowiringEvents.cpp
new file mode 100644
index 000000000..6017dca19
--- /dev/null
+++ b/src/autowiring/AutowiringEvents.cpp
@@ -0,0 +1,10 @@
+// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
+#include "stdafx.h"
+#include "AutowiringEvents.h"
+
+AutowiringEvents::AutowiringEvents(void){}
+
+AutowiringEvents::~AutowiringEvents(void){}
+
+template class RegEvent<AutowiringEvents>;
+template class TypeUnifierComplex<AutowiringEvents>;
diff --git a/src/autowiring/BasicThread.cpp b/src/autowiring/BasicThread.cpp
index 9937624df..13b79caee 100644
--- a/src/autowiring/BasicThread.cpp
+++ b/src/autowiring/BasicThread.cpp
@@ -19,6 +19,8 @@ BasicThread::BasicThread(const char* pName):
   m_priority(ThreadPriority::Default)
 {}
 
+BasicThread::~BasicThread(void){}
+
 std::mutex& BasicThread::GetLock(void) {
   return m_state->m_lock;
 }
diff --git a/src/autowiring/BoltBase.cpp b/src/autowiring/BoltBase.cpp
new file mode 100644
index 000000000..65c4f4708
--- /dev/null
+++ b/src/autowiring/BoltBase.cpp
@@ -0,0 +1,7 @@
+// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
+#include "stdafx.h"
+#include "BoltBase.h"
+
+BoltBase::BoltBase(void){}
+
+BoltBase::~BoltBase(void){}
diff --git a/src/autowiring/CMakeLists.txt b/src/autowiring/CMakeLists.txt
index 8477cfb4e..ef69817e3 100644
--- a/src/autowiring/CMakeLists.txt
+++ b/src/autowiring/CMakeLists.txt
@@ -14,6 +14,7 @@ set(Autowiring_SRCS
   auto_in.h
   auto_out.h
   auto_arg.h
+  auto_arg.cpp
   AnySharedPointer.h
   AutoCheckout.h
   AutoRestarter.h
@@ -24,6 +25,7 @@ set(Autowiring_SRCS
   CoreJob.cpp
   AutoFilterDescriptor.h
   AutoInjectable.h
+  AutoInjectable.cpp
   AutoMerge.h
   AutoPacket.h
   AutoPacket.cpp
@@ -40,14 +42,17 @@ set(Autowiring_SRCS
   AutowirableSlot.cpp
   AutowiringConfig.h
   AutowiringEvents.h
+  AutowiringEvents.cpp
   autowiring.h
   autowiring_error.h
+  autowiring_error.cpp
   BasicThread.h
   BasicThread.cpp
   BasicThreadStateBlock.h
   BasicThreadStateBlock.cpp
   Bolt.h
   BoltBase.h
+  BoltBase.cpp
   CallExtractor.h
   ContextCreator.h
   ContextCreatorBase.h
@@ -64,6 +69,7 @@ set(Autowiring_SRCS
   CoreThread.cpp
   CoreThread.h
   CoreRunnable.h
+  CoreRunnable.cpp
   CreationRules.h
   CurrentContextPusher.cpp
   CurrentContextPusher.h
@@ -92,6 +98,7 @@ set(Autowiring_SRCS
   JunctionBoxManager.h
   JunctionBoxManager.cpp
   ExceptionFilter.h
+  ExceptionFilter.cpp
   GlobalCoreContext.cpp
   GlobalCoreContext.h
   has_autoinit.h
@@ -107,6 +114,7 @@ set(Autowiring_SRCS
   atomic_object.h
   unlock_object.h
   Object.h
+  Object.cpp
   ObjectPool.h
   ObjectPoolMonitor.h
   ObjectPoolMonitor.cpp
@@ -187,6 +195,8 @@ ADD_MSVC_PRECOMPILED_HEADER("stdafx.h" "stdafx.cpp" Autowiring_SRCS)
 #
 
 add_library(Autowiring STATIC ${Autowiring_SRCS})
+set_target_properties(Autowiring PROPERTIES COMPILE_FLAGS "-fvisibility=hidden")
+
 target_include_directories(Autowiring INTERFACE
   "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>"
   "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>"
diff --git a/src/autowiring/CoreRunnable.cpp b/src/autowiring/CoreRunnable.cpp
new file mode 100644
index 000000000..a66c19abf
--- /dev/null
+++ b/src/autowiring/CoreRunnable.cpp
@@ -0,0 +1,7 @@
+// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
+#include "stdafx.h"
+#include "CoreRunnable.h"
+
+CoreRunnable::CoreRunnable(void){}
+
+CoreRunnable::~CoreRunnable(void){}
diff --git a/src/autowiring/CoreThread.cpp b/src/autowiring/CoreThread.cpp
index ad744b50a..3ccb54529 100644
--- a/src/autowiring/CoreThread.cpp
+++ b/src/autowiring/CoreThread.cpp
@@ -8,6 +8,8 @@ CoreThread::CoreThread(const char* pName):
   BasicThread(pName)
 {}
 
+CoreThread::~CoreThread(void){}
+
 void CoreThread::DoRunLoopCleanup(std::shared_ptr<CoreContext>&& ctxt, std::shared_ptr<Object>&& refTracker) {
   try {
     // If we are asked to rundown while we still have elements in our dispatch queue,
diff --git a/src/autowiring/DispatchQueue.cpp b/src/autowiring/DispatchQueue.cpp
index 2f480d404..772c7820b 100644
--- a/src/autowiring/DispatchQueue.cpp
+++ b/src/autowiring/DispatchQueue.cpp
@@ -3,6 +3,9 @@
 #include "DispatchQueue.h"
 #include "at_exit.h"
 
+dispatch_aborted_exception::dispatch_aborted_exception(void){}
+dispatch_aborted_exception::~dispatch_aborted_exception(void){}
+
 DispatchQueue::DispatchQueue(void):
   m_dispatchCap(1024),
   m_aborted(false)
diff --git a/src/autowiring/EventRegistry.cpp b/src/autowiring/EventRegistry.cpp
index e3010b9e9..6413cfcff 100644
--- a/src/autowiring/EventRegistry.cpp
+++ b/src/autowiring/EventRegistry.cpp
@@ -1,7 +1,6 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #include "stdafx.h"
 #include "EventRegistry.h"
-#include "JunctionBox.h"
 
 // Head of a linked list which will have node for every event type
 const EventRegistryEntry* g_pFirstEventEntry = nullptr;
diff --git a/src/autowiring/ExceptionFilter.cpp b/src/autowiring/ExceptionFilter.cpp
new file mode 100644
index 000000000..0995bc393
--- /dev/null
+++ b/src/autowiring/ExceptionFilter.cpp
@@ -0,0 +1,7 @@
+// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
+#include "stdafx.h"
+#include "ExceptionFilter.h"
+
+ExceptionFilter::ExceptionFilter(void){}
+
+ExceptionFilter::~ExceptionFilter(void){}
diff --git a/src/autowiring/Object.cpp b/src/autowiring/Object.cpp
new file mode 100644
index 000000000..9b0d7064f
--- /dev/null
+++ b/src/autowiring/Object.cpp
@@ -0,0 +1,7 @@
+// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
+#include "stdafx.h"
+#include "Object.h"
+
+Object::Object(void) {}
+
+Object::~Object(void) {}
diff --git a/src/autowiring/auto_arg.cpp b/src/autowiring/auto_arg.cpp
new file mode 100644
index 000000000..5542b6c2b
--- /dev/null
+++ b/src/autowiring/auto_arg.cpp
@@ -0,0 +1,9 @@
+// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
+#include "stdafx.h"
+#include "auto_arg.h"
+
+auto_arg<AutoPacket&>::first_call_sigil::first_call_sigil(void){}
+auto_arg<AutoPacket&>::first_call_sigil::~first_call_sigil(void){}
+
+auto_arg<const AutoPacket&>::final_call_sigil::final_call_sigil(void){}
+auto_arg<const AutoPacket&>::final_call_sigil::~final_call_sigil(void){}
diff --git a/src/autowiring/autowiring_error.cpp b/src/autowiring/autowiring_error.cpp
new file mode 100644
index 000000000..312a0f066
--- /dev/null
+++ b/src/autowiring/autowiring_error.cpp
@@ -0,0 +1,9 @@
+// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
+#include "stdafx.h"
+#include "autowiring_error.h"
+
+autowiring_error::autowiring_error(const char* what):
+  m_what(what)
+{}
+
+autowiring_error::~autowiring_error(void){}