diff --git a/device/cuda/include/traccc/cuda/gbts_seeding/gbts_seeding_algorithm.hpp b/device/cuda/include/traccc/cuda/gbts_seeding/gbts_seeding_algorithm.hpp
index 1e8903c8f2..05c1014dc7 100644
--- a/device/cuda/include/traccc/cuda/gbts_seeding/gbts_seeding_algorithm.hpp
+++ b/device/cuda/include/traccc/cuda/gbts_seeding/gbts_seeding_algorithm.hpp
@@ -47,7 +47,7 @@ class gbts_seeding_algorithm
     /// @param str The CUDA stream to perform the operations in
     ///
     gbts_seeding_algorithm(
-        const gbts_seedfinder_config& cfg, traccc::memory_resource& mr,
+        const gbts_seedfinder_config& cfg, const traccc::memory_resource& mr,
         vecmem::copy& copy, stream& str,
         std::unique_ptr<const Logger> logger = getDummyLogger().clone());
 
diff --git a/device/cuda/src/gbts_seeding/gbts_seeding_algorithm.cu b/device/cuda/src/gbts_seeding/gbts_seeding_algorithm.cu
index 3cf3696083..3a6a98e22f 100644
--- a/device/cuda/src/gbts_seeding/gbts_seeding_algorithm.cu
+++ b/device/cuda/src/gbts_seeding/gbts_seeding_algorithm.cu
@@ -115,7 +115,7 @@ struct gbts_ctx {
 };
 
 gbts_seeding_algorithm::gbts_seeding_algorithm(
-    const gbts_seedfinder_config& cfg, traccc::memory_resource& mr,
+    const gbts_seedfinder_config& cfg, const traccc::memory_resource& mr,
     vecmem::copy& copy, stream& str, std::unique_ptr<const Logger> logger)
     : messaging(logger->clone()),
       m_config(cfg),
@@ -282,7 +282,6 @@ gbts_seeding_algorithm::output_type gbts_seeding_algorithm::operator()(
         nNodesPerBlock, ctx.nNodes, m_config.n_phi_bins);
 
     cudaStreamSynchronize(stream);
-
     error = cudaGetLastError();
 
     if (error != cudaSuccess) {
diff --git a/examples/options/CMakeLists.txt b/examples/options/CMakeLists.txt
index b57795b2c1..42466e4a8c 100644
--- a/examples/options/CMakeLists.txt
+++ b/examples/options/CMakeLists.txt
@@ -27,6 +27,7 @@ traccc_add_library( traccc_options options TYPE SHARED
   "include/traccc/options/track_propagation.hpp"
   "include/traccc/options/track_resolution.hpp"
   "include/traccc/options/track_seeding.hpp"
+  "include/traccc/options/track_gbts_seeding.hpp"
   # source files
   "src/details/interface.cpp"
   "src/accelerator.cpp"
@@ -49,6 +50,7 @@ traccc_add_library( traccc_options options TYPE SHARED
   "src/track_propagation.cpp"
   "src/track_resolution.cpp"
   "src/track_seeding.cpp"
+  "src/track_gbts_seeding.cpp"
   "src/truth_finding.cpp"
   )
 target_link_libraries( traccc_options
diff --git a/examples/options/include/traccc/options/track_gbts_seeding.hpp b/examples/options/include/traccc/options/track_gbts_seeding.hpp
new file mode 100644
index 0000000000..ebdad02928
--- /dev/null
+++ b/examples/options/include/traccc/options/track_gbts_seeding.hpp
@@ -0,0 +1,47 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022-2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "traccc/gbts_seeding/gbts_seeding_config.hpp"
+#include "traccc/options/details/interface.hpp"
+
+// System include(s).
+#include <cstddef>
+
+namespace traccc::opts {
+
+/// Option(s) for multi-threaded code execution
+class track_gbts_seeding : public interface {
+
+    public:
+    /// @name Options
+    /// @{
+
+    bool useGBTS = false;
+    std::string config_dir = "DEFAULT";
+
+    /// @}
+    // config info from file
+    std::vector<std::pair<uint64_t, short>> barcodeBinning;
+    std::vector<std::pair<int, std::vector<int>>> binTables;
+    traccc::device::gbts_layerInfo layerInfo;
+
+    /// Constructor
+    track_gbts_seeding();
+
+    /// Read/process the command line options
+    ///
+    /// @param vm The command line options to interpret/read
+    ///
+    void read(const boost::program_options::variables_map& vm) override;
+
+    std::unique_ptr<configuration_printable> as_printable() const override;
+};
+
+}  // namespace traccc::opts
diff --git a/examples/options/src/track_gbts_seeding.cpp b/examples/options/src/track_gbts_seeding.cpp
new file mode 100644
index 0000000000..fd655df081
--- /dev/null
+++ b/examples/options/src/track_gbts_seeding.cpp
@@ -0,0 +1,95 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022-2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Local include(s).
+#include "traccc/options/track_gbts_seeding.hpp"
+
+#include "traccc/examples/utils/printable.hpp"
+
+// System include(s).
+#include <filesystem>
+#include <fstream>
+#include <stdexcept>
+
+namespace traccc::opts {
+
+track_gbts_seeding::track_gbts_seeding() : interface("GBTS Options") {
+    m_desc.add_options()("useGBTS",
+                         boost::program_options::bool_switch(&useGBTS),
+                         "use gbts algorithm");
+
+    m_desc.add_options()(
+        "gbts_config_dir",
+        boost::program_options::value(&config_dir)->default_value(config_dir),
+        "directory for gbts config files");
+}
+
+void track_gbts_seeding::read(const boost::program_options::variables_map &) {
+    // fill config
+    if (!useGBTS) {
+        return;
+    }
+    std::ifstream barcodeBinningFile(
+        std::filesystem::path(config_dir + "/barcodeBinning.txt"));
+
+    unsigned int nBarcodes = 0;
+    barcodeBinningFile >> nBarcodes;
+    barcodeBinning.reserve(nBarcodes);
+
+    std::pair<uint64_t, short> barcodeLayerPair;
+    for (; nBarcodes > 0u; --nBarcodes) {
+        barcodeBinningFile >> barcodeLayerPair.first;
+        barcodeBinningFile >> barcodeLayerPair.second;
+
+        barcodeBinning.push_back(barcodeLayerPair);
+    }
+
+    std::ifstream binTablesFile(
+        std::filesystem::path(config_dir + "/binTables.txt"));
+
+    unsigned int nBinPairs = 0;
+    binTablesFile >> nBinPairs;
+    binTables.reserve(nBinPairs);
+    int bin1 = 0;
+    std::vector<int> bin2 = {0};
+    for (; nBinPairs > 0; --nBinPairs) {
+        binTablesFile >> bin1;
+        binTablesFile >> bin2[0];
+        binTables.emplace_back(bin1, bin2);
+    }
+
+    std::ifstream layerInfoFile(
+        std::filesystem::path(config_dir + "/layerInfo.txt"));
+
+    unsigned int nLayers = 0;
+    layerInfoFile >> nLayers;
+    layerInfo.reserve(nLayers);
+    int type = 0;
+    std::array<int, 2> info = {0, 0};
+    std::array<float, 2> geo = {0, 0};
+    for (; nLayers > 0u; --nLayers) {
+        layerInfoFile >> type;
+        layerInfoFile >> info[0] >> info[1];
+        layerInfoFile >> geo[0] >> geo[1];
+        layerInfo.addLayer(static_cast<char>(type), info[0], info[1], geo[0],
+                           geo[1]);
+    }
+}
+
+std::unique_ptr<configuration_printable> track_gbts_seeding::as_printable()
+    const {
+    auto cat = std::make_unique<configuration_category>(m_description);
+
+    cat->add_child(std::make_unique<configuration_kv_pair>(
+        "using gbts algorithm ", std::to_string(useGBTS)));
+    cat->add_child(std::make_unique<configuration_kv_pair>(
+        "gbts config directory ", config_dir));
+
+    return cat;
+}
+
+}  // namespace traccc::opts
diff --git a/examples/run/alpaka/full_chain_algorithm.cpp b/examples/run/alpaka/full_chain_algorithm.cpp
index 839f93e234..7c4c967521 100644
--- a/examples/run/alpaka/full_chain_algorithm.cpp
+++ b/examples/run/alpaka/full_chain_algorithm.cpp
@@ -23,13 +23,14 @@ full_chain_algorithm::full_chain_algorithm(
     const seedfinder_config& finder_config,
     const spacepoint_grid_config& grid_config,
     const seedfilter_config& filter_config,
+    const gbts_seedfinder_config& gbts_config,
     const track_params_estimation_config& track_params_estimation_config,
     const finding_algorithm::config_type& finding_config,
     const fitting_algorithm::config_type& fitting_config,
     const detector_design_description::host& det_descr,
     const detector_conditions_description::host& det_cond,
     const magnetic_field& field, host_detector* detector,
-    std::unique_ptr<const traccc::Logger> logger)
+    std::unique_ptr<const traccc::Logger> logger, bool useGBTS)
     : messaging(logger->clone()),
       m_queue(),
       m_vecmem_objects(m_queue),
@@ -90,10 +91,17 @@ full_chain_algorithm::full_chain_algorithm(
       m_finder_config(finder_config),
       m_grid_config(grid_config),
       m_filter_config(filter_config),
+      m_gbts_config(gbts_config),
       m_track_params_estimation_config(track_params_estimation_config),
       m_finding_config(finding_config),
-      m_fitting_config(fitting_config) {
+      m_fitting_config(fitting_config),
+      usingGBTS(useGBTS) {
 
+    if (usingGBTS) {
+        std::cout << "GBTS not implemented for alpaka, this will run with "
+                     "triplet seeding"
+                  << std::endl;
+    }
     std::cout << traccc::alpaka::get_device_info() << std::endl;
 
     // Copy the detector (description) to the device.
@@ -172,9 +180,11 @@ full_chain_algorithm::full_chain_algorithm(const full_chain_algorithm& parent)
       m_finder_config(parent.m_finder_config),
       m_grid_config(parent.m_grid_config),
       m_filter_config(parent.m_filter_config),
+      m_gbts_config(parent.m_gbts_config),
       m_track_params_estimation_config(parent.m_track_params_estimation_config),
       m_finding_config(parent.m_finding_config),
-      m_fitting_config(parent.m_fitting_config) {
+      m_fitting_config(parent.m_fitting_config),
+      usingGBTS(parent.usingGBTS) {
 
     // Copy the detector (description) to the device.
     m_vecmem_objects
diff --git a/examples/run/alpaka/full_chain_algorithm.hpp b/examples/run/alpaka/full_chain_algorithm.hpp
index cca056989c..90de44c324 100644
--- a/examples/run/alpaka/full_chain_algorithm.hpp
+++ b/examples/run/alpaka/full_chain_algorithm.hpp
@@ -31,6 +31,8 @@
 #include "traccc/utils/algorithm.hpp"
 #include "traccc/utils/messaging.hpp"
 #include "traccc/utils/propagation.hpp"
+// GBTS include for placeholder input (not implemented)
+#include "traccc/gbts_seeding/gbts_seeding_config.hpp"
 
 // VecMem include(s).
 #include <vecmem/containers/vector.hpp>
@@ -79,13 +81,14 @@ class full_chain_algorithm
         const seedfinder_config& finder_config,
         const spacepoint_grid_config& grid_config,
         const seedfilter_config& filter_config,
+        const gbts_seedfinder_config& gbts_config,
         const track_params_estimation_config& track_params_estimation_config,
         const finding_algorithm::config_type& finding_config,
         const fitting_algorithm::config_type& fitting_config,
         const detector_design_description::host& det_descr,
         const detector_conditions_description::host& det_cond,
         const magnetic_field& field, host_detector* detector,
-        std::unique_ptr<const traccc::Logger> logger);
+        std::unique_ptr<const traccc::Logger> logger, bool useGBTS = false);
 
     /// Copy constructor
     ///
@@ -181,13 +184,18 @@ class full_chain_algorithm
     spacepoint_grid_config m_grid_config;
     /// Configuration for the seed filtering
     seedfilter_config m_filter_config;
+    /// placeholder GBTS config
+    [[maybe_unused]] gbts_seedfinder_config m_gbts_config;
     /// Configuration for track parameter estimation
     track_params_estimation_config m_track_params_estimation_config;
+
     /// Configuration for the track finding
     finding_algorithm::config_type m_finding_config;
     /// Configuration for the track fitting
     fitting_algorithm::config_type m_fitting_config;
 
+    bool usingGBTS;
+
     /// @}
 
 };  // class full_chain_algorithm
diff --git a/examples/run/common/throughput_mt.ipp b/examples/run/common/throughput_mt.ipp
index 7052bde74b..d4518dacd9 100644
--- a/examples/run/common/throughput_mt.ipp
+++ b/examples/run/common/throughput_mt.ipp
@@ -26,6 +26,7 @@
 #include "traccc/options/throughput.hpp"
 #include "traccc/options/track_finding.hpp"
 #include "traccc/options/track_fitting.hpp"
+#include "traccc/options/track_gbts_seeding.hpp"
 #include "traccc/options/track_propagation.hpp"
 #include "traccc/options/track_seeding.hpp"
 
@@ -77,6 +78,7 @@ int throughput_mt(std::string_view description, int argc, char* argv[]) {
     opts::input_data input_opts;
     opts::clusterization clusterization_opts;
     opts::track_seeding seeding_opts;
+    opts::track_gbts_seeding seeding_gbts_opts;
     opts::track_finding finding_opts;
     opts::track_propagation propagation_opts;
     opts::track_fitting fitting_opts;
@@ -86,8 +88,8 @@ int throughput_mt(std::string_view description, int argc, char* argv[]) {
     opts::program_options program_opts{
         description,
         {detector_opts, bfield_opts, input_opts, clusterization_opts,
-         seeding_opts, finding_opts, propagation_opts, fitting_opts,
-         throughput_opts, threading_opts, logging_opts},
+         seeding_opts, seeding_gbts_opts, finding_opts, propagation_opts,
+         fitting_opts, throughput_opts, threading_opts, logging_opts},
         argc,
         argv,
         prelogger->cloneWithSuffix("Options")};
@@ -147,10 +149,23 @@ int throughput_mt(std::string_view description, int argc, char* argv[]) {
     // Algorithm configuration(s).
     typename FULL_CHAIN_ALG::clustering_algorithm::config_type clustering_cfg(
         clusterization_opts);
+
     const traccc::seedfinder_config seedfinder_config(seeding_opts);
     const traccc::seedfilter_config seedfilter_config(seeding_opts);
     const traccc::spacepoint_grid_config spacepoint_grid_config(seeding_opts);
     const traccc::track_params_estimation_config track_params_estimation_config;
+
+    traccc::gbts_seedfinder_config gbts_config;
+    if (seeding_gbts_opts.useGBTS) {
+        if (!gbts_config.setLinkingScheme(
+                seeding_gbts_opts.binTables, seeding_gbts_opts.layerInfo,
+                seeding_gbts_opts.barcodeBinning, 900.0f,
+                prelogger->clone("GBTSconfig"))) {
+            TRACCC_ERROR("failure in setting gbts linking scheme");
+            return -1;
+        }
+    }
+
     detray::propagation::config propagation_config(propagation_opts);
     typename FULL_CHAIN_ALG::finding_algorithm::config_type finding_cfg(
         finding_opts);
@@ -165,10 +180,10 @@ int throughput_mt(std::string_view description, int argc, char* argv[]) {
     algs.reserve(threading_opts.threads + 1);
     for (std::size_t i = 0; i < threading_opts.threads + 1; ++i) {
         algs.push_back({host_mr, clustering_cfg, seedfinder_config,
-                        spacepoint_grid_config, seedfilter_config,
+                        spacepoint_grid_config, seedfilter_config, gbts_config,
                         track_params_estimation_config, finding_cfg,
                         fitting_cfg, det_descr, det_cond, field, &detector,
-                        logger().clone()});
+                        logger().clone(), seeding_gbts_opts.useGBTS});
     }
 
     // Set up a lambda that calls the correct function on the algorithms.
diff --git a/examples/run/common/throughput_st.ipp b/examples/run/common/throughput_st.ipp
index ef69214752..02b43742c4 100644
--- a/examples/run/common/throughput_st.ipp
+++ b/examples/run/common/throughput_st.ipp
@@ -25,6 +25,7 @@
 #include "traccc/options/throughput.hpp"
 #include "traccc/options/track_finding.hpp"
 #include "traccc/options/track_fitting.hpp"
+#include "traccc/options/track_gbts_seeding.hpp"
 #include "traccc/options/track_propagation.hpp"
 #include "traccc/options/track_seeding.hpp"
 
@@ -131,7 +132,7 @@ int throughput_st(std::string_view description, int argc, char* argv[]) {
     const traccc::seedfinder_config seedfinder_config(seeding_opts);
     const traccc::seedfilter_config seedfilter_config(seeding_opts);
     const traccc::spacepoint_grid_config spacepoint_grid_config(seeding_opts);
-
+    traccc::gbts_seedfinder_config gbts_config;
     const traccc::track_params_estimation_config track_params_estimation_config;
 
     typename FULL_CHAIN_ALG::finding_algorithm::config_type finding_cfg(
@@ -145,8 +146,8 @@ int throughput_st(std::string_view description, int argc, char* argv[]) {
     // Set up the full-chain algorithm.
     std::unique_ptr<FULL_CHAIN_ALG> alg = std::make_unique<FULL_CHAIN_ALG>(
         host_mr, clustering_cfg, seedfinder_config, spacepoint_grid_config,
-        seedfilter_config, track_params_estimation_config, finding_cfg,
-        fitting_cfg, det_descr, det_cond, field, &detector,
+        seedfilter_config, gbts_config, track_params_estimation_config,
+        finding_cfg, fitting_cfg, det_descr, det_cond, field, &detector,
         logger().clone("FullChainAlg"));
 
     // Seed the random number generator.
diff --git a/examples/run/cpu/full_chain_algorithm.cpp b/examples/run/cpu/full_chain_algorithm.cpp
index 3ab1f4573a..960683865b 100644
--- a/examples/run/cpu/full_chain_algorithm.cpp
+++ b/examples/run/cpu/full_chain_algorithm.cpp
@@ -15,13 +15,14 @@ full_chain_algorithm::full_chain_algorithm(
     const seedfinder_config& finder_config,
     const spacepoint_grid_config& grid_config,
     const seedfilter_config& filter_config,
+    const gbts_seedfinder_config& gbts_config,
     const track_params_estimation_config& track_params_estimation_config,
     const finding_algorithm::config_type& finding_config,
     const fitting_algorithm::config_type& fitting_config,
     const detector_design_description::host& det_descr,
     const detector_conditions_description::host& det_cond,
     const magnetic_field& field, const host_detector* detector,
-    std::unique_ptr<const traccc::Logger> logger)
+    std::unique_ptr<const traccc::Logger> logger, const bool useGBTS)
     : messaging(logger->clone()),
       m_mr(mr),
       m_copy{std::make_unique<vecmem::copy>()},
@@ -42,9 +43,18 @@ full_chain_algorithm::full_chain_algorithm(
       m_finder_config(finder_config),
       m_grid_config(grid_config),
       m_filter_config(filter_config),
+      m_gbts_config(gbts_config),
       m_track_params_estimation_config(track_params_estimation_config),
       m_finding_config(finding_config),
-      m_fitting_config(fitting_config) {}
+      m_fitting_config(fitting_config),
+      usingGBTS(useGBTS) {
+
+    if (usingGBTS) {
+        std::cout << "GBTS not implemented for CPU, this will run with triplet "
+                     "seeding"
+                  << std::endl;
+    }
+}
 
 full_chain_algorithm::output_type full_chain_algorithm::operator()(
     const edm::silicon_cell_collection::host& cells) const {
diff --git a/examples/run/cpu/full_chain_algorithm.hpp b/examples/run/cpu/full_chain_algorithm.hpp
index 89c5ca1cfe..d203376b19 100644
--- a/examples/run/cpu/full_chain_algorithm.hpp
+++ b/examples/run/cpu/full_chain_algorithm.hpp
@@ -25,6 +25,8 @@
 #include "traccc/utils/algorithm.hpp"
 #include "traccc/utils/messaging.hpp"
 #include "traccc/utils/propagation.hpp"
+// GBTS include for dummy input (not implemented)
+#include "traccc/gbts_seeding/gbts_seeding_config.hpp"
 
 // VecMem include(s).
 #include <vecmem/memory/memory_resource.hpp>
@@ -75,13 +77,15 @@ class full_chain_algorithm
         const seedfinder_config& finder_config,
         const spacepoint_grid_config& grid_config,
         const seedfilter_config& filter_config,
+        const gbts_seedfinder_config& gbts_config,
         const track_params_estimation_config& track_params_estimation_config,
         const finding_algorithm::config_type& finding_config,
         const fitting_algorithm::config_type& fitting_config,
         const detector_design_description::host& det_descr,
         const detector_conditions_description::host& det_cond,
         const magnetic_field& field, const host_detector* detector,
-        std::unique_ptr<const traccc::Logger> logger);
+        std::unique_ptr<const traccc::Logger> logger,
+        const bool useGBTS = false);
 
     /// Reconstruct track parameters in the entire detector
     ///
@@ -144,7 +148,8 @@ class full_chain_algorithm
     spacepoint_grid_config m_grid_config;
     /// Configuration for the seed filtering
     seedfilter_config m_filter_config;
-
+    /// placeholder GBTS config
+    [[maybe_unused]] gbts_seedfinder_config m_gbts_config;
     /// Configuration for track parameter estimation
     track_params_estimation_config m_track_params_estimation_config;
 
@@ -153,6 +158,8 @@ class full_chain_algorithm
     /// Configuration for the track fitting
     fitting_algorithm::config_type m_fitting_config;
 
+    const bool usingGBTS;
+
     /// @}
 };  // class full_chain_algorithm
 
diff --git a/examples/run/cuda/full_chain_algorithm.cpp b/examples/run/cuda/full_chain_algorithm.cpp
index 26962a86d1..a3e74233d9 100644
--- a/examples/run/cuda/full_chain_algorithm.cpp
+++ b/examples/run/cuda/full_chain_algorithm.cpp
@@ -37,13 +37,14 @@ full_chain_algorithm::full_chain_algorithm(
     const seedfinder_config& finder_config,
     const spacepoint_grid_config& grid_config,
     const seedfilter_config& filter_config,
+    const gbts_seedfinder_config& gbts_config,
     const track_params_estimation_config& track_params_estimation_config,
     const finding_algorithm::config_type& finding_config,
     const fitting_algorithm::config_type& fitting_config,
     const detector_design_description::host& det_descr,
     const detector_conditions_description::host& det_cond,
     const magnetic_field& field, host_detector* detector,
-    std::unique_ptr<const traccc::Logger> logger)
+    std::unique_ptr<const traccc::Logger> logger, bool useGBTS)
     : messaging(logger->clone()),
       m_host_mr(host_mr),
       m_pinned_host_mr(),
@@ -88,6 +89,9 @@ full_chain_algorithm::full_chain_algorithm(
       m_seeding(finder_config, grid_config, filter_config,
                 {m_cached_device_mr, &m_cached_pinned_host_mr}, m_copy,
                 m_stream, logger->cloneWithSuffix("SeedingAlg")),
+      m_gbts_seeding(gbts_config,
+                     {m_cached_device_mr, &m_cached_pinned_host_mr}, m_copy,
+                     m_stream, logger->cloneWithSuffix("GbtsAlg")),
       m_track_parameter_estimation(
           track_params_estimation_config,
           {m_cached_device_mr, &m_cached_pinned_host_mr}, m_copy, m_stream,
@@ -100,9 +104,11 @@ full_chain_algorithm::full_chain_algorithm(
       m_finder_config(finder_config),
       m_grid_config(grid_config),
       m_filter_config(filter_config),
+      m_gbts_config(gbts_config),
       m_track_params_estimation_config(track_params_estimation_config),
       m_finding_config(finding_config),
-      m_fitting_config(fitting_config) {
+      m_fitting_config(fitting_config),
+      usingGBTS(useGBTS) {
 
     // Tell the user what device is being used.
     int device = 0;
@@ -170,6 +176,9 @@ full_chain_algorithm::full_chain_algorithm(const full_chain_algorithm& parent)
                 parent.m_filter_config,
                 {m_cached_device_mr, &m_cached_pinned_host_mr}, m_copy,
                 m_stream, parent.logger().cloneWithSuffix("SeedingAlg")),
+      m_gbts_seeding(parent.m_gbts_config,
+                     {m_cached_device_mr, &m_cached_pinned_host_mr}, m_copy,
+                     m_stream, parent.logger().cloneWithSuffix("GbtsAlg")),
       m_track_parameter_estimation(
           parent.m_track_params_estimation_config,
           {m_cached_device_mr, &m_cached_pinned_host_mr}, m_copy, m_stream,
@@ -184,9 +193,11 @@ full_chain_algorithm::full_chain_algorithm(const full_chain_algorithm& parent)
       m_finder_config(parent.m_finder_config),
       m_grid_config(parent.m_grid_config),
       m_filter_config(parent.m_filter_config),
+      m_gbts_config(parent.m_gbts_config),
       m_track_params_estimation_config(parent.m_track_params_estimation_config),
       m_finding_config(parent.m_finding_config),
-      m_fitting_config(parent.m_fitting_config) {
+      m_fitting_config(parent.m_fitting_config),
+      usingGBTS(parent.usingGBTS) {
 
     m_copy.setup(m_device_det_descr)->wait();
     m_copy(vecmem::get_data(m_det_descr.get()), m_device_det_descr)->wait();
@@ -218,9 +229,16 @@ full_chain_algorithm::output_type full_chain_algorithm::operator()(
         // Run the seed-finding (asynchronously).
         const spacepoint_formation_algorithm::output_type spacepoints =
             m_spacepoint_formation(m_device_detector, measurements);
+
+        triplet_seeding_algorithm::output_type seeds;
+        if (usingGBTS) {
+            seeds = m_gbts_seeding(spacepoints, measurements);
+        } else {
+            seeds = m_seeding(spacepoints);
+        }
         const seed_parameter_estimation_algorithm::output_type track_params =
             m_track_parameter_estimation(m_field, measurements, spacepoints,
-                                         m_seeding(spacepoints));
+                                         seeds);
 
         // Run the track finding (asynchronously).
         const finding_algorithm::output_type track_candidates =
@@ -270,9 +288,16 @@ bound_track_parameters_collection_types::host full_chain_algorithm::seeding(
         // Run the seed-finding (asynchronously).
         const spacepoint_formation_algorithm::output_type spacepoints =
             m_spacepoint_formation(m_device_detector, measurements);
+
+        triplet_seeding_algorithm::output_type seeds;
+        if (usingGBTS) {
+            seeds = m_gbts_seeding(spacepoints, measurements);
+        } else {
+            seeds = m_seeding(spacepoints);
+        }
         const seed_parameter_estimation_algorithm::output_type track_params =
             m_track_parameter_estimation(m_field, measurements, spacepoints,
-                                         m_seeding(spacepoints));
+                                         seeds);
 
         // Copy a limited amount of result data back to the host.
         const auto host_seeds = m_copy.to(track_params, m_cached_pinned_host_mr,
diff --git a/examples/run/cuda/full_chain_algorithm.hpp b/examples/run/cuda/full_chain_algorithm.hpp
index ba7887d3bb..663da07eb7 100644
--- a/examples/run/cuda/full_chain_algorithm.hpp
+++ b/examples/run/cuda/full_chain_algorithm.hpp
@@ -13,6 +13,7 @@
 #include "traccc/cuda/clusterization/measurement_sorting_algorithm.hpp"
 #include "traccc/cuda/finding/combinatorial_kalman_filter_algorithm.hpp"
 #include "traccc/cuda/fitting/kalman_fitting_algorithm.hpp"
+#include "traccc/cuda/gbts_seeding/gbts_seeding_algorithm.hpp"
 #include "traccc/cuda/seeding/seed_parameter_estimation_algorithm.hpp"
 #include "traccc/cuda/seeding/silicon_pixel_spacepoint_formation_algorithm.hpp"
 #include "traccc/cuda/seeding/triplet_seeding_algorithm.hpp"
@@ -77,13 +78,14 @@ class full_chain_algorithm
         const seedfinder_config& finder_config,
         const spacepoint_grid_config& grid_config,
         const seedfilter_config& filter_config,
+        const gbts_seedfinder_config& gbts_config,
         const track_params_estimation_config& track_params_estimation_config,
         const finding_algorithm::config_type& finding_config,
         const fitting_algorithm::config_type& fitting_config,
         const detector_design_description::host& det_descr,
         const detector_conditions_description::host& det_cond,
         const magnetic_field& field, host_detector* detector,
-        std::unique_ptr<const traccc::Logger> logger);
+        std::unique_ptr<const traccc::Logger> logger, bool useGBTS = false);
 
     /// Copy constructor
     ///
@@ -158,6 +160,8 @@ class full_chain_algorithm
     spacepoint_formation_algorithm m_spacepoint_formation;
     /// Seeding algorithm
     triplet_seeding_algorithm m_seeding;
+    /// Seeding with GBTS algorithm
+    gbts_seeding_algorithm m_gbts_seeding;
     /// Track parameter estimation algorithm
     seed_parameter_estimation_algorithm m_track_parameter_estimation;
 
@@ -179,6 +183,8 @@ class full_chain_algorithm
     spacepoint_grid_config m_grid_config;
     /// Configuration for the seed filtering
     seedfilter_config m_filter_config;
+    // Configuration for GBTS seeding
+    gbts_seedfinder_config m_gbts_config;
 
     /// Configuration for track parameter estimation
     track_params_estimation_config m_track_params_estimation_config;
@@ -188,6 +194,8 @@ class full_chain_algorithm
     /// Configuration for the track fitting
     fitting_algorithm::config_type m_fitting_config;
 
+    bool usingGBTS;
+
     /// @}
 };  // class full_chain_algorithm
 
diff --git a/examples/run/sycl/full_chain_algorithm.cpp b/examples/run/sycl/full_chain_algorithm.cpp
index 516e77e42b..b2936cee33 100644
--- a/examples/run/sycl/full_chain_algorithm.cpp
+++ b/examples/run/sycl/full_chain_algorithm.cpp
@@ -29,13 +29,14 @@ full_chain_algorithm::full_chain_algorithm(
     const seedfinder_config& finder_config,
     const spacepoint_grid_config& grid_config,
     const seedfilter_config& filter_config,
+    const gbts_seedfinder_config& gbts_config,
     const track_params_estimation_config& track_params_estimation_config,
     const finding_algorithm::config_type& finding_config,
     const fitting_algorithm::config_type& fitting_config,
     const detector_design_description::host& det_descr,
     const detector_conditions_description::host& det_cond,
     const magnetic_field& field, host_detector* detector,
-    std::unique_ptr<const traccc::Logger> log)
+    std::unique_ptr<const traccc::Logger> log, bool useGBTS)
     : messaging(log->clone()),
       m_data(std::make_unique<details::full_chain_algorithm_data>()),
       m_host_mr(host_mr),
@@ -110,10 +111,17 @@ full_chain_algorithm::full_chain_algorithm(
       m_finder_config(finder_config),
       m_grid_config(grid_config),
       m_filter_config(filter_config),
+      m_gbts_config(gbts_config),
       m_track_params_estimation_config(track_params_estimation_config),
       m_finding_config(finding_config),
-      m_fitting_config(fitting_config) {
+      m_fitting_config(fitting_config),
+      usingGBTS(useGBTS) {
 
+    if (usingGBTS) {
+        TRACCC_ERROR(
+            "GBTS not implemented for sycl, this will run with "
+            "triplet seeding");
+    }
     // Tell the user what device is being used.
     TRACCC_INFO("Using SYCL device: " << m_data->m_queue.device_name());
 
@@ -201,9 +209,11 @@ full_chain_algorithm::full_chain_algorithm(const full_chain_algorithm& parent)
       m_finder_config(parent.m_finder_config),
       m_grid_config(parent.m_grid_config),
       m_filter_config(parent.m_filter_config),
+      m_gbts_config(parent.m_gbts_config),
       m_track_params_estimation_config(parent.m_track_params_estimation_config),
       m_finding_config(parent.m_finding_config),
-      m_fitting_config(parent.m_fitting_config) {
+      m_fitting_config(parent.m_fitting_config),
+      usingGBTS(parent.usingGBTS) {
 
     // Copy the detector (description) to the device.
     m_copy(vecmem::get_data(m_det_descr.get()), m_device_det_descr)->wait();
diff --git a/examples/run/sycl/full_chain_algorithm.hpp b/examples/run/sycl/full_chain_algorithm.hpp
index 4840ab7ae2..0f3ac369f9 100644
--- a/examples/run/sycl/full_chain_algorithm.hpp
+++ b/examples/run/sycl/full_chain_algorithm.hpp
@@ -24,6 +24,8 @@
 #include "traccc/sycl/seeding/triplet_seeding_algorithm.hpp"
 #include "traccc/utils/algorithm.hpp"
 #include "traccc/utils/propagation.hpp"
+// GBTS include for placeholder input (not implemented)
+#include "traccc/gbts_seeding/gbts_seeding_config.hpp"
 
 // VecMem include(s).
 #include <vecmem/memory/binary_page_memory_resource.hpp>
@@ -78,13 +80,14 @@ class full_chain_algorithm
         const seedfinder_config& finder_config,
         const spacepoint_grid_config& grid_config,
         const seedfilter_config& filter_config,
+        const gbts_seedfinder_config& gbts_config,
         const track_params_estimation_config& track_params_estimation_config,
         const finding_algorithm::config_type& finding_config,
         const fitting_algorithm::config_type& fitting_config,
         const detector_design_description::host& det_descr,
         const detector_conditions_description::host& det_cond,
         const magnetic_field& field, host_detector* detector,
-        std::unique_ptr<const traccc::Logger> logger);
+        std::unique_ptr<const traccc::Logger> logger, bool useGBTS = false);
 
     /// Copy constructor
     ///
@@ -182,13 +185,18 @@ class full_chain_algorithm
     spacepoint_grid_config m_grid_config;
     /// Configuration for the seed filtering
     seedfilter_config m_filter_config;
+    /// placeholder GBTS config
+    [[maybe_unused]] gbts_seedfinder_config m_gbts_config;
     /// Configuration for track parameter estimation
     track_params_estimation_config m_track_params_estimation_config;
+
     /// Configuration for the track finding
     finding_algorithm::config_type m_finding_config;
     /// Configuration for the track fitting
     fitting_algorithm::config_type m_fitting_config;
 
+    bool usingGBTS;
+
     /// @}
 };  // class full_chain_algorithm
 
diff --git a/extras/traccc_itk_throughput_mt_profiler.sh b/extras/traccc_itk_throughput_mt_profiler.sh
index 355123181b..eb382a0301 100755
--- a/extras/traccc_itk_throughput_mt_profiler.sh
+++ b/extras/traccc_itk_throughput_mt_profiler.sh
@@ -29,7 +29,7 @@ usage() {
    echo "  -r <repetitions>     The number of repetitions in the test"
    echo "  -e <eventMultiplier> Multiplier for the number of events per thread"
    echo "  -c <csvFile>         Name of the output CSV file"
-   echo "  -y <throughputType>  Type of throughput test to run (traccc/g200/g100)"
+   echo "  -y <throughputType>  Type of throughput test to run (traccc/g200/g100, or with GBTS, g230/g130)"
    echo "  -h                   Print this help"
    echo ""
 }
@@ -43,7 +43,7 @@ TRACCC_THREAD_STEP=${TRACCC_THREAD_STEP:-1}
 TRACCC_REPETITIONS=${TRACCC_REPETITIONS:-5}
 TRACCC_CSV_FILE=${TRACCC_CSV_FILE:-"output.csv"}
 TRACCC_THROUGPUT_TYPE=${TRACCC_THROUGPUT_TYPE:-"traccc"}
-while getopts ":x:i:m:t:r:c:y:h" opt; do
+while getopts ":x:i:m:t:s:r:c:y:h" opt; do
    case $opt in
       x)
          TRACCC_EXECUTABLE=$OPTARG
@@ -146,6 +146,12 @@ if [[ "${TRACCC_THROUGPUT_TYPE}" == "g200" ]]; then
    TRACCC_CUTS=${G200_CUTS[@]}
 elif [[ "${TRACCC_THROUGPUT_TYPE}" == "g100" ]]; then
    TRACCC_CUTS=${G100_CUTS[@]}
+elif [[ "${TRACCC_THROUGPUT_TYPE}" == "g230" ]]; then
+   TRACCC_CUTS=${G200_CUTS[@]}
+   TRACCC_CUTS+=(--useGBTS --gbts_config_dir="${TRACCC_INPUT_DIR}")
+elif [[ "${TRACCC_THROUGPUT_TYPE}" == "g130" ]]; then
+   TRACCC_CUTS=${G100_CUTS[@]}
+   TRACCC_CUTS+=(--useGBTS --gbts_config_dir="${TRACCC_INPUT_DIR}")
 elif [[ "${TRACCC_THROUGPUT_TYPE}" != "traccc" ]]; then
    echo "***"
    echo "*** Unknown throughput type: '${TRACCC_THROUGPUT_TYPE}'"
@@ -192,7 +198,9 @@ for NTHREAD in $(seq ${TRACCC_MIN_THREADS} ${TRACCC_THREAD_STEP} ${TRACCC_MAX_TH
             --cold-run-events=$((5*${NTHREAD}))                                \
             --processed-events=$((100*${NTHREAD}))                             \
             --log-file="${TRACCC_CSV_FILE}"                                    \
-            ${TRACCC_CUTS[@]}
+            ${TRACCC_CUTS[@]}                                                  \
+            --useGBTS="${TRACCC_USE_GBTS}"	                                  \
+            --gbts_config_dir="${TRACCC_INPUT_DIR}"
       done
    done
 done