diff --git a/.bazelrc b/.bazelrc
index fd0eaaa..f30718e 100644
--- a/.bazelrc
+++ b/.bazelrc
@@ -1,3 +1,3 @@
-build:windows --copt="/std:c++17" --copt="/W4"
+build:windows --copt="/std:c++17" --copt="/W4" --copt="/O2"
 build:linux --copt="-std=c++17" --copt="-O3"
-build:macos --copt="-std=c++17"
+build:macos --copt="-std=c++17" --copt="-O3"
diff --git a/.gitignore b/.gitignore
index 6dd515f..915ed92 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,5 @@
 
 .vscode/
 bazel-*
+
+callgrind.out.*
diff --git a/BUILD b/BUILD
index c693788..0cfbf49 100644
--- a/BUILD
+++ b/BUILD
@@ -23,6 +23,7 @@ cc_library(
         "-Wall",
         "-Wextra",
         "-Wshadow",
+        "-Wunused",
     ],
     hdrs = glob([
         "include/**/*.hpp",
diff --git a/README.md b/README.md
index a78f5fb..f7bd657 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,10 @@
 
 C++17 inversion of control and dependency injection container library.
 
+## Containerless Version
+
+See the [`containerless` branch](https://github.com/mosure/inversify-cpp/tree/containerless) for a static binding (containerless) version of the library.
+
 ## Features
 *   Constant, dynamic, and automatic resolvers
 *   Singleton, resolution (TODO), and unique scopes
@@ -71,6 +75,8 @@ namespace symbols {
 
 ```
 
+> Note: symbols which hold the same interface type may do so via structs which inherit inversify::Symbol
+
 #### Declare Classes and Dependencies
 
 ```cpp
@@ -135,9 +141,9 @@ Singleton scope dynamic bindings cache the first resolution of the binding.
 ```cpp
 
 container.bind<symbols::fizz>().toDynamicValue(
-    [](const inversify::Context& ctx) {
-        auto foo = ctx.container.get<symbols::foo>();
-        auto bar = ctx.container.get<symbols::bar>();
+    [](auto& ctx) {
+        auto foo = ctx.container.template get<symbols::foo>();
+        auto bar = ctx.container.template get<symbols::bar>();
 
         auto fizz = std::make_shared<Fizz>(foo, bar);
 
@@ -154,10 +160,10 @@ Dynamic bindings can be used to resolve factory functions.
 ```cpp
 
 container.bind<symbols::fizzFactory>().toDynamicValue(
-    [](const inversify::Context& ctx) {
+    [](auto& ctx) {
         return [&]() {
-            auto foo = ctx.container.get<symbols::foo>();
-            auto bar = ctx.container.get<symbols::bar>();
+            auto foo = ctx.container.template get<symbols::foo>();
+            auto bar = ctx.container.template get<symbols::bar>();
 
             auto fizz = std::make_shared<Fizz>(foo, bar);
 
@@ -209,12 +215,19 @@ Use the following to run tests:
 
 `bazel run test --enable_platform_specific_config`
 
-> Note: run the example app in a similar way: `bazel run example --enable_platform_specific_config`
+> Note: run the example app in a similar way: `bazel run example/simple --enable_platform_specific_config`
 
 ## TODOS
 *   More compile-time checks
 *   Resolution scope
 
+### Profiling
+
+Run the following to generate a callgrind file:
+
+*   `bazel run example/profiling --enable_platform_specific_config --compilation_mode=dbg -s`
+*   `valgrind --tool=callgrind --dump-instr=yes --simulate-cache=yes --collect-jumps=yes ./bazel-bin/example/profiling/profiling`
+
 ## Generating `single_include` Variant
 
 Run `python ./third_party/amalgamate/amalgamate.py -c ./third_party/amalgamate/config.json -s ./` from the root of the repository.
diff --git a/example/profiling/BUILD b/example/profiling/BUILD
new file mode 100644
index 0000000..04b43b3
--- /dev/null
+++ b/example/profiling/BUILD
@@ -0,0 +1,13 @@
+load("@rules_cc//cc:defs.bzl", "cc_binary")
+
+
+cc_binary(
+    name = "profiling",
+    srcs = [
+        "main.cpp",
+    ],
+    deps = [
+        "//:inversify",
+    ],
+    visibility = ["//visibility:public"]
+)
diff --git a/example/profiling/main.cpp b/example/profiling/main.cpp
new file mode 100644
index 0000000..f39f6b9
--- /dev/null
+++ b/example/profiling/main.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+
+#include <mosure/inversify.hpp>
+
+
+namespace inversify = mosure::inversify;
+
+using int_symbol = inversify::Symbol<int>;
+
+struct Service {
+    int val;
+
+    Service() : val(0) { }
+    Service(int val) : val(val) { }
+
+    void foo() {
+        std::cout << "hello: " << val << std::endl;
+    }
+};
+
+template <>
+struct inversify::Injectable<Service>
+    : inversify::Inject<
+        int_symbol
+    >
+{ };
+
+using test_symbol = inversify::Symbol<Service>;
+
+
+template <typename Container>
+void to_profile(Container& container) {
+    container.template get<test_symbol>().foo();
+}
+
+int main() {
+    inversify::Container<
+        int_symbol,
+        test_symbol
+    > container;
+
+    container.bind<int_symbol>().toConstantValue(3);
+    container.bind<test_symbol>().to<Service>();
+
+    to_profile(container);
+}
diff --git a/example/BUILD b/example/simple/BUILD
similarity index 74%
rename from example/BUILD
rename to example/simple/BUILD
index 2e4692a..baa57df 100644
--- a/example/BUILD
+++ b/example/simple/BUILD
@@ -2,7 +2,7 @@ load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library")
 
 
 cc_library(
-    name = "example_api",
+    name = "simple_api",
     hdrs = glob([
         "api/*.hpp",
         "src/*.hpp",
@@ -14,7 +14,7 @@ cc_library(
 )
 
 cc_library(
-    name = "example_src_hdrs",
+    name = "simple_src_hdrs",
     hdrs = glob([
         "src/*.hpp",
     ]),
@@ -25,13 +25,13 @@ cc_library(
 )
 
 cc_binary(
-    name = "example",
+    name = "simple",
     srcs = glob([
         "src/*.cpp",
     ]),
     deps = [
-        ":example_api",
-        ":example_src_hdrs",
+        ":simple_api",
+        ":simple_src_hdrs",
         "//:inversify",
     ],
     visibility = ["//visibility:public"]
diff --git a/example/api/logger.hpp b/example/simple/api/logger.hpp
similarity index 100%
rename from example/api/logger.hpp
rename to example/simple/api/logger.hpp
diff --git a/example/api/service.hpp b/example/simple/api/service.hpp
similarity index 100%
rename from example/api/service.hpp
rename to example/simple/api/service.hpp
diff --git a/example/api/settings.hpp b/example/simple/api/settings.hpp
similarity index 100%
rename from example/api/settings.hpp
rename to example/simple/api/settings.hpp
diff --git a/example/api/symbols.hpp b/example/simple/api/symbols.hpp
similarity index 100%
rename from example/api/symbols.hpp
rename to example/simple/api/symbols.hpp
diff --git a/example/src/logger.hpp b/example/simple/src/logger.hpp
similarity index 100%
rename from example/src/logger.hpp
rename to example/simple/src/logger.hpp
diff --git a/example/src/main.cpp b/example/simple/src/main.cpp
similarity index 79%
rename from example/src/main.cpp
rename to example/simple/src/main.cpp
index 19034f5..d5747f4 100644
--- a/example/src/main.cpp
+++ b/example/simple/src/main.cpp
@@ -11,7 +11,11 @@
 namespace inversify = mosure::inversify;
 
 int main() {
-    inversify::Container container;
+    inversify::Container<
+        symbols::logger,
+        symbols::service,
+        symbols::settings
+    > container;
 
     container.bind<symbols::logger>().to<Logger>().inSingletonScope();
     container.bind<symbols::service>().to<Service>();
diff --git a/example/src/mock_logger.hpp b/example/simple/src/mock_logger.hpp
similarity index 100%
rename from example/src/mock_logger.hpp
rename to example/simple/src/mock_logger.hpp
diff --git a/example/src/service.hpp b/example/simple/src/service.hpp
similarity index 100%
rename from example/src/service.hpp
rename to example/simple/src/service.hpp
diff --git a/example/src/settings.hpp b/example/simple/src/settings.hpp
similarity index 100%
rename from example/src/settings.hpp
rename to example/simple/src/settings.hpp
diff --git a/include/mosure/binding.hpp b/include/mosure/binding.hpp
index 2c68aff..870c1ff 100644
--- a/include/mosure/binding.hpp
+++ b/include/mosure/binding.hpp
@@ -1,56 +1,73 @@
 #pragma once
 
 #include <functional>
-#include <memory>
+#include <type_traits>
 
 #include <mosure/context.hpp>
 #include <mosure/factory.hpp>
 #include <mosure/resolver.hpp>
+#include <mosure/exceptions/resolution.hpp>
 
 
 namespace mosure::inversify {
 
-    template <typename T>
+    template <typename T, typename... SymbolTypes>
     class BindingScope {
         public:
             void inSingletonScope() {
-                resolver_ = std::make_shared<inversify::CachedResolver<T>>(resolver_);
+                static_assert(
+                    std::is_copy_constructible<T>::value,
+                    "inversify::BindingScope singleton must have copy constructor"
+                );
+
+                this->factory_ = [this, factory = std::move(factory_)](auto& context) {
+                    if (!this->cached_set_) {
+                        this->cached_ = factory(context);
+                        this->cached_set_ = true;
+                    }
+
+                    return this->cached_;
+                };
             }
 
         protected:
-            inversify::ResolverPtr<T> resolver_;
+            T cached_;
+            bool cached_set_ { false };
+            inversify::Factory<T, SymbolTypes...> factory_;
     };
 
-    template <typename T>
-    class BindingTo : public BindingScope<T> {
+    template <typename T, typename... SymbolTypes>
+    class BindingTo
+        : public BindingScope<T, SymbolTypes...>
+    {
         public:
             void toConstantValue(T&& value) {
-                this->resolver_ = std::make_shared<inversify::ConstantResolver<T>>(value);
+                this->factory_ = [val = std::move(value)](auto&) {
+                    return val;
+                };
             }
 
-            BindingScope<T>& toDynamicValue(inversify::Factory<T> factory) {
-                this->resolver_ = std::make_shared<inversify::DynamicResolver<T>>(factory);
+            BindingScope<T, SymbolTypes...>& toDynamicValue(inversify::Factory<T, SymbolTypes...>&& factory) {
+                this->factory_ = std::move(factory);
 
                 return *this;
             }
 
             template <typename U>
-            BindingScope<T>& to() {
-                this->resolver_ = std::make_shared<inversify::AutoResolver<T, U>>();
+            BindingScope<T, SymbolTypes...>& to() {
+                this->factory_ = inversify::get_auto_resolver<T, U, SymbolTypes...>();
 
                 return *this;
             }
     };
 
-    template <typename T>
-    class Binding : public BindingTo<T> {
+    template <typename T, typename... SymbolTypes>
+    class Binding
+        : public BindingTo<typename T::value, SymbolTypes...>
+    {
         public:
-            inline T resolve(const Context& context) const {
-                if (!this->resolver_) {
-                    throw inversify::exceptions::ResolutionException("inversify::Resolver not found. Malformed binding.");
-                }
-
-                return this->resolver_->resolve(context);
+            inline typename T::value resolve(const inversify::Context<SymbolTypes...>& context) {
+                return this->factory_(context);
             }
     };
 
diff --git a/include/mosure/container.hpp b/include/mosure/container.hpp
index 8bd165d..a234377 100644
--- a/include/mosure/container.hpp
+++ b/include/mosure/container.hpp
@@ -1,31 +1,64 @@
 #pragma once
 
+#include <tuple>
+
 #include <mosure/binding.hpp>
 #include <mosure/context.hpp>
 #include <mosure/interfaces/icontainer.hpp>
+#include <mosure/meta.hpp>
 
 
 namespace mosure::inversify {
 
-    template <typename Symbol>
-    struct BindingLookup {
-        inline static inversify::Binding<typename Symbol::value> binding {};
-    };
-
-    class Container : public inversify::IContainer<Container> {
+    template <typename... SymbolTypes>
+    class Container
+        : public inversify::IContainer<Container, SymbolTypes...> 
+    {
         public:
+            static_assert(
+                meta::valid_symbol_types_v<SymbolTypes...>,
+                "inversify::Container symbols must be of type inversify::Symbol"
+            );
+
+            static_assert(
+                !meta::is_empty_v<SymbolTypes...>,
+                "inversify::Container must register at least one symbol"
+            );
+
+            using BindingMap = std::tuple<
+                inversify::Binding<
+                    SymbolTypes,
+                    SymbolTypes...
+                >...
+            >;
+
             template <typename T>
-            inline inversify::BindingTo<typename T::value>& bind() {
-                return BindingLookup<T>::binding;
+            inline inversify::BindingTo<typename T::value, SymbolTypes...>& bind() {
+                static_assert(
+                    meta::contains_v<T, SymbolTypes...>,
+                    "inversify::Container symbol not registered"
+                );
+
+                return std::get<
+                    inversify::Binding<T, SymbolTypes...>
+                >(bindings_);
             }
 
             template <typename T>
-            inline typename T::value get() const {
-                return BindingLookup<T>::binding.resolve(context_);
+            inline typename T::value get() {
+                static_assert(
+                    meta::contains_v<T, SymbolTypes...>,
+                    "inversify::Container symbol not registered"
+                );
+
+                return std::get<
+                    inversify::Binding<T, SymbolTypes...>
+                >(bindings_).resolve(context_);
             }
 
         private:
-            inversify::Context context_ { *this };
+            BindingMap bindings_ {};
+            inversify::Context<SymbolTypes...> context_ { *this };
     };
 
 }
diff --git a/include/mosure/context.hpp b/include/mosure/context.hpp
index beba74c..f6ba081 100644
--- a/include/mosure/context.hpp
+++ b/include/mosure/context.hpp
@@ -5,10 +5,12 @@
 
 namespace mosure::inversify {
 
+    template <typename... SymbolTypes>
     class Container;
 
+    template <typename... SymbolTypes>
     struct Context {
-        const inversify::IContainer<Container>& container;
+        inversify::IContainer<Container, SymbolTypes...>& container;
     };
 
 }
diff --git a/include/mosure/factory.hpp b/include/mosure/factory.hpp
index ec98d4c..5e1d4a3 100644
--- a/include/mosure/factory.hpp
+++ b/include/mosure/factory.hpp
@@ -7,7 +7,7 @@
 
 namespace mosure::inversify {
 
-    template <typename T>
-    using Factory = std::function<T(const inversify::Context&)>;
+    template <typename T, typename... SymbolTypes>
+    using Factory = std::function<T(const inversify::Context<SymbolTypes...>&)>;
 
 }
diff --git a/include/mosure/injectable.hpp b/include/mosure/injectable.hpp
index b71c32d..aa4ce7e 100644
--- a/include/mosure/injectable.hpp
+++ b/include/mosure/injectable.hpp
@@ -5,21 +5,24 @@
 
 #include <mosure/context.hpp>
 #include <mosure/meta.hpp>
-#include <mosure/symbol.hpp>
 
 
 namespace mosure::inversify {
 
     template <typename... Dependencies>
     struct Inject {
-        static_assert(meta::valid_inject_types_v<Dependencies...>, "inversify::Injectable dependencies must be of type inversify::Symbol");
-
-        inline static auto resolve(const inversify::Context& context) {
-            return std::make_tuple(context.container.get<Dependencies>()...);
+        static_assert(
+            meta::valid_symbol_types_v<Dependencies...>,
+            "inversify::Injectable dependencies must be of type inversify::Symbol"
+        );
+
+        template <typename... SymbolTypes>
+        inline static auto resolve(const inversify::Context<SymbolTypes...>& context) {
+            return std::make_tuple(context.container.template get<Dependencies>()...);
         }
     };
 
     template <typename Implementation, typename Inject = inversify::Inject<>>
-    struct Injectable : Inject { };
+    struct Injectable: Inject { };
 
 }
diff --git a/include/mosure/interfaces/icontainer.hpp b/include/mosure/interfaces/icontainer.hpp
index 10bdb3c..7cedf40 100644
--- a/include/mosure/interfaces/icontainer.hpp
+++ b/include/mosure/interfaces/icontainer.hpp
@@ -7,22 +7,28 @@
 
 namespace mosure::inversify {
 
-    template <typename T>
+    template <
+        typename T,
+        typename... SymbolTypes
+    >
     class BindingTo;
 
-    template <typename Implementation>
+    template <
+        template <typename...> class Implementation,
+        typename... SymbolTypes
+    >
     class IContainer {
         public:
             template <typename T>
-            inversify::BindingTo<typename T::value>& bind() {
-                auto crtpImplementation = static_cast<Implementation const *>(this);
+            inversify::BindingTo<typename T::value, SymbolTypes...>& bind() {
+                auto crtpImplementation = static_cast<Implementation<SymbolTypes...> *>(this);
 
                 return crtpImplementation->template bind<T>();
             }
 
             template <typename T>
-            typename T::value get() const {
-                auto crtpImplementation = static_cast<Implementation const *>(this);
+            typename T::value get() {
+                auto crtpImplementation = static_cast<Implementation<SymbolTypes...> *>(this);
 
                 return crtpImplementation->template get<T>();
             }
diff --git a/include/mosure/inversify.hpp b/include/mosure/inversify.hpp
index c21eb2b..0f8bc4b 100644
--- a/include/mosure/inversify.hpp
+++ b/include/mosure/inversify.hpp
@@ -33,7 +33,7 @@ SOFTWARE.
 #include <stdexcept>        // runtime_error
 #include <string>           // string
 #include <tuple>            // make_from_tuple, tuple
-#include <type_traits>      // apply, conjunction_v, false_type, true_type
+#include <type_traits>      // apply, conjunction_v, disjunction_v, false_type, is_copy_constructable, is_same, true_type
 
 #include <mosure/binding.hpp>
 #include <mosure/container.hpp>
diff --git a/include/mosure/meta.hpp b/include/mosure/meta.hpp
index a6b9801..fab12ad 100644
--- a/include/mosure/meta.hpp
+++ b/include/mosure/meta.hpp
@@ -1,23 +1,67 @@
 #pragma once
 
+#include <memory>
 #include <type_traits>
 #include <utility>
 
+#include <mosure/symbol.hpp>
+
 
 namespace mosure::inversify::meta {
 
-    template <class T, template <class...> class Template>
+    template<
+        typename T,
+        typename... Types
+    >
+    inline constexpr bool contains_v = std::disjunction_v<
+        std::is_same<T, Types>...
+    >;
+
+
+    template <typename... Args>
+    struct is_empty : std::false_type { };
+
+    template<>
+    struct is_empty<> : std::true_type { };
+
+    template <typename... Args>
+    inline constexpr bool is_empty_v = is_empty<Args...>::value;
+
+
+    template <
+        typename T,
+        template <typename...> typename Template
+    >
     struct is_specialization : std::false_type { };
 
-    template <template <class...> class Template, class... Args>
+    template <
+        template <typename...> typename Template,
+        typename... Args
+    >
     struct is_specialization<Template<Args...>, Template> : std::true_type { };
 
-    template <typename ...Types>
-    inline constexpr bool valid_inject_types_v = std::conjunction_v<
-        meta::is_specialization<Types, Symbol>...
-    >;
 
     template <typename T>
-    using value_t = typename T::value;
+    struct is_unique_ptr : std::false_type { };
+
+    template <
+        typename T,
+        typename D
+    >
+    struct is_unique_ptr<std::unique_ptr<T, D>> : std::true_type { };
+
+    template <typename T>
+    struct is_shared_ptr : std::false_type { };
+
+    template <typename T>
+    struct is_shared_ptr<std::shared_ptr<T>> : std::true_type { };
+
+
+    template <typename ...Types>
+    inline constexpr bool valid_symbol_types_v = std::conjunction_v<
+        meta::is_specialization<Types, inversify::Symbol>...
+    > || std::conjunction_v<
+        std::is_base_of<inversify::Symbol<typename Types::value>, Types>...
+    >;
 
 }
diff --git a/include/mosure/resolver.hpp b/include/mosure/resolver.hpp
index 3a8d8fe..6a3c27f 100644
--- a/include/mosure/resolver.hpp
+++ b/include/mosure/resolver.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <atomic>
 #include <memory>
 #include <tuple>
 #include <type_traits>
@@ -8,112 +7,49 @@
 #include <mosure/context.hpp>
 #include <mosure/factory.hpp>
 #include <mosure/injectable.hpp>
-#include <mosure/exceptions/resolution.hpp>
+#include <mosure/meta.hpp>
 
 
 namespace mosure::inversify {
 
-    template <typename T>
-    class Resolver {
-        public:
-            inline virtual T resolve(const inversify::Context&) = 0;
-    };
-
-    template <typename T>
-    using ResolverPtr = std::shared_ptr<Resolver<T>>;
-
-    template <typename T>
-    class ConstantResolver : public Resolver<T> {
-        public:
-            explicit ConstantResolver(T value) : value_(value) { }
-
-            inline T resolve(const inversify::Context&) override {
-                return value_;
-            }
-
-        private:
-            T value_;
-    };
-
-    template <typename T>
-    class DynamicResolver : public Resolver<T> {
-        public:
-            explicit DynamicResolver(inversify::Factory<T> factory) : factory_(factory) { }
-
-            inline T resolve(const inversify::Context& context) override {
-                return factory_(context);
-            }
-
-        private:
-            inversify::Factory<T> factory_;
-    };
-
-    template <typename T, typename U, typename = void>
-    class AutoResolver;
-
-    template <typename T, typename U>
-    class AutoResolver<T, U> : public Resolver<T> {
-        public:
-            inline T resolve(const inversify::Context& context) override {
-                return std::make_from_tuple<U>(inversify::Injectable<U>::resolve(context));
-            }
-    };
-
-    // unique_ptr specialization
     template <
         typename T,
-        typename U
+        typename U,
+        typename... SymbolTypes
     >
-    class AutoResolver<std::unique_ptr<T>, U> : public Resolver<std::unique_ptr<T>> {
-        public:
-            inline std::unique_ptr<T> resolve(const inversify::Context& context) override {
-                auto expansion = [&context](auto&& ... deps){
+    inline static inversify::Factory<T, SymbolTypes...> get_auto_resolver() {
+        if constexpr (meta::is_unique_ptr<T>::value) {
+            return [](const inversify::Context<SymbolTypes...>& context) {
+                auto expansion = [](auto&& ... deps){
                     return std::make_unique<U>(deps...);
                 };
 
-                return std::apply(expansion, std::move(inversify::Injectable<U>::resolve(context)));
-            }
-    };
-
-    // shared_ptr specialization
-    template <
-        typename T,
-        typename U
-    >
-    class AutoResolver<std::shared_ptr<T>, U> : public Resolver<std::shared_ptr<T>> {
-        public:
-            inline std::shared_ptr<T> resolve(const inversify::Context& context) override {
-                auto expansion = [&context](auto&& ... deps){
+                return std::apply(
+                    expansion,
+                    std::move(
+                        inversify::Injectable<U>::resolve(context)
+                    )
+                );
+            };
+        } else if constexpr (meta::is_shared_ptr<T>::value) {
+            return [](const inversify::Context<SymbolTypes...>& context) {
+                auto expansion = [](auto&& ... deps){
                     return std::make_shared<U>(deps...);
                 };
 
-                return std::apply(expansion, std::move(inversify::Injectable<U>::resolve(context)));
-            }
-    };
-
-    template <typename T>
-    class CachedResolver : public Resolver<T> {
-        static_assert(
-            std::is_copy_constructible_v<T>,
-            "inversify::CachedResolver requires a copy constructor. Are you caching a unique_ptr?"
-        );
-
-        public:
-            explicit CachedResolver(ResolverPtr<T> parent) : parent_(parent) { }
-
-            inline T resolve(const inversify::Context& context) override {
-                if (!hasCached_) {
-                    hasCached_ = true;
-                    cached_ = parent_->resolve(context);
-                }
-
-                return cached_;
-            }
-
-        private:
-            T cached_;
-            std::atomic<bool> hasCached_ { false };
-            ResolverPtr<T> parent_;
-    };
-
+                return std::apply(
+                    expansion,
+                    std::move(
+                        inversify::Injectable<U>::resolve(context)
+                    )
+                );
+            };
+        } else {
+            return [](const inversify::Context<SymbolTypes...>& context) {
+                return std::make_from_tuple<U>(
+                    inversify::Injectable<U>::resolve(context)
+                );
+            };
+        }
+    }
 }
diff --git a/include/mosure/symbol.hpp b/include/mosure/symbol.hpp
index 073e4aa..f28991a 100644
--- a/include/mosure/symbol.hpp
+++ b/include/mosure/symbol.hpp
@@ -1,13 +1,17 @@
 #pragma once
 
 #include <type_traits>
+#include <variant>
 
 
 namespace mosure::inversify {
 
     template <typename Interface>
     struct Symbol {
-        static_assert(!std::is_abstract<Interface>(), "inversify::Container cannot bind/get abstract class value (use a smart pointer instead).");
+        static_assert(
+            !std::is_abstract<Interface>(),
+            "inversify::Container cannot bind/get abstract class value (use a smart pointer instead)."
+        );
 
         using value = Interface;
     };
diff --git a/single_include/mosure/inversify.hpp b/single_include/mosure/inversify.hpp
index 940e973..b29a164 100644
--- a/single_include/mosure/inversify.hpp
+++ b/single_include/mosure/inversify.hpp
@@ -33,98 +33,109 @@ SOFTWARE.
 #include <stdexcept>        // runtime_error
 #include <string>           // string
 #include <tuple>            // make_from_tuple, tuple
-#include <type_traits>      // apply, conjunction_v, false_type, true_type
+#include <type_traits>      // apply, conjunction_v, disjunction_v, false_type, is_copy_constructable, is_same, true_type
 
 // #include <mosure/binding.hpp>
 
 
 #include <functional>
-#include <memory>
+#include <type_traits>
 
 // #include <mosure/context.hpp>
 
 
 // #include <mosure/interfaces/icontainer.hpp>
-
-
-#include <memory>
-
+
+
+#include <memory>
+
 // #include <mosure/symbol.hpp>
 
 
 #include <type_traits>
+#include <variant>
 
 
 namespace mosure::inversify {
 
     template <typename Interface>
     struct Symbol {
-        static_assert(!std::is_abstract<Interface>(), "inversify::Container cannot bind/get abstract class value (use a smart pointer instead).");
+        static_assert(
+            !std::is_abstract<Interface>(),
+            "inversify::Container cannot bind/get abstract class value (use a smart pointer instead)."
+        );
 
         using value = Interface;
     };
 
 }
-
-
-
-namespace mosure::inversify {
-
-    template <typename T>
-    class BindingTo;
-
-    template <typename Implementation>
-    class IContainer {
-        public:
-            template <typename T>
-            inversify::BindingTo<typename T::value>& bind() {
-                auto crtpImplementation = static_cast<Implementation const *>(this);
-
-                return crtpImplementation->template bind<T>();
-            }
-
-            template <typename T>
-            typename T::value get() const {
-                auto crtpImplementation = static_cast<Implementation const *>(this);
-
-                return crtpImplementation->template get<T>();
-            }
-    };
-
-}
 
 
 
 namespace mosure::inversify {
 
+    template <
+        typename T,
+        typename... SymbolTypes
+    >
+    class BindingTo;
+
+    template <
+        template <typename...> class Implementation,
+        typename... SymbolTypes
+    >
+    class IContainer {
+        public:
+            template <typename T>
+            inversify::BindingTo<typename T::value, SymbolTypes...>& bind() {
+                auto crtpImplementation = static_cast<Implementation<SymbolTypes...> *>(this);
+
+                return crtpImplementation->template bind<T>();
+            }
+
+            template <typename T>
+            typename T::value get() {
+                auto crtpImplementation = static_cast<Implementation<SymbolTypes...> *>(this);
+
+                return crtpImplementation->template get<T>();
+            }
+    };
+
+}
+
+
+
+namespace mosure::inversify {
+
+    template <typename... SymbolTypes>
     class Container;
 
+    template <typename... SymbolTypes>
     struct Context {
-        const inversify::IContainer<Container>& container;
+        inversify::IContainer<Container, SymbolTypes...>& container;
     };
 
 }
 
 // #include <mosure/factory.hpp>
-
-
-#include <functional>
-
+
+
+#include <functional>
+
 // #include <mosure/context.hpp>
-
-
-
-namespace mosure::inversify {
-
-    template <typename T>
-    using Factory = std::function<T(const inversify::Context&)>;
-
-}
+
+
+
+namespace mosure::inversify {
+
+    template <typename T, typename... SymbolTypes>
+    using Factory = std::function<T(const inversify::Context<SymbolTypes...>&)>;
+
+}
 
 // #include <mosure/resolver.hpp>
 
 
-#include <atomic>
 #include <memory>
 #include <tuple>
 #include <type_traits>
@@ -134,177 +145,164 @@ namespace mosure::inversify {
 // #include <mosure/factory.hpp>
 
 // #include <mosure/injectable.hpp>
-
-
-#include <tuple>
-#include <type_traits>
-
+
+
+#include <tuple>
+#include <type_traits>
+
 // #include <mosure/context.hpp>
-
+
 // #include <mosure/meta.hpp>
-
-
-#include <type_traits>
-#include <utility>
-
-
-namespace mosure::inversify::meta {
-
-    template <class T, template <class...> class Template>
-    struct is_specialization : std::false_type { };
-
-    template <template <class...> class Template, class... Args>
-    struct is_specialization<Template<Args...>, Template> : std::true_type { };
-
-    template <typename ...Types>
-    inline constexpr bool valid_inject_types_v = std::conjunction_v<
-        meta::is_specialization<Types, Symbol>...
-    >;
-
-    template <typename T>
-    using value_t = typename T::value;
-
-}
-
+
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+
 // #include <mosure/symbol.hpp>
-
-
-
-namespace mosure::inversify {
-
-    template <typename... Dependencies>
-    struct Inject {
-        static_assert(meta::valid_inject_types_v<Dependencies...>, "inversify::Injectable dependencies must be of type inversify::Symbol");
-
-        inline static auto resolve(const inversify::Context& context) {
-            return std::make_tuple(context.container.get<Dependencies>()...);
-        }
-    };
-
-    template <typename Implementation>
-    struct Injectable {
-        using Inject = inversify::Inject<>;
-    };
-
-}
 
-// #include <mosure/exceptions/resolution.hpp>
 
 
-#include <stdexcept>
-#include <string>
+namespace mosure::inversify::meta {
 
+    template<
+        typename T,
+        typename... Types
+    >
+    inline constexpr bool contains_v = std::disjunction_v<
+        std::is_same<T, Types>...
+    >;
 
-namespace mosure::inversify::exceptions {
 
-    struct ResolutionException : public std::runtime_error {
-        explicit ResolutionException(const std::string& msg) : std::runtime_error(msg) { }
-    };
+    template <typename... Args>
+    struct is_empty : std::false_type { };
 
-}
+    template<>
+    struct is_empty<> : std::true_type { };
 
+    template <typename... Args>
+    inline constexpr bool is_empty_v = is_empty<Args...>::value;
 
 
-namespace mosure::inversify {
+    template <
+        typename T,
+        template <typename...> typename Template
+    >
+    struct is_specialization : std::false_type { };
+
+    template <
+        template <typename...> typename Template,
+        typename... Args
+    >
+    struct is_specialization<Template<Args...>, Template> : std::true_type { };
+
 
     template <typename T>
-    class Resolver {
-        public:
-            virtual T resolve(const inversify::Context&) = 0;
-    };
+    struct is_unique_ptr : std::false_type { };
+
+    template <
+        typename T,
+        typename D
+    >
+    struct is_unique_ptr<std::unique_ptr<T, D>> : std::true_type { };
 
     template <typename T>
-    using ResolverPtr = std::shared_ptr<Resolver<T>>;
+    struct is_shared_ptr : std::false_type { };
 
     template <typename T>
-    class ConstantResolver : public Resolver<T> {
-        public:
-            explicit ConstantResolver(T value) : value_(value) { }
+    struct is_shared_ptr<std::shared_ptr<T>> : std::true_type { };
 
-            T resolve(const inversify::Context&) override {
-                return value_;
-            }
 
-        private:
-            T value_;
-    };
+    template <typename ...Types>
+    inline constexpr bool valid_symbol_types_v = std::conjunction_v<
+        meta::is_specialization<Types, inversify::Symbol>...
+    > || std::conjunction_v<
+        std::is_base_of<inversify::Symbol<typename Types::value>, Types>...
+    >;
 
-    template <typename T>
-    class DynamicResolver : public Resolver<T> {
-        public:
-            explicit DynamicResolver(inversify::Factory<T> factory) : factory_(factory) { }
+}
 
-            T resolve(const inversify::Context& context) override {
-                return factory_(context);
-            }
 
-        private:
-            inversify::Factory<T> factory_;
-    };
 
-    template <typename T, typename U, typename = void>
-    class AutoResolver;
+namespace mosure::inversify {
 
-    template <typename T, typename U>
-    class AutoResolver<T, U> : public Resolver<T> {
-        public:
-            T resolve(const inversify::Context& context) override {
-                return std::make_from_tuple<U>(inversify::Injectable<U>::Inject::resolve(context));
-            }
+    template <typename... Dependencies>
+    struct Inject {
+        static_assert(
+            meta::valid_symbol_types_v<Dependencies...>,
+            "inversify::Injectable dependencies must be of type inversify::Symbol"
+        );
+
+        template <typename... SymbolTypes>
+        inline static auto resolve(const inversify::Context<SymbolTypes...>& context) {
+            return std::make_tuple(context.container.template get<Dependencies>()...);
+        }
     };
 
-    // unique_ptr specialization
+    template <typename Implementation, typename Inject = inversify::Inject<>>
+    struct Injectable: Inject { };
+
+}
+
+// #include <mosure/meta.hpp>
+
+
+
+namespace mosure::inversify {
+
     template <
         typename T,
-        typename U
+        typename U,
+        typename... SymbolTypes
     >
-    class AutoResolver<std::unique_ptr<T>, U> : public Resolver<std::unique_ptr<T>> {
-        public:
-            std::unique_ptr<T> resolve(const inversify::Context& context) override {
-                auto expansion = [&context](auto&& ... deps){
+    inline static inversify::Factory<T, SymbolTypes...> get_auto_resolver() {
+        if constexpr (meta::is_unique_ptr<T>::value) {
+            return [](const inversify::Context<SymbolTypes...>& context) {
+                auto expansion = [](auto&& ... deps){
                     return std::make_unique<U>(deps...);
                 };
 
-                return std::apply(expansion, std::move(inversify::Injectable<U>::Inject::resolve(context)));
-            }
-    };
-
-    // shared_ptr specialization
-    template <
-        typename T,
-        typename U
-    >
-    class AutoResolver<std::shared_ptr<T>, U> : public Resolver<std::shared_ptr<T>> {
-        public:
-            std::shared_ptr<T> resolve(const inversify::Context& context) override {
-                auto expansion = [&context](auto&& ... deps){
+                return std::apply(
+                    expansion,
+                    std::move(
+                        inversify::Injectable<U>::resolve(context)
+                    )
+                );
+            };
+        } else if constexpr (meta::is_shared_ptr<T>::value) {
+            return [](const inversify::Context<SymbolTypes...>& context) {
+                auto expansion = [](auto&& ... deps){
                     return std::make_shared<U>(deps...);
                 };
 
-                return std::apply(expansion, std::move(inversify::Injectable<U>::Inject::resolve(context)));
-            }
-    };
+                return std::apply(
+                    expansion,
+                    std::move(
+                        inversify::Injectable<U>::resolve(context)
+                    )
+                );
+            };
+        } else {
+            return [](const inversify::Context<SymbolTypes...>& context) {
+                return std::make_from_tuple<U>(
+                    inversify::Injectable<U>::resolve(context)
+                );
+            };
+        }
+    }
+}
 
-    template <typename T>
-    class CachedResolver : public Resolver<T> {
-        static_assert(std::is_copy_constructible_v<T>, "inversify::CachedResolver requires a copy constructor. Are you caching a unique_ptr?");
+// #include <mosure/exceptions/resolution.hpp>
 
-        public:
-            explicit CachedResolver(ResolverPtr<T> parent) : parent_(parent) { }
 
-            T resolve(const inversify::Context& context) override {
-                if (!hasCached_) {
-                    hasCached_ = true;
-                    cached_ = parent_->resolve(context);
-                }
+#include <stdexcept>
+#include <string>
 
-                return cached_;
-            }
 
-        private:
-            T cached_;
-            std::atomic<bool> hasCached_ { false };
-            ResolverPtr<T> parent_;
+namespace mosure::inversify::exceptions {
+
+    struct ResolutionException : public std::runtime_error {
+        explicit ResolutionException(const std::string& msg) : std::runtime_error(msg) { }
     };
 
 }
@@ -313,47 +311,63 @@ namespace mosure::inversify {
 
 namespace mosure::inversify {
 
-    template <typename T>
+    template <typename T, typename... SymbolTypes>
     class BindingScope {
         public:
             void inSingletonScope() {
-                resolver_ = std::make_shared<inversify::CachedResolver<T>>(resolver_);
+                static_assert(
+                    std::is_copy_constructible<T>::value,
+                    "inversify::BindingScope singleton must have copy constructor"
+                );
+
+                this->factory_ = [this, factory = std::move(factory_)](auto& context) {
+                    if (!this->cached_set_) {
+                        this->cached_ = factory(context);
+                        this->cached_set_ = true;
+                    }
+
+                    return this->cached_;
+                };
             }
 
         protected:
-            inversify::ResolverPtr<T> resolver_;
+            T cached_;
+            bool cached_set_ { false };
+            inversify::Factory<T, SymbolTypes...> factory_;
     };
 
-    template <typename T>
-    class BindingTo : public BindingScope<T> {
+    template <typename T, typename... SymbolTypes>
+    class BindingTo
+        : public BindingScope<T, SymbolTypes...>
+    {
         public:
             void toConstantValue(T&& value) {
-                this->resolver_ = std::make_shared<inversify::ConstantResolver<T>>(value);
+                this->factory_ = [val = std::move(value)](auto&) {
+                    return val;
+                };
             }
 
-            BindingScope<T>& toDynamicValue(inversify::Factory<T> factory) {
-                this->resolver_ = std::make_shared<inversify::DynamicResolver<T>>(factory);
+            BindingScope<T, SymbolTypes...>& toDynamicValue(inversify::Factory<T, SymbolTypes...>&& factory) {
+                this->factory_ = std::move(factory);
 
                 return *this;
             }
 
             template <typename U>
-            BindingScope<T>& to() {
-                this->resolver_ = std::make_shared<inversify::AutoResolver<T, U>>();
+            BindingScope<T, SymbolTypes...>& to() {
+                this->factory_ = inversify::get_auto_resolver<T, U, SymbolTypes...>();
 
                 return *this;
             }
     };
 
-    template <typename T>
-    class Binding : public BindingTo<T> {
+    template <typename T, typename... SymbolTypes>
+    class Binding
+        : public BindingTo<typename T::value, SymbolTypes...>
+    {
         public:
-            T resolve(const Context& context) const {
-                if (!this->resolver_) {
-                    throw inversify::exceptions::ResolutionException("inversify::Resolver not found. Malformed binding.");
-                }
-
-                return this->resolver_->resolve(context);
+            inline typename T::value resolve(const inversify::Context<SymbolTypes...>& context) {
+                return this->factory_(context);
             }
     };
 
@@ -362,35 +376,69 @@ namespace mosure::inversify {
 // #include <mosure/container.hpp>
 
 
+#include <tuple>
+
 // #include <mosure/binding.hpp>
 
 // #include <mosure/context.hpp>
 
 // #include <mosure/interfaces/icontainer.hpp>
 
+// #include <mosure/meta.hpp>
+
 
 
 namespace mosure::inversify {
 
-    template <typename Symbol>
-    struct BindingLookup {
-        inline static inversify::Binding<typename Symbol::value> binding {};
-    };
-
-    class Container : public inversify::IContainer<Container> {
+    template <typename... SymbolTypes>
+    class Container
+        : public inversify::IContainer<Container, SymbolTypes...> 
+    {
         public:
+            static_assert(
+                meta::valid_symbol_types_v<SymbolTypes...>,
+                "inversify::Container symbols must be of type inversify::Symbol"
+            );
+
+            static_assert(
+                !meta::is_empty_v<SymbolTypes...>,
+                "inversify::Container must register at least one symbol"
+            );
+
+            using BindingMap = std::tuple<
+                inversify::Binding<
+                    SymbolTypes,
+                    SymbolTypes...
+                >...
+            >;
+
             template <typename T>
-            inversify::BindingTo<typename T::value>& bind() {
-                return BindingLookup<T>::binding;
+            inline inversify::BindingTo<typename T::value, SymbolTypes...>& bind() {
+                static_assert(
+                    meta::contains_v<T, SymbolTypes...>,
+                    "inversify::Container symbol not registered"
+                );
+
+                return std::get<
+                    inversify::Binding<T, SymbolTypes...>
+                >(bindings_);
             }
 
             template <typename T>
-            typename T::value get() const {
-                return BindingLookup<T>::binding.resolve(context_);
+            inline typename T::value get() {
+                static_assert(
+                    meta::contains_v<T, SymbolTypes...>,
+                    "inversify::Container symbol not registered"
+                );
+
+                return std::get<
+                    inversify::Binding<T, SymbolTypes...>
+                >(bindings_).resolve(context_);
             }
 
         private:
-            inversify::Context context_ { *this };
+            BindingMap bindings_ {};
+            inversify::Context<SymbolTypes...> context_ { *this };
     };
 
 }
diff --git a/test/auto_resolve.cpp b/test/auto_resolve.cpp
index f49a847..edbf899 100644
--- a/test/auto_resolve.cpp
+++ b/test/auto_resolve.cpp
@@ -1,9 +1,9 @@
+#define CATCH_CONFIG_ENABLE_BENCHMARKING
 #include <catch2/catch.hpp>
 
 #include <mosure/inversify.hpp>
 
 #include "mock/fizz.hpp"
-#include "mock/ifizz.hpp"
 #include "mock/symbols.hpp"
 
 
@@ -12,7 +12,12 @@ namespace inversify = mosure::inversify;
 SCENARIO("container resolves automatic values", "[resolve]") {
 
     GIVEN("A container with automatic unique_ptr binding") {
-        inversify::Container container;
+        inversify::Container<
+            symbols::foo,
+            symbols::bar,
+            symbols::autoFizzUnique,
+            symbols::autoFizzShared
+        > container;
 
         container.bind<symbols::foo>().toConstantValue(10);
         container.bind<symbols::bar>().toConstantValue(1.618);
@@ -45,7 +50,12 @@ SCENARIO("container resolves automatic values", "[resolve]") {
     }
 
     GIVEN("A container with automatic singleton shared_ptr binding") {
-        inversify::Container container;
+        inversify::Container<
+            symbols::foo,
+            symbols::bar,
+            symbols::autoFizzUnique,
+            symbols::autoFizzShared
+        > container;
 
         container.bind<symbols::foo>().toConstantValue(10);
         container.bind<symbols::bar>().toConstantValue(1.618);
diff --git a/test/constant_resolve.cpp b/test/constant_resolve.cpp
index 94d5a64..6c93935 100644
--- a/test/constant_resolve.cpp
+++ b/test/constant_resolve.cpp
@@ -1,3 +1,4 @@
+#define CATCH_CONFIG_ENABLE_BENCHMARKING
 #include <catch2/catch.hpp>
 
 #include <mosure/inversify.hpp>
@@ -10,7 +11,9 @@ namespace inversify = mosure::inversify;
 SCENARIO("container resolves constant values", "[resolve]") {
 
     GIVEN("A container with constant binding") {
-        inversify::Container container;
+        inversify::Container<
+            symbols::foo
+        > container;
 
         container.bind<symbols::foo>().toConstantValue(10);
 
@@ -34,4 +37,30 @@ SCENARIO("container resolves constant values", "[resolve]") {
             }
         }
     }
+
+    GIVEN("A container with constant bindings of the same type") {
+        inversify::Container<
+            symbols::foo,
+            symbols::foo2
+        > container;
+
+        container.bind<symbols::foo>().toConstantValue(10);
+        container.bind<symbols::foo2>().toConstantValue(20);
+
+        WHEN("the foo is resolved") {
+            auto result = container.get<symbols::foo>();
+
+            THEN("the correct value is returned") {
+                REQUIRE(result == 10);
+            }
+        }
+
+        WHEN("the foo2 is resolved") {
+            auto result = container.get<symbols::foo2>();
+
+            THEN("the correct value is returned") {
+                REQUIRE(result == 20);
+            }
+        }
+    }
 }
diff --git a/test/dynamic_resolve.cpp b/test/dynamic_resolve.cpp
index c540a41..45da108 100644
--- a/test/dynamic_resolve.cpp
+++ b/test/dynamic_resolve.cpp
@@ -1,12 +1,12 @@
 #include <functional>
 #include <memory>
 
+#define CATCH_CONFIG_ENABLE_BENCHMARKING
 #include <catch2/catch.hpp>
 
 #include <mosure/inversify.hpp>
 
 #include "mock/fizz.hpp"
-#include "mock/ifizz.hpp"
 #include "mock/symbols.hpp"
 
 
@@ -15,11 +15,16 @@ namespace inversify = mosure::inversify;
 SCENARIO("container resolves dynamic values", "[resolve]") {
 
     GIVEN("A container with dynamic binding") {
-        inversify::Container container;
+        inversify::Container<
+            symbols::foo,
+            symbols::bar,
+            symbols::fizz,
+            symbols::fizzFactory
+        > container;
 
         container.bind<symbols::foo>().toConstantValue(3);
-        container.bind<symbols::bar>().toDynamicValue([](const inversify::Context& ctx) {
-            auto foo = ctx.container.get<symbols::foo>();
+        container.bind<symbols::bar>().toDynamicValue([](auto& ctx) {
+            auto foo = ctx.container.template get<symbols::foo>();
 
             return foo * 1.5;
         });
@@ -33,8 +38,8 @@ SCENARIO("container resolves dynamic values", "[resolve]") {
         }
 
         WHEN("the binding is redefined") {
-            container.bind<symbols::bar>().toDynamicValue([](const inversify::Context& ctx) {
-                auto foo = ctx.container.get<symbols::foo>();
+            container.bind<symbols::bar>().toDynamicValue([](auto& ctx) {
+                auto foo = ctx.container.template get<symbols::foo>();
 
                 return foo * 2.5;
             });
@@ -50,16 +55,21 @@ SCENARIO("container resolves dynamic values", "[resolve]") {
     }
 
     GIVEN("A container with factory binding") {
-        inversify::Container container;
+        inversify::Container<
+            symbols::foo,
+            symbols::bar,
+            symbols::fizz,
+            symbols::fizzFactory
+        > container;
 
         container.bind<symbols::foo>().toConstantValue(10);
         container.bind<symbols::bar>().toConstantValue(1.618);
 
         container.bind<symbols::fizzFactory>().toDynamicValue(
-            [](const inversify::Context& ctx) {
+            [](auto& ctx) {
                 return [&]() {
-                    auto foo = ctx.container.get<symbols::foo>();
-                    auto bar = ctx.container.get<symbols::bar>();
+                    auto foo = ctx.container.template get<symbols::foo>();
+                    auto bar = ctx.container.template get<symbols::bar>();
 
                     auto fizz = std::make_unique<Fizz>(foo, bar);
 
@@ -85,15 +95,20 @@ SCENARIO("container resolves dynamic values", "[resolve]") {
     }
 
     GIVEN("A container with singleton dynamic binding") {
-        inversify::Container container;
+        inversify::Container<
+            symbols::foo,
+            symbols::bar,
+            symbols::fizz,
+            symbols::fizzFactory
+        > container;
 
         container.bind<symbols::foo>().toConstantValue(10);
         container.bind<symbols::bar>().toConstantValue(1.618);
 
         container.bind<symbols::fizz>().toDynamicValue(
-            [](const inversify::Context& ctx) {
-                auto foo = ctx.container.get<symbols::foo>();
-                auto bar = ctx.container.get<symbols::bar>();
+            [](auto& ctx) {
+                auto foo = ctx.container.template get<symbols::foo>();
+                auto bar = ctx.container.template get<symbols::bar>();
 
                 auto fizz = std::make_shared<Fizz>(foo, bar);
 
@@ -112,15 +127,20 @@ SCENARIO("container resolves dynamic values", "[resolve]") {
     }
 
     GIVEN("A container with resolution dynamic binding") {
-        inversify::Container container;
+        inversify::Container<
+            symbols::foo,
+            symbols::bar,
+            symbols::fizz,
+            symbols::fizzFactory
+        > container;
 
         container.bind<symbols::foo>().toConstantValue(10);
         container.bind<symbols::bar>().toConstantValue(1.618);
 
         container.bind<symbols::fizz>().toDynamicValue(
-            [](const inversify::Context& ctx) {
-                auto foo = ctx.container.get<symbols::foo>();
-                auto bar = ctx.container.get<symbols::bar>();
+            [](auto& ctx) {
+                auto foo = ctx.container.template get<symbols::foo>();
+                auto bar = ctx.container.template get<symbols::bar>();
 
                 auto fizz = std::make_unique<Fizz>(foo, bar);
 
diff --git a/test/main.cpp b/test/main.cpp
index 4ed06df..16fefad 100644
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -1,2 +1,3 @@
+#define CATCH_CONFIG_ENABLE_BENCHMARKING
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
diff --git a/test/mock/iservices.hpp b/test/mock/iservices.hpp
new file mode 100644
index 0000000..9fbb122
--- /dev/null
+++ b/test/mock/iservices.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <memory>
+
+
+struct IServiceA {
+    virtual int foo() = 0;
+};
+using ServiceAPtr = std::shared_ptr<IServiceA>;
+
+struct IServiceB {
+    virtual int foo() = 0;
+};
+using ServiceBPtr = std::shared_ptr<IServiceB>;
+
+struct IServiceC {
+    virtual int foo() = 0;
+};
+using ServiceCPtr = std::shared_ptr<IServiceC>;
diff --git a/test/mock/services.hpp b/test/mock/services.hpp
new file mode 100644
index 0000000..c233bc3
--- /dev/null
+++ b/test/mock/services.hpp
@@ -0,0 +1,67 @@
+#include <mosure/inversify.hpp>
+
+#include "mock/iservices.hpp"
+#include "mock/symbols.hpp"
+
+
+namespace inversify = mosure::inversify;
+
+struct ServiceA : IServiceA {
+    ServiceA(int foo)
+        :
+        foo_(foo)
+    { }
+
+    inline int foo() override {
+        return foo_;
+    }
+
+    int foo_;
+};
+
+struct ServiceB : IServiceB {
+    ServiceB(ServiceAPtr serviceA)
+        :
+        serviceA_(serviceA)
+    { }
+
+    inline int foo() override {
+        return serviceA_->foo();
+    }
+
+    ServiceAPtr serviceA_;
+};
+
+struct ServiceC : IServiceC {
+    ServiceC(ServiceBPtr serviceB)
+        :
+        serviceB_(serviceB)
+    { }
+
+    inline int foo() override {
+        return serviceB_->foo();
+    }
+
+    ServiceBPtr serviceB_;
+};
+
+template <>
+struct inversify::Injectable<ServiceA>
+    : inversify::Inject<
+        symbols::foo
+    >
+{ };
+
+template <>
+struct inversify::Injectable<ServiceB>
+    : inversify::Inject<
+        symbols::symbolA
+    >
+{ };
+
+template <>
+struct inversify::Injectable<ServiceC>
+    : inversify::Inject<
+        symbols::symbolB
+    >
+{ };
diff --git a/test/mock/symbols.hpp b/test/mock/symbols.hpp
index a515985..66879c0 100644
--- a/test/mock/symbols.hpp
+++ b/test/mock/symbols.hpp
@@ -5,16 +5,23 @@
 #include <mosure/inversify.hpp>
 
 #include "mock/ifizz.hpp"
+#include "mock/iservices.hpp"
 
 
 namespace inversify = mosure::inversify;
 
 namespace symbols {
     using foo = inversify::Symbol<int>;
+    struct foo2 : inversify::Symbol<int> {}; // make the symbol unique by defining a struct :/
+
     using bar = inversify::Symbol<double>;
     using fizz = inversify::Symbol<IFizzSharedPtr>;
     using fizzFactory = inversify::Symbol<std::function<IFizzUniquePtr()>>;
 
     using autoFizzUnique = inversify::Symbol<IFizzUniquePtr>;
     using autoFizzShared = inversify::Symbol<IFizzSharedPtr>;
+
+    using symbolA = inversify::Symbol<ServiceAPtr>;
+    using symbolB = inversify::Symbol<ServiceBPtr>;
+    using symbolC = inversify::Symbol<ServiceCPtr>;
 }
diff --git a/test/speed.cpp b/test/speed.cpp
index ddaac95..c97fd8e 100644
--- a/test/speed.cpp
+++ b/test/speed.cpp
@@ -2,134 +2,44 @@
 #include <iostream>
 #include <memory>
 
+#define CATCH_CONFIG_ENABLE_BENCHMARKING
 #include <catch2/catch.hpp>
 
 #include <mosure/inversify.hpp>
 
 #include "mock/symbols.hpp"
+#include "mock/services.hpp"
 
 
 namespace inversify = mosure::inversify;
 
-struct IServiceA {
-    virtual int foo() = 0;
-};
-struct ServiceA : IServiceA {
-    ServiceA(int foo)
-        :
-        foo_(foo)
-    { }
-
-    inline int foo() override {
-        return foo_;
-    }
-
-    int foo_;
-};
-using ServiceAPtr = std::shared_ptr<IServiceA>;
-using symbolA = inversify::Symbol<ServiceAPtr>;
-
-struct IServiceB {
-    virtual int foo() = 0;
-};
-struct ServiceB : IServiceB {
-    ServiceB(ServiceAPtr serviceA)
-        :
-        serviceA_(serviceA)
-    { }
-
-    inline int foo() override {
-        return serviceA_->foo();
-    }
-
-    ServiceAPtr serviceA_;
-};
-using ServiceBPtr = std::shared_ptr<IServiceB>;
-using symbolB = inversify::Symbol<ServiceBPtr>;
-
-struct IServiceC {
-    virtual int foo() = 0;
-};
-struct ServiceC : IServiceC {
-    ServiceC(ServiceBPtr serviceB)
-        :
-        serviceB_(serviceB)
-    { }
-
-    inline int foo() override {
-        return serviceB_->foo();
-    }
-
-    ServiceBPtr serviceB_;
-};
-using ServiceCPtr = std::shared_ptr<IServiceC>;
-using symbolC = inversify::Symbol<ServiceCPtr>;
-
-template <>
-struct inversify::Injectable<ServiceA>
-    : inversify::Inject<
-        symbols::foo
-    >
-{ };
-
-template <>
-struct inversify::Injectable<ServiceB>
-    : inversify::Inject<
-        symbolA
-    >
-{ };
-
-template <>
-struct inversify::Injectable<ServiceC>
-    : inversify::Inject<
-        symbolB
-    >
-{ };
-
-
 SCENARIO("container resolves automatic values quickly", "[performance]") {
 
-    GIVEN("A container with an auto binding chain") {
-        inversify::Container container;
+    GIVEN("A container with an auto binding chain of size 3") {
+        inversify::Container<
+            symbols::foo,
+            symbols::symbolA,
+            symbols::symbolB,
+            symbols::symbolC
+        > container;
 
         container.bind<symbols::foo>().toConstantValue(10);
-        container.bind<symbolA>().to<ServiceA>();
-        container.bind<symbolB>().to<ServiceB>();
-        container.bind<symbolC>().to<ServiceC>();
-
-        WHEN("the dependency is resolved") {
-            const int iterations = 1000000;
-
-            auto inversify_start = std::chrono::high_resolution_clock::now();
-            for (int i = 0; i < iterations; ++i) {
-                container.get<symbolC>();
-            }
-            auto inversify_finish = std::chrono::high_resolution_clock::now();
-            auto inversify_us = std::chrono::duration_cast<std::chrono::microseconds>(inversify_finish - inversify_start);
-            auto inversify_mean = inversify_us / (float)iterations;
-            std::cout << "inversify mean: " << inversify_mean.count() << std::endl;
-
-            auto manual_start = std::chrono::high_resolution_clock::now();
-            for (int i = 0; i < iterations; ++i) {
-                std::make_shared<ServiceC>(
-                    std::make_shared<ServiceB>(
-                        std::make_shared<ServiceA>(
-                            10
-                        )
+        container.bind<symbols::symbolA>().to<ServiceA>();
+        container.bind<symbols::symbolB>().to<ServiceB>();
+        container.bind<symbols::symbolC>().to<ServiceC>();
+
+        BENCHMARK("container.get<T>()") {
+            return container.get<symbols::symbolC>();
+        };
+
+        BENCHMARK("manual injection with nested std::make_shared<T>(...)") {
+            return std::make_shared<ServiceC>(
+                std::make_shared<ServiceB>(
+                    std::make_shared<ServiceA>(
+                        10
                     )
-                );
-            }
-            auto manual_finish = std::chrono::high_resolution_clock::now();
-            auto manual_us = std::chrono::duration_cast<std::chrono::microseconds>(manual_finish - manual_start);
-            auto manual_mean = manual_us / (float)iterations;
-            std::cout << "manual mean: " << manual_mean.count() << std::endl;
-
-            auto speed_ratio = inversify_mean / manual_mean;
-            std::cout << "ratio: " << speed_ratio << std::endl;
-
-            THEN("the performance is comparable to a factory") {
-                REQUIRE(speed_ratio < 1.75); // these are rookie numbers
-            }
-        }
+                )
+            );
+        };
     }
 }