diff --git a/Source/Base/include/Base/variable_container.h b/Source/Base/include/Base/variable_container.h
index 42037375a..881a9ab97 100644
--- a/Source/Base/include/Base/variable_container.h
+++ b/Source/Base/include/Base/variable_container.h
@@ -2,17 +2,16 @@
 #pragma once
 
 #include <cassert>
-#include <array>
 #include <vector>
+#include <variant>
 #include <robin_hood.h>
-#include <stddef.h>
 
 namespace nc::base {
 
 namespace detail {
 
 struct variable_container_base {
-    enum class type : char
+    enum class type : unsigned char
     {
         dense = 0,
         sparse = 1,
@@ -22,167 +21,133 @@ struct variable_container_base {
 
 } // namespace detail
 
+// variable_container is a hybrid container, which can take one of 3 forms - a common value container, a dense container
+// and a sparse container. It's useful when characteristics of data can dratically change in run-time and not known in
+// advance. variable_container is not compatible with all idioms of STL containers and should be used with care.
 template <class T = int>
-class alignas(max_align_t) variable_container
+class variable_container
 {
 public:
-    typedef T value_type;
-    typedef T &reference;
-    typedef const T &const_reference;
-
+    using value_type = T;
+    using reference = T &;
+    using const_reference = const T &;
     using type = detail::variable_container_base::type;
 
-    /**
-     * Construction/desctuction/assigning.
-     */
+    // Creates a container with a specified type.
+    // A common value container will implicitly create the default value.
     variable_container(type _type = type::common);
+
+    // Creates a container with a common value copied from the parameter.
     variable_container(const T &_value);
+
+    // Creates a container with a common value moved from the parameter.
     variable_container(T &&_value);
-    variable_container(const variable_container &_rhs);
-    variable_container(variable_container &&_rhs) noexcept;
-    ~variable_container();
-    const variable_container &operator=(const variable_container &_rhs);
-    const variable_container &operator=(variable_container &&_rhs) noexcept;
-
-    /**
-     * return current container's type.
-     */
-    type mode() const noexcept;
-
-    /**
-     * reverts container to empty state with specified type.
-     */
+
+    // Returns the current container's type.
+    constexpr type mode() const noexcept;
+
+    // Reverts the container to an empty state with a specified type.
     void reset(type _type);
 
-    /**
-     * for common mode return common value.
-     * for other modes uses at() of vector<> and unordered_map<>.
-     */
+    // Returns a reference to an element at the specified index and throws if it doesn't exist.
+    // For the common mode returns the common value.
+    // For other modes uses .at() of vector<> and unordered_map<>.
     T &at(size_t _at);
+
+    // Returns a reference to an element at the specified index and throws if it doesn't exist.
+    // For the common mode returns the common value.
+    // For other modes uses .at() of vector<> and unordered_flat_map<>.
     const T &at(size_t _at) const;
 
-    /**
-     * for common mode return common value.
-     * for dense mode uses vector<>::operator[].
-     * for sparse mode uses unordered_map<>::find.
-     * precondition: the element must exist.
-     */
+    // Returns a reference to an existing element at the specified index.
+    // For the common mode returns the common value.
+    // For the dense mode uses vector<>::operator[].
+    // For the sparse mode uses unordered_flat_map<>::find (precondition: the element must exist).
     T &operator[](size_t _at) noexcept;
+
+    // Returns a reference to an existing element at the specified index.
+    // For the common mode returns the common value.
+    // For the dense mode uses vector<>::operator[].
+    // For the sparse mode uses unordered_flat_map<>::find (precondition: the element must exist).
     const T &operator[](size_t _at) const noexcept;
 
-    /**
-     * return amount of elements inside.
-     * for common mode always returns 1.
-     * for other modes return size of a corresponding container.
-     */
+    // Returns the amount of elements inside the container.
+    // For common mode always returns 1.
+    // For other modes return the size of a corresponding container.
     size_t size() const noexcept;
 
-    /**
-     * returns size() == 0;
-     */
+    // returns size() == 0;
     bool empty() const noexcept;
 
-    /**
-     * Can be used only with Dense mode, ignored otherwise.
-     */
+    // Resizes the container to a new size.
+    // Can be used only with Dense mode, ignored otherwise.
     void resize(size_t _new_size);
 
-    /**
-     * if mode is Dense an _at is above current size -> will resize accordingly.
-     * if mode is Common will ignore _at and fill common value with _value.
-     */
+    // Inserts the value into the container at the specified index.
+    // If mode is Dense and _at is above the current size the container will resize accordingly.
+    // If mode is Common the _at index will be ignored and the common value will be set with _value.
     void insert(size_t _at, const T &_value);
+
+    // Inserts the value into the container at the specified index.
+    // If mode is Dense and _at is above the current size the container will resize accordingly.
+    // If mode is Common the _at index will be ignored and the common value will be set with _value.
     void insert(size_t _at, T &&_value);
 
-    /**
-     * for common mode return true always.
-     * for sparse mode checks for presence of this item.
-     * for dense mode checks vector bounds.
-     */
+    // Checks at the container has an element at the specified index.
+    // For the common mode always returns true.
+    // For the sparse mode checks for presence of this item in the unordered map.
+    // For the dense mode checks the vector bounds.
     bool has(size_t _at) const noexcept;
 
-    /**
-     * return true if:
-     * - type is common or dense
-     * - type is sparse and map containst all keys from [0, size)
-     */
+    // Checks if the container has no gaps in the seqence of used indices.
+    // Returns true if:
+    //  - the type is common or dense
+    //  - the type is sparse and the map contains all keys in [0, size)
     bool is_contiguous() const noexcept;
 
-    /**
-     * transforms sparse container with contiguous elements into a dense container.
-     * will throw a logic_error if any element is missing ( container is non contiguous ).
-     * if container isn't sparse type - will throw a logic_error.
-     */
+    // Transforms a sparse container with contiguous elements into a dense container.
+    // Will throw a logic_error if any element is missing (i.e., the container is non contiguous).
+    // If container isn't of a sparse type - will throw a logic_error.
     void compress_contiguous();
 
 private:
     using common_type = value_type;
     using sparse_type = robin_hood::unordered_flat_map<size_t, T>;
     using dense_type = std::vector<T>;
-    static constexpr std::size_t m_StorageSize =
-        std::max({sizeof(common_type), sizeof(sparse_type), sizeof(dense_type)});
-    static_assert(alignof(max_align_t) >= alignof(common_type));
-    static_assert(alignof(max_align_t) >= alignof(sparse_type));
-    static_assert(alignof(max_align_t) >= alignof(dense_type));
-
-    common_type &Common();
-    const common_type &Common() const;
-    sparse_type &Sparse();
-    const sparse_type &Sparse() const;
-    dense_type &Dense();
-    const dense_type &Dense() const;
-
-    void Construct();
-    void ConstructCopy(const variable_container<T> &_rhs);
-    void ConstructMove(variable_container<T> &&_rhs);
-    void Destruct();
-    // it would be nice to change this ugly casts to C++11-style unions, but current XCode6.4
-    // crashes on them. check it later.
-    // TODO: get rid of Common(), Sparse() and Dense() functions, move to modern union.
-    std::array<char, m_StorageSize> m_Storage;
-    type m_Type;
-};
-
-template <class T>
-variable_container<T>::variable_container(type _type) : m_Type(_type)
-{
-    Construct();
-}
+    using StorageT = std::variant<dense_type, sparse_type, common_type>;
 
-template <class T>
-variable_container<T>::variable_container(const variable_container<T> &_rhs) : m_Type(_rhs.m_Type)
-{
-    ConstructCopy(_rhs);
-}
+    common_type &Common() noexcept;
+    const common_type &Common() const noexcept;
+    sparse_type &Sparse() noexcept;
+    const sparse_type &Sparse() const noexcept;
+    dense_type &Dense() noexcept;
+    const dense_type &Dense() const noexcept;
 
-template <class T>
-variable_container<T>::variable_container(variable_container<T> &&_rhs) noexcept : m_Type(_rhs.m_Type)
-{
-    ConstructMove(std::move(_rhs));
-}
+    StorageT m_Storage;
+};
 
 template <class T>
-variable_container<T>::variable_container(const T &_value) : m_Type(type::common)
+variable_container<T>::variable_container(type _type)
+    : m_Storage(_type == type::common   ? StorageT{std::in_place_type<common_type>}
+                : _type == type::sparse ? StorageT{std::in_place_type<sparse_type>}
+                                        : StorageT{std::in_place_type<dense_type>})
 {
-    new(&Common()) common_type(_value);
 }
 
 template <class T>
-variable_container<T>::variable_container(T &&_value) : m_Type(type::common)
+variable_container<T>::variable_container(const T &_value) : m_Storage{_value}
 {
-    new(&Common()) common_type(move(_value));
 }
 
 template <class T>
-variable_container<T>::~variable_container()
+variable_container<T>::variable_container(T &&_value) : m_Storage{std::move(_value)}
 {
-    Destruct();
 }
 
 template <class T>
-typename variable_container<T>::type variable_container<T>::mode() const noexcept
+constexpr typename variable_container<T>::type variable_container<T>::mode() const noexcept
 {
-    return m_Type;
+    return static_cast<type>(m_Storage.index());
 }
 
 template <class T>
@@ -192,248 +157,202 @@ void variable_container<T>::reset(type _type)
 }
 
 template <class T>
-const variable_container<T> &variable_container<T>::operator=(const variable_container<T> &_rhs)
+typename variable_container<T>::common_type &variable_container<T>::Common() noexcept
 {
-    if( m_Type != _rhs.m_Type ) {
-        Destruct();
-        m_Type = _rhs.m_Type;
-        ConstructCopy(_rhs);
-    }
-    else {
-        if( m_Type == type::common )
-            Common() = _rhs.Common();
-        else if( m_Type == type::sparse )
-            Sparse() = _rhs.Sparse();
-        else // if( m_Type == type::dense )
-            Dense() = _rhs.Dense();
-    }
-    return *this;
+    assert(std::holds_alternative<common_type>(m_Storage));
+    return *std::get_if<common_type>(&m_Storage);
 }
 
 template <class T>
-const variable_container<T> &variable_container<T>::operator=(variable_container<T> &&_rhs) noexcept
+const typename variable_container<T>::common_type &variable_container<T>::Common() const noexcept
 {
-    if( m_Type != _rhs.m_Type ) {
-        Destruct();
-        m_Type = _rhs.m_Type;
-        ConstructMove(std::move(_rhs));
-    }
-    else {
-        if( m_Type == type::common )
-            Common() = std::move(_rhs.Common());
-        else if( m_Type == type::sparse )
-            Sparse() = std::move(_rhs.Sparse());
-        else // if( m_Type == type::dense )
-            Dense() = std::move(_rhs.Dense());
-    }
-    return *this;
+    assert(std::holds_alternative<common_type>(m_Storage));
+    return *std::get_if<common_type>(&m_Storage);
 }
 
 template <class T>
-typename variable_container<T>::common_type &variable_container<T>::Common()
+typename variable_container<T>::sparse_type &variable_container<T>::Sparse() noexcept
 {
-    return *reinterpret_cast<common_type *>(m_Storage.data());
+    assert(std::holds_alternative<sparse_type>(m_Storage));
+    return *std::get_if<sparse_type>(&m_Storage);
 }
 
 template <class T>
-const typename variable_container<T>::common_type &variable_container<T>::Common() const
+const typename variable_container<T>::sparse_type &variable_container<T>::Sparse() const noexcept
 {
-    return *reinterpret_cast<const common_type *>(m_Storage.data());
+    assert(std::holds_alternative<sparse_type>(m_Storage));
+    return *std::get_if<sparse_type>(&m_Storage);
 }
 
 template <class T>
-typename variable_container<T>::sparse_type &variable_container<T>::Sparse()
+typename variable_container<T>::dense_type &variable_container<T>::Dense() noexcept
 {
-    return *reinterpret_cast<sparse_type *>(m_Storage.data());
+    assert(std::holds_alternative<dense_type>(m_Storage));
+    return *std::get_if<dense_type>(&m_Storage);
 }
 
 template <class T>
-const typename variable_container<T>::sparse_type &variable_container<T>::Sparse() const
+const typename variable_container<T>::dense_type &variable_container<T>::Dense() const noexcept
 {
-    return *reinterpret_cast<const sparse_type *>(m_Storage.data());
-}
-
-template <class T>
-typename variable_container<T>::dense_type &variable_container<T>::Dense()
-{
-    return *reinterpret_cast<dense_type *>(m_Storage.data());
-}
-
-template <class T>
-const typename variable_container<T>::dense_type &variable_container<T>::Dense() const
-{
-    return *reinterpret_cast<const dense_type *>(m_Storage.data());
-}
-
-template <class T>
-void variable_container<T>::Construct()
-{
-    if( m_Type == type::common )
-        new(&Common()) common_type;
-    else if( m_Type == type::sparse )
-        new(&Sparse()) sparse_type;
-    else // if( m_Type == type::dense )
-        new(&Dense()) dense_type;
-}
-
-template <class T>
-void variable_container<T>::ConstructCopy(const variable_container<T> &_rhs)
-{
-    assert(m_Type == _rhs.m_Type);
-
-    if( m_Type == type::common )
-        new(&Common()) common_type(_rhs.Common());
-    else if( m_Type == type::sparse )
-        new(&Sparse()) sparse_type(_rhs.Sparse());
-    else // if( m_Type == type::dense )
-        new(&Dense()) dense_type(_rhs.Dense());
-}
-
-template <class T>
-void variable_container<T>::ConstructMove(variable_container<T> &&_rhs)
-{
-    assert(m_Type == _rhs.m_Type);
-
-    if( m_Type == type::common )
-        new(&Common()) common_type(std::move(_rhs.Common()));
-    else if( m_Type == type::sparse )
-        new(&Sparse()) sparse_type(std::move(_rhs.Sparse()));
-    else // if( m_Type == type::dense )
-        new(&Dense()) dense_type(std::move(_rhs.Dense()));
-}
-
-template <class T>
-void variable_container<T>::Destruct()
-{
-    if( m_Type == type::common )
-        Common().~common_type();
-    else if( m_Type == type::sparse )
-        Sparse().~sparse_type();
-    else // if( m_Type == type::dense )
-        Dense().~dense_type();
+    assert(std::holds_alternative<dense_type>(m_Storage));
+    return *std::get_if<dense_type>(&m_Storage);
 }
 
 template <class T>
 T &variable_container<T>::at(size_t _at)
 {
-    if( m_Type == type::common )
-        return Common();
-    else if( m_Type == type::dense )
-        return Dense().at(_at);
-    else // if( m_Type == type::sparse )
-        return Sparse().at(_at);
+    switch( mode() ) {
+        case type::common: {
+            return Common();
+        }
+        case type::dense: {
+            return Dense().at(_at);
+        }
+        case type::sparse: {
+            return Sparse().at(_at);
+        }
+    }
 }
 
 template <class T>
 T &variable_container<T>::operator[](size_t _at) noexcept
 {
-    if( m_Type == type::common ) {
-        return Common();
-    }
-    else if( m_Type == type::dense ) {
-        assert(_at < Dense().size());
-        return Dense()[_at];
-    }
-    else { // if( m_Type == type::sparse )
-        auto it = Sparse().find(_at);
-        assert(it != Sparse().end());
-        return it->second;
+    switch( mode() ) {
+        case type::common: {
+            return Common();
+        }
+        case type::dense: {
+            assert(_at < Dense().size());
+            return Dense()[_at];
+        }
+        case type::sparse: {
+            auto it = Sparse().find(_at);
+            assert(it != Sparse().end());
+            return it->second;
+        }
     }
 }
 
 template <class T>
 const T &variable_container<T>::at(size_t _at) const
 {
-    if( m_Type == type::common )
-        return Common();
-    else if( m_Type == type::dense )
-        return Dense().at(_at);
-    else // if( m_Type == type::sparse )
-        return Sparse().at(_at);
+    switch( mode() ) {
+        case type::common: {
+            return Common();
+        }
+        case type::dense: {
+            return Dense().at(_at);
+        }
+        case type::sparse: {
+            return Sparse().at(_at);
+        }
+    }
 }
 
 template <class T>
 const T &variable_container<T>::operator[](size_t _at) const noexcept
 {
-    if( m_Type == type::common ) {
-        return Common();
-    }
-    else if( m_Type == type::dense ) {
-        assert(_at < Dense().size());
-        return Dense()[_at];
-    }
-    else { // if( m_Type == type::sparse )
-        auto it = Sparse().find(_at);
-        assert(it != Sparse().end());
-        return it->second;
+    switch( mode() ) {
+        case type::common: {
+            return Common();
+        }
+        case type::dense: {
+            assert(_at < Dense().size());
+            return Dense()[_at];
+        }
+        case type::sparse: {
+            auto it = Sparse().find(_at);
+            assert(it != Sparse().end());
+            return it->second;
+        }
     }
 }
 
 template <class T>
 void variable_container<T>::resize(size_t _new_size)
 {
-    if( m_Type == type::dense )
+    if( mode() == type::dense )
         Dense().resize(_new_size);
 }
 
 template <class T>
 void variable_container<T>::insert(size_t _at, const T &_value)
 {
-    if( m_Type == type::common ) {
-        Common() = _value;
-    }
-    else if( m_Type == type::dense ) {
-        if( Dense().size() <= _at )
-            Dense().resize(_at + 1);
-        Dense()[_at] = _value;
-    }
-    else { // if( m_Type == type::sparse )
-        auto r = Sparse().insert(typename sparse_type::value_type(_at, _value));
-        if( !r.second )
-            r.first->second = _value;
+    switch( mode() ) {
+        case type::common: {
+            Common() = _value;
+            break;
+        }
+        case type::dense: {
+            dense_type &dense = Dense();
+            if( dense.size() <= _at )
+                dense.resize(_at + 1);
+            dense[_at] = _value;
+            break;
+        }
+        case type::sparse: {
+            sparse_type &sparse = Sparse();
+            auto i = sparse.find(_at);
+            if( i == sparse.end() )
+                sparse.emplace(_at, _value);
+            else
+                i->second = std::move(_value);
+            break;
+        }
     }
 }
 
 template <class T>
 void variable_container<T>::insert(size_t _at, T &&_value)
 {
-    if( m_Type == type::common ) {
-        Common() = std::move(_value);
-    }
-    else if( m_Type == type::dense ) {
-        if( Dense().size() <= _at )
-            Dense().resize(_at + 1);
-        Dense()[_at] = std::move(_value);
-    }
-    else { // if( m_Type == type::sparse )
-        auto i = Sparse().find(static_cast<unsigned>(_at));
-        if( i == std::end(Sparse()) )
-            Sparse().insert(typename sparse_type::value_type(static_cast<unsigned>(_at), std::move(_value)));
-        else
-            i->second = std::move(_value);
+    switch( mode() ) {
+        case type::common: {
+            Common() = std::move(_value);
+            break;
+        }
+        case type::dense: {
+            dense_type &dense = Dense();
+            if( dense.size() <= _at )
+                dense.resize(_at + 1);
+            dense[_at] = std::move(_value);
+            break;
+        }
+        case type::sparse: {
+            sparse_type &sparse = Sparse();
+            auto i = sparse.find(_at);
+            if( i == sparse.end() )
+                sparse.emplace(_at, std::move(_value));
+            else
+                i->second = std::move(_value);
+            break;
+        }
     }
 }
 
 template <class T>
 bool variable_container<T>::has(size_t _at) const noexcept
 {
-    if( m_Type == type::common )
-        return true;
-    else if( m_Type == type::dense )
-        return _at < Dense().size();
-    else // if( m_Type == type::sparse )
-        return Sparse().contains(_at);
+    switch( mode() ) {
+        case type::common:
+            return true;
+        case type::dense:
+            return _at < Dense().size();
+        case type::sparse:
+            return Sparse().contains(_at);
+    }
 }
 
 template <class T>
 size_t variable_container<T>::size() const noexcept
 {
-    if( m_Type == type::common )
-        return 1;
-    else if( m_Type == type::dense )
-        return Dense().size();
-    else // if( m_Type == type::sparse )
-        return Sparse().size();
+    switch( mode() ) {
+        case type::common:
+            return 1;
+        case type::dense:
+            return Dense().size();
+        case type::sparse:
+            return Sparse().size();
+    }
 }
 
 template <class T>
@@ -445,7 +364,7 @@ bool variable_container<T>::empty() const noexcept
 template <class T>
 bool variable_container<T>::is_contiguous() const noexcept
 {
-    if( m_Type == type::dense || m_Type == type::common )
+    if( mode() == type::dense || mode() == type::common )
         return true;
 
     auto &sparse = Sparse();
@@ -460,7 +379,7 @@ bool variable_container<T>::is_contiguous() const noexcept
 template <class T>
 void variable_container<T>::compress_contiguous()
 {
-    if( m_Type != type::sparse )
+    if( mode() != type::sparse )
         throw std::logic_error("variable_container<T>::compress_contiguous was called for a non-sparse container");
 
     variable_container<T> new_dense(type::dense);