diff --git a/crates/core_simd/src/fmt.rs b/crates/core_simd/src/fmt.rs
index 3a540f5a049..90c520e75bb 100644
--- a/crates/core_simd/src/fmt.rs
+++ b/crates/core_simd/src/fmt.rs
@@ -1,9 +1,8 @@
-use crate::simd::{LaneCount, Simd, SimdElement, SupportedLaneCount};
+use crate::simd::{Simd, SimdElement};
 use core::fmt;
 
 impl<T, const N: usize> fmt::Debug for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement + fmt::Debug,
 {
     /// A `Simd<T, N>` has a debug format like the one for `[T]`:
diff --git a/crates/core_simd/src/iter.rs b/crates/core_simd/src/iter.rs
index b3732fd74d5..fdc458efeda 100644
--- a/crates/core_simd/src/iter.rs
+++ b/crates/core_simd/src/iter.rs
@@ -1,4 +1,4 @@
-use crate::simd::{LaneCount, Simd, SupportedLaneCount};
+use crate::simd::Simd;
 use core::{
     iter::{Product, Sum},
     ops::{Add, Mul},
@@ -7,8 +7,6 @@ use core::{
 macro_rules! impl_traits {
     { $type:ty } => {
         impl<const N: usize> Sum<Self> for Simd<$type, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
@@ -17,8 +15,6 @@ macro_rules! impl_traits {
         }
 
         impl<const N: usize> Product<Self> for Simd<$type, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn product<I: Iterator<Item = Self>>(iter: I) -> Self {
@@ -27,8 +23,6 @@ macro_rules! impl_traits {
         }
 
         impl<'a, const N: usize> Sum<&'a Self> for Simd<$type, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self {
@@ -37,8 +31,6 @@ macro_rules! impl_traits {
         }
 
         impl<'a, const N: usize> Product<&'a Self> for Simd<$type, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self {
diff --git a/crates/core_simd/src/lane_count.rs b/crates/core_simd/src/lane_count.rs
deleted file mode 100644
index 839195c38ed..00000000000
--- a/crates/core_simd/src/lane_count.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-mod sealed {
-    pub trait Sealed {}
-}
-use sealed::Sealed;
-
-/// Specifies the number of lanes in a SIMD vector as a type.
-pub struct LaneCount<const N: usize>;
-
-impl<const N: usize> LaneCount<N> {
-    /// The number of bytes in a bitmask with this many lanes.
-    pub const BITMASK_LEN: usize = N.div_ceil(8);
-}
-
-/// Statically guarantees that a lane count is marked as supported.
-///
-/// This trait is *sealed*: the list of implementors below is total.
-/// Users do not have the ability to mark additional `LaneCount<N>` values as supported.
-/// Only SIMD vectors with supported lane counts are constructable.
-pub trait SupportedLaneCount: Sealed {
-    #[doc(hidden)]
-    type BitMask: Copy + AsRef<[u8]> + AsMut<[u8]>;
-    #[doc(hidden)]
-    const EMPTY_BIT_MASK: Self::BitMask;
-    #[doc(hidden)]
-    const FULL_BIT_MASK: Self::BitMask;
-}
-
-impl<const N: usize> Sealed for LaneCount<N> {}
-
-macro_rules! supported_lane_count {
-    ($($lanes:literal),+) => {
-        $(
-            impl SupportedLaneCount for LaneCount<$lanes> {
-                type BitMask = [u8; Self::BITMASK_LEN];
-                const EMPTY_BIT_MASK: Self::BitMask = [0; Self::BITMASK_LEN];
-                const FULL_BIT_MASK: Self::BitMask = {
-                    let mut array = [!0u8; Self::BITMASK_LEN];
-                    if $lanes % 8 > 0 {
-                        array[Self::BITMASK_LEN - 1] = (!0) >> (8 - $lanes % 8);
-                    }
-                    array
-                };
-            }
-        )+
-    };
-}
-
-supported_lane_count!(
-    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
-    27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
-    51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64
-);
diff --git a/crates/core_simd/src/lib.rs b/crates/core_simd/src/lib.rs
index 9d7dfd2ab35..3e5ebe19e4d 100644
--- a/crates/core_simd/src/lib.rs
+++ b/crates/core_simd/src/lib.rs
@@ -9,7 +9,8 @@
     simd_ffi,
     staged_api,
     prelude_import,
-    ptr_metadata
+    ptr_metadata,
+    rustc_attrs
 )]
 #![cfg_attr(
     all(
diff --git a/crates/core_simd/src/masks.rs b/crates/core_simd/src/masks.rs
index 7baa9647591..3e2209556b6 100644
--- a/crates/core_simd/src/masks.rs
+++ b/crates/core_simd/src/masks.rs
@@ -2,7 +2,7 @@
 //! Types representing
 #![allow(non_camel_case_types)]
 
-use crate::simd::{LaneCount, Select, Simd, SimdCast, SimdElement, SupportedLaneCount};
+use crate::simd::{Select, Simd, SimdCast, SimdElement};
 use core::cmp::Ordering;
 use core::{fmt, mem};
 
@@ -41,7 +41,6 @@ mod sealed {
     pub trait Sealed {
         fn valid<const N: usize>(values: Simd<Self, N>) -> bool
         where
-            LaneCount<N>: SupportedLaneCount,
             Self: SimdElement;
 
         fn eq(self, other: Self) -> bool;
@@ -69,8 +68,6 @@ macro_rules! impl_element {
         impl Sealed for $ty {
             #[inline]
             fn valid<const N: usize>(value: Simd<Self, N>) -> bool
-            where
-                LaneCount<N>: SupportedLaneCount,
             {
                 // We can't use `Simd` directly, because `Simd`'s functions call this function and
                 // we will end up with an infinite loop.
@@ -121,23 +118,19 @@ impl_element! { isize, usize }
 /// The layout of this type is unspecified, and may change between platforms
 /// and/or Rust versions, and code should not assume that it is equivalent to
 /// `[T; N]`.
+///
+/// `N` cannot be 0 and may be at most 64. This limit may be increased in
+/// the future.
 #[repr(transparent)]
 pub struct Mask<T, const N: usize>(Simd<T, N>)
 where
-    T: MaskElement,
-    LaneCount<N>: SupportedLaneCount;
+    T: MaskElement;
 
-impl<T, const N: usize> Copy for Mask<T, N>
-where
-    T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
-{
-}
+impl<T, const N: usize> Copy for Mask<T, N> where T: MaskElement {}
 
 impl<T, const N: usize> Clone for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -148,7 +141,6 @@ where
 impl<T, const N: usize> Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     /// Constructs a mask by setting all elements to the given value.
     #[inline]
@@ -315,8 +307,6 @@ where
         ) -> U
         where
             T: MaskElement,
-            LaneCount<M>: SupportedLaneCount,
-            LaneCount<N>: SupportedLaneCount,
         {
             let resized = mask.resize::<M>(false);
 
@@ -421,7 +411,6 @@ where
 impl<T, const N: usize> From<[bool; N]> for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn from(array: [bool; N]) -> Self {
@@ -432,7 +421,6 @@ where
 impl<T, const N: usize> From<Mask<T, N>> for [bool; N]
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn from(vector: Mask<T, N>) -> Self {
@@ -443,7 +431,6 @@ where
 impl<T, const N: usize> Default for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn default() -> Self {
@@ -454,7 +441,6 @@ where
 impl<T, const N: usize> PartialEq for Mask<T, N>
 where
     T: MaskElement + PartialEq,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
@@ -465,7 +451,6 @@ where
 impl<T, const N: usize> PartialOrd for Mask<T, N>
 where
     T: MaskElement + PartialOrd,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
@@ -476,7 +461,6 @@ where
 impl<T, const N: usize> fmt::Debug for Mask<T, N>
 where
     T: MaskElement + fmt::Debug,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -489,7 +473,6 @@ where
 impl<T, const N: usize> core::ops::BitAnd for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     type Output = Self;
     #[inline]
@@ -502,7 +485,6 @@ where
 impl<T, const N: usize> core::ops::BitAnd<bool> for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     type Output = Self;
     #[inline]
@@ -514,7 +496,6 @@ where
 impl<T, const N: usize> core::ops::BitAnd<Mask<T, N>> for bool
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     type Output = Mask<T, N>;
     #[inline]
@@ -526,7 +507,6 @@ where
 impl<T, const N: usize> core::ops::BitOr for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     type Output = Self;
     #[inline]
@@ -539,7 +519,6 @@ where
 impl<T, const N: usize> core::ops::BitOr<bool> for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     type Output = Self;
     #[inline]
@@ -551,7 +530,6 @@ where
 impl<T, const N: usize> core::ops::BitOr<Mask<T, N>> for bool
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     type Output = Mask<T, N>;
     #[inline]
@@ -563,7 +541,6 @@ where
 impl<T, const N: usize> core::ops::BitXor for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     type Output = Self;
     #[inline]
@@ -576,7 +553,6 @@ where
 impl<T, const N: usize> core::ops::BitXor<bool> for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     type Output = Self;
     #[inline]
@@ -588,7 +564,6 @@ where
 impl<T, const N: usize> core::ops::BitXor<Mask<T, N>> for bool
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     type Output = Mask<T, N>;
     #[inline]
@@ -600,7 +575,6 @@ where
 impl<T, const N: usize> core::ops::Not for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     type Output = Mask<T, N>;
     #[inline]
@@ -612,7 +586,6 @@ where
 impl<T, const N: usize> core::ops::BitAndAssign for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn bitand_assign(&mut self, rhs: Self) {
@@ -623,7 +596,6 @@ where
 impl<T, const N: usize> core::ops::BitAndAssign<bool> for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn bitand_assign(&mut self, rhs: bool) {
@@ -634,7 +606,6 @@ where
 impl<T, const N: usize> core::ops::BitOrAssign for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn bitor_assign(&mut self, rhs: Self) {
@@ -645,7 +616,6 @@ where
 impl<T, const N: usize> core::ops::BitOrAssign<bool> for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn bitor_assign(&mut self, rhs: bool) {
@@ -656,7 +626,6 @@ where
 impl<T, const N: usize> core::ops::BitXorAssign for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn bitxor_assign(&mut self, rhs: Self) {
@@ -667,7 +636,6 @@ where
 impl<T, const N: usize> core::ops::BitXorAssign<bool> for Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn bitxor_assign(&mut self, rhs: bool) {
@@ -679,8 +647,6 @@ macro_rules! impl_from {
     { $from:ty  => $($to:ty),* } => {
         $(
         impl<const N: usize> From<Mask<$from, N>> for Mask<$to, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn from(value: Mask<$from, N>) -> Self {
diff --git a/crates/core_simd/src/mod.rs b/crates/core_simd/src/mod.rs
index 14fe70df4ed..5f635d80a17 100644
--- a/crates/core_simd/src/mod.rs
+++ b/crates/core_simd/src/mod.rs
@@ -5,7 +5,6 @@ mod alias;
 mod cast;
 mod fmt;
 mod iter;
-mod lane_count;
 mod masks;
 mod ops;
 mod select;
@@ -27,7 +26,6 @@ pub mod simd {
 
     pub use crate::core_simd::alias::*;
     pub use crate::core_simd::cast::*;
-    pub use crate::core_simd::lane_count::{LaneCount, SupportedLaneCount};
     pub use crate::core_simd::masks::*;
     pub use crate::core_simd::select::*;
     pub use crate::core_simd::swizzle::*;
diff --git a/crates/core_simd/src/ops.rs b/crates/core_simd/src/ops.rs
index f36e360fadf..eb6601f7348 100644
--- a/crates/core_simd/src/ops.rs
+++ b/crates/core_simd/src/ops.rs
@@ -1,4 +1,4 @@
-use crate::simd::{LaneCount, Select, Simd, SimdElement, SupportedLaneCount, cmp::SimdPartialEq};
+use crate::simd::{Select, Simd, SimdElement, cmp::SimdPartialEq};
 use core::ops::{Add, Mul};
 use core::ops::{BitAnd, BitOr, BitXor};
 use core::ops::{Div, Rem, Sub};
@@ -12,7 +12,6 @@ mod unary;
 impl<I, T, const N: usize> core::ops::Index<I> for Simd<T, N>
 where
     T: SimdElement,
-    LaneCount<N>: SupportedLaneCount,
     I: core::slice::SliceIndex<[T]>,
 {
     type Output = I::Output;
@@ -25,7 +24,6 @@ where
 impl<I, T, const N: usize> core::ops::IndexMut<I> for Simd<T, N>
 where
     T: SimdElement,
-    LaneCount<N>: SupportedLaneCount,
     I: core::slice::SliceIndex<[T]>,
 {
     #[inline]
@@ -130,7 +128,6 @@ macro_rules! for_base_types {
                 impl<const N: usize> $op<Self> for Simd<$scalar, N>
                 where
                     $scalar: SimdElement,
-                    LaneCount<N>: SupportedLaneCount,
                 {
                     type Output = $out;
 
diff --git a/crates/core_simd/src/ops/assign.rs b/crates/core_simd/src/ops/assign.rs
index d21d867de26..c1830c35df7 100644
--- a/crates/core_simd/src/ops/assign.rs
+++ b/crates/core_simd/src/ops/assign.rs
@@ -21,7 +21,6 @@ macro_rules! assign_ops {
         where
             Self: $trait<U, Output = Self>,
             T: SimdElement,
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn $assign_call(&mut self, rhs: U) {
diff --git a/crates/core_simd/src/ops/deref.rs b/crates/core_simd/src/ops/deref.rs
index 913cbbe977c..360b83c4034 100644
--- a/crates/core_simd/src/ops/deref.rs
+++ b/crates/core_simd/src/ops/deref.rs
@@ -13,7 +13,6 @@ macro_rules! deref_lhs {
         where
             T: SimdElement,
             $simd: $trait<$simd, Output = $simd>,
-            LaneCount<N>: SupportedLaneCount,
         {
             type Output = Simd<T, N>;
 
@@ -33,7 +32,6 @@ macro_rules! deref_rhs {
         where
             T: SimdElement,
             $simd: $trait<$simd, Output = $simd>,
-            LaneCount<N>: SupportedLaneCount,
         {
             type Output = Simd<T, N>;
 
@@ -64,7 +62,6 @@ macro_rules! deref_ops {
             where
                 T: SimdElement,
                 $simd: $trait<$simd, Output = $simd>,
-                LaneCount<N>: SupportedLaneCount,
             {
                 type Output = $simd;
 
diff --git a/crates/core_simd/src/ops/shift_scalar.rs b/crates/core_simd/src/ops/shift_scalar.rs
index f5115a5a5e9..7ca83dc40f6 100644
--- a/crates/core_simd/src/ops/shift_scalar.rs
+++ b/crates/core_simd/src/ops/shift_scalar.rs
@@ -1,13 +1,11 @@
 // Shift operations uniquely typically only have a scalar on the right-hand side.
 // Here, we implement shifts for scalar RHS arguments.
 
-use crate::simd::{LaneCount, Simd, SupportedLaneCount};
+use crate::simd::Simd;
 
 macro_rules! impl_splatted_shifts {
     { impl $trait:ident :: $trait_fn:ident for $ty:ty } => {
         impl<const N: usize> core::ops::$trait<$ty> for Simd<$ty, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             type Output = Self;
             #[inline]
@@ -17,8 +15,6 @@ macro_rules! impl_splatted_shifts {
         }
 
         impl<const N: usize> core::ops::$trait<&$ty> for Simd<$ty, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             type Output = Self;
             #[inline]
@@ -28,8 +24,6 @@ macro_rules! impl_splatted_shifts {
         }
 
         impl<'lhs, const N: usize> core::ops::$trait<$ty> for &'lhs Simd<$ty, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             type Output = Simd<$ty, N>;
             #[inline]
@@ -39,8 +33,6 @@ macro_rules! impl_splatted_shifts {
         }
 
         impl<'lhs, const N: usize> core::ops::$trait<&$ty> for &'lhs Simd<$ty, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             type Output = Simd<$ty, N>;
             #[inline]
diff --git a/crates/core_simd/src/ops/unary.rs b/crates/core_simd/src/ops/unary.rs
index 412a5b80117..e1c06167f97 100644
--- a/crates/core_simd/src/ops/unary.rs
+++ b/crates/core_simd/src/ops/unary.rs
@@ -1,4 +1,4 @@
-use crate::simd::{LaneCount, Simd, SimdElement, SupportedLaneCount};
+use crate::simd::{Simd, SimdElement};
 use core::ops::{Neg, Not}; // unary ops
 
 macro_rules! neg {
@@ -6,7 +6,6 @@ macro_rules! neg {
         $(impl<const N: usize> Neg for Simd<$scalar, N>
         where
             $scalar: SimdElement,
-            LaneCount<N>: SupportedLaneCount,
         {
             type Output = Self;
 
@@ -40,7 +39,6 @@ macro_rules! not {
         $(impl<const N: usize> Not for Simd<$scalar, N>
         where
             $scalar: SimdElement,
-            LaneCount<N>: SupportedLaneCount,
         {
             type Output = Self;
 
diff --git a/crates/core_simd/src/select.rs b/crates/core_simd/src/select.rs
index 5240b9b0c71..404f54d8f38 100644
--- a/crates/core_simd/src/select.rs
+++ b/crates/core_simd/src/select.rs
@@ -1,6 +1,4 @@
-use crate::simd::{
-    FixEndianness, LaneCount, Mask, MaskElement, Simd, SimdElement, SupportedLaneCount,
-};
+use crate::simd::{FixEndianness, Mask, MaskElement, Simd, SimdElement};
 
 /// Choose elements from two vectors using a mask.
 ///
@@ -59,7 +57,6 @@ impl<T, U, const N: usize> Select<Simd<T, N>> for Mask<U, N>
 where
     T: SimdElement,
     U: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn select(self, true_values: Simd<T, N>, false_values: Simd<T, N>) -> Simd<T, N> {
@@ -76,7 +73,6 @@ where
 impl<T, const N: usize> Select<Simd<T, N>> for u64
 where
     T: SimdElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn select(self, true_values: Simd<T, N>, false_values: Simd<T, N>) -> Simd<T, N> {
@@ -92,8 +88,6 @@ where
         ) -> Simd<T, N>
         where
             T: SimdElement,
-            LaneCount<M>: SupportedLaneCount,
-            LaneCount<N>: SupportedLaneCount,
         {
             let default = true_values[0];
             let true_values = true_values.resize::<M>(default);
@@ -135,7 +129,6 @@ impl<T, U, const N: usize> Select<Mask<T, N>> for Mask<U, N>
 where
     T: MaskElement,
     U: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn select(self, true_values: Mask<T, N>, false_values: Mask<T, N>) -> Mask<T, N> {
@@ -150,7 +143,6 @@ where
 impl<T, const N: usize> Select<Mask<T, N>> for u64
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
     fn select(self, true_values: Mask<T, N>, false_values: Mask<T, N>) -> Mask<T, N> {
diff --git a/crates/core_simd/src/simd/cmp/eq.rs b/crates/core_simd/src/simd/cmp/eq.rs
index 789fc0bb942..d553d6c040c 100644
--- a/crates/core_simd/src/simd/cmp/eq.rs
+++ b/crates/core_simd/src/simd/cmp/eq.rs
@@ -1,5 +1,5 @@
 use crate::simd::{
-    LaneCount, Mask, Simd, SimdElement, SupportedLaneCount,
+    Mask, Simd, SimdElement,
     ptr::{SimdConstPtr, SimdMutPtr},
 };
 
@@ -21,8 +21,6 @@ macro_rules! impl_number {
     { $($number:ty),* } => {
         $(
         impl<const N: usize> SimdPartialEq for Simd<$number, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             type Mask = Mask<<$number as SimdElement>::Mask, N>;
 
@@ -50,8 +48,6 @@ macro_rules! impl_mask {
     { $($integer:ty),* } => {
         $(
         impl<const N: usize> SimdPartialEq for Mask<$integer, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             type Mask = Self;
 
@@ -75,10 +71,7 @@ macro_rules! impl_mask {
 
 impl_mask! { i8, i16, i32, i64, isize }
 
-impl<T, const N: usize> SimdPartialEq for Simd<*const T, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+impl<T, const N: usize> SimdPartialEq for Simd<*const T, N> {
     type Mask = Mask<isize, N>;
 
     #[inline]
@@ -92,10 +85,7 @@ where
     }
 }
 
-impl<T, const N: usize> SimdPartialEq for Simd<*mut T, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+impl<T, const N: usize> SimdPartialEq for Simd<*mut T, N> {
     type Mask = Mask<isize, N>;
 
     #[inline]
diff --git a/crates/core_simd/src/simd/cmp/ord.rs b/crates/core_simd/src/simd/cmp/ord.rs
index 1b1c689ad45..5672fbbf54c 100644
--- a/crates/core_simd/src/simd/cmp/ord.rs
+++ b/crates/core_simd/src/simd/cmp/ord.rs
@@ -1,5 +1,5 @@
 use crate::simd::{
-    LaneCount, Mask, Select, Simd, SupportedLaneCount,
+    Mask, Select, Simd,
     cmp::SimdPartialEq,
     ptr::{SimdConstPtr, SimdMutPtr},
 };
@@ -49,8 +49,6 @@ macro_rules! impl_integer {
     { $($integer:ty),* } => {
         $(
         impl<const N: usize> SimdPartialOrd for Simd<$integer, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn simd_lt(self, other: Self) -> Self::Mask {
@@ -82,8 +80,6 @@ macro_rules! impl_integer {
         }
 
         impl<const N: usize> SimdOrd for Simd<$integer, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn simd_max(self, other: Self) -> Self {
@@ -115,8 +111,6 @@ macro_rules! impl_float {
     { $($float:ty),* } => {
         $(
         impl<const N: usize> SimdPartialOrd for Simd<$float, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn simd_lt(self, other: Self) -> Self::Mask {
@@ -156,8 +150,6 @@ macro_rules! impl_mask {
     { $($integer:ty),* } => {
         $(
         impl<const N: usize> SimdPartialOrd for Mask<$integer, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn simd_lt(self, other: Self) -> Self::Mask {
@@ -189,8 +181,6 @@ macro_rules! impl_mask {
         }
 
         impl<const N: usize> SimdOrd for Mask<$integer, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn simd_max(self, other: Self) -> Self {
@@ -218,10 +208,7 @@ macro_rules! impl_mask {
 
 impl_mask! { i8, i16, i32, i64, isize }
 
-impl<T, const N: usize> SimdPartialOrd for Simd<*const T, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+impl<T, const N: usize> SimdPartialOrd for Simd<*const T, N> {
     #[inline]
     fn simd_lt(self, other: Self) -> Self::Mask {
         self.addr().simd_lt(other.addr())
@@ -243,10 +230,7 @@ where
     }
 }
 
-impl<T, const N: usize> SimdOrd for Simd<*const T, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+impl<T, const N: usize> SimdOrd for Simd<*const T, N> {
     #[inline]
     fn simd_max(self, other: Self) -> Self {
         self.simd_lt(other).select(other, self)
@@ -268,10 +252,7 @@ where
     }
 }
 
-impl<T, const N: usize> SimdPartialOrd for Simd<*mut T, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+impl<T, const N: usize> SimdPartialOrd for Simd<*mut T, N> {
     #[inline]
     fn simd_lt(self, other: Self) -> Self::Mask {
         self.addr().simd_lt(other.addr())
@@ -293,10 +274,7 @@ where
     }
 }
 
-impl<T, const N: usize> SimdOrd for Simd<*mut T, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+impl<T, const N: usize> SimdOrd for Simd<*mut T, N> {
     #[inline]
     fn simd_max(self, other: Self) -> Self {
         self.simd_lt(other).select(other, self)
diff --git a/crates/core_simd/src/simd/num/float.rs b/crates/core_simd/src/simd/num/float.rs
index 76ab5748c63..efd7c246951 100644
--- a/crates/core_simd/src/simd/num/float.rs
+++ b/crates/core_simd/src/simd/num/float.rs
@@ -1,6 +1,6 @@
 use super::sealed::Sealed;
 use crate::simd::{
-    LaneCount, Mask, Select, Simd, SimdCast, SimdElement, SupportedLaneCount,
+    Mask, Select, Simd, SimdCast, SimdElement,
     cmp::{SimdPartialEq, SimdPartialOrd},
 };
 
@@ -240,15 +240,9 @@ pub trait SimdFloat: Copy + Sealed {
 macro_rules! impl_trait {
     { $($ty:ty { bits: $bits_ty:ty, mask: $mask_ty:ty }),* } => {
         $(
-        impl<const N: usize> Sealed for Simd<$ty, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
-        {
-        }
+        impl<const N: usize> Sealed for Simd<$ty, N> {}
 
         impl<const N: usize> SimdFloat for Simd<$ty, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             type Mask = Mask<<$mask_ty as SimdElement>::Mask, N>;
             type Scalar = $ty;
diff --git a/crates/core_simd/src/simd/num/int.rs b/crates/core_simd/src/simd/num/int.rs
index 5a292407d05..6ebf0ba397c 100644
--- a/crates/core_simd/src/simd/num/int.rs
+++ b/crates/core_simd/src/simd/num/int.rs
@@ -1,7 +1,6 @@
 use super::sealed::Sealed;
 use crate::simd::{
-    LaneCount, Mask, Select, Simd, SimdCast, SimdElement, SupportedLaneCount, cmp::SimdOrd,
-    cmp::SimdPartialOrd, num::SimdUint,
+    Mask, Select, Simd, SimdCast, SimdElement, cmp::SimdOrd, cmp::SimdPartialOrd, num::SimdUint,
 };
 
 /// Operations on SIMD vectors of signed integers.
@@ -241,16 +240,9 @@ pub trait SimdInt: Copy + Sealed {
 macro_rules! impl_trait {
     { $($ty:ident ($unsigned:ident)),* } => {
         $(
-        impl<const N: usize> Sealed for Simd<$ty, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
-        {
-        }
+        impl<const N: usize> Sealed for Simd<$ty, N> {}
 
-        impl<const N: usize> SimdInt for Simd<$ty, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
-        {
+        impl<const N: usize> SimdInt for Simd<$ty, N> {
             type Mask = Mask<<$ty as SimdElement>::Mask, N>;
             type Scalar = $ty;
             type Unsigned = Simd<$unsigned, N>;
diff --git a/crates/core_simd/src/simd/num/uint.rs b/crates/core_simd/src/simd/num/uint.rs
index 45d978068b6..f8a40f8ec56 100644
--- a/crates/core_simd/src/simd/num/uint.rs
+++ b/crates/core_simd/src/simd/num/uint.rs
@@ -1,5 +1,5 @@
 use super::sealed::Sealed;
-use crate::simd::{LaneCount, Simd, SimdCast, SimdElement, SupportedLaneCount, cmp::SimdOrd};
+use crate::simd::{Simd, SimdCast, SimdElement, cmp::SimdOrd};
 
 /// Operations on SIMD vectors of unsigned integers.
 pub trait SimdUint: Copy + Sealed {
@@ -123,15 +123,9 @@ pub trait SimdUint: Copy + Sealed {
 macro_rules! impl_trait {
     { $($ty:ident ($signed:ident)),* } => {
         $(
-        impl<const N: usize> Sealed for Simd<$ty, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
-        {
-        }
+        impl<const N: usize> Sealed for Simd<$ty, N> {}
 
         impl<const N: usize> SimdUint for Simd<$ty, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             type Scalar = $ty;
             type Cast<T: SimdElement> = Simd<T, N>;
diff --git a/crates/core_simd/src/simd/ptr/const_ptr.rs b/crates/core_simd/src/simd/ptr/const_ptr.rs
index 36452e7ae92..7ef9dc21373 100644
--- a/crates/core_simd/src/simd/ptr/const_ptr.rs
+++ b/crates/core_simd/src/simd/ptr/const_ptr.rs
@@ -1,5 +1,5 @@
 use super::sealed::Sealed;
-use crate::simd::{LaneCount, Mask, Simd, SupportedLaneCount, cmp::SimdPartialEq, num::SimdUint};
+use crate::simd::{Mask, Simd, cmp::SimdPartialEq, num::SimdUint};
 
 /// Operations on SIMD vectors of constant pointers.
 pub trait SimdConstPtr: Copy + Sealed {
@@ -88,12 +88,9 @@ pub trait SimdConstPtr: Copy + Sealed {
     fn wrapping_sub(self, count: Self::Usize) -> Self;
 }
 
-impl<T, const N: usize> Sealed for Simd<*const T, N> where LaneCount<N>: SupportedLaneCount {}
+impl<T, const N: usize> Sealed for Simd<*const T, N> {}
 
-impl<T, const N: usize> SimdConstPtr for Simd<*const T, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+impl<T, const N: usize> SimdConstPtr for Simd<*const T, N> {
     type Usize = Simd<usize, N>;
     type Isize = Simd<isize, N>;
     type CastPtr<U> = Simd<*const U, N>;
diff --git a/crates/core_simd/src/simd/ptr/mut_ptr.rs b/crates/core_simd/src/simd/ptr/mut_ptr.rs
index c644f390c20..3b9b75ddf56 100644
--- a/crates/core_simd/src/simd/ptr/mut_ptr.rs
+++ b/crates/core_simd/src/simd/ptr/mut_ptr.rs
@@ -1,5 +1,5 @@
 use super::sealed::Sealed;
-use crate::simd::{LaneCount, Mask, Simd, SupportedLaneCount, cmp::SimdPartialEq, num::SimdUint};
+use crate::simd::{Mask, Simd, cmp::SimdPartialEq, num::SimdUint};
 
 /// Operations on SIMD vectors of mutable pointers.
 pub trait SimdMutPtr: Copy + Sealed {
@@ -85,12 +85,9 @@ pub trait SimdMutPtr: Copy + Sealed {
     fn wrapping_sub(self, count: Self::Usize) -> Self;
 }
 
-impl<T, const N: usize> Sealed for Simd<*mut T, N> where LaneCount<N>: SupportedLaneCount {}
+impl<T, const N: usize> Sealed for Simd<*mut T, N> {}
 
-impl<T, const N: usize> SimdMutPtr for Simd<*mut T, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+impl<T, const N: usize> SimdMutPtr for Simd<*mut T, N> {
     type Usize = Simd<usize, N>;
     type Isize = Simd<isize, N>;
     type CastPtr<U> = Simd<*mut U, N>;
diff --git a/crates/core_simd/src/swizzle.rs b/crates/core_simd/src/swizzle.rs
index 81085a9ee4a..02dcd71356d 100644
--- a/crates/core_simd/src/swizzle.rs
+++ b/crates/core_simd/src/swizzle.rs
@@ -1,4 +1,4 @@
-use crate::simd::{LaneCount, Mask, MaskElement, Simd, SimdElement, SupportedLaneCount};
+use crate::simd::{Mask, MaskElement, Simd, SimdElement};
 
 /// Constructs a new SIMD vector by copying elements from selected elements in other vectors.
 ///
@@ -82,8 +82,6 @@ pub trait Swizzle<const N: usize> {
     fn swizzle<T, const M: usize>(vector: Simd<T, M>) -> Simd<T, N>
     where
         T: SimdElement,
-        LaneCount<N>: SupportedLaneCount,
-        LaneCount<M>: SupportedLaneCount,
     {
         // Safety: `vector` is a vector, and the index is a const vector of u32.
         unsafe {
@@ -122,8 +120,6 @@ pub trait Swizzle<const N: usize> {
     fn concat_swizzle<T, const M: usize>(first: Simd<T, M>, second: Simd<T, M>) -> Simd<T, N>
     where
         T: SimdElement,
-        LaneCount<N>: SupportedLaneCount,
-        LaneCount<M>: SupportedLaneCount,
     {
         // Safety: `first` and `second` are vectors, and the index is a const vector of u32.
         unsafe {
@@ -161,8 +157,6 @@ pub trait Swizzle<const N: usize> {
     fn swizzle_mask<T, const M: usize>(mask: Mask<T, M>) -> Mask<T, N>
     where
         T: MaskElement,
-        LaneCount<N>: SupportedLaneCount,
-        LaneCount<M>: SupportedLaneCount,
     {
         // SAFETY: all elements of this mask come from another mask
         unsafe { Mask::from_simd_unchecked(Self::swizzle(mask.to_simd())) }
@@ -177,8 +171,6 @@ pub trait Swizzle<const N: usize> {
     fn concat_swizzle_mask<T, const M: usize>(first: Mask<T, M>, second: Mask<T, M>) -> Mask<T, N>
     where
         T: MaskElement,
-        LaneCount<N>: SupportedLaneCount,
-        LaneCount<M>: SupportedLaneCount,
     {
         // SAFETY: all elements of this mask come from another mask
         unsafe {
@@ -190,7 +182,6 @@ pub trait Swizzle<const N: usize> {
 impl<T, const N: usize> Simd<T, N>
 where
     T: SimdElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     /// Reverse the order of the elements in the vector.
     #[inline]
@@ -464,10 +455,7 @@ where
     /// ```
     #[inline]
     #[must_use = "method returns a new vector and does not mutate the original inputs"]
-    pub fn resize<const M: usize>(self, value: T) -> Simd<T, M>
-    where
-        LaneCount<M>: SupportedLaneCount,
-    {
+    pub fn resize<const M: usize>(self, value: T) -> Simd<T, M> {
         struct Resize<const N: usize>;
         impl<const N: usize, const M: usize> Swizzle<M> for Resize<N> {
             const INDEX: [usize; M] = const {
@@ -495,10 +483,7 @@ where
     /// ```
     #[inline]
     #[must_use = "method returns a new vector and does not mutate the original inputs"]
-    pub fn extract<const START: usize, const LEN: usize>(self) -> Simd<T, LEN>
-    where
-        LaneCount<LEN>: SupportedLaneCount,
-    {
+    pub fn extract<const START: usize, const LEN: usize>(self) -> Simd<T, LEN> {
         struct Extract<const N: usize, const START: usize>;
         impl<const N: usize, const START: usize, const LEN: usize> Swizzle<LEN> for Extract<N, START> {
             const INDEX: [usize; LEN] = const {
@@ -519,7 +504,6 @@ where
 impl<T, const N: usize> Mask<T, N>
 where
     T: MaskElement,
-    LaneCount<N>: SupportedLaneCount,
 {
     /// Reverse the order of the elements in the mask.
     #[inline]
@@ -655,10 +639,7 @@ where
     /// ```
     #[inline]
     #[must_use = "method returns a new vector and does not mutate the original inputs"]
-    pub fn resize<const M: usize>(self, value: bool) -> Mask<T, M>
-    where
-        LaneCount<M>: SupportedLaneCount,
-    {
+    pub fn resize<const M: usize>(self, value: bool) -> Mask<T, M> {
         // Safety: swizzles are safe for masks
         unsafe {
             Mask::<T, M>::from_simd_unchecked(self.to_simd().resize::<M>(if value {
@@ -681,10 +662,7 @@ where
     /// ```
     #[inline]
     #[must_use = "method returns a new vector and does not mutate the original inputs"]
-    pub fn extract<const START: usize, const LEN: usize>(self) -> Mask<T, LEN>
-    where
-        LaneCount<LEN>: SupportedLaneCount,
-    {
+    pub fn extract<const START: usize, const LEN: usize>(self) -> Mask<T, LEN> {
         // Safety: swizzles are safe for masks
         unsafe { Mask::<T, LEN>::from_simd_unchecked(self.to_simd().extract::<START, LEN>()) }
     }
diff --git a/crates/core_simd/src/swizzle_dyn.rs b/crates/core_simd/src/swizzle_dyn.rs
index 73b18595d0a..ae0b174973d 100644
--- a/crates/core_simd/src/swizzle_dyn.rs
+++ b/crates/core_simd/src/swizzle_dyn.rs
@@ -1,10 +1,7 @@
-use crate::simd::{LaneCount, Simd, SupportedLaneCount};
+use crate::simd::Simd;
 use core::mem;
 
-impl<const N: usize> Simd<u8, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+impl<const N: usize> Simd<u8, N> {
     /// Swizzle a vector of bytes according to the index vector.
     /// Indices within range select the appropriate byte.
     /// Indices "out of bounds" instead select 0.
@@ -184,10 +181,7 @@ unsafe fn transize<T, const N: usize>(
     f: unsafe fn(T, T) -> T,
     a: Simd<u8, N>,
     b: Simd<u8, N>,
-) -> Simd<u8, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+) -> Simd<u8, N> {
     // SAFETY: Same obligation to use this function as to use mem::transmute_copy.
     unsafe { mem::transmute_copy(&f(mem::transmute_copy(&a), mem::transmute_copy(&b))) }
 }
@@ -196,10 +190,7 @@ where
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 #[allow(unused)]
 #[inline(always)]
-fn zeroing_idxs<const N: usize>(idxs: Simd<u8, N>) -> Simd<u8, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+fn zeroing_idxs<const N: usize>(idxs: Simd<u8, N>) -> Simd<u8, N> {
     use crate::simd::{Select, cmp::SimdPartialOrd};
     idxs.simd_lt(Simd::splat(N as u8))
         .select(idxs, Simd::splat(u8::MAX))
diff --git a/crates/core_simd/src/to_bytes.rs b/crates/core_simd/src/to_bytes.rs
index fee2cc06c5b..1fd285e457d 100644
--- a/crates/core_simd/src/to_bytes.rs
+++ b/crates/core_simd/src/to_bytes.rs
@@ -1,12 +1,12 @@
 use crate::simd::{
-    LaneCount, Simd, SimdElement, SupportedLaneCount,
+    Simd, SimdElement,
     num::{SimdFloat, SimdInt, SimdUint},
 };
 
 mod sealed {
     use super::*;
     pub trait Sealed {}
-    impl<T: SimdElement, const N: usize> Sealed for Simd<T, N> where LaneCount<N>: SupportedLaneCount {}
+    impl<T: SimdElement, const N: usize> Sealed for Simd<T, N> {}
 }
 use sealed::Sealed;
 
diff --git a/crates/core_simd/src/vector.rs b/crates/core_simd/src/vector.rs
index c00cfcdd41f..2dba5c83e11 100644
--- a/crates/core_simd/src/vector.rs
+++ b/crates/core_simd/src/vector.rs
@@ -1,5 +1,5 @@
 use crate::simd::{
-    LaneCount, Mask, MaskElement, SupportedLaneCount, Swizzle,
+    Mask, MaskElement, Swizzle,
     cmp::SimdPartialOrd,
     num::SimdUint,
     ptr::{SimdConstPtr, SimdMutPtr},
@@ -51,6 +51,8 @@ use crate::simd::{
 /// Thus it is sound to [`transmute`] `Simd<T, N>` to `[T; N]` and should optimize to "zero cost",
 /// but the reverse transmutation may require a copy the compiler cannot simply elide.
 ///
+/// `N` cannot be 0 and may be at most 64. This limit may be increased in the future.
+///
 /// # ABI "Features"
 /// Due to Rust's safety guarantees, `Simd<T, N>` is currently passed and returned via memory,
 /// not SIMD registers, except as an optimization. Using `#[inline]` on functions that accept
@@ -100,14 +102,13 @@ use crate::simd::{
 // avoided, as it will likely become illegal on `#[repr(simd)]` structs in the future. It also
 // causes rustc to emit illegal LLVM IR in some cases.
 #[repr(simd, packed)]
+#[rustc_simd_monomorphize_lane_limit = "64"]
 pub struct Simd<T, const N: usize>([T; N])
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement;
 
 impl<T, const N: usize> Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
     /// Number of elements in this vector.
@@ -149,7 +150,6 @@ where
         const fn splat_const<T, const N: usize>(value: T) -> Simd<T, N>
         where
             T: SimdElement,
-            LaneCount<N>: SupportedLaneCount,
         {
             Simd::from_array([value; N])
         }
@@ -157,7 +157,6 @@ where
         fn splat_rt<T, const N: usize>(value: T) -> Simd<T, N>
         where
             T: SimdElement,
-            LaneCount<N>: SupportedLaneCount,
         {
             // This is preferred over `[value; N]`, since it's explicitly a splat:
             // https://github.com/rust-lang/rust/issues/97804
@@ -886,16 +885,10 @@ where
     }
 }
 
-impl<T, const N: usize> Copy for Simd<T, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-    T: SimdElement,
-{
-}
+impl<T, const N: usize> Copy for Simd<T, N> where T: SimdElement {}
 
 impl<T, const N: usize> Clone for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
     #[inline]
@@ -906,7 +899,6 @@ where
 
 impl<T, const N: usize> Default for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement + Default,
 {
     #[inline]
@@ -917,7 +909,6 @@ where
 
 impl<T, const N: usize> PartialEq for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement + PartialEq,
 {
     #[inline]
@@ -951,7 +942,6 @@ where
 /// Lexicographic order. For the SIMD elementwise minimum and maximum, use simd_min and simd_max instead.
 impl<T, const N: usize> PartialOrd for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement + PartialOrd,
 {
     #[inline]
@@ -961,17 +951,11 @@ where
     }
 }
 
-impl<T, const N: usize> Eq for Simd<T, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-    T: SimdElement + Eq,
-{
-}
+impl<T, const N: usize> Eq for Simd<T, N> where T: SimdElement + Eq {}
 
 /// Lexicographic order. For the SIMD elementwise minimum and maximum, use simd_min and simd_max instead.
 impl<T, const N: usize> Ord for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement + Ord,
 {
     #[inline]
@@ -983,7 +967,6 @@ where
 
 impl<T, const N: usize> core::hash::Hash for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement + core::hash::Hash,
 {
     #[inline]
@@ -998,7 +981,6 @@ where
 // array references
 impl<T, const N: usize> AsRef<[T; N]> for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
     #[inline]
@@ -1009,7 +991,6 @@ where
 
 impl<T, const N: usize> AsMut<[T; N]> for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
     #[inline]
@@ -1021,7 +1002,6 @@ where
 // slice references
 impl<T, const N: usize> AsRef<[T]> for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
     #[inline]
@@ -1032,7 +1012,6 @@ where
 
 impl<T, const N: usize> AsMut<[T]> for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
     #[inline]
@@ -1044,7 +1023,6 @@ where
 // vector/array conversion
 impl<T, const N: usize> From<[T; N]> for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
     #[inline]
@@ -1055,7 +1033,6 @@ where
 
 impl<T, const N: usize> From<Simd<T, N>> for [T; N]
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
     #[inline]
@@ -1066,7 +1043,6 @@ where
 
 impl<T, const N: usize> TryFrom<&[T]> for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
     type Error = core::array::TryFromSliceError;
@@ -1079,7 +1055,6 @@ where
 
 impl<T, const N: usize> TryFrom<&mut [T]> for Simd<T, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
     type Error = core::array::TryFromSliceError;
@@ -1217,10 +1192,7 @@ where
 }
 
 #[inline]
-fn lane_indices<const N: usize>() -> Simd<usize, N>
-where
-    LaneCount<N>: SupportedLaneCount,
-{
+fn lane_indices<const N: usize>() -> Simd<usize, N> {
     #![allow(clippy::needless_range_loop)]
     let mut index = [0; N];
     for i in 0..N {
@@ -1232,7 +1204,6 @@ where
 #[inline]
 fn mask_up_to<M, const N: usize>(len: usize) -> Mask<M, N>
 where
-    LaneCount<N>: SupportedLaneCount,
     M: MaskElement,
 {
     let index = lane_indices::<N>();
diff --git a/crates/std_float/src/lib.rs b/crates/std_float/src/lib.rs
index 148aa5f9f17..c3c9b76e50b 100644
--- a/crates/std_float/src/lib.rs
+++ b/crates/std_float/src/lib.rs
@@ -11,7 +11,7 @@ use core_simd::simd;
 
 use core::intrinsics::simd as intrinsics;
 
-use simd::{LaneCount, Simd, SupportedLaneCount};
+use simd::Simd;
 
 #[cfg(feature = "as_crate")]
 mod experimental {
@@ -140,16 +140,14 @@ pub trait StdFloat: Sealed + Sized {
     fn fract(self) -> Self;
 }
 
-impl<const N: usize> Sealed for Simd<f32, N> where LaneCount<N>: SupportedLaneCount {}
-impl<const N: usize> Sealed for Simd<f64, N> where LaneCount<N>: SupportedLaneCount {}
+impl<const N: usize> Sealed for Simd<f32, N> {}
+impl<const N: usize> Sealed for Simd<f64, N> {}
 
 macro_rules! impl_float {
     {
         $($fn:ident: $intrinsic:ident,)*
     } => {
         impl<const N: usize> StdFloat for Simd<f32, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn fract(self) -> Self {
@@ -165,8 +163,6 @@ macro_rules! impl_float {
         }
 
         impl<const N: usize> StdFloat for Simd<f64, N>
-        where
-            LaneCount<N>: SupportedLaneCount,
         {
             #[inline]
             fn fract(self) -> Self {
diff --git a/crates/test_helpers/src/lib.rs b/crates/test_helpers/src/lib.rs
index 35401a9ddb4..eb3d3f68bc2 100644
--- a/crates/test_helpers/src/lib.rs
+++ b/crates/test_helpers/src/lib.rs
@@ -604,8 +604,6 @@ macro_rules! test_lanes {
                 use super::*;
 
                 fn implementation<const $lanes: usize>()
-                where
-                    core_simd::simd::LaneCount<$lanes>: core_simd::simd::SupportedLaneCount,
                 $body
 
                 #[cfg(target_arch = "wasm32")]
@@ -704,8 +702,6 @@ macro_rules! test_lanes_panic {
                 use super::*;
 
                 fn implementation<const $lanes: usize>()
-                where
-                    core_simd::simd::LaneCount<$lanes>: core_simd::simd::SupportedLaneCount,
                 $body
 
                 // test some odd and even non-power-of-2 lengths on miri
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index df4bd75ecfe..ed4d7e8a801 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2025-08-17"
+channel = "nightly-2025-09-30"
 components = ["rustfmt", "clippy", "miri", "rust-src"]