diff --git a/Cargo.lock b/Cargo.lock
index c0671e2c4..ac951d4fe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -990,10 +990,8 @@ dependencies = [
 [[package]]
 name = "fearless_simd"
 version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fb2907d1f08b2b316b9223ced5b0e89d87028ba8deae9764741dba8ff7f3903"
+source = "git+https://github.com/linebender/fearless_simd?rev=5999991#5999991189327435c5f16d6a609636b3f63b7ab1"
 dependencies = [
- "bytemuck",
  "libm",
 ]
 
@@ -3944,6 +3942,7 @@ name = "vello_bench"
 version = "0.0.0"
 dependencies = [
  "criterion",
+ "fearless_simd",
  "parley",
  "rand",
  "smallvec",
@@ -4087,6 +4086,7 @@ name = "vello_sparse_tests"
 version = "0.0.0"
 dependencies = [
  "bytemuck",
+ "fearless_simd",
  "image",
  "oxipng",
  "pollster",
diff --git a/Cargo.toml b/Cargo.toml
index 3dad9c96d..0e7800066 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -116,7 +116,7 @@ rayon = { version = "1.10.0" }
 thread_local = "1.1.8"
 crossbeam-channel = "0.5.15"
 ordered-channel = { version = "1.2.0", features = ["crossbeam-channel"] }
-fearless_simd = { version = "0.3.0", default-features = false }
+fearless_simd = { git = "https://github.com/linebender/fearless_simd", rev = "5999991", default-features = false }
 
 # The below crates are experimental!
 vello_api = { path = "sparse_strips/vello_api", default-features = false }
diff --git a/sparse_strips/vello_bench/Cargo.toml b/sparse_strips/vello_bench/Cargo.toml
index d35ebe213..3f2a456bc 100644
--- a/sparse_strips/vello_bench/Cargo.toml
+++ b/sparse_strips/vello_bench/Cargo.toml
@@ -13,6 +13,7 @@ publish = false
 vello_common = { workspace = true }
 vello_cpu = { workspace = true }
 vello_dev_macros = { workspace = true }
+fearless_simd = { workspace = true, features = ["force_support_fallback"] }
 criterion = { workspace = true }
 parley = { version = "0.5.0", default-features = true }
 rand = { workspace = true }
diff --git a/sparse_strips/vello_bench/src/data.rs b/sparse_strips/vello_bench/src/data.rs
index 237a4168f..76b6a2c5b 100644
--- a/sparse_strips/vello_bench/src/data.rs
+++ b/sparse_strips/vello_bench/src/data.rs
@@ -1,6 +1,7 @@
 // Copyright 2025 the Vello Authors
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
+use fearless_simd::Fallback;
 use std::path::Path;
 use std::sync::OnceLock;
 use usvg::tiny_skia_path::PathSegment;
@@ -152,7 +153,7 @@ impl DataItem {
         let tiles = self.sorted_tiles();
 
         strip::render(
-            Level::fallback(),
+            Level::Fallback(Fallback::new()),
             &tiles,
             &mut strip_buf,
             &mut alpha_buf,
diff --git a/sparse_strips/vello_bench/src/glyph.rs b/sparse_strips/vello_bench/src/glyph.rs
index 6a2423a45..a4b016a26 100644
--- a/sparse_strips/vello_bench/src/glyph.rs
+++ b/sparse_strips/vello_bench/src/glyph.rs
@@ -25,7 +25,7 @@ pub fn glyph(c: &mut Criterion) {
         strip_generator: StripGenerator::new(
             WIDTH,
             HEIGHT,
-            Level::try_detect().unwrap_or(Level::fallback()),
+            Level::try_detect().unwrap_or(Level::baseline()),
         ),
         strip_storage: StripStorage::default(),
         glyph_caches: Default::default(),
diff --git a/sparse_strips/vello_common/src/encode.rs b/sparse_strips/vello_common/src/encode.rs
index 952bf1c4e..a206a3b33 100644
--- a/sparse_strips/vello_common/src/encode.rs
+++ b/sparse_strips/vello_common/src/encode.rs
@@ -954,7 +954,7 @@ impl FromF32Color for u8 {
 
     fn from_f32<S: Simd>(mut color: f32x4<S>) -> [Self; 4] {
         let simd = color.simd;
-        color = color.madd(f32x4::splat(simd, 255.0), f32x4::splat(simd, 0.5));
+        color = color.mul_add(f32x4::splat(simd, 255.0), f32x4::splat(simd, 0.5));
 
         [
             color[0] as Self,
@@ -1009,11 +1009,11 @@ impl<T: FromF32Color> GradientLut<T> {
             let scales = f32x16::block_splat(f32x4::from_slice(simd, &range.scale));
 
             ramp_range.clone().step_by(4).for_each(|idx| {
-                let t_vals = f32x4::splat(simd, idx as f32).madd(inv_lut_scale, add_factor);
+                let t_vals = f32x4::splat(simd, idx as f32).mul_add(inv_lut_scale, add_factor);
 
                 let t_vals = element_wise_splat(simd, t_vals);
 
-                let mut result = scales.madd(t_vals, biases);
+                let mut result = scales.mul_add(t_vals, biases);
                 let alphas = result.splat_4th();
                 // Premultiply colors, since we did interpolation in unpremultiplied space.
                 if range.interpolation_alpha_space == InterpolationAlphaSpace::Unpremultiplied {
diff --git a/sparse_strips/vello_common/src/flatten_simd.rs b/sparse_strips/vello_common/src/flatten_simd.rs
index 6c6df7272..3f34be89f 100644
--- a/sparse_strips/vello_common/src/flatten_simd.rs
+++ b/sparse_strips/vello_common/src/flatten_simd.rs
@@ -263,7 +263,7 @@ fn approx_parabola_integral_simd<S: Simd>(x: f32x8<S>) -> f32x8<S> {
     const D: f32 = 0.67;
     const D_POWI_4: f32 = 0.201_511_2;
 
-    let temp1 = f32x8::splat(simd, 0.25).madd(x * x, f32x8::splat(simd, D_POWI_4));
+    let temp1 = f32x8::splat(simd, 0.25).mul_add(x * x, f32x8::splat(simd, D_POWI_4));
     let temp2 = temp1.sqrt();
     let temp3 = temp2.sqrt();
     let temp4 = f32x8::splat(simd, 1.0) - f32x8::splat(simd, D);
@@ -278,7 +278,7 @@ fn approx_parabola_integral_simd_x4<S: Simd>(x: f32x4<S>) -> f32x4<S> {
     const D: f32 = 0.67;
     const D_POWI_4: f32 = 0.201_511_2;
 
-    let temp1 = f32x4::splat(simd, 0.25).madd(x * x, f32x4::splat(simd, D_POWI_4));
+    let temp1 = f32x4::splat(simd, 0.25).mul_add(x * x, f32x4::splat(simd, D_POWI_4));
     let temp2 = temp1.sqrt();
     let temp3 = temp2.sqrt();
     let temp4 = f32x4::splat(simd, 1.0) - f32x4::splat(simd, D);
@@ -294,7 +294,7 @@ fn approx_parabola_inv_integral_simd<S: Simd>(x: f32x8<S>) -> f32x8<S> {
     const ONE_MINUS_B: f32 = 1.0 - B;
 
     let temp1 = f32x8::splat(simd, B * B);
-    let temp2 = f32x8::splat(simd, 0.25).madd(x * x, temp1);
+    let temp2 = f32x8::splat(simd, 0.25).mul_add(x * x, temp1);
     let temp3 = temp2.sqrt();
     let temp4 = f32x8::splat(simd, ONE_MINUS_B) + temp3;
 
@@ -319,9 +319,9 @@ fn eval_simd<S: Simd>(
     let im0 = p0 * mt * mt * mt;
     let im1 = p1 * mt * mt * 3.0;
     let im2 = p2 * mt * 3.0;
-    let im3 = p3.madd(t, im2) * t;
+    let im3 = p3.mul_add(t, im2) * t;
 
-    (im1 + im3).madd(t, im0)
+    (im1 + im3).mul_add(t, im0)
 }
 
 #[inline(always)]
@@ -386,8 +386,8 @@ fn estimate_subdiv_simd<S: Simd>(simd: S, sqrt_tol: f32, ctx: &mut FlattenCtx) {
         let p_onehalf = f32x8::from_slice(simd, &odd_pts[i * 8..][..8]);
         let p2 = f32x8::from_slice(simd, &even_pts[(i * 8 + 2)..][..8]);
         let x = p0 * -0.5;
-        let x1 = p_onehalf.madd(2.0, x);
-        let p1 = p2.madd(-0.5, x1);
+        let x1 = p_onehalf.mul_add(2.0, x);
+        let p1 = p2.mul_add(-0.5, x1);
 
         odd_pts[(i * 8)..][..8].copy_from_slice(p1.as_slice());
 
@@ -402,7 +402,7 @@ fn estimate_subdiv_simd<S: Simd>(simd: S, sqrt_tol: f32, ctx: &mut FlattenCtx) {
         let d02x = d01x + d12x;
         let d02y = d01y + d12y;
         // (d02x * ddy) - (d02y * ddx)
-        let cross = ddx.madd(-d02y, d02x * ddy);
+        let cross = ddx.mul_add(-d02y, d02x * ddy);
 
         let x0_x2_a = {
             let (d01x_low, _) = simd.split_f32x8(d01x);
@@ -416,11 +416,11 @@ fn estimate_subdiv_simd<S: Simd>(simd: S, sqrt_tol: f32, ctx: &mut FlattenCtx) {
 
             simd.combine_f32x4(d12y_low, d01y_low)
         };
-        let x0_x2_num = temp1.madd(ddy, x0_x2_a);
+        let x0_x2_num = temp1.mul_add(ddy, x0_x2_a);
         let x0_x2 = x0_x2_num / cross;
         let (ddx_low, _) = simd.split_f32x8(ddx);
         let (ddy_low, _) = simd.split_f32x8(ddy);
-        let dd_hypot = ddy_low.madd(ddy_low, ddx_low * ddx_low).sqrt();
+        let dd_hypot = ddy_low.mul_add(ddy_low, ddx_low * ddx_low).sqrt();
         let (x0, x2) = simd.split_f32x8(x0_x2);
         let scale_denom = dd_hypot * (x2 - x0);
         let (temp2, _) = simd.split_f32x8(cross);
@@ -469,19 +469,19 @@ fn output_lines_simd<S: Simd>(
 
     const IOTA2: [f32; 8] = [0., 0., 1., 1., 2., 2., 3., 3.];
     let iota2 = f32x8::from_slice(simd, IOTA2.as_ref());
-    let x = iota2.madd(dx, f32x8::splat(simd, x0));
+    let x = iota2.mul_add(dx, f32x8::splat(simd, x0));
     let da = f32x8::splat(simd, ctx.da[i]);
-    let mut a = da.madd(x, f32x8::splat(simd, ctx.a0[i]));
+    let mut a = da.mul_add(x, f32x8::splat(simd, ctx.a0[i]));
     let a_inc = 4.0 * dx * da;
     let uscale = f32x8::splat(simd, ctx.uscale[i]);
 
     for j in 0..n.div_ceil(4) {
         let u = approx_parabola_inv_integral_simd(a);
-        let t = u.madd(uscale, -ctx.u0[i] * uscale);
+        let t = u.mul_add(uscale, -ctx.u0[i] * uscale);
         let mt = 1.0 - t;
         let z = p0 * mt * mt;
-        let z1 = p1.madd(2.0 * t * mt, z);
-        let p = p2.madd(t * t, z1);
+        let z1 = p1.mul_add(2.0 * t * mt, z);
+        let p = p2.mul_add(t * t, z1);
 
         out[j * 8..][..8].copy_from_slice(p.as_slice());
 
diff --git a/sparse_strips/vello_common/src/strip.rs b/sparse_strips/vello_common/src/strip.rs
index 731b58d38..6d48ec855 100644
--- a/sparse_strips/vello_common/src/strip.rs
+++ b/sparse_strips/vello_common/src/strip.rs
@@ -169,7 +169,7 @@ fn render_impl<S: Simd>(
                     for x in 0..Tile::WIDTH as usize {
                         let area = location_winding[x];
                         let coverage = area.abs();
-                        let mulled = coverage.madd(p2, p1);
+                        let mulled = coverage.mul_add(p2, p1);
                         // Note that we are not storing the location winding here but the actual
                         // alpha value as f32, so we reuse the variable as a temporary storage.
                         // Also note that we need the `min` here because the winding can be > 1
@@ -185,9 +185,9 @@ fn render_impl<S: Simd>(
                     #[expect(clippy::needless_range_loop, reason = "dimension clarity")]
                     for x in 0..Tile::WIDTH as usize {
                         let area = location_winding[x];
-                        let im1 = area.madd(p1, p1).floor();
-                        let coverage = p2.madd(im1, area).abs();
-                        let mulled = p3.madd(coverage, p1);
+                        let im1 = area.mul_add(p1, p1).floor();
+                        let coverage = p2.mul_add(im1, area).abs();
+                        let mulled = p3.mul_add(coverage, p1);
                         // TODO: It is possible that, unlike for `NonZero`, we don't need the `min`
                         // here.
                         location_winding[x] = mulled.min(p3);
@@ -346,9 +346,10 @@ fn render_impl<S: Simd>(
             let ymin = px_top_y.max(ymin);
             let ymax = px_bottom_y.min(ymax);
             let h = (ymax - ymin).max(0.0);
-            accumulated_winding = h.madd(sign, accumulated_winding);
+            accumulated_winding = h.mul_add(sign, accumulated_winding);
             for x_idx in 0..Tile::WIDTH {
-                location_winding[x_idx as usize] = h.madd(sign, location_winding[x_idx as usize]);
+                location_winding[x_idx as usize] =
+                    h.mul_add(sign, location_winding[x_idx as usize]);
             }
 
             if line_right_x < 0. {
@@ -392,26 +393,26 @@ fn render_impl<S: Simd>(
             // will be NaN, as `0 * inf` results in NaN. This is true for both the left and
             // right edge. In both cases, the call to `f32::max` will set this to `ymin`.
             let line_px_left_y = (px_left_x - line_top_x)
-                .madd(y_slope, line_top_y)
+                .mul_add(y_slope, line_top_y)
                 .max_precise(ymin)
                 .min_precise(ymax);
             let line_px_right_y = (px_right_x - line_top_x)
-                .madd(y_slope, line_top_y)
+                .mul_add(y_slope, line_top_y)
                 .max_precise(ymin)
                 .min_precise(ymax);
 
             // `x_slope` is always finite, as horizontal geometry is elided.
             let line_px_left_yx =
-                (line_px_left_y - line_top_y).madd(x_slope, f32x4::splat(s, line_top_x));
+                (line_px_left_y - line_top_y).mul_add(x_slope, f32x4::splat(s, line_top_x));
             let line_px_right_yx =
-                (line_px_right_y - line_top_y).madd(x_slope, f32x4::splat(s, line_top_x));
+                (line_px_right_y - line_top_y).mul_add(x_slope, f32x4::splat(s, line_top_x));
             let h = (line_px_right_y - line_px_left_y).abs();
 
             // The trapezoidal area enclosed between the line and the right edge of the pixel
             // square.
             let area = 0.5 * h * (2. * px_right_x - line_px_right_yx - line_px_left_yx);
-            location_winding[x_idx as usize] += area.madd(sign, acc);
-            acc = h.madd(sign, acc);
+            location_winding[x_idx as usize] += area.mul_add(sign, acc);
+            acc = h.mul_add(sign, acc);
         }
 
         accumulated_winding += acc;
diff --git a/sparse_strips/vello_common/src/strip_generator.rs b/sparse_strips/vello_common/src/strip_generator.rs
index 24414310b..85b1f47bf 100644
--- a/sparse_strips/vello_common/src/strip_generator.rs
+++ b/sparse_strips/vello_common/src/strip_generator.rs
@@ -192,7 +192,7 @@ mod tests {
 
     #[test]
     fn reset() {
-        let mut generator = StripGenerator::new(100, 100, Level::fallback());
+        let mut generator = StripGenerator::new(100, 100, Level::baseline());
         let mut storage = StripStorage::default();
         let rect = Rect::new(0.0, 0.0, 100.0, 100.0);
 
diff --git a/sparse_strips/vello_common/src/tile.rs b/sparse_strips/vello_common/src/tile.rs
index e21872c26..74561cc54 100644
--- a/sparse_strips/vello_common/src/tile.rs
+++ b/sparse_strips/vello_common/src/tile.rs
@@ -1053,7 +1053,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &[]);
     }
 
@@ -1078,7 +1078,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, W | T),
             Tile::new(1, 0, 1, W | T),
@@ -1124,7 +1124,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(1, 24, 0, B),
             Tile::new(2, 24, 1, B),
@@ -1147,7 +1147,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, W | T | R),
             Tile::new(1, 0, 0, L | B),
@@ -1178,7 +1178,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 23, 0, B),
             Tile::new(0, 24, 0, W | T | R),
@@ -1209,7 +1209,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(24, 0, 0, R),
             Tile::new(23, 0, 1, R),
@@ -1236,7 +1236,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, L),
             Tile::new(0, 0, 1, L | R),
@@ -1259,7 +1259,7 @@ mod tests {
             p1: Point { x: 90.0, y: -5.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &[]);
     }
 
@@ -1276,7 +1276,7 @@ mod tests {
             },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &[]);
     }
 
@@ -1287,7 +1287,7 @@ mod tests {
             p1: Point { x: 10.0, y: 10.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 2, 0, L | R),
             Tile::new(1, 2, 0, L | R),
@@ -1310,7 +1310,7 @@ mod tests {
             },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(23, 2, 0, R), Tile::new(24, 2, 0, L | R)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1335,7 +1335,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &[]);
     }
 
@@ -1344,14 +1344,14 @@ mod tests {
         let path = BezPath::from_svg("M261,0 L78848,0 L78848,4 L261,4 Z").unwrap();
         let mut line_buf = vec![];
         fill(
-            Level::try_detect().unwrap_or(Level::fallback()),
+            Level::try_detect().unwrap_or(Level::baseline()),
             &path,
             Affine::IDENTITY,
             &mut line_buf,
             &mut FlattenCtx::default(),
         );
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         tiles.assert_tiles_match(&line_buf, 10, 10, &[]);
     }
 
@@ -1372,7 +1372,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, W | T),
             Tile::new(0, 0, 1, W | B | T),
@@ -1409,7 +1409,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 24, 0, B),
             Tile::new(0, 23, 1, B),
@@ -1426,7 +1426,7 @@ mod tests {
             p1: Point { x: 2.0, y: -1.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, W | L | T)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1445,7 +1445,7 @@ mod tests {
             },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(24, 24, 0, R | B)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1461,7 +1461,7 @@ mod tests {
             p1: Point { x: 8.5, y: 1.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, R),
             Tile::new(1, 0, 0, R | L),
@@ -1478,7 +1478,7 @@ mod tests {
             p1: Point { x: 1.5, y: 1.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, R),
             Tile::new(1, 0, 0, R | L),
@@ -1495,7 +1495,7 @@ mod tests {
             p1: Point { x: 12.5, y: 1.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, R),
             Tile::new(1, 0, 0, R | L),
@@ -1513,7 +1513,7 @@ mod tests {
             p1: Point { x: 1.0, y: 8.5 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, B),
             Tile::new(0, 1, 0, W | T | B),
@@ -1530,7 +1530,7 @@ mod tests {
             p1: Point { x: 1.0, y: 13.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, B),
             Tile::new(0, 1, 0, W | T | B),
@@ -1548,7 +1548,7 @@ mod tests {
             p1: Point { x: 1.0, y: 1.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, B),
             Tile::new(0, 1, 0, W | T | B),
@@ -1566,7 +1566,7 @@ mod tests {
             p1: Point { x: 1.0, y: 1.5 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, B),
             Tile::new(0, 1, 0, W | T | B),
@@ -1584,7 +1584,7 @@ mod tests {
             p1: Point { x: 1.0, y: 8.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, B), Tile::new(0, 1, 0, W | T)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1597,7 +1597,7 @@ mod tests {
             p1: Point { x: 1.0, y: 7.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, W | B), Tile::new(0, 1, 0, W | T)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1613,7 +1613,7 @@ mod tests {
             p1: Point { x: 11.0, y: 9.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, R),
             Tile::new(1, 0, 0, L | B),
@@ -1632,7 +1632,7 @@ mod tests {
             p1: Point { x: 1.0, y: 1.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, R),
             Tile::new(1, 0, 0, L | B),
@@ -1651,7 +1651,7 @@ mod tests {
             p1: Point { x: 14.0, y: 6.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(2, 1, 0, R | B),
             Tile::new(3, 1, 0, L),
@@ -1670,7 +1670,7 @@ mod tests {
             p1: Point { x: 2.0, y: 11.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(2, 1, 0, R | B),
             Tile::new(3, 1, 0, L),
@@ -1695,7 +1695,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, 0), Tile::new(0, 0, 1, 0)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1708,7 +1708,7 @@ mod tests {
             p1: Point { x: 5.0, y: 3.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(1, 0, 0, P | L),
             Tile::new(0, 1, 0, P | R),
@@ -1725,7 +1725,7 @@ mod tests {
             p1: Point { x: 0.1, y: 0.1 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, P | R),
             Tile::new(1, 0, 0, P | L),
@@ -1742,7 +1742,7 @@ mod tests {
             p1: Point { x: 9.0, y: 9.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(1, 1, 0, P | R),
             Tile::new(2, 1, 0, P | L),
@@ -1759,7 +1759,7 @@ mod tests {
             p1: Point { x: 9.0, y: 5.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(1, 1, 0, R | B),
             Tile::new(2, 1, 0, L),
@@ -1776,7 +1776,7 @@ mod tests {
             p1: Point { x: 4.0, y: 4.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, W | P | R), Tile::new(1, 0, 0, L)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1789,7 +1789,7 @@ mod tests {
             p1: Point { x: 4.0, y: 0.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, P | R), Tile::new(1, 0, 0, W | L)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1802,7 +1802,7 @@ mod tests {
             p1: Point { x: 8.0, y: 8.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, W | P | R),
             Tile::new(1, 0, 0, P | L),
@@ -1820,7 +1820,7 @@ mod tests {
             p1: Point { x: 8.0, y: 0.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(1, 0, 0, P | R | L),
             Tile::new(2, 0, 0, W | L),
@@ -1838,7 +1838,7 @@ mod tests {
             p1: Point { x: 8.0, y: 2.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, R),
             Tile::new(1, 0, 0, R | L),
@@ -1855,7 +1855,7 @@ mod tests {
             p1: Point { x: 4.0, y: 0.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, P | R | B),
             Tile::new(1, 0, 0, W | L),
@@ -1872,7 +1872,7 @@ mod tests {
             p1: Point { x: 4.0, y: 8.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [
             Tile::new(0, 0, 0, W | B),
             Tile::new(0, 1, 0, W | P | R | T),
@@ -1892,7 +1892,7 @@ mod tests {
             p1: Point { x: 3.0, y: 3.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, 0)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1905,7 +1905,7 @@ mod tests {
             p1: Point { x: 3.0, y: 1.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, 0)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1918,7 +1918,7 @@ mod tests {
             p1: Point { x: 1.0, y: 3.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, W)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1931,7 +1931,7 @@ mod tests {
             p1: Point { x: 4.0, y: 1.0 },
         }];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, R), Tile::new(1, 0, 0, L)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1950,7 +1950,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, 0), Tile::new(0, 0, 1, 0)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1969,7 +1969,7 @@ mod tests {
             },
         ];
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         let expected = [Tile::new(0, 0, 0, W), Tile::new(0, 0, 1, W)];
 
         tiles.assert_tiles_match(&lines, VIEW_DIM, VIEW_DIM, &expected);
@@ -1986,7 +1986,7 @@ mod tests {
             p1: Point { x: 224.0, y: 388.0 },
         };
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         tiles.make_tiles_msaa(&[line], 600, 600);
         tiles.make_tiles_analytic_aa(&[line], 600, 600);
     }
@@ -2005,7 +2005,7 @@ mod tests {
             },
         };
 
-        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
+        let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::baseline()));
         tiles.make_tiles_analytic_aa(&[line], 200, 100);
         tiles.make_tiles_msaa(&[line], 200, 100);
     }
@@ -2013,7 +2013,7 @@ mod tests {
     #[test]
     fn sort_test() {
         let mut lines = vec![];
-        let mut tiles = Tiles::new(Level::fallback());
+        let mut tiles = Tiles::new(Level::baseline());
 
         let step = 4.0;
         let mut y = F_V_DIM - 10.0;
diff --git a/sparse_strips/vello_cpu/src/fine/common/gradient/radial.rs b/sparse_strips/vello_cpu/src/fine/common/gradient/radial.rs
index e7dcba84e..217ea57aa 100644
--- a/sparse_strips/vello_cpu/src/fine/common/gradient/radial.rs
+++ b/sparse_strips/vello_cpu/src/fine/common/gradient/radial.rs
@@ -3,7 +3,7 @@
 
 use crate::fine::common::gradient::SimdGradientKind;
 use vello_common::encode::{FocalData, RadialKind};
-use vello_common::fearless_simd::{Simd, SimdBase, f32x8};
+use vello_common::fearless_simd::*;
 
 pub(crate) enum SimdRadialKindInner<S: Simd> {
     Radial {
diff --git a/sparse_strips/vello_cpu/src/fine/common/gradient/sweep.rs b/sparse_strips/vello_cpu/src/fine/common/gradient/sweep.rs
index 4c2dda35b..02a0a401f 100644
--- a/sparse_strips/vello_cpu/src/fine/common/gradient/sweep.rs
+++ b/sparse_strips/vello_cpu/src/fine/common/gradient/sweep.rs
@@ -45,9 +45,9 @@ fn x_y_to_unit_angle<S: Simd>(simd: S, x: f32x8<S>, y: f32x8<S>) -> f32x8<S> {
     let slope = x_abs.min(y_abs) / x_abs.max(y_abs);
     let s = slope * slope;
 
-    let a = f32x8::splat(simd, -7.054_738_2e-3).madd(s, f32x8::splat(simd, 2.476_102e-2));
-    let b = a.madd(s, f32x8::splat(simd, -5.185_397e-2));
-    let c = b.madd(s, f32x8::splat(simd, 0.159_121_17));
+    let a = f32x8::splat(simd, -7.054_738_2e-3).mul_add(s, f32x8::splat(simd, 2.476_102e-2));
+    let b = a.mul_add(s, f32x8::splat(simd, -5.185_397e-2));
+    let c = b.mul_add(s, f32x8::splat(simd, 0.159_121_17));
 
     let mut phi = slope * c;
 
diff --git a/sparse_strips/vello_cpu/src/fine/common/image.rs b/sparse_strips/vello_cpu/src/fine/common/image.rs
index b144d6e6b..88f2a50f8 100644
--- a/sparse_strips/vello_cpu/src/fine/common/image.rs
+++ b/sparse_strips/vello_cpu/src/fine/common/image.rs
@@ -259,7 +259,7 @@ impl<S: Simd> Iterator for FilteredImagePainter<'_, S> {
                         let color_sample = sample(x_positions, y_positions);
                         let w = element_wise_splat(self.simd, cx[x_idx] * cy[y_idx]);
 
-                        interpolated_color = w.madd(color_sample, interpolated_color);
+                        interpolated_color = w.mul_add(color_sample, interpolated_color);
                     }
                 }
 
@@ -298,7 +298,7 @@ impl<S: Simd> Iterator for FilteredImagePainter<'_, S> {
                         let color_sample = sample(x_positions, y_positions);
                         let w = element_wise_splat(self.simd, cx[x_idx] * cy[y_idx]);
 
-                        interpolated_color = w.madd(color_sample, interpolated_color);
+                        interpolated_color = w.mul_add(color_sample, interpolated_color);
                     }
                 }
 
@@ -417,7 +417,7 @@ pub(crate) fn extend<S: Simd>(
         crate::peniko::Extend::Pad => val.min(max - bias).max(f32x4::splat(simd, 0.0)),
         crate::peniko::Extend::Repeat => {
             // floor := (val * inv_max).floor() * max is the nearest multiple of `max` below val.
-            max.madd(-(val * inv_max).floor(), val)
+            max.mul_add(-(val * inv_max).floor(), val)
                 // In certain edge cases, we might still end up with a higher number.
                 .min(max - 1.0)
         }
@@ -494,7 +494,7 @@ fn single_weight<S: Simd>(
     c: f32x4<S>,
     d: f32x4<S>,
 ) -> f32x4<S> {
-    t.madd(d, c).madd(t, b).madd(t, a)
+    t.mul_add(d, c).mul_add(t, b).mul_add(t, a)
 }
 
 /// Mitchell filter with the variables B = 1/3 and C = 1/3.
diff --git a/sparse_strips/vello_cpu/src/fine/common/rounded_blurred_rect.rs b/sparse_strips/vello_cpu/src/fine/common/rounded_blurred_rect.rs
index 973b46b0c..75c3f44eb 100644
--- a/sparse_strips/vello_cpu/src/fine/common/rounded_blurred_rect.rs
+++ b/sparse_strips/vello_cpu/src/fine/common/rounded_blurred_rect.rs
@@ -138,15 +138,15 @@ impl<S: Simd> Iterator for AlphaCalculator<S> {
         let r = &self.r;
 
         // Equivalent to j + r.v1 - r.v1 * r.height
-        let y = j - r.v1.msub(r.height, r.v1);
+        let y = j - r.v1.mul_sub(r.height, r.v1);
         // Equivalent to r.r1 + y.abs() - (r.h * r.v1)
-        let y0 = r.r1 - r.h.msub(r.v1, y.abs());
+        let y0 = r.r1 - r.h.mul_sub(r.v1, y.abs());
         let y1 = y0.max(r.v0);
 
         // Equivalent to i + r.v1 - r.v1 * r.width
-        let x = i - r.v1.msub(r.width, r.v1);
+        let x = i - r.v1.mul_sub(r.width, r.v1);
         // Equivalent to r.r1 + x.abs() - (r.w * r.v1)
-        let x0 = r.r1 - r.w.msub(r.v1, x.abs());
+        let x0 = r.r1 - r.w.mul_sub(r.v1, x.abs());
         let x1 = x0.max(r.v0);
         let d_pos = (x1.powf(r.exponent) + y1.powf(r.exponent)).powf(r.recip_exponent);
         let d_neg = x0.max(y0).min(r.v0);
@@ -222,11 +222,11 @@ impl<S: Simd> FloatExt<S> for f32x8<S> {
     fn compute_erf7(simd: S, x: Self) -> Self {
         let x = x * Self::splat(simd, core::f32::consts::FRAC_2_SQRT_PI);
         let xx = x * x;
-        let p1 = Self::splat(simd, 0.0104).madd(xx, Self::splat(simd, 0.03395));
-        let p2 = p1.madd(xx, Self::splat(simd, 0.24295));
+        let p1 = Self::splat(simd, 0.0104).mul_add(xx, Self::splat(simd, 0.03395));
+        let p2 = p1.mul_add(xx, Self::splat(simd, 0.24295));
         let p3 = x * xx;
-        let x = p2.madd(p3, x);
-        let denom = x.madd(x, Self::splat(simd, 1.0)).sqrt();
+        let x = p2.mul_add(p3, x);
+        let denom = x.mul_add(x, Self::splat(simd, 1.0)).sqrt();
         x / denom
     }
 
diff --git a/sparse_strips/vello_cpu/src/fine/highp/mod.rs b/sparse_strips/vello_cpu/src/fine/highp/mod.rs
index f5c1e480b..e2871b9ef 100644
--- a/sparse_strips/vello_cpu/src/fine/highp/mod.rs
+++ b/sparse_strips/vello_cpu/src/fine/highp/mod.rs
@@ -377,7 +377,7 @@ mod fill {
         one_minus_alpha: f32x16<S>,
     ) {
         let mut bg_c = f32x16::from_slice(s, dest);
-        bg_c = one_minus_alpha.madd(bg_c, src);
+        bg_c = one_minus_alpha.mul_add(bg_c, src);
         dest.copy_from_slice(bg_c.as_slice());
     }
 }
@@ -483,9 +483,9 @@ mod alpha_fill {
         let bg_c = f32x16::from_slice(s, dest);
         let mask_a = extract_masks(s, masks);
         // 1 - src_a * mask_a
-        let inv_src_a_mask_a = src_a.madd(-mask_a, one);
+        let inv_src_a_mask_a = src_a.mul_add(-mask_a, one);
 
-        let res = bg_c.madd(inv_src_a_mask_a, src_c * mask_a);
+        let res = bg_c.mul_add(inv_src_a_mask_a, src_c * mask_a);
         dest.copy_from_slice(res.as_slice());
     }
 }
diff --git a/sparse_strips/vello_cpu/src/fine/lowp/image.rs b/sparse_strips/vello_cpu/src/fine/lowp/image.rs
index 4460e94f4..11d467384 100644
--- a/sparse_strips/vello_cpu/src/fine/lowp/image.rs
+++ b/sparse_strips/vello_cpu/src/fine/lowp/image.rs
@@ -5,7 +5,7 @@ use crate::fine::PosExt;
 use crate::fine::common::image::{ImagePainterData, extend, sample};
 use crate::fine::macros::u8x16_painter;
 use vello_common::encode::EncodedImage;
-use vello_common::fearless_simd::{Simd, SimdBase, f32x4, u8x16};
+use vello_common::fearless_simd::*;
 use vello_common::pixmap::Pixmap;
 use vello_common::simd::element_wise_splat;
 use vello_common::util::f32_to_u8;
diff --git a/sparse_strips/vello_cpu/src/fine/lowp/mod.rs b/sparse_strips/vello_cpu/src/fine/lowp/mod.rs
index b56531149..8b0e71b74 100644
--- a/sparse_strips/vello_cpu/src/fine/lowp/mod.rs
+++ b/sparse_strips/vello_cpu/src/fine/lowp/mod.rs
@@ -530,9 +530,9 @@ fn mix<S: Simd>(src_c: u8x32<S>, bg_c: u8x32<S>, blend_mode: BlendMode) -> u8x32
 
     let to_u8 = |val1: f32x16<S>, val2: f32x16<S>| {
         let val1 =
-            f32_to_u8(f32x16::splat(val1.simd, 255.0).madd(val1, f32x16::splat(val1.simd, 0.5)));
+            f32_to_u8(f32x16::splat(val1.simd, 255.0).mul_add(val1, f32x16::splat(val1.simd, 0.5)));
         let val2 =
-            f32_to_u8(f32x16::splat(val2.simd, 255.0).madd(val2, f32x16::splat(val2.simd, 0.5)));
+            f32_to_u8(f32x16::splat(val2.simd, 255.0).mul_add(val2, f32x16::splat(val2.simd, 0.5)));
 
         val1.simd.combine_u8x16(val1, val2)
     };
diff --git a/sparse_strips/vello_cpu/src/fine/mod.rs b/sparse_strips/vello_cpu/src/fine/mod.rs
index 194f06be0..12fe10f33 100644
--- a/sparse_strips/vello_cpu/src/fine/mod.rs
+++ b/sparse_strips/vello_cpu/src/fine/mod.rs
@@ -113,7 +113,7 @@ impl<S: Simd> NumericVec<S> for u8x16<S> {
     fn from_f32(simd: S, val: f32x16<S>) -> Self {
         let v1 = f32x16::splat(simd, 255.0);
         let v2 = f32x16::splat(simd, 0.5);
-        let mulled = val.madd(v1, v2);
+        let mulled = val.mul_add(v1, v2);
 
         f32_to_u8(mulled)
     }
@@ -914,7 +914,7 @@ impl<S: Simd> PosExt<S> for f32x4<S> {
         let columns: [f32; Tile::HEIGHT as usize] = [0.0, 1.0, 2.0, 3.0];
         let column_mask: Self = columns.simd_into(simd);
 
-        column_mask.madd(Self::splat(simd, y_advance), Self::splat(simd, pos))
+        column_mask.mul_add(Self::splat(simd, y_advance), Self::splat(simd, pos))
     }
 }
 
diff --git a/sparse_strips/vello_cpu/src/render.rs b/sparse_strips/vello_cpu/src/render.rs
index 49025a573..a3164649e 100644
--- a/sparse_strips/vello_cpu/src/render.rs
+++ b/sparse_strips/vello_cpu/src/render.rs
@@ -100,7 +100,7 @@ pub struct RenderSettings {
 impl Default for RenderSettings {
     fn default() -> Self {
         Self {
-            level: Level::try_detect().unwrap_or(Level::fallback()),
+            level: Level::try_detect().unwrap_or(Level::baseline()),
             #[cfg(feature = "multithreading")]
             num_threads: (std::thread::available_parallelism()
                 .unwrap()
@@ -1129,7 +1129,7 @@ mod tests {
 
         let mut pixmap = Pixmap::new(200, 200);
         let settings = RenderSettings {
-            level: Level::try_detect().unwrap_or(Level::fallback()),
+            level: Level::baseline(),
             num_threads: 1,
             render_mode: RenderMode::OptimizeQuality,
         };
diff --git a/sparse_strips/vello_hybrid/examples/wgpu_webgl/src/lib.rs b/sparse_strips/vello_hybrid/examples/wgpu_webgl/src/lib.rs
index 2c92302c1..d0e763deb 100644
--- a/sparse_strips/vello_hybrid/examples/wgpu_webgl/src/lib.rs
+++ b/sparse_strips/vello_hybrid/examples/wgpu_webgl/src/lib.rs
@@ -85,7 +85,7 @@ impl RendererWrapper {
                 height,
             },
             RenderSettings {
-                level: Level::try_detect().unwrap_or(Level::fallback()),
+                level: Level::try_detect().unwrap_or(Level::baseline()),
                 atlas_config: AtlasConfig {
                     atlas_size: (max_texture_dimension_2d, max_texture_dimension_2d),
                     ..AtlasConfig::default()
diff --git a/sparse_strips/vello_hybrid/src/gradient_cache.rs b/sparse_strips/vello_hybrid/src/gradient_cache.rs
index 73b41dee0..26b922d7d 100644
--- a/sparse_strips/vello_hybrid/src/gradient_cache.rs
+++ b/sparse_strips/vello_hybrid/src/gradient_cache.rs
@@ -343,7 +343,7 @@ mod tests {
 
     #[test]
     fn test_cache_empty() {
-        let mut cache = GradientRampCache::new(5, Level::fallback());
+        let mut cache = GradientRampCache::new(5, Level::baseline());
         cache.maintain();
 
         assert_eq!(cache.cache.len(), 0);
@@ -354,7 +354,7 @@ mod tests {
 
     #[test]
     fn test_unique_entry_creation() {
-        let mut cache = GradientRampCache::new(5, Level::fallback());
+        let mut cache = GradientRampCache::new(5, Level::baseline());
         insert_entries(&mut cache, 4);
         cache.maintain();
 
@@ -365,7 +365,7 @@ mod tests {
 
     #[test]
     fn test_no_eviction_under_limit() {
-        let mut cache = GradientRampCache::new(5, Level::fallback());
+        let mut cache = GradientRampCache::new(5, Level::baseline());
         insert_entries(&mut cache, 4);
         cache.maintain();
 
@@ -374,7 +374,7 @@ mod tests {
 
     #[test]
     fn test_no_eviction_at_limit() {
-        let mut cache = GradientRampCache::new(5, Level::fallback());
+        let mut cache = GradientRampCache::new(5, Level::baseline());
         insert_entries(&mut cache, 5);
         cache.maintain();
 
@@ -383,7 +383,7 @@ mod tests {
 
     #[test]
     fn test_eviction_over_limit() {
-        let mut cache = GradientRampCache::new(5, Level::fallback());
+        let mut cache = GradientRampCache::new(5, Level::baseline());
         insert_entries(&mut cache, 10);
         cache.maintain();
 
@@ -393,7 +393,7 @@ mod tests {
 
     #[test]
     fn test_lut_compaction_and_offset_updates() {
-        let mut cache = GradientRampCache::new(2, Level::fallback());
+        let mut cache = GradientRampCache::new(2, Level::baseline());
 
         // Start from 1 to keep LUT sizes consistent, making it easier to test LUT size
         // before and after eviction.
@@ -436,7 +436,7 @@ mod tests {
 
     #[test]
     fn test_correct_lru_eviction() {
-        let mut cache = GradientRampCache::new(3, Level::fallback());
+        let mut cache = GradientRampCache::new(3, Level::baseline());
 
         // Insert 3 gradients to fill the cache
         let gradient1 = create_gradient(0.1);
@@ -493,7 +493,7 @@ mod tests {
 
     #[test]
     fn test_take_and_restore_luts() {
-        let mut cache = GradientRampCache::new(5, Level::fallback());
+        let mut cache = GradientRampCache::new(5, Level::baseline());
 
         let gradient1 = create_gradient(0.1);
         let gradient2 = create_gradient(0.2);
@@ -526,7 +526,7 @@ mod tests {
 
     #[test]
     fn test_lut_start_invalidation() {
-        let mut cache = GradientRampCache::new(2, Level::fallback());
+        let mut cache = GradientRampCache::new(2, Level::baseline());
 
         let gradient_1 = create_encoded_gradient(create_gradient(0.1));
         let gradient_2 = create_encoded_gradient(create_gradient(0.2));
diff --git a/sparse_strips/vello_hybrid/src/scene.rs b/sparse_strips/vello_hybrid/src/scene.rs
index f6226d796..af4fd2f8f 100644
--- a/sparse_strips/vello_hybrid/src/scene.rs
+++ b/sparse_strips/vello_hybrid/src/scene.rs
@@ -49,7 +49,7 @@ pub struct RenderSettings {
 impl Default for RenderSettings {
     fn default() -> Self {
         Self {
-            level: Level::try_detect().unwrap_or(Level::fallback()),
+            level: Level::try_detect().unwrap_or(Level::baseline()),
             atlas_config: AtlasConfig::default(),
         }
     }
diff --git a/sparse_strips/vello_sparse_tests/Cargo.toml b/sparse_strips/vello_sparse_tests/Cargo.toml
index aa6dbd555..1526f41af 100644
--- a/sparse_strips/vello_sparse_tests/Cargo.toml
+++ b/sparse_strips/vello_sparse_tests/Cargo.toml
@@ -18,6 +18,7 @@ path = "tests/mod.rs"
 vello_api = { workspace = true }
 vello_common = { workspace = true, features = ["std"] }
 vello_cpu = { workspace = true, features = ["multithreading", "std", "f32_pipeline"] }
+fearless_simd = { workspace = true, features = ["force_support_fallback"] }
 vello_hybrid = { workspace = true }
 wgpu = { workspace = true, default-features = true }
 pollster = { workspace = true }
diff --git a/sparse_strips/vello_sparse_tests/tests/filter.rs b/sparse_strips/vello_sparse_tests/tests/filter.rs
index 5c3776bc8..398703975 100644
--- a/sparse_strips/vello_sparse_tests/tests/filter.rs
+++ b/sparse_strips/vello_sparse_tests/tests/filter.rs
@@ -5,6 +5,7 @@
 
 use crate::util::circular_star;
 use crate::{renderer::Renderer, util::layout_glyphs_roboto};
+use fearless_simd::Fallback;
 use vello_common::color::AlphaColor;
 use vello_common::color::palette::css::{
     PURPLE, REBECCA_PURPLE, ROYAL_BLUE, SEA_GREEN, TOMATO, VIOLET, WHITE,
@@ -34,7 +35,7 @@ fn filter_flood(ctx: &mut impl Renderer) {
         width,
         height,
         vello_cpu::RenderSettings {
-            level: vello_cpu::Level::fallback(),
+            level: vello_cpu::Level::Fallback(Fallback::new()),
             num_threads: 0,
             render_mode: vello_cpu::RenderMode::default(),
         },
diff --git a/sparse_strips/vello_sparse_tests/tests/issues.rs b/sparse_strips/vello_sparse_tests/tests/issues.rs
index 0aba2d835..2441eb17d 100644
--- a/sparse_strips/vello_sparse_tests/tests/issues.rs
+++ b/sparse_strips/vello_sparse_tests/tests/issues.rs
@@ -405,7 +405,7 @@ fn gradient_color_alpha_unmul(ctx: &mut impl Renderer) {
 #[test]
 fn multi_threading_oob_access() {
     let settings = RenderSettings {
-        level: Level::try_detect().unwrap_or(Level::fallback()),
+        level: Level::try_detect().unwrap_or(Level::baseline()),
         num_threads: 4,
         render_mode: RenderMode::OptimizeQuality,
     };
diff --git a/sparse_strips/vello_sparse_tests/tests/mask.rs b/sparse_strips/vello_sparse_tests/tests/mask.rs
index b3fe27995..bab58af61 100644
--- a/sparse_strips/vello_sparse_tests/tests/mask.rs
+++ b/sparse_strips/vello_sparse_tests/tests/mask.rs
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
 use crate::renderer::Renderer;
+use fearless_simd::Fallback;
 use smallvec::smallvec;
 use vello_common::color::DynamicColor;
 use vello_common::color::palette::css::{BLACK, LIME, RED, YELLOW};
@@ -17,7 +18,7 @@ pub(crate) fn example_mask(alpha_mask: bool) -> Mask {
     let mut mask_pix = Pixmap::new(100, 100);
     // TODO: Would be nice to take the settings from the current test context.
     let settings = RenderSettings {
-        level: Level::fallback(),
+        level: Level::Fallback(Fallback::new()),
         num_threads: 0,
         render_mode: RenderMode::OptimizeSpeed,
     };
diff --git a/sparse_strips/vello_sparse_tests/tests/util.rs b/sparse_strips/vello_sparse_tests/tests/util.rs
index 33ec30086..ec2bca611 100644
--- a/sparse_strips/vello_sparse_tests/tests/util.rs
+++ b/sparse_strips/vello_sparse_tests/tests/util.rs
@@ -18,6 +18,7 @@ use vello_common::peniko::{Blob, ColorStop, ColorStops, FontData};
 use vello_common::pixmap::Pixmap;
 use vello_cpu::{Level, RenderMode};
 
+use fearless_simd::Fallback;
 #[cfg(not(target_arch = "wasm32"))]
 use std::path::PathBuf;
 
@@ -61,16 +62,10 @@ pub(crate) fn get_ctx<T: Renderer>(
 ) -> T {
     let level = match level {
         #[cfg(target_arch = "aarch64")]
-        "neon" => Level::Neon(
-            Level::try_detect()
-                .unwrap_or(Level::fallback())
-                .as_neon()
-                .expect("neon should be available"),
-        ),
+        "neon" => Level::Neon(Level::new().as_neon().expect("neon should be available")),
         #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))]
         "wasm_simd128" => Level::WasmSimd128(
-            Level::try_detect()
-                .unwrap_or(Level::fallback())
+            Level::new()
                 .as_wasm_simd128()
                 .expect("wasm simd128 should be available"),
         ),
@@ -92,7 +87,7 @@ pub(crate) fn get_ctx<T: Renderer>(
                 panic!("avx2 or fma feature not detected");
             }
         }
-        "fallback" => Level::fallback(),
+        "fallback" => Level::Fallback(Fallback::new()),
         _ => panic!("unknown level: {level}"),
     };