diff --git a/benches/eulerbench.rs b/benches/eulerbench.rs
index 311533b..49608fb 100644
--- a/benches/eulerbench.rs
+++ b/benches/eulerbench.rs
@@ -37,32 +37,32 @@ fn bench_euler_3d(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar euler 3d");
     for size in [10000].iter() {
         group.throughput(Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::Vec3A;
             bench_euler!(b, size, ty => Vec3A, zero => Vec3A::ZERO, dt => Vec3A::splat(UPDATE_RATE))
         });
-        bench_cgmath!(group, size, |b, size| {
+        bench!("cgmath", group, size, |b, size| {
             use cgmath::{prelude::*, Vector3};
             bench_euler!(b, size, ty => Vector3<f32>, zero => Vector3::zero(), dt => UPDATE_RATE)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::Vec3;
             bench_euler!(b, size, ty => Vec3, zero => Vec3::zero(), dt => UPDATE_RATE);
         });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{zero, Vector3};
             bench_euler!(b, size, ty => Vector3<f32>, zero => zero(), dt => UPDATE_RATE);
         });
 
-        bench_euclid!(group, size, |b, size| {
+        bench!("euclid", group, size, |b, size| {
             use euclid::{UnknownUnit, Vector3D};
             bench_euler!(b, size, ty => Vector3D<f32, UnknownUnit>, zero => Vector3D::zero(), dt => UPDATE_RATE);
         });
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::Vec3;
             bench_euler!(b, size, ty => Vec3<f32>, zero => Vec3::zero(), dt => Vec3::broadcast(UPDATE_RATE))
         });
-        bench_pathfinder!(group, size, |b, size| {
+        bench!("pathfinder_geometry" as "pathfinder", group, size, |b, size| {
             use pathfinder_geometry::vector::Vector4F;
             bench_euler!(b, size, ty => Vector4F, zero => Vector4F::splat(0.0), dt => Vector4F::splat(UPDATE_RATE))
         });
@@ -74,28 +74,28 @@ fn bench_euler_3d_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide euler 3d");
     for size in [80000].iter() {
         group.throughput(Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::Vec3A;
             bench_euler!(b, size, ty => Vec3A, zero => Vec3A::ZERO, dt => Vec3A::splat(UPDATE_RATE))
         });
 
         // sse
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::{f32x4, Vec3x4};
             bench_euler!(b, &(size / 4), ty => Vec3x4, zero => Vec3x4::zero(), dt => f32x4::splat(UPDATE_RATE))
         });
-        bench_nalgebra_f32x4!(group, size, |b, size| {
+        bench!("nalgebra_f32x4", group, size, |b, size| {
             use nalgebra::{zero, Vector3};
             use simba::simd::{f32x4, SimdValue};
             bench_euler!(b, &(size / 4), ty => Vector3<f32x4>, zero => zero(), dt => f32x4::splat(UPDATE_RATE));
         });
 
         // avx
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::{f32x8, Vec3x8};
             bench_euler!(b, &(size / 8), ty => Vec3x8, zero => Vec3x8::zero(), dt => f32x8::splat(UPDATE_RATE))
         });
-        bench_nalgebra_f32x8!(group, size, |b, size| {
+        bench!("nalgebra_f32x8", group, size, |b, size| {
             use nalgebra::{zero, Vector3};
             use simba::simd::{f32x8, SimdValue};
             bench_euler!(b, &(size / 8), ty => Vector3<f32x8>, zero => zero(), dt => f32x8::splat(UPDATE_RATE));
@@ -108,32 +108,32 @@ fn bench_euler_2d(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar euler 2d");
     for size in [10000].iter() {
         group.throughput(Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::Vec2;
             bench_euler!(b, size, ty => Vec2, zero => Vec2::ZERO, dt => Vec2::splat(UPDATE_RATE))
         });
-        bench_cgmath!(group, size, |b, size| {
+        bench!("cgmath", group, size, |b, size| {
             use cgmath::{prelude::*, Vector2};
             bench_euler!(b, size, ty => Vector2<f32>, zero => Vector2::zero(), dt => UPDATE_RATE)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::Vec2;
             bench_euler!(b, size, ty => Vec2, zero => Vec2::zero(), dt => UPDATE_RATE);
         });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{zero, Vector2};
             bench_euler!(b, size, ty => Vector2<f32>, zero => zero(), dt => UPDATE_RATE);
         });
 
-        bench_euclid!(group, size, |b, size| {
+        bench!("euclid", group, size, |b, size| {
             use euclid::{UnknownUnit, Vector2D};
             bench_euler!(b, size, ty => Vector2D<f32, UnknownUnit>, zero => Vector2D::zero(), dt => UPDATE_RATE);
         });
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::Vec2;
             bench_euler!(b, size, ty => Vec2<f32>, zero => Vec2::zero(), dt => Vec2::broadcast(UPDATE_RATE))
         });
-        bench_pathfinder!(group, size, |b, size| {
+        bench!("pathfinder_geometry" as "pathfinder", group, size, |b, size| {
             use pathfinder_geometry::vector::Vector2F;
             bench_euler!(b, size, ty => Vector2F, zero => Vector2F::splat(0.0), dt => Vector2F::splat(UPDATE_RATE))
         });
@@ -145,27 +145,27 @@ fn bench_euler_2d_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide euler 2d");
     for size in [80000].iter() {
         group.throughput(Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::Vec2;
             bench_euler!(b, size, ty => Vec2, zero => Vec2::ZERO, dt => Vec2::splat(UPDATE_RATE))
         });
 
         // sse
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::{f32x4, Vec2x4};
             bench_euler!(b, &(size / 4), ty => Vec2x4, zero => Vec2x4::zero(), dt => f32x4::splat(UPDATE_RATE))
         });
-        bench_nalgebra_f32x4!(group, size, |b, size| {
+        bench!("nalgebra_f32x4", group, size, |b, size| {
             use nalgebra::{zero, Vector2};
             use simba::simd::{f32x4, SimdValue};
             bench_euler!(b, &(size / 4), ty => Vector2<f32x4>, zero => zero(), dt => f32x4::splat(UPDATE_RATE));
         });
         // avx
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::{f32x8, Vec2x8};
             bench_euler!(b, &(size / 8), ty => Vec2x8, zero => Vec2x8::zero(), dt => f32x8::splat(UPDATE_RATE))
         });
-        bench_nalgebra_f32x8!(group, size, |b, size| {
+        bench!("nalgebra_f32x8", group, size, |b, size| {
             use nalgebra::{zero, Vector2};
             use simba::simd::{f32x8, SimdValue};
             bench_euler!(b, &(size / 8), ty => Vector2<f32x8>, zero => zero(), dt => f32x8::splat(UPDATE_RATE));
diff --git a/benches/matrix2.rs b/benches/matrix2.rs
index 13d4958..6913926 100644
--- a/benches/matrix2.rs
+++ b/benches/matrix2.rs
@@ -9,28 +9,28 @@ use std::ops::Mul;
 // returns self to check overhead of benchmark
 fn bench_matrix2_ret_self(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix2 return self");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat2;
         bench_unop!(b, op => ret_self, ty => Mat2)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Matrix2;
         bench_unop!(b, op => ret_self, ty => Matrix2<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat2;
         bench_unop!(b, op => ret_self, ty => Mat2)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix2;
         bench_unop!(b, op => ret_self, ty => Matrix2<f32>)
     });
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat2;
         bench_unop!(b, op => ret_self, ty => Mat2<f32>)
     });
 
-    bench_pathfinder!(group, |b| {
+    bench!("pathfinder_geometry" as "pathfinder", group, |b| {
         use pathfinder_geometry::transform2d::Matrix2x2F;
         bench_unop!(b, op => ret_self, ty => Matrix2x2F)
     });
@@ -41,24 +41,24 @@ fn bench_matrix2_ret_self_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide matrix2 return self");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat2;
         bench_unop_wide!(b, size, width => 1, op => ret_self, ty => Mat2)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat2x4;
         bench_unop_wide!(b, size, width => 4, op => ret_self, ty => Mat2x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Matrix2;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => ret_self, ty => Matrix2<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat2x8;
         bench_unop_wide!(b, size, width => 8, op => ret_self, ty => Mat2x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Matrix2;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => ret_self, ty => Matrix2<f32x8>)
@@ -68,24 +68,24 @@ fn bench_matrix2_ret_self_wide(c: &mut Criterion) {
 
 fn bench_matrix2_transpose(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix2 transpose");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat2;
         bench_unop!(b, op => transpose, ty => Mat2)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{prelude::*, Matrix2};
         bench_unop!(b, op => transpose, ty => Matrix2<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat2;
         bench_unop!(b, op => transposed, ty => Mat2)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix2;
         bench_unop!(b, op => transpose, ty => Matrix2<f32>)
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat2;
         bench_unop!(b, op => transposed, ty => Mat2<f32>)
     });
@@ -96,24 +96,24 @@ fn bench_matrix2_transpose_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide matrix2 transpose");
     let size = &MIN_WIDE_BENCH_SIZE;
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat2;
         bench_unop_wide!(b, size, width => 1, op => transpose, ty => Mat2)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat2x4;
         bench_unop_wide!(b, size, width => 4, op => transposed, ty => Mat2x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Matrix2;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => transpose, ty => Matrix2<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat2x8;
         bench_unop_wide!(b, size, width => 8, op => transposed, ty => Mat2x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Matrix2;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => transpose, ty => Matrix2<f32x8>)
@@ -123,28 +123,28 @@ fn bench_matrix2_transpose_wide(c: &mut Criterion) {
 
 fn bench_matrix2_determinant(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix2 determinant");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat2;
         bench_unop!(b, op => determinant, ty => Mat2)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{prelude::*, Matrix2};
         bench_unop!(b, op => determinant, ty => Matrix2<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat2;
         bench_unop!(b, op => determinant, ty => Mat2)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix2;
         bench_unop!(b, op => determinant, ty => Matrix2<f32>)
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat2;
         bench_unop!(b, op => determinant, ty => Mat2<f32>)
     });
-    bench_pathfinder!(group, |b| {
+    bench!("pathfinder_geometry" as "pathfinder", group, |b| {
         use pathfinder_geometry::transform2d::Matrix2x2F;
         bench_unop!(b, op => det, ty => Matrix2x2F)
     });
@@ -155,15 +155,15 @@ fn bench_matrix2_determinant_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide matrix2 determinant");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat2;
         bench_unop_wide!(b, size, width => 1, op => determinant, ty => Mat2)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat2x4;
         bench_unop_wide!(b, size, width => 4, op => determinant, ty => Mat2x4)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat2x8;
         bench_unop_wide!(b, size, width => 8, op => determinant, ty => Mat2x8)
     });
@@ -172,24 +172,24 @@ fn bench_matrix2_determinant_wide(c: &mut Criterion) {
 
 fn bench_matrix2_inverse(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix2 inverse");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat2;
         bench_unop!(b, op => inverse, ty => Mat2)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{prelude::*, Matrix2};
         bench_unop!(b, op => invert, ty => Matrix2<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat2;
         bench_unop!(b, op => inversed, ty => Mat2)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix2;
         bench_unop!(b, op => try_inverse, ty => Matrix2<f32>)
     });
 
-    bench_pathfinder!(group, |b| {
+    bench!("pathfinder_geometry" as "pathfinder", group, |b| {
         use pathfinder_geometry::transform2d::Matrix2x2F;
         bench_unop!(b, op => inverse, ty => Matrix2x2F)
     });
@@ -200,15 +200,15 @@ fn bench_matrix2_inverse_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide matrix2 inverse");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat2;
         bench_unop_wide!(b, size, width => 1, op => inverse, ty => Mat2)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat2x4;
         bench_unop_wide!(b, size, width => 4, op => inversed, ty => Mat2x4)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat2x8;
         bench_unop_wide!(b, size, width => 8, op => inversed, ty => Mat2x8)
     });
@@ -217,28 +217,28 @@ fn bench_matrix2_inverse_wide(c: &mut Criterion) {
 
 fn bench_matrix2_mul_matrix2(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix2 mul matrix2");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat2;
         bench_binop!(b, op => mul, ty1 => Mat2, ty2 => Mat2)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Matrix2;
         bench_binop!(b, op => mul, ty1 => Matrix2<f32>, ty2 => Matrix2<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat2;
         bench_binop!(b, op => mul, ty1 => Mat2, ty2 => Mat2)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix2;
         bench_binop!(b, op => mul, ty1 => Matrix2<f32>, ty2 => Matrix2<f32>)
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat2;
         bench_binop!(b, op => mul, ty1 => Mat2<f32>, ty2 => Mat2<f32>)
     });
-    bench_pathfinder!(group, |b| {
+    bench!("pathfinder_geometry" as "pathfinder", group, |b| {
         use pathfinder_geometry::transform2d::Matrix2x2F;
         bench_binop!(b, op => mul, ty1 => Matrix2x2F, ty2 => Matrix2x2F)
     });
@@ -249,24 +249,24 @@ fn bench_matrix2_mul_matrix2_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide matrix2 mul matrix2");
     for size in [16, 256].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::Mat2;
             bench_binop_wide!(b, size, width => 1, op => mul, ty1 => Mat2, ty2 => Mat2)
         });
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::Mat2x4;
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Mat2x4, ty2 => Mat2x4)
         });
-        bench_nalgebra_f32x4!(group, size, |b, size| {
+        bench!("nalgebra_f32x4", group, size, |b, size| {
             use nalgebra::Matrix2;
             use simba::simd::f32x4;
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Matrix2<f32x4>, ty2 => Matrix2<f32x4>)
         });
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::Mat2x8;
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Mat2x8, ty2 => Mat2x8)
         });
-        bench_nalgebra_f32x8!(group, size, |b, size| {
+        bench!("nalgebra_f32x8", group, size, |b, size| {
             use nalgebra::Matrix2;
             use simba::simd::f32x8;
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Matrix2<f32x8>, ty2 => Matrix2<f32x8>)
@@ -279,28 +279,28 @@ fn bench_matrix2_mul_vector2(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix2 mul vector2");
     for size in [1, 100].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::{Mat2, Vec2};
             bench_binop!(b, size, op => mul, ty1 => Mat2, ty2 => Vec2)
         });
-        bench_cgmath!(group, size, |b, size| {
+        bench!("cgmath", group, size, |b, size| {
             use cgmath::{Matrix2, Vector2};
             bench_binop!(b, size, op => mul, ty1 => Matrix2<f32>, ty2 => Vector2<f32>)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::{Mat2, Vec2};
             bench_binop!(b, size, op => mul, ty1 => Mat2, ty2 => Vec2)
         });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{Matrix2, Vector2};
             bench_binop!(b, size, op => mul, ty1 => Matrix2<f32>, ty2 => Vector2<f32>)
         });
 
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::{Mat2, Vec2};
             bench_binop!(b, size, op => mul, ty1 => Mat2<f32>, ty2 => Vec2<f32>)
         });
-        bench_pathfinder!(group, size, |b, size| {
+        bench!("pathfinder_geometry" as "pathfinder", group, size, |b, size| {
             use pathfinder_geometry::{transform2d::Matrix2x2F, vector::Vector2F};
             bench_binop!(b, size, op => mul, ty1 => Matrix2x2F, ty2 => Vector2F)
         });
@@ -312,24 +312,24 @@ fn bench_matrix2_mul_vector2_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide matrix2 mul vector2");
     for size in [16, 256].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::{Mat2, Vec2};
             bench_binop_wide!(b, size, width => 1, op => mul, ty1 => Mat2, ty2 => Vec2)
         });
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::{Mat2x4, Vec2x4};
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Mat2x4, ty2 => Vec2x4)
         });
-        bench_nalgebra_f32x4!(group, size, |b, size| {
+        bench!("nalgebra_f32x4", group, size, |b, size| {
             use nalgebra::{Matrix2, Vector2};
             use simba::simd::f32x4;
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Matrix2<f32x4>, ty2 => Vector2<f32x4>)
         });
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::{Mat2x8, Vec2x8};
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Mat2x8, ty2 => Vec2x8)
         });
-        bench_nalgebra_f32x8!(group, size, |b, size| {
+        bench!("nalgebra_f32x8", group, size, |b, size| {
             use nalgebra::{Matrix2, Vector2};
             use simba::simd::f32x8;
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Matrix2<f32x8>, ty2 => Vector2<f32x8>)
diff --git a/benches/matrix3.rs b/benches/matrix3.rs
index ff23fb6..f96bf4c 100644
--- a/benches/matrix3.rs
+++ b/benches/matrix3.rs
@@ -8,24 +8,24 @@ use std::ops::Mul;
 
 fn bench_matrix3_ret_self(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix3 return self");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat3;
         bench_unop!(b, op => ret_self, ty => Mat3)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Matrix3;
         bench_unop!(b, op => ret_self, ty => Matrix3<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat3;
         bench_unop!(b, op => ret_self, ty => Mat3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix3;
         bench_unop!(b, op => ret_self, ty => Matrix3<f32>)
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat3;
         bench_unop!(b, op => ret_self, ty => Mat3<f32>)
     });
@@ -36,24 +36,24 @@ fn bench_matrix3_ret_self_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide matrix3 return self");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat3;
         bench_unop_wide!(b, size, width => 1, op => ret_self, ty => Mat3)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat3x4;
         bench_unop_wide!(b, size, width => 4, op => ret_self, ty => Mat3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Matrix3;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => ret_self, ty => Matrix3<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat3x8;
         bench_unop_wide!(b, size, width => 8, op => ret_self, ty => Mat3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Matrix3;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => ret_self, ty => Matrix3<f32x8>)
@@ -63,24 +63,24 @@ fn bench_matrix3_ret_self_wide(c: &mut Criterion) {
 
 fn bench_matrix3_transpose(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix3 transpose");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat3;
         bench_unop!(b, op => transpose, ty => Mat3)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{prelude::*, Matrix3};
         bench_unop!(b, op => transpose, ty => Matrix3<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat3;
         bench_unop!(b, op => transposed, ty => Mat3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix3;
         bench_unop!(b, op => transpose, ty => Matrix3<f32>)
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat3;
         bench_unop!(b, op => transposed, ty => Mat3<f32>)
     });
@@ -91,24 +91,24 @@ fn bench_matrix3_transpose_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide matrix3 transpose");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat3;
         bench_unop_wide!(b, size, width => 1, op => transpose, ty => Mat3)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat3x4;
         bench_unop_wide!(b, size, width => 4, op => transposed, ty => Mat3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Matrix3;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => transpose, ty => Matrix3<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat3x8;
         bench_unop_wide!(b, size, width => 8, op => transposed, ty => Mat3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Matrix3;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => transpose, ty => Matrix3<f32x8>)
@@ -118,24 +118,24 @@ fn bench_matrix3_transpose_wide(c: &mut Criterion) {
 
 fn bench_matrix3_determinant(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix3 determinant");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat3;
         bench_unop!(b, op => determinant, ty => Mat3)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{prelude::*, Matrix3};
         bench_unop!(b, op => determinant, ty => Matrix3<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat3;
         bench_unop!(b, op => determinant, ty => Mat3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix3;
         bench_unop!(b, op => determinant, ty => Matrix3<f32>)
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat3;
         bench_unop!(b, op => determinant, ty => Mat3<f32>)
     });
@@ -146,15 +146,15 @@ fn bench_matrix3_determinant_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide matrix3 determinant");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat3;
         bench_unop_wide!(b, size, width => 1, op => determinant, ty => Mat3)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat3x4;
         bench_unop_wide!(b, size, width => 4, op => determinant, ty => Mat3x4)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat3x8;
         bench_unop_wide!(b, size, width => 8, op => determinant, ty => Mat3x8)
     });
@@ -163,19 +163,19 @@ fn bench_matrix3_determinant_wide(c: &mut Criterion) {
 
 fn bench_matrix3_inverse(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix3 inverse");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat3;
         bench_unop!(b, op => inverse, ty => Mat3)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{prelude::*, Matrix3};
         bench_unop!(b, op => invert, ty => Matrix3<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat3;
         bench_unop!(b, op => inversed, ty => Mat3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix3;
         bench_unop!(b, op => try_inverse, ty => Matrix3<f32>)
     });
@@ -187,15 +187,15 @@ fn bench_matrix3_inverse_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide matrix3 inverse");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat3;
         bench_unop_wide!(b, size, width => 1, op => inverse, ty => Mat3)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat3x4;
         bench_unop_wide!(b, size, width => 4, op => inversed, ty => Mat3x4)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat3x8;
         bench_unop_wide!(b, size, width => 8, op => inversed, ty => Mat3x8)
     });
@@ -204,24 +204,24 @@ fn bench_matrix3_inverse_wide(c: &mut Criterion) {
 
 fn bench_matrix3_mul_matrix3(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix3 mul matrix3");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat3;
         bench_binop!(b, op => mul, ty1 => Mat3, ty2 => Mat3)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Matrix3;
         bench_binop!(b, op => mul, ty1 => Matrix3<f32>, ty2 => Matrix3<f32>, param => by_ref)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat3;
         bench_binop!(b, op => mul, ty1 => Mat3, ty2 => Mat3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix3;
         bench_binop!(b, op => mul, ty1 => Matrix3<f32>, ty2 => Matrix3<f32>, param => by_ref)
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat3;
         bench_binop!(b, op => mul, ty1 => Mat3<f32>, ty2 => Mat3<f32>)
     });
@@ -232,24 +232,24 @@ fn bench_matrix3_mul_matrix3_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide matrix3 mul matrix3");
     for size in [16, 256].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::Mat3;
             bench_binop_wide!(b, size, width => 1, op => mul, ty1 => Mat3, ty2 => Mat3)
         });
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::Mat3x4;
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Mat3x4, ty2 => Mat3x4)
         });
-        bench_nalgebra_f32x4!(group, size, |b, size| {
+        bench!("nalgebra_f32x4", group, size, |b, size| {
             use nalgebra::Matrix3;
             use simba::simd::f32x4;
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Matrix3<f32x4>, ty2 => Matrix3<f32x4>)
         });
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::Mat3x8;
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Mat3x8, ty2 => Mat3x8)
         });
-        bench_nalgebra_f32x8!(group, size, |b, size| {
+        bench!("nalgebra_f32x8", group, size, |b, size| {
             use nalgebra::Matrix3;
             use simba::simd::f32x8;
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Matrix3<f32x8>, ty2 => Matrix3<f32x8>)
@@ -262,24 +262,24 @@ fn bench_matrix3_mul_vector3(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix3 mul vector3");
     for size in [1, 100].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::{Mat3, Vec3};
             bench_binop!(b, size, op => mul, ty1 => Mat3, ty2 => Vec3)
         });
-        bench_cgmath!(group, size, |b, size| {
+        bench!("cgmath", group, size, |b, size| {
             use cgmath::{Matrix3, Vector3};
             bench_binop!(b, size, op => mul, ty1 => Matrix3<f32>, ty2 => Vector3<f32>)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::{Mat3, Vec3};
             bench_binop!(b, size, op => mul, ty1 => Mat3, ty2 => Vec3)
         });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{Matrix3, Vector3};
             bench_binop!(b, size, op => mul, ty1 => Matrix3<f32>, ty2 => Vector3<f32>)
         });
 
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::{Mat3, Vec3};
             bench_binop!(b, size, op => mul, ty1 => Mat3<f32>, ty2 => Vec3<f32>)
         });
@@ -291,24 +291,24 @@ fn bench_matrix3_mul_vector3_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide matrix3 mul vector3");
     for size in [16, 256].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::{Mat3, Vec3};
             bench_binop_wide!(b, size, width => 1, op => mul, ty1 => Mat3, ty2 => Vec3)
         });
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::{Mat3x4, Vec3x4};
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Mat3x4, ty2 => Vec3x4)
         });
-        bench_nalgebra_f32x4!(group, size, |b, size| {
+        bench!("nalgebra_f32x4", group, size, |b, size| {
             use nalgebra::{Matrix3, Vector3};
             use simba::simd::f32x4;
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Matrix3<f32x4>, ty2 => Vector3<f32x4>)
         });
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::{Mat3x8, Vec3x8};
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Mat3x8, ty2 => Vec3x8)
         });
-        bench_nalgebra_f32x8!(group, size, |b, size| {
+        bench!("nalgebra_f32x8", group, size, |b, size| {
             use nalgebra::{Matrix3, Vector3};
             use simba::simd::f32x8;
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Matrix3<f32x8>, ty2 => Vector3<f32x8>)
diff --git a/benches/matrix4.rs b/benches/matrix4.rs
index 6887218..2a1e3ae 100644
--- a/benches/matrix4.rs
+++ b/benches/matrix4.rs
@@ -9,24 +9,24 @@ use std::ops::Mul;
 // returns self to check overhead of benchmark
 fn bench_matrix4_ret_self(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix4 return self");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat4;
         bench_unop!(b, op => ret_self, ty => Mat4)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Matrix4;
         bench_unop!(b, op => ret_self, ty => Matrix4<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat4;
         bench_unop!(b, op => ret_self, ty => Mat4)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix4;
         bench_unop!(b, op => ret_self, ty => Matrix4<f32>)
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat4;
         bench_unop!(b, op => ret_self, ty => Mat4<f32>)
     });
@@ -37,24 +37,24 @@ fn bench_matrix4_ret_self_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide matrix4 return self");
     group.throughput(criterion::Throughput::Elements(*size as u64));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat4;
         bench_unop_wide!(b, size, width => 1, op => ret_self, ty => Mat4)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat4x4;
         bench_unop_wide!(b, size, width => 4, op => ret_self, ty => Mat4x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Matrix4;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => ret_self, ty => Matrix4<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat4x8;
         bench_unop_wide!(b, size, width => 8, op => ret_self, ty => Mat4x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Matrix4;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => ret_self, ty => Matrix4<f32x8>)
@@ -64,24 +64,24 @@ fn bench_matrix4_ret_self_wide(c: &mut Criterion) {
 
 fn bench_matrix4_transpose(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix4 transpose");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat4;
         bench_unop!(b, op => transpose, ty => Mat4);
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{prelude::*, Matrix4};
         bench_unop!(b, op => transpose, ty => Matrix4<f32>);
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat4;
         bench_unop!(b, op => transposed, ty => Mat4)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix4;
         bench_unop!(b, op => transpose, ty => Matrix4<f32>);
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat4;
         bench_unop!(b, op => transposed, ty => Mat4<f32>)
     });
@@ -92,24 +92,24 @@ fn bench_matrix4_transpose_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide matrix4 transpose");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat4;
         bench_unop_wide!(b, size, width => 1, op => transpose, ty => Mat4)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat4x4;
         bench_unop_wide!(b, size, width => 4, op => transposed, ty => Mat4x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Matrix4;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => transpose, ty => Matrix4<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat4x8;
         bench_unop_wide!(b, size, width => 8, op => transposed, ty => Mat4x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Matrix4;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => transpose, ty => Matrix4<f32x8>)
@@ -119,28 +119,28 @@ fn bench_matrix4_transpose_wide(c: &mut Criterion) {
 
 fn bench_matrix4_determinant(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix4 determinant");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat4;
         bench_unop!(b, op => determinant, ty => Mat4)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{Matrix4, SquareMatrix};
         bench_unop!(b, op => determinant, ty => Matrix4<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat4;
         bench_unop!(b, op => determinant, ty => Mat4)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix4;
         bench_unop!(b, op => determinant, ty => Matrix4<f32>)
     });
 
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Transform3D, UnknownUnit};
         bench_unop!(b, op => determinant, ty => Transform3D<f32, UnknownUnit, UnknownUnit>)
     });
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat4;
         bench_unop!(b, op => determinant, ty => Mat4<f32>)
     });
@@ -151,15 +151,15 @@ fn bench_matrix4_determinant_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide matrix4 determinant");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat4;
         bench_unop_wide!(b, size, width => 1, op => determinant, ty => Mat4)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat4x4;
         bench_unop_wide!(b, size, width => 4, op => determinant, ty => Mat4x4)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat4x8;
         bench_unop_wide!(b, size, width => 8, op => determinant, ty => Mat4x8)
     });
@@ -168,28 +168,28 @@ fn bench_matrix4_determinant_wide(c: &mut Criterion) {
 
 fn bench_matrix4_inverse(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix4 inverse");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat4;
         bench_unop!(b, op => inverse, ty => Mat4)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{Matrix4, SquareMatrix};
         bench_unop!(b, op => invert, ty => Matrix4<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat4;
         bench_unop!(b, op => inversed, ty => Mat4)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix4;
         bench_unop!(b, op => try_inverse, ty => Matrix4<f32>)
     });
 
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Transform3D, UnknownUnit};
         bench_unop!(b, op => inverse, ty => Transform3D<f32, UnknownUnit, UnknownUnit>)
     });
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat4;
         bench_unop!(b, op => inverted, ty => Mat4<f32>)
     });
@@ -200,15 +200,15 @@ fn bench_matrix4_inverse_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide matrix4 inverse");
     let size = &MIN_WIDE_BENCH_SIZE;
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Mat4;
         bench_unop_wide!(b, size, width => 1, op => inverse, ty => Mat4)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Mat4x4;
         bench_unop_wide!(b, size, width => 4, op => inversed, ty => Mat4x4)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Mat4x8;
         bench_unop_wide!(b, size, width => 8, op => inversed, ty => Mat4x8)
     });
@@ -217,28 +217,28 @@ fn bench_matrix4_inverse_wide(c: &mut Criterion) {
 
 fn bench_matrix4_mul_matrix4(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix4 mul matrix4");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Mat4;
         bench_binop!(b, op => mul, ty1 => Mat4, ty2 => Mat4)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Matrix4;
         bench_binop!(b, op => mul, ty1 => Matrix4<f32>, ty2 => Matrix4<f32>, param => by_ref)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Mat4;
         bench_binop!(b, op => mul, ty1 => Mat4, ty2 => Mat4)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Matrix4;
         bench_binop!(b, op => mul, ty1 => Matrix4<f32>, ty2 => Matrix4<f32>, param => by_ref)
     });
 
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Transform3D, UnknownUnit};
         bench_binop!(b, op => then, ty => Transform3D<f32, UnknownUnit, UnknownUnit>, param => by_ref)
     });
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Mat4;
         bench_binop!(b, op => mul, ty1 => Mat4<f32>, ty2 => Mat4<f32>)
     });
@@ -249,24 +249,24 @@ fn bench_matrix4_mul_matrix4_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide matrix4 mul matrix4");
     for size in [16, 256].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::Mat4;
             bench_binop_wide!(b, size, width => 1, op => mul, ty1 => Mat4, ty2 => Mat4)
         });
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::Mat4x4;
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Mat4x4, ty2 => Mat4x4)
         });
-        bench_nalgebra_f32x4!(group, size, |b, size| {
+        bench!("nalgebra_f32x4", group, size, |b, size| {
             use nalgebra::Matrix4;
             use simba::simd::f32x4;
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Matrix4<f32x4>, ty2 => Matrix4<f32x4>)
         });
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::Mat4x8;
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Mat4x8, ty2 => Mat4x8)
         });
-        bench_nalgebra_f32x8!(group, size, |b, size| {
+        bench!("nalgebra_f32x8", group, size, |b, size| {
             use nalgebra::Matrix4;
             use simba::simd::f32x8;
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Matrix4<f32x8>, ty2 => Matrix4<f32x8>)
@@ -279,24 +279,24 @@ fn bench_matrix4_mul_vector4(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar matrix4 mul vector4");
     for size in [1, 100].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::{Mat4, Vec4};
             bench_binop!(b, size, op => mul, ty1 => Mat4, ty2 => Vec4)
         });
-        bench_cgmath!(group, size, |b, size| {
+        bench!("cgmath", group, size, |b, size| {
             use cgmath::{Matrix4, Vector4};
             bench_binop!(b, size, op => mul, ty1 => Matrix4<f32>, ty2 => Vector4<f32>)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::{Mat4, Vec4};
             bench_binop!(b, size, op => mul, ty1 => Mat4, ty2 => Vec4)
         });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{Matrix4, Vector4};
             bench_binop!(b, size, op => mul, ty1 => Matrix4<f32>, ty2 => Vector4<f32>)
         });
 
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::{Mat4, Vec4};
             bench_binop!(b, size, op => mul, ty1 => Mat4<f32>, ty2 => Vec4<f32>)
         });
@@ -308,24 +308,24 @@ fn bench_matrix4_mul_vector4_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide matrix4 mul vector4");
     for size in [16, 256].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::{Mat4, Vec4};
             bench_binop_wide!(b, size, width => 1, op => mul, ty1 => Mat4, ty2 => Vec4)
         });
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::{Mat4x4, Vec4x4};
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Mat4x4, ty2 => Vec4x4)
         });
-        bench_nalgebra_f32x4!(group, size, |b, size| {
+        bench!("nalgebra_f32x4", group, size, |b, size| {
             use nalgebra::{Matrix4, Vector4};
             use simba::simd::f32x4;
             bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Matrix4<f32x4>, ty2 => Vector4<f32x4>)
         });
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::{Mat4x8, Vec4x8};
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Mat4x8, ty2 => Vec4x8)
         });
-        bench_nalgebra_f32x8!(group, size, |b, size| {
+        bench!("nalgebra_f32x8", group, size, |b, size| {
             use nalgebra::{Matrix4, Vector4};
             use simba::simd::f32x8;
             bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Matrix4<f32x8>, ty2 => Vector4<f32x8>)
diff --git a/benches/ray_sphere_intersect.rs b/benches/ray_sphere_intersect.rs
index 115ee15..1b9d5de 100644
--- a/benches/ray_sphere_intersect.rs
+++ b/benches/ray_sphere_intersect.rs
@@ -170,27 +170,27 @@ fn bench_ray_sphere_intersect_scalar(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar ray-sphere intersection");
     for size in [10000].iter() {
         group.throughput(Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::Vec3;
             bench_intersection_scalar!(b, size, ty => Vec3, zero => Vec3::ZERO, norm => normalize, mag_sq => length_squared, param => by_value);
         });
-        bench_cgmath!(group, size, |b, size| {
+        bench!("cgmath", group, size, |b, size| {
             use cgmath::{prelude::*, Vector3};
             bench_intersection_scalar!(b, size, ty => Vector3<f32>, zero => Vector3::zero(), norm => normalize, mag_sq => magnitude2, param => by_value)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::Vec3;
             bench_intersection_scalar!(b, size, ty => Vec3, zero => Vec3::zero(), norm => normalized, mag_sq => mag_sq, param => by_value);
         });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{zero, Vector3};
             bench_intersection_scalar!(b, size, ty => Vector3<f32>, zero => zero(), norm => normalize, mag_sq => norm_squared, param => by_ref);
         });
-        bench_euclid!(group, size, |b, size| {
+        bench!("euclid", group, size, |b, size| {
             use euclid::{UnknownUnit, Vector3D};
             bench_intersection_scalar!(b, size, ty => Vector3D<f32, UnknownUnit>, zero => Vector3D::zero(), norm => normalize, mag_sq => square_length, param => by_value);
         });
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::Vec3;
             bench_intersection_scalar!(b, size, ty => Vec3<f32>, zero => Vec3::zero(), norm => normalized, mag_sq => magnitude_squared, param => by_value)
         });
@@ -202,28 +202,28 @@ fn bench_ray_sphere_intersect_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide ray-sphere intersection");
     for size in [80000].iter() {
         group.throughput(Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::Vec3A;
             bench_intersection_scalar!(b, size, ty => Vec3A, zero => Vec3A::ZERO, norm => normalize, mag_sq => length_squared, param => by_value);
         });
 
         // sse
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::{f32x4, Vec3x4};
             bench_intersection_wide_uv!(b, &((*size as f32 / 4.0).ceil() as usize), ty => Vec3x4, wt => f32x4, zero_vec => Vec3x4::zero(), max => f32::MAX)
         });
-        bench_nalgebra_f32x4!(group, size, |b, size| {
+        bench!("nalgebra_f32x4", group, size, |b, size| {
             use nalgebra::{zero, Vector3};
             use simba::simd::{f32x4, SimdValue};
             bench_intersection_wide_na!(b, &((*size as f32 / 4.0).ceil() as usize), ty => Vector3<f32x4>, wt => f32x4, zero_vec => zero(), max => f32::MAX);
         });
 
         // avx
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::{f32x8, Vec3x8};
             bench_intersection_wide_uv!(b, &((*size as f32 / 8.0).ceil() as usize), ty => Vec3x8, wt => f32x8, zero_vec => Vec3x8::zero(), max => f32::MAX)
         });
-        bench_nalgebra_f32x8!(group, size, |b, size| {
+        bench!("nalgebra_f32x8", group, size, |b, size| {
             use nalgebra::{zero, Vector3};
             use simba::simd::{f32x8, SimdValue};
             bench_intersection_wide_na!(b, &((*size as f32 / 8.0).ceil() as usize), ty => Vector3<f32x8>, wt => f32x8, zero_vec => zero(), max => f32::MAX);
diff --git a/benches/rotation3.rs b/benches/rotation3.rs
index 9065367..83cf5d8 100644
--- a/benches/rotation3.rs
+++ b/benches/rotation3.rs
@@ -9,24 +9,24 @@ use std::ops::Mul;
 // returns self to check overhead of benchmark
 fn bench_rotation3_nop(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar rotation3 return self");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Quat;
         bench_unop!(b, op => ret_self, ty => Quat)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Quaternion;
         bench_unop!(b, op => ret_self, ty => Quaternion<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Rotor3;
         bench_unop!(b, op => ret_self, ty => Rotor3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::UnitQuaternion;
         bench_unop!(b, op => ret_self, ty => UnitQuaternion<f32>)
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Quaternion;
         bench_unop!(b, op => ret_self, ty => Quaternion<f32>)
     });
@@ -37,24 +37,24 @@ fn bench_rotation3_nop_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide rotation3 return self");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Quat;
         bench_unop_wide!(b, size, width => 1, op => ret_self, ty => Quat)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Rotor3x4;
         bench_unop_wide!(b, size, width => 4, op => ret_self, ty => Rotor3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::UnitQuaternion;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => ret_self, ty => UnitQuaternion<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Rotor3x8;
         bench_unop_wide!(b, size, width => 8, op => ret_self, ty => Rotor3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::UnitQuaternion;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => ret_self, ty => UnitQuaternion<f32x8>)
@@ -65,29 +65,29 @@ fn bench_rotation3_nop_wide(c: &mut Criterion) {
 fn bench_rotation3_inverse(c: &mut Criterion) {
     // unit quaternion inverse is the conjugate
     let mut group = c.benchmark_group("scalar rotation3 inverse");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Quat;
         bench_unop!(b, op => conjugate, ty => Quat)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Quaternion;
         bench_unop!(b, op => conjugate, ty => Quaternion<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Rotor3;
         bench_unop!(b, op => reversed, ty => Rotor3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::UnitQuaternion;
         bench_unop!(b, op => conjugate, ty => UnitQuaternion<f32>)
     });
 
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Rotation3D, UnknownUnit};
         // euclid inverse assumes normalized quaternion, so it's just a conjugate
         bench_unop!(b, op => inverse, ty => Rotation3D<f32, UnknownUnit, UnknownUnit>)
     });
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Quaternion;
         bench_unop!(b, op => conjugate, ty => Quaternion<f32>)
     });
@@ -98,24 +98,24 @@ fn bench_rotation3_inverse_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide rotation3 inverse");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Quat;
         bench_unop_wide!(b, size, width => 1, op => conjugate, ty => Quat)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Rotor3x4;
         bench_unop_wide!(b, size, width => 4, op => reversed, ty => Rotor3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::UnitQuaternion;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => conjugate, ty => UnitQuaternion<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Rotor3x8;
         bench_unop_wide!(b, size, width => 8, op => reversed, ty => Rotor3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::UnitQuaternion;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => conjugate, ty => UnitQuaternion<f32x8>)
@@ -125,28 +125,28 @@ fn bench_rotation3_inverse_wide(c: &mut Criterion) {
 
 fn bench_rotation3_mul_rotation3(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar rotation3 mul rotation3");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Quat;
         bench_binop!(b, op => mul, ty1 => Quat, ty2 => Quat)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Quaternion;
         bench_binop!(b, op => mul, ty1 => Quaternion<f32>, ty2 => Quaternion<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Rotor3;
         bench_binop!(b, op => mul, ty1 => Rotor3, ty2 => Rotor3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::UnitQuaternion;
         bench_binop!(b, op => mul, ty1 => UnitQuaternion<f32>, ty2 => UnitQuaternion<f32>)
     });
 
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Rotation3D, UnknownUnit};
         bench_binop!(b, op => then, ty => Rotation3D<f32, UnknownUnit, UnknownUnit>, param => by_ref)
     });
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Quaternion;
         bench_binop!(b, op => mul, ty1 => Quaternion<f32>, ty2 => Quaternion<f32>);
     });
@@ -157,24 +157,24 @@ fn bench_rotation3_mul_rotation3_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide rotation3 mul rotation3");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Quat;
         bench_binop_wide!(b, size, width => 1, op => mul, ty1 => Quat, ty2 => Quat)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Rotor3x4;
         bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Rotor3x4, ty2 => Rotor3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::UnitQuaternion;
         use simba::simd::f32x4;
         bench_binop_wide!(b, size, width => 4, op => mul, ty1 => UnitQuaternion<f32x4>, ty2 => UnitQuaternion<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Rotor3x8;
         bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Rotor3x8, ty2 => Rotor3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::UnitQuaternion;
         use simba::simd::f32x8;
         bench_binop_wide!(b, size, width => 8, op => mul, ty1 => UnitQuaternion<f32x8>, ty2 => UnitQuaternion<f32x8>)
@@ -186,28 +186,28 @@ fn bench_rotation3_mul_vector3(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar rotation3 mul vector3");
     for size in [1, 100].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::{Quat, Vec3};
             bench_binop!(b, size, op => mul, ty1 => Quat, ty2 => Vec3)
         });
-        bench_cgmath!(group, size, |b, size| {
+        bench!("cgmath", group, size, |b, size| {
             use cgmath::{Quaternion, Vector3};
             bench_binop!(b, size, op => mul, ty1 => Quaternion<f32>, ty2 => Vector3<f32>)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::{Rotor3, Vec3};
             bench_binop!(b, size, op => mul, ty1 => Rotor3, ty2 => Vec3)
         });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{UnitQuaternion, Vector3};
             bench_binop!(b, size, op => mul, ty1 => UnitQuaternion<f32>, ty2 => Vector3<f32>)
         });
 
-        bench_euclid!(group, size, |b, size| {
+        bench!("euclid", group, size, |b, size| {
             use euclid::{Point3D, Rotation3D, UnknownUnit};
             bench_binop!(b, size, op => transform_point3d, ty1 => Rotation3D<f32, UnknownUnit, UnknownUnit>, ty2 => Point3D<f32, UnknownUnit>)
         });
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::{Quaternion, Vec3};
             bench_binop!(b, size, op => mul, ty1 => Quaternion<f32>, ty2 => Vec3<f32>)
         });
@@ -219,24 +219,24 @@ fn bench_rotation3_mul_vector3_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide rotation3 mul vector3");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::{Quat, Vec3};
         bench_binop_wide!(b, size, width => 1, op => mul, ty1 => Quat, ty2 => Vec3)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::{Rotor3x4, Vec3x4};
         bench_binop_wide!(b, size, width => 4, op => mul, ty1 => Rotor3x4, ty2 => Vec3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::{UnitQuaternion, Vector3};
         use simba::simd::f32x4;
         bench_binop_wide!(b, size, width => 4, op => mul, ty1 => UnitQuaternion<f32x4>, ty2 => Vector3<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::{Rotor3x8, Vec3x8};
         bench_binop_wide!(b, size, width => 8, op => mul, ty1 => Rotor3x8, ty2 => Vec3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::{UnitQuaternion, Vector3};
         use simba::simd::f32x8;
         bench_binop_wide!(b, size, width => 8, op => mul, ty1 => UnitQuaternion<f32x8>, ty2 => Vector3<f32x8>)
diff --git a/benches/support/macros.rs b/benches/support/macros.rs
index 8f2b996..91fb7da 100644
--- a/benches/support/macros.rs
+++ b/benches/support/macros.rs
@@ -1,224 +1,55 @@
 #[allow(dead_code)]
 pub const MIN_WIDE_BENCH_SIZE: u64 = 16;
 
-#[macro_export]
-macro_rules! bench_lib {
-    ($libname:literal, $group:ident, $size:expr, $closure:expr) => {
-        #[cfg(feature = $libname)]
-        $group.bench_with_input(
-            criterion::BenchmarkId::new($libname, $size),
-            $size,
-            $closure,
-        )
-    };
-    ($libname:literal, $group:ident, $closure:expr) => {
-        #[cfg(feature = $libname)]
-        $group.bench_function($libname, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_glam {
-    ($group:ident, $closure:expr) => {
-        // bench_lib!("glam", $group, $closure)
+/// Register a Criterion benchmark for a math library.
+///
+/// # Forms
+///
+/// **glam** (always compiled, no `#[cfg]` gate):
+/// ```ignore
+/// bench!("glam", group, |b| { ... });
+/// bench!("glam", group, size, |b, size| { ... });
+/// ```
+///
+/// **Gated library** (feature name == display name):
+/// ```ignore
+/// bench!("cgmath", group, |b| { ... });
+/// bench!("nalgebra", group, size, |b, size| { ... });
+/// ```
+///
+/// **Display-name override** (feature name ≠ display name):
+/// ```ignore
+/// bench!("pathfinder_geometry" as "pathfinder", group, |b| { ... });
+/// bench!("pathfinder_geometry" as "pathfinder", group, size, |b, size| { ... });
+/// ```
+#[macro_export]
+macro_rules! bench {
+    // glam (always compiled, no feature gate)
+    ("glam", $group:ident, $closure:expr) => {
         $group.bench_function("glam", $closure)
     };
-    ($group:ident, $size:expr, $closure:expr) => {
-        // bench_lib!("glam", $group, $size, $closure)
+    ("glam", $group:ident, $size:expr, $closure:expr) => {
         $group.bench_with_input(criterion::BenchmarkId::new("glam", $size), $size, $closure)
     };
-}
-
-#[macro_export]
-macro_rules! bench_glam_f32x1 {
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("glam_f32x1", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_cgmath {
-    ($group:ident, $closure:expr) => {
-        bench_lib!("cgmath", $group, $closure)
-    };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("cgmath", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_ultraviolet {
-    ($group:ident, $closure:expr) => {
-        bench_lib!("ultraviolet", $group, $closure)
-    };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("ultraviolet", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_ultraviolet_f32x4 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("ultraviolet_f32x4", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("ultraviolet_f32x4", $group, $size, $closure)
-    };
-}
 
-#[macro_export]
-macro_rules! bench_ultraviolet_f32x8 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("ultraviolet_f32x8", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("ultraviolet_f32x8", $group, $size, $closure)
+    // Gated libraries (feature name = display name)
+    ($lib:literal, $group:ident, $closure:expr) => {
+        #[cfg(feature = $lib)]
+        $group.bench_function($lib, $closure)
     };
-}
-
-#[macro_export]
-macro_rules! bench_ultraviolet_f64 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("ultraviolet_f64", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("ultraviolet_f64", $group, $size, $closure)
+    ($lib:literal, $group:ident, $size:expr, $closure:expr) => {
+        #[cfg(feature = $lib)]
+        $group.bench_with_input(criterion::BenchmarkId::new($lib, $size), $size, $closure)
     };
-}
 
-#[macro_export]
-macro_rules! bench_ultraviolet_f64x2 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("ultraviolet_f64x2", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("ultraviolet_f64x2", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_ultraviolet_f64x4 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("ultraviolet_f64x4", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("ultraviolet_f64x4", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_nalgebra {
-    ($group:ident, $closure:expr) => {
-        bench_lib!("nalgebra", $group, $closure)
-    };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("nalgebra", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_nalgebra_f32x4 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("nalgebra_f32x4", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("nalgebra_f32x4", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_nalgebra_f32x8 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("nalgebra_f32x8", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("nalgebra_f32x8", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_nalgebra_f32x16 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("nalgebra_f32x16", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("nalgebra_f32x16", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_nalgebra_f64 {
-    ($group:ident, $closure:expr) => {
-        bench_lib!("nalgebra_f64", $group, $closure)
-    };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("nalgebra_f64", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_nalgebra_f64x2 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("nalgebra_f64x2", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("nalgebra_f64x2", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_nalgebra_f64x4 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("nalgebra_f64x4", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("nalgebra_f64x4", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_nalgebra_f64x8 {
-    // ($group:ident, $closure:expr) => {
-    //     bench_lib!("nalgebra_f64x8", $group, $closure)
-    // };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("nalgebra_f64x8", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_euclid {
-    ($group:ident, $closure:expr) => {
-        bench_lib!("euclid", $group, $closure)
-    };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("euclid", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_vek {
-    ($group:ident, $closure:expr) => {
-        bench_lib!("vek", $group, $closure)
-    };
-    ($group:ident, $size:expr, $closure:expr) => {
-        bench_lib!("vek", $group, $size, $closure)
-    };
-}
-
-#[macro_export]
-macro_rules! bench_pathfinder {
-    ($group:ident, $closure:expr) => {
-        #[cfg(feature = "pathfinder_geometry")]
-        $group.bench_function("pathfinder", $closure)
+    // Display-name override
+    ($lib:literal as $display:literal, $group:ident, $closure:expr) => {
+        #[cfg(feature = $lib)]
+        $group.bench_function($display, $closure)
     };
-    ($group:ident, $size:expr, $closure:expr) => {
-        #[cfg(feature = "pathfinder_geometry")]
-        $group.bench_with_input(
-            criterion::BenchmarkId::new("pathfinder", $size),
-            $size,
-            $closure,
-        )
+    ($lib:literal as $display:literal, $group:ident, $size:expr, $closure:expr) => {
+        #[cfg(feature = $lib)]
+        $group.bench_with_input(criterion::BenchmarkId::new($display, $size), $size, $closure)
     };
 }
 
diff --git a/benches/transform2d.rs b/benches/transform2d.rs
index 3fdecce..5f16cd1 100644
--- a/benches/transform2d.rs
+++ b/benches/transform2d.rs
@@ -6,19 +6,19 @@ use criterion::{criterion_group, criterion_main, Criterion};
 fn bench_transform2_ret_self(c: &mut Criterion) {
     use mathbench::BenchValue;
     let mut group = c.benchmark_group("scalar transform2 return self");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Affine2;
         bench_unop!(b, op => ret_self, ty => Affine2)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Transform2;
         bench_unop!(b, op => ret_self, ty => Transform2<f32>)
     });
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Transform2D, UnknownUnit};
         bench_unop!(b, op => ret_self, ty => Transform2D<f32, UnknownUnit, UnknownUnit>)
     });
-    bench_pathfinder!(group, |b| {
+    bench!("pathfinder_geometry" as "pathfinder", group, |b| {
         use pathfinder_geometry::transform2d::Transform2F;
         bench_unop!(b, op => ret_self, ty => Transform2F)
     });
@@ -27,19 +27,19 @@ fn bench_transform2_ret_self(c: &mut Criterion) {
 
 fn bench_transform2_inverse(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar transform2 inverse");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Affine2;
         bench_unop!(b, op => inverse, ty => Affine2)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Transform2;
         bench_unop!(b, op => try_inverse, ty => Transform2<f32>)
     });
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Transform2D, UnknownUnit};
         bench_unop!(b, op => inverse, ty => Transform2D<f32, UnknownUnit, UnknownUnit>)
     });
-    bench_pathfinder!(group, |b| {
+    bench!("pathfinder_geometry" as "pathfinder", group, |b| {
         use pathfinder_geometry::transform2d::Transform2F;
         bench_unop!(b, op => inverse, ty => Transform2F)
     });
@@ -49,19 +49,19 @@ fn bench_transform2_inverse(c: &mut Criterion) {
 fn bench_transform2_mul_transform2(c: &mut Criterion) {
     use std::ops::Mul;
     let mut group = c.benchmark_group("scalar transform2 mul transform2");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Affine2;
         bench_binop!(b, op => mul, ty1 => Affine2, ty2 => Affine2)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Transform2;
         bench_binop!(b, op => mul, ty1 => Transform2<f32>, ty2 => Transform2<f32>, param => by_ref)
     });
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Transform2D, UnknownUnit};
         bench_binop!(b, op => then, ty => Transform2D<f32, UnknownUnit, UnknownUnit>, param => by_ref)
     });
-    bench_pathfinder!(group, |b| {
+    bench!("pathfinder_geometry" as "pathfinder", group, |b| {
         use pathfinder_geometry::transform2d::Transform2F;
         use std::ops::Mul;
         bench_binop!(b, op => mul, ty1 => Transform2F, ty2 => Transform2F)
diff --git a/benches/transform3d.rs b/benches/transform3d.rs
index f2da983..d3c89d8 100644
--- a/benches/transform3d.rs
+++ b/benches/transform3d.rs
@@ -7,19 +7,19 @@ use criterion::{criterion_group, criterion_main, Criterion};
 fn bench_transform3_ret_self(c: &mut Criterion) {
     use mathbench::BenchValue;
     let mut group = c.benchmark_group("scalar transform3 return self");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Affine3A;
         bench_unop!(b, op => ret_self, ty => Affine3A)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Transform3;
         bench_unop!(b, op => ret_self, ty => Transform3<f32>)
     });
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Transform3D, UnknownUnit};
         bench_unop!(b, op => ret_self, ty => Transform3D<f32, UnknownUnit, UnknownUnit>)
     });
-    bench_pathfinder!(group, |b| {
+    bench!("pathfinder_geometry" as "pathfinder", group, |b| {
         use pathfinder_geometry::transform3d::Transform4F;
         bench_unop!(b, op => ret_self, ty => Transform4F)
     });
@@ -28,19 +28,19 @@ fn bench_transform3_ret_self(c: &mut Criterion) {
 
 fn bench_transform3_inverse(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar transform3 inverse");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Affine3A;
         bench_unop!(b, op => inverse, ty => Affine3A)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Transform3;
         bench_unop!(b, op => try_inverse, ty => Transform3<f32>)
     });
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Transform3D, UnknownUnit};
         bench_unop!(b, op => inverse, ty => Transform3D<f32, UnknownUnit, UnknownUnit>)
     });
-    bench_pathfinder!(group, |b| {
+    bench!("pathfinder_geometry" as "pathfinder", group, |b| {
         use pathfinder_geometry::transform3d::Transform4F;
         bench_unop!(b, op => inverse, ty => Transform4F)
     });
@@ -50,19 +50,19 @@ fn bench_transform3_inverse(c: &mut Criterion) {
 fn bench_transform3_mul_transform3(c: &mut Criterion) {
     use std::ops::Mul;
     let mut group = c.benchmark_group("scalar transform3 mul transform3d");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Affine3A;
         bench_binop!(b, op => mul, ty1 => Affine3A, ty2 => Affine3A)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Transform3;
         bench_binop!(b, op => mul, ty1 => Transform3<f32>, ty2 => Transform3<f32>, param => by_ref)
     });
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{Transform3D, UnknownUnit};
         bench_binop!(b, op => then, ty => Transform3D<f32, UnknownUnit, UnknownUnit>, param => by_ref)
     });
-    bench_pathfinder!(group, |b| {
+    bench!("pathfinder_geometry" as "pathfinder", group, |b| {
         use pathfinder_geometry::transform3d::Transform4F;
         bench_binop!(b, op => mul, ty1 => Transform4F, ty2 => Transform4F)
     });
diff --git a/benches/transformations.rs b/benches/transformations.rs
index 7aea1c8..1b88bf2 100644
--- a/benches/transformations.rs
+++ b/benches/transformations.rs
@@ -7,27 +7,27 @@ fn bench_transform_vector3(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar transform vector3");
     for size in [1, 100].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::{Affine3A, Vec3A};
             bench_binop!(b, size, op => transform_vector3a, ty1 => Affine3A, ty2 => Vec3A)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::{Mat4, Vec3};
             bench_binop!(b, size, op => transform_vec3, ty1 => Mat4, ty2 => Vec3)
         });
-        bench_cgmath!(group, size, |b, size| {
+        bench!("cgmath", group, size, |b, size| {
             use cgmath::{Matrix4, Transform, Vector3};
             bench_binop!(b, size, op => transform_vector, ty1 => Matrix4<f32>, ty2 => Vector3<f32>)
         });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{Transform3, Vector3};
             bench_binop!(b, size, op => transform_vector, ty1 => Transform3<f32>, ty2 => Vector3<f32>, param => by_ref)
         });
-        bench_euclid!(group, size, |b, size| {
+        bench!("euclid", group, size, |b, size| {
             use euclid::{Transform3D, UnknownUnit, Vector3D};
             bench_binop!(b, size, op => transform_vector3d, ty1 => Transform3D<f32, UnknownUnit, UnknownUnit>, ty2 => Vector3D<f32, UnknownUnit>)
         });
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::{Mat4, Vec3};
             bench_binop!(b, size, op => mul_direction, ty1 => Mat4<f32>, ty2 => Vec3<f32>)
         });
@@ -39,15 +39,15 @@ fn bench_transform_vector3_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide transform vector3");
     for size in [16, 256].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::{Affine3A, Vec3A};
             bench_binop_wide!(b, size, width => 1, op => transform_vector3a, ty1 => Affine3A, ty2 => Vec3A)
         });
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::{Mat4x4, Vec3x4};
             bench_binop_wide!(b, size, width => 4, op => transform_vec3, ty1 => Mat4x4, ty2 => Vec3x4)
         });
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::{Mat4x8, Vec3x8};
             bench_binop_wide!(b, size, width => 8, op => transform_vec3, ty1 => Mat4x8, ty2 => Vec3x8)
         });
@@ -59,31 +59,31 @@ fn bench_transform_point3(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar transform point3");
     for size in [1, 100].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::{Affine3A, Vec3A};
             bench_binop!(b, size, op => transform_point3a, ty1 => Affine3A, ty2 => Vec3A)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::{Mat4, Vec3};
             bench_binop!(b, size, op => transform_point3, ty1 => Mat4, ty2 => Vec3)
         });
-        bench_cgmath!(group, size, |b, size| {
+        bench!("cgmath", group, size, |b, size| {
             use cgmath::{Matrix4, Point3, Transform};
             bench_binop!(b, size, op => transform_point, ty1 => Matrix4<f32>, ty2 => Point3<f32>)
         });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{Point3, Transform3};
             bench_binop!(b, size, op => transform_point, ty1 => Transform3<f32>, ty2 => Point3<f32>, param => by_ref)
         });
-        bench_euclid!(group, size, |b, size| {
+        bench!("euclid", group, size, |b, size| {
             use euclid::{Point3D, Transform3D, UnknownUnit};
             bench_binop!(b, size, op => transform_point3d, ty1 => Transform3D<f32, UnknownUnit, UnknownUnit>, ty2 => Point3D<f32, UnknownUnit>)
         });
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::{Mat4, Vec3};
             bench_binop!(b, size, op => mul_point, ty1 => Mat4<f32>, ty2 => Vec3<f32>)
         });
-        bench_pathfinder!(group, size, |b, size| {
+        bench!("pathfinder_geometry" as "pathfinder", group, size, |b, size| {
             // pathfinder doesn't have a point3 or vector3 type
             use pathfinder_geometry::{transform3d::Transform4F, vector::Vector4F};
             use std::ops::Mul;
@@ -97,15 +97,15 @@ fn bench_transform_point3_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide transform point3");
     for size in [16, 256].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::{Affine3A, Vec3A};
             bench_binop_wide!(b, size, width => 1, op => transform_point3a, ty1 => Affine3A, ty2 => Vec3A)
         });
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::{Mat4x4, Vec3x4};
             bench_binop_wide!(b, size, width => 4, op => transform_point3, ty1 => Mat4x4, ty2 => Vec3x4)
         });
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::{Mat4x8, Vec3x8};
             bench_binop_wide!(b, size, width => 8, op => transform_point3, ty1 => Mat4x8, ty2 => Vec3x8)
         });
@@ -117,31 +117,31 @@ fn bench_transform_point2(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar transform point2");
     for size in [1, 100].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::{Affine2, Vec2};
             bench_binop!(b, size, op => transform_point2, ty1 => Affine2, ty2 => Vec2)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::{Mat3, Vec2};
             bench_binop!(b, size, op => transform_point2, ty1 => Mat3, ty2 => Vec2)
         });
-        bench_cgmath!(group, size, |b, size| {
+        bench!("cgmath", group, size, |b, size| {
             use cgmath::{Matrix3, Point2, Transform};
             bench_binop!(b, size, op => transform_point, ty1 => Matrix3<f32>, ty2 => Point2<f32>)
         });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{Point2, Transform2};
             bench_binop!(b, size, op => transform_point, ty1 => Transform2<f32>, ty2 => Point2<f32>, param => by_ref)
         });
-        bench_euclid!(group, size, |b, size| {
+        bench!("euclid", group, size, |b, size| {
             use euclid::{Point2D, Transform2D, UnknownUnit};
             bench_binop!(b, size, op => transform_point, ty1 => Transform2D<f32, UnknownUnit, UnknownUnit>, ty2 => Point2D<f32, UnknownUnit>)
         });
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::{Mat3, Vec2};
             bench_binop!(b, size, op => mul_point_2d, ty1 => Mat3<f32>, ty2 => Vec2<f32>)
         });
-        bench_pathfinder!(group, size, |b, size| {
+        bench!("pathfinder_geometry" as "pathfinder", group, size, |b, size| {
             // pathfinder doesn't have a point type, this is an affine transformation.
             use pathfinder_geometry::{transform2d::Transform2F, vector::Vector2F};
             use std::ops::Mul;
@@ -155,15 +155,15 @@ fn bench_transform_point2_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide transform point2");
     for size in [16, 256].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::{Affine2, Vec2};
             bench_binop_wide!(b, size, width => 1, op => transform_point2, ty1 => Affine2, ty2 => Vec2)
         });
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::{Mat3x4, Vec2x4};
             bench_binop_wide!(b, size, width => 4, op => transform_point2, ty1 => Mat3x4, ty2 => Vec2x4)
         });
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::{Mat3x8, Vec2x8};
             bench_binop_wide!(b, size, width => 8, op => transform_point2, ty1 => Mat3x8, ty2 => Vec2x8)
         });
@@ -175,28 +175,28 @@ fn bench_transform_vector2(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar transform vector2");
     for size in [1, 100].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam!(group, size, |b, size| {
+        bench!("glam", group, size, |b, size| {
             use glam::{Affine2, Vec2};
             bench_binop!(b, size, op => transform_vector2, ty1 => Affine2, ty2 => Vec2)
         });
-        bench_ultraviolet!(group, size, |b, size| {
+        bench!("ultraviolet", group, size, |b, size| {
             use ultraviolet::{Mat3, Vec2};
             bench_binop!(b, size, op => transform_vec2, ty1 => Mat3, ty2 => Vec2)
         });
         // TODO: doesn't compile but might need a macro change to set return type
-        // bench_cgmath!(group, |b| {
+        // bench!("cgmath", group, |b| {
         //     use cgmath::{Matrix3, Transform, Vector2};
         //     bench_binop!(b, op => transform_vector, ty1 => Matrix3<f32>, ty2 => Vector2<f32>)
         // });
-        bench_nalgebra!(group, size, |b, size| {
+        bench!("nalgebra", group, size, |b, size| {
             use nalgebra::{Transform2, Vector2};
             bench_binop!(b, size, op => transform_vector, ty1 => Transform2<f32>, ty2 => Vector2<f32>, param => by_ref)
         });
-        bench_euclid!(group, size, |b, size| {
+        bench!("euclid", group, size, |b, size| {
             use euclid::{Transform2D, UnknownUnit, Vector2D};
             bench_binop!(b, size, op => transform_vector, ty1 => Transform2D<f32, UnknownUnit, UnknownUnit>, ty2 => Vector2D<f32, UnknownUnit>)
         });
-        bench_vek!(group, size, |b, size| {
+        bench!("vek", group, size, |b, size| {
             use vek::{Mat3, Vec2};
             bench_binop!(b, size, op => mul_direction_2d, ty1 => Mat3<f32>, ty2 => Vec2<f32>)
         });
@@ -208,15 +208,15 @@ fn bench_transform_vector2_wide(c: &mut Criterion) {
     let mut group = c.benchmark_group("wide transform vector2");
     for size in [16, 256].iter() {
         group.throughput(criterion::Throughput::Elements(*size as u64));
-        bench_glam_f32x1!(group, size, |b, size| {
+        bench!("glam_f32x1", group, size, |b, size| {
             use glam::{Affine2, Vec2};
             bench_binop_wide!(b, size, width => 1, op => transform_vector2, ty1 => Affine2, ty2 => Vec2)
         });
-        bench_ultraviolet_f32x4!(group, size, |b, size| {
+        bench!("ultraviolet_f32x4", group, size, |b, size| {
             use ultraviolet::{Mat3x4, Vec2x4};
             bench_binop_wide!(b, size, width => 4, op => transform_vec2, ty1 => Mat3x4, ty2 => Vec2x4)
         });
-        bench_ultraviolet_f32x8!(group, size, |b, size| {
+        bench!("ultraviolet_f32x8", group, size, |b, size| {
             use ultraviolet::{Mat3x8, Vec2x8};
             bench_binop_wide!(b, size, width => 8, op => transform_vec2, ty1 => Mat3x8, ty2 => Vec2x8)
         });
diff --git a/benches/vector3.rs b/benches/vector3.rs
index 21b5662..9cbe342 100644
--- a/benches/vector3.rs
+++ b/benches/vector3.rs
@@ -8,24 +8,24 @@ use mathbench::BenchValue;
 // returns self to check overhead of benchmark
 fn bench_vector3_ret_self(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar vector3 return self");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Vec3A;
         bench_unop!(b, op => ret_self, ty => Vec3A)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Vector3;
         bench_unop!(b, op => ret_self, ty => Vector3<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Vec3;
         bench_unop!(b, op => ret_self, ty => Vec3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Vector3;
         bench_unop!(b, op => ret_self, ty => Vector3<f32>)
     });
 
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Vec3;
         bench_unop!(b, op => ret_self, ty => Vec3<f32>)
     });
@@ -36,24 +36,24 @@ fn bench_vector3_ret_self_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide vector3 return self");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Vec3A;
         bench_unop_wide!(b, size, width => 1, op => ret_self, ty => Vec3A)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Vec3x4;
         bench_unop_wide!(b, size, width => 4, op => ret_self, ty => Vec3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Vector3;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => ret_self, ty => Vector3<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Vec3x8;
         bench_unop_wide!(b, size, width => 8, op => ret_self, ty => Vec3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Vector3;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => ret_self, ty => Vector3<f32x8>)
@@ -63,28 +63,28 @@ fn bench_vector3_ret_self_wide(c: &mut Criterion) {
 
 fn bench_vector3_length(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar vector3 length");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Vec3;
         bench_unop!(b, op => length, ty => Vec3)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{InnerSpace, Vector3};
         bench_unop!(b, op => magnitude, ty => Vector3<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Vec3;
         bench_unop!(b, op => mag, ty => Vec3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Vector3;
         bench_unop!(b, op => magnitude, ty => Vector3<f32>)
     });
 
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{UnknownUnit, Vector3D};
         bench_unop!(b, op => length, ty => Vector3D<f32, UnknownUnit>)
     });
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Vec3;
         bench_unop!(b, op => magnitude, ty => Vec3<f32>)
     });
@@ -95,24 +95,24 @@ fn bench_vector3_length_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide vector3 length");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Vec3A;
         bench_unop_wide!(b, size, width => 1, op => length, ty => Vec3A)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Vec3x4;
         bench_unop_wide!(b, size, width => 4, op => mag, ty => Vec3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Vector3;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => norm, ty => Vector3<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Vec3x8;
         bench_unop_wide!(b, size, width => 8, op => mag, ty => Vec3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Vector3;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => norm, ty => Vector3<f32x8>)
@@ -122,27 +122,27 @@ fn bench_vector3_length_wide(c: &mut Criterion) {
 
 fn bench_vector3_normalize(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar vector3 normalize");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Vec3A;
         bench_unop!(b, op => normalize, ty => Vec3A)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{InnerSpace, Vector3};
         bench_unop!(b, op => normalize, ty => Vector3<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Vec3;
         bench_unop!(b, op => normalized, ty => Vec3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Vector3;
         bench_unop!(b, op => normalize, ty => Vector3<f32>)
     });
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{UnknownUnit, Vector3D};
         bench_unop!(b, op => normalize, ty => Vector3D<f32, UnknownUnit>)
     });
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Vec3;
         bench_unop!(b, op => normalized, ty => Vec3<f32>)
     });
@@ -153,24 +153,24 @@ fn bench_vector3_normalize_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide vector3 normalize");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Vec3A;
         bench_unop_wide!(b, size, width => 1, op => normalize, ty => Vec3A)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Vec3x4;
         bench_unop_wide!(b, size, width => 4, op => normalized, ty => Vec3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Vector3;
         use simba::simd::f32x4;
         bench_unop_wide!(b, size, width => 4, op => normalize, ty => Vector3<f32x4>)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Vec3x8;
         bench_unop_wide!(b, size, width => 8, op => normalized, ty => Vec3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Vector3;
         use simba::simd::f32x8;
         bench_unop_wide!(b, size, width => 8, op => normalize, ty => Vector3<f32x8>)
@@ -180,28 +180,28 @@ fn bench_vector3_normalize_wide(c: &mut Criterion) {
 
 fn bench_vector3_dot(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar vector3 dot");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Vec3A;
         bench_binop!(b, op => dot, ty1 => Vec3A, ty2 => Vec3A)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::{InnerSpace, Vector3};
         bench_binop!(b, op => dot, ty1 => Vector3<f32>, ty2 => Vector3<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Vec3;
         bench_binop!(b, op => dot, ty1 => Vec3, ty2 => Vec3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Vector3;
         bench_binop!(b, op => dot, ty1 => Vector3<f32>, ty2 => Vector3<f32>, param => by_ref)
     });
 
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{UnknownUnit, Vector3D};
         bench_binop!(b, op => dot, ty1 => Vector3D<f32, UnknownUnit>, ty2 => Vector3D<f32, UnknownUnit>)
     });
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Vec3;
         bench_binop!(b, op => dot, ty1 => Vec3<f32>, ty2 => Vec3<f32>)
     });
@@ -212,24 +212,24 @@ fn bench_vector3_dot_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide vector3 dot");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Vec3A;
         bench_binop_wide!(b, size, width => 1, op => dot, ty1 => Vec3A, ty2 => Vec3A)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Vec3x4;
         bench_binop_wide!(b, size, width => 4, op => dot, ty1 => Vec3x4, ty2 => Vec3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Vector3;
         use simba::simd::f32x4;
         bench_binop_wide!(b, size, width => 4, op => dot, ty1 => Vector3<f32x4>, ty2 => Vector3<f32x4>, param => by_ref)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Vec3x8;
         bench_binop_wide!(b, size, width => 8, op => dot, ty1 => Vec3x8, ty2 => Vec3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Vector3;
         use simba::simd::f32x8;
         bench_binop_wide!(b, size, width => 8, op => dot, ty1 => Vector3<f32x8>, ty2 => Vector3<f32x8>, param => by_ref)
@@ -239,28 +239,28 @@ fn bench_vector3_dot_wide(c: &mut Criterion) {
 
 fn bench_vector3_cross(c: &mut Criterion) {
     let mut group = c.benchmark_group("scalar vector3 cross");
-    bench_glam!(group, |b| {
+    bench!("glam", group, |b| {
         use glam::Vec3A;
         bench_binop!(b, op => cross, ty1 => Vec3A, ty2 => Vec3A)
     });
-    bench_cgmath!(group, |b| {
+    bench!("cgmath", group, |b| {
         use cgmath::Vector3;
         bench_binop!(b, op => cross, ty1 => Vector3<f32>, ty2 => Vector3<f32>)
     });
-    bench_ultraviolet!(group, |b| {
+    bench!("ultraviolet", group, |b| {
         use ultraviolet::Vec3;
         bench_binop!(b, op => cross, ty1 => Vec3, ty2 => Vec3)
     });
-    bench_nalgebra!(group, |b| {
+    bench!("nalgebra", group, |b| {
         use nalgebra::Vector3;
         bench_binop!(b, op => cross, ty1 => Vector3<f32>, ty2 => Vector3<f32>, param => by_ref)
     });
 
-    bench_euclid!(group, |b| {
+    bench!("euclid", group, |b| {
         use euclid::{UnknownUnit, Vector3D};
         bench_binop!(b, op => cross, ty1 => Vector3D<f32, UnknownUnit>, ty2 => Vector3D<f32, UnknownUnit>)
     });
-    bench_vek!(group, |b| {
+    bench!("vek", group, |b| {
         use vek::Vec3;
         bench_binop!(b, op => cross, ty1 => Vec3<f32>, ty2 => Vec3<f32>)
     });
@@ -271,24 +271,24 @@ fn bench_vector3_cross_wide(c: &mut Criterion) {
     let size = &MIN_WIDE_BENCH_SIZE;
     let mut group = c.benchmark_group("wide vector3 cross");
     group.throughput(criterion::Throughput::Elements(*size));
-    bench_glam_f32x1!(group, size, |b, size| {
+    bench!("glam_f32x1", group, size, |b, size| {
         use glam::Vec3A;
         bench_binop_wide!(b, size, width => 1, op => cross, ty1 => Vec3A, ty2 => Vec3A)
     });
-    bench_ultraviolet_f32x4!(group, size, |b, size| {
+    bench!("ultraviolet_f32x4", group, size, |b, size| {
         use ultraviolet::Vec3x4;
         bench_binop_wide!(b, size, width => 4, op => cross, ty1 => Vec3x4, ty2 => Vec3x4)
     });
-    bench_nalgebra_f32x4!(group, size, |b, size| {
+    bench!("nalgebra_f32x4", group, size, |b, size| {
         use nalgebra::Vector3;
         use simba::simd::f32x4;
         bench_binop_wide!(b, size, width => 4, op => cross, ty1 => Vector3<f32x4>, ty2 => Vector3<f32x4>, param => by_ref)
     });
-    bench_ultraviolet_f32x8!(group, size, |b, size| {
+    bench!("ultraviolet_f32x8", group, size, |b, size| {
         use ultraviolet::Vec3x8;
         bench_binop_wide!(b, size, width => 8, op => cross, ty1 => Vec3x8, ty2 => Vec3x8)
     });
-    bench_nalgebra_f32x8!(group, size, |b, size| {
+    bench!("nalgebra_f32x8", group, size, |b, size| {
         use nalgebra::Vector3;
         use simba::simd::f32x8;
         bench_binop_wide!(b, size, width => 8, op => cross, ty1 => Vector3<f32x8>, ty2 => Vector3<f32x8>, param => by_ref)