diff --git a/extension/include/boost/di/extension/providers/runtime_provider.hpp b/extension/include/boost/di/extension/providers/runtime_provider.hpp
index a197d2c6f0..9be3da98a5 100644
--- a/extension/include/boost/di/extension/providers/runtime_provider.hpp
+++ b/extension/include/boost/di/extension/providers/runtime_provider.hpp
@@ -12,11 +12,100 @@
 #include <type_traits>
 #include <typeindex>
 #include <unordered_map>
+#include <vector>
+#include <list>
 #include <utility>
 
 #include "boost/di.hpp"
 #include "boost/di/extension/scopes/shared.hpp"
 
+// Additions
+#include "boost/di/extension/providers/runtime_provider_additions.h"
+#include "boost/di/extension/providers/runtime_provider_additions_any_of.h"
+#include "boost/di/extension/providers/runtime_provider_additions_di_core_array.h"
+#include "boost/di/extension/providers/runtime_provider_additions_is_singleton.h"
+#include "boost/di/extension/providers/runtime_provider_generator_saver.h"
+
+static size_t unique_binding_id {0}; // TODO, is this kosher to put here? - Could just generate a UUID each time
+
+// Move to another file once we know what we're doing here
+class ibinding_entry {
+public:
+   virtual ~ibinding_entry() {}
+   virtual size_t unique_id() const = 0;
+   virtual void* get_it(const bool is_heap) = 0;
+   virtual bool is_singleton() const = 0;
+   virtual void for_each_type_id(std::function<void(const std::type_index)> fn) = 0;
+   virtual size_t type_id_size() const = 0;
+   virtual std::string binding_str() const = 0;
+};
+
+
+template <typename PROVIDER_T, typename BINDING_T, typename T, typename TYPEID_ARRAY>
+class my_binding_entry : public ibinding_entry {
+public:
+ my_binding_entry
+    ( const bool singleton_context
+    , PROVIDER_T* provider
+    , BINDING_T binding
+    , const size_t id
+    , const TYPEID_ARRAY & type_id_array
+    , std::unordered_map<size_t, size_t> & mapping
+    ) : m_singleton_context(singleton_context)
+      , m_provider(provider)
+      , m_binding(binding)
+      , m_id(id)
+      , m_type_id_array(type_id_array)
+      , m_mapping(mapping)
+  {}
+
+  size_t unique_id() const override { return m_id; }
+
+  void* get_it(const bool is_heap ) override
+  {
+    // Under new scheme just always make it - we have to find "shared" versions at a different level
+    auto res = m_provider->template make<T>(m_binding);
+
+    if(is_heap && m_singleton_context)
+    {
+      m_mapping[reinterpret_cast<std::uintptr_t>(res)] = m_id;
+    }
+
+    return res;
+  }
+
+  bool is_singleton() const override { return m_singleton_context; }
+
+  void for_each_type_id(std::function<void(const std::type_index)> fn) override
+  {
+     for(const auto & type_id_entry : m_type_id_array)
+     {
+        fn(type_id_entry);
+     }
+  }
+
+  size_t type_id_size() const override
+  {
+     return m_type_id_array.size();
+  }
+
+  std::string binding_str() const override
+  {
+      const std::string r = std::type_index(typeid(BINDING_T)).name();
+      return r;
+  }
+
+private:
+  bool m_singleton_context {false};
+  PROVIDER_T* m_provider {nullptr};
+  BINDING_T m_binding;
+  size_t m_id {0};
+  TYPEID_ARRAY m_type_id_array;
+  std::unordered_map<size_t, size_t> & m_mapping;
+};
+
+
+
 BOOST_DI_NAMESPACE_BEGIN
 namespace extension {
 
@@ -29,29 +118,257 @@ struct assert_error_policy {
 
 template <class TErrorPolicy, class TScopeTraits>
 class runtime_provider : public config {
-  using bindings_t = std::unordered_map<std::type_index, std::function<void *()>>;
-  using data_t = std::unordered_map<std::type_index, std::shared_ptr<void>>;
+  using bindings_t = std::unordered_map<std::type_index, std::vector<std::shared_ptr<ibinding_entry>>>;
+  using data_t = std::unordered_map<std::type_index, std::list<std::shared_ptr<void>>>;
+  // Map created addresses to unique ids of generator fns - so we can tell which generator functions don't need to be called again
+  using mapping_t = std::unordered_map<size_t, size_t>;
 
   class abstract_provider : TErrorPolicy {
    public:
-    explicit abstract_provider(const bindings_t &bindings) : bindings_{bindings} {}
+    explicit abstract_provider(const bindings_t &bindings, data_t & data, const mapping_t & mapping) : bindings_{bindings}, data_ptr_{&data}, mapping_(mapping) {}
 
     template <class...>
     struct is_creatable {
       static constexpr auto value = true;
     };
 
+
+    // DWK - get di core array vector ...
     template <class T, class TInitialization, class TMemory, class... TArgs>
-    auto get(const TInitialization &, const TMemory &, TArgs &&... args) const {
+    typename std::enable_if<is_di_core_array<T>::value && !is_di_core_array_list<T>::value, T>::type*
+    get(const TInitialization & , const TMemory & , TArgs &&... args) const
+    {
+      // Create container (vector<std::shared_ptr<>>)
+      auto vec = get<T>(std::integral_constant < bool,
+                            !std::is_abstract<T>::value && std::is_constructible<T, TArgs...>::value > {},
+                        std::forward<TArgs>(args)...);
+
+      typedef typename is_di_core_array<T>::subtype entry_t;
+//      typedef typename is_di_core_array<T>::raw_ptr_t raw_ptr_t;
+//      typedef typename is_di_core_array<T>::ptr_t ptr_t;
+
+      // -------------------------------------------------------------------
+//      if(create_all)
+      {
+        // TODO, make this optional to collect vs generate_all: std::list vs std::vector?
+        // Force creation from all bindings of this type
+        auto my_bindings_itr = bindings_.find(typeid(entry_t));
+        if(my_bindings_itr != bindings_.end())
+        {
+          for(auto & generator_fn : my_bindings_itr->second)
+          {
+            // -------------------------------
+            // Determine if we need to run this generator or if it has already been saved off previously (under right conditions: singleton + heap)
+            bool already_run {false};
+            for(const auto & m : mapping_)
+            {
+              if(m.second == generator_fn->unique_id())
+              {
+//                std::cout << "Skipping already created " << m.second << ", " << generator_fn->binding_str() << std::endl;
+                already_run = true;
+                break;
+              }
+            }
+            if(already_run)
+              continue;
+            // -------------------------------
+
+            void* generated_void_ptr = generator_fn->get_it(true);
+            entry_t* generated_t_ptr = static_cast<entry_t*>(generated_void_ptr);
+
+            if(generator_fn->type_id_size() > 0)
+            {
+              std::shared_ptr<entry_t> generated_t_shared_ptr(generated_t_ptr);
+              std::shared_ptr<void> generated_void_shared_ptr(generated_t_shared_ptr);
+
+              //          auto entry_t_type_index = std::type_index(typeid(entry_t));
+              //          auto & data_list = (*data_ptr_)[entry_t_type_index];
+              //          data_list.push_back(generated_void_shared_ptr);
+
+              generator_fn->for_each_type_id([&](const std::type_index & ti)
+                                             {
+                                               auto & data_list = (*data_ptr_)[ti];
+                                               data_list.push_back(generated_void_shared_ptr);
+                                             });
+            }
+
+            //          auto xx = generator_fn->get_it(true); // always on heap this way .. prob?
+//          auto xx_idx = std::type_index(typeid(entry_t));
+//          auto & xyz = (*data_ptr_)[xx_idx];
+//          auto xyz_shared = std::shared_ptr<entry_t>(reinterpret_cast<entry_t>(xx));
+//          auto xyz_void_shared = std::shared_ptr<void>(xyz_shared);
+//          xyz.push_back(xyz_void_shared);
+          }
+        }
+      }
+      // -------------------------------------------------------------------
+
+      // Look in data_ and if nothing around then return empty vec
+      const auto ti = std::type_index(typeid(entry_t));
+      auto data_itr = data_ptr_->find(ti);
+
+      if(data_itr == data_ptr_->end())
+      {
+        return vec;
+      }
+      // else
+
+      //
+      for(auto & ptr : data_itr->second)
+      {
+        std::shared_ptr<void> xx = ptr;
+        std::shared_ptr<entry_t> my_ptr = std::static_pointer_cast<entry_t>(xx);
+        vec->push_back( my_ptr );
+      }
+
+      return vec;
+    }
+
+
+    // DWK - get di core array list ...
+    template <class T, class TInitialization, class TMemory, class... TArgs>
+    typename std::enable_if<is_di_core_array_list<T>::value && !is_di_core_array<T>::value, T>::type*
+    get(const TInitialization &, const TMemory &, TArgs &&... ) const
+    {
+      // Create container (vector<std::shared_ptr<>>)
+// TODO, using this below causes us to create a list that already has entries in it
+//      auto vec = get<T>(std::integral_constant < bool,
+//                            !std::is_abstract<T>::value && std::is_constructible<T, TArgs...>::value > {},
+//                        std::forward<TArgs>(args)...);
+
+      auto vec = get<T>(std::integral_constant < bool,
+                            !std::is_abstract<T>::value && std::is_constructible<T, TArgs...>::value > {}
+                        );
+
+//      typedef typename std::enable_if<is_di_core_array_list<T>::value && !is_di_core_array<T>::value, T>::type* res_t;
+      typedef typename is_di_core_array_list<T>::subtype entry_t;
+//      res_t* vec = new res_t();
+
+//      typedef typename is_di_core_array<T>::raw_ptr_t raw_ptr_t;
+//      typedef typename is_di_core_array<T>::ptr_t ptr_t;
+
+
+#if 0
+      // -------------------------------------------------------------------
+      if(create_all)
+      {
+        // TODO, make this optional to collect vs generate_all: std::list vs std::vector?
+        // Force creation from all bindings of this type
+        auto my_bindings_itr = bindings_.find(typeid(entry_t));
+        if(my_bindings_itr != bindings_.end())
+        {
+          for(auto & generator_fn : my_bindings_itr->second)
+          {
+            // -------------------------------
+            // Determine if we need to run this generator or if it has already been saved off previously (under right conditions: singleton + heap)
+            bool already_run {false};
+            for(const auto & m : mapping_)
+            {
+              if(m.second == generator_fn->unique_id())
+              {
+                already_run = true;
+                break;
+              }
+            }
+            if(already_run)
+              continue;
+            // -------------------------------
+
+            void* generated_void_ptr = generator_fn->get_it(true);
+            entry_t* generated_t_ptr = static_cast<entry_t*>(generated_void_ptr);
+
+            if(generator_fn->type_id_size() > 0)
+            {
+              std::shared_ptr<entry_t> generated_t_shared_ptr(generated_t_ptr);
+              std::shared_ptr<void> generated_void_shared_ptr(generated_t_shared_ptr);
+
+              //          auto entry_t_type_index = std::type_index(typeid(entry_t));
+              //          auto & data_list = (*data_ptr_)[entry_t_type_index];
+              //          data_list.push_back(generated_void_shared_ptr);
+
+              generator_fn->for_each_type_id([&](const std::type_index & ti)
+                                             {
+                                               auto & data_list = (*data_ptr_)[ti];
+                                               data_list.push_back(generated_void_shared_ptr);
+                                             });
+            }
+
+            //          auto xx = generator_fn->get_it(true); // always on heap this way .. prob?
+//          auto xx_idx = std::type_index(typeid(entry_t));
+//          auto & xyz = (*data_ptr_)[xx_idx];
+//          auto xyz_shared = std::shared_ptr<entry_t>(reinterpret_cast<entry_t>(xx));
+//          auto xyz_void_shared = std::shared_ptr<void>(xyz_shared);
+//          xyz.push_back(xyz_void_shared);
+          }
+        }
+      }
+      // -------------------------------------------------------------------
+#endif
+// DWK 12-17-2020
+      // Look in data_ and if nothing around then return empty vec
+      const auto ti = std::type_index(typeid(entry_t));
+      auto data_itr = data_ptr_->find(ti);
+
+      if(data_itr == data_ptr_->end())
+      {
+        return vec;
+      }
+      // else
+
+      //
+      for(auto & ptr : data_itr->second)
+      {
+        std::shared_ptr<void> xx = ptr;
+        std::shared_ptr<entry_t> my_ptr = std::static_pointer_cast<entry_t>(xx);
+        vec->push_back( my_ptr );
+      }
+
+      return vec;
+    }
+
+
+
+
+    template <class T, class TInitialization, class TMemory, class... TArgs>
+    typename std::enable_if<!is_di_core_array<T>::value && !is_di_core_array_list<T>::value, T>::type*
+    get(const TInitialization &, const TMemory &, TArgs &&... args) const
+    {
+      const bool is_heap = std::is_same<TMemory, boost::ext::di::v1_2_0::type_traits::heap>();
+
       auto it = bindings_.find(std::type_index(typeid(T)));
-      if (it == bindings_.end()) {
+      if (it == bindings_.end())
+      {
         return get<T>(std::integral_constant < bool,
-                      !std::is_abstract<T>::value && std::is_constructible<T, TArgs...>::value > {},
+                          !std::is_abstract<T>::value && std::is_constructible<T, TArgs...>::value > {},
                       std::forward<TArgs>(args)...);
       }
-      return static_cast<T *>(it->second());
+      assert(!it->second.empty());
+      assert((*it->second.begin()) != nullptr);
+      auto my_shared_ptr = (*it->second.begin());
+      const std::string t_type_name_str = typeid(T).name();
+
+      void* generated_void_ptr = my_shared_ptr->get_it(is_heap);
+      T* generated_t_ptr = static_cast<T*>(generated_void_ptr);
+
+      if(is_heap && my_shared_ptr->is_singleton())
+      {
+        std::shared_ptr<T> generated_t_shared_ptr(generated_t_ptr);
+        std::shared_ptr<void> generated_void_shared_ptr(generated_t_shared_ptr);
+
+        my_shared_ptr->for_each_type_id([&](const std::type_index & ti)
+            {
+              auto & data_list = (*data_ptr_)[ti];
+              if(data_list.size() == 1 && nullptr == (*data_list.begin()))
+                (*data_list.begin()) = generated_void_shared_ptr;
+              else
+                data_list.push_back(generated_void_shared_ptr);
+            });
+      }
+      return generated_t_ptr; // Have to be careful not to use this in the shared.hpp
     }
 
+
+
    private:
     template <class T, class... TArgs>
     auto get(std::true_type, TArgs &&... args) const {
@@ -65,24 +382,45 @@ class runtime_provider : public config {
     }
 
     const bindings_t &bindings_;
+//    const data_t &data_;
+    data_t* data_ptr_;
+    const mapping_t & mapping_;
   };
 
  public:
   template <class T>
   using scope_traits = typename TScopeTraits::template scope_traits<T>;
 
-  auto provider(...) { return abstract_provider{bindings_}; }
+  auto provider(...) { return abstract_provider{bindings_, data_, mapping_}; }
   auto &bindings() { return bindings_; }
   const auto &bindings() const { return bindings_; }
 
   template <class T>
-  auto &data() {
-    return data_[std::type_index(typeid(T))];
+  auto &data()
+  {
+    const auto t_idx = std::type_index(typeid(T));
+    if(data_[t_idx].empty()) // auto-populate data_ with [t_idx]
+      data_[t_idx].push_back(std::shared_ptr<void*>(nullptr));
+    assert(data_[t_idx].size() > 0);
+    return data_[std::type_index(typeid(T))].front();
   }
 
+  // Used to populate data_ from functor for creating instance
+  const auto& get_full_data() const
+  {
+    return data_;
+  }
+
+  const auto& get_full_bindings() const
+  { return bindings_; }
+
+  auto& get_full_mapping()
+  { return mapping_; }
+
  private:
   bindings_t bindings_{};
   data_t data_{};
+  mapping_t mapping_{};
 };
 
 namespace detail {
@@ -119,11 +457,154 @@ class injector : public core::injector<runtime_provider<TErrorPolicy, TScopeTrai
     install(bindings);
   }
 
+//  template <class T, std::enable_if_t<!std::is_base_of<core::injector_base, T>::value, int> = 0>
+//  void install(const T &binding) {
+//    this->cfg().bindings()[std::type_index(typeid(typename T::expected))].push_back( [this, binding] {
+//      return make<typename T::given>(binding);
+//    });
+//  }
+
+#if 0
+  // Debug
+  void dump_data_bindings()
+  {
+    std::cout << "----------------------------------\n";
+    std::cout << "dump data\n";
+    const std::unordered_map<std::type_index, std::list<std::shared_ptr<void>>> & d = this->cfg().get_full_data();
+    for(const auto & d_i : d)
+    {
+      std::cout << "  data: " << d_i.first.name() << " -> " << d_i.second.size() << "\n";
+      for(const auto & v_i : d_i.second)
+      {
+        std::cout << "    " << v_i << "\n";
+      }
+    }
+    std::cout << "----------------------------------\n";
+
+    std::cout << "dump bindings\n";
+    for(const auto & binding : this->cfg().get_full_bindings())
+    {
+      // bindings_t = std::unordered_map<std::type_index, std::list<std::shared_ptr<ibinding_entry>>>;
+      std::cout << "binding " << binding.first.name() << " -> count " << binding.second.size() << std::endl;
+      for(const auto & boundee : binding.second)
+      {
+        std::cout << "    " << (*boundee).my_address_of() << std::endl;
+      }
+    }
+
+    std::cout << "----------------------------------\n";
+  }
+#endif
+
+  int& gs_num()
+  {
+    static int gs_num {0};
+    return gs_num;
+  }
+
+
   template <class T, std::enable_if_t<!std::is_base_of<core::injector_base, T>::value, int> = 0>
   void install(const T &binding) {
-    this->cfg().bindings()[std::type_index(typeid(typename T::expected))] = [this, binding] {
-      return make<typename T::given>(binding);
-    };
+
+    auto type_index_array = dependency_any_to_type_index_vec<T>();
+
+//    std::cout << "type_index_array " << type_index_array.size() << std::endl;
+//    for(const auto & ti : type_index_array)
+//    {
+//      std::cout << " --> " << ti.name() << std::endl;
+//    }
+
+    const bool is_singleton = dependency_is_singleton_scope<T>();
+
+#if 0
+//    std::cout << "Creating generator saver for " << typeid(T).name() << "\n";
+    std::shared_ptr<generator_saver> gs_ptr = std::make_shared<generator_saver>(
+        [ this
+        , binding
+        , my_is_singleton = dependency_is_singleton_scope<T>()
+//        , my_data = &(this->cfg().get_full_data())
+        , my_type_index_array = type_index_array
+        ]
+        {
+//            this->cfg().bindings()[std::type_index(typeid(typename T::expected))].push_back( [this, binding] {
+//              return make<typename T::given>(binding);
+//            });
+//          std::cout << "CALLING MAKE for type with " << my_type_index_array.size() << " bindings" << std::endl;
+//          for(const auto & x : my_type_index_array)
+//            std::cout << "  --> " << x.name() << std::endl;
+//          // Make entry once
+//          auto made_entity = make<typename T::given>(binding);
+//          // Stuff entry pointer into all places in data_ that it can support based on type_index
+//          dwk_add_to_data<T>(my_is_singleton, this->cfg().get_full_data(), my_type_index_array, made_entity);
+//          // Return what we made
+//          return made_entity;
+        });
+#endif
+
+#if 0
+// does NOT want to work
+    std::shared_ptr<generator_saver> gs_ptr = std::make_shared<generator_saver>([this, binding] (){ return make<typename T::given>(binding); });
+
+    for(const auto & id : type_index_array)
+    {
+      this->cfg().bindings()[id].push_back(
+          [gs_ptr] () mutable
+          {
+             return gs_ptr->do_it();
+          });
+    }
+#endif
+
+#if 0
+    typedef generator_saver<typename T::given> gs_t;
+    std::shared_ptr<gs_t> gs_ptr = std::make_shared<gs_t>(++gs_num(), [this, binding] (){ return make<typename T::given>(binding); });
+
+    for(const auto & id : type_index_array)
+    {
+      std::cout << "mapping (" << id.name() << ") to (" << typeid(typename T::given).name() << ")" << std::endl;
+
+      this->cfg().bindings()[id].push_back(
+//          [this, binding] () mutable
+          [gs_ptr]
+          {
+//            generator_saver gs([this, binding] (){ return make<typename T::given>(binding); });
+//            return gs.do_it();
+            return gs_ptr->do_it();
+          });
+    }
+#endif
+
+#if 0
+// WORKS
+    for(const auto & id : type_index_array)
+    {
+      this->cfg().bindings()[id].push_back(
+          [this, binding] ()
+          {
+              return make<typename T::given>(binding);
+          });
+    }
+#endif
+
+
+    // Let's try this
+//    typedef std::function<void*()> fn_t;
+//    std::shared_ptr<fn_t> ptr_fn(new fn_t([this, binding] ()
+//                                          {
+//                                            if(mt->ptr == nullptr)
+//                                              mt->ptr = make<typename T::given>(binding);
+//                                            return mt->ptr;
+//                                          }));
+
+    typedef my_binding_entry<injector<TErrorPolicy, TScopeTraits>, T, typename T::given, decltype(type_index_array)> my_thing_t;
+    std::shared_ptr<ibinding_entry> my_thing_ptr = std::shared_ptr<my_thing_t>(new my_thing_t(is_singleton, this, binding, ++unique_binding_id, type_index_array, this->cfg().get_full_mapping()));
+
+    for(const auto & id : type_index_array)
+    {
+      this->cfg().bindings()[id].push_back(
+          my_thing_ptr );
+    }
+
   }
 
   template <class T, std::enable_if_t<std::is_base_of<core::injector_base, T>::value, int> = 0>
@@ -153,6 +634,7 @@ class injector : public core::injector<runtime_provider<TErrorPolicy, TScopeTrai
   auto make_impl(aux::pair<TInit, aux::type_list<Ts...>>) {
     return new T{typename any<Ts, injector>::type{*this}...};
   }
+ public:
 
   template <class T, class TBinding>
   auto make(const TBinding &) -> decltype(make_impl<T>(typename ctor_traits<T>::type{})) {
@@ -160,7 +642,8 @@ class injector : public core::injector<runtime_provider<TErrorPolicy, TScopeTrai
   }
 
   template <class T, class TBinding>
-  auto make(const TBinding &binding) -> decltype(new T{binding.object_}) {
+  auto make(const TBinding &binding) -> decltype(new T{binding.object_})
+  {
     return new T{binding.object_};
   }
 };
diff --git a/extension/include/boost/di/extension/providers/runtime_provider_additions.h b/extension/include/boost/di/extension/providers/runtime_provider_additions.h
new file mode 100755
index 0000000000..d38406e805
--- /dev/null
+++ b/extension/include/boost/di/extension/providers/runtime_provider_additions.h
@@ -0,0 +1,107 @@
+#pragma once
+// DWK for this entire file
+
+#include <cassert>
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <typeindex>
+#include <unordered_map>
+#include <utility>
+
+#include "boost/di.hpp"
+#include "boost/di/extension/scopes/shared.hpp"
+
+#include "boost/di/extension/providers/runtime_provider_additions_any_of.h"
+#include "boost/di/extension/providers/runtime_provider_additions_di_core_array.h"
+//#include "boost/di/extension/providers/runtime_provider
+#include "boost/di/extension/providers/runtime_provider_generator_saver.h"
+#include "boost/di/extension/providers/runtime_provider_additions_is_singleton.h"
+
+
+BOOST_DI_NAMESPACE_BEGIN
+namespace extension {
+
+
+// ---------------------------------------------------------------------------
+// dependency_any_to_type_index_vec
+template <typename T>
+typename std::enable_if<!dwk_is_di_core_dep_any_v<T>, std::array<std::type_index, 0> >::type
+constexpr dependency_any_to_type_index_vec() // std::vector<std::type_index> & /*type_index_vec*/)
+{
+  // TODO, assert??  is there really nothing to add to the vector
+  return std::array<std::type_index, 0>();
+}
+
+
+
+template <typename T>
+typename std::enable_if<dwk_is_di_core_dep_any_v<T>, typename dwk_is_di_core_dep<T>::array_t >::type
+constexpr dependency_any_to_type_index_vec()
+{
+//    std::cout << "----------------------------\n";
+//    std::cout << "dwk_get_binding_typeids di_Core template\n";
+//    std::cout << "SCOPE>>> " << typeid(typename dwk_is_di_core_dep<T>::scope_t).name() << std::endl;
+//    std::cout << "BINDINGS>>> " << typeid(typename dwk_is_di_core_dep<T>::bindings_t).name() << std::endl;
+//    std::cout << "BOUND>>> " << typeid(typename dwk_is_di_core_dep<T>::bound_t).name() << std::endl;
+//    std::cout << "W>>> " << typeid(typename dwk_is_di_core_dep<T>::W_t).name() << std::endl;
+//    std::cout << "X>>> " << typeid(typename dwk_is_di_core_dep<T>::X_t).name() << std::endl;
+//    std::cout << "----------------------------\n";
+
+  // TODO, link up dwk_is_di_core_dep and this method get_type_index_array insead of them just happening to have the same return type '1' currently
+  const auto res = get_type_index_array<typename dwk_is_di_core_dep<T>::bindings_t>();
+  return res;
+}
+
+
+#if 0
+// TODO, or maybe just delete all of this?
+// ---------------------------------------------------------------------------
+// TODO, this needs some cleanup
+template <typename T, typename DATA_T, typename MADE_T>
+//typename std::enable_if<dwk_is_core_any_v<T>, void>::type
+void
+dwk_add_to_data2(const bool is_singleton, DATA_T & data, const std::vector<std::type_index> & type_index_vec, MADE_T m)
+{
+  if(!is_singleton)
+  {
+    std::cout << "Skipping adding non-singleton " << typeid(T).name() << std::endl;
+     return;
+  }
+//      std::cout << "ADD TO DATA2 CRAZY MULTI INHERITANCE " << typeid(T).name() << "\n";
+  // only create this shared_ptr once and stuff it everywhere it has been bound to
+  std::shared_ptr<typename std::remove_pointer<MADE_T>::type> made_shared_ptr{m};
+  std::shared_ptr<void> void_shared_ptr = made_shared_ptr;
+
+  // TODO, don't need to pass in the type index vec cause we can just get it from the dwk_is_core_any<T>::??
+  for(auto & type_idx : type_index_vec)
+  {
+    std::cout << "   ADDING to data: " << typeid(MADE_T).name() << " as a " << type_idx.name() << ", " << type_idx.hash_code() << "\n";
+    data[type_idx].push_back(void_shared_ptr);
+    std::cout << "data[type_idx].size() == " << data[type_idx].size() << std::endl;
+//          std::cout << "   ADDING after size = " << data[type_idx].size() << "\n";
+//          std::cout << std::endl;
+  }
+}
+
+template <typename T, typename DATA_T, typename MADE_T>
+typename std::enable_if<!dwk_is_di_core_dep_any_v<T>, void>::type
+dwk_add_to_data(const bool /*is_singleton*/, DATA_T & /*data*/, const std::vector<std::type_index> & /*type_index_vec*/, MADE_T /*m*/)
+{
+  // TODO, believe this is done with double, int, etc.
+  std::cout << "dwk_add_to_data nada" << std::endl;
+}
+
+template <typename T, typename DATA_T, typename MADE_T>
+// DWK, TODO make this also ensure that T::given is a pointer and not an instance
+typename std::enable_if<dwk_is_di_core_dep_any_v<T>, void>::type
+dwk_add_to_data(const bool is_singleton, DATA_T & data, const std::vector<std::type_index> & type_index_vec, MADE_T m)
+{
+  typedef typename dwk_is_di_core_dep<T>::bindings_t bindings_t;
+  dwk_add_to_data2<bindings_t, DATA_T>(is_singleton, data, type_index_vec, m);
+}
+
+#endif
+
+} // namespace extension
+BOOST_DI_NAMESPACE_END
diff --git a/extension/include/boost/di/extension/providers/runtime_provider_additions_any_of.h b/extension/include/boost/di/extension/providers/runtime_provider_additions_any_of.h
new file mode 100644
index 0000000000..ffba512f65
--- /dev/null
+++ b/extension/include/boost/di/extension/providers/runtime_provider_additions_any_of.h
@@ -0,0 +1,67 @@
+#pragma once
+
+//
+// Created by Dave on 9/20/20.
+//
+
+#include <array>
+
+#include "boost/di.hpp"
+
+
+BOOST_DI_NAMESPACE_BEGIN
+namespace extension {
+
+// ---------------------------------------------------------------------------
+// Takes variadic template pack from concepts::any_of<Ts..>> and gives you an array of std::type_index
+template<typename T> struct is_any_of : std::false_type {};
+template<typename... Ts> struct is_any_of<boost::ext::di::v1_2_0::concepts::any_of<Ts...>> : std::true_type
+{
+  static constexpr size_t size() { return sizeof...(Ts); }
+  static constexpr std::array<std::type_index, sizeof...(Ts)> var_args_to_array_ids()
+  {
+    const std::array<std::type_index, sizeof...(Ts)> res {typeid(Ts)...};
+    return res;
+  }
+};
+template<typename T> constexpr bool is_any_of_v = is_any_of<T>::value;
+
+// ---------------------------------------------------------------------------
+// Specialization function for any_of<Ts...> to array
+template<typename T>
+typename std::enable_if<is_any_of_v<T>, std::array<std::type_index, is_any_of<T>::size() > >::type
+get_type_index_array()
+{
+  return is_any_of<T>::var_args_to_array_ids();
+}
+
+// Specialization function for just a type
+template<typename T>
+typename std::enable_if<!is_any_of_v<T> /*&& std::is_integral<T>()*/, std::array<std::type_index, 1> >::type
+get_type_index_array()
+{
+  return std::array<std::type_index, 1>{ typeid(T) };
+}
+
+// ---------------------------------------------------------------------------
+// Specialization function for any_of<Ts...> to array
+template<typename T>
+typename std::enable_if<is_any_of_v<T>, size_t >::type
+constexpr get_size_index_array()
+{
+  return is_any_of<T>::size();
+}
+
+// Specialization function for just a type
+template<typename T>
+typename std::enable_if<!is_any_of_v<T> /*&& std::is_integral<T>()*/, size_t >::type
+constexpr get_size_index_array()
+{
+  return 1;
+}
+
+
+
+
+} // namespace extension
+BOOST_DI_NAMESPACE_END
diff --git a/extension/include/boost/di/extension/providers/runtime_provider_additions_core_dep_any.h b/extension/include/boost/di/extension/providers/runtime_provider_additions_core_dep_any.h
new file mode 100644
index 0000000000..c2844d65fd
--- /dev/null
+++ b/extension/include/boost/di/extension/providers/runtime_provider_additions_core_dep_any.h
@@ -0,0 +1,25 @@
+#pragma once
+//
+// Created by Dave on 9/20/20.
+//
+#include <array>
+#include "boost/di/extension/providers/runtime_provider_additions_any_of.h"
+
+// ---------------------------------------------------------------------------
+// di core dep any
+template<typename, typename = void, typename = void, typename = void>
+struct dwk_is_di_core_dep : std::false_type {};
+template <typename SCOPE, typename BINDINGS, typename BOUND, typename W, typename X>
+struct dwk_is_di_core_dep<boost::ext::di::v1_2_0::core::dependency<SCOPE, BINDINGS, BOUND, W, X>> : std::true_type
+{
+    typedef SCOPE scope_t; // scope: singleton?
+    typedef BINDINGS bindings_t;
+    typedef BOUND bound_t;
+    typedef W W_t;
+    typedef X X_t;
+
+    static constexpr size_t size() { return boost::di::extension::get_size_index_array<bindings_t>(); }
+    typedef std::array<std::type_index, size()> array_t;
+};
+template <typename T>
+static constexpr bool dwk_is_di_core_dep_any_v = dwk_is_di_core_dep<T>::value;
diff --git a/extension/include/boost/di/extension/providers/runtime_provider_additions_di_core_array.h b/extension/include/boost/di/extension/providers/runtime_provider_additions_di_core_array.h
new file mode 100644
index 0000000000..b0da968f96
--- /dev/null
+++ b/extension/include/boost/di/extension/providers/runtime_provider_additions_di_core_array.h
@@ -0,0 +1,60 @@
+#pragma once
+// DWK for this entire file
+
+#include "boost/di.hpp"
+#include "boost/di/extension/scopes/shared.hpp"
+
+BOOST_DI_NAMESPACE_BEGIN
+namespace extension {
+
+// ---------------------------------------------------------------------------
+// This specialization detects when we're trying to create an std::vector<std::shared_ptr<interface_t>>
+// it's not just a vector, it's some weird boost di wrapper core array with a vector inside that
+//    template<typename T>
+//    struct is_vector : public std::false_type {};
+//    template<typename T>
+//    struct is_vector<std::vector<T>> : public std::true_type {};
+
+template <typename T>
+struct is_di_core_array : public std::false_type {};
+template <typename T> //                N5boost3ext2di6v1_2_04core5arrayIFNSt3__16vectorINS5_10shared_ptrI2i1EENS5_9allocatorIS9_EEEEvEJEEE
+struct is_di_core_array<boost::ext::di::v1_2_0::core::array<std::__1::vector<T*, std::__1::allocator<T*> > ()> > : public std::true_type
+{
+typedef T subtype;
+typedef T* raw_ptr_t;
+typedef T* ptr_t;
+};
+// but then shared_ptr<T> is a possibility too - why don't we just tie into the other get<T> creation methods?
+template <typename T>
+struct is_di_core_array<boost::ext::di::v1_2_0::core::array<std::__1::vector<std::shared_ptr<T>, std::__1::allocator<std::shared_ptr<T>> > ()> > : public std::true_type
+{
+typedef T subtype;
+typedef T* raw_ptr_t;
+typedef std::shared_ptr<T> ptr_t;
+};
+
+
+// ----------------------------------------------------------------------------
+template <typename T>
+struct is_di_core_array_list : public std::false_type {};
+template <typename T>                       // boost::ext::di::v1_2_0::cores::successful::any_type_ref<std::__1::list, boost::ext::di::v1_2_0::core::injector>
+                       //get<T> NSt3__14listINS_10shared_ptrI2i1EENS_9allocatorIS3_EEEE
+struct is_di_core_array_list<std::__1::list<T*, std::__1::allocator<T*> >  > : public std::true_type
+{
+  typedef T subtype;
+  typedef T* raw_ptr_t;
+  typedef T* ptr_t;
+};
+// but then shared_ptr<T> is a possibility too - why don't we just tie into the other get<T> creation methods?
+template <typename T>
+struct is_di_core_array_list<std::__1::list<std::shared_ptr<T>, std::__1::allocator<std::shared_ptr<T>> >  > : public std::true_type
+{
+  typedef T subtype;
+  typedef T* raw_ptr_t;
+  typedef std::shared_ptr<T> ptr_t;
+};
+
+
+
+} // namespace extension
+BOOST_DI_NAMESPACE_END
diff --git a/extension/include/boost/di/extension/providers/runtime_provider_additions_is_singleton.h b/extension/include/boost/di/extension/providers/runtime_provider_additions_is_singleton.h
new file mode 100644
index 0000000000..1b1b8e88a6
--- /dev/null
+++ b/extension/include/boost/di/extension/providers/runtime_provider_additions_is_singleton.h
@@ -0,0 +1,38 @@
+#pragma once
+// DWK for this entire file
+
+#include "boost/di.hpp"
+#include "boost/di/extension/providers/runtime_provider_additions_core_dep_any.h"
+
+BOOST_DI_NAMESPACE_BEGIN
+namespace extension {
+
+// ---------------------------------------------------------------------------
+// scope_is_singleton
+template<typename T>
+typename std::enable_if<!std::is_same<boost::ext::di::v1_2_0::scopes::singleton, T>::value, bool>::type
+scope_is_singleton() { return false; }
+
+template<typename T>
+typename std::enable_if<std::is_same<boost::ext::di::v1_2_0::scopes::singleton, T>::value, bool>::type
+scope_is_singleton() { return true; }
+
+// ---------------------------------------------------------------------------
+// dependency_is_singleton_scope
+template <typename T>
+typename std::enable_if<!dwk_is_di_core_dep_any_v<T>, bool>::type
+dependency_is_singleton_scope()
+{
+  return false; // Unknown really
+}
+template <typename T>
+typename std::enable_if<dwk_is_di_core_dep_any_v<T>, bool>::type
+dependency_is_singleton_scope()
+{
+  typedef typename dwk_is_di_core_dep<T>::scope_t scope_t;
+  return scope_is_singleton<scope_t>();
+}
+
+
+} // namespace extension
+BOOST_DI_NAMESPACE_END
\ No newline at end of file
diff --git a/extension/include/boost/di/extension/providers/runtime_provider_generator_saver.h b/extension/include/boost/di/extension/providers/runtime_provider_generator_saver.h
new file mode 100755
index 0000000000..00120d7ae0
--- /dev/null
+++ b/extension/include/boost/di/extension/providers/runtime_provider_generator_saver.h
@@ -0,0 +1,52 @@
+#pragma once
+// DWK for this entire file
+
+// TODO, namespace?!
+template <typename T>
+class generator_saver
+{
+ public:
+  explicit generator_saver
+    ( const int gs_num
+    , std::function<void*()> fn)
+      : m_gs_num(gs_num)
+      , m_fn(fn)
+  {}
+
+  generator_saver(generator_saver const &) = delete;
+  generator_saver(generator_saver &&) = delete;
+
+  ~generator_saver()
+  {}
+
+// TODO?
+//  ~generator_saver()
+//  {
+//      if(m_saved)
+//      {
+//        delete m_saved;
+//        m_saved = nullptr;
+//      }
+//  }
+
+  void* do_it()
+  {
+    if(!m_saved)
+    {
+      if(!m_fn)
+        return nullptr;
+      m_saved = m_fn();
+      // Created type
+    }
+    else
+    {
+      // Using previoulsy saved type
+    }
+    return m_saved;
+  }
+private:
+  int m_gs_num {0};
+  std::function<void*()> m_fn { [](){return nullptr;} };
+  void* m_saved {nullptr};
+
+};
diff --git a/extension/include/boost/di/extension/scopes/shared.hpp b/extension/include/boost/di/extension/scopes/shared.hpp
index ca65234bf8..c03920cc5c 100644
--- a/extension/include/boost/di/extension/scopes/shared.hpp
+++ b/extension/include/boost/di/extension/scopes/shared.hpp
@@ -66,11 +66,22 @@ class shared {
         std::lock_guard<std::mutex> lock(mutex_);
         if (!object)
 #endif
-          object = std::shared_ptr<T>{provider.get()};
+        {
+          auto raw_ptr_from_get = provider.get();
+
+          // Check one last time and use that instead so that the shared_ptr comes from the right place
+          if(object)
+          {
+            return wrappers::shared<shared, T>{std::static_pointer_cast<T>(object)};
+          }
+
+          object = std::shared_ptr<T>{raw_ptr_from_get};
+        }
       }
       return wrappers::shared<shared, T>{std::static_pointer_cast<T>(object)};
     }
 
+
    private:
 #if !defined(BOOST_DI_NOT_THREAD_SAFE)
     std::mutex mutex_;
diff --git a/extension/test/CMakeLists.txt b/extension/test/CMakeLists.txt
index 6cc9b60b4a..87c7ebd3de 100644
--- a/extension/test/CMakeLists.txt
+++ b/extension/test/CMakeLists.txt
@@ -28,6 +28,7 @@ test(policies/uml_dumper)
 test(providers/heap)
 test(providers/mocks_provider)
 test(providers/runtime_provider)
+test(providers/runtime_provider_additions)
 test(scopes/scoped)
 test(scopes/session)
 test(scopes/shared)
diff --git a/extension/test/providers/runtime_provider.cpp b/extension/test/providers/runtime_provider.cpp
index ff6fa41d99..d3f5d0e11a 100644
--- a/extension/test/providers/runtime_provider.cpp
+++ b/extension/test/providers/runtime_provider.cpp
@@ -36,7 +36,13 @@ struct impl3 : i3 {
   int f() const override { return 1234; }
 };
 
-struct impl2 : i2 {
+
+struct i2_xxx {
+  virtual ~i2_xxx() noexcept = default;
+  virtual int other_bar() const { return 420; }
+};
+
+struct impl2 : i2, i2_xxx {
   explicit impl2(i3& i, std::string str) {
     assert(i.f() == 1234);
     assert(str == "text");
@@ -75,11 +81,11 @@ class module_example {
 };
 
 struct example {
-  example(std::shared_ptr<i1> sp, int i, module_example& me) {
+  example(std::shared_ptr<i1> sp, int i /*, module_example& me*/) {
     assert(dynamic_cast<impl1*>(sp.get()));
     assert(sp->foo() == 42);
     assert(i == 87);
-    assert(me.get() == 2 * 100);
+//    assert(me.get() == 2 * 100);
   }
 };
 
@@ -96,7 +102,7 @@ int main() {
   /*<<install bindings>>*/
   injector.install(
     di::bind<i1>().to<impl1>(),
-    di::bind<i2>().to<impl2>()
+    di::bind<i2, i2_xxx>().to<impl2>()
   );
 
   /*<<more bindings>>*/
diff --git a/extension/test/providers/runtime_provider_additions.cpp b/extension/test/providers/runtime_provider_additions.cpp
new file mode 100644
index 0000000000..bfa5038e07
--- /dev/null
+++ b/extension/test/providers/runtime_provider_additions.cpp
@@ -0,0 +1,229 @@
+//
+// Copyright (c) 2012-2020 Kris Jusiak (kris at jusiak dot net)
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#include "boost/di/extension/providers/runtime_provider.hpp"
+
+#include <cassert>
+#include <string>
+
+namespace di = boost::di;
+
+struct i1 {
+  virtual ~i1() noexcept = default;
+  virtual int foo() const = 0;
+};
+
+struct i2 {
+  virtual ~i2() noexcept = default;
+  virtual int bar() const = 0;
+};
+
+struct i3 {
+  virtual ~i3() noexcept = default;
+  virtual int f() const = 0;
+};
+
+struct i4 {
+  virtual ~i4() noexcept = default;
+  virtual int foo() const = 0;
+};
+
+struct impl3 : i3 {
+  explicit impl3(const int& i) { assert(i == 87); }
+  int f() const override { return 1234; }
+};
+
+
+struct i2_xxx {
+  virtual ~i2_xxx() noexcept = default;
+  virtual int other_bar() const { return 420; }
+};
+
+struct impl2 : i2, i2_xxx {
+  explicit impl2(i3& i, std::string str)
+  {
+    assert(i.f() == 1234);
+    assert(str == "text");
+  }
+  int bar() const override { return 99; }
+};
+
+
+
+struct impl1 : i1 {
+  explicit impl1(std::unique_ptr<i2> sp2) { assert(sp2->bar() == 99); }
+  int foo() const override { return 42; }
+};
+
+
+
+struct i1_b {
+  virtual ~i1_b() noexcept = default;
+  virtual int foo_b() const = 0;
+};
+
+struct impl1b : i1, i1_b {
+  explicit impl1b(std::unique_ptr<i2> sp2) { assert(sp2->bar() == 99); }
+  int foo() const override { return 42; }
+  int foo_b() const override { return 1042; }
+};
+
+class ctor;
+class dtor;
+
+struct impl4 : i4 {
+  template <class>
+  static auto& calls() {
+    static auto i = 0;
+    return i;
+  }
+
+  impl4() { ++calls<ctor>(); }
+  ~impl4() { ++calls<dtor>(); }
+
+  int foo() const override { return 100; }
+};
+
+class module_example {
+ public:
+  explicit module_example(std::shared_ptr<i4> sp) : sp{sp} {}
+  auto get() const { return sp->foo() * 2; }
+
+ private:
+  std::shared_ptr<i4> sp{};
+};
+
+struct example {
+  example(std::shared_ptr<i1> sp, int i, module_example& me) {
+    assert(dynamic_cast<impl1*>(sp.get()));
+    assert(sp->foo() == 42);
+    assert(i == 87);
+    assert(me.get() == 2 * 100);
+  }
+};
+
+//auto ct_module = [] { return di::make_injector(di::bind<i4>().to<impl4>()); };
+di::extension::runtime_injector rt_module() { return di::make_injector(di::bind<i4>().to<impl4>()); }
+
+int main() {
+  // clang-format off
+  namespace di = boost::di;
+
+  /*<<create runtime injector>>*/
+  di::extension::runtime_injector injector{};
+
+  /*<<install bindings>>*/
+  injector.install(
+    di::bind<i1>().to<impl1>(),
+    di::bind<i1, i1_b>().to<impl1b>().in(boost::di::singleton),
+        di::bind<i3>().to<impl3>(), // todo remove this when integrating with below
+        di::bind<int>().to(87), // todo remove this as well...
+        di::bind<std::string>().to("text"), // todo remove this as well...
+    di::bind<i2, i2_xxx>().to<impl2>()
+  );
+
+  // Create one by itself - to get injected into constructors
+  std::shared_ptr<i1_b> i1_b_ptr = injector.create<std::shared_ptr<i1_b>>();
+  // std::cout << "i1_b_ptr is @" << i1_b_ptr << std::endl;
+
+
+  {
+    // Try out list first - which means give us only what has been created already
+    typedef std::list<std::shared_ptr<i1>> i1_list_t;
+    i1_list_t i1_list = injector.create<i1_list_t>();
+    assert(1 == i1_list.size());
+
+    int i1_b_count {0};
+    for(auto & x : i1_list)
+    {
+      if(std::dynamic_pointer_cast<i1_b>(x))
+      {
+        ++i1_b_count;
+        assert( &(*x) == &(* reinterpret_cast<i1*>(i1_b_ptr.get()) ) );
+      }
+    }
+    assert(1 == i1_b_count);
+  }
+
+
+  {
+     // Try out vector - which means construct all of them
+     typedef std::vector<std::shared_ptr<i1>> i1_vec_t;
+     i1_vec_t i1_vec = injector.create<i1_vec_t>();
+     assert(2 == i1_vec.size());
+
+     int i1_b_count {0};
+     for(auto & x : i1_vec)
+     {
+        if(std::dynamic_pointer_cast<i1_b>(x))
+        {
+           ++i1_b_count;
+           assert( &(*x) == &(* reinterpret_cast<i1*>(i1_b_ptr.get()) ) );
+        }
+     }
+    assert(1 == i1_b_count);
+
+  }
+
+
+#if 0
+  typedef std::vector<std::shared_ptr<i1>> i1_vec_t;
+//  typedef std::list<std::shared_ptr<i1>> i1_vec_t; // TODO, omg this is horribly broken! lol!
+  i1_vec_t i1_vec = injector.create<i1_vec_t>();
+  std::cout << "i1_vec size " << i1_vec.size() << std::endl;
+  for(auto & x : i1_vec)
+  {
+    std::cout << "   @" << x << " -> " << x->foo() << std::endl;
+    if(std::dynamic_pointer_cast<i1_b>(x))
+      std::cout << "   ^^ this is a i1_b type" << std::endl;
+  }
+
+  std::shared_ptr<i1> i1_by_self = injector.create<std::shared_ptr<i1>>();
+  std::cout << "i1 by self is @" << i1_by_self << std::endl;
+
+
+  std::shared_ptr<i3> i3_ptr = injector.create<std::shared_ptr<i3>>();
+  std::cout << "i3 " << i3_ptr->f() << std::endl;
+#endif
+
+#if 0
+  /*<<more bindings>>*/
+  injector.install(di::bind<int>().to(87));
+
+  /*<<injector bindings>>*/
+  auto component = di::make_injector(
+    di::bind<i3>().to<impl3>(),
+    di::bind<std::string>().to("text")
+  );
+  injector.install(component);
+
+  /*<<module bindings>>*/
+  injector.install(ct_module());
+
+  /*<<create example>>*/
+  injector.create<example>();
+
+// injector.dump_data_bindings();
+
+  // scoped injector
+  {
+    impl4::calls<ctor>() = {};
+    impl4::calls<dtor>() = {};
+
+    di::extension::runtime_injector injector{};
+    injector.install(rt_module());
+    auto m = di::create<module_example>(injector);
+
+    assert(m.get() == 2 * 100);
+    assert(impl4::calls<ctor>() == 1);
+    assert(impl4::calls<dtor>() == 0);
+  }
+  assert(impl4::calls<ctor>() == 1);
+  assert(impl4::calls<dtor>() == 1);
+#endif
+  // clang-format on
+}
+