diff --git a/rosomaxa/src/algorithms/gsom/network.rs b/rosomaxa/src/algorithms/gsom/network.rs
index 5378de0c4..3dd770c78 100644
--- a/rosomaxa/src/algorithms/gsom/network.rs
+++ b/rosomaxa/src/algorithms/gsom/network.rs
@@ -34,7 +34,7 @@ where
     min_max_weights: MinMaxWeights,
     nodes: NodeHashMap<I, S>,
     storage_factory: F,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 }
 
 /// GSOM network configuration.
@@ -61,12 +61,7 @@ where
     F: StorageFactory<I, S>,
 {
     /// Creates a new instance of `Network`.
-    pub fn new(
-        roots: [I; 4],
-        config: NetworkConfig,
-        random: Arc<dyn Random + Send + Sync>,
-        storage_factory: F,
-    ) -> Self {
+    pub fn new(roots: [I; 4], config: NetworkConfig, random: Arc<dyn Random>, storage_factory: F) -> Self {
         let dimension = roots[0].weights().len();
 
         assert!(roots.iter().all(|r| r.weights().len() == dimension));
diff --git a/rosomaxa/src/evolution/config.rs b/rosomaxa/src/evolution/config.rs
index 6149e2586..caf45b0ee 100644
--- a/rosomaxa/src/evolution/config.rs
+++ b/rosomaxa/src/evolution/config.rs
@@ -238,8 +238,8 @@ where
         max_time: Option<usize>,
         min_cv: Option<(String, usize, f64, bool, K)>,
         target_proximity: Option<(Vec<f64>, f64)>,
-    ) -> Result<Box<dyn Termination<Context = C, Objective = O> + Send + Sync>, GenericError> {
-        let terminations: Vec<Box<dyn Termination<Context = C, Objective = O> + Send + Sync>> = match (
+    ) -> Result<Box<dyn Termination<Context = C, Objective = O>>, GenericError> {
+        let terminations: Vec<Box<dyn Termination<Context = C, Objective = O>>> = match (
             max_generations,
             max_time,
             &min_cv,
@@ -250,7 +250,7 @@ where
                 vec![Box::new(MaxGeneration::new(3000)), Box::new(MaxTime::new(300.))]
             }
             _ => {
-                let mut terminations: Vec<Box<dyn Termination<Context = C, Objective = O> + Send + Sync>> = vec![];
+                let mut terminations: Vec<Box<dyn Termination<Context = C, Objective = O>>> = vec![];
 
                 if let Some(limit) = max_generations {
                     (logger)(format!("configured to use max-generations: {limit}").as_str());
@@ -270,16 +270,15 @@ where
                             .as_str(),
                         );
 
-                    let variation: Box<dyn Termination<Context = C, Objective = O> + Send + Sync> =
-                        match interval_type.as_str() {
-                            "sample" => {
-                                Box::new(MinVariation::<C, O, S, K>::new_with_sample(value, threshold, is_global, key))
-                            }
-                            "period" => {
-                                Box::new(MinVariation::<C, O, S, K>::new_with_period(value, threshold, is_global, key))
-                            }
-                            _ => return Err(format!("unknown variation interval type: {interval_type}").into()),
-                        };
+                    let variation: Box<dyn Termination<Context = C, Objective = O>> = match interval_type.as_str() {
+                        "sample" => {
+                            Box::new(MinVariation::<C, O, S, K>::new_with_sample(value, threshold, is_global, key))
+                        }
+                        "period" => {
+                            Box::new(MinVariation::<C, O, S, K>::new_with_period(value, threshold, is_global, key))
+                        }
+                        _ => return Err(format!("unknown variation interval type: {interval_type}").into()),
+                    };
 
                     terminations.push(variation)
                 }
diff --git a/rosomaxa/src/example.rs b/rosomaxa/src/example.rs
index d89e32530..b06db2a4e 100644
--- a/rosomaxa/src/example.rs
+++ b/rosomaxa/src/example.rs
@@ -138,7 +138,7 @@ impl HeuristicObjective for VectorObjective {
 }
 
 impl Shuffled for VectorObjective {
-    fn get_shuffled(&self, _: &(dyn Random + Send + Sync)) -> Self {
+    fn get_shuffled(&self, _: &(dyn Random)) -> Self {
         self.clone()
     }
 }
diff --git a/rosomaxa/src/hyper/dynamic_selective.rs b/rosomaxa/src/hyper/dynamic_selective.rs
index fe1cf390d..849bf3625 100644
--- a/rosomaxa/src/hyper/dynamic_selective.rs
+++ b/rosomaxa/src/hyper/dynamic_selective.rs
@@ -187,7 +187,7 @@ where
 struct SearchAgent<'a, C, O, S> {
     slot_machines: HashMap<SearchState, SlotMachines<'a, C, O, S>>,
     tracker: HeuristicTracker,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 }
 
 impl<'a, C, O, S> SearchAgent<'a, C, O, S>
diff --git a/rosomaxa/src/lib.rs b/rosomaxa/src/lib.rs
index b837c48e7..533ec0c76 100644
--- a/rosomaxa/src/lib.rs
+++ b/rosomaxa/src/lib.rs
@@ -296,7 +296,7 @@ pub fn get_default_population<O, S>(
     objective: Arc<O>,
     environment: Arc<Environment>,
     selection_size: usize,
-) -> Box<dyn HeuristicPopulation<Objective = O, Individual = S> + Send + Sync>
+) -> Box<dyn HeuristicPopulation<Objective = O, Individual = S>>
 where
     O: HeuristicObjective<Solution = S> + Shuffled + 'static,
     S: HeuristicSolution + RosomaxaWeighted + 'static,
diff --git a/rosomaxa/src/population/elitism.rs b/rosomaxa/src/population/elitism.rs
index 21be61b8f..7f94d3133 100644
--- a/rosomaxa/src/population/elitism.rs
+++ b/rosomaxa/src/population/elitism.rs
@@ -26,7 +26,7 @@ where
     S: HeuristicSolution,
 {
     objective: Arc<O>,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
     selection_size: usize,
     max_population_size: usize,
     individuals: Vec<S>,
@@ -39,7 +39,7 @@ where
 /// Provides way to get a new objective by shuffling existing one.
 pub trait Shuffled {
     /// Returns a new objective, potentially shuffled.
-    fn get_shuffled(&self, random: &(dyn Random + Send + Sync)) -> Self;
+    fn get_shuffled(&self, random: &(dyn Random)) -> Self;
 }
 
 impl<O, S> HeuristicPopulation for Elitism<O, S>
@@ -113,12 +113,7 @@ where
     S: HeuristicSolution,
 {
     /// Creates a new instance of `Elitism`.
-    pub fn new(
-        objective: Arc<O>,
-        random: Arc<dyn Random + Send + Sync>,
-        max_population_size: usize,
-        selection_size: usize,
-    ) -> Self {
+    pub fn new(objective: Arc<O>, random: Arc<dyn Random>, max_population_size: usize, selection_size: usize) -> Self {
         Self::new_with_dedup(
             objective,
             random,
@@ -147,7 +142,7 @@ where
     /// Creates a new instance of `Elitism` with custom deduplication function.
     pub fn new_with_dedup(
         objective: Arc<O>,
-        random: Arc<dyn Random + Send + Sync>,
+        random: Arc<dyn Random>,
         max_population_size: usize,
         selection_size: usize,
         dedup_fn: DedupFn<O, S>,
diff --git a/rosomaxa/src/population/rosomaxa.rs b/rosomaxa/src/population/rosomaxa.rs
index 8fe2caeba..e5a81eb86 100644
--- a/rosomaxa/src/population/rosomaxa.rs
+++ b/rosomaxa/src/population/rosomaxa.rs
@@ -338,11 +338,7 @@ where
         network.smooth(1);
     }
 
-    fn fill_populations(
-        network: &IndividualNetwork<O, S>,
-        coordinates: &mut Vec<Coordinate>,
-        random: &(dyn Random + Send + Sync),
-    ) {
+    fn fill_populations(network: &IndividualNetwork<O, S>, coordinates: &mut Vec<Coordinate>, random: &(dyn Random)) {
         coordinates.clear();
         coordinates.extend(network.iter().filter_map(|(coordinate, node)| {
             if node.storage.population.size() > 0 {
@@ -455,7 +451,7 @@ where
     S: HeuristicSolution + RosomaxaWeighted,
 {
     node_size: usize,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
     objective: Arc<O>,
 }
 
diff --git a/rosomaxa/src/termination/min_variation.rs b/rosomaxa/src/termination/min_variation.rs
index 87ed831cb..af87f9a08 100644
--- a/rosomaxa/src/termination/min_variation.rs
+++ b/rosomaxa/src/termination/min_variation.rs
@@ -145,7 +145,7 @@ where
     C: HeuristicContext<Objective = O, Solution = S> + Stateful<Key = K>,
     O: HeuristicObjective<Solution = S>,
     S: HeuristicSolution,
-    K: Hash + Eq + Clone,
+    K: Hash + Eq + Clone + Send + Sync,
 {
     type Context = C;
     type Objective = O;
diff --git a/rosomaxa/src/termination/mod.rs b/rosomaxa/src/termination/mod.rs
index c17a52bd2..e9d8f044a 100644
--- a/rosomaxa/src/termination/mod.rs
+++ b/rosomaxa/src/termination/mod.rs
@@ -4,7 +4,7 @@
 use crate::prelude::*;
 
 /// A trait which specifies criteria when metaheuristic should stop searching for improved solution.
-pub trait Termination {
+pub trait Termination: Send + Sync {
     /// A heuristic objective function type.
     type Context: HeuristicContext<Objective = Self::Objective>;
 
@@ -37,7 +37,7 @@ where
     O: HeuristicObjective<Solution = S>,
     S: HeuristicSolution,
 {
-    terminations: Vec<Box<dyn Termination<Context = C, Objective = O> + Send + Sync>>,
+    terminations: Vec<Box<dyn Termination<Context = C, Objective = O>>>,
 }
 
 impl<C, O, S> CompositeTermination<C, O, S>
@@ -47,7 +47,7 @@ where
     S: HeuristicSolution,
 {
     /// Creates a new instance of `CompositeTermination`.
-    pub fn new(terminations: Vec<Box<dyn Termination<Context = C, Objective = O> + Send + Sync>>) -> Self {
+    pub fn new(terminations: Vec<Box<dyn Termination<Context = C, Objective = O>>>) -> Self {
         Self { terminations }
     }
 }
diff --git a/rosomaxa/src/utils/environment.rs b/rosomaxa/src/utils/environment.rs
index e758445e8..7a11e363e 100644
--- a/rosomaxa/src/utils/environment.rs
+++ b/rosomaxa/src/utils/environment.rs
@@ -17,10 +17,10 @@ pub trait Quota: Send + Sync {
 #[derive(Clone)]
 pub struct Environment {
     /// A wrapper on random generator.
-    pub random: Arc<dyn Random + Send + Sync>,
+    pub random: Arc<dyn Random>,
 
     /// A global execution quota.
-    pub quota: Option<Arc<dyn Quota + Send + Sync>>,
+    pub quota: Option<Arc<dyn Quota>>,
 
     /// Keeps data parallelism settings.
     pub parallelism: Parallelism,
@@ -36,15 +36,15 @@ impl Environment {
     /// Creates an instance of `Environment` using optional time quota and defaults.
     pub fn new_with_time_quota(max_time: Option<usize>) -> Self {
         Self {
-            quota: max_time.map::<Arc<dyn Quota + Send + Sync>, _>(|time| Arc::new(TimeQuota::new(time as f64))),
+            quota: max_time.map::<Arc<dyn Quota>, _>(|time| Arc::new(TimeQuota::new(time as f64))),
             ..Self::default()
         }
     }
 
     /// Creates an instance of `Environment`.
     pub fn new(
-        random: Arc<dyn Random + Send + Sync>,
-        quota: Option<Arc<dyn Quota + Send + Sync>>,
+        random: Arc<dyn Random>,
+        quota: Option<Arc<dyn Quota>>,
         parallelism: Parallelism,
         logger: InfoLogger,
         is_experimental: bool,
diff --git a/rosomaxa/src/utils/iterators.rs b/rosomaxa/src/utils/iterators.rs
index 4301fd7c8..6e604bfb6 100644
--- a/rosomaxa/src/utils/iterators.rs
+++ b/rosomaxa/src/utils/iterators.rs
@@ -47,12 +47,12 @@ pub struct SelectionSamplingIterator<I: Iterator> {
     needed: usize,
     size: usize,
     iterator: I,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 }
 
 impl<I: Iterator> SelectionSamplingIterator<I> {
     /// Creates a new instance of `SelectionSamplingIterator`.
-    pub fn new(iterator: I, amount: usize, random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(iterator: I, amount: usize, random: Arc<dyn Random>) -> Self {
         assert!(amount > 0);
         Self {
             // NOTE relying on lower bound size hint!
@@ -93,7 +93,7 @@ impl<I: Iterator> Iterator for SelectionSamplingIterator<I> {
 pub fn create_range_sampling_iter<I: Iterator>(
     iterator: I,
     sample_size: usize,
-    random: &(dyn Random + Send + Sync),
+    random: &(dyn Random),
 ) -> impl Iterator<Item = I::Item> {
     let iterator_size = iterator.size_hint().0 as f64;
     let sample_count = (iterator_size / sample_size as f64).max(1.) - 1.;
@@ -131,7 +131,7 @@ pub trait SelectionSamplingSearch: Iterator {
     fn sample_search<'a, T, R, FM, FI, FC>(
         self,
         sample_size: usize,
-        random: Arc<dyn Random + Send + Sync>,
+        random: Arc<dyn Random>,
         mut map_fn: FM,
         index_fn: FI,
         compare_fn: FC,
diff --git a/rosomaxa/src/utils/noise.rs b/rosomaxa/src/utils/noise.rs
index 3386a795d..09e76509c 100644
--- a/rosomaxa/src/utils/noise.rs
+++ b/rosomaxa/src/utils/noise.rs
@@ -9,19 +9,19 @@ pub struct Noise {
     probability: f64,
     range: (f64, f64),
     is_addition: bool,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 }
 
 impl Noise {
     /// Creates a new instance of `Noise` which will add some noise in given range
     /// to the target value: `value = value + value * sample_from(range)`
-    pub fn new_with_addition(probability: f64, range: (f64, f64), random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new_with_addition(probability: f64, range: (f64, f64), random: Arc<dyn Random>) -> Self {
         Self { probability, range, is_addition: true, random }
     }
 
     /// Creates a new instance of `Noise` which will apply noise by multiplying target value
     /// by value from given range: `value = value * sample_from(range)`
-    pub fn new_with_ratio(probability: f64, range: (f64, f64), random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new_with_ratio(probability: f64, range: (f64, f64), random: Arc<dyn Random>) -> Self {
         Self { probability, range, is_addition: false, random }
     }
 
@@ -48,7 +48,7 @@ impl Noise {
     }
 
     /// Returns random generator.
-    pub fn random(&self) -> &(dyn Random + Send + Sync) {
+    pub fn random(&self) -> &(dyn Random) {
         self.random.as_ref()
     }
 }
diff --git a/rosomaxa/src/utils/random.rs b/rosomaxa/src/utils/random.rs
index 26678bb50..cbbc05b49 100644
--- a/rosomaxa/src/utils/random.rs
+++ b/rosomaxa/src/utils/random.rs
@@ -19,7 +19,7 @@ pub trait DistributionSampler {
 }
 
 /// Provides the way to use randomized values in generic way.
-pub trait Random {
+pub trait Random: Send + Sync {
     /// Produces integral random value, uniformly distributed on the closed interval [min, max]
     fn uniform_int(&self, min: i32, max: i32) -> i32;
 
@@ -43,11 +43,11 @@ pub trait Random {
 
 /// Provides way to sample from different distributions.
 #[derive(Clone)]
-pub struct DefaultDistributionSampler(Arc<dyn Random + Send + Sync>);
+pub struct DefaultDistributionSampler(Arc<dyn Random>);
 
 impl DefaultDistributionSampler {
     /// Creates a new instance of `DefaultDistributionSampler`.
-    pub fn new(random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(random: Arc<dyn Random>) -> Self {
         Self(random)
     }
 }
diff --git a/rosomaxa/tests/helpers/utils/mod.rs b/rosomaxa/tests/helpers/utils/mod.rs
index 82a0d6188..5520be8dd 100644
--- a/rosomaxa/tests/helpers/utils/mod.rs
+++ b/rosomaxa/tests/helpers/utils/mod.rs
@@ -1,6 +1,6 @@
 use crate::utils::{DefaultRandom, Random};
 use std::sync::Arc;
 
-pub fn create_test_random() -> Arc<dyn Random + Send + Sync> {
+pub fn create_test_random() -> Arc<dyn Random> {
     Arc::new(DefaultRandom::default())
 }
diff --git a/rosomaxa/tests/unit/example_test.rs b/rosomaxa/tests/unit/example_test.rs
index d3f2dd9a2..f20844b24 100644
--- a/rosomaxa/tests/unit/example_test.rs
+++ b/rosomaxa/tests/unit/example_test.rs
@@ -1,10 +1,6 @@
 use super::*;
 
-fn just_noise(
-    probability: f64,
-    range: (f64, f64),
-    random: Arc<dyn Random + Send + Sync>,
-) -> VectorHeuristicOperatorMode {
+fn just_noise(probability: f64, range: (f64, f64), random: Arc<dyn Random>) -> VectorHeuristicOperatorMode {
     VectorHeuristicOperatorMode::JustNoise(Noise::new_with_ratio(probability, range, random))
 }
 
@@ -12,7 +8,7 @@ fn dimen_noise(
     probability: f64,
     range: (f64, f64),
     dimen: usize,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 ) -> VectorHeuristicOperatorMode {
     let dimen = vec![dimen].into_iter().collect();
     VectorHeuristicOperatorMode::DimensionNoise(Noise::new_with_ratio(probability, range, random), dimen)
diff --git a/rosomaxa/tests/unit/hyper/dynamic_selective_test.rs b/rosomaxa/tests/unit/hyper/dynamic_selective_test.rs
index 09fbbfa08..89296470f 100644
--- a/rosomaxa/tests/unit/hyper/dynamic_selective_test.rs
+++ b/rosomaxa/tests/unit/hyper/dynamic_selective_test.rs
@@ -8,7 +8,7 @@ use std::time::Duration;
 fn can_estimate_median() {
     struct DelayableHeuristicOperator {
         delay_range: Range<i32>,
-        random: Arc<dyn Random + Send + Sync>,
+        random: Arc<dyn Random>,
     }
     impl HeuristicSearchOperator for DelayableHeuristicOperator {
         type Context = VectorContext;
diff --git a/vrp-cli/src/commands/solve.rs b/vrp-cli/src/commands/solve.rs
index 9380f9255..4f4dbebf0 100644
--- a/vrp-cli/src/commands/solve.rs
+++ b/vrp-cli/src/commands/solve.rs
@@ -67,7 +67,7 @@ struct LocationWriter(pub Box<dyn Fn(File, BufWriter<Box<dyn Write>>) -> Result<
 #[allow(clippy::type_complexity)]
 type FormatMap<'a> = HashMap<&'a str, (ProblemReader, InitSolutionReader, SolutionWriter, LocationWriter)>;
 
-fn add_scientific(formats: &mut FormatMap, matches: &ArgMatches, random: Arc<dyn Random + Send + Sync>) {
+fn add_scientific(formats: &mut FormatMap, matches: &ArgMatches, random: Arc<dyn Random>) {
     if cfg!(feature = "scientific-format") {
         use vrp_scientific::common::read_init_solution;
         use vrp_scientific::lilim::{LilimProblem, LilimSolution};
@@ -119,7 +119,7 @@ fn add_scientific(formats: &mut FormatMap, matches: &ArgMatches, random: Arc<dyn
     }
 }
 
-fn add_pragmatic(formats: &mut FormatMap, random: Arc<dyn Random + Send + Sync>) {
+fn add_pragmatic(formats: &mut FormatMap, random: Arc<dyn Random>) {
     use vrp_pragmatic::format::problem::{deserialize_problem, PragmaticProblem};
     use vrp_pragmatic::format::solution::read_init_solution as read_init_pragmatic;
 
@@ -156,7 +156,7 @@ fn add_pragmatic(formats: &mut FormatMap, random: Arc<dyn Random + Send + Sync>)
     );
 }
 
-fn get_formats<'a>(matches: &ArgMatches, random: Arc<dyn Random + Send + Sync>) -> FormatMap<'a> {
+fn get_formats<'a>(matches: &ArgMatches, random: Arc<dyn Random>) -> FormatMap<'a> {
     let mut formats = FormatMap::default();
 
     add_scientific(&mut formats, matches, random.clone());
@@ -533,9 +533,9 @@ fn check_pragmatic_solution_with_args(matches: &ArgMatches) -> GenericResult<()>
 }
 
 /// Creates interruption quota.
-pub fn create_interruption_quota(max_time: Option<usize>) -> Arc<dyn Quota + Send + Sync> {
+pub fn create_interruption_quota(max_time: Option<usize>) -> Arc<dyn Quota> {
     struct InterruptionQuota {
-        inner: Option<Arc<dyn Quota + Send + Sync>>,
+        inner: Option<Arc<dyn Quota>>,
         should_interrupt: Arc<AtomicBool>,
     }
 
@@ -546,7 +546,7 @@ pub fn create_interruption_quota(max_time: Option<usize>) -> Arc<dyn Quota + Sen
         }
     }
 
-    let inner = max_time.map::<Arc<dyn Quota + Send + Sync>, _>(|time| Arc::new(TimeQuota::new(time as f64)));
+    let inner = max_time.map::<Arc<dyn Quota>, _>(|time| Arc::new(TimeQuota::new(time as f64)));
     let should_interrupt = Arc::new(AtomicBool::new(false));
 
     // NOTE ignore error which happens in unit tests
diff --git a/vrp-cli/src/extensions/solve/config.rs b/vrp-cli/src/extensions/solve/config.rs
index 74d7ae745..be32373eb 100644
--- a/vrp-cli/src/extensions/solve/config.rs
+++ b/vrp-cli/src/extensions/solve/config.rs
@@ -570,10 +570,7 @@ fn configure_from_termination(
     builder
 }
 
-fn create_recreate_method(
-    method: &RecreateMethod,
-    environment: Arc<Environment>,
-) -> (Arc<dyn Recreate + Send + Sync>, usize) {
+fn create_recreate_method(method: &RecreateMethod, environment: Arc<Environment>) -> (Arc<dyn Recreate>, usize) {
     let random = environment.random.clone();
     match method {
         RecreateMethod::Cheapest { weight } => (Arc::new(RecreateWithCheapest::new(random)), *weight),
@@ -637,7 +634,7 @@ fn create_operator(
 
 fn create_operator_probability(
     probability: &OperatorProbabilityType,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 ) -> TargetHeuristicProbability {
     match probability {
         OperatorProbabilityType::Scalar { scalar } => create_scalar_operator_probability(*scalar, random),
@@ -665,7 +662,7 @@ fn create_ruin_method(
     problem: &Arc<Problem>,
     environment: Arc<Environment>,
     method: &RuinMethod,
-) -> (Arc<dyn Ruin + Send + Sync>, f64) {
+) -> (Arc<dyn Ruin>, f64) {
     let limits = RemovalLimits::new(problem.as_ref());
     let get_limits = |min: usize, max: usize| RemovalLimits {
         removed_activities_range: min..max,
@@ -700,11 +697,11 @@ fn create_ruin_method(
 fn create_local_search(
     times: &MinMaxConfig,
     inners: &[LocalOperatorType],
-    random: Arc<dyn Random + Send + Sync>,
-) -> Arc<dyn LocalOperator + Send + Sync> {
+    random: Arc<dyn Random>,
+) -> Arc<dyn LocalOperator> {
     let operators = inners
         .iter()
-        .map::<(Arc<dyn LocalOperator + Send + Sync>, usize), _>(|op| match op {
+        .map::<(Arc<dyn LocalOperator>, usize), _>(|op| match op {
             LocalOperatorType::SwapStar { weight } => (Arc::new(ExchangeSwapStar::new(random.clone(), 200)), *weight),
             LocalOperatorType::InterRouteBest { weight, noise } => {
                 (Arc::new(ExchangeInterRouteBest::new(noise.probability, noise.min, noise.max)), *weight)
diff --git a/vrp-core/examples/common/routing.rs b/vrp-core/examples/common/routing.rs
index 800f50914..3a9c12f10 100644
--- a/vrp-core/examples/common/routing.rs
+++ b/vrp-core/examples/common/routing.rs
@@ -3,7 +3,7 @@
 use vrp_core::prelude::*;
 
 /// Gets a routing matrix for 5 unique locations.
-pub fn define_routing_data() -> GenericResult<impl TransportCost + Send + Sync> {
+pub fn define_routing_data() -> GenericResult<impl TransportCost> {
     // define distance/duration matrix (use the same data for both)
     // as we have five locations, we need to define 5x5 matrix, flatten to 1 dimension:
     #[rustfmt::skip]
diff --git a/vrp-core/examples/custom_constraint.rs b/vrp-core/examples/custom_constraint.rs
index b14c83d25..fc5020691 100644
--- a/vrp-core/examples/custom_constraint.rs
+++ b/vrp-core/examples/custom_constraint.rs
@@ -49,7 +49,7 @@ impl FeatureConstraint for HardwareConstraint {
 }
 
 /// Specifies a CVRP problem variant: 4 delivery jobs with demand=1 and 2 vehicles with capacity=2 in each.
-fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost + Send + Sync>) -> GenericResult<Problem> {
+fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost>) -> GenericResult<Problem> {
     // create 4 jobs when second and forth have fridge requirement
     let single_jobs = (1..=4)
         .map(|idx| {
@@ -99,7 +99,7 @@ fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost + Send + S
 }
 
 /// Defines CVRP variant with a custom constraint as a goal of optimization.
-fn define_goal(transport: Arc<dyn TransportCost + Send + Sync>) -> GenericResult<GoalContext> {
+fn define_goal(transport: Arc<dyn TransportCost>) -> GenericResult<GoalContext> {
     let minimize_unassigned = MinimizeUnassignedBuilder::new("min-unassigned").build()?;
     let capacity_feature = CapacityFeatureBuilder::<SingleDimLoad>::new("capacity").build()?;
     let transport_feature = TransportFeatureBuilder::new("min-distance")
diff --git a/vrp-core/examples/custom_objective.rs b/vrp-core/examples/custom_objective.rs
index fdb2d38ce..f9ad16254 100644
--- a/vrp-core/examples/custom_objective.rs
+++ b/vrp-core/examples/custom_objective.rs
@@ -81,7 +81,7 @@ fn calculate_solution_fitness(solution_ctx: &SolutionContext) -> Cost {
 
 /// Specifies four delivery jobs with demand=1 (two of them are with top priority) and a single vehicle
 /// with capacity=2 which doesn't need to return to the depot.
-fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost + Send + Sync>) -> GenericResult<Problem> {
+fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost>) -> GenericResult<Problem> {
     // create 4 jobs where two are having top prio
     let single_jobs = (1..=4)
         .map(|idx| {
@@ -114,7 +114,7 @@ fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost + Send + S
 }
 
 /// Defines optimization goal as CVRP variant with a priority objective function on top.
-fn define_goal(transport: Arc<dyn TransportCost + Send + Sync>) -> GenericResult<GoalContext> {
+fn define_goal(transport: Arc<dyn TransportCost>) -> GenericResult<GoalContext> {
     let minimize_unassigned = MinimizeUnassignedBuilder::new("min-unassigned").build()?;
     let capacity_feature = CapacityFeatureBuilder::<SingleDimLoad>::new("capacity").build()?;
     let transport_feature = TransportFeatureBuilder::new("min-distance")
diff --git a/vrp-core/examples/cvrp.rs b/vrp-core/examples/cvrp.rs
index 8cfb33b98..a3a81ac62 100644
--- a/vrp-core/examples/cvrp.rs
+++ b/vrp-core/examples/cvrp.rs
@@ -17,7 +17,7 @@ use std::sync::Arc;
 use vrp_core::prelude::*;
 
 /// Specifies a CVRP problem variant: 4 delivery jobs with demand=1 and 4 vehicles with capacity=2 in each.
-fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost + Send + Sync>) -> GenericResult<Problem> {
+fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost>) -> GenericResult<Problem> {
     // create 4 jobs with location indices from 1 to 4
     let single_jobs = (1..=4)
         .map(|idx| {
@@ -59,7 +59,7 @@ fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost + Send + S
 }
 
 /// Defines CVRP variant as a goal of optimization.
-fn define_goal(transport: Arc<dyn TransportCost + Send + Sync>) -> GenericResult<GoalContext> {
+fn define_goal(transport: Arc<dyn TransportCost>) -> GenericResult<GoalContext> {
     // configure features needed to model CVRP
     let minimize_unassigned = MinimizeUnassignedBuilder::new("min-unassigned").build()?;
     let capacity_feature = CapacityFeatureBuilder::<SingleDimLoad>::new("capacity").build()?;
diff --git a/vrp-core/examples/pdptw.rs b/vrp-core/examples/pdptw.rs
index c0c4e2897..309c095df 100644
--- a/vrp-core/examples/pdptw.rs
+++ b/vrp-core/examples/pdptw.rs
@@ -19,7 +19,7 @@ use vrp_core::models::common::TimeWindow;
 use vrp_core::prelude::*;
 
 /// Specifies a PDPTW problem variant: two PUDO (pick up/drop off) jobs with demand=1 and 1 vehicle with capacity 1
-fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost + Send + Sync>) -> GenericResult<Problem> {
+fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost>) -> GenericResult<Problem> {
     // build two PUDO (pick up/drop off) jobs with demand=1 and permissive time windows (just to show API usage)
     let pudos = (1..=2)
         .map(|idx| {
@@ -72,7 +72,7 @@ fn define_problem(goal: GoalContext, transport: Arc<dyn TransportCost + Send + S
 }
 
 /// Defines PDPTW variant as a goal of optimization.
-fn define_goal(transport: Arc<dyn TransportCost + Send + Sync>) -> GenericResult<GoalContext> {
+fn define_goal(transport: Arc<dyn TransportCost>) -> GenericResult<GoalContext> {
     // configure features needed to model PDPTW
     let minimize_unassigned = MinimizeUnassignedBuilder::new("min-unassigned").build()?;
     let capacity_feature = CapacityFeatureBuilder::<SingleDimLoad>::new("capacity").build()?;
diff --git a/vrp-core/src/construction/clustering/dbscan/mod.rs b/vrp-core/src/construction/clustering/dbscan/mod.rs
index 9d350539a..f627d0aa9 100644
--- a/vrp-core/src/construction/clustering/dbscan/mod.rs
+++ b/vrp-core/src/construction/clustering/dbscan/mod.rs
@@ -16,7 +16,7 @@ use std::sync::Arc;
 /// Creates clusters of jobs using DBSCAN algorithm.
 pub fn create_job_clusters(
     problem: &Problem,
-    random: &(dyn Random + Send + Sync),
+    random: &(dyn Random),
     min_points: Option<usize>,
     epsilon: Option<f64>,
 ) -> Vec<Vec<Job>> {
diff --git a/vrp-core/src/construction/clustering/vicinity/estimations.rs b/vrp-core/src/construction/clustering/vicinity/estimations.rs
index 266307920..4f36f8726 100644
--- a/vrp-core/src/construction/clustering/vicinity/estimations.rs
+++ b/vrp-core/src/construction/clustering/vicinity/estimations.rs
@@ -96,7 +96,7 @@ pub(crate) fn get_clusters(
 /// Gets jobs dissimilarities.
 pub(crate) fn get_jobs_dissimilarities(
     jobs: &[Job],
-    transport: &(dyn TransportCost + Send + Sync),
+    transport: &(dyn TransportCost),
     config: &ClusterConfig,
 ) -> HashMap<Job, DissimilarityIndex> {
     jobs.iter()
@@ -121,7 +121,7 @@ pub(crate) fn get_jobs_dissimilarities(
 fn get_dissimilarities(
     outer: &Job,
     inner: &Job,
-    transport: &(dyn TransportCost + Send + Sync),
+    transport: &(dyn TransportCost),
     config: &ClusterConfig,
 ) -> Vec<DissimilarityInfo> {
     let min_shared_time = config.threshold.min_shared_time.unwrap_or(0.);
diff --git a/vrp-core/src/construction/enablers/conditional_job.rs b/vrp-core/src/construction/enablers/conditional_job.rs
index 75f0b8c20..e88022610 100644
--- a/vrp-core/src/construction/enablers/conditional_job.rs
+++ b/vrp-core/src/construction/enablers/conditional_job.rs
@@ -3,7 +3,7 @@ use crate::models::problem::Job;
 use std::collections::HashSet;
 
 /// Defines how jobs are moved in solution context. Index of original affected route context is passed.
-pub trait JobContextTransition {
+pub trait JobContextTransition: Send + Sync {
     /// Returns true if job is moved from required to ignored.
     fn remove_from_required(&self, solution_ctx: &SolutionContext, route_index: Option<usize>, job: &Job) -> bool;
 
@@ -20,10 +20,10 @@ pub trait JobContextTransition {
 /// A concrete implementation of `JobContextTransition` which allows to use lambdas.
 pub struct ConcreteJobContextTransition<FRemoveRequired, FPromoteRequired, FRemoveLocked, FPromoteLocked>
 where
-    FRemoveRequired: Fn(&SolutionContext, Option<usize>, &Job) -> bool,
-    FPromoteRequired: Fn(&SolutionContext, Option<usize>, &Job) -> bool,
-    FRemoveLocked: Fn(&SolutionContext, Option<usize>, &Job) -> bool,
-    FPromoteLocked: Fn(&SolutionContext, Option<usize>, &Job) -> bool,
+    FRemoveRequired: Fn(&SolutionContext, Option<usize>, &Job) -> bool + Send + Sync,
+    FPromoteRequired: Fn(&SolutionContext, Option<usize>, &Job) -> bool + Send + Sync,
+    FRemoveLocked: Fn(&SolutionContext, Option<usize>, &Job) -> bool + Send + Sync,
+    FPromoteLocked: Fn(&SolutionContext, Option<usize>, &Job) -> bool + Send + Sync,
 {
     /// A function which removes job from required list.
     pub remove_required: FRemoveRequired,
@@ -38,10 +38,10 @@ where
 impl<FRemoveRequired, FPromoteRequired, FRemoveLocked, FPromoteLocked> JobContextTransition
     for ConcreteJobContextTransition<FRemoveRequired, FPromoteRequired, FRemoveLocked, FPromoteLocked>
 where
-    FRemoveRequired: Fn(&SolutionContext, Option<usize>, &Job) -> bool,
-    FPromoteRequired: Fn(&SolutionContext, Option<usize>, &Job) -> bool,
-    FRemoveLocked: Fn(&SolutionContext, Option<usize>, &Job) -> bool,
-    FPromoteLocked: Fn(&SolutionContext, Option<usize>, &Job) -> bool,
+    FRemoveRequired: Fn(&SolutionContext, Option<usize>, &Job) -> bool + Send + Sync,
+    FPromoteRequired: Fn(&SolutionContext, Option<usize>, &Job) -> bool + Send + Sync,
+    FRemoveLocked: Fn(&SolutionContext, Option<usize>, &Job) -> bool + Send + Sync,
+    FPromoteLocked: Fn(&SolutionContext, Option<usize>, &Job) -> bool + Send + Sync,
 {
     fn remove_from_required(&self, solution_ctx: &SolutionContext, route_index: Option<usize>, job: &Job) -> bool {
         (self.remove_required)(solution_ctx, route_index, job)
@@ -64,7 +64,7 @@ where
 pub fn process_conditional_jobs(
     solution_ctx: &mut SolutionContext,
     route_index: Option<usize>,
-    context_transition: &(dyn JobContextTransition + Send + Sync),
+    context_transition: &(dyn JobContextTransition),
 ) {
     // analyzed required/ignored
     let ignored: HashSet<Job> = solution_ctx
diff --git a/vrp-core/src/construction/enablers/departure_time.rs b/vrp-core/src/construction/enablers/departure_time.rs
index 75916ac00..80f781909 100644
--- a/vrp-core/src/construction/enablers/departure_time.rs
+++ b/vrp-core/src/construction/enablers/departure_time.rs
@@ -12,8 +12,8 @@ use std::cmp::Ordering;
 /// Tries to move forward route's departure time.
 pub fn advance_departure_time(
     route_ctx: &mut RouteContext,
-    activity: &(dyn ActivityCost + Send + Sync),
-    transport: &(dyn TransportCost + Send + Sync),
+    activity: &(dyn ActivityCost),
+    transport: &(dyn TransportCost),
     consider_whole_tour: bool,
 ) {
     if let Some(new_departure_time) = try_advance_departure_time(route_ctx, transport, consider_whole_tour) {
@@ -24,8 +24,8 @@ pub fn advance_departure_time(
 /// Tries to move backward route's departure time.
 pub fn recede_departure_time(
     route_ctx: &mut RouteContext,
-    activity: &(dyn ActivityCost + Send + Sync),
-    transport: &(dyn TransportCost + Send + Sync),
+    activity: &(dyn ActivityCost),
+    transport: &(dyn TransportCost),
 ) {
     if let Some(new_departure_time) = try_recede_departure_time(route_ctx) {
         update_route_departure(route_ctx, activity, transport, new_departure_time);
@@ -34,7 +34,7 @@ pub fn recede_departure_time(
 
 fn try_advance_departure_time(
     route_ctx: &RouteContext,
-    transport: &(dyn TransportCost + Send + Sync),
+    transport: &(dyn TransportCost),
     optimize_whole_tour: bool,
 ) -> Option<Timestamp> {
     let route = route_ctx.route();
diff --git a/vrp-core/src/construction/enablers/multi_trip.rs b/vrp-core/src/construction/enablers/multi_trip.rs
index 962b3986b..cbb9094fb 100644
--- a/vrp-core/src/construction/enablers/multi_trip.rs
+++ b/vrp-core/src/construction/enablers/multi_trip.rs
@@ -12,7 +12,7 @@ use std::iter::once;
 use std::sync::Arc;
 
 /// Specifies multi trip extension behavior.
-pub trait MultiTrip {
+pub trait MultiTrip: Send + Sync {
     /// Gets an actual route intervals.
     fn get_route_intervals(&self) -> &RouteIntervals;
 
@@ -40,7 +40,7 @@ pub fn create_multi_trip_feature(
     name: &str,
     violation_code: ViolationCode,
     policy: MarkerInsertionPolicy,
-    multi_trip: Arc<dyn MultiTrip + Send + Sync>,
+    multi_trip: Arc<dyn MultiTrip>,
 ) -> Result<Feature, GenericError> {
     FeatureBuilder::default()
         .with_name(name)
@@ -52,7 +52,7 @@ pub fn create_multi_trip_feature(
 struct MultiTripConstraint {
     code: ViolationCode,
     policy: MarkerInsertionPolicy,
-    multi_trip: Arc<dyn MultiTrip + Send + Sync>,
+    multi_trip: Arc<dyn MultiTrip>,
 }
 
 impl FeatureConstraint for MultiTripConstraint {
@@ -103,19 +103,19 @@ impl FeatureConstraint for MultiTripConstraint {
 }
 
 impl MultiTripConstraint {
-    fn new(code: ViolationCode, policy: MarkerInsertionPolicy, multi_trip: Arc<dyn MultiTrip + Send + Sync>) -> Self {
+    fn new(code: ViolationCode, policy: MarkerInsertionPolicy, multi_trip: Arc<dyn MultiTrip>) -> Self {
         Self { code, policy, multi_trip }
     }
 }
 
 struct MultiTripState {
-    multi_trip: Arc<dyn MultiTrip + Send + Sync>,
-    context_transition: Box<dyn JobContextTransition + Send + Sync>,
+    multi_trip: Arc<dyn MultiTrip>,
+    context_transition: Box<dyn JobContextTransition>,
     code: ViolationCode,
 }
 
 impl MultiTripState {
-    pub fn new(code: ViolationCode, multi_trip: Arc<dyn MultiTrip + Send + Sync>) -> Self {
+    pub fn new(code: ViolationCode, multi_trip: Arc<dyn MultiTrip>) -> Self {
         let context_transition = Box::new(ConcreteJobContextTransition {
             remove_required: {
                 let multi_trip = multi_trip.clone();
diff --git a/vrp-core/src/construction/enablers/reserved_time.rs b/vrp-core/src/construction/enablers/reserved_time.rs
index d04e96d4c..343e5fa28 100644
--- a/vrp-core/src/construction/enablers/reserved_time.rs
+++ b/vrp-core/src/construction/enablers/reserved_time.rs
@@ -101,15 +101,12 @@ impl ActivityCost for DynamicActivityCost {
 /// Provides way to calculate transport costs which might contain reserved time.
 pub struct DynamicTransportCost {
     reserved_times_fn: ReservedTimesFn,
-    inner: Arc<dyn TransportCost + Send + Sync>,
+    inner: Arc<dyn TransportCost>,
 }
 
 impl DynamicTransportCost {
     /// Creates a new instance of `DynamicTransportCost`.
-    pub fn new(
-        reserved_times_index: ReservedTimesIndex,
-        inner: Arc<dyn TransportCost + Send + Sync>,
-    ) -> Result<Self, GenericError> {
+    pub fn new(reserved_times_index: ReservedTimesIndex, inner: Arc<dyn TransportCost>) -> Result<Self, GenericError> {
         Ok(Self { reserved_times_fn: create_reserved_times_fn(reserved_times_index)?, inner })
     }
 }
diff --git a/vrp-core/src/construction/enablers/schedule_update.rs b/vrp-core/src/construction/enablers/schedule_update.rs
index 5f30e3e36..a3ed39367 100644
--- a/vrp-core/src/construction/enablers/schedule_update.rs
+++ b/vrp-core/src/construction/enablers/schedule_update.rs
@@ -12,8 +12,8 @@ custom_tour_state!(LimitDuration typeof Duration);
 /// Updates route schedule data.
 pub fn update_route_schedule(
     route_ctx: &mut RouteContext,
-    activity: &(dyn ActivityCost + Send + Sync),
-    transport: &(dyn TransportCost + Send + Sync),
+    activity: &(dyn ActivityCost),
+    transport: &(dyn TransportCost),
 ) {
     update_schedules(route_ctx, activity, transport);
     update_states(route_ctx, activity, transport);
@@ -23,8 +23,8 @@ pub fn update_route_schedule(
 /// Updates route departure to the new one.
 pub fn update_route_departure(
     route_ctx: &mut RouteContext,
-    activity: &(dyn ActivityCost + Send + Sync),
-    transport: &(dyn TransportCost + Send + Sync),
+    activity: &(dyn ActivityCost),
+    transport: &(dyn TransportCost),
     new_departure_time: Timestamp,
 ) {
     let start = route_ctx.route_mut().tour.get_mut(0).unwrap();
@@ -33,11 +33,7 @@ pub fn update_route_departure(
     update_route_schedule(route_ctx, activity, transport);
 }
 
-fn update_schedules(
-    route_ctx: &mut RouteContext,
-    activity: &(dyn ActivityCost + Send + Sync),
-    transport: &(dyn TransportCost + Send + Sync),
-) {
+fn update_schedules(route_ctx: &mut RouteContext, activity: &(dyn ActivityCost), transport: &(dyn TransportCost)) {
     let init = {
         let start = route_ctx.route().tour.start().unwrap();
         (start.place.location, start.schedule.departure)
@@ -59,11 +55,7 @@ fn update_schedules(
     });
 }
 
-fn update_states(
-    route_ctx: &mut RouteContext,
-    activity: &(dyn ActivityCost + Send + Sync),
-    transport: &(dyn TransportCost + Send + Sync),
-) {
+fn update_states(route_ctx: &mut RouteContext, activity: &(dyn ActivityCost), transport: &(dyn TransportCost)) {
     // update latest arrival and waiting states of non-terminate (jobs) activities
     let actor = route_ctx.route().actor.clone();
     let init = (
@@ -117,7 +109,7 @@ fn update_states(
     route_ctx.state_mut().set_waiting_time_states(waiting_times);
 }
 
-fn update_statistics(route_ctx: &mut RouteContext, transport: &(dyn TransportCost + Send + Sync)) {
+fn update_statistics(route_ctx: &mut RouteContext, transport: &(dyn TransportCost)) {
     let (route, state) = route_ctx.as_mut();
 
     let start = route.tour.start().unwrap();
diff --git a/vrp-core/src/construction/enablers/travel_info.rs b/vrp-core/src/construction/enablers/travel_info.rs
index 212329215..80d504be2 100644
--- a/vrp-core/src/construction/enablers/travel_info.rs
+++ b/vrp-core/src/construction/enablers/travel_info.rs
@@ -7,7 +7,7 @@ use crate::models::solution::{Activity, Route};
 pub fn calculate_travel(
     route_ctx: &RouteContext,
     activity_ctx: &ActivityContext,
-    transport: &(dyn TransportCost + Send + Sync),
+    transport: &(dyn TransportCost),
 ) -> ((Distance, Distance), (Duration, Duration)) {
     let route = route_ctx.route();
     let prev = activity_ctx.prev;
@@ -33,7 +33,7 @@ pub fn calculate_travel(
 pub fn calculate_travel_delta(
     route_ctx: &RouteContext,
     activity_ctx: &ActivityContext,
-    transport: &(dyn TransportCost + Send + Sync),
+    transport: &(dyn TransportCost),
 ) -> (Distance, Duration) {
     // NOTE accept some code duplication between methods in that module as they are called often,
     //      generalization might require some redundancy in calculations
@@ -65,7 +65,7 @@ fn calculate_travel_leg(
     first: &Activity,
     second: &Activity,
     departure: Timestamp,
-    transport: &(dyn TransportCost + Send + Sync),
+    transport: &(dyn TransportCost),
 ) -> (Distance, Duration) {
     let first_to_second_dis =
         transport.distance(route, first.place.location, second.place.location, TravelTime::Departure(departure));
diff --git a/vrp-core/src/construction/features/fast_service.rs b/vrp-core/src/construction/features/fast_service.rs
index bbda5acce..c41197964 100644
--- a/vrp-core/src/construction/features/fast_service.rs
+++ b/vrp-core/src/construction/features/fast_service.rs
@@ -12,8 +12,8 @@ pub struct FastServiceFeatureBuilder {
     violation_code: Option<ViolationCode>,
     demand_type_fn: Option<DemandTypeFn>,
     is_filtered_job_fn: Option<IsFilteredJobFn>,
-    transport: Option<Arc<dyn TransportCost + Send + Sync>>,
-    activity: Option<Arc<dyn ActivityCost + Send + Sync>>,
+    transport: Option<Arc<dyn TransportCost>>,
+    activity: Option<Arc<dyn ActivityCost>>,
 }
 
 impl FastServiceFeatureBuilder {
@@ -54,13 +54,13 @@ impl FastServiceFeatureBuilder {
     }
 
     /// Sets transport costs to estimate distance.
-    pub fn set_transport(mut self, transport: Arc<dyn TransportCost + Send + Sync>) -> Self {
+    pub fn set_transport(mut self, transport: Arc<dyn TransportCost>) -> Self {
         self.transport = Some(transport);
         self
     }
 
     /// Sets activity costs to estimate job start/end time.
-    pub fn set_activity(mut self, activity: Arc<dyn ActivityCost + Send + Sync>) -> Self {
+    pub fn set_activity(mut self, activity: Arc<dyn ActivityCost>) -> Self {
         self.activity = Some(activity);
         self
     }
@@ -110,8 +110,8 @@ custom_tour_state!(MultiJobRanges typeof MultiJobRanges);
 struct FastServiceObjective {
     demand_type_fn: DemandTypeFn,
     is_filtered_job_fn: IsFilteredJobFn,
-    transport: Arc<dyn TransportCost + Send + Sync>,
-    activity: Arc<dyn ActivityCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
+    activity: Arc<dyn ActivityCost>,
 }
 
 impl FeatureObjective for FastServiceObjective {
@@ -167,8 +167,8 @@ impl FastServiceObjective {
     fn new(
         demand_type_fn: DemandTypeFn,
         is_filtered_job_fn: IsFilteredJobFn,
-        transport: Arc<dyn TransportCost + Send + Sync>,
-        activity: Arc<dyn ActivityCost + Send + Sync>,
+        transport: Arc<dyn TransportCost>,
+        activity: Arc<dyn ActivityCost>,
     ) -> Self {
         Self { demand_type_fn, is_filtered_job_fn, transport, activity }
     }
diff --git a/vrp-core/src/construction/features/reachable.rs b/vrp-core/src/construction/features/reachable.rs
index c54fc61ad..58d441a61 100644
--- a/vrp-core/src/construction/features/reachable.rs
+++ b/vrp-core/src/construction/features/reachable.rs
@@ -9,14 +9,14 @@ use std::sync::Arc;
 /// Creates a feature to check reachability of the jobs. It is a hard constraint.
 pub fn create_reachable_feature(
     name: &str,
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
     code: ViolationCode,
 ) -> Result<Feature, GenericError> {
     FeatureBuilder::default().with_name(name).with_constraint(ReachableConstraint { transport, code }).build()
 }
 
 struct ReachableConstraint {
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
     code: ViolationCode,
 }
 
diff --git a/vrp-core/src/construction/features/recharge.rs b/vrp-core/src/construction/features/recharge.rs
index fc801c195..0e454398c 100644
--- a/vrp-core/src/construction/features/recharge.rs
+++ b/vrp-core/src/construction/features/recharge.rs
@@ -17,7 +17,7 @@ use std::sync::Arc;
 pub struct RechargeFeatureBuilder {
     name: String,
     violation_code: Option<ViolationCode>,
-    transport: Option<Arc<dyn TransportCost + Send + Sync>>,
+    transport: Option<Arc<dyn TransportCost>>,
     belongs_to_route_fn: Option<Arc<dyn Fn(&Route, &Job) -> bool + Send + Sync>>,
     is_recharge_single_fn: Option<RechargeSingleFn>,
     distance_limit_fn: Option<RechargeDistanceLimitFn>,
@@ -43,7 +43,7 @@ impl RechargeFeatureBuilder {
     }
 
     /// Sets transport costs to estimate distance.
-    pub fn set_transport(mut self, transport: Arc<dyn TransportCost + Send + Sync>) -> Self {
+    pub fn set_transport(mut self, transport: Arc<dyn TransportCost>) -> Self {
         self.transport = Some(transport);
         self
     }
@@ -171,7 +171,7 @@ custom_activity_state!(RechargeDistance typeof Distance);
 
 struct RechargeableMultiTrip {
     route_intervals: RouteIntervals,
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
     code: ViolationCode,
     distance_limit_fn: RechargeDistanceLimitFn,
     recharge_single_fn: RechargeSingleFn,
diff --git a/vrp-core/src/construction/features/tour_limits.rs b/vrp-core/src/construction/features/tour_limits.rs
index abe5eca69..24dd0b5f2 100644
--- a/vrp-core/src/construction/features/tour_limits.rs
+++ b/vrp-core/src/construction/features/tour_limits.rs
@@ -33,7 +33,7 @@ pub fn create_activity_limit_feature(
 /// This is a hard constraint.
 pub fn create_travel_limit_feature(
     name: &str,
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
     distance_code: ViolationCode,
     duration_code: ViolationCode,
     tour_distance_limit_fn: TravelLimitFn<Distance>,
@@ -86,7 +86,7 @@ impl FeatureConstraint for ActivityLimitConstraint {
 }
 
 struct TravelLimitConstraint {
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
     tour_distance_limit_fn: TravelLimitFn<Distance>,
     tour_duration_limit_fn: TravelLimitFn<Duration>,
     distance_code: ViolationCode,
diff --git a/vrp-core/src/construction/features/transport.rs b/vrp-core/src/construction/features/transport.rs
index 22993256f..de10683fd 100644
--- a/vrp-core/src/construction/features/transport.rs
+++ b/vrp-core/src/construction/features/transport.rs
@@ -17,8 +17,8 @@ use crate::models::solution::Activity;
 /// Provides a way to build different flavors of time window feature.
 pub struct TransportFeatureBuilder {
     name: String,
-    transport: Option<Arc<dyn TransportCost + Send + Sync>>,
-    activity: Option<Arc<dyn ActivityCost + Send + Sync>>,
+    transport: Option<Arc<dyn TransportCost>>,
+    activity: Option<Arc<dyn ActivityCost>>,
     code: Option<ViolationCode>,
     is_constrained: bool,
 }
@@ -44,14 +44,14 @@ impl TransportFeatureBuilder {
     }
 
     /// Sets transport costs to estimate distance.
-    pub fn set_transport_cost(mut self, transport: Arc<dyn TransportCost + Send + Sync>) -> Self {
+    pub fn set_transport_cost(mut self, transport: Arc<dyn TransportCost>) -> Self {
         self.transport = Some(transport);
         self
     }
 
     /// Sets activity costs to estimate job start/end time.
     /// If omitted, then [SimpleActivityCost] is used by default.
-    pub fn set_activity_cost(mut self, activity: Arc<dyn ActivityCost + Send + Sync>) -> Self {
+    pub fn set_activity_cost(mut self, activity: Arc<dyn ActivityCost>) -> Self {
         self.activity = Some(activity);
         self
     }
@@ -117,9 +117,7 @@ impl TransportFeatureBuilder {
         )
     }
 
-    fn get_costs(
-        &mut self,
-    ) -> GenericResult<(Arc<dyn TransportCost + Send + Sync>, Arc<dyn ActivityCost + Send + Sync>)> {
+    fn get_costs(&mut self) -> GenericResult<(Arc<dyn TransportCost>, Arc<dyn ActivityCost>)> {
         let transport = self.transport.take().ok_or_else(|| GenericError::from("transport must be set"))?;
         let activity = self.activity.take().unwrap_or_else(|| Arc::new(SimpleActivityCost::default()));
 
@@ -129,8 +127,8 @@ impl TransportFeatureBuilder {
 
 fn create_feature(
     name: &str,
-    transport: Arc<dyn TransportCost + Send + Sync>,
-    activity: Arc<dyn ActivityCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
+    activity: Arc<dyn ActivityCost>,
     time_window_code: ViolationCode,
     is_constrained: bool,
     fitness_fn: Box<dyn Fn(&InsertionContext) -> f64 + Send + Sync>,
@@ -154,8 +152,8 @@ fn create_feature(
 }
 
 struct TransportConstraint {
-    transport: Arc<dyn TransportCost + Send + Sync>,
-    activity: Arc<dyn ActivityCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
+    activity: Arc<dyn ActivityCost>,
     time_window_code: ViolationCode,
 }
 
@@ -281,8 +279,8 @@ impl FeatureConstraint for TransportConstraint {
 }
 
 struct TransportObjective {
-    activity: Arc<dyn ActivityCost + Send + Sync>,
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    activity: Arc<dyn ActivityCost>,
+    transport: Arc<dyn TransportCost>,
     fitness_fn: Box<dyn Fn(&InsertionContext) -> f64 + Send + Sync>,
 }
 
@@ -365,12 +363,12 @@ impl FeatureObjective for TransportObjective {
 }
 
 struct TransportState {
-    transport: Arc<dyn TransportCost + Send + Sync>,
-    activity: Arc<dyn ActivityCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
+    activity: Arc<dyn ActivityCost>,
 }
 
 impl TransportState {
-    fn new(transport: Arc<dyn TransportCost + Send + Sync>, activity: Arc<dyn ActivityCost + Send + Sync>) -> Self {
+    fn new(transport: Arc<dyn TransportCost>, activity: Arc<dyn ActivityCost>) -> Self {
         Self { transport, activity }
     }
 }
diff --git a/vrp-core/src/construction/heuristics/evaluators.rs b/vrp-core/src/construction/heuristics/evaluators.rs
index f3b44029f..ae0a5df41 100644
--- a/vrp-core/src/construction/heuristics/evaluators.rs
+++ b/vrp-core/src/construction/heuristics/evaluators.rs
@@ -21,7 +21,7 @@ pub struct EvaluationContext<'a> {
     /// A leg selection mode.
     pub leg_selection: &'a LegSelection,
     /// A result selector.
-    pub result_selector: &'a (dyn ResultSelector + Send + Sync),
+    pub result_selector: &'a (dyn ResultSelector),
 }
 
 /// Specifies allowed insertion position in route for the job.
diff --git a/vrp-core/src/construction/heuristics/insertions.rs b/vrp-core/src/construction/heuristics/insertions.rs
index a88487eec..2aaae871b 100644
--- a/vrp-core/src/construction/heuristics/insertions.rs
+++ b/vrp-core/src/construction/heuristics/insertions.rs
@@ -256,10 +256,10 @@ impl InsertionHeuristic {
     pub fn process(
         &self,
         mut insertion_ctx: InsertionContext,
-        job_selector: &(dyn JobSelector + Send + Sync),
-        route_selector: &(dyn RouteSelector + Send + Sync),
+        job_selector: &(dyn JobSelector),
+        route_selector: &(dyn RouteSelector),
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionContext {
         prepare_insertion_ctx(&mut insertion_ctx);
 
diff --git a/vrp-core/src/construction/heuristics/metrics.rs b/vrp-core/src/construction/heuristics/metrics.rs
index b3de67bac..803c58f24 100644
--- a/vrp-core/src/construction/heuristics/metrics.rs
+++ b/vrp-core/src/construction/heuristics/metrics.rs
@@ -266,7 +266,7 @@ fn get_values_from_route_state<'a>(
 }
 
 /// Gets medoid location of given route context.
-fn get_medoid(route_ctx: &RouteContext, transport: &(dyn TransportCost + Send + Sync)) -> Option<usize> {
+fn get_medoid(route_ctx: &RouteContext, transport: &(dyn TransportCost)) -> Option<usize> {
     let profile = &route_ctx.route().actor.vehicle.profile;
     let locations = route_ctx.route().tour.all_activities().map(|activity| activity.place.location).collect::<Vec<_>>();
     locations
diff --git a/vrp-core/src/construction/heuristics/selectors.rs b/vrp-core/src/construction/heuristics/selectors.rs
index 3f10f27f9..cd7c0c77b 100644
--- a/vrp-core/src/construction/heuristics/selectors.rs
+++ b/vrp-core/src/construction/heuristics/selectors.rs
@@ -14,7 +14,7 @@ use std::sync::Arc;
 
 /// On each insertion step, selects a list of routes where jobs can be inserted.
 /// It is up to implementation to decide whether list consists of all possible routes or just some subset.
-pub trait RouteSelector {
+pub trait RouteSelector: Send + Sync {
     /// This method is called before select. It allows to apply some changes on mutable context
     /// before immutable borrowing could happen within select method.
     /// Default implementation simply shuffles existing routes.
@@ -46,7 +46,7 @@ impl RouteSelector for AllRouteSelector {
 
 /// On each insertion step, selects a list of jobs to be inserted.
 /// It is up to implementation to decide whether list consists of all jobs or just some subset.
-pub trait JobSelector {
+pub trait JobSelector: Send + Sync {
     /// This method is called before select. It allows to apply some changes on mutable context
     /// before immutable borrowing could happen within select method.
     /// Default implementation simply shuffles jobs in required collection.
@@ -67,7 +67,7 @@ pub struct AllJobSelector {}
 impl JobSelector for AllJobSelector {}
 
 /// Evaluates insertion.
-pub trait InsertionEvaluator {
+pub trait InsertionEvaluator: Send + Sync {
     /// Evaluates insertion of a single job into given collection of routes.
     fn evaluate_job(
         &self,
@@ -75,7 +75,7 @@ pub trait InsertionEvaluator {
         job: &Job,
         routes: &[&RouteContext],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult;
 
     /// Evaluates insertion of multiple jobs into given route.
@@ -85,7 +85,7 @@ pub trait InsertionEvaluator {
         route_ctx: &RouteContext,
         jobs: &[&Job],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult;
 
     /// Evaluates insertion of a job collection into given collection of routes.
@@ -95,7 +95,7 @@ pub trait InsertionEvaluator {
         jobs: &[&Job],
         routes: &[&RouteContext],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult;
 }
 
@@ -123,7 +123,7 @@ impl PositionInsertionEvaluator {
         jobs: &[&Job],
         routes: &[&RouteContext],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> Vec<InsertionResult> {
         if Self::is_fold_jobs(insertion_ctx) {
             parallel_collect(jobs, |job| self.evaluate_job(insertion_ctx, job, routes, leg_selection, result_selector))
@@ -146,7 +146,7 @@ impl InsertionEvaluator for PositionInsertionEvaluator {
         job: &Job,
         routes: &[&RouteContext],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult {
         let eval_ctx = EvaluationContext { goal: &insertion_ctx.problem.goal, job, leg_selection, result_selector };
 
@@ -161,7 +161,7 @@ impl InsertionEvaluator for PositionInsertionEvaluator {
         route_ctx: &RouteContext,
         jobs: &[&Job],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult {
         jobs.iter().fold(InsertionResult::make_failure(), |acc, job| {
             let eval_ctx = EvaluationContext { goal: &insertion_ctx.problem.goal, job, leg_selection, result_selector };
@@ -175,7 +175,7 @@ impl InsertionEvaluator for PositionInsertionEvaluator {
         jobs: &[&Job],
         routes: &[&RouteContext],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult {
         if Self::is_fold_jobs(insertion_ctx) {
             map_reduce(
@@ -196,7 +196,7 @@ impl InsertionEvaluator for PositionInsertionEvaluator {
 }
 
 /// Insertion result selector.
-pub trait ResultSelector {
+pub trait ResultSelector: Send + Sync {
     /// Selects one insertion result from two to promote as best.
     fn select_insertion(
         &self,
@@ -318,18 +318,18 @@ impl ResultSelector for FarthestResultSelector {
 /// A result selector strategy inspired by "Slack Induction by String Removals for Vehicle
 /// Routing Problems", Jan Christiaens, Greet Vanden Berghe.
 pub struct BlinkResultSelector {
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
     ratio: f64,
 }
 
 impl BlinkResultSelector {
     /// Creates an instance of `BlinkResultSelector`.
-    pub fn new(ratio: f64, random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(ratio: f64, random: Arc<dyn Random>) -> Self {
         Self { random, ratio }
     }
 
     /// Creates an instance of `BlinkResultSelector` with default values.
-    pub fn new_with_defaults(random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new_with_defaults(random: Arc<dyn Random>) -> Self {
         Self::new(0.01, random)
     }
 }
@@ -371,19 +371,19 @@ pub enum ResultSelection {
     Stochastic(ResultSelectorProvider),
 
     /// Returns concrete instance of result selector to be used.
-    Concrete(Box<dyn ResultSelector + Send + Sync>),
+    Concrete(Box<dyn ResultSelector>),
 }
 
 /// Provides way to access one of built-in result selectors non-deterministically.
 pub struct ResultSelectorProvider {
-    inners: Vec<Box<dyn ResultSelector + Send + Sync>>,
+    inners: Vec<Box<dyn ResultSelector>>,
     weights: Vec<usize>,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 }
 
 impl ResultSelectorProvider {
     /// Creates a new instance of `StochasticResultSelectorFn`
-    pub fn new_default(random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new_default(random: Arc<dyn Random>) -> Self {
         Self {
             inners: vec![
                 Box::<BestResultSelector>::default(),
@@ -397,7 +397,7 @@ impl ResultSelectorProvider {
     }
 
     /// Returns random result selector from the list.
-    pub fn pick(&self) -> &(dyn ResultSelector + Send + Sync) {
+    pub fn pick(&self) -> &(dyn ResultSelector) {
         self.inners[self.random.weighted(self.weights.as_slice())].as_ref()
     }
 }
@@ -406,7 +406,7 @@ impl ResultSelectorProvider {
 #[derive(Clone)]
 pub enum LegSelection {
     /// Stochastic mode: depending on route size, not all legs could be selected.
-    Stochastic(Arc<dyn Random + Send + Sync>),
+    Stochastic(Arc<dyn Random>),
     /// Exhaustive mode: all legs are selected.
     Exhaustive,
 }
@@ -447,12 +447,7 @@ impl LegSelection {
     }
 
     /// Returns a sample data for stochastic mode.
-    fn get_sample_data(
-        &self,
-        route_ctx: &RouteContext,
-        job: &Job,
-        skip: usize,
-    ) -> Option<(usize, Arc<dyn Random + Send + Sync>)> {
+    fn get_sample_data(&self, route_ctx: &RouteContext, job: &Job, skip: usize) -> Option<(usize, Arc<dyn Random>)> {
         match self {
             Self::Stochastic(random) => {
                 let gen_usize = |min: i32, max: i32| random.uniform_int(min, max) as usize;
diff --git a/vrp-core/src/models/domain.rs b/vrp-core/src/models/domain.rs
index 012fe4787..39c1f14b3 100644
--- a/vrp-core/src/models/domain.rs
+++ b/vrp-core/src/models/domain.rs
@@ -23,10 +23,10 @@ pub struct Problem {
     pub goal: Arc<GoalContext>,
 
     /// Specifies activity costs.
-    pub activity: Arc<dyn ActivityCost + Send + Sync>,
+    pub activity: Arc<dyn ActivityCost>,
 
     /// Specifies transport costs.
-    pub transport: Arc<dyn TransportCost + Send + Sync>,
+    pub transport: Arc<dyn TransportCost>,
 
     /// Specifies index for storing extra parameters of arbitrary type.
     pub extras: Arc<Extras>,
@@ -131,8 +131,8 @@ pub struct ProblemBuilder {
     #[allow(clippy::type_complexity)]
     group_key_fn: Option<Box<dyn Fn(&[Arc<Actor>]) -> Box<FleetGroupKeyFn>>>,
     goal: Option<Arc<GoalContext>>,
-    activity: Option<Arc<dyn ActivityCost + Send + Sync>>,
-    transport: Option<Arc<dyn TransportCost + Send + Sync>>,
+    activity: Option<Arc<dyn ActivityCost>>,
+    transport: Option<Arc<dyn TransportCost>>,
     extras: Option<Arc<Extras>>,
 }
 
@@ -184,14 +184,14 @@ impl ProblemBuilder {
     /// Adds a transport distance/duration estimation logic. A typical implementation will normally
     /// wrap routing distance/duration matrices.
     /// A required field.
-    pub fn with_transport_cost(mut self, transport: Arc<dyn TransportCost + Send + Sync>) -> Self {
+    pub fn with_transport_cost(mut self, transport: Arc<dyn TransportCost>) -> Self {
         self.transport = Some(transport);
         self
     }
 
     /// Adds an activity service time estimation logic.
     /// An optional field: [SimpleActivityCost] will be used by default.
-    pub fn with_activity_cost(mut self, activity: Arc<dyn ActivityCost + Send + Sync>) -> Self {
+    pub fn with_activity_cost(mut self, activity: Arc<dyn ActivityCost>) -> Self {
         self.activity = Some(activity);
         self
     }
diff --git a/vrp-core/src/models/goal.rs b/vrp-core/src/models/goal.rs
index 3ab46a1fb..8e5d2c673 100644
--- a/vrp-core/src/models/goal.rs
+++ b/vrp-core/src/models/goal.rs
@@ -441,7 +441,7 @@ impl HeuristicObjective for GoalContext {
 }
 
 impl Shuffled for GoalContext {
-    fn get_shuffled(&self, random: &(dyn Random + Send + Sync)) -> Self {
+    fn get_shuffled(&self, random: &(dyn Random)) -> Self {
         const RANDOM_ALTERNATIVE_PROBABILITY: f64 = 0.05;
         const RANDOM_SHUFFLE_PROBABILITY: f64 = 0.001;
 
@@ -465,7 +465,7 @@ impl GoalContext {
         Self { goal, ..self.clone() }
     }
 
-    fn get_shuffled(&self, random: &(dyn Random + Send + Sync)) -> Self {
+    fn get_shuffled(&self, random: &(dyn Random)) -> Self {
         let instance = self.clone();
 
         let mut layers = self.goal.layers.clone();
diff --git a/vrp-core/src/models/problem/builders.rs b/vrp-core/src/models/problem/builders.rs
index b38a98317..3003381db 100644
--- a/vrp-core/src/models/problem/builders.rs
+++ b/vrp-core/src/models/problem/builders.rs
@@ -135,7 +135,7 @@ impl JobPlaceBuilder {
 pub struct MultiBuilder {
     jobs: Vec<Arc<Single>>,
     dimens: Dimensions,
-    permutator: Option<Box<dyn JobPermutation + Send + Sync>>,
+    permutator: Option<Box<dyn JobPermutation>>,
 }
 
 impl MultiBuilder {
@@ -159,7 +159,7 @@ impl MultiBuilder {
 
     /// Sets a permutation logic which tells allowed order of sub-jobs assignment.
     /// If omitted, sub-jobs can be assigned only in the order of addition.
-    pub fn permutation(mut self, permutation: impl JobPermutation + Send + Sync + 'static) -> Self {
+    pub fn permutation(mut self, permutation: impl JobPermutation + 'static) -> Self {
         self.permutator = Some(Box::new(permutation));
         self
     }
diff --git a/vrp-core/src/models/problem/costs.rs b/vrp-core/src/models/problem/costs.rs
index b562ef5f1..901905c20 100644
--- a/vrp-core/src/models/problem/costs.rs
+++ b/vrp-core/src/models/problem/costs.rs
@@ -19,7 +19,7 @@ pub enum TravelTime {
 }
 
 /// Provides the way to get cost information for specific activities done by specific actor.
-pub trait ActivityCost {
+pub trait ActivityCost: Send + Sync {
     /// Returns cost to perform activity.
     fn cost(&self, route: &Route, activity: &Activity, arrival: Timestamp) -> Cost {
         let actor = route.actor.as_ref();
@@ -53,7 +53,7 @@ impl ActivityCost for SimpleActivityCost {
 }
 
 /// Provides the way to get routing information for specific locations and actor.
-pub trait TransportCost {
+pub trait TransportCost: Send + Sync {
     /// Returns time-dependent transport cost between two locations for given actor.
     fn cost(&self, route: &Route, from: Location, to: Location, travel_time: TravelTime) -> Cost {
         let actor = route.actor.as_ref();
@@ -160,9 +160,7 @@ impl TransportFallback for NoFallback {
 
 /// Creates time agnostic or time aware routing costs based on matrix data passed.
 /// Panics at runtime if given route path is not present in matrix data.
-pub fn create_matrix_transport_cost(
-    costs: Vec<MatrixData>,
-) -> Result<Arc<dyn TransportCost + Send + Sync>, GenericError> {
+pub fn create_matrix_transport_cost(costs: Vec<MatrixData>) -> GenericResult<Arc<dyn TransportCost>> {
     create_matrix_transport_cost_with_fallback(costs, NoFallback)
 }
 
@@ -171,7 +169,7 @@ pub fn create_matrix_transport_cost(
 pub fn create_matrix_transport_cost_with_fallback<T: TransportFallback + 'static>(
     costs: Vec<MatrixData>,
     fallback: T,
-) -> Result<Arc<dyn TransportCost + Send + Sync>, GenericError> {
+) -> GenericResult<Arc<dyn TransportCost>> {
     if costs.is_empty() {
         return Err("no matrix data found".into());
     }
diff --git a/vrp-core/src/models/problem/jobs.rs b/vrp-core/src/models/problem/jobs.rs
index 03a96bfe1..4d958f9ea 100644
--- a/vrp-core/src/models/problem/jobs.rs
+++ b/vrp-core/src/models/problem/jobs.rs
@@ -112,7 +112,7 @@ pub struct Multi {
     /// Dimensions which contains extra work requirements.
     pub dimens: Dimensions,
     /// Permutation generator.
-    permutator: Box<dyn JobPermutation + Send + Sync>,
+    permutator: Box<dyn JobPermutation>,
 }
 
 impl Debug for Multi {
@@ -126,7 +126,7 @@ impl Debug for Multi {
 
 /// Defines a trait to work with multi job's permutations. Essentially, it specifies valid combinations
 /// of sub-jobs inside multi-job.
-pub trait JobPermutation {
+pub trait JobPermutation: Send + Sync {
     // TODO fix all implementations to support returning reference
     /// Returns a valid permutation.
     fn get(&self) -> Vec<Vec<usize>>;
@@ -171,7 +171,7 @@ impl Multi {
     pub fn new_shared_with_permutator(
         jobs: Vec<Arc<Single>>,
         dimens: Dimensions,
-        permutator: Box<dyn JobPermutation + Send + Sync>,
+        permutator: Box<dyn JobPermutation>,
     ) -> Arc<Self> {
         Self::bind(Self { jobs, dimens, permutator })
     }
@@ -236,7 +236,7 @@ pub struct Jobs {
 
 impl Jobs {
     /// Creates a new [`Jobs`].
-    pub fn new(fleet: &Fleet, jobs: Vec<Job>, transport: &(dyn TransportCost + Send + Sync)) -> Jobs {
+    pub fn new(fleet: &Fleet, jobs: Vec<Job>, transport: &(dyn TransportCost)) -> Jobs {
         Jobs { jobs: jobs.clone(), index: create_index(fleet, jobs, transport) }
     }
 
@@ -302,11 +302,7 @@ pub fn get_job_locations(job: &Job) -> impl Iterator<Item = Option<Location>> +
 }
 
 /// Creates job index.
-fn create_index(
-    fleet: &Fleet,
-    jobs: Vec<Job>,
-    transport: &(dyn TransportCost + Send + Sync),
-) -> HashMap<usize, JobIndex> {
+fn create_index(fleet: &Fleet, jobs: Vec<Job>, transport: &(dyn TransportCost)) -> HashMap<usize, JobIndex> {
     let avg_profile_costs = get_avg_profile_costs(fleet);
 
     fleet.profiles.iter().fold(HashMap::new(), |mut acc, profile| {
@@ -351,7 +347,7 @@ fn create_index(
 fn get_cost_between_locations(
     profile: &Profile,
     costs: &Costs,
-    transport: &(dyn TransportCost + Send + Sync),
+    transport: &(dyn TransportCost),
     from: Location,
     to: Location,
 ) -> LowPrecisionCost {
@@ -370,7 +366,7 @@ fn get_cost_between_locations(
 fn get_cost_between_job_and_location(
     profile: &Profile,
     costs: &Costs,
-    transport: &(dyn TransportCost + Send + Sync),
+    transport: &(dyn TransportCost),
     job: &Job,
     to: Location,
 ) -> LowPrecisionCost {
@@ -385,7 +381,7 @@ fn get_cost_between_job_and_location(
 fn get_cost_between_jobs(
     profile: &Profile,
     costs: &Costs,
-    transport: &(dyn TransportCost + Send + Sync),
+    transport: &(dyn TransportCost),
     lhs: &Job,
     rhs: &Job,
 ) -> LowPrecisionCost {
diff --git a/vrp-core/src/models/solution/registry.rs b/vrp-core/src/models/solution/registry.rs
index 85ecdabd3..967feda00 100644
--- a/vrp-core/src/models/solution/registry.rs
+++ b/vrp-core/src/models/solution/registry.rs
@@ -12,12 +12,12 @@ pub struct Registry {
     available: HashMap<usize, HashSet<Arc<Actor>>>,
     index: HashMap<Arc<Actor>, usize>,
     all: Vec<Arc<Actor>>,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 }
 
 impl Registry {
     /// Creates a new instance of `Registry`
-    pub fn new(fleet: &Fleet, random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(fleet: &Fleet, random: Arc<dyn Random>) -> Self {
         let index = fleet
             .groups
             .iter()
diff --git a/vrp-core/src/solver/heuristic.rs b/vrp-core/src/solver/heuristic.rs
index bed47d784..a43211a14 100644
--- a/vrp-core/src/solver/heuristic.rs
+++ b/vrp-core/src/solver/heuristic.rs
@@ -214,7 +214,7 @@ impl Input for InsertionContext {
 /// Creates a heuristic operator probability which uses `is_hit` method from passed random object.
 pub fn create_scalar_operator_probability(
     scalar_probability: f64,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 ) -> TargetHeuristicProbability {
     (Box::new(move |_, _| random.is_hit(scalar_probability)), PhantomData)
 }
@@ -224,7 +224,7 @@ pub fn create_context_operator_probability(
     jobs_threshold: usize,
     routes_threshold: usize,
     phases: Vec<(SelectionPhase, f64)>,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 ) -> TargetHeuristicProbability {
     let phases = phases.into_iter().collect::<HashMap<_, _>>();
     (
@@ -272,7 +272,7 @@ mod builder {
         environment: Arc<Environment>,
     ) -> InitialOperators<RefinementContext, GoalContext, InsertionContext> {
         let random = environment.random.clone();
-        let wrap = |recreate: Arc<dyn Recreate + Send + Sync>| Box::new(RecreateInitialOperator::new(recreate));
+        let wrap = |recreate: Arc<dyn Recreate>| Box::new(RecreateInitialOperator::new(recreate));
 
         let mut main: InitialOperators<_, _, _> = vec![
             (wrap(Arc::new(RecreateWithCheapest::new(random.clone()))), 1),
@@ -327,7 +327,7 @@ fn create_diversify_operators(
 ) -> HeuristicDiversifyOperators<RefinementContext, GoalContext, InsertionContext> {
     let random = environment.random.clone();
 
-    let recreates: Vec<(Arc<dyn Recreate + Send + Sync>, usize)> = vec![
+    let recreates: Vec<(Arc<dyn Recreate>, usize)> = vec![
         (Arc::new(RecreateWithSkipBest::new(1, 2, random.clone())), 1),
         (Arc::new(RecreateWithRegret::new(1, 3, random.clone())), 1),
         (Arc::new(RecreateWithPerturbation::new_with_defaults(random.clone())), 1),
@@ -436,7 +436,7 @@ mod statik {
     }
 
     /// Creates default local search operator.
-    pub fn create_default_local_search(random: Arc<dyn Random + Send + Sync>) -> TargetSearchOperator {
+    pub fn create_default_local_search(random: Arc<dyn Random>) -> TargetSearchOperator {
         Arc::new(LocalSearch::new(Arc::new(CompositeLocalOperator::new(
             vec![
                 (Arc::new(ExchangeSwapStar::new(random, SINGLE_HEURISTIC_QUOTA_LIMIT)), 200),
@@ -455,11 +455,8 @@ mod statik {
 mod dynamic {
     use super::*;
 
-    fn get_recreates(
-        problem: &Problem,
-        random: Arc<dyn Random + Send + Sync>,
-    ) -> Vec<(Arc<dyn Recreate + Send + Sync>, String)> {
-        let cheapest: Arc<dyn Recreate + Send + Sync> = Arc::new(RecreateWithCheapest::new(random.clone()));
+    fn get_recreates(problem: &Problem, random: Arc<dyn Random>) -> Vec<(Arc<dyn Recreate>, String)> {
+        let cheapest: Arc<dyn Recreate> = Arc::new(RecreateWithCheapest::new(random.clone()));
         vec![
             (cheapest.clone(), "cheapest".to_string()),
             (Arc::new(RecreateWithSkipBest::new(1, 2, random.clone())), "skip_best".to_string()),
@@ -492,7 +489,7 @@ mod dynamic {
         environment: Arc<Environment>,
         limits: RemovalLimits,
         prefix: &str,
-    ) -> Vec<(Arc<dyn Ruin + Send + Sync>, String, f64)> {
+    ) -> Vec<(Arc<dyn Ruin>, String, f64)> {
         vec![
             (Arc::new(AdjustedStringRemoval::new_with_defaults(limits.clone())), format!("{prefix}_asr"), 2.),
             (Arc::new(NeighbourRemoval::new(limits.clone())), format!("{prefix}_neighbour_removal"), 5.),
@@ -578,7 +575,7 @@ mod dynamic {
         // NOTE we need to wrap any of ruin methods in composite which calls restore context before recreate
         let ruins = ruins
             .into_iter()
-            .map::<(Arc<dyn Ruin + Send + Sync>, String, f64), _>(|(ruin, name, weight)| {
+            .map::<(Arc<dyn Ruin>, String, f64), _>(|(ruin, name, weight)| {
                 (Arc::new(CompositeRuin::new(vec![(ruin, 1.), (extra_random_job.clone(), 0.1)])), name, weight)
             })
             .collect::<Vec<_>>();
@@ -648,7 +645,7 @@ mod dynamic {
         Arc::new(RuinAndRecreate::new(ruin, recreate))
     }
 
-    pub fn create_default_local_search(random: Arc<dyn Random + Send + Sync>) -> Arc<LocalSearch> {
+    pub fn create_default_local_search(random: Arc<dyn Random>) -> Arc<LocalSearch> {
         Arc::new(LocalSearch::new(Arc::new(CompositeLocalOperator::new(
             vec![
                 (Arc::new(ExchangeSwapStar::new(random, SINGLE_HEURISTIC_QUOTA_LIMIT / 4)), 2),
@@ -666,12 +663,12 @@ mod dynamic {
 fn get_recreate_with_alternative_goal<T, F>(
     original_goal: &GoalContext,
     recreate_fn: F,
-) -> impl Iterator<Item = Arc<dyn Recreate + Send + Sync>> + '_
+) -> impl Iterator<Item = Arc<dyn Recreate>> + '_
 where
     T: Recreate + Send + Sync + 'static,
     F: Fn() -> T + 'static,
 {
-    original_goal.get_alternatives().map::<Arc<dyn Recreate + Send + Sync>, _>(move |goal| {
-        Arc::new(RecreateWithGoal::new(Arc::new(goal), recreate_fn()))
-    })
+    original_goal
+        .get_alternatives()
+        .map::<Arc<dyn Recreate>, _>(move |goal| Arc::new(RecreateWithGoal::new(Arc::new(goal), recreate_fn())))
 }
diff --git a/vrp-core/src/solver/mod.rs b/vrp-core/src/solver/mod.rs
index 9a6116ec8..c96851524 100644
--- a/vrp-core/src/solver/mod.rs
+++ b/vrp-core/src/solver/mod.rs
@@ -193,12 +193,12 @@ impl Stateful for RefinementContext {
 
 /// Wraps recreate method as `InitialOperator`
 pub struct RecreateInitialOperator {
-    recreate: Arc<dyn Recreate + Send + Sync>,
+    recreate: Arc<dyn Recreate>,
 }
 
 impl RecreateInitialOperator {
     /// Creates a new instance of `RecreateInitialOperator`.
-    pub fn new(recreate: Arc<dyn Recreate + Send + Sync>) -> Self {
+    pub fn new(recreate: Arc<dyn Recreate>) -> Self {
         Self { recreate }
     }
 }
diff --git a/vrp-core/src/solver/search/infeasible_search.rs b/vrp-core/src/solver/search/infeasible_search.rs
index 5401dcddc..a9d1b4145 100644
--- a/vrp-core/src/solver/search/infeasible_search.rs
+++ b/vrp-core/src/solver/search/infeasible_search.rs
@@ -9,7 +9,7 @@ use std::sync::Arc;
 /// A mutation operator which performs search in infeasible space.
 pub struct InfeasibleSearch {
     inner_search: TargetSearchOperator,
-    recovery_operator: Arc<dyn Recreate + Send + Sync>,
+    recovery_operator: Arc<dyn Recreate>,
     max_repeat_count: usize,
     shuffle_objectives_probability: (f64, f64),
     skip_constraint_check_probability: (f64, f64),
@@ -19,7 +19,7 @@ impl InfeasibleSearch {
     /// Creates a new instance of `InfeasibleSearch`.
     pub fn new(
         inner_search: TargetSearchOperator,
-        recovery_operator: Arc<dyn Recreate + Send + Sync>,
+        recovery_operator: Arc<dyn Recreate>,
         max_repeat_count: usize,
         shuffle_objectives_probability: (f64, f64),
         skip_constraint_check_probability: (f64, f64),
@@ -125,7 +125,7 @@ fn create_relaxed_insertion_ctx(
 
 fn create_modified_variant(
     original: &GoalContext,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
     skip_probability: f64,
     shuffle_probability: f64,
 ) -> Arc<GoalContext> {
@@ -156,7 +156,7 @@ fn get_random_individual(new_refinement_ctx: &RefinementContext) -> &InsertionCo
 
 struct StochasticFeatureConstraint {
     inner: Arc<dyn FeatureConstraint>,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
     probability: f64,
 }
 
diff --git a/vrp-core/src/solver/search/local/exchange_inter_route.rs b/vrp-core/src/solver/search/local/exchange_inter_route.rs
index b5cee8015..9c5b41a9a 100644
--- a/vrp-core/src/solver/search/local/exchange_inter_route.rs
+++ b/vrp-core/src/solver/search/local/exchange_inter_route.rs
@@ -177,7 +177,7 @@ fn test_job_insertion(
     route_ctx: &RouteContext,
     job: &Job,
     leg_selection: &LegSelection,
-    result_selector: &(dyn ResultSelector + Send + Sync),
+    result_selector: &(dyn ResultSelector),
 ) -> Option<InsertionSuccess> {
     let eval_ctx = EvaluationContext { goal: &insertion_ctx.problem.goal, job, leg_selection, result_selector };
 
diff --git a/vrp-core/src/solver/search/local/exchange_swap_star.rs b/vrp-core/src/solver/search/local/exchange_swap_star.rs
index bdaf52c0f..91e98d5a0 100644
--- a/vrp-core/src/solver/search/local/exchange_swap_star.rs
+++ b/vrp-core/src/solver/search/local/exchange_swap_star.rs
@@ -24,13 +24,13 @@ use std::iter::once;
 /// For more details, see `<https://arxiv.org/abs/2012.10384>`
 pub struct ExchangeSwapStar {
     leg_selection: LegSelection,
-    result_selector: Box<dyn ResultSelector + Send + Sync>,
+    result_selector: Box<dyn ResultSelector>,
     quota_limit: usize,
 }
 
 impl ExchangeSwapStar {
     /// Creates a new instance of `ExchangeSwapStar`.
-    pub fn new(random: Arc<dyn Random + Send + Sync>, quota_limit: usize) -> Self {
+    pub fn new(random: Arc<dyn Random>, quota_limit: usize) -> Self {
         Self {
             leg_selection: LegSelection::Stochastic(random),
             result_selector: Box::<BestResultSelector>::default(),
@@ -77,7 +77,7 @@ impl LocalOperator for ExchangeSwapStar {
 }
 
 /// Encapsulates common data used by search phase.
-type SearchContext<'a> = (&'a InsertionContext, &'a LegSelection, &'a (dyn ResultSelector + Send + Sync));
+type SearchContext<'a> = (&'a InsertionContext, &'a LegSelection, &'a (dyn ResultSelector));
 
 fn get_route_by_idx(insertion_ctx: &InsertionContext, route_idx: usize) -> &RouteContext {
     insertion_ctx.solution.routes.get(route_idx).expect("invalid route index")
@@ -293,7 +293,7 @@ fn try_exchange_jobs_in_routes(
     insertion_ctx: &mut InsertionContext,
     route_pair: (usize, usize),
     leg_selection: &LegSelection,
-    result_selector: &(dyn ResultSelector + Send + Sync),
+    result_selector: &(dyn ResultSelector),
 ) -> bool {
     let quota = insertion_ctx.environment.quota.clone();
     let is_quota_reached = move || quota.as_ref().map_or(false, |quota| quota.is_reached());
@@ -374,7 +374,7 @@ fn try_exchange_jobs(
     insertion_ctx: &mut InsertionContext,
     insertion_pair: (InsertionResult, InsertionResult),
     leg_selection: &LegSelection,
-    result_selector: &(dyn ResultSelector + Send + Sync),
+    result_selector: &(dyn ResultSelector),
 ) {
     if let (InsertionResult::Success(outer_success), InsertionResult::Success(inner_success)) = insertion_pair {
         let constraint = insertion_ctx.problem.goal.clone();
diff --git a/vrp-core/src/solver/search/local/mod.rs b/vrp-core/src/solver/search/local/mod.rs
index 6461def5e..a1960fcec 100644
--- a/vrp-core/src/solver/search/local/mod.rs
+++ b/vrp-core/src/solver/search/local/mod.rs
@@ -22,7 +22,7 @@ mod reschedule_departure;
 pub use self::reschedule_departure::*;
 
 /// Specifies behavior of a local search operator.
-pub trait LocalOperator {
+pub trait LocalOperator: Send + Sync {
     /// Applies local search operator to passed solution in order to explore possible
     /// small move in solution space which leads to a different solution.
     fn explore(&self, refinement_ctx: &RefinementContext, insertion_ctx: &InsertionContext)
@@ -31,14 +31,14 @@ pub trait LocalOperator {
 
 /// Provides the way to run multiple local search operators with different probability.
 pub struct CompositeLocalOperator {
-    operators: Vec<Arc<dyn LocalOperator + Send + Sync>>,
+    operators: Vec<Arc<dyn LocalOperator>>,
     weights: Vec<usize>,
     times: (i32, i32),
 }
 
 impl CompositeLocalOperator {
     /// Creates a new instance of `CompositeLocalOperator`.
-    pub fn new(operators: Vec<(Arc<dyn LocalOperator + Send + Sync>, usize)>, min: usize, max: usize) -> Self {
+    pub fn new(operators: Vec<(Arc<dyn LocalOperator>, usize)>, min: usize, max: usize) -> Self {
         let weights = operators.iter().map(|(_, weight)| *weight).collect();
         let operators = operators.into_iter().map(|(operator, _)| operator).collect();
 
diff --git a/vrp-core/src/solver/search/local_search.rs b/vrp-core/src/solver/search/local_search.rs
index c22301cde..6614100b6 100644
--- a/vrp-core/src/solver/search/local_search.rs
+++ b/vrp-core/src/solver/search/local_search.rs
@@ -7,12 +7,12 @@ use std::sync::Arc;
 
 /// A mutation operator which applies local search principles.
 pub struct LocalSearch {
-    operator: Arc<dyn LocalOperator + Send + Sync>,
+    operator: Arc<dyn LocalOperator>,
 }
 
 impl LocalSearch {
     /// Creates a new instance of `LocalSearch`.
-    pub fn new(operator: Arc<dyn LocalOperator + Send + Sync>) -> Self {
+    pub fn new(operator: Arc<dyn LocalOperator>) -> Self {
         Self { operator }
     }
 }
diff --git a/vrp-core/src/solver/search/recreate/mod.rs b/vrp-core/src/solver/search/recreate/mod.rs
index dade3d9f9..828520333 100644
--- a/vrp-core/src/solver/search/recreate/mod.rs
+++ b/vrp-core/src/solver/search/recreate/mod.rs
@@ -9,7 +9,7 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 /// A trait which specifies logic to produce a new feasible solution from partial one.
-pub trait Recreate {
+pub trait Recreate: Send + Sync {
     /// Recreates a new solution from the given.
     fn run(&self, refinement_ctx: &RefinementContext, insertion_ctx: InsertionContext) -> InsertionContext;
 }
@@ -46,13 +46,13 @@ pub use self::recreate_with_slice::RecreateWithSlice;
 
 /// Provides the way to run one of multiple recreate methods.
 pub struct WeightedRecreate {
-    recreates: Vec<Arc<dyn Recreate + Send + Sync>>,
+    recreates: Vec<Arc<dyn Recreate>>,
     weights: Vec<usize>,
 }
 
 impl WeightedRecreate {
     /// Creates a new instance of `WeightedRecreate` using list of recreate strategies.
-    pub fn new(recreates: Vec<(Arc<dyn Recreate + Send + Sync>, usize)>) -> Self {
+    pub fn new(recreates: Vec<(Arc<dyn Recreate>, usize)>) -> Self {
         let (recreates, weights) = recreates.into_iter().unzip();
         Self { recreates, weights }
     }
@@ -67,8 +67,8 @@ impl Recreate for WeightedRecreate {
 
 /// Provides way to reuse generic behaviour.
 pub struct ConfigurableRecreate {
-    job_selector: Box<dyn JobSelector + Send + Sync>,
-    route_selector: Box<dyn RouteSelector + Send + Sync>,
+    job_selector: Box<dyn JobSelector>,
+    route_selector: Box<dyn RouteSelector>,
     leg_selection: LegSelection,
     result_selection: ResultSelection,
     insertion_heuristic: InsertionHeuristic,
@@ -77,8 +77,8 @@ pub struct ConfigurableRecreate {
 impl ConfigurableRecreate {
     /// Creates a new instance of `ConfigurableRecreate`.
     pub fn new(
-        job_selector: Box<dyn JobSelector + Send + Sync>,
-        route_selector: Box<dyn RouteSelector + Send + Sync>,
+        job_selector: Box<dyn JobSelector>,
+        route_selector: Box<dyn RouteSelector>,
         leg_selection: LegSelection,
         result_selection: ResultSelection,
         insertion_heuristic: InsertionHeuristic,
@@ -106,12 +106,12 @@ impl Recreate for ConfigurableRecreate {
 
 /// Provides way to use different recreate methods on different selection phases.
 pub struct PhasedRecreate {
-    recreates: HashMap<SelectionPhase, Arc<dyn Recreate + Send + Sync>>,
+    recreates: HashMap<SelectionPhase, Arc<dyn Recreate>>,
 }
 
 impl PhasedRecreate {
     /// Creates a new instance of `PhasedRecreate`.
-    pub fn new(recreates: HashMap<SelectionPhase, Arc<dyn Recreate + Send + Sync>>) -> Self {
+    pub fn new(recreates: HashMap<SelectionPhase, Arc<dyn Recreate>>) -> Self {
         assert!([SelectionPhase::Initial, SelectionPhase::Exploration, SelectionPhase::Exploitation]
             .iter()
             .all(|key| recreates.contains_key(key)));
@@ -126,19 +126,19 @@ impl Recreate for PhasedRecreate {
     }
 }
 
-pub(crate) struct RecreateWithGoal<T: Recreate + Send + Sync> {
+pub(crate) struct RecreateWithGoal<T: Recreate> {
     goal: Arc<GoalContext>,
     inner: T,
 }
 
-impl<T: Recreate + Send + Sync> RecreateWithGoal<T> {
+impl<T: Recreate> RecreateWithGoal<T> {
     /// Creates a new instance of `RecreateWithGoal`.
     pub fn new(goal: Arc<GoalContext>, inner: T) -> Self {
         Self { goal, inner }
     }
 }
 
-impl<T: Recreate + Send + Sync> Recreate for RecreateWithGoal<T> {
+impl<T: Recreate> Recreate for RecreateWithGoal<T> {
     fn run(&self, refinement_ctx: &RefinementContext, insertion_ctx: InsertionContext) -> InsertionContext {
         let problem = insertion_ctx.problem.clone();
 
diff --git a/vrp-core/src/solver/search/recreate/recreate_with_blinks.rs b/vrp-core/src/solver/search/recreate/recreate_with_blinks.rs
index 6812bd541..5a8449010 100644
--- a/vrp-core/src/solver/search/recreate/recreate_with_blinks.rs
+++ b/vrp-core/src/solver/search/recreate/recreate_with_blinks.rs
@@ -62,20 +62,17 @@ impl JobSelector for RankedJobSelector {
 /// A recreate method as described in "Slack Induction by String Removals for
 /// Vehicle Routing Problems" (aka SISR) paper by Jan Christiaens, Greet Vanden Berghe.
 pub struct RecreateWithBlinks {
-    job_selectors: Vec<Box<dyn JobSelector + Send + Sync>>,
-    route_selector: Box<dyn RouteSelector + Send + Sync>,
+    job_selectors: Vec<Box<dyn JobSelector>>,
+    route_selector: Box<dyn RouteSelector>,
     leg_selection: LegSelection,
-    result_selector: Box<dyn ResultSelector + Send + Sync>,
+    result_selector: Box<dyn ResultSelector>,
     insertion_heuristic: InsertionHeuristic,
     weights: Vec<usize>,
 }
 
 impl RecreateWithBlinks {
     /// Creates a new instance of `RecreateWithBlinks`.
-    pub fn new(
-        selectors: Vec<(Box<dyn JobSelector + Send + Sync>, usize)>,
-        random: Arc<dyn Random + Send + Sync>,
-    ) -> Self {
+    pub fn new(selectors: Vec<(Box<dyn JobSelector>, usize)>, random: Arc<dyn Random>) -> Self {
         let weights = selectors.iter().map(|(_, weight)| *weight).collect();
         Self {
             job_selectors: selectors.into_iter().map(|(selector, _)| selector).collect(),
@@ -88,7 +85,7 @@ impl RecreateWithBlinks {
     }
 
     /// Creates a new instance of `RecreateWithBlinks` with default prameters.
-    pub fn new_with_defaults(random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new_with_defaults(random: Arc<dyn Random>) -> Self {
         Self::new(
             vec![
                 (Box::<AllJobSelector>::default(), 10),
diff --git a/vrp-core/src/solver/search/recreate/recreate_with_cheapest.rs b/vrp-core/src/solver/search/recreate/recreate_with_cheapest.rs
index 11ade9f19..891ae4fba 100644
--- a/vrp-core/src/solver/search/recreate/recreate_with_cheapest.rs
+++ b/vrp-core/src/solver/search/recreate/recreate_with_cheapest.rs
@@ -13,7 +13,7 @@ pub struct RecreateWithCheapest {
 
 impl RecreateWithCheapest {
     /// Creates a new instance of `RecreateWithCheapest`.
-    pub fn new(random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(random: Arc<dyn Random>) -> Self {
         Self {
             recreate: ConfigurableRecreate::new(
                 Box::<AllJobSelector>::default(),
diff --git a/vrp-core/src/solver/search/recreate/recreate_with_farthest.rs b/vrp-core/src/solver/search/recreate/recreate_with_farthest.rs
index dd30f2f67..425bbcb6a 100644
--- a/vrp-core/src/solver/search/recreate/recreate_with_farthest.rs
+++ b/vrp-core/src/solver/search/recreate/recreate_with_farthest.rs
@@ -14,7 +14,7 @@ pub struct RecreateWithFarthest {
 
 impl RecreateWithFarthest {
     /// Creates a new instance of `RecreateWithFarthest`.
-    pub fn new(random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(random: Arc<dyn Random>) -> Self {
         Self {
             recreate: ConfigurableRecreate::new(
                 Box::<AllJobSelector>::default(),
diff --git a/vrp-core/src/solver/search/recreate/recreate_with_gaps.rs b/vrp-core/src/solver/search/recreate/recreate_with_gaps.rs
index a8b3b2a9e..5875a7b93 100644
--- a/vrp-core/src/solver/search/recreate/recreate_with_gaps.rs
+++ b/vrp-core/src/solver/search/recreate/recreate_with_gaps.rs
@@ -30,7 +30,7 @@ pub struct RecreateWithGaps {
 
 impl RecreateWithGaps {
     /// Creates a new instance of `RecreateWithGaps`.
-    pub fn new(min_jobs: usize, max_jobs: usize, random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(min_jobs: usize, max_jobs: usize, random: Arc<dyn Random>) -> Self {
         Self {
             recreate: ConfigurableRecreate::new(
                 Box::new(GapsJobSelector { min_jobs, max_jobs }),
diff --git a/vrp-core/src/solver/search/recreate/recreate_with_nearest_neighbor.rs b/vrp-core/src/solver/search/recreate/recreate_with_nearest_neighbor.rs
index de6391ee3..538ad3c0b 100644
--- a/vrp-core/src/solver/search/recreate/recreate_with_nearest_neighbor.rs
+++ b/vrp-core/src/solver/search/recreate/recreate_with_nearest_neighbor.rs
@@ -12,7 +12,7 @@ pub struct RecreateWithNearestNeighbor {
 
 impl RecreateWithNearestNeighbor {
     /// Creates a new instance of `RecreateWithNearestNeighbor`.
-    pub fn new(random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(random: Arc<dyn Random>) -> Self {
         Self {
             recreate: ConfigurableRecreate::new(
                 Box::<AllJobSelector>::default(),
diff --git a/vrp-core/src/solver/search/recreate/recreate_with_perturbation.rs b/vrp-core/src/solver/search/recreate/recreate_with_perturbation.rs
index 3fb0db880..c3034d040 100644
--- a/vrp-core/src/solver/search/recreate/recreate_with_perturbation.rs
+++ b/vrp-core/src/solver/search/recreate/recreate_with_perturbation.rs
@@ -13,7 +13,7 @@ pub struct RecreateWithPerturbation {
 
 impl RecreateWithPerturbation {
     /// Creates a new instance of `RecreateWithPerturbation`.
-    pub fn new(noise: Noise, random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(noise: Noise, random: Arc<dyn Random>) -> Self {
         Self {
             recreate: ConfigurableRecreate::new(
                 Box::<AllJobSelector>::default(),
@@ -26,7 +26,7 @@ impl RecreateWithPerturbation {
     }
 
     /// Creates a new instance of `RecreateWithPerturbation` with default values.
-    pub fn new_with_defaults(random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new_with_defaults(random: Arc<dyn Random>) -> Self {
         Self::new(Noise::new_with_ratio(0.05, (-0.25, 0.25), random.clone()), random)
     }
 }
diff --git a/vrp-core/src/solver/search/recreate/recreate_with_regret.rs b/vrp-core/src/solver/search/recreate/recreate_with_regret.rs
index 1e4e55175..52599be85 100644
--- a/vrp-core/src/solver/search/recreate/recreate_with_regret.rs
+++ b/vrp-core/src/solver/search/recreate/recreate_with_regret.rs
@@ -22,7 +22,7 @@ impl Recreate for RecreateWithRegret {
 
 impl RecreateWithRegret {
     /// Creates a new instance of `RecreateWithRegret`.
-    pub fn new(min: usize, max: usize, random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(min: usize, max: usize, random: Arc<dyn Random>) -> Self {
         Self {
             recreate: ConfigurableRecreate::new(
                 Box::<AllJobSelector>::default(),
@@ -58,7 +58,7 @@ impl InsertionEvaluator for RegretInsertionEvaluator {
         job: &Job,
         routes: &[&RouteContext],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult {
         self.fallback_evaluator.evaluate_job(insertion_ctx, job, routes, leg_selection, result_selector)
     }
@@ -69,7 +69,7 @@ impl InsertionEvaluator for RegretInsertionEvaluator {
         route_ctx: &RouteContext,
         jobs: &[&Job],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult {
         self.fallback_evaluator.evaluate_route(insertion_ctx, route_ctx, jobs, leg_selection, result_selector)
     }
@@ -80,7 +80,7 @@ impl InsertionEvaluator for RegretInsertionEvaluator {
         jobs: &[&Job],
         routes: &[&RouteContext],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult {
         let regret_index = insertion_ctx.environment.random.uniform_int(self.min as i32, self.max as i32) as usize;
 
diff --git a/vrp-core/src/solver/search/recreate/recreate_with_skip_best.rs b/vrp-core/src/solver/search/recreate/recreate_with_skip_best.rs
index 7c75b15fa..df29a5f83 100644
--- a/vrp-core/src/solver/search/recreate/recreate_with_skip_best.rs
+++ b/vrp-core/src/solver/search/recreate/recreate_with_skip_best.rs
@@ -20,7 +20,7 @@ impl Recreate for RecreateWithSkipBest {
 
 impl RecreateWithSkipBest {
     /// Creates a new instance of `RecreateWithSkipBest`.
-    pub fn new(min: usize, max: usize, random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(min: usize, max: usize, random: Arc<dyn Random>) -> Self {
         Self {
             recreate: ConfigurableRecreate::new(
                 Box::<AllJobSelector>::default(),
@@ -56,7 +56,7 @@ impl InsertionEvaluator for SkipBestInsertionEvaluator {
         job: &Job,
         routes: &[&RouteContext],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult {
         self.fallback_evaluator.evaluate_job(insertion_ctx, job, routes, leg_selection, result_selector)
     }
@@ -67,7 +67,7 @@ impl InsertionEvaluator for SkipBestInsertionEvaluator {
         route_ctx: &RouteContext,
         jobs: &[&Job],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult {
         self.fallback_evaluator.evaluate_route(insertion_ctx, route_ctx, jobs, leg_selection, result_selector)
     }
@@ -78,7 +78,7 @@ impl InsertionEvaluator for SkipBestInsertionEvaluator {
         jobs: &[&Job],
         routes: &[&RouteContext],
         leg_selection: &LegSelection,
-        result_selector: &(dyn ResultSelector + Send + Sync),
+        result_selector: &(dyn ResultSelector),
     ) -> InsertionResult {
         let skip_index = insertion_ctx.environment.random.uniform_int(self.min as i32, self.max as i32);
 
diff --git a/vrp-core/src/solver/search/recreate/recreate_with_skip_random.rs b/vrp-core/src/solver/search/recreate/recreate_with_skip_random.rs
index 2dc1cb470..c13a8d888 100644
--- a/vrp-core/src/solver/search/recreate/recreate_with_skip_random.rs
+++ b/vrp-core/src/solver/search/recreate/recreate_with_skip_random.rs
@@ -14,7 +14,7 @@ pub struct RecreateWithSkipRandom {
 
 impl RecreateWithSkipRandom {
     /// Creates a new instance of `RecreateWithSkipRandom`.
-    pub fn new(random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(random: Arc<dyn Random>) -> Self {
         Self {
             recreate: ConfigurableRecreate::new(
                 Box::<SkipRandomJobSelector>::default(),
@@ -35,10 +35,7 @@ impl Recreate for RecreateWithSkipRandom {
 
 impl RecreateWithSkipRandom {
     /// Creates `RecreateWithSkipRandom` as `PhasedRecreate` which runs only in exploration phase.
-    pub fn default_explorative_phased(
-        default_recreate: Arc<dyn Recreate + Send + Sync>,
-        random: Arc<dyn Random + Send + Sync>,
-    ) -> PhasedRecreate {
+    pub fn default_explorative_phased(default_recreate: Arc<dyn Recreate>, random: Arc<dyn Random>) -> PhasedRecreate {
         let recreates = vec![
             (SelectionPhase::Initial, default_recreate.clone()),
             (SelectionPhase::Exploration, Arc::new(RecreateWithSkipRandom::new(random))),
diff --git a/vrp-core/src/solver/search/recreate/recreate_with_slice.rs b/vrp-core/src/solver/search/recreate/recreate_with_slice.rs
index 1c20e9ba4..dda37b3e1 100644
--- a/vrp-core/src/solver/search/recreate/recreate_with_slice.rs
+++ b/vrp-core/src/solver/search/recreate/recreate_with_slice.rs
@@ -14,7 +14,7 @@ pub struct RecreateWithSlice {
 
 impl RecreateWithSlice {
     /// Creates a new instance of `RecreateWithSlice`.
-    pub fn new(random: Arc<dyn Random + Send + Sync>) -> Self {
+    pub fn new(random: Arc<dyn Random>) -> Self {
         Self {
             recreate: ConfigurableRecreate::new(
                 Box::<SliceJobSelector>::default(),
diff --git a/vrp-core/src/solver/search/redistribute_search.rs b/vrp-core/src/solver/search/redistribute_search.rs
index 46075c46a..35eda4ca1 100644
--- a/vrp-core/src/solver/search/redistribute_search.rs
+++ b/vrp-core/src/solver/search/redistribute_search.rs
@@ -17,12 +17,12 @@ use std::sync::Arc;
 /// the same routes again.
 /// The main idea is to introduce a bit more diversity in the population.
 pub struct RedistributeSearch {
-    recreate: Arc<dyn Recreate + Send + Sync>,
+    recreate: Arc<dyn Recreate>,
 }
 
 impl RedistributeSearch {
     /// Creates a new instance of `RedistributeSearch`.
-    pub fn new(recreate: Arc<dyn Recreate + Send + Sync>) -> Self {
+    pub fn new(recreate: Arc<dyn Recreate>) -> Self {
         Self { recreate }
     }
 }
diff --git a/vrp-core/src/solver/search/ruin/adjusted_string_removal.rs b/vrp-core/src/solver/search/ruin/adjusted_string_removal.rs
index cd44facec..4207cd386 100644
--- a/vrp-core/src/solver/search/ruin/adjusted_string_removal.rs
+++ b/vrp-core/src/solver/search/ruin/adjusted_string_removal.rs
@@ -41,7 +41,7 @@ impl AdjustedStringRemoval {
     }
 
     /// Calculates initial parameters from paper using 5,6,7 equations.
-    fn calculate_limits(&self, routes: &[RouteContext], random: &Arc<dyn Random + Send + Sync>) -> (usize, usize) {
+    fn calculate_limits(&self, routes: &[RouteContext], random: &Arc<dyn Random>) -> (usize, usize) {
         // Equation 5: max removed string cardinality for each tour
         let lsmax = calculate_average_tour_cardinality(routes).min(self.lmax as f64);
 
@@ -115,7 +115,7 @@ fn select_string<'a>(
     seed_tour: (&'a Tour, usize),
     cardinality: usize,
     alpha: f64,
-    random: &Arc<dyn Random + Send + Sync>,
+    random: &Arc<dyn Random>,
 ) -> JobIter<'a> {
     if random.is_head_not_tails() {
         sequential_string(seed_tour, cardinality, random)
@@ -125,11 +125,7 @@ fn select_string<'a>(
 }
 
 /// Selects sequential string.
-fn sequential_string<'a>(
-    seed_tour: (&'a Tour, usize),
-    cardinality: usize,
-    random: &Arc<dyn Random + Send + Sync>,
-) -> JobIter<'a> {
+fn sequential_string<'a>(seed_tour: (&'a Tour, usize), cardinality: usize, random: &Arc<dyn Random>) -> JobIter<'a> {
     let (begin, end) = lower_bounds(cardinality, seed_tour.0.job_activity_count(), seed_tour.1);
     let start = random.uniform_int(begin as i32, end as i32) as usize;
 
@@ -141,7 +137,7 @@ fn preserved_string<'a>(
     seed_tour: (&'a Tour, usize),
     cardinality: usize,
     alpha: f64,
-    random: &Arc<dyn Random + Send + Sync>,
+    random: &Arc<dyn Random>,
 ) -> JobIter<'a> {
     let size = seed_tour.0.job_activity_count();
     let index = seed_tour.1;
@@ -180,12 +176,7 @@ fn lower_bounds(string_crd: usize, tour_crd: usize, index: usize) -> (usize, usi
 }
 
 /// Calculates preserved substring cardinality.
-fn preserved_cardinality(
-    string_crd: usize,
-    tour_crd: usize,
-    alpha: f64,
-    random: &Arc<dyn Random + Send + Sync>,
-) -> usize {
+fn preserved_cardinality(string_crd: usize, tour_crd: usize, alpha: f64, random: &Arc<dyn Random>) -> usize {
     if string_crd == tour_crd {
         return 0;
     }
diff --git a/vrp-core/src/solver/search/ruin/mod.rs b/vrp-core/src/solver/search/ruin/mod.rs
index 8b2a2ceef..6482e8304 100644
--- a/vrp-core/src/solver/search/ruin/mod.rs
+++ b/vrp-core/src/solver/search/ruin/mod.rs
@@ -10,7 +10,7 @@ use std::ops::Range;
 use std::sync::Arc;
 
 /// A trait which specifies logic to destroy parts of solution.
-pub trait Ruin {
+pub trait Ruin: Send + Sync {
     /// Ruins given solution and returns a new one with less jobs assigned.
     fn run(&self, refinement_ctx: &RefinementContext, insertion_ctx: InsertionContext) -> InsertionContext;
 }
@@ -34,7 +34,7 @@ mod worst_jobs_removal;
 pub use self::worst_jobs_removal::WorstJobRemoval;
 
 /// A type which specifies a group of multiple ruin strategies with their probability.
-pub type RuinGroup = (Vec<(Arc<dyn Ruin + Send + Sync>, f64)>, usize);
+pub type RuinGroup = (Vec<(Arc<dyn Ruin>, f64)>, usize);
 
 /// Provides the way to pick one ruin from the group ruin methods.
 pub struct WeightedRuin {
@@ -83,12 +83,12 @@ impl Ruin for WeightedRuin {
 
 /// Provides the way to run multiple ruin methods one by one on the same solution.
 pub struct CompositeRuin {
-    ruins: Vec<(Arc<dyn Ruin + Send + Sync>, f64)>,
+    ruins: Vec<(Arc<dyn Ruin>, f64)>,
 }
 
 impl CompositeRuin {
     /// Creates a new instance of `CompositeRuin` using list of ruin strategies.
-    pub fn new(ruins: Vec<(Arc<dyn Ruin + Send + Sync>, f64)>) -> Self {
+    pub fn new(ruins: Vec<(Arc<dyn Ruin>, f64)>) -> Self {
         Self { ruins }
     }
 }
diff --git a/vrp-core/src/solver/search/ruin/route_removal.rs b/vrp-core/src/solver/search/ruin/route_removal.rs
index 016b0760c..695fd4f71 100644
--- a/vrp-core/src/solver/search/ruin/route_removal.rs
+++ b/vrp-core/src/solver/search/ruin/route_removal.rs
@@ -139,7 +139,7 @@ impl Ruin for WorstRouteRemoval {
 fn remove_routes_with_actors<Iter>(
     solution_ctx: &mut SolutionContext,
     limits: &RemovalLimits,
-    random: &(dyn Random + Send + Sync),
+    random: &(dyn Random),
     actors: Iter,
 ) where
     Iter: Iterator<Item = Arc<Actor>>,
diff --git a/vrp-core/src/solver/search/ruin/worst_jobs_removal.rs b/vrp-core/src/solver/search/ruin/worst_jobs_removal.rs
index d0503ade4..595b3d955 100644
--- a/vrp-core/src/solver/search/ruin/worst_jobs_removal.rs
+++ b/vrp-core/src/solver/search/ruin/worst_jobs_removal.rs
@@ -114,7 +114,7 @@ fn get_cost_savings(
     start: &Activity,
     middle: &Activity,
     end: &Activity,
-    transport: &Arc<dyn TransportCost + Send + Sync>,
+    transport: &Arc<dyn TransportCost>,
 ) -> Cost {
     let actor = route.actor.as_ref();
 
@@ -128,6 +128,6 @@ fn get_cost_savings(
 }
 
 #[inline(always)]
-fn get_cost(route: &Route, from: &Activity, to: &Activity, transport: &Arc<dyn TransportCost + Send + Sync>) -> Cost {
+fn get_cost(route: &Route, from: &Activity, to: &Activity, transport: &Arc<dyn TransportCost>) -> Cost {
     transport.cost(route, from.place.location, to.place.location, TravelTime::Departure(from.schedule.departure))
 }
diff --git a/vrp-core/src/solver/search/ruin_recreate.rs b/vrp-core/src/solver/search/ruin_recreate.rs
index b7bd73bdb..80ab155b2 100644
--- a/vrp-core/src/solver/search/ruin_recreate.rs
+++ b/vrp-core/src/solver/search/ruin_recreate.rs
@@ -7,13 +7,13 @@ use std::sync::Arc;
 
 /// A mutation operator based on ruin and recreate principle.
 pub struct RuinAndRecreate {
-    ruin: Arc<dyn Ruin + Send + Sync>,
-    recreate: Arc<dyn Recreate + Send + Sync>,
+    ruin: Arc<dyn Ruin>,
+    recreate: Arc<dyn Recreate>,
 }
 
 impl RuinAndRecreate {
     /// Creates a new instance of `RuinAndRecreate` using given ruin and recreate methods.
-    pub fn new(ruin: Arc<dyn Ruin + Send + Sync>, recreate: Arc<dyn Recreate + Send + Sync>) -> Self {
+    pub fn new(ruin: Arc<dyn Ruin>, recreate: Arc<dyn Recreate>) -> Self {
         Self { ruin, recreate }
     }
 }
diff --git a/vrp-core/src/solver/search/utils/removal.rs b/vrp-core/src/solver/search/utils/removal.rs
index 6dd1dcfc1..9aa3fd7bf 100644
--- a/vrp-core/src/solver/search/utils/removal.rs
+++ b/vrp-core/src/solver/search/utils/removal.rs
@@ -21,7 +21,7 @@ pub struct JobRemovalTracker {
 
 impl JobRemovalTracker {
     /// Creates a new instance of `JobRemoval`.
-    pub fn new(limits: &RemovalLimits, random: &(dyn Random + Send + Sync)) -> Self {
+    pub fn new(limits: &RemovalLimits, random: &(dyn Random)) -> Self {
         Self {
             activities_left: random
                 .uniform_int(limits.removed_activities_range.start as i32, limits.removed_activities_range.end as i32),
@@ -81,7 +81,7 @@ impl JobRemovalTracker {
         &mut self,
         solution: &mut SolutionContext,
         route_idx: usize,
-        random: &(dyn Random + Send + Sync),
+        random: &(dyn Random),
     ) -> bool {
         if self.routes_left == 0 || self.activities_left == 0 {
             return false;
@@ -96,12 +96,7 @@ impl JobRemovalTracker {
         }
     }
 
-    fn can_remove_full_route(
-        &self,
-        solution: &SolutionContext,
-        route_idx: usize,
-        random: &(dyn Random + Send + Sync),
-    ) -> bool {
+    fn can_remove_full_route(&self, solution: &SolutionContext, route_idx: usize, random: &(dyn Random)) -> bool {
         let route_ctx = solution.routes.get(route_idx).expect("invalid route index");
 
         // check locked jobs
@@ -148,7 +143,7 @@ impl JobRemovalTracker {
         &mut self,
         solution: &mut SolutionContext,
         route_idx: usize,
-        random: &(dyn Random + Send + Sync),
+        random: &(dyn Random),
     ) -> bool {
         let locked = solution.locked.clone();
         let route_ctx = solution.routes.get(route_idx).expect("invalid route index");
diff --git a/vrp-core/src/solver/search/utils/selection.rs b/vrp-core/src/solver/search/utils/selection.rs
index 31cb3a27d..b670aaf79 100644
--- a/vrp-core/src/solver/search/utils/selection.rs
+++ b/vrp-core/src/solver/search/utils/selection.rs
@@ -44,7 +44,7 @@ pub(crate) fn select_seed_job_with_tabu_list(
 /// Selects seed job from existing solution
 pub(crate) fn select_seed_job(
     routes: &[RouteContext],
-    random: &(dyn Random + Send + Sync),
+    random: &(dyn Random),
     route_filter: &(dyn Fn(&RouteContext) -> bool),
     job_filter: &(dyn Fn(&Job) -> bool),
 ) -> Option<(Profile, usize, Job)> {
@@ -76,7 +76,7 @@ pub(crate) fn select_seed_job(
 
 fn select_random_job(
     route_ctx: &RouteContext,
-    random: &(dyn Random + Send + Sync),
+    random: &(dyn Random),
     job_filter: &(dyn Fn(&Job) -> bool),
 ) -> Option<Job> {
     let size = route_ctx.route().tour.job_activity_count();
diff --git a/vrp-core/src/solver/search/utils/tabu_list.rs b/vrp-core/src/solver/search/utils/tabu_list.rs
index e506d8e12..96762b670 100644
--- a/vrp-core/src/solver/search/utils/tabu_list.rs
+++ b/vrp-core/src/solver/search/utils/tabu_list.rs
@@ -15,7 +15,7 @@ pub struct TabuList {
     jobs: HashSet<Job>,
     max_actors: usize,
     max_jobs: usize,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 }
 
 impl TabuList {
@@ -77,7 +77,7 @@ fn add_with_limits<T: Clone + Eq + PartialEq + Hash>(
     new_item: T,
     old_items: &mut HashSet<T>,
     limits: usize,
-    random: &(dyn Random + Send + Sync),
+    random: &(dyn Random),
 ) {
     // NOTE do not use tabu list when limit is zero
     if limits == 0 {
diff --git a/vrp-core/src/solver/search/utils/termination.rs b/vrp-core/src/solver/search/utils/termination.rs
index 05a6d9f84..b5947fabb 100644
--- a/vrp-core/src/solver/search/utils/termination.rs
+++ b/vrp-core/src/solver/search/utils/termination.rs
@@ -3,7 +3,7 @@ use rosomaxa::utils::*;
 use std::sync::Arc;
 
 struct CompositeTimeQuota {
-    inner: Arc<dyn Quota + Send + Sync>,
+    inner: Arc<dyn Quota>,
     limit: usize,
     timer: Timer,
 }
diff --git a/vrp-core/tests/helpers/models/domain.rs b/vrp-core/tests/helpers/models/domain.rs
index 7308015bb..5300d7c4c 100644
--- a/vrp-core/tests/helpers/models/domain.rs
+++ b/vrp-core/tests/helpers/models/domain.rs
@@ -4,7 +4,7 @@ use crate::models::problem::JobIdDimension;
 use crate::prelude::*;
 use std::sync::Arc;
 
-pub fn test_random() -> Arc<dyn Random + Send + Sync> {
+pub fn test_random() -> Arc<dyn Random> {
     Arc::new(DefaultRandom::default())
 }
 
diff --git a/vrp-core/tests/helpers/solver/mod.rs b/vrp-core/tests/helpers/solver/mod.rs
index 672ccfd9d..dbc798ec7 100644
--- a/vrp-core/tests/helpers/solver/mod.rs
+++ b/vrp-core/tests/helpers/solver/mod.rs
@@ -104,11 +104,7 @@ pub fn generate_matrix_routes(
     rows: usize,
     cols: usize,
     is_open_vrp: bool,
-    goal_factory: impl FnOnce(
-        Arc<dyn TransportCost + Send + Sync>,
-        Arc<dyn ActivityCost + Send + Sync>,
-        &Extras,
-    ) -> GoalContext,
+    goal_factory: impl FnOnce(Arc<dyn TransportCost>, Arc<dyn ActivityCost>, &Extras) -> GoalContext,
     job_factory: impl Fn(&str, Option<Location>) -> Arc<Single>,
     vehicle_modify: impl Fn(Vehicle) -> Vehicle,
     matrix_modify: impl Fn(Vec<f64>) -> (Vec<f64>, Vec<f64>),
diff --git a/vrp-core/tests/helpers/utils/mod.rs b/vrp-core/tests/helpers/utils/mod.rs
index 54b1e470a..412c96b5f 100644
--- a/vrp-core/tests/helpers/utils/mod.rs
+++ b/vrp-core/tests/helpers/utils/mod.rs
@@ -3,6 +3,6 @@ use std::sync::Arc;
 
 pub mod random;
 
-pub fn create_test_environment_with_random(random: Arc<dyn Random + Send + Sync>) -> Arc<Environment> {
+pub fn create_test_environment_with_random(random: Arc<dyn Random>) -> Arc<Environment> {
     Arc::new(Environment { random, ..Default::default() })
 }
diff --git a/vrp-core/tests/unit/construction/clustering/dbscan_test.rs b/vrp-core/tests/unit/construction/clustering/dbscan_test.rs
index 55ef1db23..09b19ac69 100644
--- a/vrp-core/tests/unit/construction/clustering/dbscan_test.rs
+++ b/vrp-core/tests/unit/construction/clustering/dbscan_test.rs
@@ -19,11 +19,7 @@ fn can_get_max_curvature() {
     assert_eq!(get_max_curvature(values), 2.);
 }
 
-fn goal_factory(
-    _: Arc<dyn TransportCost + Send + Sync>,
-    _: Arc<dyn ActivityCost + Send + Sync>,
-    _: &Extras,
-) -> GoalContext {
+fn goal_factory(_: Arc<dyn TransportCost>, _: Arc<dyn ActivityCost>, _: &Extras) -> GoalContext {
     TestGoalContextBuilder::with_transport_feature().build()
 }
 
@@ -119,7 +115,7 @@ fn can_create_job_clusters_impl(param: (usize, f64), expected: &[Vec<Location>])
         |v| v,
         |_| (vec![0.; 64], create_test_distances()),
     );
-    let random: Arc<dyn Random + Send + Sync> = Arc::new(FakeRandom::new(vec![0, 0], vec![epsilon]));
+    let random: Arc<dyn Random> = Arc::new(FakeRandom::new(vec![0, 0], vec![epsilon]));
 
     let clusters = create_job_clusters(&problem, random.as_ref(), Some(min_points), Some(epsilon))
         .iter()
diff --git a/vrp-core/tests/unit/models/problem/jobs_test.rs b/vrp-core/tests/unit/models/problem/jobs_test.rs
index 96f948aab..d86723687 100644
--- a/vrp-core/tests/unit/models/problem/jobs_test.rs
+++ b/vrp-core/tests/unit/models/problem/jobs_test.rs
@@ -78,7 +78,7 @@ impl TransportCost for FixedTransportCost {
 }
 
 impl FixedTransportCost {
-    pub fn new_shared(duration_cost: f64, distance_cost: f64) -> Arc<dyn TransportCost + Send + Sync> {
+    pub fn new_shared(duration_cost: f64, distance_cost: f64) -> Arc<dyn TransportCost> {
         Arc::new(Self { duration_cost, distance_cost })
     }
 }
@@ -240,7 +240,7 @@ can_handle_negative_distances_durations! {
     case04: (-1., 0.),
 }
 
-fn can_handle_negative_distances_durations_impl(transport_costs: Arc<dyn TransportCost + Send + Sync>) {
+fn can_handle_negative_distances_durations_impl(transport_costs: Arc<dyn TransportCost>) {
     let profile = Profile::default();
     let species = vec![
         TestSingleBuilder::default().id("s0").location(Some(0)).build_as_job_ref(),
diff --git a/vrp-pragmatic/src/format/problem/fleet_reader.rs b/vrp-pragmatic/src/format/problem/fleet_reader.rs
index 855c5f30e..797789627 100644
--- a/vrp-pragmatic/src/format/problem/fleet_reader.rs
+++ b/vrp-pragmatic/src/format/problem/fleet_reader.rs
@@ -27,7 +27,7 @@ pub(super) fn create_transport_costs(
     api_problem: &ApiProblem,
     matrices: &[Matrix],
     coord_index: Arc<CoordIndex>,
-) -> Result<Arc<dyn TransportCost + Sync + Send>, GenericError> {
+) -> GenericResult<Arc<dyn TransportCost>> {
     if !matrices.iter().all(|m| m.profile.is_some()) && !matrices.iter().all(|m| m.profile.is_none()) {
         return Err("all matrices should have profile set or none of them".into());
     }
diff --git a/vrp-pragmatic/src/format/problem/goal_reader.rs b/vrp-pragmatic/src/format/problem/goal_reader.rs
index 292bf40f1..238a110d2 100644
--- a/vrp-pragmatic/src/format/problem/goal_reader.rs
+++ b/vrp-pragmatic/src/format/problem/goal_reader.rs
@@ -385,7 +385,7 @@ fn create_capacity_with_reload_feature<T: LoadOps + SharedResource + Mul<f64, Ou
 fn get_tour_limit_feature(
     name: &str,
     api_problem: &ApiProblem,
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
 ) -> GenericResult<Feature> {
     let (distances, durations) = api_problem
         .fleet
@@ -423,7 +423,7 @@ fn get_tour_limit_feature(
 fn get_recharge_feature(
     name: &str,
     api_problem: &ApiProblem,
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
 ) -> GenericResult<Feature> {
     fn is_recharge_single(single: &Single) -> bool {
         single.dimens.get_job_type().map_or(false, |job_type| job_type == "recharge")
diff --git a/vrp-pragmatic/src/format/problem/job_reader.rs b/vrp-pragmatic/src/format/problem/job_reader.rs
index 9b42cae8e..5714d6a0d 100644
--- a/vrp-pragmatic/src/format/problem/job_reader.rs
+++ b/vrp-pragmatic/src/format/problem/job_reader.rs
@@ -30,7 +30,7 @@ pub(super) fn read_jobs_with_extra_locks(
     fleet: &Fleet,
     transport: &(dyn TransportCost + Sync + Send),
     job_index: &mut JobIndex,
-    random: &Arc<dyn Random + Send + Sync>,
+    random: &Arc<dyn Random>,
 ) -> (Jobs, Vec<Arc<Lock>>) {
     let (mut jobs, mut locks) = read_required_jobs(api_problem, props, coord_index, job_index, random);
     let (conditional_jobs, conditional_locks) = read_conditional_jobs(api_problem, coord_index, job_index);
@@ -108,7 +108,7 @@ fn read_required_jobs(
     props: &ProblemProperties,
     coord_index: &CoordIndex,
     job_index: &mut JobIndex,
-    random: &Arc<dyn Random + Send + Sync>,
+    random: &Arc<dyn Random>,
 ) -> (Vec<Job>, Vec<Arc<Lock>>) {
     let mut jobs = vec![];
     let has_multi_dimens = props.has_multi_dimen_capacity;
@@ -439,12 +439,7 @@ fn get_single_job(job: &ApiJob, single: Single) -> Job {
     Job::Single(Arc::new(single))
 }
 
-fn get_multi_job(
-    job: &ApiJob,
-    singles: Vec<Single>,
-    deliveries_start_index: usize,
-    random: &Arc<dyn Random + Send + Sync>,
-) -> Job {
+fn get_multi_job(job: &ApiJob, singles: Vec<Single>, deliveries_start_index: usize, random: &Arc<dyn Random>) -> Job {
     let mut dimens: Dimensions = Default::default();
     fill_dimens(job, &mut dimens);
 
diff --git a/vrp-pragmatic/src/format/problem/mod.rs b/vrp-pragmatic/src/format/problem/mod.rs
index 2a5caef7e..918647fdb 100644
--- a/vrp-pragmatic/src/format/problem/mod.rs
+++ b/vrp-pragmatic/src/format/problem/mod.rs
@@ -120,8 +120,8 @@ struct ProblemBlocks {
     jobs: Arc<CoreJobs>,
     fleet: Arc<CoreFleet>,
     job_index: Option<Arc<JobIndex>>,
-    transport: Arc<dyn TransportCost + Send + Sync>,
-    activity: Arc<dyn ActivityCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
+    activity: Arc<dyn ActivityCost>,
     locks: Vec<Arc<Lock>>,
     reserved_times_index: ReservedTimesIndex,
 }
diff --git a/vrp-pragmatic/src/format/problem/problem_reader.rs b/vrp-pragmatic/src/format/problem/problem_reader.rs
index 33c895d42..0c535f16a 100644
--- a/vrp-pragmatic/src/format/problem/problem_reader.rs
+++ b/vrp-pragmatic/src/format/problem/problem_reader.rs
@@ -193,7 +193,7 @@ fn get_problem_blocks(
             format!("check matrix routing data: '{err}'"),
         )]
     })?;
-    let activity: Arc<dyn ActivityCost + Send + Sync> = Arc::new(OnlyVehicleActivityCost::default());
+    let activity: Arc<dyn ActivityCost> = Arc::new(OnlyVehicleActivityCost::default());
 
     let (transport, activity) = if reserved_times_index.is_empty() {
         (transport, activity)
@@ -209,14 +209,14 @@ fn get_problem_blocks(
                     format!("check fleet definition: '{err}'"),
                 )]
             })
-            .map::<(Arc<dyn TransportCost + Send + Sync>, Arc<dyn ActivityCost + Send + Sync>), _>(
-                |(transport, activity)| (Arc::new(transport), Arc::new(activity)),
-            )?
+            .map::<(Arc<dyn TransportCost>, Arc<dyn ActivityCost>), _>(|(transport, activity)| {
+                (Arc::new(transport), Arc::new(activity))
+            })?
     };
 
     // TODO pass random from outside as there might be need to have it initialized with seed
     //      at the moment, this random instance is used only by multi job permutation generator
-    let random: Arc<dyn Random + Send + Sync> = Arc::new(DefaultRandom::default());
+    let random: Arc<dyn Random> = Arc::new(DefaultRandom::default());
     let (jobs, locks) = read_jobs_with_extra_locks(
         api_problem,
         problem_props,
diff --git a/vrp-pragmatic/src/format/solution/initial_reader.rs b/vrp-pragmatic/src/format/solution/initial_reader.rs
index 028b5a73a..6b78b01a5 100644
--- a/vrp-pragmatic/src/format/solution/initial_reader.rs
+++ b/vrp-pragmatic/src/format/solution/initial_reader.rs
@@ -26,7 +26,7 @@ type ActorKey = (String, String, usize);
 pub fn read_init_solution<R: Read>(
     solution: BufReader<R>,
     problem: Arc<Problem>,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 ) -> Result<Solution, GenericError> {
     let solution = deserialize_solution(solution).map_err(|err| format!("cannot deserialize solution: {err}"))?;
 
diff --git a/vrp-pragmatic/tests/helpers/solution.rs b/vrp-pragmatic/tests/helpers/solution.rs
index a04e4fa82..45b3df354 100644
--- a/vrp-pragmatic/tests/helpers/solution.rs
+++ b/vrp-pragmatic/tests/helpers/solution.rs
@@ -461,14 +461,14 @@ pub fn get_ids_from_tour_sorted(tour: &Tour) -> Vec<Vec<String>> {
     ids
 }
 
-pub fn create_random() -> Arc<dyn Random + Send + Sync> {
+pub fn create_random() -> Arc<dyn Random> {
     Arc::new(DefaultRandom::default())
 }
 
 pub fn to_core_solution(
     solution: &Solution,
     core_problem: Arc<CoreProblem>,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 ) -> Result<CoreSolution, GenericError> {
     let mut writer = BufWriter::new(Vec::new());
     serialize_solution(solution, &mut writer).expect("cannot serialize test solution");
diff --git a/vrp-scientific/src/common/initial_reader.rs b/vrp-scientific/src/common/initial_reader.rs
index f38a34e6c..bd454c919 100644
--- a/vrp-scientific/src/common/initial_reader.rs
+++ b/vrp-scientific/src/common/initial_reader.rs
@@ -16,7 +16,7 @@ use vrp_core::prelude::*;
 pub fn read_init_solution<R: Read>(
     mut reader: BufReader<R>,
     problem: Arc<Problem>,
-    random: Arc<dyn Random + Send + Sync>,
+    random: Arc<dyn Random>,
 ) -> Result<Solution, GenericError> {
     let mut buffer = String::new();
 
diff --git a/vrp-scientific/src/common/routing.rs b/vrp-scientific/src/common/routing.rs
index 0068b1b89..7580f0533 100644
--- a/vrp-scientific/src/common/routing.rs
+++ b/vrp-scientific/src/common/routing.rs
@@ -31,7 +31,7 @@ impl CoordIndex {
     }
 
     /// Creates transport.
-    pub fn create_transport(&self, is_rounded: bool) -> Result<Arc<dyn TransportCost + Send + Sync>, GenericError> {
+    pub fn create_transport(&self, is_rounded: bool) -> Result<Arc<dyn TransportCost>, GenericError> {
         let matrix_values = self
             .locations
             .iter()
diff --git a/vrp-scientific/src/common/text_reader.rs b/vrp-scientific/src/common/text_reader.rs
index 1aa6cfa74..55d19dbb4 100644
--- a/vrp-scientific/src/common/text_reader.rs
+++ b/vrp-scientific/src/common/text_reader.rs
@@ -31,12 +31,12 @@ pub(crate) trait TextReader {
     fn create_goal_context(
         &self,
         activity: Arc<SimpleActivityCost>,
-        transport: Arc<dyn TransportCost + Send + Sync>,
+        transport: Arc<dyn TransportCost>,
     ) -> Result<GoalContext, GenericError>;
 
     fn read_definitions(&mut self) -> Result<(Vec<Job>, Fleet), GenericError>;
 
-    fn create_transport(&self, is_rounded: bool) -> Result<Arc<dyn TransportCost + Send + Sync>, GenericError>;
+    fn create_transport(&self, is_rounded: bool) -> Result<Arc<dyn TransportCost>, GenericError>;
 
     fn create_extras(&self) -> Extras;
 }
@@ -104,7 +104,7 @@ pub(crate) fn create_dimens_with_id(
 
 pub(crate) fn create_goal_context_prefer_min_tours(
     activity: Arc<SimpleActivityCost>,
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
     is_time_constrained: bool,
 ) -> GenericResult<GoalContext> {
     let features = get_essential_features(activity, transport, is_time_constrained)?;
@@ -117,7 +117,7 @@ pub(crate) fn create_goal_context_prefer_min_tours(
 
 pub(crate) fn create_goal_context_distance_only(
     activity: Arc<SimpleActivityCost>,
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
     is_time_constrained: bool,
 ) -> Result<GoalContext, GenericError> {
     let features = get_essential_features(activity, transport, is_time_constrained)?;
@@ -130,7 +130,7 @@ pub(crate) fn create_goal_context_distance_only(
 
 fn get_essential_features(
     activity: Arc<SimpleActivityCost>,
-    transport: Arc<dyn TransportCost + Send + Sync>,
+    transport: Arc<dyn TransportCost>,
     is_time_constrained: bool,
 ) -> Result<Vec<Feature>, GenericError> {
     Ok(vec![
diff --git a/vrp-scientific/src/lilim/reader.rs b/vrp-scientific/src/lilim/reader.rs
index b5a7025be..639793095 100644
--- a/vrp-scientific/src/lilim/reader.rs
+++ b/vrp-scientific/src/lilim/reader.rs
@@ -61,7 +61,7 @@ impl<R: Read> TextReader for LilimReader<R> {
     fn create_goal_context(
         &self,
         activity: Arc<SimpleActivityCost>,
-        transport: Arc<dyn TransportCost + Send + Sync>,
+        transport: Arc<dyn TransportCost>,
     ) -> Result<GoalContext, GenericError> {
         let is_time_constrained = true;
         create_goal_context_prefer_min_tours(activity, transport, is_time_constrained)
@@ -74,7 +74,7 @@ impl<R: Read> TextReader for LilimReader<R> {
         Ok((jobs, fleet))
     }
 
-    fn create_transport(&self, is_rounded: bool) -> Result<Arc<dyn TransportCost + Send + Sync>, GenericError> {
+    fn create_transport(&self, is_rounded: bool) -> Result<Arc<dyn TransportCost>, GenericError> {
         self.coord_index.create_transport(is_rounded)
     }
 
diff --git a/vrp-scientific/src/solomon/reader.rs b/vrp-scientific/src/solomon/reader.rs
index 442e32f07..5f6fed428 100644
--- a/vrp-scientific/src/solomon/reader.rs
+++ b/vrp-scientific/src/solomon/reader.rs
@@ -57,7 +57,7 @@ impl<R: Read> TextReader for SolomonReader<R> {
     fn create_goal_context(
         &self,
         activity: Arc<SimpleActivityCost>,
-        transport: Arc<dyn TransportCost + Send + Sync>,
+        transport: Arc<dyn TransportCost>,
     ) -> Result<GoalContext, GenericError> {
         let is_time_constrained = true;
         create_goal_context_prefer_min_tours(activity, transport, is_time_constrained)
@@ -70,7 +70,7 @@ impl<R: Read> TextReader for SolomonReader<R> {
         Ok((jobs, fleet))
     }
 
-    fn create_transport(&self, is_rounded: bool) -> Result<Arc<dyn TransportCost + Send + Sync>, GenericError> {
+    fn create_transport(&self, is_rounded: bool) -> Result<Arc<dyn TransportCost>, GenericError> {
         self.coord_index.create_transport(is_rounded)
     }
 
diff --git a/vrp-scientific/src/tsplib/reader.rs b/vrp-scientific/src/tsplib/reader.rs
index c25cf6560..7f028c2ea 100644
--- a/vrp-scientific/src/tsplib/reader.rs
+++ b/vrp-scientific/src/tsplib/reader.rs
@@ -42,7 +42,7 @@ impl<R: Read> TextReader for TsplibReader<R> {
     fn create_goal_context(
         &self,
         activity: Arc<SimpleActivityCost>,
-        transport: Arc<dyn TransportCost + Send + Sync>,
+        transport: Arc<dyn TransportCost>,
     ) -> Result<GoalContext, GenericError> {
         let is_time_constrained = false;
         create_goal_context_distance_only(activity, transport, is_time_constrained)
@@ -81,7 +81,7 @@ impl<R: Read> TextReader for TsplibReader<R> {
         Ok((jobs, fleet))
     }
 
-    fn create_transport(&self, is_rounded: bool) -> Result<Arc<dyn TransportCost + Send + Sync>, GenericError> {
+    fn create_transport(&self, is_rounded: bool) -> Result<Arc<dyn TransportCost>, GenericError> {
         self.coord_index.create_transport(is_rounded)
     }