diff --git a/tests/benchmarks/cpu/propagation.cpp b/tests/benchmarks/cpu/propagation.cpp
index a182d03ad..30d1c1653 100644
--- a/tests/benchmarks/cpu/propagation.cpp
+++ b/tests/benchmarks/cpu/propagation.cpp
@@ -92,7 +92,7 @@ int main(int argc, char** argv) {
             n_tracks);
 
     // Specific configuration for the random track generation
-    trk_cfg.seed(42u);
+    trk_cfg.seed(detail::random_numbers<scalar>::default_seed());
 
     // Add additional tracks for warmup
     bench_cfg.n_warmup(static_cast<int>(
diff --git a/tests/include/detray/test/common/detector_scan_config.hpp b/tests/include/detray/test/common/detector_scan_config.hpp
index c1deb59dd..62672d7a6 100644
--- a/tests/include/detray/test/common/detector_scan_config.hpp
+++ b/tests/include/detray/test/common/detector_scan_config.hpp
@@ -26,8 +26,8 @@ namespace detray::test {
 template <typename track_generator_t>
 struct detector_scan_config : public test::fixture_base<>::configuration {
     using base_type = test::fixture_base<>;
-    using scalar_type = typename base_type::scalar_type;
-    using vector3_type = typename base_type::vector3_type;
+    using scalar_type = typename base_type::scalar;
+    using vector3_type = typename base_type::vector3;
     using trk_gen_config_t = typename track_generator_t::configuration;
 
     /// Name of the test
diff --git a/tests/include/detray/test/common/material_validation_config.hpp b/tests/include/detray/test/common/material_validation_config.hpp
index e14525263..14ea10262 100644
--- a/tests/include/detray/test/common/material_validation_config.hpp
+++ b/tests/include/detray/test/common/material_validation_config.hpp
@@ -25,8 +25,8 @@ namespace detray::test {
 /// @brief Configuration for a detector scan test.
 struct material_validation_config : public test::fixture_base<>::configuration {
     using base_type = test::fixture_base<>;
-    using scalar_type = typename base_type::scalar_type;
-    using vector3_type = typename base_type::vector3_type;
+    using scalar_type = typename base_type::scalar;
+    using vector3_type = typename base_type::vector3;
 
     /// Name of the test
     std::string m_name{"material_validation"};
diff --git a/tests/include/detray/test/common/navigation_validation_config.hpp b/tests/include/detray/test/common/navigation_validation_config.hpp
index c18f12923..b76f89ce0 100644
--- a/tests/include/detray/test/common/navigation_validation_config.hpp
+++ b/tests/include/detray/test/common/navigation_validation_config.hpp
@@ -26,8 +26,8 @@ namespace detray::test {
 struct navigation_validation_config
     : public test::fixture_base<>::configuration {
     using base_type = test::fixture_base<>;
-    using scalar_type = typename base_type::scalar_type;
-    using vector3_type = typename base_type::vector3_type;
+    using scalar_type = typename base_type::scalar;
+    using vector3_type = typename base_type::vector3;
 
     /// Name of the test
     std::string m_name{"navigation_validation"};
diff --git a/tests/tools/CMakeLists.txt b/tests/tools/CMakeLists.txt
index 3e4fb870c..544f49168 100644
--- a/tests/tools/CMakeLists.txt
+++ b/tests/tools/CMakeLists.txt
@@ -21,7 +21,6 @@ target_link_libraries(
     INTERFACE
         Boost::program_options
         vecmem::core
-        detray::core_array
         detray::test_common
         detray::io
         detray::csv_io
diff --git a/tests/tools/include/detray/options/propagation_options.hpp b/tests/tools/include/detray/options/propagation_options.hpp
index 7e634a323..57bc8082d 100644
--- a/tests/tools/include/detray/options/propagation_options.hpp
+++ b/tests/tools/include/detray/options/propagation_options.hpp
@@ -172,6 +172,7 @@ void configure_options<detray::stepping::config>(
 
         cfg.path_limit = path_limit * unit<float>::m;
     }
+    cfg.do_covariance_transport = false;
     if (vm.count("covariance_transport")) {
         cfg.do_covariance_transport = true;
     }
diff --git a/tests/tools/include/detray/options/track_generator_options.hpp b/tests/tools/include/detray/options/track_generator_options.hpp
index 071d41d80..0ec1b56e5 100644
--- a/tests/tools/include/detray/options/track_generator_options.hpp
+++ b/tests/tools/include/detray/options/track_generator_options.hpp
@@ -38,6 +38,9 @@ void add_uniform_track_gen_options(
         boost::program_options::value<std::size_t>()->default_value(
             cfg.eta_steps()),
         "No. eta steps for particle gun")(
+        "random_seed",
+        boost::program_options::value<std::size_t>()->default_value(cfg.seed()),
+        "Seed for the random number generator")(
         "eta_range",
         boost::program_options::value<std::vector<scalar_t>>()->multitoken(),
         "Min, Max range of eta values for particle gun")(
@@ -45,14 +48,12 @@ void add_uniform_track_gen_options(
         "origin",
         boost::program_options::value<std::vector<scalar_t>>()->multitoken(),
         "Coordintates for particle gun origin position [mm]")(
-        "p_tot",
-        boost::program_options::value<scalar_t>()->default_value(
-            static_cast<scalar_t>(cfg.m_p_mag) / unit<scalar_t>::GeV),
-        "Total momentum of the test particle [GeV]")(
-        "p_T",
-        boost::program_options::value<scalar_t>()->default_value(
-            static_cast<scalar_t>(cfg.m_p_mag) / unit<scalar_t>::GeV),
-        "Transverse momentum of the test particle [GeV]");
+        "p_range",
+        boost::program_options::value<std::vector<scalar_t>>()->multitoken(),
+        "Total momentum [range] of the test particle [GeV]")(
+        "pT_range",
+        boost::program_options::value<std::vector<scalar_t>>()->multitoken(),
+        "Transverse momentum [range] of the test particle [GeV]");
 }
 
 /// Add options for detray event generation
@@ -63,6 +64,7 @@ void configure_uniform_track_gen_options(
 
     cfg.phi_steps(vm["phi_steps"].as<std::size_t>());
     cfg.eta_steps(vm["eta_steps"].as<std::size_t>());
+    cfg.seed(vm["random_seed"].as<std::size_t>());
     cfg.randomize_charge(vm.count("randomize_charge"));
 
     if (vm.count("eta_range")) {
@@ -84,15 +86,47 @@ void configure_uniform_track_gen_options(
                 "Particle gun origin needs three arguments");
         }
     }
-    if (!vm["p_T"].defaulted() && !vm["p_tot"].defaulted()) {
+    if (vm.count("pT_range") && vm.count("p_range")) {
         throw std::invalid_argument(
             "Transverse and total momentum cannot be specified at the same "
             "time");
     }
-    if (!vm["p_T"].defaulted()) {
-        cfg.p_T(vm["p_T"].as<scalar_t>() * unit<scalar_t>::GeV);
+    if (vm.count("pT_range")) {
+        const auto pt_range = vm["pT_range"].as<std::vector<scalar_t>>();
+
+        // Default
+        if (pt_range.empty()) {
+            cfg.p_T(static_cast<scalar_t>(cfg.m_p_mag) * unit<scalar_t>::GeV);
+        } else if (pt_range.size() == 1u) {
+            cfg.p_T(pt_range[0] * unit<scalar_t>::GeV);
+        } else if (pt_range.size() == 2u) {
+            std::cout << "WARNING: Momentum range not possible with uniform "
+                         "track generator: Using first value."
+                      << std::endl;
+            cfg.p_T(pt_range[0] * unit<scalar_t>::GeV);
+        } else {
+            throw std::invalid_argument(
+                "Wrong number of arguments for pT range: Need one argument or "
+                "range");
+        }
     } else {
-        cfg.p_tot(vm["p_tot"].as<scalar_t>() * unit<scalar_t>::GeV);
+        const auto p_range = vm["p_range"].as<std::vector<scalar_t>>();
+
+        // Default
+        if (p_range.empty()) {
+            cfg.p_tot(static_cast<scalar_t>(cfg.m_p_mag) * unit<scalar_t>::GeV);
+        } else if (p_range.size() == 1u) {
+            cfg.p_tot(p_range[0] * unit<scalar_t>::GeV);
+        } else if (p_range.size() == 2u) {
+            std::cout << "WARNING: Momentum range not possible with uniform "
+                         "track generator: Using first value."
+                      << std::endl;
+            cfg.p_tot(p_range[0] * unit<scalar_t>::GeV);
+        } else {
+            throw std::invalid_argument(
+                "Wrong number of arguments for p_tot range: Need one argument "
+                "or range");
+        }
     }
 }
 
@@ -107,6 +141,9 @@ void add_rnd_track_gen_options(
         boost::program_options::value<std::size_t>()->default_value(
             cfg.n_tracks()),
         "No. of tracks for particle gun")(
+        "random_seed",
+        boost::program_options::value<std::size_t>()->default_value(cfg.seed()),
+        "Seed for the random number generator")(
         "theta_range",
         boost::program_options::value<std::vector<scalar_t>>()->multitoken(),
         "Min, Max range of theta values for particle gun")(
@@ -117,14 +154,12 @@ void add_rnd_track_gen_options(
         "origin",
         boost::program_options::value<std::vector<scalar_t>>()->multitoken(),
         "Coordintates for particle gun origin position")(
-        "p_tot",
-        boost::program_options::value<scalar_t>()->default_value(
-            static_cast<scalar_t>(cfg.mom_range()[0]) / unit<scalar_t>::GeV),
-        "Total momentum of the test particle [GeV]")(
-        "p_T",
-        boost::program_options::value<scalar_t>()->default_value(
-            static_cast<scalar_t>(cfg.mom_range()[0]) / unit<scalar_t>::GeV),
-        "Transverse momentum of the test particle [GeV]");
+        "p_range",
+        boost::program_options::value<std::vector<scalar_t>>()->multitoken(),
+        "Total momentum [range] of the test particle [GeV]")(
+        "pT_range",
+        boost::program_options::value<std::vector<scalar_t>>()->multitoken(),
+        "Transverse momentum [range] of the test particle [GeV]");
 }
 
 /// Add options for detray event generation
@@ -134,6 +169,7 @@ void configure_rnd_track_gen_options(
     random_track_generator_config<scalar_t> &cfg) {
 
     cfg.n_tracks(vm["n_tracks"].as<std::size_t>());
+    cfg.seed(vm["random_seed"].as<std::size_t>());
     cfg.randomize_charge(vm.count("randomize_charge"));
 
     if (vm.count("eta_range") && vm.count("theta_range")) {
@@ -173,15 +209,43 @@ void configure_rnd_track_gen_options(
                 "Particle gun origin needs three arguments");
         }
     }
-    if (!vm["p_T"].defaulted() && !vm["p_tot"].defaulted()) {
+    if (vm.count("pT_range") && vm.count("p_range")) {
         throw std::invalid_argument(
             "Transverse and total momentum cannot be specified at the same "
             "time");
     }
-    if (!vm["p_T"].defaulted()) {
-        cfg.p_T(vm["p_T"].as<scalar_t>() * unit<scalar_t>::GeV);
+    if (vm.count("pT_range")) {
+        const auto pt_range = vm["pT_range"].as<std::vector<scalar_t>>();
+
+        // Default
+        if (pt_range.empty()) {
+            cfg.p_T(cfg.mom_range()[0] * unit<scalar_t>::GeV);
+        } else if (pt_range.size() == 1u) {
+            cfg.p_T(pt_range[0] * unit<scalar_t>::GeV);
+        } else if (pt_range.size() == 2u) {
+            cfg.pT_range(pt_range[0] * unit<scalar_t>::GeV,
+                         pt_range[1] * unit<scalar_t>::GeV);
+        } else {
+            throw std::invalid_argument(
+                "Wrong number of arguments for pT range: Need one argument or "
+                "range");
+        }
     } else {
-        cfg.p_tot(vm["p_tot"].as<scalar_t>() * unit<scalar_t>::GeV);
+        const auto p_range = vm["p_range"].as<std::vector<scalar_t>>();
+
+        // Default
+        if (p_range.empty()) {
+            cfg.p_tot(cfg.mom_range()[0] * unit<scalar_t>::GeV);
+        } else if (p_range.size() == 1u) {
+            cfg.p_tot(p_range[0] * unit<scalar_t>::GeV);
+        } else if (p_range.size() == 2u) {
+            cfg.mom_range(p_range[0] * unit<scalar_t>::GeV,
+                          p_range[1] * unit<scalar_t>::GeV);
+        } else {
+            throw std::invalid_argument(
+                "Wrong number of arguments for p_tot range: Need one argument "
+                "or range");
+        }
     }
 }
 
diff --git a/tests/tools/src/cpu/CMakeLists.txt b/tests/tools/src/cpu/CMakeLists.txt
index a6e3f2d5a..ea630ea83 100644
--- a/tests/tools/src/cpu/CMakeLists.txt
+++ b/tests/tools/src/cpu/CMakeLists.txt
@@ -32,7 +32,7 @@ detray_add_executable(generate_telescope_detector
 # Build the visualization executable.
 detray_add_executable(detector_display
                       "detector_display.cpp"
-                      LINK_LIBRARIES Boost::program_options detray::tools
+                      LINK_LIBRARIES Boost::program_options  detray::core_array detray::tools
                       detray::svgtools
 )
 
@@ -40,7 +40,7 @@ detray_add_executable(detector_display
 detray_add_executable(detector_validation
                       "detector_validation.cpp"
                       LINK_LIBRARIES GTest::gtest GTest::gtest_main
-                      Boost::program_options detray::tools detray::test_utils
+                      Boost::program_options detray::core_array detray::tools detray::test_utils
                       detray::svgtools
 )
 
@@ -48,6 +48,49 @@ detray_add_executable(detector_validation
 detray_add_executable(material_validation
                       "material_validation.cpp"
                       LINK_LIBRARIES GTest::gtest GTest::gtest_main
-                      Boost::program_options detray::tools detray::test_utils
+                      Boost::program_options detray::core_array detray::tools detray::test_utils
                       detray::svgtools
 )
+
+if(DETRAY_BUILD_BENCHMARKS)
+    # Look for openMP, which is used for the CPU propagation benchmark
+    find_package(OpenMP)
+
+    # Build the propagation benchmark executable.
+    macro(detray_add_propagation_benchmark algebra)
+        detray_add_executable(propagation_benchmark_${algebra}
+                            "propagation_benchmark.cpp"
+                            LINK_LIBRARIES Boost::program_options benchmark::benchmark benchmark::benchmark_main vecmem::core detray::core_${algebra} detray::benchmarks detray::benchmark_cpu detray::tools detray::detectors
+        )
+
+        target_compile_options(
+            detray_propagation_benchmark_${algebra}
+            PRIVATE "-march=native" "-ftree-vectorize"
+        )
+
+        if(OpenMP_CXX_FOUND)
+            target_link_libraries(
+                detray_propagation_benchmark_${algebra}
+                PRIVATE OpenMP::OpenMP_CXX
+            )
+        endif()
+    endmacro()
+
+    # Build the array benchmark.
+    detray_add_propagation_benchmark( array )
+
+    # Build the Eigen benchmark executable.
+    if(DETRAY_EIGEN_PLUGIN)
+        detray_add_propagation_benchmark( eigen )
+    endif()
+
+    # Build the SMatrix benchmark executable.
+    if(DETRAY_SMATRIX_PLUGIN)
+        detray_add_propagation_benchmark( smatrix )
+    endif()
+
+    # Build the Vc benchmark executable.
+    if(DETRAY_VC_AOS_PLUGIN)
+        detray_add_propagation_benchmark( vc_aos )
+    endif()
+endif()
diff --git a/tests/tools/src/cpu/propagation_benchmark.cpp b/tests/tools/src/cpu/propagation_benchmark.cpp
new file mode 100644
index 000000000..53468c068
--- /dev/null
+++ b/tests/tools/src/cpu/propagation_benchmark.cpp
@@ -0,0 +1,162 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/detectors/bfield.hpp"
+#include "detray/navigation/navigator.hpp"
+#include "detray/propagator/actor_chain.hpp"
+#include "detray/propagator/actors/aborters.hpp"
+#include "detray/propagator/actors/parameter_resetter.hpp"
+#include "detray/propagator/actors/parameter_transporter.hpp"
+#include "detray/propagator/actors/pointwise_material_interactor.hpp"
+#include "detray/propagator/rk_stepper.hpp"
+#include "detray/tracks/tracks.hpp"
+
+// Detray IO include(s)
+#include "detray/io/frontend/detector_reader.hpp"
+
+// Detray benchmark include(s)
+#include "detray/benchmarks/cpu/propagation_benchmark.hpp"
+
+// Detray test include(s).
+#include "detray/test/utils/simulation/event_generator/track_generators.hpp"
+#include "detray/test/utils/types.hpp"
+
+// Detray test include(s)
+#include "detray/options/detector_io_options.hpp"
+#include "detray/options/parse_options.hpp"
+#include "detray/options/propagation_options.hpp"
+#include "detray/options/track_generator_options.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// System include(s)
+#include <algorithm>
+#include <string>
+
+namespace po = boost::program_options;
+
+using namespace detray;
+
+int main(int argc, char** argv) {
+
+    // Use the most general type to be able to read in all detector files
+    using detector_t = detray::detector<test::default_metadata>;
+    using test_algebra = typename detector_t::algebra_type;
+    using scalar = dscalar<test_algebra>;
+    using vector3 = dvector3D<test_algebra>;
+    using free_track_parameters_t = free_track_parameters<test_algebra>;
+    using uniform_gen_t =
+        detail::random_numbers<scalar, std::uniform_real_distribution<scalar>>;
+    using track_generator_t =
+        random_track_generator<free_track_parameters_t, uniform_gen_t>;
+
+    using field_t = bfield::const_field_t<scalar>;
+    using stepper_t = rk_stepper<typename field_t::view_t, test_algebra>;
+    using empty_chain_t = actor_chain<>;
+    using default_chain =
+        actor_chain<dtuple, parameter_transporter<test_algebra>,
+                    pointwise_material_interactor<test_algebra>,
+                    parameter_resetter<test_algebra>>;
+
+    // Host memory resource
+    vecmem::host_memory_resource host_mr;
+
+    // Constant magnetic field
+    vector3 B{0.f, 0.f, 2.f * unit<scalar>::T};
+
+    // Number of tracks in the different benchmark cases
+    std::vector<int> n_tracks{8 * 8,     16 * 16,   32 * 32,  64 * 64,
+                              128 * 128, 256 * 256, 512 * 512};
+
+    //
+    // Configuration
+    //
+
+    // Specific options for this test
+    po::options_description desc("\ndetray propagation benchmark options");
+
+    std::vector<dindex> window;
+    desc.add_options()("context", po::value<dindex>(),
+                       "Number of the geometry context")(
+        "sort_tracks", "Sort track samples by theta angle");
+
+    // Configs to be filled
+    detray::io::detector_reader_config reader_cfg{};
+    track_generator_t::configuration trk_cfg{};
+    propagation::config prop_cfg{};
+    detray::benchmarks::benchmark_base::configuration bench_cfg{};
+
+    // Read options from commandline
+    po::variables_map vm = detray::options::parse_options(
+        desc, argc, argv, reader_cfg, trk_cfg, prop_cfg);
+
+    // General options
+    bool do_sort{(vm.count("sort_tracks") != 0)};
+
+    // The geometry context to be displayed
+    detector_t::geometry_context gctx;
+    if (vm.count("context")) {
+        gctx = detector_t::geometry_context{vm["context"].as<dindex>()};
+    }
+
+    //
+    // Prepare data
+    //
+
+    // Read the detector geometry
+    reader_cfg.do_check(true);
+
+    const auto [det, names] =
+        detray::io::read_detector<detector_t>(host_mr, reader_cfg);
+    const std::string& det_name = det.name(names);
+
+    // Generate the track samples
+    auto track_samples =
+        detray::benchmarks::generate_track_samples<track_generator_t>(
+            &host_mr, n_tracks, trk_cfg, do_sort);
+
+    // Create a constant b-field
+    auto bfield = bfield::create_const_field<scalar>(B);
+
+    // Build actor states
+    dtuple<> empty_state{};
+
+    parameter_transporter<test_algebra>::state transporter_state{};
+    pointwise_material_interactor<test_algebra>::state interactor_state{};
+    parameter_resetter<test_algebra>::state resetter_state{};
+
+    auto actor_states = detail::make_tuple<dtuple>(
+        transporter_state, interactor_state, resetter_state);
+
+    //
+    // Register benchmarks
+    //
+
+    // Number of warmup tracks
+    const int n_max_tracks{*std::ranges::max_element(n_tracks)};
+    bench_cfg.n_warmup(
+        static_cast<int>(std::ceil(0.1f * static_cast<float>(n_max_tracks))));
+
+    if (prop_cfg.stepping.do_covariance_transport) {
+        detray::benchmarks::register_benchmark<
+            detray::benchmarks::host_propagation_bm, stepper_t, default_chain>(
+            det_name + "_W_COV_TRANSPORT", bench_cfg, prop_cfg, det, bfield,
+            &actor_states, track_samples, n_tracks);
+    } else {
+        detray::benchmarks::register_benchmark<
+            detray::benchmarks::host_propagation_bm, stepper_t, empty_chain_t>(
+            det_name, bench_cfg, prop_cfg, det, bfield, &empty_state,
+            track_samples, n_tracks);
+    }
+
+    // Run benchmarks
+    ::benchmark::Initialize(&argc, argv);
+    ::benchmark::RunSpecifiedBenchmarks();
+    ::benchmark::Shutdown();
+}