diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..ac4444e
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,29 @@
+BasedOnStyle: Chromium
+IndentWidth: 2
+ColumnLimit: 120
+
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowAllArgumentsOnNextLine: false
+SortIncludes: false
+
+# Available starting from clang_format 18
+# AllowShortCompoundRequirementOnASingleLine: true
+
+AccessModifierOffset: '-2'
+AlignAfterOpenBracket: Align
+AlignConsecutiveMacros: true
+AlignConsecutiveAssignments: true
+AlignEscapedNewlines: Left
+AlignTrailingComments: true
+AllowShortBlocksOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: true
+BinPackArguments: true
+BinPackParameters: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeComma
+BreakInheritanceList: BeforeComma
+BreakStringLiterals: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+IndentPPDirectives: AfterHash
+SortUsingDeclarations: true
\ No newline at end of file
diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 0000000..252f4f2
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,25 @@
+---
+Checks: "*,
+        -abseil-*,
+        -altera-*,
+        -android-*,
+        -fuchsia-*,
+        -google-*,
+        -llvm*,
+        -modernize-use-trailing-return-type,
+        -zircon-*,
+        -readability-else-after-return,
+        -readability-static-accessed-through-instance,
+        -readability-avoid-const-params-in-decls,
+        -cppcoreguidelines-non-private-member-variables-in-classes,
+        -misc-non-private-member-variables-in-classes,
+        -hicpp-named-parameter,
+        -clang-diagnostic-unknown-attributes,
+        -readability-named-parameter,
+        -*-avoid-c-arrays,
+        -*-magic-numbers,
+        -*-union-access
+"
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
+FormatStyle:     none
\ No newline at end of file
diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..9cb2f56
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,17 @@
+# Rules in this file were initially inferred by Visual Studio IntelliCode from the Y:\che\palliate codebase based on best match to current usage at 16/01/2022
+# You can modify the rules from these initially generated values to suit your own policies
+# You can learn more about editorconfig here: https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference
+
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+charset = utf-8
+end_of_line = lf
+
+[*.py]
+indent_style = space
+indent_size = 4
+charset = utf-8
+end_of_line = lf
\ No newline at end of file
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..dcf18cf
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,3 @@
+*.h linguist-language=cpp
+
+* text=auto eol=lf
diff --git a/.github/conan.profile b/.github/conan.profile
new file mode 100644
index 0000000..a31a3d5
--- /dev/null
+++ b/.github/conan.profile
@@ -0,0 +1,11 @@
+[settings]
+arch=x86_64
+compiler=gcc
+compiler.cppstd=23
+compiler.libcxx=libstdc++11
+compiler.version=13
+os=Linux
+
+[buildenv]
+CC=/usr/bin/gcc
+CXX=/usr/bin/g++
diff --git a/.github/workflows/codegen.yml b/.github/workflows/codegen.yml
new file mode 100644
index 0000000..12264ca
--- /dev/null
+++ b/.github/workflows/codegen.yml
@@ -0,0 +1,41 @@
+name: Run codegen
+
+on:
+  push:
+    branches: ["master", "develop"]
+  workflow_dispatch:
+
+# only run one at a time, discard unfinished runs
+concurrency:
+  group: "codegen"
+  cancel-in-progress: true
+
+jobs:
+  codegen:
+    permissions:
+      contents: write
+      pull-requests: write
+
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Setup palgen
+      uses: palliate/palgen@master
+      with:
+        run: false
+        requirements: tools/requirements.txt
+
+    - name: Run codegen
+      run: palgen --debug codegen
+
+    - name: PR changes
+      uses: peter-evans/create-pull-request@v6
+      with:
+        commit-message: Rerun codegen
+        author: Codegen Bot <contact@palliate.io>
+        branch: codegen/uncommitted
+        delete-branch: true
+        title: Codegen update
+        draft: false
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..4734932
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,36 @@
+name: Tests
+
+on:
+  push:
+    branches: ["master", "develop"]
+  pull_request:
+    branches: ["master"]
+  workflow_dispatch:
+
+jobs:
+  run-tests:
+    runs-on: ubuntu-latest
+    container: fedora:latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Install dependencies
+      run: dnf -y install conan
+
+    - name: Set up Conan profile
+      run: |
+        conan profile detect
+        cp .github/conan.profile `conan profile path default`
+
+    - uses: actions/checkout@v3
+    - name: Build
+      run: conan build . --build=missing -o sanitizers=True -s build_type=Debug
+
+    - name: Test Package
+      run: |
+        conan editable add .
+        conan test test_package slo/0.1 -s build_type=Debug
+
+    - name: Test
+      run: ./build/Debug/slo_test
diff --git a/.gitignore b/.gitignore
index 728d411..f765140 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,5 +31,21 @@
 *.out
 *.app
 
+# Python
+*.pyc
+**/__pycache__/
+
 # IDE files
 .vscode
+
+# Build files
+**/build/
+
+# misc
+**/compile_commands.json
+**/scratchpad*.*
+**/CMakeUserPresets.json
+
+# Caches
+.cache
+.pytest_cache
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..211bfad
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,79 @@
+cmake_minimum_required(VERSION 3.15)
+include(cmake/warnings.cmake)
+
+project(slo CXX)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+add_library(slo INTERFACE)
+
+set_property(TARGET slo PROPERTY CXX_STANDARD 23)
+
+target_include_directories(slo INTERFACE 
+    $<INSTALL_INTERFACE:include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>)
+
+
+option(BUILD_TESTING "Enable tests" ON)
+option(ENABLE_SANITIZERS "Enable asan and ubsan" OFF)
+option(ENABLE_COVERAGE "Enable coverage instrumentation" OFF)
+option(ENABLE_BENCHMARK "Enable benchmarks" OFF)
+
+if(NOT BUILD_TESTING STREQUAL OFF)
+  message(STATUS "Building unit tests")
+
+  enable_testing()
+  add_executable(slo_test "")
+  
+  enable_warnings(slo_test)
+
+  find_package(GTest REQUIRED)
+  target_link_libraries(slo_test PRIVATE slo)
+  target_link_libraries(slo_test PRIVATE GTest::gtest GTest::gtest_main GTest::gmock)
+
+  include(GoogleTest)
+  gtest_discover_tests(slo_test)
+  
+  add_subdirectory(test)
+
+  if(ENABLE_COVERAGE)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+      target_compile_options(slo_test PRIVATE -g -O0 --coverage -fprofile-arcs -ftest-coverage -fprofile-abs-path)
+      target_link_libraries(slo_test PRIVATE gcov)
+      message(STATUS "Instrumenting for coverage")
+    else()
+      message(FATAL_ERROR "Currently only GCC is supported for coverage instrumentation.")
+    endif()
+  endif()
+
+  if(ENABLE_SANITIZERS AND WIN32)
+    message(STATUS "Enabling sanitizers")
+    if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+      target_compile_options(slo_test INTERFACE -fsanitize=address)
+      target_link_options(slo_test INTERFACE -fsanitize=address)
+    endif()
+  elseif(ENABLE_SANITIZERS)
+    message(STATUS "Enabling sanitizers")
+    target_compile_options(slo_test INTERFACE -fsanitize=address,undefined)
+    target_link_options(slo_test INTERFACE -fsanitize=address,undefined)
+  endif()
+endif()
+
+if (ENABLE_BENCHMARK)
+  message(STATUS "Building runtime benchmarks")
+  add_executable(slo_benchmark "")
+  add_subdirectory(benchmark)
+  find_package(benchmark REQUIRED)
+  target_link_libraries(slo_benchmark PRIVATE benchmark::benchmark_main)
+  target_link_libraries(slo_benchmark PRIVATE slo)
+endif()
+
+## headers
+set_target_properties(slo PROPERTIES PUBLIC_HEADER "include/slo")
+install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/include/
+        DESTINATION include)
+
+## binaries
+install(TARGETS ${TARGET}
+        ARCHIVE DESTINATION lib # Windows import libraries (.lib)
+        RUNTIME DESTINATION bin # Windows DLLs
+        LIBRARY DESTINATION lib) # shared libraries (ie Linux .so)
diff --git a/README.md b/README.md
index 6e3a603..8eb5c1d 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,50 @@
-# variant
\ No newline at end of file
+# `slo::variant` - a fast variant
+
+This C++23 library implements various tricks to speed up compile time of a variant type. While there are some slight differences, this library aims to fulfill most of the requirements specified in [[variant]](https://standards.pydong.org/c++23/variant). This was initially written as reference implementation for the techniques discussed in [a deep-dive blog post about unions](https://pydong.org/posts/implementing-variant/).
+
+## Differences
+### Storage
+A variant is essentially just a record of a sum type and a discriminator. The most natural way to implement this in C++ is by defining variant as a non-union class-type that has two members: the actual union type and some small integer as discriminator. Unfortunately this can introduce additional, undesired padding.
+
+However, if all alternative types are standard-layout types and the compiler has C++26 `std::is_within_lifetime` (or an intrinsic that can be used to implement it) we can potentially do a little better. If those conditions are met `slo::variant` will automatically prefer the inverted storage strategy. Essentially it works by wrapping every alternative in a struct type that has the tag as first data member - outside of constant evaluated context the tag can be inspected through any alternative (even inactive ones!) since they all share the same common initial sequence. Since we can't just access the tag through an inactive member In constant evaluated context, we need to do a bit more mental gymnastics. To retrieve the tag we must find the currently active alternative - `std::is_within_lifetime` can help with that. Once we have found the active member, we can access the tag through it.
+
+### Underlying union layout
+To generate the underlying union from a list of types, most implementations opt to define it as a recursive union type. Since this recursive type must be walked for a lot of operations (notably `std::get` and the in-place constructors), its recursion depth is a major contributor to bad compile times. Some libraries such as boost:variant2 alleviate that issue by partially specializing the recursive union for a bunch of alternatives at once if possible. This does flatten the recursion depth quite a bit, but it is still linear.
+
+To get rid of crazy recursion depth with very large variants, `slo::Variant` switches strategy if instantiated with a lot of alternatives. The alternative strategy uses a complete binary tree layout for the underlying union instead. The trade-off is essentially a little bit of time to generate the tree once template gets instantiated for much quicker and also more consistently quick to compile `get`, in-place constructors and so on.
+
+### Wrapping existing unions
+Sometimes for some reason you already have a bare union. To allow you to use it safely, like you could've if it was a variant, the `slo::Union` alias template can be used to generate a variant from it. The `slo::Union` template takes pointers to data members instead of types - so instead of `slo::variant<int, char>` you would write `slo::Union<&Foo::member_1, &Foo::member_2>`.
+
+The interesting thing about wrapping a bare union like this is that we now have a flat union type. None of the recursion worries matter anymore and as an added bonus we can (optionally) attempt to hide the discriminator in tail padding of the union member.
+
+### Visitation
+`slo::visit` can use one of 3 visitation strategies
+- Generate a sufficiently large switch with macros, discard all unneeded cases. The Microsoft STL way.
+- Trigger an optimization pass in GCC/Clang to turn a fold expression into a switch.
+- Generate an array of pointers to generated dispatcher functions
+
+The latter is the fall-back strategy. This is the only strategy that requires an indirect call. Interestingly at the time of writing libstdc++ and libc++ both _always_ generate an array of function pointers when visiting multiple variants - even if the total amount of possible states is very low. `slo::visit` does not - it will also generate jump tables when visiting multiple variants.
+
+
+## Usage
+TODO
+
+
+## FAQ
+### Why `slo`? Isn't this supposed to be fast?
+**S**tandard **L**ibrary **O**ptimizations. Also turns out not many people use the `slo` namespace in their (public) projects.
+
+## License
+
+`slo::variant` is provided under the [MIT License](LICENSE). Feel free to use and modify it in your projects. The techniques used in this library are explained in the aforementioned blog post, which is published under the [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) license.
+
+
+## Contributing
+
+If you'd like to contribute to `slo::variant`, please fork the repository, make your changes, and submit a pull request. Contributions are highly welcomed - including but not limited to bug reports, bug fixes, new features, and improvements.
+
+
+## Contact
+
+For questions or issues related to this library, please [open an issue](https://github.com/tsche/variant/issues).
diff --git a/benchmark/algorithm/cbt.cpp b/benchmark/algorithm/cbt.cpp
new file mode 100644
index 0000000..580a14c
--- /dev/null
+++ b/benchmark/algorithm/cbt.cpp
@@ -0,0 +1,120 @@
+#include <type_traits>
+#include <utility>
+#include <slo/util/list.h>
+#include <slo/impl/feature.h>
+#define SLO_USE_PACK_INDEXING ON
+
+
+
+#if USING(SLO_USE_PACK_INDEXING) || __cpp_pack_indexing >= 202311L
+#  define SLO_TYPE_AT(Idx, Pack) Pack[Idx]
+#define SLO_HAS_TYPE_PACK_INDEXING 1
+#elif __has_builtin(__type_pack_element)
+#  define SLO_TYPE_AT(Idx, Pack) __type_pack_element<Idx, Pack>
+#define SLO_HAS_TYPE_PACK_INDEXING 0
+#else
+#define SLO_HAS_TYPE_PACK_INDEXING 0
+# define SLO_TYPE_AT(Idx, Pack) slo::util::type_at<Idx, slo::util::TypeList<Pack>>
+#endif
+
+template <typename...>
+union UnionType {};
+
+namespace indexing {
+namespace detail {
+
+template <template <typename...> class, typename, typename...>
+struct Tree;
+
+template <template <typename...> class Node, std::size_t... I, typename T>
+struct Tree<Node, std::index_sequence<I...>, T> {
+  using type = Node<T>;
+};
+
+template <template <typename...> class Node, typename... T>
+struct Tree<Node, std::index_sequence<>, Node<T...>> {
+  using type = Node<T...>;
+};
+
+template <template <typename...> class Node, std::size_t... I, typename... T>
+  requires(sizeof...(T) > 1 && sizeof...(T) % 2 == 0)
+struct Tree<Node, std::index_sequence<I...>, T...> {
+  using type = Tree<Node,
+                    std::make_index_sequence<sizeof...(T) / 4>,
+                    Node<SLO_TYPE_AT(2 * I, T...), SLO_TYPE_AT(2 * I + 1, T...)>...>::type;
+};
+
+template <template <typename...> class Node, std::size_t... I, typename... T>
+  requires(sizeof...(T) > 1 && sizeof...(T) % 2 != 0)
+struct Tree<Node, std::index_sequence<I...>, T...> {
+  using type = Tree<Node,
+                    std::make_index_sequence<(sizeof...(T) + 2) / 4>,
+                    Node<SLO_TYPE_AT(2 * I, T...), SLO_TYPE_AT(2 * I + 1, T...)>...,
+                    SLO_TYPE_AT(sizeof...(T) - 1, T...)>::type;
+};
+
+}  // namespace detail
+
+template <template <typename...> class Node, typename... Ts>
+using to_cbt = detail::Tree<Node, std::make_index_sequence<sizeof...(Ts) / 2>, Ts...>::type;
+}  // namespace indexing
+
+namespace recursive {
+template <typename... Ts>
+struct TypeList;
+
+namespace detail {
+template <template <typename...> class, typename, typename>
+struct ToCBTImpl;
+
+template <template <typename...> class Node, typename T>
+struct ToCBTImpl<Node, TypeList<T>, TypeList<>> {
+  using type = Node<T>;
+};
+
+template <template <typename...> class Node, typename T, typename U>
+struct ToCBTImpl<Node, TypeList<>, TypeList<Node<T, U>>> {
+  using type = Node<T, U>;
+};
+
+template <template <typename...> class Node, typename... Out>
+struct ToCBTImpl<Node, TypeList<>, TypeList<Out...>> {
+  using type = ToCBTImpl<Node, TypeList<Out...>, TypeList<>>::type;
+};
+
+template <template <typename...> class Node, typename T, typename... Out>
+struct ToCBTImpl<Node, TypeList<T>, TypeList<Out...>> {
+  using type = ToCBTImpl<Node, TypeList<Out..., T>, TypeList<>>::type;
+};
+
+template <template <typename...> class Node, typename T1, typename T2, typename... In, typename... Out>
+struct ToCBTImpl<Node, TypeList<T1, T2, In...>, TypeList<Out...>> {
+  using type = ToCBTImpl<Node, TypeList<In...>, TypeList<Out..., Node<T1, T2>>>::type;
+};
+}  // namespace detail
+
+template <template <typename...> class Node, typename... Ts>
+using to_cbt = typename detail::ToCBTImpl<Node, TypeList<Ts...>, TypeList<>>::type;
+}  // namespace recursive
+
+template <auto>
+struct Constant {};
+
+template <typename...>
+union Node {};
+
+template <std::size_t... Idx>
+auto generate_tree(std::index_sequence<Idx...>) {
+#if defined(INDEXING)
+  using underlying = indexing::to_cbt<UnionType, Constant<Idx>...>;
+#elif defined(RECURSIVE)
+  using underlying = recursive::to_cbt<UnionType, Constant<Idx>...>;
+#else
+#  error
+#endif
+  return std::type_identity<underlying>{};
+}
+
+int main() {
+  using TestType = typename decltype(generate_tree(std::make_index_sequence<COUNT>()))::type;
+}
diff --git a/benchmark/algorithm/profiles.toml b/benchmark/algorithm/profiles.toml
new file mode 100644
index 0000000..9e4db34
--- /dev/null
+++ b/benchmark/algorithm/profiles.toml
@@ -0,0 +1,14 @@
+source = "cbt.cpp"
+standard = "c++26"
+
+[query]
+"generate_type" = "traceEvents[?name=='InstantiateFunction' && starts_with(@.args.detail, 'generate_tree')].dur"
+"total" = "traceEvents[?name=='ExecuteCompiler'].dur"
+
+[profile.Indexing]
+INDEXING = true
+COUNT = 255
+
+[profile.Recursive]
+RECURSIVE = true
+COUNT = 255
\ No newline at end of file
diff --git a/benchmark/control.cpp b/benchmark/control.cpp
new file mode 100644
index 0000000..086d94b
--- /dev/null
+++ b/benchmark/control.cpp
@@ -0,0 +1,129 @@
+// This is the gold standard to test against - a handwritten variant
+#include <concepts>
+#include <cstddef>
+#include "util.h"
+
+struct Variant {
+    union Union {
+        Constant<0> alternative_0;
+        Constant<1> alternative_1;
+        Constant<2> alternative_2;
+        Constant<3> alternative_3;
+        Constant<4> alternative_4;
+    };
+
+    Union data;
+    std::size_t index;
+
+    explicit Variant(Constant<0> obj) : data{.alternative_0 = obj}, index{0} {}
+    explicit Variant(Constant<1> obj) : data{.alternative_1 = obj}, index{1} {}
+    explicit Variant(Constant<2> obj) : data{.alternative_2 = obj}, index{2} {}
+    explicit Variant(Constant<3> obj) : data{.alternative_3 = obj}, index{3} {}
+    explicit Variant(Constant<4> obj) : data{.alternative_4 = obj}, index{4} {}
+
+    Variant& operator=(Constant<0> obj) {
+        data.alternative_0 = obj;
+        index = 0;
+        return *this;
+    }
+
+    Variant& operator=(Constant<1> obj) {
+        data.alternative_1 = obj;
+        index = 1;
+        return *this;
+    }
+
+    Variant& operator=(Constant<2> obj) {
+        data.alternative_2 = obj;
+        index = 2;
+        return *this;
+    }
+
+    Variant& operator=(Constant<3> obj) {
+        data.alternative_3 = obj;
+        index = 3;
+        return *this;
+    }
+
+    Variant& operator=(Constant<4> obj) {
+        data.alternative_4 = obj;
+        index = 4;
+        return *this;
+    }
+
+    template <typename T, typename Self>
+    decltype(auto) get(this Self&& self) {
+        if constexpr (std::same_as<T, Constant<0>>) {
+            if (self.index == 0){
+                return self.data.alternative_0;
+            }
+        } else if constexpr (std::same_as<T, Constant<1>>) {
+            if (self.index == 1){
+                return self.data.alternative_1;
+            }
+        } else if constexpr (std::same_as<T, Constant<2>>) {
+            if (self.index == 2){
+                return self.data.alternative_2;
+            }
+        } else if constexpr (std::same_as<T, Constant<3>>) {
+            if (self.index == 3){
+                return self.data.alternative_3;
+            }
+        } else if constexpr (std::same_as<T, Constant<4>>) {
+            if (self.index == 4){
+                return self.data.alternative_4;
+            }
+        }
+        throw std::exception();
+    }
+    template <std::size_t N, typename Self>
+    decltype(auto) get_n(this Self&& self) {
+        if constexpr (N == 0) {
+            if (self.index == 0){
+                return self.data.alternative_0;
+            }
+        } else if constexpr (N == 1) {
+            if (self.index == 1){
+                return self.data.alternative_1;
+            }
+        } else if constexpr (N == 2) {
+            if (self.index == 2){
+                return self.data.alternative_2;
+            }
+        } else if constexpr (N == 3) {
+            if (self.index == 3){
+                return self.data.alternative_3;
+            }
+        } else if constexpr (N == 4) {
+            if (self.index == 4){
+                return self.data.alternative_4;
+            }
+        }
+        throw std::exception();
+    }
+    template <typename F, typename Self>
+    decltype(auto) visit(this Self&& self, F visitor) {
+        switch (self.index) {
+            case 0:
+                return visitor(self.data.alternative_0);
+            case 1:
+                return visitor(self.data.alternative_1);
+            case 2:
+                return visitor(self.data.alternative_2);
+            case 3:
+                return visitor(self.data.alternative_3);
+            case 4:
+                return visitor(self.data.alternative_4);
+        }
+
+        // No visitation possible
+        std::unreachable();
+    }
+};
+
+#include <cstdio>
+int main() {
+  auto obj = Variant{constant<3>};
+  obj      = constant<2>;
+  obj.visit([]<auto V>(Constant<V>) { printf("%d\n", V); });
+}
\ No newline at end of file
diff --git a/benchmark/profiles.toml b/benchmark/profiles.toml
new file mode 100644
index 0000000..791896e
--- /dev/null
+++ b/benchmark/profiles.toml
@@ -0,0 +1,14 @@
+# source = "underlying.cpp"
+
+# [query]
+# "generate_type" = "traceEvents[?name=='InstantiateFunction' && starts_with(@.args.detail, 'generate_union')].dur"
+# "total" = "traceEvents[?name=='ExecuteCompiler'].dur"
+
+# [profile.Std]
+# STANDARD_VARIANT = true
+
+# [profile.Tree]
+# TREE = true
+
+# [profile.Recursive]
+# RECURSIVE = true
diff --git a/benchmark/type_list/get.cpp b/benchmark/type_list/get.cpp
new file mode 100644
index 0000000..bcd52e0
--- /dev/null
+++ b/benchmark/type_list/get.cpp
@@ -0,0 +1,435 @@
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <concepts>
+
+namespace recursive {
+template <std::size_t Idx, typename T, typename... Ts>
+struct GetImpl {
+  using type = typename GetImpl<Idx - 1, Ts...>::type;
+};
+
+template <typename T, typename... Ts>
+struct GetImpl<0, T, Ts...> {
+  using type = T;
+};
+
+template <std::size_t Idx, typename... Ts>
+using get = GetImpl<Idx, Ts...>::type;
+}  // namespace recursive
+
+namespace inheritance1 {
+template <std::size_t Idx, typename T>
+struct Tagged {
+  using type = T;
+};
+
+template <typename, typename...>
+struct GetHelper;
+
+template <std::size_t... Idx, typename... Ts>
+struct GetHelper<std::index_sequence<Idx...>, Ts...> : Tagged<Idx, Ts>... {};
+
+template <std::size_t Idx, typename T>
+Tagged<Idx, T> get_impl(Tagged<Idx, T>);
+
+template <std::size_t Idx, typename... Ts>
+using get = typename decltype(get_impl<Idx>(GetHelper<std::index_sequence_for<Ts...>, Ts...>{}))::type;
+}  // namespace inheritance1
+
+namespace inheritance2 {
+template <std::size_t Idx, typename T>
+struct Tagged {
+  using type = T;
+  Tagged operator()(std::integral_constant<std::size_t, Idx>);
+};
+
+template <typename, typename...>
+struct GetHelper;
+
+template <std::size_t... Idx, typename... Ts>
+struct GetHelper<std::index_sequence<Idx...>, Ts...> : Tagged<Idx, Ts>... {
+  using Tagged<Idx, Ts>::operator()...;
+};
+
+template <std::size_t Idx, typename... Ts>
+using get = decltype(GetHelper<std::index_sequence_for<Ts...>, Ts...>{}(std::integral_constant<std::size_t, Idx>{}))::type;
+}  // namespace inheritance2
+
+namespace voidptr {
+template <std::size_t N, typename = std::make_index_sequence<N>>
+struct GetImpl;
+
+template <std::size_t N, std::size_t... Skip>
+struct GetImpl<N, std::index_sequence<Skip...>> {
+  template <typename T>
+  auto operator()(decltype((void*)Skip)..., T*, ...) -> T;
+};
+
+template <std::size_t Idx, typename... Ts>
+using get = decltype(GetImpl<Idx>{}(static_cast<Ts*>(0)...));
+}  // namespace voidptr
+
+namespace ignored {
+struct Universal {
+    constexpr Universal() = default;
+    constexpr Universal(auto&&) {}
+    constexpr Universal& operator=(auto&&) { return *this; }
+};
+
+template <std::size_t N, typename = std::make_index_sequence<N>>
+struct GetImpl;
+
+template <std::size_t N, std::size_t... Skip>
+struct GetImpl<N, std::index_sequence<Skip...>> {
+    template <typename T>
+    auto operator()(decltype(Universal{Skip})..., T&&, auto&&...) -> T;
+};
+
+template <std::size_t Idx, typename... Ts>
+using get = decltype(GetImpl<Idx>{}(std::declval<Ts>()...));
+}  // namespace ignored
+
+
+namespace paging {
+template <std::size_t Idx, typename T>
+struct GetImpl;
+
+template <template <typename...> class List, typename T0, typename... Ts>
+struct GetImpl<0, List<T0, Ts...>> {
+  using type = T0;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List, typename T0, typename T1, typename... Ts>
+struct GetImpl<1, List<T0, T1, Ts...>> {
+  using type = T1;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List, typename T0, typename T1, typename T2, typename... Ts>
+struct GetImpl<2, List<T0, T1, T2, Ts...>> {
+  using type = T2;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List, typename T0, typename T1, typename T2, typename T3, typename... Ts>
+struct GetImpl<3, List<T0, T1, T2, T3, Ts...>> {
+  using type = T3;
+  using tail = List<Ts...>;
+};
+
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename... Ts>
+struct GetImpl<4, List<T0, T1, T2, T3, T4, Ts...>> {
+  using type = T4;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename... Ts>
+struct GetImpl<5, List<T0, T1, T2, T3, T4, T5, Ts...>> {
+  using type = T5;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename... Ts>
+struct GetImpl<6, List<T0, T1, T2, T3, T4, T5, T6, Ts...>> {
+  using type = T6;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename... Ts>
+struct GetImpl<7, List<T0, T1, T2, T3, T4, T5, T6, T7, Ts...>> {
+  using type = T7;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename... Ts>
+struct GetImpl<8, List<T0, T1, T2, T3, T4, T5, T6, T7, T8, Ts...>> {
+  using type = T8;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename T9,
+          typename... Ts>
+struct GetImpl<9, List<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ts...>> {
+  using type = T9;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename T9,
+          typename T10,
+          typename... Ts>
+struct GetImpl<10, List<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Ts...>> {
+  using type = T10;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename T9,
+          typename T10,
+          typename T11,
+          typename... Ts>
+struct GetImpl<11, List<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Ts...>> {
+  using type = T11;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename T9,
+          typename T10,
+          typename T11,
+          typename T12,
+          typename... Ts>
+struct GetImpl<12, List<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Ts...>> {
+  using type = T12;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename T9,
+          typename T10,
+          typename T11,
+          typename T12,
+          typename T13,
+          typename... Ts>
+struct GetImpl<13, List<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Ts...>> {
+  using type = T13;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename T9,
+          typename T10,
+          typename T11,
+          typename T12,
+          typename T13,
+          typename T14,
+          typename... Ts>
+struct GetImpl<14, List<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, Ts...>> {
+  using type = T14;
+  using tail = List<Ts...>;
+};
+
+template <template <typename...> class List,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename T9,
+          typename T10,
+          typename T11,
+          typename T12,
+          typename T13,
+          typename T14,
+          typename T15,
+          typename... Ts>
+struct GetImpl<15, List<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, Ts...>> {
+  using type = T15;
+  using tail = List<Ts...>;
+};
+
+constexpr inline std::size_t PAGE_SIZE = 16;
+
+template <std::size_t Idx, template <typename...> class List, typename... Ts>
+  requires(Idx >= PAGE_SIZE)
+struct GetImpl<Idx, List<Ts...>> {
+  using first_page = GetImpl<PAGE_SIZE - 1, List<Ts...>>;
+  using recurse    = GetImpl<Idx - PAGE_SIZE, typename first_page::tail>;
+  using type       = typename recurse::type;
+  using tail       = typename recurse::tail;
+};
+
+template <typename...>
+struct List {};
+template <std::size_t Idx, typename... Ts>
+using get = GetImpl<Idx, List<Ts...>>::type;
+}  // namespace paging
+
+
+namespace nested {
+namespace detail {
+template <std::size_t Idx, typename T>
+struct Tagged {
+  using type                         = T;
+  constexpr static std::size_t value = Idx;
+};
+
+template <std::size_t Idx, typename T>
+constexpr T get_type_impl(Tagged<Idx, T>){
+    static_assert(false, "get_type_impl not allowed in an evaluated context");
+}
+}  // namespace detail
+
+template <typename... Ts>
+struct TypeList2 {
+  template <typename = std::index_sequence_for<Ts...>>
+  struct GetHelper;
+
+  template <std::size_t... Idx>
+  struct GetHelper<std::index_sequence<Idx...>> : detail::Tagged<Idx, Ts>... {};
+
+  template <std::size_t Idx>
+  using type_at = decltype(get_type_impl<Idx>(GetHelper{}));
+};
+
+template <std::size_t Idx, typename... Ts>
+using get = typename TypeList2<Ts...>::template type_at<Idx>;
+}
+
+
+#if __has_builtin(__type_pack_element)
+namespace builtin {
+template <std::size_t Idx, typename... Ts>
+using get = __type_pack_element<Idx, Ts...>;
+}  // namespace builtin
+#endif
+
+namespace cpp26 {
+template <std::size_t Idx, typename... Ts>
+using get = Ts...[Idx];
+}  // namespace cpp26
+
+template <auto>
+struct Dummy {};
+
+template <std::size_t... Idx>
+void run(std::index_sequence<Idx...>) {
+#if defined(RECURSIVE)
+  using recursive::get;
+#elif defined(INHERITANCE1)
+  using inheritance1::get;
+#elif defined(INHERITANCE2)
+  using inheritance2::get;
+#elif defined(VOIDPTR)
+  using voidptr::get;
+#elif defined(IGNORED)
+  using ignored::get;
+#elif defined(NESTED)
+  using nested::get;
+#elif defined(PAGING)
+  using paging::get;
+#elif defined(BUILTIN)
+#  if !__has_builtin(__type_pack_element)
+#    error "Your compiler does not have a pack indexing builtin"
+#  endif
+  using builtin::get;
+#elif defined(CPP26)
+// #  if __cpp_pack_indexing < 202311L
+// #    error "Your compiler does not implement C++26 pack indexing"
+// #  endif
+  using cpp26::get;
+#else
+#  error "Define one of RECURSIVE, INHERITANCE1, INHERITANCE2, VOIDPTR, IGNORED, NESTED, PAGING, BUILTIN or CPP26."
+#endif
+  static_assert((std::same_as<get<Idx, Dummy<Idx>...>, Dummy<Idx>> && ...));
+}
+
+#ifndef COUNT
+#  define COUNT 10
+#endif
+
+int main() {
+  run(std::make_index_sequence<COUNT>{});
+}
\ No newline at end of file
diff --git a/benchmark/type_list/get_unique.cpp b/benchmark/type_list/get_unique.cpp
new file mode 100644
index 0000000..2590d48
--- /dev/null
+++ b/benchmark/type_list/get_unique.cpp
@@ -0,0 +1,238 @@
+#include <concepts>
+#include <utility>
+
+template <typename... Ts>
+struct TypeList {
+  static constexpr std::size_t size = sizeof...(Ts);
+};
+
+namespace fold {
+
+template <typename T, typename List, typename = std::make_index_sequence<List::size>>
+struct type_index;
+
+template <typename T, typename... Ts, std::size_t... Idx>
+struct type_index<T, TypeList<Ts...>, std::index_sequence<Idx...>> {
+  constexpr static std::size_t occurrences = (std::same_as<T, Ts> + ... + 0);
+  constexpr static std::size_t value =
+      (occurrences != 1) ? sizeof...(Ts) : ((Idx * static_cast<std::size_t>(std::same_as<T, Ts>)) + ... + 0);
+};
+
+template <typename T, typename... Ts>
+constexpr std::size_t index = type_index<T, TypeList<Ts...>>::value;
+}  // namespace fold
+
+namespace inheritance {
+template <typename T>
+struct Wrap {};
+
+template <std::size_t I, typename T>
+struct Indexed : Wrap<T> {};
+
+template <typename T, typename = std::make_index_sequence<T::size>>
+struct UniqueHelper;
+
+template <typename... Ts, std::size_t... Idx>
+struct UniqueHelper<TypeList<Ts...>, std::index_sequence<Idx...>> : Indexed<Idx, Ts>... {};
+
+template <typename T, typename... Ts>
+static constexpr bool occurs_once = std::is_convertible_v<UniqueHelper<TypeList<Ts...>>, Wrap<T>>;
+
+template <typename T, typename... Ts>
+consteval std::size_t get_type_index() {
+  std::size_t index = 0;
+  (void)((!std::same_as<T, Ts> ? ++index, false : true) || ...);
+  return index;
+}
+
+template <typename, typename... Ts>
+inline constexpr std::size_t index = sizeof...(Ts);
+
+template <typename T, typename... Ts>
+  requires occurs_once<T, Ts...>
+inline constexpr std::size_t index<T, Ts...> = get_type_index<T, Ts...>();
+}  // namespace inheritance
+
+namespace array {
+
+template <typename T, typename... Ts>
+constexpr std::size_t get_index() {
+  constexpr bool matches[] = {std::same_as<T, Ts>...};
+  std::size_t result       = sizeof...(Ts);
+
+  for (std::size_t idx = 0; idx < sizeof...(Ts); ++idx) {
+    if (matches[idx]) {
+      if (result != sizeof...(Ts)) {
+        return sizeof...(Ts);
+      }
+      result = idx;
+    }
+  }
+  return result;
+}
+
+template <typename T, typename... Ts>
+inline constexpr std::size_t index = get_index<T, Ts...>();
+}  // namespace array
+
+namespace hash {
+template <typename T>
+constexpr auto hash_type() {
+#if defined(_MSC_VER)
+  return __FUNCSIG__;
+#else
+  return __PRETTY_FUNCTION__;
+#endif
+}
+
+template <std::size_t N, typename U>
+constexpr std::size_t get_index(U needle, U const (&haystack)[N]) {
+  std::size_t result = N;
+  for (std::size_t idx = 0; idx < N; ++idx) {
+    if (needle == haystack[idx]) {
+      if (result != N) {
+        // ambiguous
+        return N;
+      }
+      result = idx;
+    }
+  }
+  return result;
+}
+
+template <typename T, typename... Ts>
+inline constexpr std::size_t index = get_index(hash_type<T>, {hash_type<Ts>...});
+}  // namespace hash
+
+namespace inheritance2 {
+namespace detail {
+template <std::size_t Idx, typename T>
+struct Tagged {
+  using type                         = T;
+  constexpr static std::size_t value = Idx;
+};
+
+template <typename, typename...>
+struct GetHelper;
+template <typename... T>
+constexpr inline bool dependent_false = false;
+template <std::size_t... Idx, typename... Ts>
+struct GetHelper<std::index_sequence<Idx...>, Ts...> : Tagged<Idx, Ts>... {};
+
+template <typename T, std::size_t Idx>
+Tagged<Idx, T> rget_impl(Tagged<Idx, T>){
+    static_assert(false, "get_index_impl not allowed in an evaluated context");
+}
+}  // namespace detail
+
+template <typename T, typename... Ts>
+concept occurs_once =
+    requires(detail::GetHelper<std::index_sequence_for<Ts...>, Ts...> obj) { detail::rget_impl<T>(obj); };
+
+template <typename T, typename... Ts>
+constexpr inline std::size_t index = sizeof...(Ts);
+
+template <typename T, typename... Ts>
+  requires occurs_once<T, Ts...>
+constexpr inline std::size_t index<T, Ts...> =
+    decltype(detail::rget_impl<T>(detail::GetHelper<std::index_sequence_for<Ts...>, Ts...>{}))::value;
+}  // namespace inheritance2
+
+namespace inheritance3 {
+template <typename T>
+struct Wrap {};
+
+template <std::size_t I, typename T>
+struct Indexed : Wrap<T> {
+  static constexpr std::size_t value = I;
+};
+
+template <typename T, typename = std::make_index_sequence<T::size>>
+struct UniqueHelper;
+
+template <typename... Ts, std::size_t... Idx>
+struct UniqueHelper<TypeList<Ts...>, std::index_sequence<Idx...>> : Indexed<Idx, Ts>... {};
+
+template <typename T, typename... Ts>
+concept occurs_once = requires(UniqueHelper<TypeList<Ts...>> obj) { static_cast<Wrap<T>>(obj); };
+
+template <typename T, std::size_t Idx>
+Indexed<Idx, T> get_index_impl(Indexed<Idx, T>);
+
+template <typename, typename... Ts>
+inline constexpr std::size_t index = sizeof...(Ts);
+
+template <typename T, typename... Ts>
+  requires occurs_once<T, Ts...>
+inline constexpr std::size_t index<T, Ts...> = decltype(get_index_impl<T>(UniqueHelper<TypeList<Ts...>>{}))::value;
+
+}  // namespace inheritance3
+
+namespace nested {
+  namespace detail {
+template <std::size_t Idx, typename T>
+struct Tagged {
+  using type                         = T;
+  constexpr static std::size_t value = Idx;
+};
+
+template <typename T, std::size_t Idx>
+constexpr Tagged<Idx, T> get_index_impl(Tagged<Idx, T>){
+    static_assert(false, "get_index_impl not allowed in an evaluated context");
+}
+}  // namespace detail
+
+template <typename... Ts>
+struct TypeList2 {
+  template <typename = std::index_sequence_for<Ts...>>
+  struct GetHelper;
+
+  template <std::size_t... Idx>
+  struct GetHelper<std::index_sequence<Idx...>> : detail::Tagged<Idx, Ts>... {};
+
+  template <typename T>
+  constexpr static std::size_t index_of = sizeof...(Ts);
+
+  template <typename T>
+    requires requires(GetHelper<> obj) { detail::get_index_impl<T>(obj); }
+  constexpr static std::size_t index_of<T> = decltype(detail::get_index_impl<T>(GetHelper{}))::value;
+};
+
+template <typename T, typename... Ts>
+constexpr inline std::size_t index = TypeList2<Ts...>::template index_of<T>;
+}
+
+template <auto>
+struct Dummy {};
+
+template <std::size_t... Idx>
+void run(std::index_sequence<Idx...>) {
+#if defined(INHERITANCE)
+  using inheritance::index;
+#elif defined(INHERITANCE2)
+  using inheritance2::index;
+#elif defined(INHERITANCE3)
+  using inheritance3::index;
+#elif defined(NESTED)
+  using nested::index;
+#elif defined(FOLD)
+  using fold::index;
+#elif defined(ARRAY)
+  using array::index;
+#elif defined(HASH)
+  using hash::index;
+#else
+#  error "Define either INHERITANCE, INHERITANCE2, INHERITANCE3, NESTED, FOLD, ARRAY or HASH."
+#endif
+  static_assert(index<int, Dummy<Idx>...> == sizeof...(Idx));
+  static_assert(((index<Dummy<Idx>, Dummy<Idx>...> == Idx) && ...));
+  static_assert(index<float, float, Dummy<Idx>..., float> == sizeof...(Idx) + 2);
+}
+
+#ifndef COUNT
+#  define COUNT 10
+#endif
+
+int main() {
+  run(std::make_index_sequence<COUNT>{});
+}
\ No newline at end of file
diff --git a/benchmark/type_list/profiles.toml b/benchmark/type_list/profiles.toml
new file mode 100644
index 0000000..49c6885
--- /dev/null
+++ b/benchmark/type_list/profiles.toml
@@ -0,0 +1,76 @@
+# # source = "get_unique.cpp"
+# standard = "c++26"
+# # options  = ["-O2"]
+
+# # [query]
+# # "generate_type" = "traceEvents[?name=='InstantiateFunction' && starts_with(@.args.detail, 'run')].dur"
+# # "total" = "traceEvents[?name=='ExecuteCompiler'].dur"
+
+# # [profile.Inheritance]
+# # INHERITANCE = true
+# # COUNT = 200
+
+# # [profile.Inheritance2]
+# # INHERITANCE2 = true
+# # COUNT = 200
+
+# # [profile.Inheritance3]
+# # INHERITANCE3 = true
+# # COUNT = 200
+
+# # [profile.Nested]
+# # NESTED = true
+# # COUNT = 200
+
+# # [profile.Array]
+# # ARRAY = true
+# # COUNT = 200
+
+# # [profile.Fold]
+# # FOLD = true
+# # COUNT = 200
+
+# # [profile.Hash]
+# # HASH = true
+# # COUNT = 200
+
+# # source = "get.cpp"
+# [query]
+# # "generate_type" = "traceEvents[?name=='InstantiateFunction' && starts_with(@.args.detail, 'run')].dur"
+# "total" = "traceEvents[?name=='ExecuteCompiler'].dur"
+
+# [profile.Recursive]
+# RECURSIVE = true
+# COUNT = 200
+
+# [profile.Inheritance]
+# INHERITANCE1 = true
+# COUNT = 200
+
+# [profile.Inheritance2]
+# INHERITANCE2 = true
+# COUNT = 200
+
+# [profile.Nested]
+# BUILTIN = true
+# COUNT = 200
+
+# [profile.Voidptr]
+# VOIDPTR = true
+# COUNT = 200
+
+# [profile.Ignored]
+# IGNORED = true
+# COUNT = 200
+
+# [profile.Paging]
+# PAGING = true
+# COUNT = 200
+
+# [profile.Builtin]
+# BUILTIN = true
+# COUNT = 200
+
+# [profile.CPP26]
+# CPP26 = true
+# COUNT = 200
\ No newline at end of file
diff --git a/benchmark/underlying.cpp b/benchmark/underlying.cpp
new file mode 100644
index 0000000..3a30e98
--- /dev/null
+++ b/benchmark/underlying.cpp
@@ -0,0 +1,55 @@
+#include <type_traits>
+#include <utility>
+#include <slo/util/list.h>
+
+#if defined(TREE) or defined(RECURSIVE)
+#  include <slo/variant.h>
+#else
+#  include <variant>
+#endif
+
+template <auto>
+struct Constant {};
+
+template <std::size_t... Idx>
+auto generate_union(std::index_sequence<Idx...>) {
+#if defined(TREE)
+  using underlying = slo::util::to_cbt<slo::impl::TreeUnion, Constant<Idx>...>;
+#elif defined(RECURSIVE)
+  using underlying = slo::impl::RecursiveUnion<Constant<Idx>...>;
+#else
+  using underlying = std::variant<Constant<Idx>...>;
+#endif
+  return std::type_identity<underlying>{};
+}
+
+template <typename T>
+auto get_size() {
+#if defined(TREE)
+  return T::size;
+#else
+  return 0;
+#endif
+}
+
+template <typename T, std::size_t... Idx>
+auto generate_getters(std::index_sequence<Idx...>) {
+  (
+      [] {
+        auto obj = T{std::in_place_index<Idx>};
+#if defined(TREE) || defined(RECURSIVE)
+        using slo::get;
+#else
+        using std::get;
+#endif
+        (void)get<Idx>(obj);
+      }(),
+      ...);
+}
+
+int main() {
+  using TestType = typename decltype(generate_union(std::make_index_sequence<200>()))::type;
+  //(void)get_size<TestType>();
+
+  generate_getters<TestType>(std::make_index_sequence<200>());
+}
diff --git a/benchmark/util.h b/benchmark/util.h
new file mode 100644
index 0000000..97a9b15
--- /dev/null
+++ b/benchmark/util.h
@@ -0,0 +1,9 @@
+#pragma once
+
+template <auto V>
+struct Constant {
+  static constexpr auto value = V;
+};
+
+template <auto V>
+inline constexpr Constant<V> constant;
\ No newline at end of file
diff --git a/benchmark/visit/macro_visit.cpp b/benchmark/visit/macro_visit.cpp
new file mode 100644
index 0000000..a280b55
--- /dev/null
+++ b/benchmark/visit/macro_visit.cpp
@@ -0,0 +1,18 @@
+#include <cstddef>
+
+#if TIERED == 1
+#include "strategy.h"
+#else
+#include "simple.h"
+#endif
+
+struct Test {
+  constexpr static std::size_t size = TEST_SIZE;
+  std::size_t tag                   = 0;
+  [[nodiscard]] std::size_t index() const noexcept { return tag; }
+};
+
+int main(int argc, char** argv) {
+  auto obj = Test(argc);
+  visit(obj);
+}
\ No newline at end of file
diff --git a/benchmark/visit/profiles.toml b/benchmark/visit/profiles.toml
new file mode 100644
index 0000000..52a43a6
--- /dev/null
+++ b/benchmark/visit/profiles.toml
@@ -0,0 +1,16 @@
+source   = "macro_visit.cpp"
+standard = "c++2b"
+options  = ["-O2"]
+
+[query]
+# "generate_type" = "traceEvents[?name=='InstantiateFunction' && starts_with(@.args.detail, 'generate_union')].dur"
+total = "traceEvents[?name=='ExecuteCompiler'].dur"
+[profile.simple]
+TEST_SIZE.min = 0
+TEST_SIZE.max = 255
+TIERED = false
+
+[profile.tiered]
+TEST_SIZE.min = 0
+TEST_SIZE.max = 255
+TIERED = true
\ No newline at end of file
diff --git a/benchmark/visit/simple.h b/benchmark/visit/simple.h
new file mode 100644
index 0000000..95d8ee0
--- /dev/null
+++ b/benchmark/visit/simple.h
@@ -0,0 +1,27 @@
+#pragma once
+#include <utility>
+#include <type_traits>
+#include <slo/util/stamp.h>
+
+template <std::size_t Idx>
+int h() {
+  return Idx;
+}
+
+#define SLO_VISIT_CASE(Idx)                               \
+  case Idx:                                               \
+    if constexpr ((Idx) < std::remove_cvref_t<V>::size) { \
+      return h<Idx>();                                    \
+    }                                                     \
+    std::unreachable();
+
+#define SLO_VISIT_STAMP(stamper, n) \
+  switch (variant.index()) {        \
+    stamper(0, SLO_VISIT_CASE);     \
+    default: std::unreachable();    \
+  }
+
+template <typename V>
+constexpr decltype(auto) visit(V&& variant) {
+  SLO_STAMP(256, SLO_VISIT_STAMP);
+}
\ No newline at end of file
diff --git a/benchmark/visit/strategy.h b/benchmark/visit/strategy.h
new file mode 100644
index 0000000..812566a
--- /dev/null
+++ b/benchmark/visit/strategy.h
@@ -0,0 +1,81 @@
+#pragma once
+#include <utility>
+#include <type_traits>
+#include <slo/util/stamp.h>
+
+template <std::size_t Idx>
+int h() {
+  return Idx;
+}
+
+#define SLO_VISIT_CASE(Idx)                               \
+  case Idx:                                               \
+    if constexpr ((Idx) < std::remove_cvref_t<V>::size) { \
+      return h<Idx>();                                    \
+    }                                                     \
+    std::unreachable();
+
+#define SLO_VISIT_STAMP(stamper, n) \
+  switch (variant.index()) {        \
+    stamper(0, SLO_VISIT_CASE);     \
+    default: std::unreachable();    \
+  }
+
+template <int I>
+struct VisitStrategy;
+
+template <>
+struct VisitStrategy<-1> {
+  // TODO dispatch table as fallback for ridiculously large variants
+};
+
+template <>
+struct VisitStrategy<0> {  // 4^0 potential states
+  template <typename>
+  static constexpr decltype(auto) visit() {
+    return -1;
+  }
+};
+
+template <>
+struct VisitStrategy<1> {  // 4^1 potential states
+  template <typename V>
+  static constexpr decltype(auto) visit(V&& variant) {
+    SLO_STAMP(4, SLO_VISIT_STAMP);
+  }
+};
+
+template <>
+struct VisitStrategy<2> {  // 4^2 potential states
+  template <typename V>
+  static constexpr decltype(auto) visit(V&& variant) {
+    SLO_STAMP(16, SLO_VISIT_STAMP);
+  }
+};
+
+template <>
+struct VisitStrategy<3> {  // 4^3 potential states
+  template <typename V>
+  static constexpr decltype(auto) visit(V&& variant) {
+    SLO_STAMP(64, SLO_VISIT_STAMP);
+  }
+};
+
+template <>
+struct VisitStrategy<4> {  // 4^4 potential states
+  template <typename V>
+  static constexpr decltype(auto) visit(V&& variant) {
+    SLO_STAMP(256, SLO_VISIT_STAMP);
+  }
+};
+
+template <typename V>
+constexpr decltype(auto) visit(V&& variant) {
+  using variant_type     = std::remove_cvref_t<V>;
+  constexpr int strategy = variant_type::size <= 4     ? 1
+                           : variant_type::size <= 16  ? 2
+                           : variant_type::size <= 64  ? 3
+                           : variant_type::size <= 256 ? 4
+                                                       : -1;
+  return VisitStrategy<strategy>::visit(std::forward<V>(variant));
+}
diff --git a/cmake/warnings.cmake b/cmake/warnings.cmake
new file mode 100644
index 0000000..867c14f
--- /dev/null
+++ b/cmake/warnings.cmake
@@ -0,0 +1,100 @@
+# Build flags
+# See:
+# - https://github.com/aminya/project_options/blob/main/src/CompilerWarnings.cmake
+# - https://github.com/cpp-best-practices/cppbestpractices/blob/master/02-Use_the_Tools_Available.md
+# - https://clang.llvm.org/docs/DiagnosticsReference.html
+# - https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html
+# - https://learn.microsoft.com/en-us/cpp/build/reference/compiler-options-listed-by-category?view=msvc-170
+# - https://developers.redhat.com/blog/2018/03/21/compiler-and-linker-flags-gcc
+
+function(enable_warnings _TARGET)
+  if("${MSVC_WARNINGS}" STREQUAL "")
+    set(MSVC_WARNINGS
+      /W4 # Baseline reasonable warnings
+      /w14242 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
+      /w14254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
+      /w14263 # 'function': member function does not override any base class virtual member function
+      /w14265 # 'classname': class has virtual functions, but destructor is not virtual instances of this class may not
+
+      # be destructed correctly
+      /w14287 # 'operator': unsigned/negative constant mismatch
+      /we4289 # nonstandard extension used: 'variable': loop control variable declared in the for-loop is used outside
+
+      # the for-loop scope
+      /w14296 # 'operator': expression is always 'boolean_value'
+      /w14311 # 'variable': pointer truncation from 'type1' to 'type2'
+      /w14545 # expression before comma evaluates to a function which is missing an argument list
+      /w14546 # function call before comma missing argument list
+      /w14547 # 'operator': operator before comma has no effect; expected operator with side-effect
+      /w14549 # 'operator': operator before comma has no effect; did you intend 'operator'?
+      /w14555 # expression has no effect; expected expression with side- effect
+      /w14619 # pragma warning: there is no warning number 'number'
+      /w14640 # Enable warning on thread un-safe static member initialization
+      /w14826 # Conversion from 'type1' to 'type_2' is sign-extended. This may cause unexpected runtime behavior.
+      /w14905 # wide string literal cast to 'LPSTR'
+      /w14906 # string literal cast to 'LPWSTR'
+      /w14928 # illegal copy-initialization; more than one user-defined conversion has been implicitly applied
+      /permissive- # standards conformance mode for MSVC compiler.
+    )
+  endif()
+
+  set(COMMON_WARNINGS
+    -Wall
+    -Wextra # reasonable and standard
+    -Wextra-semi # Warn about semicolon after in-class function definition.
+    -Wshadow # warn the user if a variable declaration shadows one from a parent context
+    -Wnon-virtual-dtor # warn the user if a class with virtual functions has a non-virtual destructor. This helps
+
+    # catch hard to track down memory errors
+    -Wold-style-cast # warn for c-style casts
+    -Wcast-align # warn for potential performance problem casts
+    -Wunused # warn on anything being unused
+    -Woverloaded-virtual # warn if you overload (not override) a virtual function
+    -Wpedantic # warn if non-standard C++ is used
+    -Wconversion # warn on type conversions that may lose data
+    -Wsign-conversion # warn on sign conversions
+    -Wnull-dereference # warn if a null dereference is detected
+    -Wdouble-promotion # warn if float is implicit promoted to double
+    -Wformat=2 # warn on security issues around functions that format output (ie printf)
+    -Wimplicit-fallthrough # warn on statements that fallthrough without an explicit annotation
+  )
+
+  if("${CLANG_WARNINGS}" STREQUAL "")
+    set(CLANG_WARNINGS
+      ${COMMON_WARNINGS}
+      -Wno-dollar-in-identifier-extension
+      -Wno-unknown-attributes # ignore unknown attribute warning
+    )
+  endif()
+
+  if("${GCC_WARNINGS}" STREQUAL "")
+    set(GCC_WARNINGS
+      ${COMMON_WARNINGS}
+      -Wmisleading-indentation # warn if indentation implies blocks where blocks do not exist
+      -Wduplicated-cond # warn if if / else chain has duplicated conditions
+      -Wduplicated-branches # warn if if / else branches have duplicated code
+      -Wlogical-op # warn about logical operations being used where bitwise were probably wanted
+      -Wuseless-cast # warn if you perform a cast to the same type
+      -Wno-attributes # ignore unknown attribute warning
+      # -fconcepts-diagnostics-depth=2
+    )
+  endif()
+
+  if(MSVC)
+    message(STATUS "Setting warning flags for MSVC")
+    set(PROJECT_WARNINGS ${MSVC_WARNINGS})
+
+  elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+    message(STATUS "Setting warning flags for clang")
+    set(PROJECT_WARNINGS ${CLANG_WARNINGS})
+
+  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    message(STATUS "Setting warning flags for GCC")
+    set(PROJECT_WARNINGS ${GCC_WARNINGS})
+
+  else()
+    message(AUTHOR_WARNING "No compiler warnings set for CXX compiler: '${CMAKE_CXX_COMPILER_ID}'")
+  endif()
+
+  target_compile_options(${_TARGET} PUBLIC ${PROJECT_WARNINGS})
+endfunction()
diff --git a/conanfile.py b/conanfile.py
new file mode 100644
index 0000000..0bc7d9d
--- /dev/null
+++ b/conanfile.py
@@ -0,0 +1,65 @@
+from conan import ConanFile
+from conan.tools.cmake import CMake, cmake_layout
+from conan.tools.files import copy
+from conan.tools.build import check_min_cppstd
+
+
+class SloRecipe(ConanFile):
+    name = "slo"
+    version = "0.1"
+    package_type = "header-library"
+
+    # Optional metadata
+    license = "MIT"
+    author = "Tsche che@palliate.io"
+    url = "<Package recipe repository url here, for issues about the package>"
+    description = "<Description of slo package here>"
+    topics = ("<Put some tag here>", "<here>", "<and here>")
+
+    # Binary configuration
+    settings = "os", "compiler", "build_type", "arch"
+    options = {
+        "benchmark": [True, False],
+        "sanitizers": [True, False],
+        "coverage": [True, False],
+    }
+    default_options = {"benchmark": False, "sanitizers": False,
+                       "coverage": False}
+    generators = "CMakeToolchain", "CMakeDeps"
+
+    exports_sources = "CMakeLists.txt", "include/*"
+
+    def validate(self):
+        if self.settings.compiler.get_safe("cppstd"):
+            check_min_cppstd(self, "23")
+
+    def requirements(self):
+        if self.options.benchmark:
+            self.requires("benchmark/1.8.3")
+
+        self.test_requires("gtest/1.14.0")
+
+    def layout(self):
+        cmake_layout(self)
+
+    def build(self):
+        if not self.conf.get("tools.build:skip_test", default=False):
+            cmake = CMake(self)
+            cmake.configure(
+                variables={
+                    "ENABLE_BENCHMARK": self.options.benchmark,
+                    "ENABLE_SANITIZERS": self.options.sanitizers,
+                    "ENABLE_COVERAGE": self.options.coverage,
+                }
+            )
+            cmake.build()
+
+    def package(self):
+        copy(self, "*.h", self.source_folder, self.package_folder)
+
+    def package_info(self):
+        self.cpp_info.bindirs = []
+        self.cpp_info.libdirs = []
+
+    def package_id(self):
+        self.info.clear()
diff --git a/include/slo/impl/concepts.h b/include/slo/impl/concepts.h
new file mode 100644
index 0000000..979d18d
--- /dev/null
+++ b/include/slo/impl/concepts.h
@@ -0,0 +1,26 @@
+#pragma once
+#include <concepts>
+#include <utility>
+
+namespace slo::impl {
+
+template <typename T>
+concept has_alternatives = requires { typename T::alternatives; };
+
+template <typename T>
+concept has_get = requires(T obj) { obj.template get<0>(); };
+
+template <typename T>
+concept has_index = requires(T const& obj) {
+  { obj.index() } -> std::convertible_to<std::size_t>;
+};
+
+template <typename T>
+concept has_unwrap = requires(T obj) {
+  { obj.unwrap() } -> std::same_as<typename T::type&>;
+  { std::as_const(obj).unwrap() } -> std::same_as<typename T::type const&>;
+  { std::move(obj).unwrap() } -> std::same_as<typename T::type&&>;
+  { std::move(std::as_const(obj)).unwrap() } -> std::same_as<typename T::type const&&>;
+};
+
+}
\ No newline at end of file
diff --git a/include/slo/impl/exception.h b/include/slo/impl/exception.h
new file mode 100644
index 0000000..44822a7
--- /dev/null
+++ b/include/slo/impl/exception.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <exception>
+namespace slo {
+
+namespace impl {
+[[noreturn]] void throw_bad_variant_access(bool);
+}
+
+class bad_variant_access : public std::exception {
+  friend void impl::throw_bad_variant_access(bool);
+  char const* reason = "bad variant access";
+  explicit bad_variant_access(const char* message) noexcept : reason(message) {}
+
+public:
+  bad_variant_access() noexcept = default;
+  [[nodiscard]] const char* what() const noexcept override { return reason; }
+};
+namespace impl {
+[[noreturn]] inline void throw_bad_variant_access(bool valueless) {
+#if __cpp_exceptions
+  if (valueless) {
+    throw slo::bad_variant_access("variant is valueless");
+  }
+  throw slo::bad_variant_access("wrong index for variant");
+#else
+  std::abort();
+#endif
+}
+}  // namespace impl
+}  // namespace slo
\ No newline at end of file
diff --git a/include/slo/impl/feature.h b/include/slo/impl/feature.h
new file mode 100644
index 0000000..6fdc678
--- /dev/null
+++ b/include/slo/impl/feature.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#define USING($operation) ((1 $operation 1) != 0)
+
+#define ON  +
+#define OFF -
+
+/**
+ * @def SLO_HIDE_IN_PADDING
+ * @brief SLO_HIDE_IN_PADDING only affects variants created from an existing union.
+ *        If this is enabled the union and the tag may overlap, or in other words
+ *        the tag may be hidden in padding. This might reduce overall padding and
+ *        afffect size of the variant type.
+ *
+ * @attention You might need to force your union to not be a standard-layout type. To do this
+ *            simply define a private non-static data member of any type (ie `char`).
+ *
+ * @warning Certain operations (such as move construction) _might_ clobber the tail padding
+ *          and overwrite the tag. This only matters if an alternative constructor threw,
+ *          as this might put the variant in a seemingly valid state while it's invalid.
+ *
+ */
+#ifndef SLO_HIDE_IN_PADDING
+#  define SLO_HIDE_IN_PADDING OFF
+#endif
+
+/**
+ * @def SLO_TREE_THRESHOLD
+ * @brief SLO_TREE_THRESHOLD controls at which amount of alternative types the strategy
+ *        for the generated underlying union is being switched to a tree-like structure.
+ *
+ */
+#ifndef SLO_TREE_THRESHOLD
+#  define SLO_TREE_THRESHOLD 42
+#endif
+
+/**
+ * @def SLO_MACRO_VISIT
+ * @brief SLO_MACRO_VISIT controls whether macro-generated switches or fold expressions
+ *        are being used to facilitate visitation. Turn this `ON` if the gcc/clang fold
+ *        expression does not work with your target compiler.
+ *
+ * @attention For MSVC the default behavior is to use macro visitation, since MSVC does not
+ *            collapse repeated branches into jump tables unless being spoonfed an actual
+ *            switch.
+ * 
+ */
+#ifndef SLO_MACRO_VISIT
+#  if defined(_MSC_VER)
+#    define SLO_MACRO_VISIT ON
+#  else
+#    define SLO_MACRO_VISIT OFF
+#  endif
+#endif
\ No newline at end of file
diff --git a/include/slo/impl/storage/inverted.h b/include/slo/impl/storage/inverted.h
new file mode 100644
index 0000000..7a1de67
--- /dev/null
+++ b/include/slo/impl/storage/inverted.h
@@ -0,0 +1,126 @@
+#pragma once
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <memory>
+
+#include <slo/impl/feature.h>
+#include <slo/impl/union/recursive.h>
+#include <slo/impl/union/tree.h>
+#include <slo/util/list.h>
+#include <slo/util/utility.h>
+
+namespace slo {
+template <typename F, typename... Vs>
+constexpr decltype(auto) visit(F&& visitor, Vs&&... variant);
+}
+
+namespace slo::impl {
+template <auto Idx, typename ValueType>
+struct TaggedWrapper {
+  using type = ValueType;
+
+  template <typename... Args>
+  constexpr explicit TaggedWrapper(Args&&... args) : tag{Idx}
+                                                   , storage{std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const noexcept { return tag; }
+
+  [[nodiscard]] constexpr ValueType& unwrap() & { return storage; }
+  [[nodiscard]] constexpr ValueType const& unwrap() const& { return storage; }
+  [[nodiscard]] constexpr ValueType&& unwrap() && { return std::move(storage); }
+  [[nodiscard]] constexpr ValueType const&& unwrap() const&& { return std::move(storage); }
+
+  decltype(Idx) tag;
+  ValueType storage;
+};
+
+/**
+ * @brief Storage for an inverted variant. This attempts to reduce padding by hiding the
+ *        tag in the alternatives themselves. Outside of constant evaluated context the
+ *        current tag can be retrieved through an inactive member, since all alternatives
+ *        share the same common initial sequence.
+ *
+ *        Due to [expr.const]/5.10 reading the tag through an inactive member is not possible.
+ *        To work around that C++26 `std::is_within_lifetime` or clang/gcc's intrinsic
+ *        `__builtin_constant_p` can be used to recursively determine which member is active.
+ *        The tag can then be read from the active member, which in turn allows visitation of
+ *        the variant.
+ *
+ * @warning Requires C++26 `std::is_within_lifetime` or clang/gcc `__builtin_constant_p` intrinsic
+ *          to work in constant evaluated context.
+ *
+ * @warning [class.mem]/26 mandates standard-layout unions for this technique, consequently it will
+ *          only work if all alternatives are standard-layout types.
+ *
+ * @tparam Ts... Alternative types. Must be standard layout.
+ */
+template <template <typename...> class Generator, typename... Ts>
+union InvertedStorage {
+  // inverted variant
+  static_assert((std::is_standard_layout_v<Ts> && ...),
+                "[class.mem]/26 mandates standard-layout unions for this technique. "
+                "This means only standard-layout alternatives can be used.");
+
+  using alternatives               = util::TypeList<Ts...>;
+  using index_type                 = alternatives::index_type;
+  constexpr static index_type npos = static_cast<index_type>(~0U);
+
+  template <std::size_t... Is>
+  static constexpr auto generate_union(std::index_sequence<Is...>)
+      -> Generator<TaggedWrapper<static_cast<index_type>(Is), Ts>...>;
+
+  using union_type = decltype(generate_union(std::index_sequence_for<Ts...>()));
+
+  TaggedWrapper<npos, util::error_type> dummy;
+  struct Container {
+    union_type value;
+  } storage;
+
+public:
+  template <std::size_t Idx, typename... Args>
+  constexpr explicit InvertedStorage(std::in_place_index_t<Idx> idx, Args&&... args)
+      : storage{union_type(idx, std::forward<Args>(args)...)} {}
+
+  constexpr InvertedStorage() : dummy() {}
+  constexpr InvertedStorage(InvertedStorage const& other)            = default;
+  constexpr InvertedStorage(InvertedStorage&& other)                 = default;
+  constexpr InvertedStorage& operator=(InvertedStorage const& other) = default;
+  constexpr InvertedStorage& operator=(InvertedStorage&& other)      = default;
+
+  constexpr ~InvertedStorage()
+    requires std::is_trivially_destructible_v<union_type>
+  = default;
+  constexpr ~InvertedStorage() { reset(); }
+
+  [[nodiscard]] constexpr std::size_t index() const noexcept {
+    if consteval {
+      if (!compat::is_within_lifetime(&dummy.tag)) {
+        return storage.value.index();
+      }
+    }
+    return dummy.index();
+  }
+
+  constexpr void reset() {
+    if (index() != npos) {
+      slo::visit([](auto&& member) { std::destroy_at(std::addressof(member)); }, *this);
+      std::construct_at(&dummy);
+    }
+  }
+
+  template <std::size_t Idx, typename... Args>
+  constexpr void emplace(Args&&... args) {
+    reset();
+    std::construct_at(&storage.value, std::in_place_index<Idx>, std::forward<Args>(args)...);
+  }
+
+  template <std::size_t Idx, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    return std::forward<Self>(self).storage.value.template get<Idx>();
+  }
+
+  [[nodiscard]] constexpr bool valueless_by_exception() const noexcept { return index() == npos; }
+};
+
+}  // namespace slo::impl
diff --git a/include/slo/impl/storage/member_ptr.h b/include/slo/impl/storage/member_ptr.h
new file mode 100644
index 0000000..0c62b3a
--- /dev/null
+++ b/include/slo/impl/storage/member_ptr.h
@@ -0,0 +1,108 @@
+#pragma once
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include <slo/impl/feature.h>
+#include <slo/util/list.h>
+#include <slo/util/concepts.h>
+
+namespace slo {
+template <typename F, typename... Vs>
+constexpr decltype(auto) visit(F&& visitor, Vs&&... variant);
+}
+
+namespace slo::impl {
+namespace detail {
+template <auto>
+struct MemberPtr;
+template <typename C, typename R, R C::* Ptr>
+struct MemberPtr<Ptr> {
+  using type                    = R;
+  using class_type              = C;
+  constexpr static R C::* value = Ptr;
+};
+
+template <typename... Ptrs>
+struct StorageProxy {
+  static_assert(util::is_homogeneous<typename Ptrs::class_type...>,
+                "All member pointers must refer to subobjects of the same type.");
+
+  using alternatives = util::TypeList<typename Ptrs::type...>;
+  using union_type   = util::type_at<0, util::TypeList<typename Ptrs::class_type...>>;
+  static_assert(std::is_union_v<union_type>, "All member pointers must refer to subobjects of a union.");
+
+  using index_type                 = alternatives::index_type;
+  constexpr static index_type npos = static_cast<index_type>(~0U);
+
+private:
+// With SLO_HIDE_IN_PADDING is enabled, the tag _may_ be hidden in padding.
+// Unfortunately certain operations (such as move construction)  _may_ clobber
+// tail padding, hence we must assume the tag is lost afterwards. This shouldn't
+// be a problem since we set the tag after construction anyway.
+
+// It's possibly problematic if a constructor throws - the variant might end up with
+// an overwritten tag that suggests it is still valid.
+
+// See https://github.com/llvm/llvm-project/issues/60711
+#if USING(SLO_HIDE_IN_PADDING)
+  [[no_unique_address]]
+#endif
+  union_type storage;
+
+  index_type tag{npos};
+
+  template <std::size_t Idx>
+  constexpr static auto member = util::type_at<Idx, util::TypeList<Ptrs...>>::value;
+
+public:
+  template <std::size_t Idx, typename... Args>
+  constexpr explicit StorageProxy(std::in_place_index_t<Idx>, Args&&... args) {
+    std::construct_at(std::addressof(storage.*member<Idx>), std::forward<Args>(args)...);
+    tag = Idx;
+  }
+
+  constexpr StorageProxy(StorageProxy const& other)            = default;
+  constexpr StorageProxy(StorageProxy&& other)                 = default;
+  constexpr StorageProxy& operator=(StorageProxy const& other) = default;
+  constexpr StorageProxy& operator=(StorageProxy&& other)      = default;
+
+  constexpr StorageProxy() {}
+  constexpr ~StorageProxy()
+    requires std::is_trivially_destructible_v<union_type>
+  = default;
+  constexpr ~StorageProxy() { reset(); }
+
+  [[nodiscard]] constexpr std::size_t index() const noexcept { return tag; }
+
+  constexpr void reset() {
+    if (tag != npos) {
+      slo::visit([](auto&& obj) { std::destroy_at(std::addressof(obj)); }, *this);
+      tag = npos;
+    }
+  }
+
+  template <std::size_t Idx, typename... Args>
+  constexpr void emplace(Args&&... args) {
+    reset();
+    std::construct_at(std::addressof(storage.*member<Idx>), std::forward<Args>(args)...);
+    tag = Idx;
+  }
+
+  template <typename T, typename... Args>
+  constexpr void emplace(Args&&... args) {
+    emplace<util::index_of<T, alternatives>>(std::forward<Args>(args)...);
+  }
+
+  template <std::size_t Idx, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    return std::forward<Self>(self).storage.*member<Idx>;
+  }
+  [[nodiscard]] constexpr bool valueless_by_exception() const noexcept { return tag == npos; }
+};
+}  // namespace detail
+
+template <auto... Ptrs>
+using StorageProxy = detail::StorageProxy<detail::MemberPtr<Ptrs>...>;
+}  // namespace slo::impl
diff --git a/include/slo/impl/storage/normal.h b/include/slo/impl/storage/normal.h
new file mode 100644
index 0000000..c3e7827
--- /dev/null
+++ b/include/slo/impl/storage/normal.h
@@ -0,0 +1,79 @@
+#pragma once
+#include <cstddef>
+#include <utility>
+#include <memory>
+
+#include <slo/impl/feature.h>
+#include <slo/impl/union/recursive.h>
+#include <slo/impl/union/tree.h>
+#include <slo/util/list.h>
+#include <slo/util/utility.h>
+
+namespace slo {
+template <typename F, typename... Vs>
+constexpr decltype(auto) visit(F&& visitor, Vs&&... variant);
+}
+
+namespace slo::impl {
+/**
+ * @brief Essentially a plain discriminated union.
+ *
+ * @tparam Ts
+ */
+template <template <typename...> class Generator, typename... Ts>
+class Storage {
+  // discriminated union
+public:
+  using alternatives               = util::TypeList<Ts...>;
+  using index_type                 = alternatives::index_type;
+  constexpr static index_type npos = static_cast<index_type>(~0U);
+
+private:
+  using union_type = Generator<Ts...>;
+  union {
+    util::error_type dummy = {};
+    union_type value;
+  };
+
+  index_type tag{npos};
+
+public:
+  template <std::size_t Idx, typename... Args>
+  constexpr explicit Storage(std::in_place_index_t<Idx> idx, Args&&... args)
+      : value(idx, std::forward<Args>(args)...)
+      , tag(Idx) {}
+
+  constexpr Storage() {}
+  constexpr Storage(Storage const& other)            = default;
+  constexpr Storage(Storage&& other)                 = default;
+  constexpr Storage& operator=(Storage const& other) = default;
+  constexpr Storage& operator=(Storage&& other)      = default;
+
+  constexpr ~Storage()
+    requires std::is_trivially_destructible_v<union_type>
+  = default;
+  constexpr ~Storage() { reset(); }
+
+  [[nodiscard]] constexpr std::size_t index() const noexcept { return tag; }
+
+  constexpr void reset() {
+    if (tag != npos) {
+      slo::visit([](auto&& member) { std::destroy_at(std::addressof(member)); }, *this);
+      tag = npos;
+    }
+  }
+
+  template <std::size_t Idx, typename... Args>
+  constexpr void emplace(Args&&... args) {
+    reset();
+    std::construct_at(&value, std::in_place_index<Idx>, std::forward<Args>(args)...);
+    tag = Idx;
+  }
+
+  template <std::size_t Idx, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    return std::forward<Self>(self).value.template get<Idx>();
+  }
+  [[nodiscard]] constexpr bool valueless_by_exception() const noexcept { return tag == npos; }
+};
+}  // namespace slo::impl
\ No newline at end of file
diff --git a/include/slo/impl/union/recursive.h b/include/slo/impl/union/recursive.h
new file mode 100644
index 0000000..e92a3b4
--- /dev/null
+++ b/include/slo/impl/union/recursive.h
@@ -0,0 +1,219 @@
+#pragma once
+#include <utility>
+#include <slo/util/compat.h>
+#include <slo/impl/concepts.h>
+
+namespace slo::impl {
+template <bool Trivial, typename... Ts>
+union RecursiveUnion;
+
+template <bool Trivial>
+union RecursiveUnion<Trivial>{};
+
+template <bool Trivial, typename T>
+union RecursiveUnion<Trivial, T> {
+  T value;
+
+  constexpr RecursiveUnion(RecursiveUnion const&)            = default;
+  constexpr RecursiveUnion(RecursiveUnion&&)                 = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion const&) = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion&&)      = default;
+  constexpr ~RecursiveUnion()                                = default;
+  constexpr ~RecursiveUnion() requires(!Trivial) {}
+
+  template <typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<0>, Args&&... args) : value{std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const requires(has_index<T>) { return value.tag; }
+
+  template <std::size_t N, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    static_assert(N == 0);
+    if constexpr (has_unwrap<T>) {
+      return std::forward<Self>(self).value.unwrap();
+    } else {
+      return compat::forward_like<Self>(std::forward<Self>(self).value);
+    }
+  }
+};
+
+template <bool Trivial, typename T0, typename... Ts>
+requires(sizeof...(Ts) != 0) union RecursiveUnion<Trivial, T0, Ts...> {
+  T0 alternative_0;
+  RecursiveUnion<Trivial, Ts...> tail;
+
+  constexpr RecursiveUnion(RecursiveUnion const&)            = default;
+  constexpr RecursiveUnion(RecursiveUnion&&)                 = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion const&) = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion&&)      = default;
+  constexpr ~RecursiveUnion()                                = default;
+  constexpr ~RecursiveUnion() requires(!Trivial) {}
+
+  template <typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<0>, Args&&... args)
+      : alternative_0{std::forward<Args>(args)...} {}
+
+  template <std::size_t N, typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<N>, Args&&... args)
+      : tail{std::in_place_index_t<N - 1>{}, std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const requires(has_index<T0>) {
+    if (compat::is_within_lifetime(&alternative_0.tag)) {
+      return alternative_0.tag;
+    } else {
+      return tail.index();
+    }
+  }
+
+  template <std::size_t N, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    if constexpr (N == 0) {
+      if constexpr (has_unwrap<T0>) {
+        return std::forward<Self>(self).alternative_0.unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).alternative_0);
+      }
+    } else {
+      return std::forward<Self>(self).tail.template get<N - 1>();
+    }
+  }
+};
+
+template <bool Trivial, typename T0, typename T1, typename... Ts>
+requires(sizeof...(Ts) != 0) union RecursiveUnion<Trivial, T0, T1, Ts...> {
+  T0 alternative_0;
+  T1 alternative_1;
+  RecursiveUnion<Trivial, Ts...> tail;
+
+  constexpr RecursiveUnion(RecursiveUnion const&)            = default;
+  constexpr RecursiveUnion(RecursiveUnion&&)                 = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion const&) = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion&&)      = default;
+  constexpr ~RecursiveUnion()                                = default;
+  constexpr ~RecursiveUnion() requires(!Trivial) {}
+
+  template <typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<0>, Args&&... args)
+      : alternative_0{std::forward<Args>(args)...} {}
+
+  template <typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<1>, Args&&... args)
+      : alternative_1{std::forward<Args>(args)...} {}
+
+  template <std::size_t N, typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<N>, Args&&... args)
+      : tail{std::in_place_index_t<N - 2>{}, std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const requires(has_index<T0>&& has_index<T1>) {
+    if (compat::is_within_lifetime(&alternative_0.tag)) {
+      return alternative_0.tag;
+    } else if (compat::is_within_lifetime(&alternative_1.tag)) {
+      return alternative_1.tag;
+    } else {
+      return tail.index();
+    }
+  }
+
+  template <std::size_t N, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    if constexpr (N == 0) {
+      if constexpr (has_unwrap<T0>) {
+        return std::forward<Self>(self).alternative_0.unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).alternative_0);
+      }
+    } else if constexpr (N == 1) {
+      if constexpr (has_unwrap<T1>) {
+        return std::forward<Self>(self).alternative_1.unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).alternative_1);
+      }
+    } else {
+      return std::forward<Self>(self).tail.template get<N - 2>();
+    }
+  }
+};
+
+template <bool Trivial, typename T0, typename T1, typename T2, typename T3, typename... Ts>
+requires(sizeof...(Ts) != 0) union RecursiveUnion<Trivial, T0, T1, T2, T3, Ts...> {
+  T0 alternative_0;
+  T1 alternative_1;
+  T2 alternative_2;
+  T3 alternative_3;
+  RecursiveUnion<Trivial, Ts...> tail;
+
+  constexpr RecursiveUnion(RecursiveUnion const&)            = default;
+  constexpr RecursiveUnion(RecursiveUnion&&)                 = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion const&) = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion&&)      = default;
+  constexpr ~RecursiveUnion()                                = default;
+  constexpr ~RecursiveUnion() requires(!Trivial) {}
+
+  template <typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<0>, Args&&... args)
+      : alternative_0{std::forward<Args>(args)...} {}
+
+  template <typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<1>, Args&&... args)
+      : alternative_1{std::forward<Args>(args)...} {}
+
+  template <typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<2>, Args&&... args)
+      : alternative_2{std::forward<Args>(args)...} {}
+
+  template <typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<3>, Args&&... args)
+      : alternative_3{std::forward<Args>(args)...} {}
+
+  template <std::size_t N, typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<N>, Args&&... args)
+      : tail{std::in_place_index_t<N - 4>{}, std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const
+      requires(has_index<T0>&& has_index<T1>&& has_index<T2>&& has_index<T3>) {
+    if (compat::is_within_lifetime(&alternative_0.tag)) {
+      return alternative_0.tag;
+    } else if (compat::is_within_lifetime(&alternative_1.tag)) {
+      return alternative_1.tag;
+    } else if (compat::is_within_lifetime(&alternative_2.tag)) {
+      return alternative_2.tag;
+    } else if (compat::is_within_lifetime(&alternative_3.tag)) {
+      return alternative_3.tag;
+    } else {
+      return tail.index();
+    }
+  }
+
+  template <std::size_t N, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    if constexpr (N == 0) {
+      if constexpr (has_unwrap<T0>) {
+        return std::forward<Self>(self).alternative_0.unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).alternative_0);
+      }
+    } else if constexpr (N == 1) {
+      if constexpr (has_unwrap<T1>) {
+        return std::forward<Self>(self).alternative_1.unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).alternative_1);
+      }
+    } else if constexpr (N == 2) {
+      if constexpr (has_unwrap<T2>) {
+        return std::forward<Self>(self).alternative_2.unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).alternative_2);
+      }
+    } else if constexpr (N == 3) {
+      if constexpr (has_unwrap<T3>) {
+        return std::forward<Self>(self).alternative_3.unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).alternative_3);
+      }
+    } else {
+      return std::forward<Self>(self).tail.template get<N - 4>();
+    }
+  }
+};
+
+}  // namespace slo::impl
\ No newline at end of file
diff --git a/include/slo/impl/union/recursive.h.in b/include/slo/impl/union/recursive.h.in
new file mode 100644
index 0000000..e625b64
--- /dev/null
+++ b/include/slo/impl/union/recursive.h.in
@@ -0,0 +1,115 @@
+#pragma once
+#include <utility>
+#include <slo/util/compat.h>
+#include <slo/impl/concepts.h>
+
+@%max 3
+@{
+
+def generate(maximum: int, fmt: str, join_str: str = ", "):
+    return join_str.join(fmt.format(idx) for idx in range(maximum))
+
+def types(count): 
+    return generate(count, "typename T{}")
+def typenames(count): 
+    return generate(count, "T{}")
+def members(count): 
+    return generate(count, "T{0} alternative_{0};", "\n")
+def no_trivial_dtors(count): 
+    return generate(count, "!std::is_trivially_destructible_v<T{}>", " || ")
+}@
+
+
+namespace slo::impl {
+template <bool Trivial, typename... Ts>
+union RecursiveUnion;
+
+template <bool Trivial, typename T>
+union RecursiveUnion<Trivial, T> {
+  T value;
+
+  constexpr RecursiveUnion(RecursiveUnion const&) = default;
+  constexpr RecursiveUnion(RecursiveUnion&&)  = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion const&) = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion&&)  = default;
+  constexpr ~RecursiveUnion() = default;
+  constexpr ~RecursiveUnion() requires (!Trivial) {}
+
+  template <typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<0>, Args&&... args) 
+    : value{std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const
+    requires(has_index<T>)
+  {
+    return value.tag;
+  }
+
+  template <std::size_t N, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    static_assert(N == 0);
+    if constexpr (has_unwrap<T>) {
+      return std::forward<Self>(self).value.unwrap();
+    } else {
+      return compat::forward_like<Self>(std::forward<Self>(self).value);
+    }
+  }
+};
+
+@[for N in range(__max__)]
+template <bool Trivial, @types(2**N), typename... Ts> 
+requires (sizeof...(Ts) != 0)
+union RecursiveUnion<Trivial, @typenames(2**N), Ts...>{
+  @members(2**N)
+  RecursiveUnion<Trivial, Ts...> tail;
+
+  constexpr RecursiveUnion(RecursiveUnion const&) = default;
+  constexpr RecursiveUnion(RecursiveUnion&&)  = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion const&) = default;
+  constexpr RecursiveUnion& operator=(RecursiveUnion&&)  = default;
+  constexpr ~RecursiveUnion() = default;
+  constexpr ~RecursiveUnion() requires (!Trivial) {}
+
+@[for Idx in range(2**N)]
+  template <typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<@Idx>, Args&&... args) 
+    : alternative_@Idx {std::forward<Args>(args)...} {}
+@[end for]
+
+  template <std::size_t N, typename... Args>
+  constexpr explicit RecursiveUnion(std::in_place_index_t<N>, Args&&... args)
+      : tail{std::in_place_index_t<N - @(2**N)>{}, std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const
+    requires(@(' && '.join(f"has_index<T{idx}>" for idx in range(2**N))))
+  {
+    @[for Idx in range(2**N)]@
+    if (compat::is_within_lifetime(&alternative_@Idx .tag)) {
+      return alternative_@Idx .tag;
+    } else
+    @[end for]@
+    {
+      return tail.index();
+    }
+  }
+
+  template <std::size_t N, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    @[for Idx in range(2**N)]@
+    if constexpr (N == @Idx) {
+      if constexpr (has_unwrap<T@Idx>) {
+        return std::forward<Self>(self).alternative_@Idx .unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).alternative_@Idx);
+      }
+    } else
+    @[end for]@
+    {
+      return std::forward<Self>(self).tail.template get<N - @(2**N)>();
+    }
+  }
+
+};
+@[end for]
+
+}  // namespace slo::impl
\ No newline at end of file
diff --git a/include/slo/impl/union/tree.h b/include/slo/impl/union/tree.h
new file mode 100644
index 0000000..fca1e78
--- /dev/null
+++ b/include/slo/impl/union/tree.h
@@ -0,0 +1,222 @@
+#pragma once
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <slo/util/compat.h>
+#include <slo/impl/concepts.h>
+#include <slo/util/list.h>
+
+namespace slo::impl {
+
+namespace detail {
+template <bool Trivial, typename... Ts>
+union TreeUnion;
+
+template <bool Trivial>
+union TreeUnion<Trivial>{};
+
+template <bool Trivial, typename... Ts, typename... Us>
+union TreeUnion<Trivial, TreeUnion<Trivial, Ts...>, TreeUnion<Trivial, Us...>> {
+  constexpr static std::size_t size = TreeUnion<Trivial, Ts...>::size + TreeUnion<Trivial, Us...>::size;
+  TreeUnion<Trivial, Ts...> left;
+  TreeUnion<Trivial, Us...> right;
+
+  constexpr TreeUnion(TreeUnion const&)                = default;
+  constexpr TreeUnion(TreeUnion&&) noexcept            = default;
+  constexpr TreeUnion& operator=(TreeUnion const&)     = default;
+  constexpr TreeUnion& operator=(TreeUnion&&) noexcept = default;
+  constexpr ~TreeUnion()                               = default;
+  constexpr ~TreeUnion() requires(!Trivial) {}
+
+  template <std::size_t Idx, typename... Args>
+  constexpr explicit TreeUnion(std::in_place_index_t<Idx> idx, Args&&... args)
+    requires(Idx < TreeUnion<Trivial, Ts...>::size)
+      : left{idx, std::forward<Args>(args)...} {}
+
+  template <std::size_t Idx, typename... Args>
+  constexpr explicit TreeUnion(std::in_place_index_t<Idx>, Args&&... args)
+    requires(Idx >= TreeUnion<Trivial, Ts...>::size)
+      : right{std::in_place_index<Idx - TreeUnion<Trivial, Ts...>::size>, std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const {
+    if (compat::is_within_lifetime(&left)) {
+      return left.index();
+    }
+    return right.index();
+  }
+
+  template <std::size_t Idx, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    if constexpr (Idx < TreeUnion<Trivial, Ts...>::size) {
+      return std::forward<Self>(self).left.template get<Idx>();
+    } else {
+      return std::forward<Self>(self).right.template get<Idx - TreeUnion<Trivial, Ts...>::size>();
+    }
+  }
+};
+
+template <bool Trivial, typename... Ts, typename U>
+union TreeUnion<Trivial, TreeUnion<Trivial, Ts...>, U> {
+  constexpr static std::size_t size = 1 + TreeUnion<Trivial, Ts...>::size;
+  TreeUnion<Trivial, Ts...> left;
+  U right;
+
+  constexpr TreeUnion(TreeUnion const&)                = default;
+  constexpr TreeUnion(TreeUnion&&) noexcept            = default;
+  constexpr TreeUnion& operator=(TreeUnion const&)     = default;
+  constexpr TreeUnion& operator=(TreeUnion&&) noexcept = default;
+  constexpr ~TreeUnion()                               = default;
+  constexpr ~TreeUnion() requires(!Trivial) {}
+
+  template <std::size_t Idx, typename... Args>
+  constexpr explicit TreeUnion(std::in_place_index_t<Idx> idx, Args&&... args)
+    requires(Idx < TreeUnion<Trivial, Ts...>::size)
+      : left{idx, std::forward<Args>(args)...} {}
+
+  template <std::size_t Idx, typename... Args>
+  constexpr explicit TreeUnion(std::in_place_index_t<Idx>, Args&&... args)
+    requires(Idx == TreeUnion<Trivial, Ts...>::size)
+      : right{std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const {
+    if (compat::is_within_lifetime(&right.tag)) {
+      return right.tag;
+    }
+    return left.index();
+  }
+
+  template <std::size_t Idx, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    if constexpr (Idx < TreeUnion<Trivial, Ts...>::size) {
+      return std::forward<Self>(self).left.template get<Idx>();
+    } else {
+      static_assert(Idx == TreeUnion<Trivial, Ts...>::size, "Index out of bounds");
+      if constexpr (has_unwrap<U>) {
+        return std::forward<Self>(self).right.unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).right);
+      }
+    }
+  }
+};
+
+template <bool Trivial, typename T, typename U>
+union TreeUnion<Trivial, T, U> {
+  T left;
+  U right;
+
+  constexpr static std::size_t size = 2;
+
+  constexpr TreeUnion(TreeUnion const&)                = default;
+  constexpr TreeUnion(TreeUnion&&) noexcept            = default;
+  constexpr TreeUnion& operator=(TreeUnion const&)     = default;
+  constexpr TreeUnion& operator=(TreeUnion&&) noexcept = default;
+  constexpr ~TreeUnion()                               = default;
+  constexpr ~TreeUnion() requires(!Trivial) {}
+
+  template <typename... Args>
+  constexpr explicit TreeUnion(std::in_place_index_t<0>, Args&&... args) : left{std::forward<Args>(args)...} {}
+
+  template <typename... Args>
+  constexpr explicit TreeUnion(std::in_place_index_t<1>, Args&&... args) : right{std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const {
+    if (compat::is_within_lifetime(&left.tag)) {
+      return left.tag;
+    } else if (compat::is_within_lifetime(&right.tag)) {
+      return right.tag;
+    }
+    std::unreachable();
+  }
+
+  template <std::size_t Idx, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    if constexpr (Idx == 0) {
+      if constexpr (has_unwrap<T>) {
+        return std::forward<Self>(self).left.unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).left);
+      }
+    } else {
+      static_assert(Idx == 1, "Index out of bounds");
+      if constexpr (has_unwrap<U>) {
+        return std::forward<Self>(self).right.unwrap();
+      } else {
+        return compat::forward_like<Self>(std::forward<Self>(self).right);
+      }
+    }
+  }
+};
+
+template <bool Trivial, typename T>
+union TreeUnion<Trivial, T> {
+  T left;
+  constexpr static std::size_t size = 1;
+
+  constexpr TreeUnion(TreeUnion const&)                = default;
+  constexpr TreeUnion(TreeUnion&&) noexcept            = default;
+  constexpr TreeUnion& operator=(TreeUnion const&)     = default;
+  constexpr TreeUnion& operator=(TreeUnion&&) noexcept = default;
+  constexpr ~TreeUnion()                               = default;
+  constexpr ~TreeUnion() requires(!Trivial) {}
+
+  template <typename... Args>
+  constexpr explicit TreeUnion(std::in_place_index_t<0>, Args&&... args) : left{std::forward<Args>(args)...} {}
+
+  [[nodiscard]] constexpr std::size_t index() const {
+    if (compat::is_within_lifetime(&left.tag)) {
+      return left.tag;
+    }
+    std::unreachable();
+  }
+
+  template <std::size_t Idx, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    static_assert(Idx == 0);
+    if constexpr (has_unwrap<T>) {
+      return std::forward<Self>(self).left.unwrap();
+    } else {
+      return compat::forward_like<Self>(std::forward<Self>(self).left);
+    }
+  }
+};
+
+template <bool, typename, typename>
+struct ToCBTImpl;
+
+template <bool Trivial>
+struct ToCBTImpl<Trivial, util::TypeList<>, util::TypeList<>> {
+  using type = TreeUnion<Trivial>;
+};
+
+
+template <bool Trivial, typename T>
+struct ToCBTImpl<Trivial, util::TypeList<T>, util::TypeList<>> {
+  using type = TreeUnion<Trivial, T>;
+};
+
+template <bool Trivial, typename T, typename U>
+struct ToCBTImpl<Trivial, util::TypeList<>, util::TypeList<TreeUnion<Trivial, T, U>>> {
+  using type = TreeUnion<Trivial, T, U>;
+};
+
+template <bool Trivial, typename... Out>
+struct ToCBTImpl<Trivial, util::TypeList<>, util::TypeList<Out...>> {
+  using type = ToCBTImpl<Trivial, util::TypeList<Out...>, util::TypeList<>>::type;
+};
+
+template <bool Trivial, typename T, typename... Out>
+struct ToCBTImpl<Trivial, util::TypeList<T>, util::TypeList<Out...>> {
+  using type = ToCBTImpl<Trivial, util::TypeList<Out..., T>, util::TypeList<>>::type;
+};
+
+template <bool Trivial, typename T1, typename T2, typename... In, typename... Out>
+struct ToCBTImpl<Trivial, util::TypeList<T1, T2, In...>, util::TypeList<Out...>> {
+  using type = ToCBTImpl<Trivial, util::TypeList<In...>, util::TypeList<Out..., TreeUnion<Trivial, T1, T2>>>::type;
+};
+}  // namespace detail
+
+template <bool Trivial, typename... Ts>
+using TreeUnion = typename detail::ToCBTImpl<Trivial, util::TypeList<Ts...>, util::TypeList<>>::type;
+
+}  // namespace slo::impl
\ No newline at end of file
diff --git a/include/slo/impl/visit/fptr_array.h b/include/slo/impl/visit/fptr_array.h
new file mode 100644
index 0000000..23cfe11
--- /dev/null
+++ b/include/slo/impl/visit/fptr_array.h
@@ -0,0 +1,31 @@
+#pragma once
+#include <cstddef>
+#include <utility>
+#include "visit.h"
+namespace slo::impl {
+
+template <int>
+struct VisitStrategy;
+
+template <>
+struct VisitStrategy<-1> {
+  template <typename R, typename F, typename... Vs, std::size_t... Idx>
+  constexpr static decltype(auto) visit_impl(std::index_sequence<Idx...>, F&& visitor, Vs&&... variants) {
+    using Impl       = VisitImpl<Vs...>;
+    auto const index = typename Impl::key_type(variants.index()...);
+
+    using function_type                       = R (*)(F&&, Vs&&...);
+    static constexpr function_type dispatch[] = {&Impl::template visit<Idx>...};
+    if (index < Impl::max_index) { // TODO should already be checked at this point
+      return dispatch[std::size_t{index}](std::forward<F>(visitor), std::forward<Vs>(variants)...);
+    }
+  }
+
+  template <typename R, typename F, typename... Vs>
+  constexpr static decltype(auto) visit(F&& visitor, Vs&&... variants) {
+    constexpr auto states = VisitImpl<Vs...>::max_index;
+    return visit_impl<R>(std::make_index_sequence<states>{}, std::forward<F>(visitor), std::forward<Vs>(variants)...);
+  }
+};
+
+}  // namespace slo::impl
\ No newline at end of file
diff --git a/include/slo/impl/visit/macro.h b/include/slo/impl/visit/macro.h
new file mode 100644
index 0000000..2b883d6
--- /dev/null
+++ b/include/slo/impl/visit/macro.h
@@ -0,0 +1,50 @@
+#pragma once
+#include <cstddef>
+#include <utility>
+#include <slo/util/stamp.h>
+#include <slo/impl/exception.h>
+
+#include "visit.h"
+
+namespace slo {
+template <typename T>
+struct variant_size;
+}
+
+namespace slo::impl {
+
+template <int I>
+struct VisitStrategy;
+
+#define SLO_VISIT_CASE(Idx)                                                                                  \
+  case Idx:                                                                                                  \
+    if constexpr ((Idx) < VisitImpl<Vs...>::max_index) {                                                     \
+      return VisitImpl<Vs...>::template visit<Idx>(std::forward<F>(visitor), std::forward<Vs>(variants)...); \
+    }                                                                                                        \
+    std::unreachable();
+
+#define SLO_VISIT_STAMP(stamper, n)                                                \
+  const auto key = typename VisitImpl<Vs...>::key_type(variants.index()...);       \
+  switch (static_cast<std::size_t>(key)) {                                         \
+    stamper(0, SLO_VISIT_CASE);                                                    \
+    default: throw_bad_variant_access((variants.valueless_by_exception() || ...)); \
+  }
+
+#define SLO_GENERATE_STRATEGY(Idx, Count)                                  \
+  template <>                                                              \
+  struct VisitStrategy<Idx> {                                              \
+    template <typename, typename F, typename... Vs>                        \
+    static constexpr decltype(auto) visit(F&& visitor, Vs&&... variants) { \
+      SLO_STAMP(Count, SLO_VISIT_STAMP);                                   \
+    }                                                                      \
+  }
+
+SLO_GENERATE_STRATEGY(1, 4);    // 4^1 potential states
+SLO_GENERATE_STRATEGY(2, 16);   // 4^2 potential states
+SLO_GENERATE_STRATEGY(3, 64);   // 4^3 potential states
+SLO_GENERATE_STRATEGY(4, 256);  // 4^4 potential states
+
+#undef SLO_VISIT_CASE
+#undef SLO_VISIT_STAMP
+#undef SLO_GENERATE_STRATEGY
+}  // namespace slo::impl
diff --git a/include/slo/impl/visit/variadic.h b/include/slo/impl/visit/variadic.h
new file mode 100644
index 0000000..63d947f
--- /dev/null
+++ b/include/slo/impl/visit/variadic.h
@@ -0,0 +1,54 @@
+#pragma once
+#include <cstddef>
+#include <concepts>
+#include <memory>
+#include <utility>
+
+#include <slo/impl/concepts.h>
+#include <slo/impl/exception.h>
+
+#include "visit.h"
+namespace slo::impl {
+template <>
+struct VisitStrategy<0> {
+  // fold
+  template <typename R, typename F, typename... Vs, std::size_t... Idx>
+  constexpr static decltype(auto) visit_impl(std::index_sequence<Idx...>, F&& visitor, Vs&&... variants) {
+    auto index        = typename VisitImpl<Vs...>::key_type{variants.index()...};
+    bool success      = false;
+    if constexpr (std::same_as<R, void>) {
+      success = ((index == Idx
+                  ? VisitImpl<Vs...>::template visit<Idx>(std::forward<F>(visitor), std::forward<Vs>(variants)...),
+                  true : false) ||
+                 ...);
+      if (success) {
+        return;
+      }
+    } else {
+      union {
+        char dummy;
+        R value;
+      } ret{};
+
+      success =
+          ((index == Idx ? std::construct_at(&ret.value, VisitImpl<Vs...>::template visit<Idx>(
+                                                             std::forward<F>(visitor), std::forward<Vs>(variants)...)),
+            true         : false) ||
+           ...);
+
+      if (success) {
+        return ret.value;
+      }
+    }
+
+    throw_bad_variant_access((variants.valueless_by_exception() || ...));
+  }
+
+  template <typename R, typename F, typename... Vs>
+  constexpr static decltype(auto) visit(F&& visitor, Vs&&... variants) {
+    constexpr auto states = VisitImpl<Vs...>::max_index;
+    return visit_impl<R>(std::make_index_sequence<states>{}, std::forward<F>(visitor), std::forward<Vs>(variants)...);
+  }
+};
+
+}  // namespace slo::impl
diff --git a/include/slo/impl/visit/visit.h b/include/slo/impl/visit/visit.h
new file mode 100644
index 0000000..0f628c3
--- /dev/null
+++ b/include/slo/impl/visit/visit.h
@@ -0,0 +1,110 @@
+#pragma once
+#include <concepts>
+#include <cstddef>
+#include <array>
+#include <utility>
+#include <type_traits>
+
+#include <slo/impl/concepts.h>
+
+namespace slo {
+template <std::size_t, typename>
+struct variant_alternative;
+
+template <typename>
+struct variant_size;
+
+template <std::size_t Idx, impl::has_get V>
+constexpr decltype(auto) get_unchecked(V&&) noexcept;
+}  // namespace slo
+
+namespace slo::impl {
+template <int I>
+struct VisitStrategy;
+
+template <std::size_t... Dimensions>
+struct Key {
+  constexpr static std::size_t size      = sizeof...(Dimensions);
+  constexpr static std::size_t max_index = (Dimensions * ... * 1);
+
+  static consteval auto generate_offsets() {
+    std::array<std::size_t, size> result = {};
+    constexpr std::size_t dimensions[]   = {Dimensions...};
+    result[0]                            = 1;
+    for (std::size_t idx = 1; idx < size; ++idx) {
+      result[idx] = dimensions[idx - 1] * result[idx - 1];
+    }
+
+    return result;
+  }
+
+  constexpr static auto offsets = generate_offsets();
+
+  std::size_t index                             = static_cast<std::size_t>(-1);
+  std::size_t subindices[sizeof...(Dimensions)] = {};
+
+  constexpr explicit Key(std::size_t index_) noexcept : index(index_) {
+    std::size_t key                    = index_;
+    constexpr std::size_t dimensions[] = {Dimensions...};
+    for (std::size_t idx = 0; idx < size; ++idx) {
+      subindices[idx] = key % dimensions[idx];
+      key /= dimensions[idx];
+    }
+  }
+
+  constexpr explicit Key(std::convertible_to<std::size_t> auto... subindices_) noexcept
+    requires(sizeof...(subindices_) > 1)
+      : index(0)
+      , subindices(subindices_...) {
+    static_assert(sizeof...(subindices_) == size, "Number of indices must match the number of dimensions.");
+    for (std::size_t idx = 0; idx < size; ++idx) {
+      index += subindices[idx] * offsets[idx];
+    }
+  }
+
+  constexpr explicit operator std::size_t() const noexcept { return index; }
+  constexpr std::size_t operator[](std::size_t position) const noexcept { return subindices[position]; }
+  friend constexpr auto operator<=>(Key const& self, std::size_t other) { return self.index <=> other; }
+  friend constexpr bool operator==(Key const& self, std::size_t other) { return self.index == other; }
+};
+
+template <typename... Variants>  // possibly cv qualified
+struct VisitImpl {
+  using key_type                         = Key<variant_size<std::remove_cvref_t<Variants>>::value...>;
+  static constexpr std::size_t max_index = key_type::max_index;
+
+  template <key_type Tag, typename = std::make_index_sequence<sizeof...(Variants)>>
+  struct Dispatch;
+
+  template <key_type Tag, std::size_t... Idx>
+  struct Dispatch<Tag, std::index_sequence<Idx...>> {
+    template <typename F, typename... U>
+    [[gnu::always_inline]]
+    constexpr static decltype(auto) visit(F&& visitor, U&&... variants) {
+      return std::forward<F>(visitor)(slo::get_unchecked<Tag[Idx]>(std::forward<U>(variants))...);
+    }
+  };
+
+  template <std::size_t Idx, typename F, typename... U>
+  [[gnu::always_inline]]
+  constexpr static decltype(auto) visit(F&& visitor, U&&... variants) {
+    return Dispatch<key_type{Idx}>::visit(std::forward<F>(visitor), std::forward<U>(variants)...);
+  }
+};
+
+template <typename Variant>
+struct VisitImpl<Variant> {
+  using key_type                         = std::size_t;
+  static constexpr std::size_t max_index = variant_size<std::remove_cvref_t<Variant>>::value;
+
+  template <std::size_t Idx, typename F, typename U>
+  [[gnu::always_inline]] constexpr static decltype(auto) visit(F&& visitor, U&& variant) {
+    return std::forward<F>(visitor)(slo::get_unchecked<Idx>(std::forward<U>(variant)));
+  }
+};
+
+// non-exhaustive result type check
+template <typename F, typename... Vs>
+// TODO: Vs... might be derived from variant
+using visit_result_t = std::invoke_result_t<F, typename slo::variant_alternative<0, std::remove_cvref_t<Vs>>::type...>;
+}  // namespace slo::impl
\ No newline at end of file
diff --git a/include/slo/util/compat.h b/include/slo/util/compat.h
new file mode 100644
index 0000000..2d1eedb
--- /dev/null
+++ b/include/slo/util/compat.h
@@ -0,0 +1,47 @@
+#pragma once
+#include <utility>
+#include <type_traits>
+
+namespace slo::compat {
+#if __cpp_lib_forward_like <= 202207L
+template <typename T, typename U>
+[[nodiscard]] constexpr auto&& forward_like(U&& obj) noexcept {
+  if constexpr (std::is_const_v<std::remove_reference_t<T>>) {
+    if constexpr (std::is_lvalue_reference_v<T&&>) {
+      return static_cast<std::remove_reference_t<U> const&>(obj);
+    } else {
+      return static_cast<std::remove_reference_t<U> const&&>(obj);
+    }
+  } else {
+    if constexpr (std::is_lvalue_reference_v<T&&>) {
+      return static_cast<U&>(obj);
+    } else {
+      return static_cast<std::remove_reference_t<U>&&>(obj);
+    }
+  }
+}
+#else
+using std::forward_like;
+#endif
+
+// standard libraries don't expose this one but it is rather handy
+template <typename T, typename U>
+using like_t = decltype(forward_like<T>(std::declval<U>()));
+
+#if __cpp_lib_within_lifetime < 202306L
+template <class T>
+constexpr bool is_within_lifetime(const T* ptr) noexcept {
+  // this is only constexpr because clang does not like it being consteval
+#  if __has_builtin(__builtin_constant_p)
+#    define HAS_IS_WITHIN_LIFETIME true
+  return __builtin_constant_p(*ptr);
+#  else
+#    define HAS_IS_WITHIN_LIFETIME false
+  return 0;
+#  endif
+}
+#else
+#  define HAS_IS_WITHIN_LIFETIME true
+using std::is_within_lifetime;
+#endif
+}  // namespace slo::compat
\ No newline at end of file
diff --git a/include/slo/util/concepts.h b/include/slo/util/concepts.h
new file mode 100644
index 0000000..17ad17b
--- /dev/null
+++ b/include/slo/util/concepts.h
@@ -0,0 +1,25 @@
+#pragma once
+#include <type_traits>
+#include <functional>
+
+
+namespace slo::util {
+template<typename...>
+struct all_same : std::true_type{};
+
+template<typename T, typename... Us>
+struct all_same<T, Us...> : std::conjunction<std::is_same<T, Us>...>{};
+
+template <typename... Ts>
+constexpr inline bool all_same_v = all_same<Ts...>::value;
+
+template <typename... Ts>
+concept is_homogeneous = all_same<Ts...>::value;
+
+template <typename T>
+concept is_hashable = 
+    std::is_default_constructible_v<std::hash<T>>
+    && std::is_copy_constructible_v<std::hash<T>>
+    && std::is_move_constructible_v<std::hash<T>>
+    && std::is_invocable_r_v<std::size_t, std::hash<T>, T const&>;
+}
\ No newline at end of file
diff --git a/include/slo/util/list.h b/include/slo/util/list.h
new file mode 100644
index 0000000..87722cc
--- /dev/null
+++ b/include/slo/util/list.h
@@ -0,0 +1,80 @@
+#pragma once
+#include <concepts>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+namespace slo::util {
+
+namespace detail {
+template <std::size_t Idx, typename T>
+struct Tagged {
+  using type                         = T;
+  constexpr static std::size_t value = Idx;
+};
+
+template <std::size_t Idx, typename T>
+constexpr T get_type_impl(Tagged<Idx, T>) {
+  static_assert(false, "get_type_impl not allowed in an evaluated context");
+}
+
+template <typename T, std::size_t Idx>
+constexpr Tagged<Idx, T> get_index_impl(Tagged<Idx, T>) {
+  static_assert(false, "get_index_impl not allowed in an evaluated context");
+}
+
+}  // namespace detail
+
+template <typename... Ts>
+struct TypeList {
+  static constexpr std::size_t size = sizeof...(Ts);
+
+  template <typename = std::index_sequence_for<Ts...>>
+  struct GetHelper;
+
+  template <std::size_t... Idx>
+  struct GetHelper<std::index_sequence<Idx...>> : detail::Tagged<Idx, Ts>... {};
+
+  /**
+   * @brief Aliases the type at the specified index
+   *
+   * @tparam Idx
+   */
+  template <std::size_t Idx>
+  requires (Idx < sizeof...(Ts))
+  using type_at =
+#if __has_builtin(__type_pack_element)
+      __type_pack_element<Idx, Ts...>;
+#else
+      decltype(get_type_impl<Idx>(GetHelper{}));
+#endif
+
+  /**
+   * @brief Reverse mapping type -> index. Returns sizeof...(Ts) if the type could not be found
+   *        or it appeared more than once in the list.
+   *
+   * @tparam T
+   */
+  template <typename T>
+  constexpr static std::size_t index_of = sizeof...(Ts);
+
+  template <typename T>
+  // constraint is not fulfilled if T is contained more than once (=> get_index_impl would be ambiguous)
+    requires requires(GetHelper<> obj) { detail::get_index_impl<T>(obj); }
+  constexpr static std::size_t index_of<T> = decltype(detail::get_index_impl<T>(GetHelper<>{}))::value;
+
+  using index_type = std::conditional_t<(sizeof...(Ts) >= 255), unsigned short, unsigned char>;
+
+  template <template <typename> class Trait>
+  constexpr static bool all = (Trait<Ts>::value && ...);
+
+  template <template <typename> class Trait>
+  constexpr static bool any = (Trait<Ts>::value || ...);
+};
+
+template <std::size_t Idx, typename List>
+using type_at = typename List::template type_at<Idx>;
+
+template <typename T, typename List>
+constexpr inline std::size_t index_of = List::template index_of<T>;
+}  // namespace slo::util
\ No newline at end of file
diff --git a/include/slo/util/stamp.h b/include/slo/util/stamp.h
new file mode 100644
index 0000000..b0abe28
--- /dev/null
+++ b/include/slo/util/stamp.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#define SLO_STAMP4(offset, x) x(offset) x(offset + 1) x(offset + 2) x(offset + 3)
+
+#define SLO_STAMP16(offset, x) \
+  SLO_STAMP4(offset, x)        \
+  SLO_STAMP4(offset + 4, x)    \
+  SLO_STAMP4(offset + 8, x)    \
+  SLO_STAMP4(offset + 12, x)
+
+#define SLO_STAMP64(offset, x) \
+  SLO_STAMP16(offset, x)       \
+  SLO_STAMP16(offset + 16, x)  \
+  SLO_STAMP16(offset + 32, x)  \
+  SLO_STAMP16(offset + 48, x)
+
+#define SLO_STAMP256(offset, x) \
+  SLO_STAMP64(offset, x)        \
+  SLO_STAMP64(offset + 64, x)   \
+  SLO_STAMP64(offset + 128, x)  \
+  SLO_STAMP64(offset + 192, x)
+
+#define SLO_STAMP(offset, x) x(SLO_STAMP##offset, offset)
\ No newline at end of file
diff --git a/include/slo/util/utility.h b/include/slo/util/utility.h
new file mode 100644
index 0000000..0d16cae
--- /dev/null
+++ b/include/slo/util/utility.h
@@ -0,0 +1,33 @@
+#pragma once
+#include <utility>
+
+namespace slo::util {
+struct error_type{};
+
+template <typename>
+struct in_place_tag : std::false_type {};
+
+template <typename T>
+struct in_place_tag<std::in_place_type_t<T>> : std::true_type {};
+template <std::size_t V>
+struct in_place_tag<std::in_place_index_t<V>> : std::true_type {};
+
+template <typename T>
+concept is_in_place = in_place_tag<T>::value;
+
+
+template <bool, template <typename...> class T, template <typename...> class F>
+struct ConditionalTemplate;
+
+template <template <typename...> class T, template <typename...> class F>
+struct ConditionalTemplate<true, T, F> {
+  template <typename... Ts>
+  using type = T<Ts...>;
+};
+
+template <template <typename...> class T, template <typename...> class F>
+struct ConditionalTemplate<false, T, F> {
+  template <typename... Ts>
+  using type = F<Ts...>;
+};
+}  // namespace slo::util
\ No newline at end of file
diff --git a/include/slo/util/warning.h b/include/slo/util/warning.h
new file mode 100644
index 0000000..f798abf
--- /dev/null
+++ b/include/slo/util/warning.h
@@ -0,0 +1,34 @@
+#pragma once
+#define SLO_PRAGMA(...) _Pragma(#__VA_ARGS__)
+
+#if defined(__clang__)
+
+#define SLO_WARNING_DISABLE_CLANG(WARNING) SLO_PRAGMA(clang diagnostic ignored WARNING)
+#define SLO_WARNING_PUSH SLO_PRAGMA(clang diagnostic push)
+#define SLO_WARNING_POP SLO_PRAGMA(clang diagnostic pop)
+
+#else
+#define SLO_WARNING_DISABLE_CLANG(...)
+#endif
+
+#if (defined(__GNUC__) || defined(__GNUG__)) && !defined(__clang__)
+
+#define SLO_WARNING_DISABLE_GCC(WARNING) SLO_PRAGMA(GCC diagnostic ignored WARNING)
+#define SLO_WARNING_PUSH SLO_PRAGMA(GCC diagnostic push)
+#define SLO_WARNING_POP SLO_PRAGMA(GCC diagnostic pop)
+
+#else
+#define SLO_WARNING_DISABLE_GCC(...)
+#endif
+
+#if defined(_MSC_VER)
+
+#define SLO_WARNING_DISABLE_MSVC(WARNING) SLO_PRAGMA(warning(disable: WARNING))
+#define SLO_WARNING_PUSH SLO_PRAGMA(warning(push))
+#define SLO_WARNING_POP SLO_PRAGMA(warning(pop))
+
+#else
+#define SLO_WARNING_DISABLE_MSVC(...)
+#endif
+
+#define SLO_WARNING_DISABLE(COMPILER, WARNING) SLO_WARNING_DISABLE_##COMPILER(WARNING)
\ No newline at end of file
diff --git a/include/slo/variant.h b/include/slo/variant.h
new file mode 100644
index 0000000..b56afc2
--- /dev/null
+++ b/include/slo/variant.h
@@ -0,0 +1,661 @@
+#pragma once
+#include <algorithm>
+#include <compare>
+#include <cstddef>
+#include <concepts>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+#include <functional>
+
+#include "impl/feature.h"
+#include "impl/concepts.h"
+#include "impl/exception.h"
+#include "impl/storage/inverted.h"
+#include "impl/storage/normal.h"
+#include "impl/storage/member_ptr.h"
+
+#include "impl/visit/fptr_array.h"
+#include "impl/visit/visit.h"
+#include "impl/union/recursive.h"
+#include "impl/union/tree.h"
+#if USING(SLO_MACRO_VISIT)
+#include "impl/visit/macro.h"
+#else
+#include "impl/visit/variadic.h"
+#endif
+
+#include "util/concepts.h"
+#include "util/compat.h"
+#include "util/list.h"
+#include "util/utility.h"
+
+namespace slo {
+
+struct nullopt {};
+
+template <std::size_t, typename>
+struct variant_alternative;
+
+template <typename>
+struct variant_size;
+
+template <std::size_t Idx, typename V>
+using variant_alternative_t = typename variant_alternative<Idx, std::remove_reference_t<V>>::type;
+
+template <typename T>
+inline constexpr std::size_t variant_size_v = slo::variant_size<T>::value;
+
+inline constexpr std::size_t variant_npos = -1ULL;
+
+namespace impl {
+template <typename Source, typename Dest>
+concept allowed_conversion = requires(Source obj) { std::type_identity_t<Dest[]>{std::move(obj)}; };
+
+template <std::size_t Idx, typename T>
+struct Build_FUN {
+  template <allowed_conversion<T> U>
+  auto operator()(T, U&&) -> std::integral_constant<std::size_t, Idx>;
+};
+
+template <typename V, typename = std::make_index_sequence<V::size>>
+struct Build_FUNs;
+
+template <template <typename...> class V, typename... Ts, std::size_t... Idx>
+struct Build_FUNs<V<Ts...>, std::index_sequence<Idx...>> : Build_FUN<Idx, Ts>... {
+  using Build_FUN<Idx, Ts>::operator()...;
+};
+
+template <typename T, typename V>
+inline constexpr auto selected_index = variant_npos;
+
+template <typename T, typename V>
+  requires std::invocable<Build_FUNs<V>, T, T>
+inline constexpr auto selected_index<T, V> = std::invoke_result_t<Build_FUNs<V>, T, T>::value;
+
+template <template <typename...> class Storage, typename... Ts>
+class Variant {
+public:
+  using alternatives         = Storage<Ts...>::alternatives;
+  static constexpr auto npos = Storage<Ts...>::npos;
+  Storage<Ts...> storage;
+
+  static_assert(alternatives::size > 0, "Variant must contain at least one alternative");
+  static_assert(!alternatives::template any<std::is_reference>, "Variant must not have reference alternatives");
+  static_assert(!alternatives::template any<std::is_void>, "Variant must not have void alternatives");
+
+  // default constructor, only if alternative #0 is default constructible
+  constexpr Variant() noexcept(
+      std::is_nothrow_default_constructible_v<variant_alternative_t<0, Variant>>)  // [variant.ctor]/5
+    requires(std::is_default_constructible_v<variant_alternative_t<0, Variant>>)   // [variant.ctor]/2
+      : Variant(std::in_place_index<0>) {}                                         // [variant.ctor]/3
+
+  constexpr Variant(Variant const& other) = default;
+  constexpr Variant(Variant const& other) noexcept(
+      alternatives::template all<std::is_nothrow_copy_constructible>)  // [variant.ctor]/8
+    requires(!std::is_trivially_destructible_v<Storage<Ts...>> &&
+             alternatives::template all<std::is_copy_constructible>)  // [variant.ctor]/9
+  {
+    slo::visit([this]<typename T>(T const& obj) { this->emplace<T>(obj); }, other);
+  }
+
+  constexpr Variant(Variant&& other) = default;
+  constexpr Variant(Variant&& other) noexcept(
+      alternatives::template all<std::is_nothrow_move_constructible>)  // [variant.ctor]/12
+    requires(!std::is_trivially_destructible_v<Storage<Ts...>>         // [variant.ctor]/13
+             && alternatives::template all<std::is_move_constructible>)
+  {
+    slo::visit([this]<typename T>(T&& obj) { this->emplace<T>(std::forward<T>(obj)); }, std::move(other));
+  }
+
+  // converting constructor
+  template <typename T>
+    requires(alternatives::size != 0                              // [variant.ctor]/15.1
+             && !std::same_as<std::remove_cvref_t<T>, Variant>    // [variant.ctor]/15.2
+             && !util::is_in_place<std::remove_cvref_t<T>>        // [variant.ctor]/15.3
+             && selected_index<T, alternatives> != variant_npos)  // [variant.ctor]/15.4, [variant.ctor]/15.5
+  constexpr explicit Variant(T&& obj) noexcept(std::is_nothrow_constructible_v<  // [variant.ctor]/18
+                                               typename util::type_at<selected_index<T, alternatives>, alternatives>,
+                                               T>)
+      : storage(std::in_place_index<selected_index<T, alternatives>>, std::forward<T>(obj)) {}
+
+  // in place constructors
+  template <typename T, typename... Args>
+  constexpr explicit Variant(std::in_place_type_t<T>,
+                             Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Args...>)  // [variant.ctor]/23
+      : storage(std::in_place_index<util::index_of<T, alternatives>>, std::forward<Args>(args)...) {}
+
+  template <typename T, typename U, typename... Args>
+  constexpr explicit Variant(std::in_place_type_t<T>, std::initializer_list<U> init_list, Args&&... args) noexcept(
+      std::is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>)  // [variant.ctor]/28
+      : storage(std::in_place_index<util::index_of<T, alternatives>>, init_list, std::forward<Args>(args)...) {}
+
+  template <std::size_t Idx, typename... Args>
+  constexpr explicit Variant(std::in_place_index_t<Idx> idx, Args&&... args) noexcept(
+      std::is_nothrow_constructible_v<util::type_at<Idx, alternatives>, Args...>)  // [variant.ctor]/33
+      : storage(idx, std::forward<Args>(args)...) {}
+
+  template <std::size_t Idx, typename U, typename... Args>
+  constexpr explicit Variant(
+      std::in_place_index_t<Idx> idx,
+      std::initializer_list<U> init_list,
+      Args&&... args) noexcept(std::is_nothrow_constructible_v<util::type_at<Idx, alternatives>,
+                                                               std::initializer_list<U>&,
+                                                               Args...>)  // noexcept not standardized
+      : storage(idx, init_list, std::forward<Args>(args)...) {}
+
+  // TODO inplace + initializer list
+
+  constexpr Variant& operator=(Variant const& other) = default;
+  constexpr Variant& operator=(Variant&& other)      = default;
+
+  constexpr Variant& operator=(Variant const& other)
+    requires(!std::is_trivially_destructible_v<Storage<Ts...>> && alternatives::template all<std::is_copy_assignable>)
+  {
+    if (this != std::addressof(other)) {
+      slo::visit([this]<typename T>(T const& obj) { this->emplace<T>(obj); }, other);
+    }
+    return *this;
+  }
+
+  constexpr Variant& operator=(Variant&& other) noexcept
+    requires(!std::is_trivially_destructible_v<Storage<Ts...>> && alternatives::template all<std::is_move_assignable>)
+  {
+    if (this != std::addressof(other)) {
+      slo::visit([this]<typename T>(T&& obj) { this->emplace<T>(std::forward<T>(obj)); }, std::move(other));
+    }
+    return *this;
+  }
+
+  constexpr ~Variant() = default;
+
+  template <typename T, typename... Args>
+  constexpr void emplace(Args&&... args) {
+    storage.template emplace<util::index_of<T, alternatives>>(std::forward<Args>(args)...);
+  }
+
+  template <std::size_t Idx, typename... Args>
+  constexpr void emplace(Args&&... args) {
+    storage.template emplace<Idx>(std::forward<Args>(args)...);
+  }
+
+  template <std::size_t Idx, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    return std::forward<Self>(self).storage.template get<Idx>();
+  }
+
+  template <typename T, typename Self>
+  constexpr decltype(auto) get(this Self&& self) {
+    return std::forward<Self>(self).storage.template get<util::index_of<T, alternatives>>();
+  }
+
+  template <typename Self, typename V>
+  constexpr decltype(auto) visit(this Self&& self, V&& visitor) {
+    return slo::visit(std::forward<V>(visitor), std::forward<Self>(self));
+  }
+
+  [[nodiscard]] constexpr bool valueless_by_exception() const noexcept { return storage.index() == npos; }
+  [[nodiscard]] constexpr std::size_t index() const noexcept {
+    if (auto idx = storage.index(); idx != npos) {
+      return idx;
+    }
+    return variant_npos;
+  }
+
+private:
+  constexpr bool can_nothrow_move() const {
+    constexpr bool results[] = {std::is_nothrow_move_constructible_v<Ts>...};
+    return valueless_by_exception() || results[index()];
+  }
+public:
+  void swap(Variant& other) {
+    if (valueless_by_exception() && other.valueless_by_exception()) {
+      // both variants valueless - do nothing
+      return;
+    }
+
+    if (index() == other.index()) {
+      // same index, swap the held objects directly
+      slo::visit(
+          [](auto& own_value, auto& other_value) {
+            using std::swap;
+            swap(own_value, other_value);
+          },
+          *this, other);
+      return;
+    }
+
+    Variant* lhs = this;
+    Variant* rhs = std::addressof(other);
+
+    if (can_nothrow_move() && other.can_nothrow_move()) {
+      std::swap(lhs, rhs);
+    }
+
+    Variant tmp(std::move(other));
+    
+#if __cpp_exceptions
+  if constexpr (alternatives::template all<std::is_nothrow_move_constructible>){
+    
+  }
+#else
+
+#endif
+  }
+};
+
+template <template <typename...> class Storage, typename... Ts>
+constexpr auto swap(Variant<Storage, Ts...>& lhs,
+                    Variant<Storage, Ts...>& rhs) noexcept(noexcept(lhs.swap(rhs))) -> decltype(lhs.swap(rhs)) {
+  return lhs.swap(rhs);
+}
+
+template <template <typename...> class S1, template <typename...> class S2, typename... Ts>
+  requires(std::three_way_comparable<Ts> && ...)
+constexpr auto operator<=>(Variant<S1, Ts...> const& lhs, Variant<S2, Ts...> const& rhs)
+    -> std::common_comparison_category_t<std::compare_three_way_result_t<Ts>...> {
+  using comparison_result = std::common_comparison_category_t<std::compare_three_way_result_t<Ts>...>;
+
+  if (lhs.valueless_by_exception() && rhs.valueless_by_exception()) {
+    return std::strong_ordering::equal;
+  }
+
+  if (lhs.valueless_by_exception()) {
+    return std::strong_ordering::less;
+  }
+
+  if (rhs.valueless_by_exception()) {
+    return std::strong_ordering::greater;
+  }
+
+  if (auto index_comparison = lhs.index() <=> rhs.index(); index_comparison != 0) {
+    // different alternatives active
+    return index_comparison;
+  }
+
+  return slo::visit<comparison_result>(
+      []<typename T>(T const& lhs_value, T const& rhs_value) -> comparison_result {
+        // compare values
+        return lhs_value <=> rhs_value;
+      },
+      lhs, rhs);
+}
+
+template <typename Operator>
+struct ComparisonVisitor {
+  template <typename T1, typename T2>
+  constexpr bool operator()(T1&& lhs, T2&& rhs) {
+    static_assert(std::is_convertible_v<decltype(Operator{}(std::forward<T1>(lhs), std::forward<T2>(rhs))), bool>,
+                  "relational operator result isn't implicitly convertible to bool");
+    return Operator{}(std::forward<T1>(lhs), std::forward<T2>(rhs));
+  }
+};
+
+template <template <typename...> class S1, template <typename...> class S2, typename... Ts>
+constexpr bool operator==(Variant<S1, Ts...> const& lhs, Variant<S2, Ts...> const& rhs) {
+  if (lhs.index() != rhs.index()) {
+    // different alternatives active
+    return false;
+  }
+  if (lhs.valueless_by_exception()) {
+    // both are valueless
+    return true;
+  }
+
+  return slo::visit<bool>(ComparisonVisitor<std::equal_to<>>{}, lhs, rhs);
+}
+
+template <template <typename...> class S1, template <typename...> class S2, typename... Ts>
+constexpr bool operator!=(Variant<S1, Ts...> const& lhs, Variant<S2, Ts...> const& rhs) {
+  if (lhs.index() != rhs.index()) {
+    // different alternatives active
+    return true;
+  }
+  if (lhs.valueless_by_exception()) {
+    // both are valueless
+    return false;
+  }
+
+  return slo::visit<bool>(ComparisonVisitor<std::not_equal_to<>>{}, lhs, rhs);
+}
+
+template <template <typename...> class S1, template <typename...> class S2, typename... Ts>
+constexpr bool operator<(Variant<S1, Ts...> const& lhs, Variant<S2, Ts...> const& rhs) {
+  if (rhs.valueless_by_exception()) {
+    return false;
+  }
+  if (lhs.valueless_by_exception()) {
+    return true;
+  }
+  if (lhs.index() < rhs.index()) {
+    return true;
+  }
+  if (lhs.index() > rhs.index()) {
+    return false;
+  }
+  return slo::visit<bool>(ComparisonVisitor<std::less<>>{}, lhs, rhs);
+}
+
+template <template <typename...> class S1, template <typename...> class S2, typename... Ts>
+constexpr bool operator>(Variant<S1, Ts...> const& lhs, Variant<S2, Ts...> const& rhs) {
+  if (lhs.valueless_by_exception()) {
+    return false;
+  }
+  if (rhs.valueless_by_exception()) {
+    return true;
+  }
+  if (lhs.index() > rhs.index()) {
+    return true;
+  }
+  if (lhs.index() < rhs.index()) {
+    return false;
+  }
+  return slo::visit<bool>(ComparisonVisitor<std::greater<>>{}, lhs, rhs);
+}
+
+template <template <typename...> class S1, template <typename...> class S2, typename... Ts>
+constexpr bool operator<=(Variant<S1, Ts...> const& lhs, Variant<S2, Ts...> const& rhs) {
+  if (lhs.valueless_by_exception()) {
+    return false;
+  }
+  if (rhs.valueless_by_exception()) {
+    return true;
+  }
+  if (lhs.index() < rhs.index()) {
+    return true;
+  }
+  if (lhs.index() > rhs.index()) {
+    return false;
+  }
+  return slo::visit<bool>(ComparisonVisitor<std::less_equal<>>{}, lhs, rhs);
+}
+
+template <template <typename...> class S1, template <typename...> class S2, typename... Ts>
+constexpr bool operator>=(Variant<S1, Ts...> const& lhs, Variant<S2, Ts...> const& rhs) {
+  if (rhs.valueless_by_exception()) {
+    return false;
+  }
+  if (lhs.valueless_by_exception()) {
+    return true;
+  }
+  if (lhs.index() > rhs.index()) {
+    return true;
+  }
+  if (lhs.index() < rhs.index()) {
+    return false;
+  }
+  return slo::visit<bool>(ComparisonVisitor<std::greater_equal<>>{}, lhs, rhs);
+}
+
+}  // namespace impl
+
+struct monostate {};
+
+constexpr bool operator==(monostate, monostate) noexcept {
+  return true;
+}
+constexpr std::strong_ordering operator<=>(monostate, monostate) noexcept {
+  return std::strong_ordering::equal;
+}
+
+//? [variant.helper], variant helper classes
+
+template <typename T>
+struct variant_size;
+
+template <typename T>
+struct variant_size : std::integral_constant<std::size_t, std::remove_cv_t<T>::alternatives::size> {
+  // Retrieve size from alternatives.
+  // Note that this primary template cannot be undefined as the standard mandates.
+
+  // Unfortunately constraining T causes this to error early
+  static_assert(impl::has_alternatives<std::remove_cv_t<T>>,
+                "variant_size must be used on slo::variant or its underlying storage.");
+};
+
+// Workaround for variant_size<slo::Variant<>> to compile
+template <template <typename...> class Storage, typename... Ts>
+struct variant_size<impl::Variant<Storage, Ts...>> : std::integral_constant<std::size_t, sizeof...(Ts)> {};
+
+template <template <typename...> class Storage, typename... Ts>
+struct variant_size<impl::Variant<Storage, Ts...> const> : std::integral_constant<std::size_t, sizeof...(Ts)> {};
+
+template <template <typename...> class Storage, typename... Ts>
+struct variant_size<impl::Variant<Storage, Ts...> volatile> : std::integral_constant<std::size_t, sizeof...(Ts)> {};
+
+template <template <typename...> class Storage, typename... Ts>
+struct variant_size<impl::Variant<Storage, Ts...> const volatile>
+    : std::integral_constant<std::size_t, sizeof...(Ts)> {};
+
+template <std::size_t Idx, impl::has_alternatives T>
+struct variant_alternative<Idx, T> {
+  static_assert(Idx < T::alternatives::size, "variant_alternative index out of range");
+  using type = util::type_at<Idx, typename T::alternatives>;
+};
+
+template <std::size_t Idx, impl::has_alternatives T>
+struct variant_alternative<Idx, T const> {
+  static_assert(Idx < T::alternatives::size, "variant_alternative index out of range");
+  using type = util::type_at<Idx, typename T::alternatives> const;
+};
+
+template <std::size_t Idx, impl::has_alternatives T>
+struct variant_alternative<Idx, T volatile> {
+  static_assert(Idx < T::alternatives::size, "variant_alternative index out of range");
+  using type = util::type_at<Idx, typename T::alternatives> volatile;
+};
+
+template <std::size_t Idx, impl::has_alternatives T>
+struct variant_alternative<Idx, T const volatile> {
+  static_assert(Idx < T::alternatives::size, "variant_alternative index out of range");
+  using type = util::type_at<Idx, typename T::alternatives> const volatile;
+};
+
+//? [variant.get], value access
+
+template <std::size_t Idx, template <typename...> class Storage, typename... Types>
+constexpr bool holds_alternative(impl::Variant<Storage, Types...> const& obj) noexcept {
+  // this one isn't standardized, but it's useful anyway
+  return obj.index() == Idx;
+}
+
+template <class T, template <typename...> class Storage, typename... Types>
+constexpr bool holds_alternative(impl::Variant<Storage, Types...> const& obj) noexcept {
+  return holds_alternative<util::index_of<T, typename impl::Variant<Storage, Types...>::alternatives>>(obj);
+}
+
+template <std::size_t Idx, impl::has_get V>
+constexpr decltype(auto) get_unchecked(V&& variant_) noexcept {
+  return std::forward<V>(variant_).template get<Idx>();
+}
+
+template <typename T, impl::has_get V>
+constexpr decltype(auto) get_unchecked(V&& variant_) noexcept {
+  return std::forward<V>(variant_).template get<T>();
+}
+
+template <std::size_t Idx, impl::has_get V>
+constexpr decltype(auto) get(V&& variant_) {
+  if (variant_.index() != Idx) [[unlikely]] {
+    impl::throw_bad_variant_access(variant_.valueless_by_exception());
+  }
+  return std::forward<V>(variant_).template get<Idx>();
+}
+
+template <typename T, impl::has_get V>
+constexpr decltype(auto) get(V&& variant_) {
+  return std::forward<V>(variant_).template get<T>();
+}
+
+template <std::size_t Idx, impl::has_get V>
+constexpr auto* get_if(V* variant_) noexcept {
+  static_assert(Idx < std::remove_cvref_t<V>::alternatives::size, "index must be in [0, number of alternatives)");
+  static_assert(!std::is_void_v<variant_alternative_t<Idx, std::remove_cvref_t<V>>>,
+                "alternative type must not be void");
+
+  if (variant_ && variant_->index() == Idx) {
+    return std::addressof(slo::get_unchecked<Idx>(*variant_));
+  }
+  return nullptr;
+}
+
+template <typename T, impl::has_get V>
+constexpr auto* get_if(V* variant_) noexcept {
+  constexpr static std::size_t index = util::index_of<T, typename std::remove_cvref_t<V>::alternatives>;
+  static_assert(index < std::remove_cvref_t<V>::alternatives::size, "T must occur exactly once in alternatives");
+  return get_if<index>(variant_);
+}
+
+template <typename R, typename F, typename... Vs>
+constexpr decltype(auto) visit(F&& visitor, Vs&&... variants) {
+  if constexpr (sizeof...(Vs) == 0) {
+    return std::forward<F>(visitor)();
+  } else {
+    constexpr std::size_t max_index = impl::VisitImpl<Vs...>::max_index;
+    constexpr int strategy          = max_index > 256          ? -1
+                                      : USING(SLO_MACRO_VISIT) ? max_index <= 4    ? 1
+                                                                 : max_index <= 16 ? 2
+                                                                 : max_index <= 64 ? 3
+                                                                                   : 4
+                                                               : 0;
+    using visit_helper              = impl::VisitStrategy<strategy>;
+    return visit_helper::template visit<R>(std::forward<F>(visitor), std::forward<Vs>(variants)...);
+  }
+}
+
+template <typename F, typename... Vs>
+constexpr decltype(auto) visit(F&& visitor, Vs&&... variants) {
+  using return_type = impl::visit_result_t<F, Vs...>;
+  return slo::visit<return_type>(std::forward<F>(visitor), std::forward<Vs>(variants)...);
+}
+
+namespace impl {
+template <template <bool, typename...> class Generator>
+struct GeneratorWrapper {
+  template <typename... Ts>
+  using type = Generator<(... && std::is_trivially_destructible_v<Ts>), Ts...>;
+};
+
+template <typename... Ts>
+using UnionGenerator = typename util::ConditionalTemplate<sizeof...(Ts) < SLO_TREE_THRESHOLD,
+                                                          GeneratorWrapper<RecursiveUnion>::type,
+                                                          GeneratorWrapper<TreeUnion>::type>::template type<Ts...>;
+
+template <template <typename...> class Generator, template <template <typename...> class, typename...> class Storage>
+struct StorageWrapper {
+  template <typename... Ts>
+  using type = Storage<Generator, Ts...>;
+};
+
+template <typename... Ts>
+using VariantStorage =
+    typename util::ConditionalTemplate<HAS_IS_WITHIN_LIFETIME && (std::is_standard_layout_v<Ts> && ...),
+                                       StorageWrapper<UnionGenerator, InvertedStorage>::type,
+                                       StorageWrapper<UnionGenerator, Storage>::type>::template type<Ts...>;
+}  // namespace impl
+
+/**
+ * @brief This implementation of variant uses a recursively defined union under the hood.
+ *
+ * @tparam Ts Alternative types
+ */
+template <typename... Ts>
+using NormalVariant = impl::Variant<impl::StorageWrapper<impl::UnionGenerator, impl::Storage>::type, Ts...>;
+
+template <typename... Ts>
+using RecursiveVariant =
+    impl::Variant<impl::StorageWrapper<impl::GeneratorWrapper<impl::RecursiveUnion>::type, impl::Storage>::type, Ts...>;
+
+template <typename... Ts>
+using TreeVariant =
+    impl::Variant<impl::StorageWrapper<impl::GeneratorWrapper<impl::TreeUnion>::type, impl::Storage>::type, Ts...>;
+
+/**
+ * @brief This implementation of variant hides the index in the actual alternative types
+ *        hence inverting the variant.
+ * @warning Your compiler must support C++26 `std::is_within_lifetime` for this to work in
+ *          constant evaluated context. If your compiler has an intrinsic that can be used to
+ *          implement `is_within_lifetime`, it will be used.
+ *
+ * @tparam Ts Alternative types
+ */
+
+template <typename... Ts>
+using InvertedVariant = impl::Variant<impl::StorageWrapper<impl::UnionGenerator, impl::InvertedStorage>::type, Ts...>;
+
+template <typename... Ts>
+using InvertedRecursiveVariant =
+    impl::Variant<impl::StorageWrapper<impl::GeneratorWrapper<impl::RecursiveUnion>::type, impl::InvertedStorage>::type,
+                  Ts...>;
+
+template <typename... Ts>
+using InvertedTreeVariant =
+    impl::Variant<impl::StorageWrapper<impl::GeneratorWrapper<impl::TreeUnion>::type, impl::InvertedStorage>::type,
+                  Ts...>;
+
+/**
+ * @brief If the compiler supports `std::is_within_lifetime` or has an intrinsic
+ *        that can be used to implement this, this type will use the inverted
+ *        storage strategy to reduce padding as much as possible.
+ *
+ * @tparam Ts Alternative types
+ */
+template <typename... Ts>
+using Variant = impl::Variant<impl::VariantStorage, Ts...>;
+
+/**
+ * @brief Same as slo::Variant. Provided for compatibility with `std::variant`.
+ *
+ * @tparam Ts Alternative types
+ */
+template <typename... Ts>
+using variant = Variant<Ts...>;
+
+/**
+ * @brief This variant implementation does not generate the underlying union,
+ *        instead it is templated over pointers to non-static data members
+ *        of an existing complete union type.
+ * @warning All template arguments must refer to pointers to non-static data members of the same union.
+ * @tparam Ptrs Pointers to non-static data members of a union
+ */
+template <auto... Ptrs>
+using Union = impl::Variant<impl::detail::StorageProxy, impl::detail::MemberPtr<Ptrs>...>;
+
+template <typename... Ts, typename... Args>
+Variant<Ts...> make_variant(Args&&... args) {
+  return {std::forward<Args>(args)...};
+}
+
+template <auto... Ptrs, typename... Args>
+Union<Ptrs...> make_variant(Args&&... args) {
+  return {std::forward<Args>(args)...};
+}
+}  // namespace slo
+
+template <>
+struct std::hash<slo::monostate> {
+  using result_type   = std::size_t;
+  using argument_type = slo::monostate;
+
+  std::size_t operator()(const slo::monostate&) const noexcept {
+    constexpr static std::size_t monostate_hash = 0xb03c924ec92d7c6f;
+    return monostate_hash;
+  }
+};
+
+template <template <typename...> class Storage, typename... Ts>
+  requires(slo::util::is_hashable<Ts> && ...)
+struct std::hash<slo::impl::Variant<Storage, Ts...>> {
+  using result_type   = std::size_t;
+  using argument_type = slo::impl::Variant<Storage, Ts...>;
+
+  std::size_t operator()(argument_type const& obj) const
+      noexcept((std::is_nothrow_invocable_v<std::hash<std::remove_const_t<Ts>>, Ts const&> && ...)) {
+    if (obj.valueless_by_exception()) {
+      constexpr static std::size_t valueless_hash = 0x22c08c8cbcae8fc4;
+      return valueless_hash;
+    }
+    return obj.index() +
+           slo::visit([]<typename T>(T const& value) { return std::hash<std::remove_cvref_t<T>>{}(value); }, obj);
+  }
+};
\ No newline at end of file
diff --git a/palgen.toml b/palgen.toml
new file mode 100644
index 0000000..efabf87
--- /dev/null
+++ b/palgen.toml
@@ -0,0 +1,21 @@
+[palgen]
+output = "build"
+
+[palgen.extensions]
+folders = ["tools"]
+inline = false
+
+[project]
+name = "slo"
+version = "0.1"
+sources = ["include", "benchmark"]
+
+[benchmark]
+output = "build"
+system_includes = ["include"]
+repeat_each = 5
+standard = "c++26"
+
+[amalgamate]
+root = "slo/variant.h"
+filename = "amalgamated.h"
\ No newline at end of file
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 0000000..85b15ec
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(slo_test PRIVATE 
+  main.cpp
+)
+
+add_subdirectory(variant)
+add_subdirectory(union)
+add_subdirectory(util)
+
+target_include_directories(slo_test PRIVATE .)
\ No newline at end of file
diff --git a/test/common/assertions.h b/test/common/assertions.h
new file mode 100644
index 0000000..0f7c937
--- /dev/null
+++ b/test/common/assertions.h
@@ -0,0 +1,29 @@
+#pragma once
+#include <gtest/gtest.h>
+#include "type_name.h"
+
+#define DEPAREN(X) ESC(ISH X)
+#define ISH(...)   ISH __VA_ARGS__
+#define ESC(...)   ESC_(__VA_ARGS__)
+#define ESC_(...)  VAN##__VA_ARGS__
+#define VANISH
+
+#define ASSERT_SAME(first, second)                                                                                 \
+  ASSERT_TRUE((std::is_same_v<DEPAREN(first), DEPAREN(second)>)) << "  Actual: " << nameof<DEPAREN(first)> << '\n' \
+                                                                 << "Expected: " << nameof<DEPAREN(second)>
+
+#define ASSERT_STATIC(...) ASSERT_SAME(std::bool_constant<(__VA_ARGS__)>, std::true_type)
+
+#define ASSERT_NOEXCEPT(...) ASSERT_TRUE((noexcept(__VA_ARGS__))) << "Operation must be noexcept"
+#define ASSERT_NOT_NOEXCEPT(...) ASSERT_FALSE((noexcept(__VA_ARGS__))) << "Operation must not be noexcept"
+
+#define TEST_T(test_suite_name, test_name, ...)                \
+  template <typename>                                          \
+  void test_suite_name##_##test_name##_ptest_body();           \
+  TEST(test_suite_name, test_name) {                           \
+    []<typename... Ts>() {                                     \
+      (..., test_suite_name##_##test_name##_ptest_body<Ts>()); \
+    }.template operator()<__VA_ARGS__>();                      \
+  }                                                            \
+  template <typename TypeParam>                                \
+  void test_suite_name##_##test_name##_ptest_body()
diff --git a/test/common/const_string.h b/test/common/const_string.h
new file mode 100644
index 0000000..4d14ceb
--- /dev/null
+++ b/test/common/const_string.h
@@ -0,0 +1,52 @@
+#pragma once
+#include <cstddef>
+#include <algorithm>
+#include <string_view>
+#include <string>
+
+template <std::size_t N>
+struct [[nodiscard]] const_string {
+  char value[N + 1]{};
+  constexpr static auto size = N;
+
+  constexpr const_string() = default;
+
+  constexpr explicit(false) const_string(char const (&literal)[N + 1]) {  // NOLINT
+    std::copy(literal, literal + N, std::begin(value));
+  }
+
+  constexpr explicit const_string(std::string_view data) { std::copy(begin(data), end(data), std::begin(value)); }
+  [[nodiscard]] constexpr explicit operator std::string_view() const noexcept { return std::string_view{value}; }
+  [[nodiscard]] constexpr explicit operator char const*() const noexcept { return value; }
+
+  [[nodiscard]] constexpr auto to_sv() const noexcept { return std::string_view{value}; }
+  [[nodiscard]] constexpr bool empty() const noexcept { return size == 0; }
+
+  [[nodiscard]] constexpr char const& operator[](std::size_t Idx) const { return value[Idx]; }
+  friend constexpr bool operator==(const_string lhs, std::string_view rhs) noexcept { return lhs.to_sv() == rhs; }
+  [[nodiscard]]constexpr std::size_t length() const { return std::char_traits<char>::length(value); }
+};
+
+template <>
+struct [[nodiscard]] const_string<0> {
+  constexpr static auto size = 0;
+
+  constexpr const_string() = default;
+
+  [[nodiscard]] constexpr explicit operator std::string_view() const noexcept { return std::string_view{}; }
+  [[nodiscard]] constexpr explicit operator char const*() const noexcept { return nullptr; }
+
+  [[nodiscard]] constexpr auto to_sv() const noexcept { return std::string_view{}; }
+  [[nodiscard]] constexpr bool empty() const noexcept { return true; }
+
+  friend constexpr bool operator==(const_string<0>, const_string<0>) noexcept { return true; }
+  template <std::size_t N>
+  friend constexpr bool operator==(const_string<0>, const_string<N>) noexcept { return false; }
+  
+  template <std::size_t N>
+  friend constexpr bool operator==(const_string, std::string_view str) noexcept { return str.empty(); }
+  [[nodiscard]] constexpr std::size_t length() const { return 0; }
+};
+
+template <std::size_t N>
+const_string(char const (&)[N]) -> const_string<N - 1>;
\ No newline at end of file
diff --git a/test/common/fixtures/helpers.h b/test/common/fixtures/helpers.h
new file mode 100644
index 0000000..dbef1d1
--- /dev/null
+++ b/test/common/fixtures/helpers.h
@@ -0,0 +1,7 @@
+#pragma once
+#include <gtest/gtest.h>
+#include <common/util.h>
+
+template <typename T>
+struct Helpers : testing::Test {};
+TYPED_TEST_SUITE(Helpers, test_variants);
\ No newline at end of file
diff --git a/test/common/lifetime.h b/test/common/lifetime.h
new file mode 100644
index 0000000..667ba04
--- /dev/null
+++ b/test/common/lifetime.h
@@ -0,0 +1,88 @@
+#pragma once
+#include <cstdio>
+#include <vector>
+#include <gmock/gmock.h>
+
+struct State {
+  enum Event { DefaultCtor, Ctor, CopyCtor, MoveCtor, Dtor, CopyAssign, MoveAssign, Visit } event;
+  std::size_t id;
+
+  State(Event event_, std::size_t id_): event(event_), id(id_){}
+
+  static char const* to_string(Event obj) {
+    switch (obj) {
+      case DefaultCtor: return "DefaultCtor";
+      case Ctor: return "Ctor";
+      case CopyCtor: return "CopyCtor";
+      case MoveCtor: return "MoveCtor";
+      case Dtor: return "Dtor";
+      case CopyAssign: return "CopyAssign";
+      case MoveAssign: return "MoveAssign";
+      case Visit: return "Visit";
+      default: return "unknown action";
+    }
+  }
+
+  friend bool operator==(State const& lhs, State const& rhs) { return (lhs.id == rhs.id) && (lhs.event == rhs.event); }
+  friend void PrintTo(State const& obj, std::ostream* os) {
+    *os << '{' << State::to_string(obj.event) << ", " << obj.id << '}';
+  }
+};
+
+class LifetimeTracker {
+private:
+  LifetimeTracker()  = default;
+  ~LifetimeTracker() = default;
+
+  std::vector<State> states;
+
+public:
+  LifetimeTracker(LifetimeTracker const&)            = delete;
+  LifetimeTracker(LifetimeTracker&&)                 = delete;
+  LifetimeTracker& operator=(LifetimeTracker const&) = delete;
+  LifetimeTracker& operator=(LifetimeTracker&&)      = delete;
+
+  static LifetimeTracker& instance() {
+    static LifetimeTracker obj{};
+    return obj;
+  }
+
+  static std::vector<State> const& get() { return instance().states; }
+
+  static void append(State state) { instance().states.push_back(state); }
+
+  static void reset() { instance().states.clear(); }
+
+  [[nodiscard]] static bool matches(std::vector<State> const& other) { return instance().states == other; }
+  [[nodiscard]] static bool is_empty() { return instance().states.empty(); }
+
+  static void assert_equal(std::vector<State> const& other) {
+    ASSERT_THAT(get(), testing::ElementsAreArray(other));
+    reset();
+  }
+
+  static void print() {
+    for (auto&& [event, id] : instance().states) {
+      fprintf(stderr, "%zu - %s\n", id, State::to_string(event));
+    }
+  }
+};
+
+template <std::size_t V>
+struct Lifetime {
+  static constexpr auto value = V;
+
+  Lifetime() { LifetimeTracker::append({State::DefaultCtor, V}); }
+  constexpr explicit Lifetime(int) { LifetimeTracker::append({State::Ctor, V}); }
+  constexpr Lifetime(Lifetime const&) { LifetimeTracker::append({State::CopyCtor, V}); }
+  constexpr Lifetime(Lifetime&&) { LifetimeTracker::append({State::MoveCtor, V}); }
+  ~Lifetime() { LifetimeTracker::append({State::Dtor, V}); }
+  constexpr Lifetime& operator=(Lifetime const&) {
+    LifetimeTracker::append({State::CopyAssign, V});
+    return *this;
+  }
+  constexpr Lifetime& operator=(Lifetime&&) {
+    LifetimeTracker::append({State::MoveAssign, V});
+    return *this;
+  }
+};
\ No newline at end of file
diff --git a/test/common/qualifiers.h b/test/common/qualifiers.h
new file mode 100644
index 0000000..b8780dc
--- /dev/null
+++ b/test/common/qualifiers.h
@@ -0,0 +1,33 @@
+#pragma once
+#include <iostream>
+
+struct Qualifiers {
+  enum CV {
+    None     = 0,
+    Const    = 1,
+    Volatile = 2
+  } qualifiers {None};
+
+  enum Category {
+    Lvalue,
+    Rvalue
+  } category {Lvalue};
+
+  friend auto operator<=>(Qualifiers const&, Qualifiers const&) noexcept = default;
+  friend std::ostream& operator<<(std::ostream& stream, Qualifiers const& self){
+    if ((self.qualifiers & Const) != 0){
+      stream << "const ";
+    } 
+    if ((self.qualifiers & Volatile) != 0){
+      stream << "volatile ";
+    }
+
+    if (self.category == Lvalue) {
+      stream << "lvalue";
+    } else if (self.category == Rvalue) {
+      stream << "rvalue";
+    }
+
+    return stream;
+  }
+};
\ No newline at end of file
diff --git a/test/common/type_name.h b/test/common/type_name.h
new file mode 100644
index 0000000..f9eeb15
--- /dev/null
+++ b/test/common/type_name.h
@@ -0,0 +1,32 @@
+#pragma once
+#include <cstddef>
+#include <string_view>
+#include "const_string.h"
+
+namespace detail {
+template <typename T>
+constexpr auto get_ctti() {
+#if defined(_MSC_VER)
+  constexpr auto prefix = std::string_view{"get_ctti<"};
+  constexpr auto suffix = std::string_view{">(void)"};
+  constexpr auto signature    = std::string_view{__FUNCSIG__};
+#else
+  constexpr auto prefix = std::string_view{"T = "};
+  constexpr auto suffix = std::string_view{"]"};
+  constexpr auto signature    = std::string_view{__PRETTY_FUNCTION__};
+#endif
+
+  constexpr std::size_t start = signature.find(prefix) + prefix.size();
+  constexpr std::size_t end   = signature.find(suffix, start);
+
+  constexpr auto value = signature.substr(start, end - start);
+  return const_string<value.size()>(value);
+}
+
+template <typename T>
+constexpr inline auto raw_type_name = get_ctti<T>();
+
+}  // namespace detail
+
+template <typename T>
+constexpr inline auto nameof = std::string_view{detail::raw_type_name<T>};
diff --git a/test/common/util.h b/test/common/util.h
new file mode 100644
index 0000000..5dcc84e
--- /dev/null
+++ b/test/common/util.h
@@ -0,0 +1,28 @@
+#pragma once
+#include <gtest/gtest.h>
+#include <slo/variant.h>
+
+template <auto V>
+struct Constant {
+  static constexpr auto value = V;
+};
+
+
+template <template <typename...> class Variant>
+struct VariantWrapper {
+  template <typename... Ts>
+  using type = Variant<Ts...>;
+};
+
+using test_variants = testing::Types<VariantWrapper<slo::NormalVariant>,
+                                     VariantWrapper<slo::RecursiveVariant>,
+                                     VariantWrapper<slo::TreeVariant>,
+
+                                     VariantWrapper<slo::InvertedVariant>,
+                                     VariantWrapper<slo::InvertedRecursiveVariant>,
+                                     VariantWrapper<slo::InvertedTreeVariant>,
+
+                                     VariantWrapper<slo::Variant> >;
+
+template <typename T, typename... Ts>
+using get_variant = typename T::template type<Ts...>;
\ No newline at end of file
diff --git a/test/main.cpp b/test/main.cpp
new file mode 100644
index 0000000..e950428
--- /dev/null
+++ b/test/main.cpp
@@ -0,0 +1,24 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+
+TEST(Dummy, AlwaysPasses) {
+  ASSERT_TRUE(true);
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+
+extern "C" {
+void __ubsan_on_report() {
+  FAIL() << "Encountered an undefined behavior sanitizer error";
+}
+void __asan_on_error() {
+  FAIL() << "Encountered an address sanitizer error";
+}
+void __tsan_on_report() {
+  FAIL() << "Encountered a thread sanitizer error";
+}
+}  // extern "C"
\ No newline at end of file
diff --git a/test/union/CMakeLists.txt b/test/union/CMakeLists.txt
new file mode 100644
index 0000000..5fcaa93
--- /dev/null
+++ b/test/union/CMakeLists.txt
@@ -0,0 +1 @@
+target_sources(slo_test PRIVATE recursive.cpp tree.cpp)
\ No newline at end of file
diff --git a/test/union/recursive.cpp b/test/union/recursive.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/test/union/tree.cpp b/test/union/tree.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/test/util/CMakeLists.txt b/test/util/CMakeLists.txt
new file mode 100644
index 0000000..f57c899
--- /dev/null
+++ b/test/util/CMakeLists.txt
@@ -0,0 +1 @@
+target_sources(slo_test PRIVATE forward_like.cpp list.cpp)
diff --git a/test/util/forward_like.cpp b/test/util/forward_like.cpp
new file mode 100644
index 0000000..01de029
--- /dev/null
+++ b/test/util/forward_like.cpp
@@ -0,0 +1,66 @@
+#include <gtest/gtest.h>
+#include <slo/util/compat.h>
+#include <common/assertions.h>
+struct In;
+struct Out;
+#define CHECK(T, U, R) ASSERT_SAME((slo::compat::like_t<T, U>), R)
+
+// P2445R1  8.1 and 8.2 "merge" model
+// clang-format off
+
+TEST(ForwardLike, Value){
+  CHECK(In,         Out,         Out&&);        // 8.1) 1
+  CHECK(In,         Out&,        Out&&);        // 8.2) 19
+  CHECK(In,         Out&&,       Out&&);        // 8.2) 24
+  CHECK(In,         Out const,   Out const&&);  // 8.1) 7
+  CHECK(In,         Out const&,  Out const&&);  // 8.2) 29
+  CHECK(In,         Out const&&, Out const&&);  // 8.2) 33
+}
+
+TEST(ForwardLike, Lvref){
+  CHECK(In&,        Out,         Out&);         // 8.1) 2
+  CHECK(In&,        Out&,        Out&);         // 8.1) 13
+  CHECK(In&,        Out&&,       Out&);         // 8.1) 14
+  CHECK(In&,        Out const,   Out const&);   // 8.1) 8
+  CHECK(In&,        Out const&,  Out const&);   // 8.1) 15
+  CHECK(In&,        Out const&&, Out const&);   // 8.1) 16
+}
+
+TEST(ForwardLike, Rvref){
+  CHECK(In&&,       Out,         Out&&);        // 8.1) 3
+  CHECK(In&&,       Out&,        Out&&);        // 8.2) 20
+  CHECK(In&&,       Out&&,       Out&&);        // 8.2) 25
+  CHECK(In&&,       Out const,   Out const&&);  // 8.1) 9
+  CHECK(In&&,       Out const&,  Out const&&);  // 8.2) 30
+  CHECK(In&&,       Out const&&, Out const&&);  // 8.2) 34
+}
+
+TEST(ForwardLike, ConstValue){
+  CHECK(In const,   Out,         Out const&&);  // 8.1) 4
+  CHECK(In const,   Out&,        Out const&&);  // 8.2) 21
+  CHECK(In const,   Out&&,       Out const&&);  // 8.2) 26
+  CHECK(In const,   Out const,   Out const&&);  // 8.1) 10
+  CHECK(In const,   Out const&,  Out const&&);  // 8.2) 31
+  CHECK(In const,   Out const&&, Out const&&);  // 8.2) 35
+}
+
+TEST(ForwardLike, ConstLvref){
+  CHECK(In const&,  Out,         Out const&);   // 8.1) 5
+  CHECK(In const&,  Out&,        Out const&);   // 8.2) 22
+  CHECK(In const&,  Out&&,       Out const&);   // 8.2) 27
+  CHECK(In const&,  Out const,   Out const&);   // 8.1) 11
+  CHECK(In const&,  Out const&,  Out const&);   // 8.1) 17
+  CHECK(In const&,  Out const&&, Out const&);   // 8.1) 18
+}
+
+TEST(ForwardLike, ConstRvref){
+  CHECK(In const&&, Out,         Out const&&);  // 8.1) 6
+  CHECK(In const&&, Out&,        Out const&&);  // 8.2) 23
+  CHECK(In const&&, Out&&,       Out const&&);  // 8.2) 28
+  CHECK(In const&&, Out const,   Out const&&);  // 8.1) 12
+  CHECK(In const&&, Out const&,  Out const&&);  // 8.2) 32
+  CHECK(In const&&, Out const&&, Out const&&);  // 8.2) 36
+}
+
+// clang-format on
+#undef CHECK
\ No newline at end of file
diff --git a/test/util/list.cpp b/test/util/list.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/test/variant/CMakeLists.txt b/test/variant/CMakeLists.txt
new file mode 100644
index 0000000..1500909
--- /dev/null
+++ b/test/variant/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(slo_test PRIVATE 
+  lifetime.cpp 
+  special_members.cpp
+  padding.cpp)
+
+add_subdirectory(variant.bad.access)
+add_subdirectory(variant.get)
+add_subdirectory(variant.helper)
+add_subdirectory(variant.visit)
+add_subdirectory(variant.ctor)
+add_subdirectory(variant.hash)
\ No newline at end of file
diff --git a/test/variant/lifetime.cpp b/test/variant/lifetime.cpp
new file mode 100644
index 0000000..d5421dc
--- /dev/null
+++ b/test/variant/lifetime.cpp
@@ -0,0 +1,125 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <utility>
+#include <variant>
+
+#include <slo/variant.h>
+#include <common/lifetime.h>
+
+template <typename T>
+struct LifetimeTest : public testing::Test {
+  using type = T;
+};
+
+template <template <typename...> class T, std::size_t... Idx>
+auto get_test_type(std::index_sequence<Idx...>) {
+  return std::type_identity<T<Lifetime<Idx>...>>{};
+}
+template <template <typename...> class T, std::size_t Count>
+using test_type = typename decltype(get_test_type<T>(std::make_index_sequence<Count>()))::type;
+
+union Bare {
+  Lifetime<0> alt_0;
+  Lifetime<1> alt_1;
+  Lifetime<2> alt_2;
+  Lifetime<3> alt_3;
+  Lifetime<4> alt_4;
+
+  Bare() {}
+  ~Bare() {}
+};
+
+using test_types = testing::Types<test_type<std::variant, 5>,  // control
+                                  test_type<slo::InvertedRecursiveVariant, 5>,
+                                  test_type<slo::InvertedTreeVariant, 5>,
+                                  test_type<slo::RecursiveVariant, 5>,
+                                  test_type<slo::TreeVariant, 5>,
+                                  slo::Union<&Bare::alt_0, &Bare::alt_1, &Bare::alt_2, &Bare::alt_3, &Bare::alt_4>>;
+TYPED_TEST_SUITE(LifetimeTest, test_types);
+
+TYPED_TEST(LifetimeTest, DefaultCtor) {
+  LifetimeTracker::reset();
+  { auto obj = TypeParam{}; }
+  LifetimeTracker::assert_equal({{State::DefaultCtor, 0}, {State::Dtor, 0}});
+}
+
+TYPED_TEST(LifetimeTest, Ctor) {
+  LifetimeTracker::reset();
+  {
+    auto obj = TypeParam{std::in_place_index<1>, 123};
+    ASSERT_EQ(obj.index(), 1);
+  }
+
+  ASSERT_FALSE(LifetimeTracker::is_empty());
+  LifetimeTracker::assert_equal({{State::Ctor, 1}, {State::Dtor, 1}});
+}
+
+TYPED_TEST(LifetimeTest, Copy) {
+  {
+    auto obj = TypeParam{std::in_place_index<1>, 123};
+    ASSERT_EQ(obj.index(), 1);
+    ASSERT_FALSE(LifetimeTracker::is_empty());
+    LifetimeTracker::assert_equal({{State::Ctor, 1}});
+
+    { auto obj2 = TypeParam{obj}; }
+    LifetimeTracker::assert_equal({{State::CopyCtor, 1}, {State::Dtor, 1}});
+
+    {
+      TypeParam target{std::in_place_index<0>, 1};
+      target = obj;
+    }
+
+    LifetimeTracker::assert_equal({{State::Ctor, 0}, {State::Dtor, 0}, {State::CopyCtor, 1}, {State::Dtor, 1}});
+  }
+
+  LifetimeTracker::assert_equal({{State::Dtor, 1}});
+}
+
+TYPED_TEST(LifetimeTest, MoveCtor) {
+  {
+    auto obj = TypeParam{std::in_place_index<1>, 123};
+    ASSERT_EQ(obj.index(), 1);
+    ASSERT_FALSE(LifetimeTracker::is_empty());
+
+    LifetimeTracker::assert_equal({{State::Ctor, 1}});
+    { auto obj2 = TypeParam{std::move(obj)}; }
+    LifetimeTracker::assert_equal({{State::MoveCtor, 1}, {State::Dtor, 1}});
+  }
+
+  LifetimeTracker::assert_equal({{State::Dtor, 1}});
+}
+
+TYPED_TEST(LifetimeTest, MoveAssign) {
+  {
+    auto obj = TypeParam{std::in_place_index<1>, 123};
+    ASSERT_EQ(obj.index(), 1);
+    ASSERT_FALSE(LifetimeTracker::is_empty());
+    LifetimeTracker::assert_equal({{State::Ctor, 1}});
+
+    {
+      TypeParam target{std::in_place_index<0>, 123};
+      target = std::move(obj);
+    }
+
+    LifetimeTracker::assert_equal({{State::Ctor, 0}, {State::Dtor, 0}, {State::MoveCtor, 1}, {State::Dtor, 1}});
+  }
+
+  LifetimeTracker::assert_equal({{State::Dtor, 1}});
+}
+
+TYPED_TEST(LifetimeTest, Emplace) {
+  ASSERT_TRUE(LifetimeTracker::is_empty());
+  {
+    auto obj = TypeParam{std::in_place_index<1>, 123};
+    ASSERT_EQ(obj.index(), 1);
+    ASSERT_FALSE(LifetimeTracker::is_empty());
+    LifetimeTracker::assert_equal({{State::Ctor, 1}});
+
+    obj.template emplace<Lifetime<0>>(Lifetime<0>{0});
+    LifetimeTracker::assert_equal({{State::Ctor, 0}, {State::Dtor, 1}, {State::MoveCtor, 0}, {State::Dtor, 0}});
+
+    obj.template emplace<1>(1);
+    LifetimeTracker::assert_equal({{State::Dtor, 0}, {State::Ctor, 1}});
+  }
+  LifetimeTracker::assert_equal({{State::Dtor, 1}});
+}
diff --git a/test/variant/padding.cpp b/test/variant/padding.cpp
new file mode 100644
index 0000000..6f66050
--- /dev/null
+++ b/test/variant/padding.cpp
@@ -0,0 +1,47 @@
+#include <type_traits>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#define SLO_HIDE_IN_PADDING ON
+#include <slo/variant.h>
+
+
+TEST(Padding, Inverted) {
+  using normal = std::variant<char[7], float>;
+  using compressed = slo::InvertedVariant<char[7], float>;
+  ASSERT_LT(sizeof(compressed), sizeof(normal));
+}
+
+union StandardLayout {
+  char first[5];
+  float second;
+  private:
+  char dummy;
+};
+
+TEST(Padding, Proxy) {
+  using normal = std::variant<char[5], float>;
+  using compressed = slo::Union<&StandardLayout::first, &StandardLayout::second>;
+  
+  ASSERT_LT(sizeof(compressed), sizeof(normal));
+}
+
+struct NotStandardLayout {
+  [[no_unique_address]]  char data[5];
+  NotStandardLayout() = default;
+private:
+  char dummy;
+};
+static_assert(!std::is_standard_layout_v<NotStandardLayout>);
+
+union Test2 {
+  NotStandardLayout first;
+  float second;
+};
+
+TEST(Padding, non_standard_layout) {
+  using normal = std::variant<NotStandardLayout, float>;
+  using compressed = slo::Union<&Test2::first, &Test2::second>;
+  ASSERT_LT(sizeof(compressed), sizeof(normal));
+}
\ No newline at end of file
diff --git a/test/variant/special_members.cpp b/test/variant/special_members.cpp
new file mode 100644
index 0000000..8825e3a
--- /dev/null
+++ b/test/variant/special_members.cpp
@@ -0,0 +1,101 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <type_traits>
+#include <string>
+#include <memory>
+#include <slo/variant.h>
+
+enum State { DELETED, DEFINED, TRIVIAL };
+
+struct Traits {
+  State destructor;
+  State copy_constructor;
+  State move_constructor;
+  State copy_assignment;
+  State move_assignment;
+
+  template <typename T>
+  void verify() const {
+    ASSERT_EQ(std::is_destructible_v<T>, destructor != DELETED);
+    ASSERT_EQ(std::is_trivially_destructible_v<T>, destructor == TRIVIAL);
+    ASSERT_EQ(std::is_copy_constructible_v<T>, copy_constructor != DELETED);
+    ASSERT_EQ(std::is_trivially_copy_constructible_v<T>, copy_constructor == TRIVIAL);
+    ASSERT_EQ(std::is_move_constructible_v<T>, move_constructor != DELETED);
+    ASSERT_EQ(std::is_trivially_move_constructible_v<T>, move_constructor == TRIVIAL);
+    ASSERT_EQ(std::is_copy_assignable_v<T>, copy_assignment != DELETED);
+    ASSERT_EQ(std::is_trivially_copy_assignable_v<T>, copy_assignment == TRIVIAL);
+    ASSERT_EQ(std::is_move_assignable_v<T>, move_assignment != DELETED);
+    ASSERT_EQ(std::is_trivially_move_assignable_v<T>, move_assignment == TRIVIAL);
+  }
+};
+
+
+union Trivial {
+  int foo;
+  char bar;
+};
+
+TEST(SpecialMembers, Trivial) {
+  using standard = std::variant<int, char>;
+  using normal   = slo::NormalVariant<int, char>;
+  using inverted = slo::InvertedVariant<int, char>;
+  using proxy    = slo::Union<&Trivial::foo, &Trivial::bar>;
+
+  auto expected = Traits{.destructor       = TRIVIAL,
+                         .copy_constructor = TRIVIAL,
+                         .move_constructor = TRIVIAL,
+                         .copy_assignment  = TRIVIAL,
+                         .move_assignment  = TRIVIAL};
+
+  expected.verify<standard>();
+  expected.verify<normal>();
+  expected.verify<inverted>();
+  expected.verify<proxy>();
+}
+
+
+union NonTrivial {
+  int foo;
+  std::string bar;
+};
+
+TEST(SpecialMembers, NonTrivial) {
+  using standard = std::variant<int, std::string>;
+  using normal   = slo::NormalVariant<int, std::string>;
+  using inverted = slo::InvertedVariant<int, std::string>;
+  using proxy    = slo::Union<&NonTrivial::foo, &NonTrivial::bar>;
+
+  auto expected = Traits{.destructor       = DEFINED,
+                         .copy_constructor = DEFINED,
+                         .move_constructor = DEFINED,
+                         .copy_assignment  = DEFINED,
+                         .move_assignment  = DEFINED};
+
+  expected.verify<standard>();
+  expected.verify<normal>();
+  expected.verify<inverted>();
+  expected.verify<proxy>();
+}
+
+
+union MoveOnly {
+  int foo;
+  std::unique_ptr<int> bar;
+};
+
+TEST(SpecialMembers, MoveOnly) {
+  using standard = std::variant<int, std::unique_ptr<int>>;
+  using normal   = slo::NormalVariant<int, std::unique_ptr<int>>;
+  using proxy    = slo::Union<&MoveOnly::foo, &MoveOnly::bar>;
+
+  auto expected = Traits{.destructor       = DEFINED,
+                         .copy_constructor = DELETED,
+                         .move_constructor = DEFINED,
+                         .copy_assignment  = DELETED,
+                         .move_assignment  = DEFINED};
+
+  expected.verify<standard>();
+  expected.verify<normal>();
+  expected.verify<proxy>();
+}
\ No newline at end of file
diff --git a/test/variant/variant.bad.access/CMakeLists.txt b/test/variant/variant.bad.access/CMakeLists.txt
new file mode 100644
index 0000000..663fb7f
--- /dev/null
+++ b/test/variant/variant.bad.access/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(slo_test PRIVATE 
+  bad_variant_access.cpp
+)
\ No newline at end of file
diff --git a/test/variant/variant.bad.access/bad_variant_access.cpp b/test/variant/variant.bad.access/bad_variant_access.cpp
new file mode 100644
index 0000000..0c62b9a
--- /dev/null
+++ b/test/variant/variant.bad.access/bad_variant_access.cpp
@@ -0,0 +1,15 @@
+#include <type_traits>
+#include <exception>
+#include <variant>
+
+#include <gtest/gtest.h>
+#include <slo/variant.h>
+
+TEST(Exception, BadVariantAccess) {
+  ASSERT_TRUE((std::is_base_of_v<std::exception, slo::bad_variant_access>));
+  ASSERT_TRUE(noexcept(std::bad_variant_access{})) << "bad_variant_access default ctor must be noexcept";
+  ASSERT_TRUE(noexcept(std::bad_variant_access{}.what())) << "bad_variant_access::what() must be noexcept";
+
+  std::bad_variant_access exception;
+  ASSERT_NE(exception.what(), nullptr) << "A message must be returned";
+}
\ No newline at end of file
diff --git a/test/variant/variant.ctor/CMakeLists.txt b/test/variant/variant.ctor/CMakeLists.txt
new file mode 100644
index 0000000..eec23a9
--- /dev/null
+++ b/test/variant/variant.ctor/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(slo_test PRIVATE 
+  converting.cpp
+  default.cpp
+)
\ No newline at end of file
diff --git a/test/variant/variant.ctor/converting.cpp b/test/variant/variant.ctor/converting.cpp
new file mode 100644
index 0000000..7ca3b0f
--- /dev/null
+++ b/test/variant/variant.ctor/converting.cpp
@@ -0,0 +1,52 @@
+#include <type_traits>
+#include <string>
+
+#include <gtest/gtest.h>
+#include <common/util.h>
+#include <slo/variant.h>
+
+template <typename T>
+struct ConvertingConstructor : testing::Test {};
+TYPED_TEST_SUITE(ConvertingConstructor, test_variants);
+
+TYPED_TEST(ConvertingConstructor, ExactMatch) {
+  using test_variant = get_variant<TypeParam, Constant<0>, Constant<1>, Constant<2>>;
+  ASSERT_TRUE((std::is_constructible_v<test_variant, Constant<1>>));
+
+  ASSERT_EQ((slo::impl::selected_index<Constant<1>, slo::util::TypeList<Constant<0>, Constant<1>, Constant<2>>>), 1);
+}
+
+TYPED_TEST(ConvertingConstructor, Convertible) {
+  using test_variant = get_variant<TypeParam, bool>;
+  ASSERT_TRUE((std::is_constructible_v<test_variant, std::true_type>));
+
+  // sanity check
+  ASSERT_FALSE((std::is_constructible_v<test_variant, std::string>));
+  ASSERT_FALSE((std::is_constructible_v<test_variant, std::nullptr_t>));
+}
+
+TYPED_TEST(ConvertingConstructor, TypePromotion) {
+  using test_variant = get_variant<TypeParam, long>;
+  ASSERT_TRUE((std::is_constructible_v<test_variant, short>));
+
+  // check if it selects the right alternative
+  ASSERT_EQ((slo::impl::selected_index<short, slo::util::TypeList<char, long>>), 1);
+}
+
+TYPED_TEST(ConvertingConstructor, Invalid) {
+  using ambiguous_variant = get_variant<TypeParam, int, int>;
+  using test_variant = get_variant<TypeParam, short, int>;
+
+  // ambiguous
+  ASSERT_EQ((slo::impl::selected_index<int, slo::util::TypeList<int, int>>), slo::variant_npos);
+  ASSERT_EQ((slo::impl::selected_index<int, slo::util::TypeList<long, long long>>), slo::variant_npos);  
+  ASSERT_FALSE((std::is_constructible_v<ambiguous_variant, int>));
+
+  // not contained
+  ASSERT_EQ((slo::impl::selected_index<float, slo::util::TypeList<short, long>>), slo::variant_npos);
+  ASSERT_FALSE((std::is_constructible_v<test_variant, float>));
+
+  // narrowing
+  ASSERT_EQ((slo::impl::selected_index<long long, slo::util::TypeList<short, int>>), slo::variant_npos);
+  ASSERT_FALSE((std::is_constructible_v<test_variant, long long>));
+}
diff --git a/test/variant/variant.ctor/default.cpp b/test/variant/variant.ctor/default.cpp
new file mode 100644
index 0000000..1d51c47
--- /dev/null
+++ b/test/variant/variant.ctor/default.cpp
@@ -0,0 +1,32 @@
+#include <type_traits>
+#include <gtest/gtest.h>
+
+#include <slo/variant.h>
+#include <common/util.h>
+
+template <typename T>
+struct DefaultCtor : testing::Test {};
+TYPED_TEST_SUITE(DefaultCtor, test_variants);
+
+struct NonDefaultConstructible {
+  NonDefaultConstructible() = delete;
+};
+
+struct NotNoexcept {
+  NotNoexcept() noexcept(false) {}
+};
+
+struct DefaultCtorThrows {
+  DefaultCtorThrows() { throw 42; }
+};
+
+TYPED_TEST(DefaultCtor, Constructible) {
+  ASSERT_TRUE((std::is_default_constructible_v<get_variant<TypeParam, std::monostate>>));
+  ASSERT_TRUE((std::is_default_constructible_v<get_variant<TypeParam, std::monostate, int>>));
+  ASSERT_FALSE((std::is_default_constructible_v<get_variant<TypeParam, NonDefaultConstructible, int>>));
+}
+
+TYPED_TEST(DefaultCtor, Noexcept) {
+  ASSERT_TRUE((std::is_nothrow_default_constructible_v<get_variant<TypeParam, int>>));
+  ASSERT_FALSE((std::is_nothrow_default_constructible_v<get_variant<TypeParam, NotNoexcept>>));
+}
diff --git a/test/variant/variant.get/CMakeLists.txt b/test/variant/variant.get/CMakeLists.txt
new file mode 100644
index 0000000..883ca68
--- /dev/null
+++ b/test/variant/variant.get/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(slo_test PRIVATE 
+  holds_alternative.cpp
+)
\ No newline at end of file
diff --git a/test/variant/variant.get/get.cpp b/test/variant/variant.get/get.cpp
new file mode 100644
index 0000000..c6f532e
--- /dev/null
+++ b/test/variant/variant.get/get.cpp
@@ -0,0 +1,30 @@
+#include <gtest/gtest.h>
+#include <slo/variant.h>
+
+#include <common/assertions.h>
+#include <common/util.h>
+
+
+template <typename T>
+struct Get : testing::Test {};
+TYPED_TEST_SUITE(Get, test_variants);
+
+TYPED_TEST(Get, IndexLvalue){
+  using variant = get_variant<TypeParam, const int, float>;
+
+  {
+    constexpr variant obj(42);
+    ASSERT_NOT_NOEXCEPT(slo::get<0>(obj));
+    ASSERT_SAME(decltype(slo::get<0>(obj)), const int&);
+    static_assert(slo::get<0>(obj) == 42, "Value mismatch");
+  }
+}
+TYPED_TEST(Get, IndexRvalue){}
+TYPED_TEST(Get, IndexConstLvalue){}
+TYPED_TEST(Get, IndexConstRvalue){}
+TYPED_TEST(Get, IndexException){}
+
+TYPED_TEST(Get, TypeLvalue){}
+TYPED_TEST(Get, TypeRvalue){}
+TYPED_TEST(Get, TypeConstLvalue){}
+TYPED_TEST(Get, TypeConstRvalue){}
\ No newline at end of file
diff --git a/test/variant/variant.get/holds_alternative.cpp b/test/variant/variant.get/holds_alternative.cpp
new file mode 100644
index 0000000..c69c4d5
--- /dev/null
+++ b/test/variant/variant.get/holds_alternative.cpp
@@ -0,0 +1,17 @@
+#include <gtest/gtest.h>
+
+#include <slo/variant.h>
+#include <common/assertions.h>
+#include <common/util.h>
+#include <common/fixtures/helpers.h>
+
+TYPED_TEST(Helpers, HoldsAlternative) {
+  constexpr get_variant<TypeParam, short, long> variant;
+  ASSERT_TRUE(slo::holds_alternative<short>(variant));
+  ASSERT_TRUE(!slo::holds_alternative<long>(variant));
+}
+
+TYPED_TEST(Helpers, HoldsAlternativeNoexcept){
+  const get_variant<TypeParam, int> variant;
+  ASSERT_NOEXCEPT(slo::holds_alternative<int>(variant));
+}
\ No newline at end of file
diff --git a/test/variant/variant.hash/CMakeLists.txt b/test/variant/variant.hash/CMakeLists.txt
new file mode 100644
index 0000000..c7d5881
--- /dev/null
+++ b/test/variant/variant.hash/CMakeLists.txt
@@ -0,0 +1 @@
+target_sources(slo_test PRIVATE monostate.cpp variant.cpp)
\ No newline at end of file
diff --git a/test/variant/variant.hash/monostate.cpp b/test/variant/variant.hash/monostate.cpp
new file mode 100644
index 0000000..9dfe9d8
--- /dev/null
+++ b/test/variant/variant.hash/monostate.cpp
@@ -0,0 +1,21 @@
+#include <gtest/gtest.h>
+#include <slo/variant.h>
+#include <slo/util/concepts.h>
+
+#include <common/assertions.h>
+
+
+TEST(Hash, Monostate) {
+  auto const hasher = std::hash<slo::monostate>{};
+
+  auto obj1 = slo::monostate{};
+  auto const obj2 = slo::monostate{};
+
+  ASSERT_EQ(hasher(obj1), hasher(obj1));
+  ASSERT_EQ(hasher(obj1), hasher(obj2));
+  ASSERT_EQ(hasher(obj2), hasher(obj1));
+  ASSERT_EQ(hasher(obj2), hasher(obj2));
+  ASSERT_SAME(decltype(hasher(obj1)), std::size_t);
+  ASSERT_NOEXCEPT(hasher(obj1));
+  ASSERT_TRUE(slo::util::is_hashable<slo::monostate>);
+}
\ No newline at end of file
diff --git a/test/variant/variant.hash/variant.cpp b/test/variant/variant.hash/variant.cpp
new file mode 100644
index 0000000..ef0c416
--- /dev/null
+++ b/test/variant/variant.hash/variant.cpp
@@ -0,0 +1,43 @@
+#include <utility>
+#include <gtest/gtest.h>
+#include <slo/variant.h>
+
+#include <common/assertions.h>
+#include <common/util.h>
+template <typename T>
+struct Hash : testing::Test {};
+TYPED_TEST_SUITE(Hash, test_variants);
+
+TYPED_TEST(Hash, DuplicateElements) {
+  // tests whether the index is used for the hash
+  using variant_type  = get_variant<TypeParam, slo::monostate, slo::monostate>;
+  auto const hasher   = std::hash<variant_type>{};
+  auto const variant1 = variant_type(std::in_place_index<0>);
+  auto const variant2 = variant_type(std::in_place_index<1>);
+
+  ASSERT_EQ(hasher(variant1), hasher(variant1));
+  ASSERT_EQ(hasher(variant2), hasher(variant2));
+  ASSERT_NE(hasher(variant1), hasher(variant2));
+}
+
+TYPED_TEST(Hash, Copy) {
+  using variant_type  = get_variant<TypeParam, int, long>;
+  auto const hasher   = std::hash<variant_type>{};
+  auto const obj      = variant_type(std::in_place_index<0>, 42);
+  auto const obj_copy = obj;
+  auto const obj2     = variant_type(std::in_place_index<0>, 100);
+
+  ASSERT_EQ(hasher(obj), hasher(obj));
+  ASSERT_EQ(hasher(obj_copy), hasher(obj_copy));
+  ASSERT_EQ(hasher(obj2), hasher(obj2));
+
+  ASSERT_EQ(hasher(obj), hasher(obj_copy));
+  ASSERT_NE(hasher(obj), hasher(obj2));
+  ASSERT_NE(hasher(obj_copy), hasher(obj2));
+
+  ASSERT_SAME(decltype(hasher(obj)), std::size_t);
+}
+
+TYPED_TEST(Hash, Valueless) {
+  // TODO
+}
\ No newline at end of file
diff --git a/test/variant/variant.helper/CMakeLists.txt b/test/variant/variant.helper/CMakeLists.txt
new file mode 100644
index 0000000..c4e398a
--- /dev/null
+++ b/test/variant/variant.helper/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(slo_test PRIVATE 
+  variant_alternative.cpp
+  variant_size.cpp
+  variant_npos.cpp
+)
\ No newline at end of file
diff --git a/test/variant/variant.helper/variant_alternative.cpp b/test/variant/variant.helper/variant_alternative.cpp
new file mode 100644
index 0000000..400e519
--- /dev/null
+++ b/test/variant/variant.helper/variant_alternative.cpp
@@ -0,0 +1,45 @@
+#include <gtest/gtest.h>
+#include <cstddef>
+
+#include <slo/variant.h>
+#include <common/assertions.h>
+
+template <class Variant, std::size_t Idx, class Expected>
+void check_alternatives() {
+  // type
+  ASSERT_SAME((typename slo::variant_alternative<Idx, Variant>::type), Expected);
+  ASSERT_SAME((typename slo::variant_alternative<Idx, const Variant>::type), const Expected);
+  ASSERT_SAME((typename slo::variant_alternative<Idx, volatile Variant>::type), volatile Expected);
+  ASSERT_SAME((typename slo::variant_alternative<Idx, const volatile Variant>::type), const volatile Expected);
+
+  // alias
+  ASSERT_SAME((slo::variant_alternative_t<Idx, Variant>), Expected);
+  ASSERT_SAME((slo::variant_alternative_t<Idx, const Variant>), const Expected);
+  ASSERT_SAME((slo::variant_alternative_t<Idx, volatile Variant>), volatile Expected);
+  ASSERT_SAME((slo::variant_alternative_t<Idx, const volatile Variant>), const volatile Expected);
+}
+
+union AlternativeUnion {
+  int member_0;
+  void* member_1;
+  const void* member_2;
+  long double member_3;
+};
+
+TEST_T(Helpers,
+       VariantAlternative,
+       slo::RecursiveVariant<int, void*, const void*, long double>,
+       slo::TreeVariant<int, void*, const void*, long double>,
+       slo::InvertedRecursiveVariant<int, void*, const void*, long double>,
+       slo::InvertedTreeVariant<int, void*, const void*, long double>,
+       slo::Union<&AlternativeUnion::member_0,
+                  &AlternativeUnion::member_1,
+                  &AlternativeUnion::member_2,
+                  &AlternativeUnion::member_3>) {
+  check_alternatives<TypeParam, 0, int>();
+  check_alternatives<TypeParam, 1, void*>();
+  check_alternatives<TypeParam, 2, const void*>();
+  check_alternatives<TypeParam, 3, long double>();
+}
+
+// todo ensure out of bounds access causes a static assertion failure
\ No newline at end of file
diff --git a/test/variant/variant.helper/variant_npos.cpp b/test/variant/variant.helper/variant_npos.cpp
new file mode 100644
index 0000000..44858eb
--- /dev/null
+++ b/test/variant/variant.helper/variant_npos.cpp
@@ -0,0 +1,9 @@
+#include <gtest/gtest.h>
+#include <cstddef>
+
+#include <slo/variant.h>
+#include <common/type_name.h>
+
+TEST(Helpers, VariantNpos) {
+  ASSERT_EQ(slo::variant_npos, static_cast<std::size_t>(-1ULL));
+}
diff --git a/test/variant/variant.helper/variant_size.cpp b/test/variant/variant.helper/variant_size.cpp
new file mode 100644
index 0000000..b63ee74
--- /dev/null
+++ b/test/variant/variant.helper/variant_size.cpp
@@ -0,0 +1,26 @@
+#include <gtest/gtest.h>
+#include <cstddef>
+
+#include <slo/variant.h>
+#include <common/type_name.h>
+#include <common/util.h>
+#include <common/fixtures/helpers.h>
+
+template <class V, std::size_t E>
+void check_size() {
+  ASSERT_EQ(slo::variant_size<V>::value, E);
+  ASSERT_EQ(slo::variant_size<V const>::value, E);
+  ASSERT_EQ(slo::variant_size<V volatile>::value, E);
+  ASSERT_EQ(slo::variant_size<V const volatile>::value, E);
+
+  ASSERT_EQ(slo::variant_size_v<V>, E);
+  ASSERT_EQ(slo::variant_size_v<V const>, E);
+  ASSERT_EQ(slo::variant_size_v<V volatile>, E);
+  ASSERT_EQ(slo::variant_size_v<V const volatile>, E);
+}
+
+TYPED_TEST(Helpers, VariantSize) {
+  check_size<get_variant<TypeParam>, 0>();
+  check_size<get_variant<TypeParam, int>, 1>();
+  check_size<get_variant<TypeParam, int, char, void*>, 3>();
+}
diff --git a/test/variant/variant.visit/CMakeLists.txt b/test/variant/variant.visit/CMakeLists.txt
new file mode 100644
index 0000000..fc1e828
--- /dev/null
+++ b/test/variant/variant.visit/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(slo_test PRIVATE
+  incomplete.cpp
+  value_category.cpp
+)
diff --git a/test/variant/variant.visit/forwarding_visitor.h b/test/variant/variant.visit/forwarding_visitor.h
new file mode 100644
index 0000000..700564a
--- /dev/null
+++ b/test/variant/variant.visit/forwarding_visitor.h
@@ -0,0 +1,103 @@
+#pragma once
+#include <gtest/gtest.h>
+#include <common/type_name.h>
+#include <common/qualifiers.h>
+
+template <typename T>
+constexpr std::string_view hash_type() {
+  return nameof<T>;
+}
+
+template <std::size_t N>
+struct CallResult {
+  using fptr_type = decltype(&hash_type<int>);
+
+  Qualifiers qualifiers;
+  fptr_type args[N];
+
+  template <typename... Args>
+  constexpr explicit CallResult(Qualifiers this_qualifiers, Args&&... args_)
+      : qualifiers{this_qualifiers}
+      , args{std::forward<Args>(args_)...} {}
+
+  template <typename... Args>
+  constexpr void verify(Qualifiers expected_qualifiers) const {
+    // qualifier mismatch
+    ASSERT_EQ(qualifiers, expected_qualifiers) << "this qualifiers mismatched.\n"
+                                               << "Expected: " << expected_qualifiers << '\n'
+                                               << "Got:      " << qualifiers << '\n';
+
+    // arity mismatch
+    ASSERT_EQ(sizeof...(Args), N) << "Invalid arity. Expected " << sizeof...(Args) << " arguments, got " << N << ".\n";
+
+    constexpr fptr_type expected_args[N]{hash_type<Args&&>...};
+    for (std::size_t idx = 0; idx < N; ++idx) {
+      // arg mismatch, call the functions to get actual types
+      ASSERT_EQ(args[idx], expected_args[idx]) << "Argument at position " << idx << " mismatched.\n"
+                                               << "Expected: " << expected_args[idx]() << '\n'
+                                               << "Got:      " << args[idx]() << '\n';
+    }
+  }
+};
+
+template <typename... Ts>
+CallResult(Qualifiers, Ts...) -> CallResult<sizeof...(Ts)>;
+
+template <>
+struct CallResult<0> {
+  Qualifiers qualifiers;
+
+  template <typename... Args>
+  void verify(Qualifiers expected_qualifiers) const {
+    ASSERT_EQ(qualifiers, expected_qualifiers) << "this qualifiers mismatched.\n"
+                                               << "Expected: " << expected_qualifiers << '\n'
+                                               << "Got:      " << qualifiers << '\n';
+  }
+};
+
+template <typename... Args>
+constexpr auto make_call_result(Qualifiers object_qualifiers) {
+  return CallResult{object_qualifiers, hash_type<Args&&>...};
+}
+
+struct ForwardingTestVisitor {
+  template <typename... Args>
+  constexpr auto operator()(Args&&...) & -> CallResult<sizeof...(Args)> {
+    return make_call_result<Args&&...>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  }
+
+  template <typename... Args>
+  constexpr auto operator()(Args&&...) && -> CallResult<sizeof...(Args)> {
+    return make_call_result<Args&&...>({Qualifiers::CV::None, Qualifiers::Rvalue});
+  }
+
+  template <typename... Args>
+  constexpr auto operator()(Args&&...) const& -> CallResult<sizeof...(Args)> {
+    return make_call_result<Args&&...>({Qualifiers::Const, Qualifiers::Lvalue});
+  }
+
+  template <typename... Args>
+  constexpr auto operator()(Args&&...) const&& -> CallResult<sizeof...(Args)> {
+    return make_call_result<Args&&...>({Qualifiers::Const, Qualifiers::Rvalue});
+  }
+
+  template <typename... Args>
+  constexpr auto operator()(Args&&...) volatile& -> CallResult<sizeof...(Args)> {
+    return make_call_result<Args&&...>({Qualifiers::Volatile, Qualifiers::Lvalue});
+  }
+
+  template <typename... Args>
+  constexpr auto operator()(Args&&...) volatile&& -> CallResult<sizeof...(Args)> {
+    return make_call_result<Args&&...>({Qualifiers::Volatile, Qualifiers::Rvalue});
+  }
+
+  template <typename... Args>
+  constexpr auto operator()(Args&&...) const volatile& -> CallResult<sizeof...(Args)> {
+    return make_call_result<Args&&...>({Qualifiers::Const | Qualifiers::Volatile, Qualifiers::Lvalue});
+  }
+
+  template <typename... Args>
+  constexpr auto operator()(Args&&...) const volatile&& -> CallResult<sizeof...(Args)> {
+    return make_call_result<Args&&...>({Qualifiers::Const | Qualifiers::Volatile, Qualifiers::Rvalue});
+  }
+};
diff --git a/test/variant/variant.visit/incomplete.cpp b/test/variant/variant.visit/incomplete.cpp
new file mode 100644
index 0000000..13445ed
--- /dev/null
+++ b/test/variant/variant.visit/incomplete.cpp
@@ -0,0 +1,16 @@
+#include <gtest/gtest.h>
+#include <slo/variant.h>
+
+
+struct Incomplete;
+template <typename T>
+struct Wrapper { T obj; };
+
+TEST(Visit, Incomplete){
+  auto obj = slo::Variant<Wrapper<Incomplete>*, int>{};
+
+  slo::visit([](auto){}, obj);
+  slo::visit([](auto) -> Wrapper<Incomplete>* { return nullptr; }, obj);
+  // slo::visit<void>([](auto){}, obj);
+  // slo::visit<void*>([](auto) -> Wrapper<Incomplete>* { return nullptr; }, obj);
+}
\ No newline at end of file
diff --git a/test/variant/variant.visit/value_category.cpp b/test/variant/variant.visit/value_category.cpp
new file mode 100644
index 0000000..b32ae9a
--- /dev/null
+++ b/test/variant/variant.visit/value_category.cpp
@@ -0,0 +1,150 @@
+#include <utility>
+
+#include <gtest/gtest.h>
+#include <slo/variant.h>
+
+#include <common/assertions.h>
+#include <common/util.h>
+
+#include "forwarding_visitor.h"
+
+template <typename T>
+struct Visit : testing::Test {};
+TYPED_TEST_SUITE(Visit, test_variants);
+
+TEST(VisitNoVariant, CallOperatorForwarding) {
+  auto visitor              = ForwardingTestVisitor{};
+  auto const& const_visitor = visitor;
+
+  auto result0 = slo::visit(visitor);
+  result0.template verify<>({Qualifiers::CV::None, Qualifiers::Lvalue});
+
+  auto result1 = slo::visit(const_visitor);
+  result1.template verify<>({Qualifiers::Const, Qualifiers::Lvalue});
+
+  auto result2 = slo::visit(std::move(visitor));
+  result2.template verify<>({Qualifiers::CV::None, Qualifiers::Rvalue});
+
+  auto result3 = slo::visit(std::move(const_visitor));
+  result3.template verify<>({Qualifiers::Const, Qualifiers::Rvalue});
+}
+
+TYPED_TEST(Visit, CallOperatorForwardingSingleVariant) {
+  auto visitor              = ForwardingTestVisitor{};
+  auto const& const_visitor = visitor;
+
+  auto obj = typename TypeParam::template type<int, char, float>{42};
+
+  auto result0 = slo::visit(visitor, obj);
+  result0.template verify<int&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+
+  auto result1 = slo::visit(const_visitor, obj);
+  result1.template verify<int&>({Qualifiers::Const, Qualifiers::Lvalue});
+
+  auto result2 = slo::visit(std::move(visitor), obj);
+  result2.template verify<int&>({Qualifiers::CV::None, Qualifiers::Rvalue});
+
+  auto result3 = slo::visit(std::move(const_visitor), obj);
+  result3.template verify<int&>({Qualifiers::Const, Qualifiers::Rvalue});
+}
+
+TYPED_TEST(Visit, CallOperatorForwardingMultiVariant) {
+  auto visitor              = ForwardingTestVisitor{};
+  auto const& const_visitor = visitor;
+
+  auto obj  = typename TypeParam::template type<int, char, float>{42};
+  auto obj2 = typename TypeParam::template type<float, double>{42.F};
+
+  auto result0 = slo::visit(visitor, obj, obj2);
+  result0.template verify<int&, float&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+
+  auto result1 = slo::visit(const_visitor, obj, obj2);
+  result1.template verify<int&, float&>({Qualifiers::Const, Qualifiers::Lvalue});
+
+  auto result2 = slo::visit(std::move(visitor), obj, obj2);
+  result2.template verify<int&, float&>({Qualifiers::CV::None, Qualifiers::Rvalue});
+
+  auto result3 = slo::visit(std::move(const_visitor), obj, obj2);
+  result3.template verify<int&, float&>({Qualifiers::Const, Qualifiers::Rvalue});
+}
+
+TYPED_TEST(Visit, ArgumentForwardingSingleVariant) {
+  auto visitor = ForwardingTestVisitor{};
+
+  auto obj              = typename TypeParam::template type<int, std::string, float>{42};
+  auto const& const_obj = obj;
+
+  auto result0 = slo::visit(visitor, obj);
+  result0.template verify<int&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  auto result1 = slo::visit(visitor, const_obj);
+  result1.template verify<int const&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  auto result2 = slo::visit(visitor, std::move(obj));
+  result2.template verify<int&&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  auto result3 = slo::visit(visitor, std::move(const_obj));
+  result3.template verify<int const&&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+}
+
+TYPED_TEST(Visit, ArgumentForwardingMultiVariant) {
+  auto visitor = ForwardingTestVisitor{};
+
+  auto obj              = typename TypeParam::template type<int, std::string, float>{42};
+  auto const& const_obj = obj;
+
+  auto obj2              = typename TypeParam::template type<double, float>{42.0};
+  auto const& const_obj2 = obj2;
+
+  slo::visit(visitor, obj, obj2).template verify<int&, double&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, const_obj, obj2).template verify<int const&, double&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, obj, const_obj2).template verify<int&, double const&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, const_obj, const_obj2)
+      .template verify<int const&, double const&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+
+  slo::visit(visitor, std::move(obj), obj2).template verify<int&&, double&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, std::move(const_obj), obj2)
+      .template verify<int const&&, double&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, std::move(obj), const_obj2)
+      .template verify<int&&, double const&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, std::move(const_obj), const_obj2)
+      .template verify<int const&&, double const&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+
+  slo::visit(visitor, obj, std::move(obj2)).template verify<int&, double&&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, obj, std::move(const_obj2))
+      .template verify<int&, double const&&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, const_obj, std::move(obj2))
+      .template verify<int const&, double&&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, const_obj, std::move(const_obj2))
+      .template verify<int const&, double const&&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+
+  slo::visit(visitor, std::move(obj), std::move(obj2))
+      .template verify<int&&, double&&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, std::move(const_obj), std::move(obj2))
+      .template verify<int const&&, double&&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, std::move(obj), std::move(const_obj2))
+      .template verify<int&&, double const&&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+  slo::visit(visitor, std::move(const_obj), std::move(const_obj2))
+      .template verify<int const&&, double const&&>({Qualifiers::CV::None, Qualifiers::Lvalue});
+}
+
+int dummy = 42;
+struct ResultTestVisitor {
+  int& operator()() & { return dummy; }
+  int const& operator()() const& { return dummy; }
+  int&& operator()() && { return std::move(dummy); }
+  int const&& operator()() const&& { return std::move(std::as_const(dummy)); }
+};
+
+TEST(VisitNoVariant, ReturnValueCategory) {
+  auto visitor              = ResultTestVisitor{};
+  auto const& const_visitor = visitor;
+  auto&& result0            = slo::visit(visitor);
+  ASSERT_SAME(decltype(result0), int&);
+
+  auto&& result1 = slo::visit(const_visitor);
+  ASSERT_SAME(decltype(result1), int const&);
+
+  auto&& result2 = slo::visit(std::move(visitor));
+  ASSERT_SAME(decltype(result2), int&&);
+
+  auto&& result3 = slo::visit(std::move(const_visitor));
+  ASSERT_SAME(decltype(result3), int const&&);
+}
\ No newline at end of file
diff --git a/test_package/CMakeLists.txt b/test_package/CMakeLists.txt
new file mode 100644
index 0000000..963d95c
--- /dev/null
+++ b/test_package/CMakeLists.txt
@@ -0,0 +1,5 @@
+cmake_minimum_required(VERSION 3.15)
+project(PackageTest CXX)
+find_package(slo CONFIG REQUIRED)
+add_executable(example src/example.cpp)
+target_link_libraries(example slo::slo)
diff --git a/test_package/conanfile.py b/test_package/conanfile.py
new file mode 100644
index 0000000..ee1bb15
--- /dev/null
+++ b/test_package/conanfile.py
@@ -0,0 +1,26 @@
+import os
+
+from conan import ConanFile
+from conan.tools.cmake import CMake, cmake_layout
+from conan.tools.build import can_run
+
+
+class SloTestConan(ConanFile):
+    settings = "os", "compiler", "build_type", "arch"
+    generators = "CMakeDeps", "CMakeToolchain"
+
+    def requirements(self):
+        self.requires(self.tested_reference_str)
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def layout(self):
+        cmake_layout(self)
+
+    def test(self):
+        if can_run(self):
+            cmd = os.path.join(self.cpp.build.bindir, "example")
+            self.run(cmd, env="conanrun")
diff --git a/test_package/src/example.cpp b/test_package/src/example.cpp
new file mode 100644
index 0000000..bdca2ab
--- /dev/null
+++ b/test_package/src/example.cpp
@@ -0,0 +1,10 @@
+#include <slo/variant.h>
+#include <iostream>
+
+
+int main() {
+  auto variant = slo::Variant<int, char, float>{3.2F};
+  slo::visit([](auto obj) {
+    std::cout << obj << '\n';
+  }, variant);
+}
\ No newline at end of file
diff --git a/tools/amalgamate.py b/tools/amalgamate.py
new file mode 100644
index 0000000..765a3cf
--- /dev/null
+++ b/tools/amalgamate.py
@@ -0,0 +1,114 @@
+import logging
+from pathlib import Path
+from enum import Enum, auto
+
+from palgen.ingest import Suffix, Absolute
+from palgen import Extension, Sources, Model
+
+INCLUDE_MARKER = "#include "
+
+
+class IncludeKind(Enum):
+    SYSTEM = auto()
+    RELATIVE = auto()
+    LOCAL = auto()
+
+
+class Header:
+    def __init__(self, root: Path, project_name: str):
+        self.root = root
+        self.project_name = project_name
+        self.system_includes: set[str] = set()
+
+        # insertion order might matter, in Python lists keep insertion order but sets do not
+        self.local_includes: list[Path] = []
+        self.seen: set[Path] = set()
+
+        self.amalgamated: str = ""
+        # recursively search include paths
+        self.get_includes(self.root)
+
+    def classify_include(self, include: str):
+        filename = include[1:-1]
+
+        if include.startswith('"'):
+            return IncludeKind.RELATIVE
+        elif filename.startswith(self.project_name):
+            return IncludeKind.LOCAL
+
+        return IncludeKind.SYSTEM
+
+    def resolve_include(self, include: str, origin: Path):
+        filename = include[1:-1]
+
+        kind = self.classify_include(include)
+        assert kind != IncludeKind.SYSTEM
+        # TODO get include path here
+        return (self.root.parent.parent if kind == IncludeKind.LOCAL else origin.parent) / filename
+
+    def get_includes(self, path: Path):
+        if path in self.seen:
+            return
+        self.seen.add(path)
+        logging.debug("Analyzing %s", path)
+        self.local_includes.append(path)  # guaranteed to be unique
+
+        text = path.read_text(encoding='utf-8')
+        in_pp_conditional = False
+
+        for line in text.split('\n'):
+            stripped = line.strip()
+            if in_pp_conditional:
+                if stripped.startswith("#endif"):
+                    in_pp_conditional = False
+                elif stripped.startswith(INCLUDE_MARKER):
+                    include = stripped[len(INCLUDE_MARKER):]
+                    if self.classify_include(include) != IncludeKind.SYSTEM:
+                        self.get_includes(self.resolve_include(include, path))
+                        continue
+
+            elif stripped.startswith("#if"):
+                in_pp_conditional = True
+
+            elif stripped.startswith("#pragma once"):
+                continue
+            elif stripped.startswith(INCLUDE_MARKER):
+                include = stripped[len(INCLUDE_MARKER):]
+                if self.classify_include(include) != IncludeKind.SYSTEM:
+                    self.get_includes(self.resolve_include(include, path))
+                else:
+                    self.system_includes.add(stripped)
+                continue
+            self.amalgamated += line + '\n'
+
+
+class Amalgamate(Extension):
+    ingest = Sources / 'include' >> Suffix(".hpp", ".h") >> Absolute
+
+    class Settings(Model):
+        root: Path
+        filename: str
+
+    def find_root(self, *_):
+        if self.settings.root.is_absolute():
+            return self.settings.root
+
+        for sourcedir in self.project.sources:
+            if (file := sourcedir / self.settings.root).exists():
+                return file
+
+    def render(self, data: list[tuple[Path]]):
+        header = Header(self.find_root(), self.project.name)
+        system_includes = '\n'.join(header.system_includes)
+        amalgamated = f"""\
+#ifndef SLO_VARIANT_INCLUDED
+#define SLO_VARIANT_INCLUDED
+{system_includes}
+{header.amalgamated}
+#endif
+"""
+        for file in data:
+            if file not in header.seen:
+                logging.warning("File %s was not included anywhere.", file)
+
+        yield self.settings.filename, amalgamated
diff --git a/tools/benchmark.py b/tools/benchmark.py
new file mode 100644
index 0000000..4fe022f
--- /dev/null
+++ b/tools/benchmark.py
@@ -0,0 +1,183 @@
+import os
+import logging
+import json
+import zlib
+from pathlib import Path
+from typing import Any, Optional
+from subprocess import check_call
+from collections import defaultdict
+
+import itertools
+
+import jmespath
+
+from palgen import Extension, Sources, Model
+from palgen.ingest import Name, Toml
+
+class Config(Model):
+    source: Path
+    profile: dict[str, Any]
+    query: dict[str, Any]
+    standard: Optional[str] = None
+    options: list[str] = []
+    true_value: str = "1"
+    false_value: str = "0"
+
+
+
+def dict_product(dicts):
+    return (dict(zip(dicts, x)) for x in itertools.product(*dicts.values()))
+
+def generate_trace(file, output, defines: dict[str, Any], config: Config):
+    defines = [f'-D{name}={value}' for name, value in defines.items()]
+    includes = ['-isystem', str(Path.cwd() / 'include')]
+    standard = f"-std={config.standard}" if config.standard else '-std=c++23'
+    profile_flags = ['-ftime-trace', '-c']
+
+    taskset_prefix = ["taskset", "--cpu-list", "23"]
+    call = [*taskset_prefix, os.environ.get("CXX") or "clang++", str(file), '-o', str(output), *
+            defines, *includes, standard, *profile_flags, *config.options]
+
+    output.parent.mkdir(exist_ok=True, parents=True)
+    check_call(call, cwd=file.parent)
+    output.unlink()
+
+    trace_file = output.with_suffix('.json')
+    logging.info("Generated %s", trace_file)
+    return trace_file
+
+
+def analyze_trace(file: Path, queries):
+    trace_times = defaultdict(list)
+    trace = json.loads(file.read_text('utf-8'))
+    for query_name, entry in queries.items():
+        search_result = jmespath.search(entry, trace)
+
+        if len(search_result) > 1:
+            logging.warning("Found more than one result")
+            continue
+
+        trace_times[query_name].append(search_result[0])
+    return trace_times
+
+class Analyze:
+    def __init__(self, config: Config, repeat_each: int, file: Path, output: Path):
+        self.config = config
+        self.output = output
+        self.repeat_each = repeat_each
+        self.queries = {name: jmespath.compile(
+            query) for name, query in config.query.items()}
+        self.config.profile = dict(self.expand_profiles(self.config.profile.copy()))
+        self.fix_bools()
+        self.runs: dict[str, list[Path]] = {
+            name: [generate_trace(file, self.output / file.parent.stem / f'{name}.{idx}.obj', features, config)
+                   for idx in range(self.repeat_each)]
+            for name, features in self.config.profile.items()}
+
+    def fix_bools(self):
+        for name, features in self.config.profile.items():
+            for feature, value in features.copy().items():
+                if isinstance(value, bool):
+                    features[feature] = self.config.true_value if value else self.config.false_value
+
+    def get_ranges(self, features: dict):
+        for feature, value in features.items():
+            if isinstance(value, dict):
+                assert "min" in value and "max" in value, "Invalid range: Missing min or max"
+                yield feature, range(int(value["min"]), int(value["max"]) + 1)
+            elif isinstance(value, list):
+                yield feature, value
+
+    def expand_profiles(self, profile_input: dict[str, Any]):
+        for name, features in profile_input.items():
+            ranges = dict(self.get_ranges(features))
+            if not ranges:
+                yield name, features
+                continue
+
+            for feature_set in dict_product(ranges):
+                new_name = f"{name}_{'_'.join(f'{feature}{value}' for feature, value in feature_set.items())}"
+                values = features.copy()
+                for feature, value in feature_set.items():
+                    values[feature] = value
+                yield new_name, values
+
+    def _search(self, trace_file: Path):
+        trace = json.loads(trace_file.read_text('utf-8'))
+        for name, query in self.queries.items():
+            result = query.search(trace)
+            if len(result) > 1:
+                logging.warning("More than one result found")
+                continue
+
+            yield name, result[0]
+
+    def run_queries(self):
+        feature_sets = {name: [dict(self._search(file))
+                               for file in files]
+                        for name, files in self.runs.items()}
+        return {query: {name: [run[query]
+                               for run in runs]
+                        for name, runs in feature_sets.items()}
+                for query in self.queries}
+
+    def worst_offenders(self):
+        expensive_classes = jmespath.compile("reverse(sort_by(traceEvents[?name=='ParseClass' "
+                                             "&& !starts_with(@.args.detail, 'std')], &dur)[])[:10]")
+        expensive_functions = jmespath.compile("reverse(sort_by(traceEvents[?name=='InstantiateFunction' "
+                                               "&& !starts_with(@.args.detail, 'std')], &dur)[])[:10]")
+
+
+class Benchmark(Extension):
+    ingest = Sources >> Name("profiles.toml") >> Toml
+
+    class Settings(Model):
+        output: Path
+        repeat_each: int = 1
+        system_includes: list[str] = []
+        includes: list[str] = []
+
+    Schema = Config
+
+    def run_benchmark(self, data):
+        if not self.settings.output.is_absolute():
+            self.settings.output = self.root_path / self.settings.output
+
+        for path, config in data:
+            if not (file := Path(config.source)).is_absolute():
+                file = path.parent / file
+            analyzer = Analyze(config, self.settings.repeat_each, file, self.settings.output)
+            queries = analyzer.run_queries()
+            colors = [f"#{hex(zlib.crc32(name.encode('utf-8')))[4:]}"
+                      for name in config.profile]
+            summary = {}
+            for idx, (query, runs) in enumerate(queries.items()):
+                datasets = []
+                yMarkers = []
+                chart_data = {"labels": [str(idx) for idx in range(self.settings.repeat_each)],
+                              "datasets": datasets,
+                              "yMarkers": yMarkers}
+                logging.info("Query %s", query)
+                summary[query] = {}
+                for name, run in runs.items():
+                    summary[query][name] = min(run)
+                    datasets.append({"name": name,
+                                     "values": run,
+                                     "chartType": 'line'})
+                    yMarkers.append({"label": name, "value": min(run)})
+                    logging.info("  Feature set %s", name)
+                    logging.info("    Results: %s", run)
+                    logging.info("    Avg: %sms", (sum(run) / len(run)) / 1000)
+                    logging.info("    Min: %sms", min(run) / 1000)
+                chart = self.settings.output / path.parent.name / f"{query}.json"
+
+                yield chart, json.dumps({'title': query,
+                                         'data': chart_data,
+                                         'type': "line",
+                                         'height': 400,
+                                         'colors': colors,
+                                         'lineOptions': {'regionFill': 1, 'spline': 1}})
+            summary_file = self.settings.output / path.parent.name / 'summary.json'
+            yield summary_file, json.dumps(summary)
+
+    pipeline = ingest >> Extension.validate >> run_benchmark >> Extension.write
diff --git a/tools/codegen.py b/tools/codegen.py
new file mode 100644
index 0000000..1d02fd8
--- /dev/null
+++ b/tools/codegen.py
@@ -0,0 +1,39 @@
+import logging
+import shutil  # required to find clang-format
+import subprocess  # required to run clang-format
+from pathlib import Path
+from typing import Iterable
+
+import em  # requires empy
+from palgen import Extension, Model, Sources
+from palgen.ingest import Suffix
+
+clang_format_path = shutil.which("clang-format")
+
+
+class Codegen(Extension):
+    ingest = Sources >> Suffix(".h.in")
+
+    class Settings(Model):
+        clang_format: bool = False
+
+    def render(self, data: Iterable[Path]):
+        for path in data:
+            logging.debug("Template found: %s", path)
+            content = path.read_text(encoding="utf-8")
+            preprocessed = em.expand(content)
+            if clang_format_path is not None:
+                logging.debug("Running clang-format")
+                result = subprocess.run(
+                    [clang_format_path, "--Wno-error=unknown"],
+                    input=preprocessed,
+                    text=True,
+                    capture_output=True,
+                    check=False
+                )
+                assert result.returncode == 0, f"clang-format returned {result.returncode}"
+
+                preprocessed = result.stdout
+
+            name = path.stem.split(".h", 1)[0]  # strip .h
+            yield path.with_name(name).with_suffix(".h"), preprocessed
diff --git a/tools/requirements.txt b/tools/requirements.txt
new file mode 100644
index 0000000..2b6895b
--- /dev/null
+++ b/tools/requirements.txt
@@ -0,0 +1,2 @@
+jmespath>=1.0.1
+empy>=4.0.1