diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9a76569cbf..2b16f4c19f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -59,6 +59,7 @@ Date: 11/28/2023
 - [[PR177]](https://github.com/lanl/singularity-eos/pull/177) added EOSPAC vector functions
 
 ### Changed (changing behavior/API/variables/...)
+- [[PR311]](https://github.com/lanl/singularity-eos/pull/311) Refactor EOSBuilder for flexibility and extensibility
 - [[PR310]](https://github.com/lanl/singularity-eos/pull/310) Speed up and clean up tests
 - [[PR295]](https://github.com/lanl/singularity-eos/pull/295) Add fast logs to singularity-eos
 - [[PR246]](https://github.com/lanl/singularity-eos/pull/246) Update CMake with upstream changes
diff --git a/doc/sphinx/src/modifiers.rst b/doc/sphinx/src/modifiers.rst
index 6fc6b1af15..552b16940b 100644
--- a/doc/sphinx/src/modifiers.rst
+++ b/doc/sphinx/src/modifiers.rst
@@ -195,6 +195,19 @@ Modifiers can be composed. For example:
   using namespace singularity;
   auto my_eos = ShiftedEOS<ScaledEOS<IdealGas>>(ScaledEOS(IdealGas(gm1, Cv), scale), shift);
 
+You can build modifiers up iteratively by, for example:
+
+.. code-block:: cpp
+
+  using namespace singularity;
+  EOS eos = IdealGas(gm1, cv);
+  if (do_shift) {
+    eos = eos.template Modify<ShiftedEOS>(shift);
+  }
+  if (do_scale) {
+    eos = eos.template Modify<ScaledEOS>(scale);
+  }
+
 Undoing Modifiers
 ------------------
 
diff --git a/doc/sphinx/src/using-eos.rst b/doc/sphinx/src/using-eos.rst
index 402f340e96..7f1d975863 100644
--- a/doc/sphinx/src/using-eos.rst
+++ b/doc/sphinx/src/using-eos.rst
@@ -388,6 +388,34 @@ modifiers. However, note that modifiers do not commute, and only one
 order is supported. The ordering, inside-out, is ``UnitSystem`` or
 ``RelativisticEOS``, then ``ScaledEOS``, then ``ShiftedEOS``.
 
+A modified equation of state can be built up iteratively. To check if
+the equation of state currently stored in the variant can modified,
+you may call
+
+.. cpp:function:: bool ModifiedInVariant<Mod>() const;
+
+where ``Mod`` is the type of the modifier you want to apply, for
+example ``ShiftedEOS``. If this function returns true, then you can
+apply a modifier with the function
+
+.. cpp:function:: Variant Modify<Mod>(Args &&..args) const;
+
+where again ``Mod`` is the modifier you wish to apply, and ``args``
+are the arguments to the constructor for that modifier, e.g., the
+shift. For example, one might build up a shifted or scaled eos with a
+code block like this:
+
+.. code-block:: cpp
+
+  using namespace singularity;
+  EOS eos = IdealGas(gm1, cv);
+  if (do_shift) {
+    eos = eos.template Modify<ShiftedEOS>(shift);
+  }
+  if (do_scale) {
+    eos = eos.template Modify<ScaledEOS>(scale);
+  }
+
 Relevant to the broad ``singularity-eos`` API, EOS models provide
 introspection. To check if an EOS is modified, call
 
@@ -470,38 +498,34 @@ temperature or density and specific internal energy.
 EOS Builder
 ------------
 
-The inclusion of modifiers can make building a desired equation of
-state somewhat cumbersome. To handle this, we have implemented the
-``EOSBuilder`` machinery. ``EOSBuilder`` is a set of functions that
-provides a declarative interface for building an equation of state
-object.
+The iterative construction of modifiers described above and in the
+:ref:`modifiers<modifiers>` section is object oriented. For
+convenience, we also provide a procedural, dispatch-based approach in
+the ``EOSBuilder`` namespace and header. The key function is
 
-The EOS Builder functions and types are defined in the
-``singularity::EOSBuilder`` namespace. The key function is
-
-.. cpp:function:: EOS EOSBuilder::buildEOS(EOSBuilder::EOSType t, EOSBuilder::params_t base_params, EOSBuilder::modifiers_t modifiers)
+.. code-block:: cpp
 
-* ``EOSBuilder::EOSType`` is an enum class with names that match the various EOS classes defined in :ref:`the models section <models>`; for example, ``EOSBuilder::EOSType::IdealGas``.
-* ``EOSBuilder::params_t`` is a dictionary object with some type erasure, which maps strings to the types ``std::string``, ``int``, or ``Real``. It is used to map parameter names to their values for class constructors.
-* ``EOSBuilder::modifiers_t`` is a dictionary from the ``EOSModifier`` enum class, which works identically to the ``EOSType`` enum but for modifiers, to ``params_t`` objects, specifying the constructor values for each modifier.
+  template <template <class> typename Mod, typename... Ts, typename... Args>
+  singularity::Variant<Ts...> Modify(const Variant<Ts...> &eos, Args &&...args);
 
-Putting it all together, initializing an ``IdealGas`` with
-``EOSBuilder`` looks something like this:
+where ``Mod`` is an EOS modifier, ``Variant`` is either your
+user-defined custom EOS variant type, or the pre-defined ``EOS`` type,
+the ``eos`` object is an EOS you'd like to modify (stored as a
+variant), and ``args`` are the additional arguments to the constructor
+of ``Mod`` beyond the object to modify. For example, initializing an
+``IdealGas`` equation of state that is optionally shifted and scaled
+might look something like this:
 
 .. code-block:: cpp
 
   using namespace singularity;
-  EOSBuilder::EOSType type = EOSBuilder::EOSType::IdealGas;
-  EOSBuilder::modifiers_t modifiers;
-  EOSBuilder::params_t base_params, shifted_params, scaled_params;
-  base_params["Cv"].emplace<Real>(Cv);
-  base_params["gm1"].emplace<Real>(gm1);
-  shifted_params["shift"].emplace<Real>(shift);
-  scaled_params["scale"].emplace<Real>(scale);
-  modifiers[EOSBuilder::EOSModifier::Shifted] = shifted_params;
-  modifiers[EOSBuilder::EOSModifier::Scaled] = scaled_params;
-  EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
-
+  EOS eos = IdealGas(gm1, cv);
+  if (do_shift) {
+    eos = EOSBuilder::Modify<ShiftedEOS>(eos, shift);
+  }
+  if (do_scale) {
+    eos = EOSBuilder::Modify<ScaledEOS>(eos, scale);
+  }
 
 .. _eos methods reference section:
 
diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index 2bb81e1b4b..46c86316a7 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -45,9 +45,7 @@ set(EOS_HEADERS
     eos/eos_stiff.hpp
 )
 
-set(EOS_SRCS
-    eos/eos_builder.cpp
-)
+set(EOS_SRCS eos/eos.cpp)
 
 if (SINGULARITY_BUILD_CLOSURE)
   list(APPEND EOS_HEADERS
diff --git a/singularity-eos/base/variadic_utils.hpp b/singularity-eos/base/variadic_utils.hpp
index 2d1aa9f7de..50e9b14269 100644
--- a/singularity-eos/base/variadic_utils.hpp
+++ b/singularity-eos/base/variadic_utils.hpp
@@ -18,7 +18,35 @@
 #include <type_traits>
 
 namespace singularity {
-namespace detail {
+namespace variadic_utils {
+
+// Some generic variatic utilities
+// ======================================================================
+
+// Backport of C++17 bool_constant.
+// With C++17, can be replaced with
+// using std::bool_constant
+template <bool B>
+using bool_constant = std::integral_constant<bool, B>;
+
+// Implementation of std::conjunction/std::disjunction without C++17
+// With C++17, can be replaced with
+// using std::disjunction
+template <bool...>
+struct bool_pack {};
+template <bool... Bs>
+using conjunction = std::is_same<bool_pack<true, Bs...>, bool_pack<Bs..., true>>;
+template <bool... Bs>
+struct disjunction : bool_constant<!conjunction<!Bs...>::value> {};
+
+// Checks if T is contained in the pack Ts
+template <typename T, typename... Ts>
+using contains = disjunction<std::is_same<T, Ts>::value...>;
+
+template <typename T, typename... Ts>
+constexpr bool contains_v() {
+  return contains<T, Ts...>::value;
+}
 
 // variadic list
 template <typename... Ts>
@@ -156,7 +184,7 @@ constexpr auto pack_size(type_list<Ts...>) {
   return sizeof...(Ts);
 }
 
-} // namespace detail
+} // namespace variadic_utils
 } // namespace singularity
 
 #endif // SINGULARITY_EOS_BASE_VARIADIC_UTILS_HPP_
diff --git a/singularity-eos/eos/eos.cpp b/singularity-eos/eos/eos.cpp
new file mode 100644
index 0000000000..d791059870
--- /dev/null
+++ b/singularity-eos/eos/eos.cpp
@@ -0,0 +1,45 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+// JMM: This is a dummy file to provide a source file for cmake to
+// compile when built without fortran.
+//
+// The main reason to do this is that when we build without fortran
+// bindings, the library is completely header only. However WITH
+// fortran bindings, it is not.
+//
+// cmake supports a build mode for header only libraries by marking
+// those libraries INTERFACE. Without this flag, a few things will go
+// wrong:
+// 1. CMake will be unable to infer a proper linker
+//    so one must be specified by hand.
+// 2. no dynamic library file (e.g., "*.a") will be generated,
+//    but dependencies that link against it, such as another library,
+//    or in our case, tests, will look for it. This will lead to
+//    a failure of the downstream library at link time.
+//
+// On the other hand, a library with implementation files
+// CANNOT be marked INTERFACE, as otherwise source files will
+// not be compiled.
+//
+// Unfortunately, switching the INTERFACE tag on and off in cmake
+// is very cumbersome, as if a library is marked INTERFACE
+// all its dependencies must ALSO be slurped in with an INTERFACE
+// flag. This introduces significant branching in the cmake code
+// and a lot of builer plate. For now, then, I simply include this
+// empty source file.
+//
+// In the future, we could include centralized code here that we
+// always want compiled, such as template instantiations or
+// convenience functions.
diff --git a/singularity-eos/eos/eos.hpp b/singularity-eos/eos/eos.hpp
index 82dc1743d8..69a839235a 100644
--- a/singularity-eos/eos/eos.hpp
+++ b/singularity-eos/eos/eos.hpp
@@ -57,13 +57,13 @@ namespace singularity {
 
 // recreate variadic list
 template <typename... Ts>
-using tl = singularity::detail::type_list<Ts...>;
+using tl = singularity::variadic_utils::type_list<Ts...>;
 
 template <template <typename> class... Ts>
-using al = singularity::detail::adapt_list<Ts...>;
+using al = singularity::variadic_utils::adapt_list<Ts...>;
 
 // transform variadic list: applies modifiers to eos's
-using singularity::detail::transform_variadic_list;
+using singularity::variadic_utils::transform_variadic_list;
 
 // all eos's
 static constexpr const auto full_eos_list =
@@ -117,13 +117,13 @@ static constexpr const auto scaled_1 =
     transform_variadic_list(full_eos_list, al<ScaledEOS>{});
 // relativistic and unit system modifiers
 static constexpr const auto unit_or_rel =
-    singularity::detail::concat(unit_system, relativistic);
+    singularity::variadic_utils::concat(unit_system, relativistic);
 // variadic list of eos with shifted, relativistic or unit system modifiers
 static constexpr const auto shifted_of_unit_or_rel =
     transform_variadic_list(unit_or_rel, al<ShiftedEOS>{});
 // combined list of all shifted EOS
 static constexpr const auto shifted =
-    singularity::detail::concat(shifted_1, shifted_of_unit_or_rel);
+    singularity::variadic_utils::concat(shifted_1, shifted_of_unit_or_rel);
 // variadic list of eos with scaled, relativistic or unit system modifiers
 static constexpr const auto scaled_of_unit_or_rel =
     transform_variadic_list(unit_or_rel, al<ScaledEOS>{});
@@ -131,17 +131,17 @@ static constexpr const auto scaled_of_unit_or_rel =
 static constexpr const auto scaled_of_shifted =
     transform_variadic_list(shifted, al<ScaledEOS>{});
 // combined list of all scaled EOS
-static constexpr const auto scaled =
-    singularity::detail::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
+static constexpr const auto scaled = singularity::variadic_utils::concat(
+    scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
 // create combined list
 static constexpr const auto combined_list_1 =
-    singularity::detail::concat(full_eos_list, shifted, scaled, unit_or_rel);
+    singularity::variadic_utils::concat(full_eos_list, shifted, scaled, unit_or_rel);
 // make a ramped eos of everything
 static constexpr const auto ramped_all =
     transform_variadic_list(combined_list_1, al<BilinearRampEOS>{});
 // final combined list
 static constexpr const auto combined_list =
-    singularity::detail::concat(combined_list_1, ramped_all);
+    singularity::variadic_utils::concat(combined_list_1, ramped_all);
 // a function that returns a Variant from a typelist
 template <typename... Ts>
 struct tl_to_Variant_struct {
diff --git a/singularity-eos/eos/eos_base.hpp b/singularity-eos/eos/eos_base.hpp
index 120c8434d5..cc40752045 100644
--- a/singularity-eos/eos/eos_base.hpp
+++ b/singularity-eos/eos/eos_base.hpp
@@ -20,6 +20,7 @@
 
 #include <ports-of-call/portability.hpp>
 #include <ports-of-call/portable_errors.hpp>
+#include <singularity-eos/base/variadic_utils.hpp>
 
 namespace singularity {
 namespace mfuncname {
@@ -137,6 +138,39 @@ class EosBase {
     f(copy);
   }
 
+  // EOS builder helpers
+  // Checks if an EOS can be modified
+  template <template <class> typename Mod, typename... Ts>
+  constexpr bool ModifiedInList() const {
+    return variadic_utils::contains_v<Mod<CRTP>, Ts...>();
+  }
+  // Modifies an EOS object by pulling out underlying type and modifying it
+  // This one returns Mod<CRT>
+  template <template <class> typename Mod, typename... Args>
+  constexpr Mod<CRTP> Modify(Args &&...args) const {
+    CRTP unmodified = *(static_cast<CRTP const *>(this));
+    return Mod<CRTP>(std::move(unmodified), std::forward<Args>(args)...);
+  }
+  // These are overloads needed for the variant, as std::visit must be
+  // able to return a variant of the same type every time. This lets
+  // us do so, even though sometimes we don't modify the object.
+  template <template <class> typename Mod, typename... Args>
+  constexpr Mod<CRTP> ConditionallyModify(std::true_type, Args &&...args) const {
+    return Modify<Mod>(std::forward<Args>(args)...);
+  }
+  template <template <class> typename Mod, typename... Args>
+  constexpr CRTP ConditionallyModify(std::false_type, Args &&...args) const {
+    CRTP unmodified = *(static_cast<CRTP const *>(this));
+    return unmodified;
+  }
+  template <template <class> typename Mod, typename... Ts, typename... Args>
+  constexpr auto ConditionallyModify(const variadic_utils::type_list<Ts...> &tl,
+                                     Args &&...args) const {
+    constexpr bool do_mod = variadic_utils::contains_v<Mod<CRTP>, Ts...>();
+    return ConditionallyModify<Mod>(variadic_utils::bool_constant<do_mod>(),
+                                    std::forward<Args>(args)...);
+  }
+
   // Vector member functions
   template <typename RealIndexer, typename ConstRealIndexer, typename LambdaIndexer>
   inline void
diff --git a/singularity-eos/eos/eos_builder.cpp b/singularity-eos/eos/eos_builder.cpp
deleted file mode 100644
index 60bd649fc8..0000000000
--- a/singularity-eos/eos/eos_builder.cpp
+++ /dev/null
@@ -1,241 +0,0 @@
-//------------------------------------------------------------------------------#
-// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
-// program was produced under U.S. Government contract 89233218CNA000001
-// for Los Alamos National Laboratory (LANL), which is operated by Triad
-// National Security, LLC for the U.S.  Department of Energy/National
-// Nuclear Security Administration. All rights in the program are
-// reserved by Triad National Security, LLC, and the U.S. Department of
-// Energy/National Nuclear Security Administration. The Government is
-// granted for itself and others acting on its behalf a nonexclusive,
-// paid-up, irrevocable worldwide license in this material to reproduce,
-// prepare derivative works, distribute copies to the public, perform
-// publicly and display publicly, and to permit others to do so.
-//------------------------------------------------------------------------------#
-
-#include <iostream> // debug
-#include <singularity-eos/eos/eos_builder.hpp>
-
-#define GETBASE(T, N) T N = mpark::get<T>(base_params[#N])
-
-namespace singularity {
-
-EOS EOSBuilder::buildEOS(EOSBuilder::EOSType type, EOSBuilder::params_t base_params,
-                         EOSBuilder::modifiers_t modifiers) {
-  using namespace EOSBuilder;
-  using std::string;
-  bool scaled = (modifiers.count(EOSModifier::Scaled) > 0);
-  bool shifted = (modifiers.count(EOSModifier::Shifted) > 0);
-  bool relativistic = (modifiers.count(EOSModifier::Relativistic) > 0);
-  bool units = (modifiers.count(EOSModifier::UnitSystem) > 0);
-  bool ramped = (modifiers.count(EOSModifier::BilinearRamp) > 0);
-  if ((shifted || scaled || relativistic || units || ramped) && !(isModifiable(type))) {
-    EOS_ERROR("Modifiers not supported for this EOS");
-  }
-  if (relativistic && (shifted || scaled || units)) {
-    EOS_ERROR("Relativistic modifier currently must be applied alone");
-  }
-  if (units && (shifted || scaled || relativistic)) {
-    EOS_ERROR("Unit System modifier currently must be applied alone");
-  }
-  Real scale = 1;
-  if (scaled) {
-    scale = mpark::get<Real>(modifiers[EOSModifier::Scaled]["scale"]);
-  }
-  Real shift = 0;
-  if (shifted) {
-    shift = mpark::get<Real>(modifiers[EOSModifier::Shifted]["shift"]);
-  }
-  Real cl = 2.99792458e8; // speed of light in cm/s
-  if (relativistic && (modifiers[EOSModifier::Relativistic].count("cl") > 0)) {
-    cl = mpark::get<Real>(modifiers[EOSModifier::Relativistic]["cl"]);
-  }
-  bool use_length_time = false;
-  if (units && (modifiers[EOSModifier::UnitSystem].count("use_length_time") > 0)) {
-    use_length_time =
-        mpark::get<bool>(modifiers[EOSModifier::UnitSystem]["use_length_time"]);
-  }
-  Real r0 = 0;
-  Real a = 1;
-  Real b = 0;
-  Real c = 0;
-  if (ramped) {
-    r0 = mpark::get<Real>(modifiers[EOSModifier::BilinearRamp]["r0"]);
-    a = mpark::get<Real>(modifiers[EOSModifier::BilinearRamp]["a"]);
-    b = mpark::get<Real>(modifiers[EOSModifier::BilinearRamp]["b"]);
-    c = mpark::get<Real>(modifiers[EOSModifier::BilinearRamp]["c"]);
-  }
-  Real rho_unit = 1;
-  Real sie_unit = 1;
-  Real temp_unit = 1;
-  Real time_unit = 1;
-  Real mass_unit = 1;
-  Real length_unit = 1;
-  if (units) {
-    if (use_length_time) {
-      if (modifiers[EOSModifier::UnitSystem].count("time_unit") > 0) {
-        time_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["time_unit"]);
-      }
-      if (modifiers[EOSModifier::UnitSystem].count("mass_unit") > 0) {
-        mass_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["mass_unit"]);
-      }
-      if (modifiers[EOSModifier::UnitSystem].count("length_unit") > 0) {
-        length_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["length_unit"]);
-      }
-    } else {
-      if (modifiers[EOSModifier::UnitSystem].count("rho_unit") > 0) {
-        rho_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["rho_unit"]);
-      }
-      if (modifiers[EOSModifier::UnitSystem].count("sie_unit") > 0) {
-        sie_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["sie_unit"]);
-      }
-    }
-    if (modifiers[EOSModifier::UnitSystem].count("temp_unit") > 0) {
-      temp_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["temp_unit"]);
-    }
-  }
-  if (type == EOSType::IdealGas) {
-    Real gm1 = mpark::get<Real>(base_params["gm1"]);
-    Real Cv = mpark::get<Real>(base_params["Cv"]);
-    IdealGas g(gm1, Cv);
-    if (units) {
-      return makeUnitSystem(std::move(g), use_length_time, rho_unit, sie_unit, temp_unit,
-                            time_unit, mass_unit, length_unit);
-    }
-    if (relativistic) {
-      return makeRelativistic(std::move(g), cl);
-    }
-    return applyShiftAndScaleAndBilinearRamp(std::move(g), scaled, shifted, ramped, scale,
-                                             shift, r0, a, b, c);
-  }
-#ifdef SINGULARITY_USE_SPINER_WITH_HDF5
-  if (type == EOSType::SpinerEOSDependsRhoT || type == EOSType::SpinerEOSDependsRhoSie) {
-    string filename = mpark::get<string>(base_params["filename"]);
-    bool reproducibility_mode = mpark::get<bool>(base_params["reproducibility_mode"]);
-    if (base_params.count("matid") > 0) {
-      int matid = mpark::get<int>(base_params["matid"]);
-      if (type == EOSType::SpinerEOSDependsRhoT) {
-        SpinerEOSDependsRhoT s(filename, matid, reproducibility_mode);
-        if (units) {
-          return makeUnitSystem(std::move(s), use_length_time, rho_unit, sie_unit,
-                                temp_unit, time_unit, mass_unit, length_unit);
-        }
-        if (relativistic) {
-          return makeRelativistic(std::move(s), cl);
-        }
-        return applyShiftAndScale(std::move(s), scaled, shifted, scale, shift);
-      } else {
-        SpinerEOSDependsRhoSie s(filename, matid, reproducibility_mode);
-        if (units) {
-          return makeUnitSystem(std::move(s), use_length_time, rho_unit, sie_unit,
-                                temp_unit, time_unit, mass_unit, length_unit);
-        }
-        if (relativistic) {
-          return makeRelativistic(std::move(s), cl);
-        }
-        return applyShiftAndScaleAndBilinearRamp(std::move(s), scaled, shifted, ramped,
-                                                 scale, shift, r0, a, b, c);
-      }
-    } else {
-      string materialName = mpark::get<string>(base_params["materialName"]);
-      if (type == EOSType::SpinerEOSDependsRhoT) {
-        SpinerEOSDependsRhoT s(filename, materialName, reproducibility_mode);
-        if (units) {
-          return makeUnitSystem(std::move(s), use_length_time, rho_unit, sie_unit,
-                                temp_unit, time_unit, mass_unit, length_unit);
-        }
-        if (relativistic) {
-          return makeRelativistic(std::move(s), cl);
-        }
-        return applyShiftAndScale(std::move(s), scaled, shifted, scale, shift);
-      } else {
-        SpinerEOSDependsRhoSie s(filename, materialName, reproducibility_mode);
-        if (units) {
-          return makeUnitSystem(std::move(s), use_length_time, rho_unit, sie_unit,
-                                temp_unit, time_unit, mass_unit, length_unit);
-        }
-        if (relativistic) {
-          return makeRelativistic(std::move(s), cl);
-        }
-        return applyShiftAndScaleAndBilinearRamp(std::move(s), scaled, shifted, ramped,
-                                                 scale, shift, r0, a, b, c);
-      }
-    }
-  }
-  if (type == EOSType::StellarCollapse) {
-    string filename = mpark::get<string>(base_params["filename"]);
-    bool use_sp5 = false;
-    if (base_params.count("use_sp5") > 0) {
-      use_sp5 = mpark::get<bool>(base_params["use_sp5"]);
-    }
-    bool filter_bmod = true;
-    if (base_params.count("filter_bmod") > 0) {
-      filter_bmod = mpark::get<bool>(base_params["filter_bmod"]);
-    }
-    StellarCollapse s(filename, use_sp5, filter_bmod);
-    if (units) {
-      return makeUnitSystem(std::move(s), use_length_time, rho_unit, sie_unit, temp_unit,
-                            time_unit, mass_unit, length_unit);
-    }
-    if (relativistic) {
-      return makeRelativistic(std::move(s), cl);
-    }
-    return applyShiftAndScaleAndBilinearRamp(std::move(s), scaled, shifted, ramped, scale,
-                                             shift, r0, a, b, c);
-  }
-#endif
-  if (type == EOSType::Gruneisen) {
-    Real C0 = mpark::get<Real>(base_params["C0"]);
-    Real s1 = mpark::get<Real>(base_params["s1"]);
-    Real s2 = mpark::get<Real>(base_params["s2"]);
-    Real s3 = mpark::get<Real>(base_params["s3"]);
-    Real G0 = mpark::get<Real>(base_params["G0"]);
-    Real b = mpark::get<Real>(base_params["b"]);
-    Real rho0 = mpark::get<Real>(base_params["rho0"]);
-    Real T0 = mpark::get<Real>(base_params["T0"]);
-    Real P0 = mpark::get<Real>(base_params["P0"]);
-    Real Cv = mpark::get<Real>(base_params["Cv"]);
-    return Gruneisen(C0, s1, s2, s3, G0, b, rho0, T0, P0, Cv);
-  }
-  if (type == EOSType::JWL) {
-    GETBASE(Real, A); // I got tired of writing this over and over
-    GETBASE(Real, B);
-    GETBASE(Real, R1);
-    GETBASE(Real, R2);
-    GETBASE(Real, w);
-    GETBASE(Real, rho0);
-    GETBASE(Real, Cv);
-    return JWL(A, B, R1, R2, w, rho0, Cv);
-  }
-  if (type == EOSType::DavisReactants) {
-    GETBASE(Real, rho0);
-    GETBASE(Real, e0);
-    GETBASE(Real, P0);
-    GETBASE(Real, T0);
-    GETBASE(Real, A);
-    GETBASE(Real, B);
-    GETBASE(Real, C);
-    GETBASE(Real, G0);
-    GETBASE(Real, Z);
-    GETBASE(Real, alpha);
-    GETBASE(Real, Cv0);
-    return DavisReactants(rho0, e0, P0, T0, A, B, C, G0, Z, alpha, Cv0);
-  }
-  if (type == EOSType::DavisProducts) {
-    GETBASE(Real, a);
-    GETBASE(Real, b);
-    GETBASE(Real, k);
-    GETBASE(Real, n);
-    GETBASE(Real, vc);
-    GETBASE(Real, pc);
-    GETBASE(Real, Cv);
-    GETBASE(Real, E0);
-    return DavisProducts(a, b, k, n, vc, pc, Cv, E0);
-  }
-  exit(1);
-}
-
-bool EOSBuilder::isModifiable(EOSBuilder::EOSType type) {
-  return EOSBuilder::modifiable.count(type) > 0;
-}
-
-} // namespace singularity
diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index 8f094d934d..fce5e8650b 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -15,129 +15,42 @@
 #ifndef _SINGULARITY_EOS_EOS_EOS_BUILDER_HPP_
 #define _SINGULARITY_EOS_EOS_EOS_BUILDER_HPP_
 
-#include <map>
-#include <mpark/variant.hpp>
+#include <utility>
+
 #include <ports-of-call/portability.hpp>
-#include <singularity-eos/eos/eos.hpp>
-#include <string>
-#include <unordered_set>
 
-namespace singularity {
+#include <singularity-eos/base/variadic_utils.hpp>
+#include <singularity-eos/eos/eos_variant.hpp>
 
+namespace singularity {
 namespace EOSBuilder {
 
-// TODO(JMM): This could be strings? Or at least use a macro so we
-// only have to write these down once?
-// strings might allow us to create these structrs more easily
-// in the host code.
-enum class EOSType {
-  IdealGas,
-  Gruneisen,
-  JWL,
-  DavisReactants,
-  DavisProducts
-#ifdef SINGULARITY_USE_SPINER_WITH_HDF5
-  ,
-  SpinerEOSDependsRhoT,
-  SpinerEOSDependsRhoSie,
-  StellarCollapse
-#endif
-};
-enum class EOSModifier { Scaled, Shifted, Relativistic, UnitSystem, BilinearRamp };
-
-// evil type erasure
-using param_t = mpark::variant<bool, int, Real, std::string>;
-using params_t = std::map<std::string, param_t>;
-using modifiers_t = std::map<EOSModifier, params_t>;
-const params_t NO_PARAMS;
-
-// TODO: Extend if needed
-const std::unordered_set<EOSType> modifiable({EOSType::IdealGas
-#ifdef SINGULARITY_USE_SPINER_WITH_HDF5
-                                              ,
-                                              EOSType::SpinerEOSDependsRhoT,
-                                              EOSType::SpinerEOSDependsRhoSie,
-                                              EOSType::StellarCollapse
-#endif
-});
-bool isModifiable(EOSType t);
-EOS buildEOS(EOSType type, params_t base_params, modifiers_t modifiers);
-inline auto buildEOS(EOSType type, params_t base_params) {
-  modifiers_t modifiers;
-  return buildEOS(type, base_params, modifiers);
-}
-
-template <typename T>
-EOS makeUnitSystem(T &&eos, bool use_length_time, Real rho_unit, Real sie_unit,
-                   Real temp_unit, Real time_unit, Real mass_unit, Real length_unit) {
-  if (use_length_time) {
-    return UnitSystem<T>(std::move(eos), eos_units_init::length_time_units_init_tag,
-                         time_unit, mass_unit, length_unit, temp_unit);
-  } else {
-    return UnitSystem<T>(std::move(eos), eos_units_init::thermal_units_init_tag, rho_unit,
-                         sie_unit, temp_unit);
-  }
-}
+// Just import the variadic utils namespace int the EOSBuilder
+// namespace.
+using namespace variadic_utils;
 
-template <typename T>
-EOS makeRelativistic(T &&eos, Real cl) {
-  return RelativisticEOS<T>(std::move(eos), cl);
+template <template <class...> typename Mod, typename U, typename... Ts>
+using IsModifiable =
+    conjunction<contains<U, Ts...>::value, contains<Mod<U>, Ts...>::value>;
+template <template <class...> typename Mod, typename U, typename... Ts>
+constexpr bool is_modifiable(const type_list<Ts...> &var) {
+  return IsModifiable<Mod, U, Ts...>::value;
 }
-
-template <typename T>
-EOS makeBilinearRamp(T &&eos, Real r0, Real a, Real b, Real c) {
-  return BilinearRampEOS<T>(std::forward<T>(eos), r0, a, b, c);
+template <template <class...> typename Mod, typename U, typename... Ts>
+constexpr bool is_modifiable(const Variant<Ts...> &var) {
+  return IsModifiable<Mod, U, Ts...>::value;
 }
-
-template <typename T>
-EOS applyShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift) {
-  if (shifted && scaled) {
-    ShiftedEOS<T> a(std::forward<T>(eos), shift);
-    ScaledEOS<ShiftedEOS<T>> b(std::move(a), scale);
-    return b;
-  }
-  if (shifted) {
-    return ShiftedEOS<T>(std::forward<T>(eos), shift);
-  }
-  if (scaled) {
-    return ScaledEOS<T>(std::forward<T>(eos), scale);
-  }
-  return eos;
+template <template <class...> typename Mod, typename U, typename... Ts>
+constexpr bool is_modifiable(const U &u, const Variant<Ts...> &var) {
+  return IsModifiable<Mod, U, Ts...>::value;
 }
 
-template <typename T, template <typename> class W, typename... ARGS>
-EOS applyWrappedShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift,
-                              ARGS... args) {
-  if (shifted && scaled) {
-    ShiftedEOS<T> a(std::forward<T>(eos), shift);
-    ScaledEOS<ShiftedEOS<T>> b(std::move(a), scale);
-    W<ScaledEOS<ShiftedEOS<T>>> c(std::move(b), args...);
-    return c;
-  }
-  if (shifted) {
-    ShiftedEOS<T> sh_eos(std::forward<T>(eos), shift);
-    return W<ShiftedEOS<T>>(std::move(sh_eos), args...);
-  }
-  if (scaled) {
-    ScaledEOS<T> sc_eos(std::forward<T>(eos), scale);
-    return W<ScaledEOS<T>>(std::move(sc_eos), args...);
-  }
-  return W<T>(std::forward<T>(eos), args...);
+template <template <class> typename Mod, typename... Ts, typename... Args>
+Variant<Ts...> Modify(const Variant<Ts...> &var, Args &&...args) {
+  return var.template Modify<Mod>(std::forward<Args>(args)...);
 }
 
-template <typename T>
-EOS applyShiftAndScaleAndBilinearRamp(T &&eos, bool scaled, bool shifted, bool ramped,
-                                      Real scale, Real shift, Real r0, Real a, Real b,
-                                      Real c) {
-  if (ramped) {
-    return applyWrappedShiftAndScale<T, BilinearRampEOS>(
-        std::forward<T>(eos), scaled, shifted, scale, shift, r0, a, b, c);
-  } else {
-    return applyShiftAndScale(std::forward<T>(eos), scaled, shifted, scale, shift);
-  }
-}
 } // namespace EOSBuilder
-
 } // namespace singularity
 
 #endif // _SINGULARITY_EOS_EOS_EOS_BUILDER_HPP_
diff --git a/singularity-eos/eos/eos_variant.hpp b/singularity-eos/eos/eos_variant.hpp
index f9e7813859..7836364633 100644
--- a/singularity-eos/eos/eos_variant.hpp
+++ b/singularity-eos/eos/eos_variant.hpp
@@ -17,6 +17,8 @@
 
 #include <mpark/variant.hpp>
 #include <ports-of-call/portability.hpp>
+#include <ports-of-call/portable_errors.hpp>
+#include <singularity-eos/base/variadic_utils.hpp>
 #include <singularity-eos/eos/eos_base.hpp>
 
 using Real = double;
@@ -62,7 +64,7 @@ class Variant {
             typename std::enable_if<
                 !std::is_same<Variant, typename std::decay<EOSChoice>::type>::value,
                 bool>::type = true>
-  PORTABLE_INLINE_FUNCTION EOSChoice get() {
+  PORTABLE_INLINE_FUNCTION EOSChoice get() const {
     return mpark::get<EOSChoice>(eos_);
   }
 
@@ -77,6 +79,25 @@ class Variant {
     return mpark::visit([&f](const auto &eos) { return eos.Evaluate(f); }, eos_);
   }
 
+  // EOS modifier object-oriented API
+  template <template <class> typename Mod>
+  constexpr bool ModifiedInVariant() const {
+    return mpark::visit(
+        [](const auto &eos) { return eos.template ModifiedInList<Mod, EOSs...>(); },
+        eos_);
+  }
+  template <template <class> typename Mod, typename... Args>
+  constexpr auto Modify(Args &&...args) const {
+    PORTABLE_ALWAYS_REQUIRE(ModifiedInVariant<Mod>(), "Modifier must be in variant");
+    return mpark::visit(
+        [&](const auto &eos) {
+          auto modified = eos.template ConditionallyModify<Mod>(
+              variadic_utils::type_list<EOSs...>(), std::forward<Args>(args)...);
+          return eos_variant<EOSs...>(modified);
+        },
+        eos_);
+  }
+
   PORTABLE_INLINE_FUNCTION
   Real TemperatureFromDensityInternalEnergy(const Real rho, const Real sie,
                                             Real *lambda = nullptr) const {
@@ -980,12 +1001,18 @@ class Variant {
 
   inline constexpr Variant UnmodifyOnce() {
     return mpark::visit(
-        [](auto &eos) { return eos_variant<EOSs...>(eos.UnmodifyOnce()); }, eos_);
+        [](auto &eos) -> eos_variant<EOSs...> {
+          return eos_variant<EOSs...>(eos.UnmodifyOnce());
+        },
+        eos_);
   }
 
   inline constexpr Variant GetUnmodifiedObject() {
     return mpark::visit(
-        [](auto &eos) { return eos_variant<EOSs...>(eos.GetUnmodifiedObject()); }, eos_);
+        [](auto &eos) -> eos_variant<EOSs...> {
+          return eos_variant<EOSs...>(eos.GetUnmodifiedObject());
+        },
+        eos_);
   }
 
   PORTABLE_INLINE_FUNCTION
diff --git a/singularity-eos/eos/singularity_eos.cpp b/singularity-eos/eos/singularity_eos.cpp
index 0b4b68a9b1..e000bfe268 100644
--- a/singularity-eos/eos/singularity_eos.cpp
+++ b/singularity-eos/eos/singularity_eos.cpp
@@ -20,6 +20,56 @@
 
 using namespace singularity;
 
+// TODO: Replace these with the new Modify method in EOSBuilder.
+// NOTE: The new EOSBuilder machinery will likely be slower than these.
+template <typename T>
+EOS applyShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift) {
+  if (shifted && scaled) {
+    ShiftedEOS<T> a(std::forward<T>(eos), shift);
+    ScaledEOS<ShiftedEOS<T>> b(std::move(a), scale);
+    return b;
+  }
+  if (shifted) {
+    return ShiftedEOS<T>(std::forward<T>(eos), shift);
+  }
+  if (scaled) {
+    return ScaledEOS<T>(std::forward<T>(eos), scale);
+  }
+  return eos;
+}
+
+template <typename T, template <typename> class W, typename... ARGS>
+EOS applyWrappedShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift,
+                              ARGS... args) {
+  if (shifted && scaled) {
+    ShiftedEOS<T> a(std::forward<T>(eos), shift);
+    ScaledEOS<ShiftedEOS<T>> b(std::move(a), scale);
+    W<ScaledEOS<ShiftedEOS<T>>> c(std::move(b), args...);
+    return c;
+  }
+  if (shifted) {
+    ShiftedEOS<T> sh_eos(std::forward<T>(eos), shift);
+    return W<ShiftedEOS<T>>(std::move(sh_eos), args...);
+  }
+  if (scaled) {
+    ScaledEOS<T> sc_eos(std::forward<T>(eos), scale);
+    return W<ScaledEOS<T>>(std::move(sc_eos), args...);
+  }
+  return W<T>(std::forward<T>(eos), args...);
+}
+
+template <typename T>
+EOS applyShiftAndScaleAndBilinearRamp(T &&eos, bool scaled, bool shifted, bool ramped,
+                                      Real scale, Real shift, Real r0, Real a, Real b,
+                                      Real c) {
+  if (ramped) {
+    return applyWrappedShiftAndScale<T, BilinearRampEOS>(
+        std::forward<T>(eos), scaled, shifted, scale, shift, r0, a, b, c);
+  } else {
+    return applyShiftAndScale(std::forward<T>(eos), scaled, shifted, scale, shift);
+  }
+}
+
 int init_sg_eos(const int nmat, EOS *&eos) {
 #ifdef PORTABILITY_STRATEGY_KOKKOS
   if (!Kokkos::is_initialized()) Kokkos::initialize();
@@ -32,12 +82,12 @@ int init_sg_eos(const int nmat, EOS *&eos) {
 // apply everything but ramp in order to possibly calculate the
 // SAP ramp parameters from p-alhpa ramp parameters
 #define SGAPPLYMODSIMPLE(A)                                                              \
-  EOSBuilder::applyShiftAndScale(A, enabled[0] == 1, enabled[1] == 1, vals[0], vals[1])
+  applyShiftAndScale(A, enabled[0] == 1, enabled[1] == 1, vals[0], vals[1])
 
 #define SGAPPLYMOD(A)                                                                    \
-  EOSBuilder::applyShiftAndScaleAndBilinearRamp(                                         \
-      A, enabled[0] == 1, enabled[1] == 1, enabled[2] == 1 || enabled[3] == 1, vals[0],  \
-      vals[1], vals[2], vals[3], vals[4], vals[5])
+  applyShiftAndScaleAndBilinearRamp(A, enabled[0] == 1, enabled[1] == 1,                 \
+                                    enabled[2] == 1 || enabled[3] == 1, vals[0],         \
+                                    vals[1], vals[2], vals[3], vals[4], vals[5])
 
 int def_en[4] = {0, 0, 0, 0};
 double def_v[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 80b1097329..e856ee532e 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -29,6 +29,7 @@ add_executable(
   test_eos_modifiers.cpp
   test_eos_vector.cpp
   test_math_utils.cpp
+  test_variadic_utils.cpp
   )
 
 add_executable(
diff --git a/test/compare_on_data.cpp b/test/compare_on_data.cpp
index 3d7506532e..12f4f1f820 100644
--- a/test/compare_on_data.cpp
+++ b/test/compare_on_data.cpp
@@ -212,15 +212,10 @@ void load_eos_spiner(const std::string &filename, const std::vector<int> &matids
                      std::vector<EOS> &eos_h, std::vector<EOS> &eos_d) {
   eos_h.clear();
   eos_d.clear();
-  EOSBuilder::EOSType type = EOSBuilder::EOSType::SpinerEOSDependsRhoT;
-  EOSBuilder::params_t params;
-  params["filename"] = filename;
-  params["reproducibility_mode"] = false;
 
   for (int matid : matids) {
     if (matid > 0) { // non-analytic
-      params["matid"] = matid;
-      eos_h.push_back(EOSBuilder::buildEOS(type, params));
+      eos_h.push_back(SpinerEOSDependsRhoT(filename, matid));
       eos_d.push_back(eos_h.back().GetOnDevice());
     }
   }
diff --git a/test/test_eos_modifiers.cpp b/test/test_eos_modifiers.cpp
index 2c6f9f3d29..e6621d71b3 100644
--- a/test/test_eos_modifiers.cpp
+++ b/test/test_eos_modifiers.cpp
@@ -27,14 +27,72 @@
 
 #include <test/eos_unit_test_helpers.hpp>
 
+namespace eos_units_init = singularity::eos_units_init;
+
+namespace EOSBuilder = singularity::EOSBuilder;
+namespace thermalqs = singularity::thermalqs;
+namespace variadic_utils = singularity::variadic_utils;
+
+using EOSBuilder::Modify;
 using singularity::BilinearRampEOS;
-using singularity::EOS;
 using singularity::IdealGas;
+using singularity::RelativisticEOS;
 using singularity::ScaledEOS;
 using singularity::ShiftedEOS;
+using singularity::UnitSystem;
 
-namespace EOSBuilder = singularity::EOSBuilder;
-namespace thermalqs = singularity::thermalqs;
+// recreate variadic list
+template <typename... Ts>
+using tl = variadic_utils::type_list<Ts...>;
+
+template <template <typename> class... Ts>
+using al = variadic_utils::adapt_list<Ts...>;
+
+// transform variadic list: applies modifiers to eos's
+using variadic_utils::transform_variadic_list;
+
+static constexpr const auto full_eos_list = tl<IdealGas>{};
+static constexpr const auto relativistic_eos_list = tl<IdealGas>{};
+static constexpr const auto unit_system_eos_list = tl<IdealGas>{};
+static constexpr const auto apply_to_all = al<ScaledEOS, ShiftedEOS>{};
+static constexpr const auto unit_system =
+    transform_variadic_list(unit_system_eos_list, al<UnitSystem>{});
+// variadic list of eos's with shifted or scaled modifiers
+static constexpr const auto shifted_1 =
+    transform_variadic_list(full_eos_list, al<ShiftedEOS>{});
+static constexpr const auto scaled_1 =
+    transform_variadic_list(full_eos_list, al<ScaledEOS>{});
+// variadic list of Relativistic<T>'s
+static constexpr const auto relativistic =
+    transform_variadic_list(relativistic_eos_list, al<RelativisticEOS>{});
+// relativistic and unit system modifiers
+static constexpr const auto unit_or_rel =
+    variadic_utils::concat(unit_system, relativistic);
+// variadic list of eos with shifted, relativistic or unit system modifiers
+static constexpr const auto shifted_of_unit_or_rel =
+    transform_variadic_list(unit_or_rel, al<ShiftedEOS>{});
+// combined list of all shifted EOS
+static constexpr const auto shifted =
+    variadic_utils::concat(shifted_1, shifted_of_unit_or_rel);
+// variadic list of eos with scaled, relativistic or unit system modifiers
+static constexpr const auto scaled_of_unit_or_rel =
+    transform_variadic_list(unit_or_rel, al<ScaledEOS>{});
+// variadic list of Scaled<Shifted<T>>'s
+static constexpr const auto scaled_of_shifted =
+    transform_variadic_list(shifted, al<ScaledEOS>{});
+// combined list of all scaled EOS
+static constexpr const auto scaled =
+    variadic_utils::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
+// create combined list
+static constexpr const auto combined_list_1 =
+    variadic_utils::concat(full_eos_list, shifted, scaled, unit_or_rel);
+// make a ramped eos of everything
+static constexpr const auto ramped_all =
+    transform_variadic_list(combined_list_1, al<BilinearRampEOS>{});
+// final combined list
+static constexpr const auto combined_list =
+    variadic_utils::concat(combined_list_1, ramped_all);
+using EOS = typename decltype(tl_to_Variant(combined_list))::vt;
 
 SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {
 
@@ -45,12 +103,11 @@ SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {
     constexpr Real shift = 0.1;
     constexpr Real rho = 2.0;
     constexpr Real sie = 0.5;
-    WHEN("We construct a shifted, scaled IdealGas by hand") {
-      IdealGas a = IdealGas(gm1, Cv);
-      ShiftedEOS<IdealGas> b = ShiftedEOS<IdealGas>(std::move(a), shift);
-      EOS eos = ScaledEOS<ShiftedEOS<IdealGas>>(std::move(b), scale);
+    WHEN("We use the EOSBuilder") {
+      EOS eos = IdealGas(gm1, Cv);
+      eos = eos.Modify<ShiftedEOS>(shift);
+      eos = eos.Modify<ScaledEOS>(scale);
       THEN("The shift and scale parameters pass through correctly") {
-
         REQUIRE(eos.PressureFromDensityInternalEnergy(rho, sie) == 0.3);
       }
       THEN("We can UnmodifyOnce to get the shifted EOS object") {
@@ -61,34 +118,14 @@ SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {
           REQUIRE(unmod.IsType<IdealGas>());
         }
       }
-    }
-    WHEN("We use the EOSBuilder") {
-      EOSBuilder::EOSType type = EOSBuilder::EOSType::IdealGas;
-      EOSBuilder::modifiers_t modifiers;
-      EOSBuilder::params_t base_params, shifted_params, scaled_params;
-      base_params["Cv"].emplace<Real>(Cv);
-      base_params["gm1"].emplace<Real>(gm1);
-      shifted_params["shift"].emplace<Real>(shift);
-      scaled_params["scale"].emplace<Real>(scale);
-      modifiers[EOSBuilder::EOSModifier::Shifted] = shifted_params;
-      modifiers[EOSBuilder::EOSModifier::Scaled] = scaled_params;
-      EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
-      THEN("The shift and scale parameters pass through correctly") {
-        REQUIRE(eos.PressureFromDensityInternalEnergy(rho, sie) == 0.3);
-      }
       WHEN("We add a ramp") {
-        EOSBuilder::params_t ramp_params;
+        // EOSBuilder::params_t ramp_params;
         Real r0 = 1;
         Real a = 1;
         Real b = 0;
         Real c = 0;
-        ramp_params["r0"].emplace<Real>(r0);
-        ramp_params["a"].emplace<Real>(a);
-        ramp_params["b"].emplace<Real>(b);
-        ramp_params["c"].emplace<Real>(c);
-        modifiers[EOSBuilder::EOSModifier::BilinearRamp] = ramp_params;
         THEN("The EOS is constructed correctly") {
-          auto eos_ramped = EOSBuilder::buildEOS(type, base_params, modifiers);
+          auto eos_ramped = Modify<BilinearRampEOS>(eos, r0, a, b, c);
         }
       }
     }
@@ -203,14 +240,9 @@ SCENARIO("Relativistic EOS", "[EOSBuilder][RelativisticEOS][IdealGas]") {
     constexpr Real Cv = 2.0;
     constexpr Real gm1 = 0.5;
     WHEN("We construct a relativistic IdealGas with EOSBuilder") {
-      EOSBuilder::EOSType type = EOSBuilder::EOSType::IdealGas;
-      EOSBuilder::modifiers_t modifiers;
-      EOSBuilder::params_t base_params, relativity_params;
-      base_params["Cv"].emplace<Real>(Cv);
-      base_params["gm1"].emplace<Real>(gm1);
-      relativity_params["cl"].emplace<Real>(1.0);
-      modifiers[EOSBuilder::EOSModifier::Relativistic] = relativity_params;
-      EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
+      constexpr Real cl = 1;
+      EOS eos = IdealGas(gm1, Cv);
+      eos = Modify<RelativisticEOS>(eos, cl);
       THEN("The EOS has finite sound speeds") {
         constexpr Real rho = 1e3;
         constexpr Real sie = 1e3;
@@ -226,21 +258,13 @@ SCENARIO("EOS Unit System", "[EOSBuilder][UnitSystem][IdealGas]") {
   GIVEN("Parameters for an ideal gas") {
     constexpr Real Cv = 2.0;
     constexpr Real gm1 = 0.5;
-    EOSBuilder::EOSType type = EOSBuilder::EOSType::IdealGas;
-    EOSBuilder::modifiers_t modifiers;
-    EOSBuilder::params_t base_params, units_params;
-    base_params["Cv"].emplace<Real>(Cv);
-    base_params["gm1"].emplace<Real>(gm1);
     GIVEN("Units with a thermal unit system") {
       constexpr Real rho_unit = 1e1;
       constexpr Real sie_unit = 1e-1;
       constexpr Real temp_unit = 123;
       WHEN("We construct an IdealGas with EOSBuilder") {
-        units_params["rho_unit"].emplace<Real>(rho_unit);
-        units_params["sie_unit"].emplace<Real>(sie_unit);
-        units_params["temp_unit"].emplace<Real>(temp_unit);
-        modifiers[EOSBuilder::EOSModifier::UnitSystem] = units_params;
-        EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
+        EOS eos = IdealGas(gm1, Cv);
+        eos = Modify<UnitSystem>(eos, rho_unit, sie_unit, temp_unit);
         THEN("Units cancel out for an ideal gas") {
           Real rho = 1e3;
           Real sie = 1e3;
@@ -256,13 +280,9 @@ SCENARIO("EOS Unit System", "[EOSBuilder][UnitSystem][IdealGas]") {
       constexpr Real mass_unit = 1e6;
       constexpr Real temp_unit = 789;
       WHEN("We construct an IdealGas with EOSBuilder") {
-        units_params["use_length_time"].emplace<bool>(true);
-        units_params["time_unit"].emplace<Real>(time_unit);
-        units_params["length_unit"].emplace<Real>(length_unit);
-        units_params["mass_unit"].emplace<Real>(mass_unit);
-        units_params["temp_unit"].emplace<Real>(temp_unit);
-        modifiers[EOSBuilder::EOSModifier::UnitSystem] = units_params;
-        EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
+        EOS eos = IdealGas(gm1, Cv);
+        eos = Modify<UnitSystem>(eos, eos_units_init::length_time_units_init_tag,
+                                 time_unit, mass_unit, length_unit, temp_unit);
         THEN("Units cancel out for an ideal gas") {
           Real rho = 1e3;
           Real sie = 1e3;
diff --git a/test/test_eos_stellar_collapse.cpp b/test/test_eos_stellar_collapse.cpp
index 66366fe186..8e60fa83e9 100644
--- a/test/test_eos_stellar_collapse.cpp
+++ b/test/test_eos_stellar_collapse.cpp
@@ -23,7 +23,6 @@
 #include <ports-of-call/portable_arrays.hpp>
 #include <ports-of-call/portable_errors.hpp>
 #include <singularity-eos/eos/eos.hpp>
-#include <singularity-eos/eos/eos_builder.hpp>
 
 #ifdef SINGULARITY_BUILD_CLOSURE
 #include <singularity-eos/eos/singularity_eos.hpp>
@@ -113,7 +112,7 @@ SCENARIO("Test 3D reinterpolation to fast log grid", "[StellarCollapse]") {
   }
 }
 
-SCENARIO("Stellar Collapse EOS", "[StellarCollapse][EOSBuilder]") {
+SCENARIO("Stellar Collapse EOS", "[StellarCollapse]") {
   using singularity::IdealGas;
   using singularity::StellarCollapse;
   const std::string savename = "stellar_collapse_ideal_2.sp5";
diff --git a/test/test_eos_tabulated.cpp b/test/test_eos_tabulated.cpp
index dfaea1a05d..7992713796 100644
--- a/test/test_eos_tabulated.cpp
+++ b/test/test_eos_tabulated.cpp
@@ -22,7 +22,6 @@
 #include <ports-of-call/portable_arrays.hpp>
 #include <ports-of-call/portable_errors.hpp>
 #include <singularity-eos/eos/eos.hpp>
-#include <singularity-eos/eos/eos_builder.hpp>
 
 #ifdef SINGULARITY_BUILD_CLOSURE
 #include <singularity-eos/eos/singularity_eos.hpp>
@@ -35,8 +34,6 @@
 
 #include <test/eos_unit_test_helpers.hpp>
 
-using singularity::EOS;
-
 #ifdef SPINER_USE_HDF
 using singularity::SpinerEOSDependsRhoSie;
 using singularity::SpinerEOSDependsRhoT;
@@ -46,7 +43,6 @@ using singularity::SpinerEOSDependsRhoT;
 using singularity::EOSPAC;
 #endif
 
-namespace EOSBuilder = singularity::EOSBuilder;
 namespace thermalqs = singularity::thermalqs;
 
 const std::string eosName = "../materials.sp5";
@@ -66,6 +62,8 @@ constexpr Real ev2k = 1.160451812e4;
 #ifdef SPINER_USE_HDF
 #ifdef SINGULARITY_TEST_SESAME
 #ifdef SINGULARITY_USE_EOSPAC
+using EOS = singularity::Variant<SpinerEOSDependsRhoSie, SpinerEOSDependsRhoT, EOSPAC>;
+
 SCENARIO("SpinerEOS depends on Rho and T", "[SpinerEOS],[DependsRhoT][EOSPAC]") {
 
   GIVEN("SpinerEOS and EOSPAC EOS for steel can be initialized with matid") {
@@ -261,54 +259,6 @@ SCENARIO("SpinerEOS depends on rho and sie", "[SpinerEOS],[DependsRhoSie]") {
     steelEOS.Finalize();      // cleans up device memory
   }
 }
-
-SCENARIO("EOS Builder and SpinerEOS",
-         "[SpinerEOS],[EOSBuilder],[GetOnDevice],[Finalize]") {
-  GIVEN("Parameters for shift and scale") {
-    constexpr Real shift = 0.0;
-    constexpr Real scale = 1.0;
-    WHEN("We construct a SpinerEOS with EOSBuilder") {
-      EOSBuilder::EOSType type = EOSBuilder::EOSType::SpinerEOSDependsRhoT;
-      EOSBuilder::modifiers_t modifiers;
-      EOSBuilder::params_t base_params, shifted_params, scaled_params;
-      base_params["filename"].emplace<std::string>(eosName);
-      base_params["matid"].emplace<int>(steelID);
-      shifted_params["shift"].emplace<Real>(shift);
-      scaled_params["scale"].emplace<Real>(scale);
-      modifiers[EOSBuilder::EOSModifier::Shifted] = shifted_params;
-      modifiers[EOSBuilder::EOSModifier::Scaled] = scaled_params;
-      EOS eosHost = EOSBuilder::buildEOS(type, base_params, modifiers);
-      THEN("The EOS is consistent.") {
-        REQUIRE(
-            isClose(4.96416e13, eosHost.InternalEnergyFromDensityTemperature(1e0, 1e6)));
-      }
-      WHEN("We get an EOS on device") {
-        EOS eosDevice = eosHost.GetOnDevice();
-        THEN("EOS calls match raw access") {
-          int nw_bm{0};
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-          Kokkos::fence();
-          using atomic_view = Kokkos::MemoryTraits<Kokkos::Atomic>;
-          Kokkos::View<int, atomic_view> n_wrong_bm("wrong_bm");
-#else
-          PortableMDArray<int> n_wrong_bm(&nw_bm, 1);
-#endif
-          portableFor(
-              "calc ie's steel 3", 0, 100, PORTABLE_LAMBDA(const int &i) {
-                const Real bm{eosDevice.BulkModulusFromDensityTemperature(1e0, 1e6)};
-                if (!isClose(bm, 2.55268e13)) n_wrong_bm() += 1;
-              });
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-          Kokkos::deep_copy(nw_bm, n_wrong_bm);
-#endif
-          REQUIRE(nw_bm == 0);
-        }
-        eosDevice.Finalize();
-      }
-      eosHost.Finalize();
-    }
-  }
-}
 #endif // SINGULARITY_USE_EOSPAC
 #endif // SINGULARITY_TEST_SESAME
 #endif // SPINER_USE_HDF
diff --git a/test/test_variadic_utils.cpp b/test/test_variadic_utils.cpp
new file mode 100644
index 0000000000..cc482fe6dd
--- /dev/null
+++ b/test/test_variadic_utils.cpp
@@ -0,0 +1,62 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#include <singularity-eos/base/variadic_utils.hpp>
+#include <singularity-eos/eos/eos.hpp>
+#include <singularity-eos/eos/eos_builder.hpp>
+#include <singularity-eos/eos/eos_variant.hpp>
+
+#ifndef CATCH_CONFIG_FAST_COMPILE
+#define CATCH_CONFIG_FAST_COMPILE
+#include "catch2/catch.hpp"
+#endif
+
+using singularity::Gruneisen;
+using singularity::IdealGas;
+using singularity::ScaledEOS;
+using singularity::ShiftedEOS;
+using Var_t = singularity::Variant<IdealGas, ShiftedEOS<IdealGas>>;
+
+namespace variadic_utils = singularity::variadic_utils;
+namespace EOSBuilder = singularity::EOSBuilder;
+
+SCENARIO("Conjunction and disjunction work properly", "[VariadicUtils]") {
+  constexpr bool true_and_false = variadic_utils::conjunction<true, false>::value;
+  constexpr bool true_or_false = variadic_utils::disjunction<true, false>::value;
+  REQUIRE(true_and_false == false);
+  REQUIRE(true_or_false == true);
+}
+
+SCENARIO("Contains works as intended", "[VariadicUtils]") {
+  REQUIRE(variadic_utils::contains_v<IdealGas, IdealGas, ShiftedEOS<IdealGas>>());
+  REQUIRE(!variadic_utils::contains_v<Gruneisen, IdealGas, ShiftedEOS<IdealGas>>());
+}
+
+SCENARIO("EOS Variant can check its own modifiability",
+         "[VariadicUtils][EOSBuilder][EOSBase][EOSVariant]") {
+  constexpr Real Cv = 2.0;
+  constexpr Real gm1 = 0.5;
+  Var_t v = IdealGas(gm1, Cv);
+  REQUIRE(v.ModifiedInVariant<ShiftedEOS>());
+  REQUIRE(!v.ModifiedInVariant<ScaledEOS>());
+}
+
+SCENARIO("IsModifiable works as intended", "[VariadicUtils][EOSBuilder]") {
+  using namespace EOSBuilder;
+  const Var_t v{};
+  REQUIRE(is_modifiable<ShiftedEOS, IdealGas>(v));
+  REQUIRE(!is_modifiable<ShiftedEOS, Gruneisen>(v));
+  REQUIRE(!is_modifiable<ScaledEOS, IdealGas>(v));
+  REQUIRE(!is_modifiable<ScaledEOS, Gruneisen>(v));
+}