diff --git a/serde_v8/Cargo.toml b/serde_v8/Cargo.toml
index 45890870c..ff5a6cc0f 100644
--- a/serde_v8/Cargo.toml
+++ b/serde_v8/Cargo.toml
@@ -28,11 +28,3 @@ serde_v8_utilities = { path = "./utilities" }
 
 [[example]]
 name = "basic"
-
-[[bench]]
-name = "de"
-harness = false
-
-[[bench]]
-name = "ser"
-harness = false
diff --git a/serde_v8/benches/de.rs b/serde_v8/benches/de.rs
deleted file mode 100644
index 46e307e04..000000000
--- a/serde_v8/benches/de.rs
+++ /dev/null
@@ -1,236 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-use bencher::benchmark_group;
-use bencher::benchmark_main;
-use bencher::Bencher;
-
-use serde::Deserialize;
-
-use serde_v8::ByteString;
-use serde_v8_utilities::js_exec;
-use serde_v8_utilities::v8_do;
-
-#[derive(Debug, Deserialize, PartialEq)]
-struct MathOp {
-  arg1: u64,
-  arg2: u64,
-  operator: Option<String>,
-}
-
-fn dedo(
-  code: &str,
-  f: impl FnOnce(&mut v8::HandleScope, v8::Local<v8::Value>),
-) {
-  v8_do(|| {
-    let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
-    let handle_scope = &mut v8::HandleScope::new(isolate);
-    let context = v8::Context::new(handle_scope);
-    let scope = &mut v8::ContextScope::new(handle_scope, context);
-    let v = js_exec(scope, code);
-
-    f(scope, v);
-  })
-}
-
-fn dedo_json(code: &str, f: impl FnOnce(String)) {
-  let code = format!("JSON.stringify({code})");
-  dedo(&code[..], |scope, v| {
-    let s: String = serde_v8::from_v8(scope, v).unwrap();
-    f(s);
-  })
-}
-
-fn de_struct_v8(b: &mut Bencher) {
-  dedo("({arg1: 10, arg2: 123 })", |scope, obj| {
-    let mut total = 0;
-    b.iter(move || {
-      let op: MathOp = serde_v8::from_v8(scope, obj).unwrap();
-      total = total + op.arg1 + op.arg2;
-    });
-  });
-}
-
-fn de_struct_v8_opt(b: &mut Bencher) {
-  dedo("({arg1: 10, arg2: 123 })", |scope, v| {
-    let k_arg1 = v8::String::new(scope, "arg1").unwrap().into();
-    let k_arg2 = v8::String::new(scope, "arg2").unwrap().into();
-    let obj = v8::Local::<v8::Object>::try_from(v).unwrap();
-    let mut total = 0;
-    b.iter(move || {
-      let v_arg1 = obj.get(scope, k_arg1).unwrap();
-      let v_arg2 = obj.get(scope, k_arg2).unwrap();
-      let op = MathOp {
-        arg1: serde_v8::from_v8(scope, v_arg1).unwrap(),
-        arg2: serde_v8::from_v8(scope, v_arg2).unwrap(),
-        operator: None,
-      };
-      total = total + op.arg1 + op.arg2;
-    });
-  });
-}
-
-fn de_struct_json(b: &mut Bencher) {
-  dedo_json("({arg1: 10, arg2: 123 })", |s| {
-    let mut total = 0;
-    b.iter(move || {
-      let op: MathOp = serde_json::from_str(&s).unwrap();
-      total = total + op.arg1 + op.arg2;
-    });
-  });
-}
-
-fn de_struct_json_deopt(b: &mut Bencher) {
-  // JSON.stringify() in loop (semi-simulating ABI loop)
-  dedo("({arg1: 10, arg2: 123 })", |scope, obj| {
-    let mut total = 0;
-    b.iter(move || {
-      let mut scope = v8::HandleScope::new(scope);
-      let s = v8::json::stringify(&mut scope, obj).unwrap();
-      let rs = s.to_rust_string_lossy(&mut scope);
-      let op: MathOp = serde_json::from_str(&rs).unwrap();
-      total = total + op.arg1 + op.arg2;
-    });
-  });
-}
-
-macro_rules! dualbench {
-  ($v8_fn:ident, $json_fn:ident, $src:expr, $t:ty) => {
-    fn $v8_fn(b: &mut Bencher) {
-      dedo($src, |scope, v| {
-        b.iter(move || {
-          let _: $t = serde_v8::from_v8(scope, v).unwrap();
-        });
-      });
-    }
-
-    fn $json_fn(b: &mut Bencher) {
-      dedo_json($src, |s| {
-        b.iter(move || {
-          let _: $t = serde_json::from_str(&s).unwrap();
-        });
-      });
-    }
-  };
-}
-
-dualbench!(de_bool_v8, de_bool_json, "true", bool);
-dualbench!(de_int_v8, de_int_json, "12345", u32);
-dualbench!(
-  de_array_v8,
-  de_array_json,
-  "[1,2,3,4,5,6,7,8,9,10]",
-  Vec<u32>
-);
-dualbench!(de_str_v8, de_str_json, "'hello world'", String);
-dualbench!(de_tuple_v8, de_tuple_json, "[1,false]", (u8, bool));
-
-fn de_tuple_v8_opt(b: &mut Bencher) {
-  dedo("[1,false]", |scope, obj| {
-    let arr = v8::Local::<v8::Array>::try_from(obj).unwrap();
-    let obj = v8::Local::<v8::Object>::from(arr);
-
-    b.iter(move || {
-      let v1 = obj.get_index(scope, 0).unwrap();
-      let v2 = obj.get_index(scope, 1).unwrap();
-      let _: (u8, bool) = (
-        serde_v8::from_v8(scope, v1).unwrap(),
-        serde_v8::from_v8(scope, v2).unwrap(),
-      );
-    });
-  });
-}
-
-fn de_bstr_v8_12_b(b: &mut Bencher) {
-  dedo(r#""hello world\n""#, |scope, v| {
-    b.iter(move || {
-      let _: ByteString = serde_v8::from_v8(scope, v).unwrap();
-    });
-  });
-}
-
-fn de_bstr_v8_1024_b(b: &mut Bencher) {
-  dedo(
-    r#""hello world\n".repeat(1e2).slice(0, 1024)"#,
-    |scope, v| {
-      b.iter(move || {
-        let _: ByteString = serde_v8::from_v8(scope, v).unwrap();
-      });
-    },
-  );
-}
-
-fn de_sob_str_6b(b: &mut Bencher) {
-  dedo("'byebye'", |scope, v| {
-    b.iter(move || {
-      let _: serde_v8::StringOrBuffer = serde_v8::from_v8(scope, v).unwrap();
-    })
-  })
-}
-
-fn de_sob_str_1kb(b: &mut Bencher) {
-  dedo("'deno'.repeat(256)", |scope, v| {
-    b.iter(move || {
-      let _: serde_v8::StringOrBuffer = serde_v8::from_v8(scope, v).unwrap();
-    })
-  })
-}
-
-fn de_sob_buf_1b(b: &mut Bencher) {
-  dedo("new Uint8Array([97])", |scope, v| {
-    b.iter(move || {
-      let _: serde_v8::StringOrBuffer = serde_v8::from_v8(scope, v).unwrap();
-    })
-  })
-}
-
-fn de_sob_buf_1kb(b: &mut Bencher) {
-  dedo("(new Uint8Array(1*1024)).fill(42)", |scope, v| {
-    b.iter(move || {
-      let _: serde_v8::StringOrBuffer = serde_v8::from_v8(scope, v).unwrap();
-    })
-  })
-}
-
-fn de_sob_buf_16kb(b: &mut Bencher) {
-  dedo("(new Uint8Array(16*1024)).fill(42)", |scope, v| {
-    b.iter(move || {
-      let _: serde_v8::StringOrBuffer = serde_v8::from_v8(scope, v).unwrap();
-    })
-  })
-}
-
-fn de_sob_buf_512kb(b: &mut Bencher) {
-  dedo("(new Uint8Array(512*1024)).fill(42)", |scope, v| {
-    b.iter(move || {
-      let _: serde_v8::StringOrBuffer = serde_v8::from_v8(scope, v).unwrap();
-    })
-  })
-}
-
-benchmark_group!(
-  benches,
-  de_struct_v8,
-  de_struct_v8_opt,
-  de_struct_json,
-  de_struct_json_deopt,
-  de_bool_v8,
-  de_bool_json,
-  de_int_v8,
-  de_int_json,
-  de_array_v8,
-  de_array_json,
-  de_str_v8,
-  de_str_json,
-  de_tuple_v8,
-  de_tuple_json,
-  de_tuple_v8_opt,
-  de_bstr_v8_12_b,
-  de_bstr_v8_1024_b,
-  de_sob_str_6b,
-  de_sob_str_1kb,
-  de_sob_buf_1b,
-  de_sob_buf_1kb,
-  de_sob_buf_16kb,
-  de_sob_buf_512kb,
-);
-
-benchmark_main!(benches);
diff --git a/serde_v8/benches/ser.rs b/serde_v8/benches/ser.rs
deleted file mode 100644
index 8423dc456..000000000
--- a/serde_v8/benches/ser.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-use bencher::benchmark_group;
-use bencher::benchmark_main;
-use bencher::Bencher;
-
-use serde::Serialize;
-
-use serde_v8::ByteString;
-use serde_v8_utilities::v8_do;
-
-#[derive(Serialize)]
-struct MathOp {
-  arg1: u64,
-  arg2: u64,
-  operator: Option<String>,
-}
-
-fn serdo(f: impl FnOnce(&mut v8::HandleScope)) {
-  v8_do(|| {
-    let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
-    let handle_scope = &mut v8::HandleScope::new(isolate);
-    let context = v8::Context::new(handle_scope);
-    let scope = &mut v8::ContextScope::new(handle_scope, context);
-
-    f(scope);
-  })
-}
-
-macro_rules! dualbench {
-  ($v8_fn:ident, $json_fn:ident, $src:expr) => {
-    fn $v8_fn(b: &mut Bencher) {
-      serdo(|scope| {
-        let v = $src;
-        b.iter(move || {
-          let _ = serde_v8::to_v8(scope, &v).unwrap();
-        });
-      });
-    }
-
-    fn $json_fn(b: &mut Bencher) {
-      let v = $src;
-      b.iter(move || {
-        let _ = serde_json::to_string(&v).unwrap();
-      });
-    }
-  };
-}
-
-dualbench!(
-  ser_struct_v8,
-  ser_struct_json,
-  MathOp {
-    arg1: 10,
-    arg2: 123,
-    operator: None
-  }
-);
-dualbench!(ser_bool_v8, ser_bool_json, true);
-dualbench!(ser_int_v8, ser_int_json, 12345);
-dualbench!(
-  ser_array_v8,
-  ser_array_json,
-  vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-);
-dualbench!(ser_str_v8, ser_str_json, "hello world");
-dualbench!(ser_tuple_v8, ser_tuple_json, (1, false));
-
-fn ser_struct_v8_manual(b: &mut Bencher) {
-  serdo(|scope| {
-    let v = MathOp {
-      arg1: 10,
-      arg2: 123,
-      operator: None,
-    };
-    b.iter(|| {
-      let obj = v8::Object::new(scope);
-      let k1 = v8::String::new(scope, "arg1").unwrap();
-      let k2 = v8::String::new(scope, "arg2").unwrap();
-      let k3 = v8::String::new(scope, "operator").unwrap();
-      //    let k1 = v8::String::new_from_utf8(scope, "arg1".as_ref(), v8::NewStringType::Internalized).unwrap();
-      //    let k2 = v8::String::new_from_utf8(scope, "arg2".as_ref(), v8::NewStringType::Internalized).unwrap();
-      //    let k3 = v8::String::new_from_utf8(scope, "operator".as_ref(), v8::NewStringType::Internalized).unwrap();
-      let v1 = v8::Number::new(scope, v.arg1 as f64);
-      let v2 = v8::Number::new(scope, v.arg2 as f64);
-      let v3 = v8::null(scope);
-      obj.set(scope, k1.into(), v1.into()).unwrap();
-      obj.set(scope, k2.into(), v2.into()).unwrap();
-      obj.set(scope, k3.into(), v3.into()).unwrap();
-    });
-  });
-}
-
-fn ser_bstr_12_b(b: &mut Bencher) {
-  serdo(|scope| {
-    let bstr = ByteString::from("hello world\n");
-    b.iter(|| {
-      let _ = serde_v8::to_v8(scope, &bstr).unwrap();
-    });
-  });
-}
-
-fn ser_bstr_1024_b(b: &mut Bencher) {
-  serdo(|scope| {
-    let mut s = "hello world\n".repeat(100);
-    s.truncate(1024);
-    let bstr = ByteString::from(s);
-    b.iter(|| {
-      let _ = serde_v8::to_v8(scope, &bstr).unwrap();
-    });
-  });
-}
-
-benchmark_group!(
-  benches,
-  ser_struct_v8,
-  ser_struct_json,
-  ser_bool_v8,
-  ser_bool_json,
-  ser_int_v8,
-  ser_int_json,
-  ser_array_v8,
-  ser_array_json,
-  ser_str_v8,
-  ser_str_json,
-  ser_tuple_v8,
-  ser_tuple_json,
-  ser_struct_v8_manual,
-  ser_bstr_12_b,
-  ser_bstr_1024_b,
-);
-benchmark_main!(benches);