diff --git a/rust/benches/normal/add_bench.rs b/rust/benches/normal/add_bench.rs
index d5434da9..554327e0 100644
--- a/rust/benches/normal/add_bench.rs
+++ b/rust/benches/normal/add_bench.rs
@@ -8,11 +8,14 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[
     ["val", "x"],
     ["push", 5],
@@ -20,22 +23,13 @@ fn bench_vm_execution(c: &mut Criterion) {
     ["add", "i16"],
     ["set", "x"]
   ]"#;
-  vm.load(raw.into());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("add_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let benchmark = vm.tools().bench("add_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(raw.into());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/normal/assign_bench.rs b/rust/benches/normal/assign_bench.rs
index 9dcde579..9bda722f 100644
--- a/rust/benches/normal/assign_bench.rs
+++ b/rust/benches/normal/assign_bench.rs
@@ -8,28 +8,22 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[["val", "x"], ["push", 5], ["set", "x"]]"#;
-  vm.load(raw.into());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("assign_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let benchmark = vm.tools().bench("assign_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(raw.into());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/normal/concat_bench.rs b/rust/benches/normal/concat_bench.rs
index 3dae8715..a060516c 100644
--- a/rust/benches/normal/concat_bench.rs
+++ b/rust/benches/normal/concat_bench.rs
@@ -8,33 +8,27 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[
     ["val", "x"],
     ["push", "Hello from "],
     ["push", "LightVM!"],
     ["set", "x"]
   ]"#;
-  vm.load(raw.into());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("concat_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let benchmark = vm.tools().bench("concat_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(raw.into());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/normal/dead_code_bench.rs b/rust/benches/normal/dead_code_bench.rs
index 18cccd1e..936059b2 100644
--- a/rust/benches/normal/dead_code_bench.rs
+++ b/rust/benches/normal/dead_code_bench.rs
@@ -8,11 +8,14 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[
     ["push", 5],
     ["push", 8],
@@ -21,22 +24,16 @@ fn bench_vm_execution(c: &mut Criterion) {
     ["push", 9],
     ["set", "x"]
   ]"#;
-  vm.load(raw.into());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("dead_code_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let benchmark = vm
+    .tools()
+    .bench("dead_code_bench")
+    .expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(raw.into());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/normal/io_bench.rs b/rust/benches/normal/io_bench.rs
index eba68e04..c48f8127 100644
--- a/rust/benches/normal/io_bench.rs
+++ b/rust/benches/normal/io_bench.rs
@@ -8,31 +8,25 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[["push", "Hello from LightVM!"], ["println"]]"#;
-  vm.load(raw.into());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("io_bench", |b: &mut Bencher| {
-    b.iter(|| {
+  let benchmark = vm.tools().bench("io_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(raw.into());
+      vm
+    },
+    |vm| {
       let _sink = std::io::sink();
       vm.run(None)
-    });
-  });
-  group.finish();
+    },
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/optimize/assign_bench.rs b/rust/benches/optimize/assign_bench.rs
index a6460e88..d9e0838c 100644
--- a/rust/benches/optimize/assign_bench.rs
+++ b/rust/benches/optimize/assign_bench.rs
@@ -8,29 +8,24 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[["val", "x"], ["push", 5], ["set", "x"]]"#;
-  let optimized_json = LightVM::tools().optimize_bytecode(raw);
-  vm.load(optimized_json.clone());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("assign_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let tools = vm.tools();
+  let optimized_json = tools.optimize_bytecode(raw);
+  let benchmark = tools.bench("assign_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(optimized_json.clone());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/optimize/concat_bench.rs b/rust/benches/optimize/concat_bench.rs
index c6bb5d93..a4a54f38 100644
--- a/rust/benches/optimize/concat_bench.rs
+++ b/rust/benches/optimize/concat_bench.rs
@@ -8,34 +8,29 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[
     ["val", "x"],
     ["push", "Hello from "],
     ["push", "LightVM!"],
     ["set", "x"]
   ]"#;
-  let optimized_json = LightVM::tools().optimize_bytecode(raw);
-  vm.load(optimized_json.clone());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("concat_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let tools = vm.tools();
+  let optimized_json = tools.optimize_bytecode(raw);
+  let benchmark = tools.bench("concat_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(optimized_json.clone());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/optimize/dead_code_bench.rs b/rust/benches/optimize/dead_code_bench.rs
index 67428a81..c72db9c8 100644
--- a/rust/benches/optimize/dead_code_bench.rs
+++ b/rust/benches/optimize/dead_code_bench.rs
@@ -8,11 +8,14 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[
     ["push", 5],
     ["push", 8],
@@ -21,23 +24,17 @@ fn bench_vm_execution(c: &mut Criterion) {
     ["push", 9],
     ["set", "x"]
   ]"#;
-  let optimized_json = LightVM::tools().optimize_bytecode(raw);
-  vm.load(optimized_json.clone());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("dead_code_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let tools = vm.tools();
+  let optimized_json = tools.optimize_bytecode(raw);
+  let benchmark = tools
+    .bench("dead_code_bench")
+    .expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(optimized_json.clone());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/optimize/io_bench.rs b/rust/benches/optimize/io_bench.rs
index 839019b9..567486a9 100644
--- a/rust/benches/optimize/io_bench.rs
+++ b/rust/benches/optimize/io_bench.rs
@@ -8,32 +8,27 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[["push", "Hello from LightVM!"], ["println"]]"#;
-  let optimized_json = LightVM::tools().optimize_bytecode(raw);
-  vm.load(optimized_json.clone());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("io_bench", |b: &mut Bencher| {
-    b.iter(|| {
+  let tools = vm.tools();
+  let optimized_json = tools.optimize_bytecode(raw);
+  let benchmark = tools.bench("io_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(optimized_json.clone());
+      vm
+    },
+    |vm| {
       let _sink = std::io::sink();
       vm.run(None)
-    });
-  });
-  group.finish();
+    },
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);