diff --git a/src/adapter_matcher.cpp b/src/adapter_matcher.cpp
index 59139ba..0ac539a 100644
--- a/src/adapter_matcher.cpp
+++ b/src/adapter_matcher.cpp
@@ -84,8 +84,15 @@ adapter_matcher::report(const std::uint64_t n_reads,
   r += '\n';
 
   auto cumulative = adap_counts;
+#if __cpp_lib_ranges_zip
   for (auto [prev, curr] : cumulative | std::views::pairwise)
     std::ranges::transform(curr, prev, std::begin(curr), std::plus{});
+#else
+  for (auto prev = 0LU, curr = 1LU; curr < std::size(cumulative);
+       ++prev, ++curr)
+    std::ranges::transform(cumulative[curr], cumulative[prev],
+                           std::begin(cumulative[curr]), std::plus{});
+#endif
 
   const auto n_pos = max_read_len + 1 >= adapter_size
                        ? max_read_len - adapter_size + 1
@@ -96,7 +103,7 @@ adapter_matcher::report(const std::uint64_t n_reads,
   const auto fmt_pct_of_reads = [n_reads](const auto c) {
     return std::format("\t{:.6g}", pct(as_frac(c, n_reads)));
   };
-  for (const auto [idx, cumul] : std::views::enumerate(cumulative))
+  for (const auto [idx, cumul] : falco::views::enumerate(cumulative))
     r += std::format("{}{}\n", make_group_tag(groups[idx]),
                      to_flat(cumul, fmt_pct_of_reads));
   return r + end_module_tag;
@@ -130,9 +137,15 @@ name: "{}",
                    return make_group_tag(g);  // ADS: purposely unquoted
                  });
   auto cumulative = adap_counts;
+#if __cpp_lib_ranges_zip
   for (auto [prev, curr] : cumulative | std::views::pairwise)
     std::ranges::transform(curr, prev, std::begin(curr), std::plus{});
-
+#else
+  for (auto prev = 0LU, curr = 1LU; curr < std::size(cumulative);
+       ++prev, ++curr)
+    std::ranges::transform(cumulative[curr], cumulative[prev],
+                           std::begin(cumulative[curr]), std::plus{});
+#endif
   const auto n_pos = max_read_len + 1 >= adapter_size
                        ? max_read_len - adapter_size + 1
                        : max_read_len;
@@ -145,7 +158,8 @@ name: "{}",
   };
   std::vector<std::string> html_by_adapter;
   const auto adapter_names = adapter_set::instance().adapter_names;
-  for (const auto [adap_id, adap_name] : std::views::enumerate(adapter_names)) {
+  for (const auto [adap_id, adap_name] :
+       falco::views::enumerate(adapter_names)) {
     const auto make_y = [&](const auto &cumul) {
       return pct_of_reads(cumul[adap_id]);
     };
diff --git a/src/adapter_set.cpp b/src/adapter_set.cpp
index 9d33107..bf94c70 100644
--- a/src/adapter_set.cpp
+++ b/src/adapter_set.cpp
@@ -74,10 +74,9 @@ adapter_set::adapter_set(const run_mode &m, const std::string &filename) {
 
 [[nodiscard]] auto
 adapter_set::validate() const -> std::tuple<bool, std::string> {
-  const auto &adapters = instance().adapters;
-  if (adapters.empty())
+  if (instance().adapters.empty())
     return {true, std::string{}};
-  const auto adap_len = std::size(adapters.front());
+  const auto adap_len = std::size(instance().adapters.front());
   if (!std::ranges::all_of(instance().adapters, [&](const auto &a) {
         return std::size(a) == adap_len;
       }))
diff --git a/src/adapter_set.hpp b/src/adapter_set.hpp
index a476425..f090a5e 100644
--- a/src/adapter_set.hpp
+++ b/src/adapter_set.hpp
@@ -12,6 +12,8 @@
 #include <variant>
 #include <vector>
 
+// ADS: all this code assumes all adapters for a given run of falco have the
+// same length
 struct adapter_set {
   static constexpr auto min_adapter_size = 6;
   static constexpr auto max_adapter_size = 16;
diff --git a/src/base_groups.cpp b/src/base_groups.cpp
index a10afc5..ab09bbc 100644
--- a/src/base_groups.cpp
+++ b/src/base_groups.cpp
@@ -44,8 +44,17 @@ make_base_groups(const std::uint64_t n_bases, const std::uint64_t n_initial,
   static constexpr auto make_groups = [](const auto n, const auto offset,
                                          const auto scale) {
     const auto f = [scale, offset](const auto x) { return offset + x * scale; };
+#if __cpp_lib_ranges_zip
     return std::views::transform(std::views::iota(0LU, n + 1), f) |
            std::views::adjacent_transform<2>(make_one_group);
+#else
+    const auto x = std::views::transform(std::views::iota(0LU, n + 1), f) |
+                   std::ranges::to<std::vector>();
+    std::vector<base_group_t> r(n);
+    for (auto i = 0U; i < n; ++i)
+      r[i] = make_one_group(x[i], x[i + 1]);
+    return r;
+#endif
   };
   if (n_bases <= n_initial + n_groups_target)
     return make_groups(n_bases, 0, 1) | std::ranges::to<std::vector>();
@@ -63,8 +72,8 @@ make_base_groups(const std::uint64_t n_bases, const std::uint64_t n_initial,
 }
 
 [[nodiscard]] auto
-get_default_base_groups(const std::uint64_t n_bases,
-                        const bool make_groups) -> base_group_vec {
+get_default_base_groups(const std::uint64_t n_bases, const bool make_groups)
+  -> base_group_vec {
   static constexpr auto default_n_initial = 9UL;
   static constexpr auto default_n_groups_target = 75UL - default_n_initial;
   return make_groups ? make_base_groups(n_bases, default_n_initial,
diff --git a/src/base_groups.hpp b/src/base_groups.hpp
index d79d573..75a561d 100644
--- a/src/base_groups.hpp
+++ b/src/base_groups.hpp
@@ -38,7 +38,7 @@ apply_base_groups(const base_group_vec &groups, auto &rows) {
   auto group_itr = std::cbegin(groups);
   auto current_row = 0U;
   for (const auto [idx, row] :
-       std::views::enumerate(rows) | std::views::drop(1)) {
+       falco::views::enumerate(rows) | std::views::drop(1)) {
     if (static_cast<std::uint64_t>(idx) < group_itr->second)
       add(rows[current_row], row);
     else {
@@ -56,7 +56,7 @@ apply_base_groups(const base_group_vec &groups, auto &rows, const auto &adder) {
   auto group_itr = std::cbegin(groups);
   auto current_row = 0U;
   for (const auto [idx, row] :
-       std::views::enumerate(rows) | std::views::drop(1)) {
+       falco::views::enumerate(rows) | std::views::drop(1)) {
     if (static_cast<std::uint64_t>(idx) < group_itr->second)
       adder(rows[current_row], row);
     else {
diff --git a/src/contaminants.cpp b/src/contaminants.cpp
index f688b57..356879d 100644
--- a/src/contaminants.cpp
+++ b/src/contaminants.cpp
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: MIT; Copyright 2026 Andrew D Smith
 
 #include "contaminants.hpp"
+#include "falco_utils.hpp"
 
 #include <algorithm>
 #include <cctype>
@@ -244,7 +245,7 @@ match_contaminant(const std::string &query) -> std::int64_t {
   auto best_match = 0L;
   auto best_match_len = 0L;
   for (const auto &[idx, seq] :
-       std::views::enumerate(std::views::elements<1>(contaminants))) {
+       falco::views::enumerate(std::views::elements<1>(contaminants))) {
     const auto n_match =
       std::max(get_overlap(query, seq), get_overlap(seq, query));
     if (n_match > best_match) {
diff --git a/src/duplication_results.cpp b/src/duplication_results.cpp
index ee813ef..f2842d7 100644
--- a/src/duplication_results.cpp
+++ b/src/duplication_results.cpp
@@ -27,6 +27,7 @@
 #include <ranges>
 #include <string>
 #include <tuple>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -179,7 +180,7 @@ overrepresented_report(const std::vector<overrep_t> &overrep,
 make_bins(const auto &breaks, const auto &hist) {
   std::vector<std::uint64_t> binned(std::size(breaks), 0);
   auto b_itr = std::cbegin(breaks);
-  for (const auto [i, h] : std::views::enumerate(hist)) {
+  for (const auto [i, h] : falco::views::enumerate(hist)) {
     // ADS: clang-tidy false positive?
     // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
     b_itr += (b_itr < std::cend(breaks) && i >= *b_itr);
@@ -229,12 +230,12 @@ duplication_results::get_dups_summary(const std::uint64_t n_reads) const
   std::vector<std::uint64_t> hist_dedup(max_dup + 1);
   for (const auto n_copies : std::views::values(dups))
     ++hist_dedup[n_copies];
-  for (auto [idx, val] : std::views::enumerate(hist_dedup))
+  for (auto [idx, val] : falco::views::enumerate(hist_dedup))
     val = static_cast<std::uint64_t>(
       get_corrected_count(count_at_limit, n_reads, idx, val));
   auto hist_mass =
     std::views::transform(
-      std::views::enumerate(hist_dedup),
+      falco::views::enumerate(hist_dedup),
       [](const auto x) { return std::get<0>(x) * std::get<1>(x); }) |
     std::ranges::to<std::vector>();
   return dup_summary_t{
@@ -255,7 +256,7 @@ duplication_results::get_dups_summary() const -> dup_summary_t {
     ++hist_dedup[n_copies];
   auto hist_mass =
     std::views::transform(
-      std::views::enumerate(hist_dedup),
+      falco::views::enumerate(hist_dedup),
       [](const auto x) { return std::get<0>(x) * std::get<1>(x); }) |
     std::ranges::to<std::vector>();
   return dup_summary_t{
diff --git a/src/duplication_results.hpp b/src/duplication_results.hpp
index ab04d5a..a86afc4 100644
--- a/src/duplication_results.hpp
+++ b/src/duplication_results.hpp
@@ -12,6 +12,7 @@
 #include <numeric>
 #include <ranges>
 #include <string>
+#include <utility>
 #include <vector>
 
 class run_mode;
diff --git a/src/falco.cpp b/src/falco.cpp
index 934daec..7150b38 100644
--- a/src/falco.cpp
+++ b/src/falco.cpp
@@ -41,6 +41,7 @@ Use these as templates. Copy and modify them to customize your analysis.
 #include "adapter_set.hpp"
 #include "bam_file.hpp"
 #include "contaminants.hpp"
+#include "duplication_results.hpp"
 #include "falco_analyzer.hpp"
 #include "falco_config.hpp"
 #include "falco_file_format.hpp"
@@ -49,12 +50,12 @@ Use these as templates. Copy and modify them to customize your analysis.
 #include "fastq_bgzf_file.hpp"
 #include "fastq_file.hpp"
 #include "fastq_gz_file.hpp"
+#include "file_info.hpp"
 #include "get_binary_dir.hpp"
 #include "original_duplicates.hpp"
-#include "quality_score.hpp"
 #include "reads_file.hpp"  // IWYU pragma: keep
-#include "results_collector.hpp"
 #include "results_summary.hpp"
+#include "run_mode.hpp"
 #include "sam_file.hpp"
 #include "tile_processor.hpp"
 
@@ -73,6 +74,7 @@ Use these as templates. Copy and modify them to customize your analysis.
 #include <fstream>
 #include <functional>
 #include <iterator>
+#include <limits>
 #include <map>
 #include <memory>
 #include <print>
@@ -80,10 +82,12 @@ Use these as templates. Copy and modify them to customize your analysis.
 #include <stdexcept>
 #include <string>
 #include <thread>
-#include <type_traits>
+#include <tuple>
 #include <utility>
 #include <vector>
 
+struct results_collector;
+
 static auto
 write_file(const auto &filename, const auto &data) {
   std::ofstream out(filename);
@@ -141,7 +145,7 @@ make_reads_files(const std::vector<file_info> &infos,
 [[nodiscard]] static auto
 get_file_info(const auto &infiles) {
   std::vector<file_info> infos;
-  for (const auto [file_id, infile] : std::views::enumerate(infiles)) {
+  for (const auto [file_id, infile] : falco::views::enumerate(infiles)) {
     const auto [input_format, format_description] = get_file_format(infile);
     const auto tile_id_position = get_tile_info(infile);
     const bool has_tiles = (tile_id_position != 0);
diff --git a/src/falco_analyzer.cpp b/src/falco_analyzer.cpp
index 549f9db..145a0ec 100644
--- a/src/falco_analyzer.cpp
+++ b/src/falco_analyzer.cpp
@@ -5,6 +5,7 @@
 #include "bamrec.hpp"
 #include "bgzf_block.hpp"
 #include "duplication_results.hpp"
+#include "falco_utils.hpp"
 #include "file_info.hpp"
 #include "fqrec.hpp"
 #include "reads_file.hpp"
@@ -48,7 +49,7 @@ analyze(const std::uint32_t n_threads, const run_mode &mode,
     for (const auto th_id : std::views::iota(0u, n_threads))
       workers.emplace_back([&, n_threads, th_id] {
         auto &res = results[th_id];
-        for (const auto [file_id, info] : std::views::enumerate(infos))
+        for (const auto [file_id, info] : falco::views::enumerate(infos))
           res[file_id].init(mode, info, dups_init[file_id]);
         while (true) {
           auto tq_lock = tq.wait_and_acquire_lock();
diff --git a/src/falco_config.cpp b/src/falco_config.cpp
index 6b3c538..f5a3a38 100644
--- a/src/falco_config.cpp
+++ b/src/falco_config.cpp
@@ -9,15 +9,17 @@
 
 #include <algorithm>
 #include <array>
+#include <cctype>
 #include <charconv>
+#include <format>
 #include <fstream>
 #include <iterator>
-#include <map>
 #include <ranges>
+#include <sstream>
 #include <stdexcept>
 #include <string>
+#include <system_error>
 #include <unordered_map>
-#include <utility>
 #include <vector>
 
 [[nodiscard]] auto
diff --git a/src/falco_config.hpp b/src/falco_config.hpp
index be193b8..c65276e 100644
--- a/src/falco_config.hpp
+++ b/src/falco_config.hpp
@@ -5,7 +5,7 @@
 
 #include <string>
 
-struct run_mode;
+class run_mode;
 
 // ADS: run mode is an out-param because it might be partially set already
 auto
diff --git a/src/falco_utils.cpp b/src/falco_utils.cpp
index 0959ca1..926dc39 100644
--- a/src/falco_utils.cpp
+++ b/src/falco_utils.cpp
@@ -7,7 +7,9 @@
 #include <cstdint>
 #include <ctime>  // for std::localtime
 #include <format>
+#include <iomanip>  // for std::put_time
 #include <span>
+#include <sstream>
 #include <string>
 #include <tuple>
 #include <vector>
@@ -56,7 +58,8 @@ get_theoretical_distribution(const std::vector<double> &gc,
   const auto sd_term = [&](const auto &x) {
     return cntr_sq(std::get<0>(x)) * std::get<1>(x);
   };
-  const auto id_gc = std::views::enumerate(gc) | std::views::transform(sd_term);
+  const auto id_gc =
+    falco::views::enumerate(gc) | std::views::transform(sd_term);
   const auto sd = std::sqrt(as_frac(
     std::reduce(std::cbegin(id_gc), std::cend(id_gc)), total_count - 1));
   const auto to_normal = [&](const auto val) {
@@ -98,9 +101,16 @@ smooth_gc_content(const std::vector<double> &data,
   for (auto w = 1; w < (window_size + 1) / 2; ++w)
     smoothed.push_back(get_mean(
       std::ranges::subrange(std::cbegin(data), std::cbegin(data) + w)));
+#if __cpp_lib_ranges_slide
   for (const auto &window : data | std::views::slide(window_size))
     // cppcheck-suppress useStlAlgorithm
     smoothed.push_back(get_mean(window));
+#else
+  for (auto i = 0LU; i < std::size(data); ++i)
+    // cppcheck-suppress useStlAlgorithm
+    smoothed.push_back(get_mean(std::ranges::subrange(
+      std::cbegin(data) + i, std::cbegin(data) + i + window_size)));
+#endif
   for (auto w = (window_size + 1) / 2; w > 1; --w)
     smoothed.push_back(get_mean(
       std::ranges::subrange(std::cend(data) - w + 1, std::cend(data))));
@@ -145,10 +155,8 @@ combine_gc_content_for_lengths(const std::vector<falco::gc_content_array> &gcs)
 }
 
 [[nodiscard]] auto
-get_program_start_time()
-  -> std::chrono::time_point<std::chrono::high_resolution_clock,
-                             std::chrono::nanoseconds> {
-  static const auto start_time = std::chrono::high_resolution_clock::now();
+get_program_start_time() -> std::chrono::time_point<std::chrono::system_clock> {
+  static const auto start_time = std::chrono::system_clock::now();
   return start_time;
 }
 
diff --git a/src/falco_utils.hpp b/src/falco_utils.hpp
index 67ff487..85b60fe 100644
--- a/src/falco_utils.hpp
+++ b/src/falco_utils.hpp
@@ -9,6 +9,7 @@
 #include <chrono>
 #include <concepts>
 #include <cstdint>
+#include <format>
 #include <functional>
 #include <iterator>
 #include <numeric>
@@ -58,6 +59,27 @@ static constexpr auto gc_content_array_max_lim = 250;
 static constexpr auto gc_content_array_max_size = gc_content_array_max_lim + 1;
 using nuc_array = std::array<std::uint64_t, alphabet_size>;
 using gc_content_array = std::vector<std::uint64_t>;
+
+// ADS: this is because I wrote falco v2 using std::views::enumerate in many
+// places, but macOS apple-clang still doesn't have this c++20 feature. Not
+// using full 'std::views::enumerate'. Assuming std::ranges::sized_range
+namespace views {
+#if __cpp_lib_ranges_enumerate
+using std::views::enumerate;
+#else
+// ADS: from https://brevzin.github.io/c++/2022/12/05/enumerate
+struct enumerate_t : std::ranges::range_adaptor_closure<enumerate_t> {
+  template <std::ranges::viewable_range R>
+    requires std::ranges::sized_range<R>
+  [[nodiscard]] constexpr auto
+  operator()(R &&r) const {
+    const auto d = std::ranges::distance(r);
+    return std::views::zip(std::views::iota(0, d), static_cast<R &&>(r));
+  }
+};
+inline constexpr enumerate_t enumerate;
+#endif
+}  // namespace views
 }  // namespace falco
 
 static constexpr std::int64_t gigabytes = 1024 * 1024 * 1024;
@@ -93,13 +115,19 @@ sum_deviation_from_normal(const std::vector<double> &gc) -> double;
 [[nodiscard]] auto
 get_run_duration(const auto start_time) {
   using namespace std::literals::chrono_literals;
-  const auto d = std::chrono::high_resolution_clock::now() - start_time;
+  const auto d = std::chrono::system_clock::now() - start_time;
   const auto d_ms = std::chrono::floor<std::chrono::milliseconds>(d);
   if (d < 1min) {
     const auto ds =
       std::chrono::duration_cast<std::chrono::duration<double>>(d).count();
     return std::format("0:{:05.2f}", ds);
   }
+  if (d < 1h) {
+    const auto dm = std::chrono::floor<std::chrono::minutes>(d);
+    const auto ds =
+      std::chrono::duration_cast<std::chrono::duration<double>>(d - dm);
+    return std::format("{}:{:05.2f}", dm.count(), ds.count());
+  }
   return std::format("{}", std::chrono::hh_mm_ss{d_ms});
 }
 
@@ -245,7 +273,7 @@ count_gc(auto seq_itr, const auto seq_end) {
 [[nodiscard]] inline auto
 tabular_dot(const auto &a) {
   auto total = static_cast<std::remove_cvref_t<decltype(a)>::value_type>(0);
-  for (const auto [i, x] : std::views::enumerate(a))
+  for (const auto [i, x] : falco::views::enumerate(a))
     total += i * x;
   return total;
 }
@@ -298,8 +326,8 @@ five_quants(const auto &a) -> std::array<std::uint32_t, 5> {
 // NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
 
 [[nodiscard]] auto
-size_to_units(const std::int64_t s,
-              const std::string &suffix = "iB") -> std::string;
+size_to_units(const std::int64_t s, const std::string &suffix = "iB")
+  -> std::string;
 
 [[nodiscard]] inline auto
 get_max_size(const auto &x) {
@@ -322,18 +350,22 @@ estimate_read_length_fastq_chunk(const auto &data, const auto n) {
   if (std::size(lines) < fastq_lines_per_read)
     return 1ul;
   auto total = 0ul;
-  for (const auto l : lines | std::views::adjacent<fastq_lines_per_read - 1>)
+#if __cpp_lib_ranges_zip
+  for (const auto l : lines | std::views::adjacent<fastq_lines_per_read - 1>) {
+#else
+  for (auto i = 0U; i + fastq_lines_per_read < std::size(lines) + 1; ++i) {
+    std::tuple<std::int64_t, std::int64_t, std::int64_t> l{i, i + 1, i + 2};
+#endif
     if (data[std::get<0>(l)] == '@' && data[std::get<2>(l)] == '+' &&
         valid(data[std::get<1>(l)]))
       // cppcheck-suppress useStlAlgorithm
       total += (std::get<2>(l) - std::get<1>(l)) - 1;
+  }
   return total / (std::size(lines) / fastq_lines_per_read);
 }
 
 [[nodiscard]] auto
-get_program_start_time()
-  -> std::chrono::time_point<std::chrono::high_resolution_clock,
-                             std::chrono::nanoseconds>;
+get_program_start_time() -> std::chrono::time_point<std::chrono::system_clock>;
 
 [[nodiscard]] auto
 format_program_start_date_and_time() -> std::string;
diff --git a/src/html.cpp b/src/html.cpp
index 3168d16..fb88c8e 100644
--- a/src/html.cpp
+++ b/src/html.cpp
@@ -20,16 +20,12 @@
 #include <algorithm>
 #include <array>
 #include <cassert>
-#include <chrono>
 #include <cmath>
-#include <ctime>  // for std::localtime
 #include <format>
-#include <iomanip>
 #include <iterator>
 #include <map>
 #include <numeric>
 #include <ranges>
-#include <sstream>  // to format time with timezone
 #include <stdexcept>
 #include <string>
 #include <vector>  // IWYU pragma: keep
@@ -196,7 +192,13 @@ line: {{color: "{}"}}
     const auto pct_for_pos = [idx](const auto &nucs_for_pos, const auto tot) {
       return pct(as_frac(nucs_for_pos[idx], tot));
     };
+#if __cpp_lib_ranges_zip
     const auto y = std::views::zip_transform(pct_for_pos, nucs, total_by_pos);
+#else
+    std::vector<double> y;
+    for (const auto [nuc, tot] : std::views::zip(nucs, total_by_pos))
+      y.push_back(pct_for_pos(nuc, tot));
+#endif
     r.emplace_back(fmt::format(per_base_fmt, fmt::join(x, ","),
                                fmt::join(y, ","), bases[idx],
                                base_colors_for_html[idx]));
@@ -239,11 +241,18 @@ yaxis: {{title: "% N", range: [0, 100]}},
   assert(std::size(nucs) == std::size(groups));
   const auto grade = grades.grade(label);
   const auto title = grades.get_title(label);
+#if __cpp_lib_ranges_zip
+  const auto y = std::views::zip_transform(pct_for_pos, nucs, n_counts);
+#else
+  std::vector<double> y;
+  for (const auto [nuc, n_count] : std::views::zip(nucs, n_counts))
+    y.push_back(pct_for_pos(nuc, n_count));
+#endif
   return fmt::format(
     html_module_fmt, grade, label, title, grade,
-    fmt::format(
-      plot_fmt, fmt::join(groups | std::views::transform(make_tag), ","),
-      fmt::join(std::views::zip_transform(pct_for_pos, nucs, n_counts), ",")));
+    fmt::format(plot_fmt,
+                fmt::join(groups | std::views::transform(make_tag), ","),
+                fmt::join(y, ",")));
 }
 
 [[nodiscard]] auto
@@ -321,7 +330,7 @@ yaxis: {{title: "Phred quality", rangemode: "tozero"}},
     return "green";
   };
   std::vector<std::string> lines;
-  for (const auto [idx, q] : std::views::enumerate(qual)) {
+  for (const auto [idx, q] : falco::views::enumerate(qual)) {
     const auto fq = five_quants(q);
     lines.emplace_back(fmt::format(row_fmt, fmt::join(fq, ", "),
                                    // ADS: unquoted on purpose
@@ -373,8 +382,8 @@ basic_stats_html(const file_info &info, const std::uint64_t n_reads,
 
 [[nodiscard]] auto
 tile_html(const tile_processor::tiles_centered_t &centered,
-          const std::vector<base_group_t> &groups,
-          const file_grades &grades) -> std::string {
+          const std::vector<base_group_t> &groups, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "tile";
   static constexpr auto n_quants = 20.0;
   // ADS: ??? (-10: red, 0: light blue, +10: dark blue)
@@ -433,8 +442,8 @@ yaxis: {{title: "tile", type: "category"}},
 }
 
 [[nodiscard]] auto
-kmer_html(const std::vector<kmer_result> &results,
-          const file_grades &grades) -> std::string {
+kmer_html(const std::vector<kmer_result> &results, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "kmer";
   static constexpr auto plot_format = R"(<div id="kmer_plot"></div>
 <script>Plotly.newPlot("kmer_plot",
diff --git a/src/kmer_counter.cpp b/src/kmer_counter.cpp
index 1d1f4e7..b4badbe 100644
--- a/src/kmer_counter.cpp
+++ b/src/kmer_counter.cpp
@@ -11,18 +11,16 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
-#include <compare>
 #include <cstdint>
 #include <cstdlib>
-#include <format>  // IWYU pragma: keep
-#include <functional>
+#include <format>
 #include <limits>
 #include <numeric>
 #include <ranges>
 #include <string>
 #include <tuple>
 #include <type_traits>
-#include <utility>  // IWYU pragma: keep
+#include <utility>
 #include <vector>
 
 [[nodiscard]] auto
@@ -135,7 +133,7 @@ kmer_counter::get_kmer_results() const -> std::vector<kmer_result> {
   auto results = counts_by_kmer | std::views::transform(kr_maker) |
                  std::ranges::to<std::vector>();
 
-  for (const auto [pos, pos_counts] : std::views::enumerate(kmer_counts)) {
+  for (const auto [pos, pos_counts] : falco::views::enumerate(kmer_counts)) {
     const auto count_for_pos = static_cast<double>(counts_by_pos[pos]);
     const auto pos_prob = pos_probs[pos];
     const auto per_kmer = std::views::zip(pos_counts, kmer_probs, results);
diff --git a/src/report.cpp b/src/report.cpp
index 69f712a..e1b774a 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -42,7 +42,7 @@ sequence_length_report(const std::vector<std::uint64_t> &lengths,
   const auto eq0 = [](const auto &x) { return std::get<1>(x) == 0; };
   auto r = std::format(start_tag, grades.grade(label));
   r += header;
-  auto to_report = std::views::enumerate(lengths) | std::views::drop_while(eq0);
+  auto to_report = falco::views::enumerate(lengths) | std::views::drop_while(eq0);
   for (const auto [idx, len] : to_report)
     r += std::format("{}\t{}\n", idx, len);
   r += end_module_tag;
@@ -57,7 +57,7 @@ gc_sequence_report(const std::vector<double> &gc_content,
   static constexpr auto header = "#GC Content\tCount\n";
   auto r = std::format(start_tag, grades.grade(label));
   r += header;
-  for (const auto [idx, gc] : std::views::enumerate(gc_content))
+  for (const auto [idx, gc] : falco::views::enumerate(gc_content))
     r += std::format("{}\t{}\n", idx, std::round(gc));
   r += end_module_tag;
   return r;
@@ -168,7 +168,7 @@ quality_base_report(const std::vector<falco::qual_array> &qual,
   };
   auto r = std::format(start_tag, grades.grade(label));
   r += header;
-  for (const auto [idx, q] : std::views::enumerate(qual))
+  for (const auto [idx, q] : falco::views::enumerate(qual))
     r += std::format("{}\t{:.{}g}{}\n", make_group_tag(groups[idx]),
                      mean_tabular(q), digits, tab_sep(five_quants(q)));
   r += end_module_tag;
diff --git a/src/results_summary.cpp b/src/results_summary.cpp
index 70cfc12..d1772b4 100644
--- a/src/results_summary.cpp
+++ b/src/results_summary.cpp
@@ -11,6 +11,7 @@
 #include <algorithm>
 #include <array>
 #include <assert.h>
+#include <format>
 #include <iterator>
 #include <numeric>
 #include <ranges>
diff --git a/src/run_mode.cpp b/src/run_mode.cpp
index 203d879..5993cba 100644
--- a/src/run_mode.cpp
+++ b/src/run_mode.cpp
@@ -6,8 +6,10 @@
 #include <format>
 #include <iterator>
 #include <ranges>
+#include <stdexcept>
 #include <string>
 #include <unordered_map>
+#include <utility>
 #include <vector>
 
 // ADS: mapping between labels and function/var names
diff --git a/src/tile_processor.cpp b/src/tile_processor.cpp
index 4c0dbb0..11a4654 100644
--- a/src/tile_processor.cpp
+++ b/src/tile_processor.cpp
@@ -74,7 +74,7 @@ tile_processor::get_centered() -> tile_processor::tiles_centered_t {
   std::vector<double> means(current_max_len);
   std::vector<double> n_tiles_for_size(current_max_len);
   for (const auto &tile_quals : quals | std::views::values) {
-    for (const auto [i, q] : std::views::enumerate(tile_quals))
+    for (const auto [i, q] : falco::views::enumerate(tile_quals))
       means[i] += as_frac(q.first, q.second);
     if (!tile_quals.empty())
       ++n_tiles_for_size[std::size(tile_quals) - 1ul];
@@ -94,7 +94,13 @@ tile_processor::get_centered() -> tile_processor::tiles_centered_t {
 
   tile_processor::tiles_centered_t centered;
   for (const auto &[id, vals] : quals) {
+#if __cpp_lib_ranges_zip
     const auto cent_vals = std::views::zip_transform(get_cent, vals, means);
+#else
+    std::vector<double> cent_vals;
+    for (const auto [val, mean] : std::views::zip(vals, means))
+      cent_vals.push_back(get_cent(val, mean));
+#endif
     centered.emplace(id, cent_vals | std::ranges::to<std::vector>());
   }
   return centered;
@@ -117,7 +123,7 @@ tile_processor::trim() -> void {
   // analysis, so we trim each tile to its own max read length post-analysis
   for (auto &tile_quals : quals | std::views::values) {
     auto first_trailing_zero = 0L;
-    for (const auto [i, q] : std::views::enumerate(tile_quals))
+    for (const auto [i, q] : falco::views::enumerate(tile_quals))
       first_trailing_zero = q.second > 0 ? i + 1 : first_trailing_zero;
     tile_quals.resize(first_trailing_zero);
   }