diff --git a/include/flux/core/assert.hpp b/include/flux/core/assert.hpp
index e8951d3a..8493a7e7 100644
--- a/include/flux/core/assert.hpp
+++ b/include/flux/core/assert.hpp
@@ -16,6 +16,7 @@
 
 namespace flux {
 
+FLUX_EXPORT
 struct unrecoverable_error : std::logic_error {
     explicit unrecoverable_error(char const* msg) : std::logic_error(msg) {}
 };
@@ -44,7 +45,7 @@ struct runtime_error_fn {
 
 }
 
-inline constexpr auto runtime_error = detail::runtime_error_fn{};
+FLUX_EXPORT inline constexpr auto runtime_error = detail::runtime_error_fn{};
 
 namespace detail {
 
@@ -71,8 +72,8 @@ struct bounds_check_fn {
 
 } // namespace detail
 
-inline constexpr auto assert_ = detail::assert_fn{};
-inline constexpr auto bounds_check = detail::bounds_check_fn{};
+FLUX_EXPORT inline constexpr auto assert_ = detail::assert_fn{};
+FLUX_EXPORT inline constexpr auto bounds_check = detail::bounds_check_fn{};
 
 #define FLUX_ASSERT(cond) (::flux::assert_(cond, "assertion '" #cond "' failed"))
 
diff --git a/include/flux/core/concepts.hpp b/include/flux/core/concepts.hpp
index 80b71ff0..dac180cf 100644
--- a/include/flux/core/concepts.hpp
+++ b/include/flux/core/concepts.hpp
@@ -25,12 +25,15 @@ namespace flux {
 /*
  * Cursor concepts
  */
+FLUX_EXPORT
 template <typename Cur>
 concept cursor = std::movable<Cur>;
 
+FLUX_EXPORT
 template <typename Cur>
 concept regular_cursor = cursor<Cur> && std::regular<Cur>;
 
+FLUX_EXPORT
 template <typename Cur>
 concept ordered_cursor =
     regular_cursor<Cur> &&
@@ -40,6 +43,7 @@ concept ordered_cursor =
  * Sequence concepts and associated types
  */
 
+FLUX_EXPORT
 template <typename T>
 struct sequence_traits;
 
@@ -50,9 +54,11 @@ using traits_t = sequence_traits<std::remove_cvref_t<T>>;
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Seq>
 using cursor_t = decltype(detail::traits_t<Seq>::first(FLUX_DECLVAL(Seq&)));
 
+FLUX_EXPORT
 template <typename Seq>
 using element_t = decltype(detail::traits_t<Seq>::read_at(FLUX_DECLVAL(Seq&), FLUX_DECLVAL(cursor_t<Seq> const&)));
 
@@ -93,19 +99,25 @@ struct rvalue_element_type<T> {
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Seq>
 using value_t = typename detail::value_type<Seq>::type;
 
+FLUX_EXPORT
 using distance_t = flux::config::int_type;
 
+FLUX_EXPORT
 using index_t = flux::config::int_type;
 
+FLUX_EXPORT
 template <typename Seq>
 using rvalue_element_t = typename detail::rvalue_element_type<Seq>::type;
 
+FLUX_EXPORT
 template <typename Seq>
 using common_element_t = std::common_reference_t<element_t<Seq>, value_t<Seq>&>;
 
+FLUX_EXPORT
 template <typename Seq>
 using const_element_t = std::common_reference_t<value_t<Seq> const&&, element_t<Seq>>;
 
@@ -144,6 +156,7 @@ concept sequence_concept =
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Seq>
 concept sequence = detail::sequence_concept<Seq>;
 
@@ -159,6 +172,7 @@ inline constexpr bool disable_multipass<T> = T::disable_multipass;
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Seq>
 concept multipass_sequence =
     sequence<Seq> && regular_cursor<cursor_t<Seq>> &&
@@ -175,6 +189,7 @@ concept bidirectional_sequence_concept =
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Seq>
 concept bidirectional_sequence = detail::bidirectional_sequence_concept<Seq>;
 
@@ -192,6 +207,7 @@ concept random_access_sequence_concept =
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Seq>
 concept random_access_sequence = detail::random_access_sequence_concept<Seq>;
 
@@ -208,6 +224,7 @@ concept contiguous_sequence_concept =
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Seq>
 concept contiguous_sequence = detail::contiguous_sequence_concept<Seq>;
 
@@ -222,6 +239,7 @@ concept bounded_sequence_concept =
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Seq>
 concept bounded_sequence = detail::bounded_sequence_concept<Seq>;
 
@@ -238,9 +256,11 @@ concept sized_sequence_concept =
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Seq>
 concept sized_sequence = detail::sized_sequence_concept<Seq>;
 
+FLUX_EXPORT
 template <typename Seq, typename T>
 concept writable_sequence_of =
     sequence<Seq> &&
@@ -260,11 +280,13 @@ inline constexpr bool is_infinite_seq<T> = T::is_infinite;
 
 }
 
+FLUX_EXPORT
 template <typename Seq>
 concept infinite_sequence =
     sequence<Seq> &&
     detail::is_infinite_seq<detail::traits_t<Seq>>;
 
+FLUX_EXPORT
 template <typename Seq>
 concept read_only_sequence =
     sequence<Seq> &&
@@ -292,6 +314,7 @@ concept trivially_copyable_sequence =
 
 }
 
+FLUX_EXPORT
 template <typename Seq>
 concept adaptable_sequence =
     (detail::rvalue_sequence<Seq>
diff --git a/include/flux/core/config.hpp b/include/flux/core/config.hpp
index 908def79..14e6c701 100644
--- a/include/flux/core/config.hpp
+++ b/include/flux/core/config.hpp
@@ -6,6 +6,8 @@
 #ifndef FLUX_CORE_CONFIG_HPP_INCLUDED
 #define FLUX_CORE_CONFIG_HPP_INCLUDED
 
+#include <flux/core/macros.hpp>
+
 #include <concepts>
 #include <cstddef>
 #include <type_traits>
@@ -71,11 +73,13 @@
 
 namespace flux {
 
+FLUX_EXPORT
 enum class error_policy {
     terminate = FLUX_ERROR_POLICY_TERMINATE,
     unwind = FLUX_ERROR_POLICY_UNWIND
 };
 
+FLUX_EXPORT
 enum class overflow_policy {
     ignore = FLUX_OVERFLOW_POLICY_IGNORE,
     wrap = FLUX_OVERFLOW_POLICY_WRAP,
@@ -84,16 +88,21 @@ enum class overflow_policy {
 
 namespace config {
 
+FLUX_EXPORT
 using int_type = FLUX_INT_TYPE;
 static_assert(std::signed_integral<int_type> && (sizeof(int_type) >= sizeof(std::ptrdiff_t)),
               "Custom FLUX_INT_TYPE must be a signed integer type at least as large as ptrdiff_t");
 
+FLUX_EXPORT
 inline constexpr error_policy on_error = static_cast<error_policy>(FLUX_ERROR_POLICY);
 
+FLUX_EXPORT
 inline constexpr overflow_policy on_overflow = static_cast<overflow_policy>(FLUX_OVERFLOW_POLICY);
 
+FLUX_EXPORT
 inline constexpr bool print_error_on_terminate = FLUX_PRINT_ERROR_ON_TERMINATE;
 
+FLUX_EXPORT
 inline constexpr bool enable_debug_asserts = FLUX_ENABLE_DEBUG_ASSERTS;
 
 } // namespace config
diff --git a/include/flux/core/functional.hpp b/include/flux/core/functional.hpp
index b5d0af99..5ff0dc6c 100644
--- a/include/flux/core/functional.hpp
+++ b/include/flux/core/functional.hpp
@@ -13,6 +13,7 @@
 
 namespace flux {
 
+FLUX_EXPORT
 template <typename Fn, typename Proj = std::identity>
 struct proj {
     Fn fn;
@@ -38,6 +39,7 @@ struct proj {
 template <typename F, typename P = std::identity>
 proj(F, P = {}) -> proj<F, P>;
 
+FLUX_EXPORT
 template <typename Fn, typename Lhs = std::identity, typename Rhs = std::identity>
 struct proj2 {
     Fn fn;
@@ -120,7 +122,7 @@ struct unpack_fn {
 
 } // namespace detail
 
-inline constexpr auto unpack = detail::unpack_fn{};
+FLUX_EXPORT inline constexpr auto unpack = detail::unpack_fn{};
 
 namespace pred {
 
@@ -142,7 +144,7 @@ inline constexpr auto cmp = [](auto&& val) {
 } // namespace detail
 
 /// Given a predicate, returns a new predicate with the condition reversed
-inline constexpr auto not_ = [](auto&& pred) {
+FLUX_EXPORT inline constexpr auto not_ = [](auto&& pred) {
     return detail::predicate([p = FLUX_FWD(pred)] (auto const&... args) {
         return !std::invoke(p, FLUX_FWD(args)...);
     });
@@ -153,7 +155,7 @@ inline constexpr auto not_ = [](auto&& pred) {
 ///
 /// The returned predicate is short-circuiting: if the first predicate returns
 /// `false`, the second will not be evaluated.
-inline constexpr auto both = [](auto&& p, auto&& and_) {
+FLUX_EXPORT inline constexpr auto both = [](auto&& p, auto&& and_) {
     return detail::predicate{[p1 = FLUX_FWD(p), p2 = FLUX_FWD(and_)] (auto const&... args) {
         return std::invoke(p1, args...) && std::invoke(p2, args...);
     }};
@@ -164,7 +166,7 @@ inline constexpr auto both = [](auto&& p, auto&& and_) {
 ///
 /// The returned predicate is short-circuiting: if the first predicate returns
 /// `true`, the second will not be evaluated
-inline constexpr auto either = [](auto&& p, auto&& or_) {
+FLUX_EXPORT inline constexpr auto either = [](auto&& p, auto&& or_) {
      return detail::predicate{[p1 = FLUX_FWD(p), p2 = FLUX_FWD(or_)] (auto const&... args) {
         return std::invoke(p1, args...) || std::invoke(p2, args...);
      }};
@@ -197,55 +199,55 @@ constexpr auto operator||(detail::predicate<L> lhs, detail::predicate<R> rhs)
 ///
 /// The returned predicate is short-circuiting: if the first predicate returns
 /// `true`, the second will not be evaluated.
-inline constexpr auto neither = [](auto&& p1, auto&& nor) {
+FLUX_EXPORT inline constexpr auto neither = [](auto&& p1, auto&& nor) {
     return not_(either(FLUX_FWD(p1), FLUX_FWD(nor)));
 };
 
-inline constexpr auto eq = detail::cmp<std::ranges::equal_to>;
-inline constexpr auto neq = detail::cmp<std::ranges::not_equal_to>;
-inline constexpr auto lt = detail::cmp<std::ranges::less>;
-inline constexpr auto gt = detail::cmp<std::ranges::greater>;
-inline constexpr auto leq = detail::cmp<std::ranges::less_equal>;
-inline constexpr auto geq = detail::cmp<std::ranges::greater_equal>;
+FLUX_EXPORT inline constexpr auto eq = detail::cmp<std::ranges::equal_to>;
+FLUX_EXPORT inline constexpr auto neq = detail::cmp<std::ranges::not_equal_to>;
+FLUX_EXPORT inline constexpr auto lt = detail::cmp<std::ranges::less>;
+FLUX_EXPORT inline constexpr auto gt = detail::cmp<std::ranges::greater>;
+FLUX_EXPORT inline constexpr auto leq = detail::cmp<std::ranges::less_equal>;
+FLUX_EXPORT inline constexpr auto geq = detail::cmp<std::ranges::greater_equal>;
 
 /// A predicate which always returns true
-inline constexpr auto true_ = detail::predicate{[](auto const&...) -> bool { return true; }};
+FLUX_EXPORT inline constexpr auto true_ = detail::predicate{[](auto const&...) -> bool { return true; }};
 
 /// A predicate which always returns false
-inline constexpr auto false_ = detail::predicate{[](auto const&...) -> bool { return false; }};
+FLUX_EXPORT inline constexpr auto false_ = detail::predicate{[](auto const&...) -> bool { return false; }};
 
 /// Identity predicate, returns the boolean value given to it
-inline constexpr auto id = detail::predicate{[](bool b) -> bool { return b; }};
+FLUX_EXPORT inline constexpr auto id = detail::predicate{[](bool b) -> bool { return b; }};
 
 /// Returns true if the given value is greater than a zero of the same type.
-inline constexpr auto positive = detail::predicate{[](auto const& val) -> bool {
+FLUX_EXPORT inline constexpr auto positive = detail::predicate{[](auto const& val) -> bool {
     return val > decltype(val){0};
 }};
 
 /// Returns true if the given value is less than a zero of the same type.
-inline constexpr auto negative = detail::predicate{[](auto const& val) -> bool {
+FLUX_EXPORT inline constexpr auto negative = detail::predicate{[](auto const& val) -> bool {
     return val < decltype(val){0};
 }};
 
 /// Returns true if the given value is not equal to a zero of the same type.
-inline constexpr auto nonzero = detail::predicate{[](auto const& val) -> bool {
+FLUX_EXPORT inline constexpr auto nonzero = detail::predicate{[](auto const& val) -> bool {
     return val != decltype(val){0};
 }};
 
 /// Given a sequence of values, constructs a predicate which returns true
 /// if its argument compares equal to one of the values
-inline constexpr auto in = [](auto const&... vals)  requires (sizeof...(vals) > 0)
+FLUX_EXPORT inline constexpr auto in = [](auto const&... vals)  requires (sizeof...(vals) > 0)
 {
     return detail::predicate{[vals...](auto const& arg) -> bool {
         return ((arg == vals) || ...);
     }};
 };
 
-inline constexpr auto even = detail::predicate([](auto const& val) -> bool {
+FLUX_EXPORT inline constexpr auto even = detail::predicate([](auto const& val) -> bool {
     return val % decltype(val){2} == decltype(val){0};
 });
 
-inline constexpr auto odd = detail::predicate([](auto const& val) -> bool {
+FLUX_EXPORT inline constexpr auto odd = detail::predicate([](auto const& val) -> bool {
   return val % decltype(val){2} != decltype(val){0};
 });
 
diff --git a/include/flux/core/inline_sequence_base.hpp b/include/flux/core/inline_sequence_base.hpp
index 2d66128f..1205e3b4 100644
--- a/include/flux/core/inline_sequence_base.hpp
+++ b/include/flux/core/inline_sequence_base.hpp
@@ -12,6 +12,7 @@
 
 namespace flux {
 
+FLUX_EXPORT
 template <cursor Cur>
 struct bounds {
     FLUX_NO_UNIQUE_ADDRESS Cur from;
@@ -23,6 +24,7 @@ struct bounds {
 template <cursor Cur>
 bounds(Cur, Cur) -> bounds<Cur>;
 
+FLUX_EXPORT
 template <sequence Seq>
 using bounds_t = bounds<cursor_t<Seq>>;
 
diff --git a/include/flux/core/macros.hpp b/include/flux/core/macros.hpp
index 0b19cf49..69d32203 100644
--- a/include/flux/core/macros.hpp
+++ b/include/flux/core/macros.hpp
@@ -27,4 +27,10 @@
               ::flux::inc(_flux_seq_, _flux_cur_))         \
             if (_flux_var_decl_ = ::flux::read_at(_flux_seq_, _flux_cur_); true)
 
+#ifdef FLUX_MODULE_INTERFACE
+#define FLUX_EXPORT export
+#else
+#define FLUX_EXPORT
+#endif
+
 #endif // FLUX_CORE_MACROS_HPP_INCLUDED
diff --git a/include/flux/core/numeric.hpp b/include/flux/core/numeric.hpp
index 42d6f2c2..0fd4d310 100644
--- a/include/flux/core/numeric.hpp
+++ b/include/flux/core/numeric.hpp
@@ -12,18 +12,21 @@
 
 namespace flux::num {
 
+FLUX_EXPORT
 inline constexpr auto wrapping_add = []<std::signed_integral T>(T lhs, T rhs) -> T
 {
     using U = std::make_unsigned_t<T>;
     return static_cast<T>(static_cast<U>(lhs) + static_cast<U>(rhs));
 };
 
+FLUX_EXPORT
 inline constexpr auto wrapping_sub = []<std::signed_integral T>(T lhs, T rhs) -> T
 {
     using U = std::make_unsigned_t<T>;
     return static_cast<T>(static_cast<U>(lhs) - static_cast<U>(rhs));
 };
 
+FLUX_EXPORT
 inline constexpr auto wrapping_mul = []<std::signed_integral T>(T lhs, T rhs) -> T
 {
     using U = std::make_unsigned_t<T>;
@@ -50,12 +53,14 @@ namespace detail {
 
 }
 
+FLUX_EXPORT
 template <std::signed_integral T>
 struct overflow_result {
     T value;
     bool overflowed;
 };
 
+FLUX_EXPORT
 inline constexpr auto overflowing_add = []<std::signed_integral T>(T lhs, T rhs)
     -> overflow_result<T>
 {
@@ -69,6 +74,7 @@ inline constexpr auto overflowing_add = []<std::signed_integral T>(T lhs, T rhs)
     }
 };
 
+FLUX_EXPORT
 inline constexpr auto overflowing_sub = []<std::signed_integral T>(T lhs, T rhs)
     -> overflow_result<T>
 {
@@ -83,6 +89,7 @@ inline constexpr auto overflowing_sub = []<std::signed_integral T>(T lhs, T rhs)
     }
 };
 
+FLUX_EXPORT
 inline constexpr auto overflowing_mul = []<std::signed_integral T>(T lhs, T rhs)
     -> overflow_result<T>
 {
@@ -95,6 +102,7 @@ inline constexpr auto overflowing_mul = []<std::signed_integral T>(T lhs, T rhs)
     }
 };
 
+FLUX_EXPORT
 inline constexpr auto checked_add =
     []<std::signed_integral T>(T lhs, T rhs,
                                std::source_location loc = std::source_location::current())
@@ -117,6 +125,7 @@ inline constexpr auto checked_add =
     }
 };
 
+FLUX_EXPORT
 inline constexpr auto checked_sub =
     []<std::signed_integral T>(T lhs, T rhs,
                                std::source_location loc = std::source_location::current())
@@ -139,6 +148,7 @@ inline constexpr auto checked_sub =
   }
 };
 
+FLUX_EXPORT
 inline constexpr auto checked_mul =
     []<std::signed_integral T>(T lhs, T rhs,
                                std::source_location loc = std::source_location::current())
diff --git a/include/flux/core/optional.hpp b/include/flux/core/optional.hpp
index 60e87e7e..c754bd37 100644
--- a/include/flux/core/optional.hpp
+++ b/include/flux/core/optional.hpp
@@ -14,8 +14,8 @@
 
 namespace flux {
 
-using nullopt_t = std::nullopt_t;
-inline constexpr nullopt_t const& nullopt = std::nullopt;
+FLUX_EXPORT using nullopt_t = std::nullopt_t;
+FLUX_EXPORT inline constexpr nullopt_t const& nullopt = std::nullopt;
 
 namespace detail {
 
@@ -27,6 +27,7 @@ concept can_optional =
 
 }
 
+FLUX_EXPORT
 template <typename T>
 class optional;
 
diff --git a/include/flux/core/sequence_access.hpp b/include/flux/core/sequence_access.hpp
index c662e324..d9b5e622 100644
--- a/include/flux/core/sequence_access.hpp
+++ b/include/flux/core/sequence_access.hpp
@@ -208,19 +208,19 @@ struct move_at_unchecked_fn {
 
 } // namespace detail
 
-inline constexpr auto first = detail::first_fn{};
-inline constexpr auto is_last = detail::is_last_fn{};
-inline constexpr auto read_at = detail::read_at_fn{};
-inline constexpr auto move_at = detail::move_at_fn{};
-inline constexpr auto read_at_unchecked = detail::read_at_unchecked_fn{};
-inline constexpr auto move_at_unchecked = detail::move_at_unchecked_fn{};
-inline constexpr auto inc = detail::inc_fn{};
-inline constexpr auto dec = detail::dec_fn{};
-inline constexpr auto distance = detail::distance_fn{};
-inline constexpr auto data = detail::data_fn{};
-inline constexpr auto last = detail::last_fn{};
-inline constexpr auto size = detail::size_fn{};
-inline constexpr auto usize = detail::usize_fn{};
+FLUX_EXPORT inline constexpr auto first = detail::first_fn{};
+FLUX_EXPORT inline constexpr auto is_last = detail::is_last_fn{};
+FLUX_EXPORT inline constexpr auto read_at = detail::read_at_fn{};
+FLUX_EXPORT inline constexpr auto move_at = detail::move_at_fn{};
+FLUX_EXPORT inline constexpr auto read_at_unchecked = detail::read_at_unchecked_fn{};
+FLUX_EXPORT inline constexpr auto move_at_unchecked = detail::move_at_unchecked_fn{};
+FLUX_EXPORT inline constexpr auto inc = detail::inc_fn{};
+FLUX_EXPORT inline constexpr auto dec = detail::dec_fn{};
+FLUX_EXPORT inline constexpr auto distance = detail::distance_fn{};
+FLUX_EXPORT inline constexpr auto data = detail::data_fn{};
+FLUX_EXPORT inline constexpr auto last = detail::last_fn{};
+FLUX_EXPORT inline constexpr auto size = detail::size_fn{};
+FLUX_EXPORT inline constexpr auto usize = detail::usize_fn{};
 
 namespace detail {
 
@@ -357,13 +357,13 @@ struct back_fn {
 } // namespace detail
 
 
-inline constexpr auto next = detail::next_fn{};
-inline constexpr auto prev = detail::prev_fn{};
-inline constexpr auto is_empty = detail::is_empty_fn{};
-inline constexpr auto swap_with = detail::swap_with_fn{};
-inline constexpr auto swap_at = detail::swap_at_fn{};
-inline constexpr auto front = detail::front_fn{};
-inline constexpr auto back = detail::back_fn{};
+FLUX_EXPORT inline constexpr auto next = detail::next_fn{};
+FLUX_EXPORT inline constexpr auto prev = detail::prev_fn{};
+FLUX_EXPORT inline constexpr auto is_empty = detail::is_empty_fn{};
+FLUX_EXPORT inline constexpr auto swap_with = detail::swap_with_fn{};
+FLUX_EXPORT inline constexpr auto swap_at = detail::swap_at_fn{};
+FLUX_EXPORT inline constexpr auto front = detail::front_fn{};
+FLUX_EXPORT inline constexpr auto back = detail::back_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/core/simple_sequence_base.hpp b/include/flux/core/simple_sequence_base.hpp
index c16cc6ab..2a61c82c 100644
--- a/include/flux/core/simple_sequence_base.hpp
+++ b/include/flux/core/simple_sequence_base.hpp
@@ -10,6 +10,7 @@
 
 namespace flux {
 
+FLUX_EXPORT
 template <typename D>
 struct simple_sequence_base : inline_sequence_base<D> {};
 
diff --git a/include/flux/core/utils.hpp b/include/flux/core/utils.hpp
index b623f7ee..c77a725e 100644
--- a/include/flux/core/utils.hpp
+++ b/include/flux/core/utils.hpp
@@ -22,6 +22,7 @@ namespace flux {
 /*
  * Useful helpers
  */
+FLUX_EXPORT
 template <typename From, typename To>
 concept decays_to = std::same_as<std::remove_cvref_t<From>, To>;
 
@@ -40,7 +41,7 @@ struct copy_fn {
 
 } // namespace detail
 
-inline constexpr auto copy = detail::copy_fn{};
+FLUX_EXPORT inline constexpr auto copy = detail::copy_fn{};
 
 namespace detail {
 
@@ -65,6 +66,7 @@ struct checked_cast_fn {
 
 } // namespace detail
 
+FLUX_EXPORT
 template <std::integral To>
 inline constexpr auto checked_cast = detail::checked_cast_fn<To>{};
 
diff --git a/include/flux/op/adjacent.hpp b/include/flux/op/adjacent.hpp
index a0d26174..8e67df2c 100644
--- a/include/flux/op/adjacent.hpp
+++ b/include/flux/op/adjacent.hpp
@@ -242,17 +242,19 @@ struct adjacent_map_fn {
 
 } // namespace detail
 
+FLUX_EXPORT
 template <distance_t N>
     requires (N > 0)
 inline constexpr auto adjacent = detail::adjacent_fn<N>{};
 
-inline constexpr auto pairwise = adjacent<2>;
+FLUX_EXPORT inline constexpr auto pairwise = adjacent<2>;
 
+FLUX_EXPORT
 template <distance_t N>
     requires (N > 0)
 inline constexpr auto adjacent_map = detail::adjacent_map_fn<N>{};
 
-inline constexpr auto pairwise_map = adjacent_map<2>;
+FLUX_EXPORT inline constexpr auto pairwise_map = adjacent_map<2>;
 
 template <typename D>
 template <distance_t N>
diff --git a/include/flux/op/all_any_none.hpp b/include/flux/op/all_any_none.hpp
index 272326ba..7937e5e5 100644
--- a/include/flux/op/all_any_none.hpp
+++ b/include/flux/op/all_any_none.hpp
@@ -26,7 +26,7 @@ struct fn {
 
 } // namespace all_detail
 
-inline constexpr auto all = all_detail::fn{};
+FLUX_EXPORT inline constexpr auto all = all_detail::fn{};
 
 namespace none_detail {
 
@@ -43,7 +43,7 @@ struct fn {
 
 } // namespace none_detail
 
-inline constexpr auto none = none_detail::fn{};
+FLUX_EXPORT inline constexpr auto none = none_detail::fn{};
 
 namespace any_detail {
 
@@ -60,7 +60,7 @@ struct fn {
 
 } // namespace any_detail
 
-inline constexpr auto any = any_detail::fn{};
+FLUX_EXPORT inline constexpr auto any = any_detail::fn{};
 
 template <typename D>
 template <typename Pred>
diff --git a/include/flux/op/begin_end.hpp b/include/flux/op/begin_end.hpp
index c2ae4826..2e3be2d6 100644
--- a/include/flux/op/begin_end.hpp
+++ b/include/flux/op/begin_end.hpp
@@ -201,8 +201,8 @@ struct end_fn {
 
 } // namespace detail
 
-inline constexpr auto begin = detail::begin_fn{};
-inline constexpr auto end = detail::end_fn{};
+FLUX_EXPORT inline constexpr auto begin = detail::begin_fn{};
+FLUX_EXPORT inline constexpr auto end = detail::end_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::begin() &
diff --git a/include/flux/op/cache_last.hpp b/include/flux/op/cache_last.hpp
index 70363156..92f44407 100644
--- a/include/flux/op/cache_last.hpp
+++ b/include/flux/op/cache_last.hpp
@@ -77,7 +77,7 @@ struct cache_last_fn {
 
 } // namespace detail
 
-inline constexpr auto cache_last = detail::cache_last_fn{};
+FLUX_EXPORT inline constexpr auto cache_last = detail::cache_last_fn{};
 
 template <typename Derived>
 constexpr auto inline_sequence_base<Derived>::cache_last() &&
diff --git a/include/flux/op/cartesian_product.hpp b/include/flux/op/cartesian_product.hpp
index e3cb3251..82be248c 100644
--- a/include/flux/op/cartesian_product.hpp
+++ b/include/flux/op/cartesian_product.hpp
@@ -244,7 +244,7 @@ struct sequence_traits<detail::cartesian_product_adaptor<Bases...>>
     }
 };
 
-inline constexpr auto cartesian_product = detail::cartesian_product_fn{};
+FLUX_EXPORT inline constexpr auto cartesian_product = detail::cartesian_product_fn{};
 
 } // end namespace flux
 
diff --git a/include/flux/op/cartesian_product_with.hpp b/include/flux/op/cartesian_product_with.hpp
index 6e66934d..5372c5b0 100644
--- a/include/flux/op/cartesian_product_with.hpp
+++ b/include/flux/op/cartesian_product_with.hpp
@@ -58,9 +58,7 @@ struct cartesian_product_with_fn
 
 } // namespace detail
 
-
-
-inline constexpr auto cartesian_product_with = detail::cartesian_product_with_fn{};
+FLUX_EXPORT inline constexpr auto cartesian_product_with = detail::cartesian_product_with_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/op/chain.hpp b/include/flux/op/chain.hpp
index e03b2a17..ed04db5a 100644
--- a/include/flux/op/chain.hpp
+++ b/include/flux/op/chain.hpp
@@ -323,7 +323,7 @@ struct sequence_traits<detail::chain_adaptor<Bases...>> {
 
 };
 
-inline constexpr auto chain = detail::chain_fn{};
+FLUX_EXPORT inline constexpr auto chain = detail::chain_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/op/chunk.hpp b/include/flux/op/chunk.hpp
index 1cc0e7b0..31690498 100644
--- a/include/flux/op/chunk.hpp
+++ b/include/flux/op/chunk.hpp
@@ -309,7 +309,7 @@ struct chunk_fn {
 
 } // namespace detail
 
-inline constexpr auto chunk = detail::chunk_fn{};
+FLUX_EXPORT inline constexpr auto chunk = detail::chunk_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::chunk(std::integral auto chunk_sz) &&
diff --git a/include/flux/op/chunk_by.hpp b/include/flux/op/chunk_by.hpp
index fde97524..fda1befb 100644
--- a/include/flux/op/chunk_by.hpp
+++ b/include/flux/op/chunk_by.hpp
@@ -133,7 +133,7 @@ struct chunk_by_fn {
 
 } // namespace detail
 
-inline constexpr auto chunk_by = detail::chunk_by_fn{};
+FLUX_EXPORT inline constexpr auto chunk_by = detail::chunk_by_fn{};
 
 template <typename Derived>
 template <typename Pred>
diff --git a/include/flux/op/compare.hpp b/include/flux/op/compare.hpp
index 3c61c0ef..fff25111 100644
--- a/include/flux/op/compare.hpp
+++ b/include/flux/op/compare.hpp
@@ -48,7 +48,7 @@ struct compare_fn {
 
 } // namespace detail
 
-inline constexpr auto compare = detail::compare_fn{};
+FLUX_EXPORT inline constexpr auto compare = detail::compare_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/op/contains.hpp b/include/flux/op/contains.hpp
index 8045d1e1..58b1c05b 100644
--- a/include/flux/op/contains.hpp
+++ b/include/flux/op/contains.hpp
@@ -27,7 +27,7 @@ struct contains_fn {
 
 } // namespace detail
 
-inline constexpr auto contains = detail::contains_fn{};
+FLUX_EXPORT inline constexpr auto contains = detail::contains_fn{};
 
 template <typename D>
 template <typename Value>
diff --git a/include/flux/op/count.hpp b/include/flux/op/count.hpp
index a3a711a2..c4c4e67f 100644
--- a/include/flux/op/count.hpp
+++ b/include/flux/op/count.hpp
@@ -68,9 +68,9 @@ struct count_if_fn {
 
 } // namespace detail
 
-inline constexpr auto count = detail::count_fn{};
-inline constexpr auto count_eq = detail::count_eq_fn{};
-inline constexpr auto count_if = detail::count_if_fn{};
+FLUX_EXPORT inline constexpr auto count = detail::count_fn{};
+FLUX_EXPORT inline constexpr auto count_eq = detail::count_eq_fn{};
+FLUX_EXPORT inline constexpr auto count_if = detail::count_if_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::count()
diff --git a/include/flux/op/cursors.hpp b/include/flux/op/cursors.hpp
index 79cd9f03..2f640547 100644
--- a/include/flux/op/cursors.hpp
+++ b/include/flux/op/cursors.hpp
@@ -92,7 +92,7 @@ struct cursors_fn {
 
 } // namespace detail
 
-inline constexpr auto cursors = detail::cursors_fn{};
+FLUX_EXPORT inline constexpr auto cursors = detail::cursors_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::cursors() &&
diff --git a/include/flux/op/cycle.hpp b/include/flux/op/cycle.hpp
index 01618cad..8023ba57 100644
--- a/include/flux/op/cycle.hpp
+++ b/include/flux/op/cycle.hpp
@@ -239,7 +239,7 @@ struct cycle_fn {
 
 } // namespace detail
 
-inline constexpr auto cycle = detail::cycle_fn{};
+FLUX_EXPORT inline constexpr auto cycle = detail::cycle_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::cycle() &&
diff --git a/include/flux/op/drop.hpp b/include/flux/op/drop.hpp
index e24522af..b072406f 100644
--- a/include/flux/op/drop.hpp
+++ b/include/flux/op/drop.hpp
@@ -85,7 +85,7 @@ struct drop_fn {
 
 } // namespace detail
 
-inline constexpr auto drop = detail::drop_fn{};
+FLUX_EXPORT inline constexpr auto drop = detail::drop_fn{};
 
 template <typename Derived>
 constexpr auto inline_sequence_base<Derived>::drop(std::integral auto count) &&
diff --git a/include/flux/op/drop_while.hpp b/include/flux/op/drop_while.hpp
index 0410346f..57f609bb 100644
--- a/include/flux/op/drop_while.hpp
+++ b/include/flux/op/drop_while.hpp
@@ -72,7 +72,7 @@ struct drop_while_fn {
 
 } // namespace detail
 
-inline constexpr auto drop_while = detail::drop_while_fn{};
+FLUX_EXPORT inline constexpr auto drop_while = detail::drop_while_fn{};
 
 template <typename D>
 template <typename Pred>
diff --git a/include/flux/op/ends_with.hpp b/include/flux/op/ends_with.hpp
index a5c9d908..6864f36e 100644
--- a/include/flux/op/ends_with.hpp
+++ b/include/flux/op/ends_with.hpp
@@ -84,7 +84,7 @@ struct ends_with_fn {
 
 } // namespace detail
 
-inline constexpr auto ends_with = detail::ends_with_fn{};
+FLUX_EXPORT inline constexpr auto ends_with = detail::ends_with_fn{};
 
 template <typename Derived>
 template <sequence Needle, typename Cmp>
diff --git a/include/flux/op/equal.hpp b/include/flux/op/equal.hpp
index 7508712e..ec065230 100644
--- a/include/flux/op/equal.hpp
+++ b/include/flux/op/equal.hpp
@@ -41,7 +41,7 @@ struct equal_fn {
 
 } // namespace detail
 
-inline constexpr auto equal = detail::equal_fn{};
+FLUX_EXPORT inline constexpr auto equal = detail::equal_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/op/fill.hpp b/include/flux/op/fill.hpp
index b5268a7a..dbce2978 100644
--- a/include/flux/op/fill.hpp
+++ b/include/flux/op/fill.hpp
@@ -23,7 +23,7 @@ struct fill_fn {
 
 } // namespace detail
 
-inline constexpr auto fill = detail::fill_fn{};
+FLUX_EXPORT inline constexpr auto fill = detail::fill_fn{};
 
 template <typename D>
 template <typename Value>
diff --git a/include/flux/op/filter.hpp b/include/flux/op/filter.hpp
index 8fd5ab7e..2bbaa964 100644
--- a/include/flux/op/filter.hpp
+++ b/include/flux/op/filter.hpp
@@ -123,7 +123,7 @@ struct filter_fn {
 
 } // namespace detail
 
-inline constexpr auto filter = detail::filter_fn{};
+FLUX_EXPORT inline constexpr auto filter = detail::filter_fn{};
 
 template <typename D>
 template <typename Pred>
diff --git a/include/flux/op/find.hpp b/include/flux/op/find.hpp
index 0f949ad5..86ebd59b 100644
--- a/include/flux/op/find.hpp
+++ b/include/flux/op/find.hpp
@@ -49,9 +49,9 @@ struct find_if_not_fn {
 
 } // namespace detail
 
-inline constexpr auto find = detail::find_fn{};
-inline constexpr auto find_if = detail::find_if_fn{};
-inline constexpr auto find_if_not = detail::find_if_not_fn{};
+FLUX_EXPORT inline constexpr auto find = detail::find_fn{};
+FLUX_EXPORT inline constexpr auto find_if = detail::find_if_fn{};
+FLUX_EXPORT inline constexpr auto find_if_not = detail::find_if_not_fn{};
 
 template <typename D>
 template <typename Value>
diff --git a/include/flux/op/flatten.hpp b/include/flux/op/flatten.hpp
index 6116b926..3b968cf8 100644
--- a/include/flux/op/flatten.hpp
+++ b/include/flux/op/flatten.hpp
@@ -238,7 +238,7 @@ struct flatten_fn {
 
 } // namespace detail
 
-inline constexpr auto flatten = detail::flatten_fn{};
+FLUX_EXPORT inline constexpr auto flatten = detail::flatten_fn{};
 
 template <typename Derived>
 constexpr auto inline_sequence_base<Derived>::flatten() &&
diff --git a/include/flux/op/fold.hpp b/include/flux/op/fold.hpp
index b81d0146..c42a7c40 100644
--- a/include/flux/op/fold.hpp
+++ b/include/flux/op/fold.hpp
@@ -82,10 +82,10 @@ struct product_op {
 
 } // namespace detail
 
-inline constexpr auto fold = detail::fold_op{};
-inline constexpr auto fold_first = detail::fold_first_op{};
-inline constexpr auto sum = detail::sum_op{};
-inline constexpr auto product = detail::product_op{};
+FLUX_EXPORT inline constexpr auto fold = detail::fold_op{};
+FLUX_EXPORT inline constexpr auto fold_first = detail::fold_first_op{};
+FLUX_EXPORT inline constexpr auto sum = detail::sum_op{};
+FLUX_EXPORT inline constexpr auto product = detail::product_op{};
 
 template <typename Derived>
 template <typename D, typename Func, typename Init>
diff --git a/include/flux/op/for_each.hpp b/include/flux/op/for_each.hpp
index c5221d38..82f05bec 100644
--- a/include/flux/op/for_each.hpp
+++ b/include/flux/op/for_each.hpp
@@ -29,7 +29,7 @@ struct for_each_fn {
 
 } // namespace detail
 
-inline constexpr auto for_each = detail::for_each_fn{};
+FLUX_EXPORT inline constexpr auto for_each = detail::for_each_fn{};
 
 template <typename D>
 template <typename Func>
diff --git a/include/flux/op/for_each_while.hpp b/include/flux/op/for_each_while.hpp
index d91356d3..ee1de7e8 100644
--- a/include/flux/op/for_each_while.hpp
+++ b/include/flux/op/for_each_while.hpp
@@ -33,7 +33,7 @@ struct for_each_while_fn {
 
 } // namespace detail
 
-inline constexpr auto for_each_while = detail::for_each_while_fn{};
+FLUX_EXPORT inline constexpr auto for_each_while = detail::for_each_while_fn{};
 
 template <typename Derived>
 template <typename Pred>
diff --git a/include/flux/op/from.hpp b/include/flux/op/from.hpp
index b9c0d057..7ccd4a95 100644
--- a/include/flux/op/from.hpp
+++ b/include/flux/op/from.hpp
@@ -46,8 +46,8 @@ struct from_fwd_ref_fn {
 
 } // namespace detail
 
-inline constexpr auto from = detail::from_fn{};
-inline constexpr auto from_fwd_ref = detail::from_fwd_ref_fn{};
+FLUX_EXPORT inline constexpr auto from = detail::from_fn{};
+FLUX_EXPORT inline constexpr auto from_fwd_ref = detail::from_fwd_ref_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/op/inplace_reverse.hpp b/include/flux/op/inplace_reverse.hpp
index 43e1be91..39dc7621 100644
--- a/include/flux/op/inplace_reverse.hpp
+++ b/include/flux/op/inplace_reverse.hpp
@@ -30,7 +30,7 @@ struct inplace_reverse_fn {
 
 } // namespace detail
 
-inline constexpr auto inplace_reverse = detail::inplace_reverse_fn{};
+FLUX_EXPORT inline constexpr auto inplace_reverse = detail::inplace_reverse_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::inplace_reverse()
diff --git a/include/flux/op/map.hpp b/include/flux/op/map.hpp
index ea5ad786..8d1d7346 100644
--- a/include/flux/op/map.hpp
+++ b/include/flux/op/map.hpp
@@ -73,7 +73,7 @@ struct map_fn {
 
 } // namespace detail
 
-inline constexpr auto map = detail::map_fn{};
+FLUX_EXPORT inline constexpr auto map = detail::map_fn{};
 
 template <typename Derived>
 template <typename Func>
diff --git a/include/flux/op/mask.hpp b/include/flux/op/mask.hpp
index f3f5fc3f..00cd9478 100644
--- a/include/flux/op/mask.hpp
+++ b/include/flux/op/mask.hpp
@@ -153,7 +153,7 @@ struct mask_fn {
 
 } // namespace detail
 
-inline constexpr auto mask = detail::mask_fn{};
+FLUX_EXPORT inline constexpr auto mask = detail::mask_fn{};
 
 template <typename D>
 template <adaptable_sequence Mask>
diff --git a/include/flux/op/minmax.hpp b/include/flux/op/minmax.hpp
index 71e08287..df7fd9a3 100644
--- a/include/flux/op/minmax.hpp
+++ b/include/flux/op/minmax.hpp
@@ -12,6 +12,7 @@
 
 namespace flux {
 
+FLUX_EXPORT
 template <typename T>
 struct minmax_result {
     T min;
@@ -85,9 +86,9 @@ struct minmax_op {
 
 } // namespace detail
 
-inline constexpr auto min = detail::min_op{};
-inline constexpr auto max = detail::max_op{};
-inline constexpr auto minmax = detail::minmax_op{};
+FLUX_EXPORT inline constexpr auto min = detail::min_op{};
+FLUX_EXPORT inline constexpr auto max = detail::max_op{};
+FLUX_EXPORT inline constexpr auto minmax = detail::minmax_op{};
 
 template <typename Derived>
 template <typename Cmp>
diff --git a/include/flux/op/output_to.hpp b/include/flux/op/output_to.hpp
index 49c293cd..cf8e9ada 100644
--- a/include/flux/op/output_to.hpp
+++ b/include/flux/op/output_to.hpp
@@ -54,7 +54,7 @@ struct output_to_fn {
 
 }
 
-inline constexpr auto output_to = detail::output_to_fn{};
+FLUX_EXPORT inline constexpr auto output_to = detail::output_to_fn{};
 
 template <typename D>
 template <typename Iter>
diff --git a/include/flux/op/read_only.hpp b/include/flux/op/read_only.hpp
index 33f9b504..289665c3 100644
--- a/include/flux/op/read_only.hpp
+++ b/include/flux/op/read_only.hpp
@@ -57,7 +57,7 @@ struct read_only_fn {
 
 } // namespace detail
 
-inline constexpr auto read_only = detail::read_only_fn{};
+FLUX_EXPORT inline constexpr auto read_only = detail::read_only_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::read_only() &&
diff --git a/include/flux/op/ref.hpp b/include/flux/op/ref.hpp
index 79a807ee..bcf9b79f 100644
--- a/include/flux/op/ref.hpp
+++ b/include/flux/op/ref.hpp
@@ -213,8 +213,8 @@ struct ref_fn {
 
 } // namespace detail
 
-inline constexpr auto mut_ref = detail::mut_ref_fn{};
-inline constexpr auto ref = detail::ref_fn{};
+FLUX_EXPORT inline constexpr auto mut_ref = detail::mut_ref_fn{};
+FLUX_EXPORT inline constexpr auto ref = detail::ref_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::ref() const&
diff --git a/include/flux/op/requirements.hpp b/include/flux/op/requirements.hpp
index 0fb51e26..21bcf57e 100644
--- a/include/flux/op/requirements.hpp
+++ b/include/flux/op/requirements.hpp
@@ -10,6 +10,7 @@
 
 namespace flux {
 
+FLUX_EXPORT
 template <typename Seq, typename Func, typename Init>
 using fold_result_t = std::decay_t<std::invoke_result_t<Func&, Init, element_t<Seq>>>;
 
@@ -24,12 +25,14 @@ concept foldable_ =
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Seq, typename Func, typename Init>
 concept foldable =
     sequence<Seq> &&
     std::invocable<Func&, Init, element_t<Seq>> &&
     detail::foldable_<Seq, Func, Init>;
 
+FLUX_EXPORT
 template <typename Fn, typename Seq1, typename Seq2 = Seq1>
 concept strict_weak_order_for =
     sequence<Seq1> &&
diff --git a/include/flux/op/reverse.hpp b/include/flux/op/reverse.hpp
index a56f3c28..3d68f1b2 100644
--- a/include/flux/op/reverse.hpp
+++ b/include/flux/op/reverse.hpp
@@ -154,7 +154,7 @@ struct reverse_fn {
 
 } // namespace detail
 
-inline constexpr auto reverse = detail::reverse_fn{};
+FLUX_EXPORT inline constexpr auto reverse = detail::reverse_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::reverse() &&
diff --git a/include/flux/op/scan.hpp b/include/flux/op/scan.hpp
index 388e1b86..65aaa9e8 100644
--- a/include/flux/op/scan.hpp
+++ b/include/flux/op/scan.hpp
@@ -177,8 +177,8 @@ struct prescan_fn {
 
 } // namespace detail
 
-inline constexpr auto scan = detail::scan_fn{};
-inline constexpr auto prescan = detail::prescan_fn{};
+FLUX_EXPORT inline constexpr auto scan = detail::scan_fn{};
+FLUX_EXPORT inline constexpr auto prescan = detail::prescan_fn{};
 
 template <typename Derived>
 template <typename D, typename Func, typename Init>
diff --git a/include/flux/op/scan_first.hpp b/include/flux/op/scan_first.hpp
index 2d3d13de..1d9a555e 100644
--- a/include/flux/op/scan_first.hpp
+++ b/include/flux/op/scan_first.hpp
@@ -126,7 +126,7 @@ struct scan_first_fn {
 
 } // namespace detail
 
-inline constexpr auto scan_first = detail::scan_first_fn{};
+FLUX_EXPORT inline constexpr auto scan_first = detail::scan_first_fn{};
 
 template <typename Derived>
 template <typename Func>
diff --git a/include/flux/op/search.hpp b/include/flux/op/search.hpp
index 6e7cd6e0..07762017 100644
--- a/include/flux/op/search.hpp
+++ b/include/flux/op/search.hpp
@@ -50,7 +50,7 @@ struct search_fn {
 
 } // namespace detail
 
-inline constexpr auto search = detail::search_fn{};
+FLUX_EXPORT inline constexpr auto search = detail::search_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/op/set_adaptors.hpp b/include/flux/op/set_adaptors.hpp
index 6c59a2e8..beb9d41d 100644
--- a/include/flux/op/set_adaptors.hpp
+++ b/include/flux/op/set_adaptors.hpp
@@ -557,10 +557,10 @@ struct set_intersection_fn {
 
 namespace flux {
 
-inline constexpr auto set_union = detail::set_union_fn{};
-inline constexpr auto set_difference = detail::set_difference_fn{};
-inline constexpr auto set_symmetric_difference = detail::set_symmetric_difference_fn{};
-inline constexpr auto set_intersection = detail::set_intersection_fn{};
+FLUX_EXPORT inline constexpr auto set_union = detail::set_union_fn{};
+FLUX_EXPORT inline constexpr auto set_difference = detail::set_difference_fn{};
+FLUX_EXPORT inline constexpr auto set_symmetric_difference = detail::set_symmetric_difference_fn{};
+FLUX_EXPORT inline constexpr auto set_intersection = detail::set_intersection_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/op/slice.hpp b/include/flux/op/slice.hpp
index 17dce88a..a3819fbc 100644
--- a/include/flux/op/slice.hpp
+++ b/include/flux/op/slice.hpp
@@ -138,7 +138,7 @@ struct sequence_traits<subsequence<Base, Bounded>>
     void for_each_while() = delete;
 };
 
-inline constexpr auto slice = detail::slice_fn{};
+FLUX_EXPORT inline constexpr auto slice = detail::slice_fn{};
 
 #if 0
 template <typename Derived>
diff --git a/include/flux/op/slide.hpp b/include/flux/op/slide.hpp
index e04a9ef5..251ee70c 100644
--- a/include/flux/op/slide.hpp
+++ b/include/flux/op/slide.hpp
@@ -125,7 +125,7 @@ struct slide_fn {
 
 } // namespace detail
 
-inline constexpr auto slide = detail::slide_fn{};
+FLUX_EXPORT inline constexpr auto slide = detail::slide_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::slide(std::integral auto win_sz) &&
diff --git a/include/flux/op/sort.hpp b/include/flux/op/sort.hpp
index 8bc1529b..939067f1 100644
--- a/include/flux/op/sort.hpp
+++ b/include/flux/op/sort.hpp
@@ -24,7 +24,7 @@ struct sort_fn {
 
 } // namespace detail
 
-inline constexpr auto sort = detail::sort_fn{};
+FLUX_EXPORT inline constexpr auto sort = detail::sort_fn{};
 
 template <typename D>
 template <typename Cmp>
diff --git a/include/flux/op/split.hpp b/include/flux/op/split.hpp
index 79ad4105..100e3667 100644
--- a/include/flux/op/split.hpp
+++ b/include/flux/op/split.hpp
@@ -128,7 +128,7 @@ struct sequence_traits<detail::split_adaptor<Base, Pattern>>
     }
 };
 
-inline constexpr auto split = detail::split_fn{};
+FLUX_EXPORT inline constexpr auto split = detail::split_fn{};
 
 template <typename Derived>
 template <multipass_sequence Pattern>
diff --git a/include/flux/op/split_string.hpp b/include/flux/op/split_string.hpp
index 9e85360a..52073eb0 100644
--- a/include/flux/op/split_string.hpp
+++ b/include/flux/op/split_string.hpp
@@ -60,7 +60,7 @@ struct split_string_fn {
 
 } // namespace detail
 
-inline constexpr auto split_string = detail::split_string_fn{};
+FLUX_EXPORT inline constexpr auto split_string = detail::split_string_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::split_string(auto&& pattern) &&
diff --git a/include/flux/op/starts_with.hpp b/include/flux/op/starts_with.hpp
index ceb1ab89..c7282656 100644
--- a/include/flux/op/starts_with.hpp
+++ b/include/flux/op/starts_with.hpp
@@ -40,7 +40,7 @@ struct starts_with_fn {
 
 } // namespace detail
 
-inline constexpr auto starts_with = detail::starts_with_fn{};
+FLUX_EXPORT inline constexpr auto starts_with = detail::starts_with_fn{};
 
 template <typename Derived>
 template <sequence Needle, typename Cmp>
diff --git a/include/flux/op/stride.hpp b/include/flux/op/stride.hpp
index 5d7d9363..237839d8 100644
--- a/include/flux/op/stride.hpp
+++ b/include/flux/op/stride.hpp
@@ -261,7 +261,7 @@ struct stride_fn {
 
 } // namespace detail
 
-inline constexpr auto stride = detail::stride_fn{};
+FLUX_EXPORT inline constexpr auto stride = detail::stride_fn{};
 
 template <typename D>
 constexpr auto inline_sequence_base<D>::stride(std::integral auto by) &&
diff --git a/include/flux/op/swap_elements.hpp b/include/flux/op/swap_elements.hpp
index 5a438ec9..4e629b65 100644
--- a/include/flux/op/swap_elements.hpp
+++ b/include/flux/op/swap_elements.hpp
@@ -30,7 +30,7 @@ struct swap_elements_fn {
 
 }
 
-inline constexpr auto swap_elements = detail::swap_elements_fn{};
+FLUX_EXPORT inline constexpr auto swap_elements = detail::swap_elements_fn{};
 
 }
 
diff --git a/include/flux/op/take.hpp b/include/flux/op/take.hpp
index a93d9e7f..ceea2d20 100644
--- a/include/flux/op/take.hpp
+++ b/include/flux/op/take.hpp
@@ -161,7 +161,7 @@ struct take_fn {
 
 } // namespace detail
 
-inline constexpr auto take = detail::take_fn{};
+FLUX_EXPORT inline constexpr auto take = detail::take_fn{};
 
 template <typename Derived>
 constexpr auto inline_sequence_base<Derived>::take(std::integral auto count) &&
diff --git a/include/flux/op/take_while.hpp b/include/flux/op/take_while.hpp
index fd6ad747..05eedd19 100644
--- a/include/flux/op/take_while.hpp
+++ b/include/flux/op/take_while.hpp
@@ -84,7 +84,7 @@ struct sequence_traits<detail::take_while_adaptor<Base, Pred>>
     }
 };
 
-inline constexpr auto take_while = detail::take_while_fn{};
+FLUX_EXPORT inline constexpr auto take_while = detail::take_while_fn{};
 
 template <typename D>
 template <typename Pred>
diff --git a/include/flux/op/to.hpp b/include/flux/op/to.hpp
index bfa6f1b7..1d393a22 100644
--- a/include/flux/op/to.hpp
+++ b/include/flux/op/to.hpp
@@ -117,6 +117,7 @@ using deduced_container_t = typename decltype(deduce_container_type<C, Seq, Args
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename Container, sequence Seq, typename... Args>
     requires (std::convertible_to<element_t<Seq>, detail::container_value_t<Container>> &&
                  detail::container_convertible<Container, Seq, Args...>) ||
@@ -147,6 +148,7 @@ constexpr auto to(Seq&& seq, Args&&... args) -> Container
     }
 }
 
+FLUX_EXPORT
 template <template <typename...> typename Container, sequence Seq, typename... Args>
     requires detail::can_deduce_container_type<Container, Seq, Args...> &&
              detail::container_convertible<
diff --git a/include/flux/op/unchecked.hpp b/include/flux/op/unchecked.hpp
index fbc419f7..a55025d9 100644
--- a/include/flux/op/unchecked.hpp
+++ b/include/flux/op/unchecked.hpp
@@ -57,7 +57,7 @@ struct unchecked_fn {
 
 } // namespace detail
 
-inline constexpr auto unchecked = detail::unchecked_fn{};
+FLUX_EXPORT inline constexpr auto unchecked = detail::unchecked_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/op/write_to.hpp b/include/flux/op/write_to.hpp
index 9d510b0b..c7dfe0ed 100644
--- a/include/flux/op/write_to.hpp
+++ b/include/flux/op/write_to.hpp
@@ -45,7 +45,7 @@ struct write_to_fn {
 
 } // namespace detail
 
-inline constexpr auto write_to = detail::write_to_fn{};
+FLUX_EXPORT inline constexpr auto write_to = detail::write_to_fn{};
 
 template <typename Derived>
 auto inline_sequence_base<Derived>::write_to(std::ostream& os) -> std::ostream&
diff --git a/include/flux/op/zip.hpp b/include/flux/op/zip.hpp
index 2d8af8ac..1fa0d555 100644
--- a/include/flux/op/zip.hpp
+++ b/include/flux/op/zip.hpp
@@ -192,7 +192,7 @@ struct sequence_traits<detail::zip_adaptor<Bases...>>
     }
 };
 
-inline constexpr auto zip = detail::zip_fn{};
+FLUX_EXPORT inline constexpr auto zip = detail::zip_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/op/zip_algorithms.hpp b/include/flux/op/zip_algorithms.hpp
index 239494a0..d0bbf566 100644
--- a/include/flux/op/zip_algorithms.hpp
+++ b/include/flux/op/zip_algorithms.hpp
@@ -40,7 +40,7 @@ struct zip_for_each_while_fn {
 
 } // namespace detail
 
-inline constexpr auto zip_for_each_while = detail::zip_for_each_while_fn{};
+FLUX_EXPORT inline constexpr auto zip_for_each_while = detail::zip_for_each_while_fn{};
 
 namespace detail {
 
@@ -93,9 +93,9 @@ struct zip_fold_fn {
 
 } // namespace detail
 
-inline constexpr auto zip_for_each = detail::zip_for_each_fn{};
-inline constexpr auto zip_find_if = detail::zip_find_if_fn{};
-inline constexpr auto zip_fold = detail::zip_fold_fn{};
+FLUX_EXPORT inline constexpr auto zip_for_each = detail::zip_for_each_fn{};
+FLUX_EXPORT inline constexpr auto zip_find_if = detail::zip_find_if_fn{};
+FLUX_EXPORT inline constexpr auto zip_fold = detail::zip_fold_fn{};
 
 } // namespace pred
 
diff --git a/include/flux/source/array_ptr.hpp b/include/flux/source/array_ptr.hpp
index 8ac9bb9c..c00d2d7d 100644
--- a/include/flux/source/array_ptr.hpp
+++ b/include/flux/source/array_ptr.hpp
@@ -19,6 +19,7 @@ struct make_array_ptr_unchecked_fn;
 
 }
 
+FLUX_EXPORT
 template <typename T>
     requires (std::is_object_v<T> && !std::is_abstract_v<T>)
 struct array_ptr : inline_sequence_base<array_ptr<T>> {
@@ -152,7 +153,8 @@ struct make_array_ptr_unchecked_fn {
 
 } // namespace detail
 
-inline constexpr auto make_array_ptr_unchecked = detail::make_array_ptr_unchecked_fn{};
+FLUX_EXPORT inline constexpr auto make_array_ptr_unchecked =
+    detail::make_array_ptr_unchecked_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/source/empty.hpp b/include/flux/source/empty.hpp
index 9c61288d..b5eb09f4 100644
--- a/include/flux/source/empty.hpp
+++ b/include/flux/source/empty.hpp
@@ -57,6 +57,7 @@ struct empty_sequence : inline_sequence_base<empty_sequence<T>> {
 
 } // namespace detail
 
+FLUX_EXPORT
 template <typename T>
     requires std::is_object_v<T>
 inline constexpr auto empty = detail::empty_sequence<T>{};
diff --git a/include/flux/source/generator.hpp b/include/flux/source/generator.hpp
index c8e0a387..ab93c646 100644
--- a/include/flux/source/generator.hpp
+++ b/include/flux/source/generator.hpp
@@ -13,6 +13,7 @@
 
 namespace flux {
 
+FLUX_EXPORT
 template <typename ElemT>
 struct generator : inline_sequence_base<generator<ElemT>> {
 
diff --git a/include/flux/source/getlines.hpp b/include/flux/source/getlines.hpp
index e3772699..20a0bc17 100644
--- a/include/flux/source/getlines.hpp
+++ b/include/flux/source/getlines.hpp
@@ -93,7 +93,7 @@ struct getlines_fn {
 
 } // namespace detail
 
-inline constexpr auto getlines = detail::getlines_fn{};
+FLUX_EXPORT inline constexpr auto getlines = detail::getlines_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/source/iota.hpp b/include/flux/source/iota.hpp
index c499e7cd..9bcd972f 100644
--- a/include/flux/source/iota.hpp
+++ b/include/flux/source/iota.hpp
@@ -186,8 +186,8 @@ struct ints_fn {
 
 } // namespace detail
 
-inline constexpr auto iota = detail::iota_fn{};
-inline constexpr auto ints = detail::ints_fn{};
+FLUX_EXPORT inline constexpr auto iota = detail::iota_fn{};
+FLUX_EXPORT inline constexpr auto ints = detail::ints_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/source/istream.hpp b/include/flux/source/istream.hpp
index 385f4e92..a8dda36b 100644
--- a/include/flux/source/istream.hpp
+++ b/include/flux/source/istream.hpp
@@ -85,6 +85,7 @@ struct sequence_traits<detail::istream_adaptor<T, CharT, Traits>>
     }
 };
 
+FLUX_EXPORT
 template <std::default_initializable T>
 inline constexpr auto from_istream = detail::from_istream_fn<T>{};
 
diff --git a/include/flux/source/istreambuf.hpp b/include/flux/source/istreambuf.hpp
index 0735f687..022f484c 100644
--- a/include/flux/source/istreambuf.hpp
+++ b/include/flux/source/istreambuf.hpp
@@ -76,6 +76,7 @@ struct sequence_traits<Streambuf>
     }
 };
 
+FLUX_EXPORT
 inline constexpr auto from_istreambuf = detail::from_istreambuf_fn{};
 
 } // namespace flux
diff --git a/include/flux/source/range.hpp b/include/flux/source/range.hpp
index 0aaa47fd..eaebace0 100644
--- a/include/flux/source/range.hpp
+++ b/include/flux/source/range.hpp
@@ -235,8 +235,8 @@ struct from_crange_fn {
 
 } // namespace detail
 
-inline constexpr auto from_range = detail::from_range_fn{};
-inline constexpr auto from_crange = detail::from_crange_fn{};
+FLUX_EXPORT inline constexpr auto from_range = detail::from_range_fn{};
+FLUX_EXPORT inline constexpr auto from_crange = detail::from_crange_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/source/repeat.hpp b/include/flux/source/repeat.hpp
index 64dab485..c421ea8d 100644
--- a/include/flux/source/repeat.hpp
+++ b/include/flux/source/repeat.hpp
@@ -138,7 +138,7 @@ struct repeat_fn {
 
 } // namespace detail
 
-inline constexpr auto repeat = detail::repeat_fn{};
+FLUX_EXPORT inline constexpr auto repeat = detail::repeat_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/source/single.hpp b/include/flux/source/single.hpp
index 3196956e..3abc4f33 100644
--- a/include/flux/source/single.hpp
+++ b/include/flux/source/single.hpp
@@ -127,7 +127,7 @@ struct sequence_traits<detail::single_sequence<T>>
 
 };
 
-inline constexpr auto single = detail::single_fn{};
+FLUX_EXPORT inline constexpr auto single = detail::single_fn{};
 
 } // namespace flux
 
diff --git a/include/flux/source/unfold.hpp b/include/flux/source/unfold.hpp
index bec219f8..3ee1d694 100644
--- a/include/flux/source/unfold.hpp
+++ b/include/flux/source/unfold.hpp
@@ -84,7 +84,7 @@ struct unfold_fn {
 
 } // namespace detail
 
-inline constexpr auto unfold = detail::unfold_fn{};
+FLUX_EXPORT inline constexpr auto unfold = detail::unfold_fn{};
 
 } // namespace flux
 
diff --git a/module/flux.cpp b/module/flux.cpp
new file mode 100644
index 00000000..5560da71
--- /dev/null
+++ b/module/flux.cpp
@@ -0,0 +1,34 @@
+
+module;
+
+#include <array>
+#include <compare>
+#include <concepts>
+#include <coroutine>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <exception>
+#include <functional>
+#include <initializer_list>
+#include <iosfwd>
+#include <iterator>
+#include <limits>
+#include <optional>
+#include <ranges>
+#include <source_location>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <variant>
+#include <version>
+
+export module flux;
+
+#define FLUX_MODULE_INTERFACE
+
+#include <flux.hpp>