diff --git a/src/f32/affine2.rs b/src/f32/affine2.rs
index cbb9374d..dfe264b3 100644
--- a/src/f32/affine2.rs
+++ b/src/f32/affine2.rs
@@ -6,11 +6,18 @@ use core::ops::{Deref, DerefMut, Mul, MulAssign};
 /// A 2D affine transform, which can represent translation, rotation, scaling and shear.
 #[derive(Copy, Clone)]
 #[cfg_attr(
-    all(feature = "bytemuck", not(feature = "scalar-math")),
+    all(
+        feature = "bytemuck",
+        not(any(feature = "scalar-math", target_arch = "spirv"))
+    ),
     derive(bytemuck::AnyBitPattern)
 )]
 #[cfg_attr(
-    all(feature = "bytemuck", feature = "scalar-math"),
+    all(
+        feature = "bytemuck",
+        feature = "scalar-math",
+        not(target_arch = "spirv")
+    ),
     derive(bytemuck::Pod, bytemuck::Zeroable)
 )]
 #[repr(C)]
diff --git a/src/f32/affine3a.rs b/src/f32/affine3a.rs
index 6946e7ce..5ef0dc16 100644
--- a/src/f32/affine3a.rs
+++ b/src/f32/affine3a.rs
@@ -7,7 +7,10 @@ use core::ops::{Deref, DerefMut, Mul, MulAssign};
 ///
 /// This type is 16 byte aligned.
 #[derive(Copy, Clone)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::AnyBitPattern))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::AnyBitPattern)
+)]
 #[repr(C)]
 pub struct Affine3A {
     pub matrix3: Mat3A,
diff --git a/src/f32/coresimd/mat2.rs b/src/f32/coresimd/mat2.rs
index 4942fa50..ac797074 100644
--- a/src/f32/coresimd/mat2.rs
+++ b/src/f32/coresimd/mat2.rs
@@ -20,7 +20,10 @@ pub const fn mat2(x_axis: Vec2, y_axis: Vec2) -> Mat2 {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Mat2(pub(crate) f32x4);
 
diff --git a/src/f32/coresimd/mat3a.rs b/src/f32/coresimd/mat3a.rs
index 3b405e49..31785f1d 100644
--- a/src/f32/coresimd/mat3a.rs
+++ b/src/f32/coresimd/mat3a.rs
@@ -44,7 +44,10 @@ pub const fn mat3a(x_axis: Vec3A, y_axis: Vec3A, z_axis: Vec3A) -> Mat3A {
 /// vectors respectively. These methods assume that `Self` contains a valid affine
 /// transform.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct Mat3A {
     pub x_axis: Vec3A,
diff --git a/src/f32/coresimd/mat4.rs b/src/f32/coresimd/mat4.rs
index 29f42c27..d0573639 100644
--- a/src/f32/coresimd/mat4.rs
+++ b/src/f32/coresimd/mat4.rs
@@ -50,7 +50,10 @@ pub const fn mat4(x_axis: Vec4, y_axis: Vec4, z_axis: Vec4, w_axis: Vec4) -> Mat
 /// The resulting perspective project can be use to transform 3D vectors as points with
 /// perspective correction using the [`Self::project_point3()`] convenience method.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct Mat4 {
     pub x_axis: Vec4,
diff --git a/src/f32/coresimd/quat.rs b/src/f32/coresimd/quat.rs
index 8525ae87..0a372cf4 100644
--- a/src/f32/coresimd/quat.rs
+++ b/src/f32/coresimd/quat.rs
@@ -35,7 +35,10 @@ pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Quat(pub(crate) f32x4);
 
diff --git a/src/f32/coresimd/vec3a.rs b/src/f32/coresimd/vec3a.rs
index f9c72d8d..adfee4eb 100644
--- a/src/f32/coresimd/vec3a.rs
+++ b/src/f32/coresimd/vec3a.rs
@@ -26,7 +26,10 @@ pub const fn vec3a(x: f32, y: f32, z: f32) -> Vec3A {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Vec3A(pub(crate) f32x4);
 
diff --git a/src/f32/coresimd/vec4.rs b/src/f32/coresimd/vec4.rs
index b6626c55..f867e504 100644
--- a/src/f32/coresimd/vec4.rs
+++ b/src/f32/coresimd/vec4.rs
@@ -22,7 +22,10 @@ pub const fn vec4(x: f32, y: f32, z: f32, w: f32) -> Vec4 {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Vec4(pub(crate) f32x4);
 
diff --git a/src/f32/mat3.rs b/src/f32/mat3.rs
index 7dc7d7b2..1a207515 100644
--- a/src/f32/mat3.rs
+++ b/src/f32/mat3.rs
@@ -42,7 +42,10 @@ pub const fn mat3(x_axis: Vec3, y_axis: Vec3, z_axis: Vec3) -> Mat3 {
 /// vectors respectively. These methods assume that `Self` contains a valid affine
 /// transform.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct Mat3 {
     pub x_axis: Vec3,
diff --git a/src/f32/neon/mat2.rs b/src/f32/neon/mat2.rs
index c6784934..35a86b66 100644
--- a/src/f32/neon/mat2.rs
+++ b/src/f32/neon/mat2.rs
@@ -26,7 +26,10 @@ pub const fn mat2(x_axis: Vec2, y_axis: Vec2) -> Mat2 {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Mat2(pub(crate) float32x4_t);
 
diff --git a/src/f32/neon/mat3a.rs b/src/f32/neon/mat3a.rs
index 260afc0c..bd1e0c27 100644
--- a/src/f32/neon/mat3a.rs
+++ b/src/f32/neon/mat3a.rs
@@ -44,7 +44,10 @@ pub const fn mat3a(x_axis: Vec3A, y_axis: Vec3A, z_axis: Vec3A) -> Mat3A {
 /// vectors respectively. These methods assume that `Self` contains a valid affine
 /// transform.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct Mat3A {
     pub x_axis: Vec3A,
diff --git a/src/f32/neon/mat4.rs b/src/f32/neon/mat4.rs
index 232e13e1..a71fb9a0 100644
--- a/src/f32/neon/mat4.rs
+++ b/src/f32/neon/mat4.rs
@@ -50,7 +50,10 @@ pub const fn mat4(x_axis: Vec4, y_axis: Vec4, z_axis: Vec4, w_axis: Vec4) -> Mat
 /// The resulting perspective project can be use to transform 3D vectors as points with
 /// perspective correction using the [`Self::project_point3()`] convenience method.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct Mat4 {
     pub x_axis: Vec4,
diff --git a/src/f32/neon/quat.rs b/src/f32/neon/quat.rs
index a335fec6..46356ee2 100644
--- a/src/f32/neon/quat.rs
+++ b/src/f32/neon/quat.rs
@@ -41,7 +41,10 @@ pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Quat(pub(crate) float32x4_t);
 
diff --git a/src/f32/neon/vec3a.rs b/src/f32/neon/vec3a.rs
index 5f0f18ca..3cb4236f 100644
--- a/src/f32/neon/vec3a.rs
+++ b/src/f32/neon/vec3a.rs
@@ -31,7 +31,10 @@ pub const fn vec3a(x: f32, y: f32, z: f32) -> Vec3A {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Vec3A(pub(crate) float32x4_t);
 
diff --git a/src/f32/neon/vec4.rs b/src/f32/neon/vec4.rs
index 1fdb8bd4..beefec16 100644
--- a/src/f32/neon/vec4.rs
+++ b/src/f32/neon/vec4.rs
@@ -27,7 +27,10 @@ pub const fn vec4(x: f32, y: f32, z: f32, w: f32) -> Vec4 {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Vec4(pub(crate) float32x4_t);
 
diff --git a/src/f32/scalar/mat2.rs b/src/f32/scalar/mat2.rs
index b62fe837..f116c8ef 100644
--- a/src/f32/scalar/mat2.rs
+++ b/src/f32/scalar/mat2.rs
@@ -14,7 +14,10 @@ pub const fn mat2(x_axis: Vec2, y_axis: Vec2) -> Mat2 {
 
 /// A 2x2 column major matrix.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(
     not(any(feature = "scalar-math", target_arch = "spirv")),
     repr(align(16))
diff --git a/src/f32/scalar/mat3a.rs b/src/f32/scalar/mat3a.rs
index 0eca6b72..24c9271c 100644
--- a/src/f32/scalar/mat3a.rs
+++ b/src/f32/scalar/mat3a.rs
@@ -42,7 +42,10 @@ pub const fn mat3a(x_axis: Vec3A, y_axis: Vec3A, z_axis: Vec3A) -> Mat3A {
 /// vectors respectively. These methods assume that `Self` contains a valid affine
 /// transform.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::AnyBitPattern))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::AnyBitPattern)
+)]
 #[repr(C)]
 pub struct Mat3A {
     pub x_axis: Vec3A,
diff --git a/src/f32/scalar/mat4.rs b/src/f32/scalar/mat4.rs
index 4c234937..f43ece48 100644
--- a/src/f32/scalar/mat4.rs
+++ b/src/f32/scalar/mat4.rs
@@ -47,7 +47,10 @@ pub const fn mat4(x_axis: Vec4, y_axis: Vec4, z_axis: Vec4, w_axis: Vec4) -> Mat
 /// The resulting perspective project can be use to transform 3D vectors as points with
 /// perspective correction using the [`Self::project_point3()`] convenience method.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(
     any(
         not(any(feature = "scalar-math", target_arch = "spirv")),
diff --git a/src/f32/scalar/quat.rs b/src/f32/scalar/quat.rs
index 6d2cf90f..cb0f2e11 100644
--- a/src/f32/scalar/quat.rs
+++ b/src/f32/scalar/quat.rs
@@ -26,7 +26,10 @@ pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat {
 /// floating point "error creep" which can occur when successive quaternion
 /// operations are applied.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(
     not(any(feature = "scalar-math", target_arch = "spirv")),
     repr(align(16))
diff --git a/src/f32/scalar/vec3a.rs b/src/f32/scalar/vec3a.rs
index 980fdeb0..d0e843e1 100644
--- a/src/f32/scalar/vec3a.rs
+++ b/src/f32/scalar/vec3a.rs
@@ -23,7 +23,10 @@ pub const fn vec3a(x: f32, y: f32, z: f32) -> Vec3A {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy, PartialEq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::AnyBitPattern))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::AnyBitPattern)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/f32/scalar/vec4.rs b/src/f32/scalar/vec4.rs
index e643cc7f..a56eb492 100644
--- a/src/f32/scalar/vec4.rs
+++ b/src/f32/scalar/vec4.rs
@@ -20,7 +20,10 @@ pub const fn vec4(x: f32, y: f32, z: f32, w: f32) -> Vec4 {
 
 /// A 4-dimensional vector.
 #[derive(Clone, Copy, PartialEq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(
     any(
         not(any(feature = "scalar-math", target_arch = "spirv")),
diff --git a/src/f32/sse2/mat2.rs b/src/f32/sse2/mat2.rs
index a646fa75..7b23e59b 100644
--- a/src/f32/sse2/mat2.rs
+++ b/src/f32/sse2/mat2.rs
@@ -29,7 +29,10 @@ pub const fn mat2(x_axis: Vec2, y_axis: Vec2) -> Mat2 {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Mat2(pub(crate) __m128);
 
diff --git a/src/f32/sse2/mat3a.rs b/src/f32/sse2/mat3a.rs
index 1b37a425..a1a15779 100644
--- a/src/f32/sse2/mat3a.rs
+++ b/src/f32/sse2/mat3a.rs
@@ -47,7 +47,10 @@ pub const fn mat3a(x_axis: Vec3A, y_axis: Vec3A, z_axis: Vec3A) -> Mat3A {
 /// vectors respectively. These methods assume that `Self` contains a valid affine
 /// transform.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct Mat3A {
     pub x_axis: Vec3A,
diff --git a/src/f32/sse2/mat4.rs b/src/f32/sse2/mat4.rs
index 3471a3d6..9791c9cb 100644
--- a/src/f32/sse2/mat4.rs
+++ b/src/f32/sse2/mat4.rs
@@ -53,7 +53,10 @@ pub const fn mat4(x_axis: Vec4, y_axis: Vec4, z_axis: Vec4, w_axis: Vec4) -> Mat
 /// The resulting perspective project can be use to transform 3D vectors as points with
 /// perspective correction using the [`Self::project_point3()`] convenience method.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct Mat4 {
     pub x_axis: Vec4,
diff --git a/src/f32/sse2/quat.rs b/src/f32/sse2/quat.rs
index 920b5b24..9ddde833 100644
--- a/src/f32/sse2/quat.rs
+++ b/src/f32/sse2/quat.rs
@@ -44,7 +44,10 @@ pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Quat(pub(crate) __m128);
 
diff --git a/src/f32/sse2/vec3a.rs b/src/f32/sse2/vec3a.rs
index aba67170..6ed72195 100644
--- a/src/f32/sse2/vec3a.rs
+++ b/src/f32/sse2/vec3a.rs
@@ -34,7 +34,10 @@ pub const fn vec3a(x: f32, y: f32, z: f32) -> Vec3A {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Vec3A(pub(crate) __m128);
 
diff --git a/src/f32/sse2/vec4.rs b/src/f32/sse2/vec4.rs
index 1299f201..c5b034ac 100644
--- a/src/f32/sse2/vec4.rs
+++ b/src/f32/sse2/vec4.rs
@@ -30,7 +30,10 @@ pub const fn vec4(x: f32, y: f32, z: f32, w: f32) -> Vec4 {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Vec4(pub(crate) __m128);
 
diff --git a/src/f32/vec2.rs b/src/f32/vec2.rs
index 08b15d06..88e12097 100644
--- a/src/f32/vec2.rs
+++ b/src/f32/vec2.rs
@@ -15,7 +15,10 @@ pub const fn vec2(x: f32, y: f32) -> Vec2 {
 
 /// A 2-dimensional vector.
 #[derive(Clone, Copy, PartialEq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(8)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/f32/vec3.rs b/src/f32/vec3.rs
index f71279ad..19c1e268 100644
--- a/src/f32/vec3.rs
+++ b/src/f32/vec3.rs
@@ -15,7 +15,10 @@ pub const fn vec3(x: f32, y: f32, z: f32) -> Vec3 {
 
 /// A 3-dimensional vector.
 #[derive(Clone, Copy, PartialEq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct Vec3 {
diff --git a/src/f32/wasm32/mat2.rs b/src/f32/wasm32/mat2.rs
index b9322802..976242e6 100644
--- a/src/f32/wasm32/mat2.rs
+++ b/src/f32/wasm32/mat2.rs
@@ -20,7 +20,10 @@ pub const fn mat2(x_axis: Vec2, y_axis: Vec2) -> Mat2 {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Mat2(pub(crate) v128);
 
diff --git a/src/f32/wasm32/mat3a.rs b/src/f32/wasm32/mat3a.rs
index f84ec21a..1704a84a 100644
--- a/src/f32/wasm32/mat3a.rs
+++ b/src/f32/wasm32/mat3a.rs
@@ -44,7 +44,10 @@ pub const fn mat3a(x_axis: Vec3A, y_axis: Vec3A, z_axis: Vec3A) -> Mat3A {
 /// vectors respectively. These methods assume that `Self` contains a valid affine
 /// transform.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct Mat3A {
     pub x_axis: Vec3A,
diff --git a/src/f32/wasm32/mat4.rs b/src/f32/wasm32/mat4.rs
index 64529b83..171b92be 100644
--- a/src/f32/wasm32/mat4.rs
+++ b/src/f32/wasm32/mat4.rs
@@ -50,7 +50,10 @@ pub const fn mat4(x_axis: Vec4, y_axis: Vec4, z_axis: Vec4, w_axis: Vec4) -> Mat
 /// The resulting perspective project can be use to transform 3D vectors as points with
 /// perspective correction using the [`Self::project_point3()`] convenience method.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct Mat4 {
     pub x_axis: Vec4,
diff --git a/src/f32/wasm32/quat.rs b/src/f32/wasm32/quat.rs
index d5ec2195..82121916 100644
--- a/src/f32/wasm32/quat.rs
+++ b/src/f32/wasm32/quat.rs
@@ -35,7 +35,10 @@ pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Quat(pub(crate) v128);
 
diff --git a/src/f32/wasm32/vec3a.rs b/src/f32/wasm32/vec3a.rs
index d05a48c4..0e6f28f6 100644
--- a/src/f32/wasm32/vec3a.rs
+++ b/src/f32/wasm32/vec3a.rs
@@ -25,7 +25,10 @@ pub const fn vec3a(x: f32, y: f32, z: f32) -> Vec3A {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Vec3A(pub(crate) v128);
 
diff --git a/src/f32/wasm32/vec4.rs b/src/f32/wasm32/vec4.rs
index 8eadf189..adf6c60c 100644
--- a/src/f32/wasm32/vec4.rs
+++ b/src/f32/wasm32/vec4.rs
@@ -21,7 +21,10 @@ pub const fn vec4(x: f32, y: f32, z: f32, w: f32) -> Vec4 {
 ///
 /// This type is 16 byte aligned.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(transparent)]
 pub struct Vec4(pub(crate) v128);
 
diff --git a/src/f64/daffine2.rs b/src/f64/daffine2.rs
index 6f7df922..d4f6b93c 100644
--- a/src/f64/daffine2.rs
+++ b/src/f64/daffine2.rs
@@ -5,7 +5,10 @@ use core::ops::{Deref, DerefMut, Mul, MulAssign};
 
 /// A 2D affine transform, which can represent translation, rotation, scaling and shear.
 #[derive(Copy, Clone)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct DAffine2 {
     pub matrix2: DMat2,
diff --git a/src/f64/daffine3.rs b/src/f64/daffine3.rs
index 8c54fa62..cd3e468f 100644
--- a/src/f64/daffine3.rs
+++ b/src/f64/daffine3.rs
@@ -5,7 +5,10 @@ use core::ops::{Deref, DerefMut, Mul, MulAssign};
 
 /// A 3D affine transform, which can represent translation, rotation, scaling and shear.
 #[derive(Copy, Clone)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct DAffine3 {
     pub matrix3: DMat3,
diff --git a/src/f64/dmat2.rs b/src/f64/dmat2.rs
index 0208df36..9fb0aabf 100644
--- a/src/f64/dmat2.rs
+++ b/src/f64/dmat2.rs
@@ -14,7 +14,10 @@ pub const fn dmat2(x_axis: DVec2, y_axis: DVec2) -> DMat2 {
 
 /// A 2x2 column major matrix.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[repr(C)]
 pub struct DMat2 {
diff --git a/src/f64/dmat3.rs b/src/f64/dmat3.rs
index d39f6f64..9a895ff4 100644
--- a/src/f64/dmat3.rs
+++ b/src/f64/dmat3.rs
@@ -42,7 +42,10 @@ pub const fn dmat3(x_axis: DVec3, y_axis: DVec3, z_axis: DVec3) -> DMat3 {
 /// vectors respectively. These methods assume that `Self` contains a valid affine
 /// transform.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[repr(C)]
 pub struct DMat3 {
     pub x_axis: DVec3,
diff --git a/src/f64/dmat4.rs b/src/f64/dmat4.rs
index ae3ecf70..ffd28aab 100644
--- a/src/f64/dmat4.rs
+++ b/src/f64/dmat4.rs
@@ -47,7 +47,10 @@ pub const fn dmat4(x_axis: DVec4, y_axis: DVec4, z_axis: DVec4, w_axis: DVec4) -
 /// The resulting perspective project can be use to transform 3D vectors as points with
 /// perspective correction using the [`Self::project_point3()`] convenience method.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[repr(C)]
 pub struct DMat4 {
diff --git a/src/f64/dquat.rs b/src/f64/dquat.rs
index ee530ea6..5106e9da 100644
--- a/src/f64/dquat.rs
+++ b/src/f64/dquat.rs
@@ -26,7 +26,10 @@ pub const fn dquat(x: f64, y: f64, z: f64, w: f64) -> DQuat {
 /// floating point "error creep" which can occur when successive quaternion
 /// operations are applied.
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct DQuat {
diff --git a/src/f64/dvec2.rs b/src/f64/dvec2.rs
index 9344d8fe..1378c917 100644
--- a/src/f64/dvec2.rs
+++ b/src/f64/dvec2.rs
@@ -15,7 +15,10 @@ pub const fn dvec2(x: f64, y: f64) -> DVec2 {
 
 /// A 2-dimensional vector.
 #[derive(Clone, Copy, PartialEq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/f64/dvec3.rs b/src/f64/dvec3.rs
index 4b71c124..4bd4e3df 100644
--- a/src/f64/dvec3.rs
+++ b/src/f64/dvec3.rs
@@ -15,7 +15,10 @@ pub const fn dvec3(x: f64, y: f64, z: f64) -> DVec3 {
 
 /// A 3-dimensional vector.
 #[derive(Clone, Copy, PartialEq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct DVec3 {
diff --git a/src/f64/dvec4.rs b/src/f64/dvec4.rs
index bc473f81..4d44a438 100644
--- a/src/f64/dvec4.rs
+++ b/src/f64/dvec4.rs
@@ -17,7 +17,10 @@ pub const fn dvec4(x: f64, y: f64, z: f64, w: f64) -> DVec4 {
 
 /// A 4-dimensional vector.
 #[derive(Clone, Copy, PartialEq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/features/impl_bytemuck.rs b/src/features/impl_bytemuck.rs
index aa7583b9..7a849b08 100644
--- a/src/features/impl_bytemuck.rs
+++ b/src/features/impl_bytemuck.rs
@@ -1,3 +1,119 @@
+#[cfg(target_arch = "spirv")]
+mod spirv {
+    use crate::{
+        Affine2, Affine3A, DAffine2, DAffine3, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4,
+        I16Vec2, I16Vec3, I16Vec4, I64Vec2, I64Vec3, I64Vec4, I8Vec2, I8Vec3, I8Vec4, IVec2, IVec3,
+        IVec4, Mat2, Mat3, Mat3A, Mat4, Quat, U16Vec2, U16Vec3, U16Vec4, U64Vec2, U64Vec3, U64Vec4,
+        U8Vec2, U8Vec3, U8Vec4, UVec2, UVec3, UVec4, Vec2, Vec3, Vec3A, Vec4,
+    };
+    use bytemuck::{AnyBitPattern, Pod, Zeroable};
+
+    // Affine2 contains internal padding due to Mat2 using SIMD
+    unsafe impl AnyBitPattern for Affine2 {}
+    unsafe impl Zeroable for Affine2 {}
+    unsafe impl AnyBitPattern for Affine3A {}
+    unsafe impl Zeroable for Affine3A {}
+
+    unsafe impl Pod for Mat2 {}
+    unsafe impl Zeroable for Mat2 {}
+    unsafe impl Pod for Mat3 {}
+    unsafe impl Zeroable for Mat3 {}
+    unsafe impl AnyBitPattern for Mat3A {}
+    unsafe impl Zeroable for Mat3A {}
+    unsafe impl Pod for Mat4 {}
+    unsafe impl Zeroable for Mat4 {}
+
+    unsafe impl Pod for Quat {}
+    unsafe impl Zeroable for Quat {}
+
+    unsafe impl Pod for Vec2 {}
+    unsafe impl Zeroable for Vec2 {}
+    unsafe impl Pod for Vec3 {}
+    unsafe impl Zeroable for Vec3 {}
+    unsafe impl AnyBitPattern for Vec3A {}
+    unsafe impl Zeroable for Vec3A {}
+    unsafe impl Pod for Vec4 {}
+    unsafe impl Zeroable for Vec4 {}
+
+    unsafe impl Pod for DAffine2 {}
+    unsafe impl Zeroable for DAffine2 {}
+    unsafe impl Pod for DAffine3 {}
+    unsafe impl Zeroable for DAffine3 {}
+
+    unsafe impl Pod for DMat2 {}
+    unsafe impl Zeroable for DMat2 {}
+    unsafe impl Pod for DMat3 {}
+    unsafe impl Zeroable for DMat3 {}
+    unsafe impl Pod for DMat4 {}
+    unsafe impl Zeroable for DMat4 {}
+
+    unsafe impl Pod for DQuat {}
+    unsafe impl Zeroable for DQuat {}
+
+    unsafe impl Pod for DVec2 {}
+    unsafe impl Zeroable for DVec2 {}
+    unsafe impl Pod for DVec3 {}
+    unsafe impl Zeroable for DVec3 {}
+    unsafe impl Pod for DVec4 {}
+    unsafe impl Zeroable for DVec4 {}
+
+    unsafe impl Pod for I8Vec2 {}
+    unsafe impl Zeroable for I8Vec2 {}
+    unsafe impl Pod for I8Vec3 {}
+    unsafe impl Zeroable for I8Vec3 {}
+    unsafe impl Pod for I8Vec4 {}
+    unsafe impl Zeroable for I8Vec4 {}
+
+    unsafe impl Pod for U8Vec2 {}
+    unsafe impl Zeroable for U8Vec2 {}
+    unsafe impl Pod for U8Vec3 {}
+    unsafe impl Zeroable for U8Vec3 {}
+    unsafe impl Pod for U8Vec4 {}
+    unsafe impl Zeroable for U8Vec4 {}
+
+    unsafe impl Pod for I16Vec2 {}
+    unsafe impl Zeroable for I16Vec2 {}
+    unsafe impl Pod for I16Vec3 {}
+    unsafe impl Zeroable for I16Vec3 {}
+    unsafe impl Pod for I16Vec4 {}
+    unsafe impl Zeroable for I16Vec4 {}
+
+    unsafe impl Pod for U16Vec2 {}
+    unsafe impl Zeroable for U16Vec2 {}
+    unsafe impl Pod for U16Vec3 {}
+    unsafe impl Zeroable for U16Vec3 {}
+    unsafe impl Pod for U16Vec4 {}
+    unsafe impl Zeroable for U16Vec4 {}
+
+    unsafe impl Pod for IVec2 {}
+    unsafe impl Zeroable for IVec2 {}
+    unsafe impl Pod for IVec3 {}
+    unsafe impl Zeroable for IVec3 {}
+    unsafe impl Pod for IVec4 {}
+    unsafe impl Zeroable for IVec4 {}
+
+    unsafe impl Pod for UVec2 {}
+    unsafe impl Zeroable for UVec2 {}
+    unsafe impl Pod for UVec3 {}
+    unsafe impl Zeroable for UVec3 {}
+    unsafe impl Pod for UVec4 {}
+    unsafe impl Zeroable for UVec4 {}
+
+    unsafe impl Pod for I64Vec2 {}
+    unsafe impl Zeroable for I64Vec2 {}
+    unsafe impl Pod for I64Vec3 {}
+    unsafe impl Zeroable for I64Vec3 {}
+    unsafe impl Pod for I64Vec4 {}
+    unsafe impl Zeroable for I64Vec4 {}
+
+    unsafe impl Pod for U64Vec2 {}
+    unsafe impl Zeroable for U64Vec2 {}
+    unsafe impl Pod for U64Vec3 {}
+    unsafe impl Zeroable for U64Vec3 {}
+    unsafe impl Pod for U64Vec4 {}
+    unsafe impl Zeroable for U64Vec4 {}
+}
+
 #[cfg(test)]
 mod test {
     use crate::{
diff --git a/src/i16/i16vec2.rs b/src/i16/i16vec2.rs
index 9546102e..0bade0df 100644
--- a/src/i16/i16vec2.rs
+++ b/src/i16/i16vec2.rs
@@ -16,7 +16,10 @@ pub const fn i16vec2(x: i16, y: i16) -> I16Vec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(4)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/i16/i16vec3.rs b/src/i16/i16vec3.rs
index 4f6c31dd..8d6206f2 100644
--- a/src/i16/i16vec3.rs
+++ b/src/i16/i16vec3.rs
@@ -19,7 +19,10 @@ pub const fn i16vec3(x: i16, y: i16, z: i16) -> I16Vec3 {
 /// A 3-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct I16Vec3 {
diff --git a/src/i16/i16vec4.rs b/src/i16/i16vec4.rs
index 55eca576..31e46727 100644
--- a/src/i16/i16vec4.rs
+++ b/src/i16/i16vec4.rs
@@ -20,7 +20,10 @@ pub const fn i16vec4(x: i16, y: i16, z: i16, w: i16) -> I16Vec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(8)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/i32/ivec2.rs b/src/i32/ivec2.rs
index 8e0e7979..e4d2f935 100644
--- a/src/i32/ivec2.rs
+++ b/src/i32/ivec2.rs
@@ -16,7 +16,10 @@ pub const fn ivec2(x: i32, y: i32) -> IVec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(8)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/i32/ivec3.rs b/src/i32/ivec3.rs
index 7a76091c..039ac100 100644
--- a/src/i32/ivec3.rs
+++ b/src/i32/ivec3.rs
@@ -19,7 +19,10 @@ pub const fn ivec3(x: i32, y: i32, z: i32) -> IVec3 {
 /// A 3-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct IVec3 {
diff --git a/src/i32/ivec4.rs b/src/i32/ivec4.rs
index cc0790ac..d721f3b0 100644
--- a/src/i32/ivec4.rs
+++ b/src/i32/ivec4.rs
@@ -20,7 +20,10 @@ pub const fn ivec4(x: i32, y: i32, z: i32, w: i32) -> IVec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/i64/i64vec2.rs b/src/i64/i64vec2.rs
index 2c078b4c..990b8df3 100644
--- a/src/i64/i64vec2.rs
+++ b/src/i64/i64vec2.rs
@@ -16,7 +16,10 @@ pub const fn i64vec2(x: i64, y: i64) -> I64Vec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/i64/i64vec3.rs b/src/i64/i64vec3.rs
index 631bb2fa..56beb0a3 100644
--- a/src/i64/i64vec3.rs
+++ b/src/i64/i64vec3.rs
@@ -19,7 +19,10 @@ pub const fn i64vec3(x: i64, y: i64, z: i64) -> I64Vec3 {
 /// A 3-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct I64Vec3 {
diff --git a/src/i64/i64vec4.rs b/src/i64/i64vec4.rs
index 3340cc62..2c4003eb 100644
--- a/src/i64/i64vec4.rs
+++ b/src/i64/i64vec4.rs
@@ -20,7 +20,10 @@ pub const fn i64vec4(x: i64, y: i64, z: i64, w: i64) -> I64Vec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/i8/i8vec2.rs b/src/i8/i8vec2.rs
index 89298c34..32fb57e7 100644
--- a/src/i8/i8vec2.rs
+++ b/src/i8/i8vec2.rs
@@ -16,7 +16,10 @@ pub const fn i8vec2(x: i8, y: i8) -> I8Vec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(2)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/i8/i8vec3.rs b/src/i8/i8vec3.rs
index 80d38acb..b3c7bc48 100644
--- a/src/i8/i8vec3.rs
+++ b/src/i8/i8vec3.rs
@@ -19,7 +19,10 @@ pub const fn i8vec3(x: i8, y: i8, z: i8) -> I8Vec3 {
 /// A 3-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct I8Vec3 {
diff --git a/src/i8/i8vec4.rs b/src/i8/i8vec4.rs
index 58ed1918..480b19d6 100644
--- a/src/i8/i8vec4.rs
+++ b/src/i8/i8vec4.rs
@@ -20,7 +20,10 @@ pub const fn i8vec4(x: i8, y: i8, z: i8, w: i8) -> I8Vec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(4)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/u16/u16vec2.rs b/src/u16/u16vec2.rs
index 285ea1b2..3cc85ad9 100644
--- a/src/u16/u16vec2.rs
+++ b/src/u16/u16vec2.rs
@@ -16,7 +16,10 @@ pub const fn u16vec2(x: u16, y: u16) -> U16Vec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(4)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/u16/u16vec3.rs b/src/u16/u16vec3.rs
index c3ceb611..c2783c32 100644
--- a/src/u16/u16vec3.rs
+++ b/src/u16/u16vec3.rs
@@ -19,7 +19,10 @@ pub const fn u16vec3(x: u16, y: u16, z: u16) -> U16Vec3 {
 /// A 3-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct U16Vec3 {
diff --git a/src/u16/u16vec4.rs b/src/u16/u16vec4.rs
index eec8d1db..aa3b75d1 100644
--- a/src/u16/u16vec4.rs
+++ b/src/u16/u16vec4.rs
@@ -20,7 +20,10 @@ pub const fn u16vec4(x: u16, y: u16, z: u16, w: u16) -> U16Vec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(8)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/u32/uvec2.rs b/src/u32/uvec2.rs
index e7a1ced8..a1e723d3 100644
--- a/src/u32/uvec2.rs
+++ b/src/u32/uvec2.rs
@@ -16,7 +16,10 @@ pub const fn uvec2(x: u32, y: u32) -> UVec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(8)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/u32/uvec3.rs b/src/u32/uvec3.rs
index 88b0528e..adbaaacb 100644
--- a/src/u32/uvec3.rs
+++ b/src/u32/uvec3.rs
@@ -19,7 +19,10 @@ pub const fn uvec3(x: u32, y: u32, z: u32) -> UVec3 {
 /// A 3-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct UVec3 {
diff --git a/src/u32/uvec4.rs b/src/u32/uvec4.rs
index 1ccbd316..1521e458 100644
--- a/src/u32/uvec4.rs
+++ b/src/u32/uvec4.rs
@@ -20,7 +20,10 @@ pub const fn uvec4(x: u32, y: u32, z: u32, w: u32) -> UVec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/u64/u64vec2.rs b/src/u64/u64vec2.rs
index 70f458e4..421d38d9 100644
--- a/src/u64/u64vec2.rs
+++ b/src/u64/u64vec2.rs
@@ -16,7 +16,10 @@ pub const fn u64vec2(x: u64, y: u64) -> U64Vec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/u64/u64vec3.rs b/src/u64/u64vec3.rs
index 0069d4b5..8c63e089 100644
--- a/src/u64/u64vec3.rs
+++ b/src/u64/u64vec3.rs
@@ -19,7 +19,10 @@ pub const fn u64vec3(x: u64, y: u64, z: u64) -> U64Vec3 {
 /// A 3-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct U64Vec3 {
diff --git a/src/u64/u64vec4.rs b/src/u64/u64vec4.rs
index 655ecff9..306a5392 100644
--- a/src/u64/u64vec4.rs
+++ b/src/u64/u64vec4.rs
@@ -20,7 +20,10 @@ pub const fn u64vec4(x: u64, y: u64, z: u64, w: u64) -> U64Vec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/u8/u8vec2.rs b/src/u8/u8vec2.rs
index 3602e1ee..3bfc2a52 100644
--- a/src/u8/u8vec2.rs
+++ b/src/u8/u8vec2.rs
@@ -16,7 +16,10 @@ pub const fn u8vec2(x: u8, y: u8) -> U8Vec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(2)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/u8/u8vec3.rs b/src/u8/u8vec3.rs
index 37b0d5f3..e9cd3e90 100644
--- a/src/u8/u8vec3.rs
+++ b/src/u8/u8vec3.rs
@@ -19,7 +19,10 @@ pub const fn u8vec3(x: u8, y: u8, z: u8) -> U8Vec3 {
 /// A 3-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct U8Vec3 {
diff --git a/src/u8/u8vec4.rs b/src/u8/u8vec4.rs
index 16233235..4bc700ed 100644
--- a/src/u8/u8vec4.rs
+++ b/src/u8/u8vec4.rs
@@ -20,7 +20,10 @@ pub const fn u8vec4(x: u8, y: u8, z: u8, w: u8) -> U8Vec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(4)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/usize/usizevec2.rs b/src/usize/usizevec2.rs
index bb11c575..4b1c2188 100644
--- a/src/usize/usizevec2.rs
+++ b/src/usize/usizevec2.rs
@@ -16,7 +16,10 @@ pub const fn usizevec2(x: usize, y: usize) -> USizeVec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/src/usize/usizevec3.rs b/src/usize/usizevec3.rs
index 16a1b2b8..105ac422 100644
--- a/src/usize/usizevec3.rs
+++ b/src/usize/usizevec3.rs
@@ -19,7 +19,10 @@ pub const fn usizevec3(x: usize, y: usize, z: usize) -> USizeVec3 {
 /// A 3-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct USizeVec3 {
diff --git a/src/usize/usizevec4.rs b/src/usize/usizevec4.rs
index 37cc1d70..8b83f841 100644
--- a/src/usize/usizevec4.rs
+++ b/src/usize/usizevec4.rs
@@ -20,7 +20,10 @@ pub const fn usizevec4(x: usize, y: usize, z: usize, w: usize) -> USizeVec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(
+    all(feature = "bytemuck", not(target_arch = "spirv")),
+    derive(bytemuck::Pod, bytemuck::Zeroable)
+)]
 #[cfg_attr(feature = "cuda", repr(align(16)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
diff --git a/templates/affine.rs.tera b/templates/affine.rs.tera
index 861946f1..7723712f 100644
--- a/templates/affine.rs.tera
+++ b/templates/affine.rs.tera
@@ -62,12 +62,12 @@ use core::ops::{Deref, DerefMut, Mul, MulAssign};
 {%- endif %}
 #[derive(Copy, Clone)]
 {%- if self_t == "Affine2" %}
-#[cfg_attr(all(feature = "bytemuck", not(feature = "scalar-math")), derive(bytemuck::AnyBitPattern))]
-#[cfg_attr(all(feature = "bytemuck", feature = "scalar-math"), derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(all(feature = "bytemuck", not(any(feature = "scalar-math", target_arch = "spirv"))), derive(bytemuck::AnyBitPattern))]
+#[cfg_attr(all(feature = "bytemuck", feature = "scalar-math", not(target_arch = "spirv")), derive(bytemuck::Pod, bytemuck::Zeroable))]
 {%- elif self_t == "Affine3A" and is_scalar %}
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::AnyBitPattern))]
+#[cfg_attr(all(feature = "bytemuck", not(target_arch = "spirv")), derive(bytemuck::AnyBitPattern))]
 {%- else %}
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(all(feature = "bytemuck", not(target_arch = "spirv")), derive(bytemuck::Pod, bytemuck::Zeroable))]
 {%- endif %}
 #[repr(C)]
 pub struct {{ self_t }} {
diff --git a/templates/mat.rs.tera b/templates/mat.rs.tera
index e624d481..fafddea5 100644
--- a/templates/mat.rs.tera
+++ b/templates/mat.rs.tera
@@ -201,9 +201,9 @@ pub const fn {{ self_t | lower }}(
 {%- endif %}
 #[derive(Clone, Copy)]
 {%- if self_t == "Mat3A" and is_scalar %}
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::AnyBitPattern))]
+#[cfg_attr(all(feature = "bytemuck", not(target_arch = "spirv")), derive(bytemuck::AnyBitPattern))]
 {%- else %}
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(all(feature = "bytemuck", not(target_arch = "spirv")), derive(bytemuck::Pod, bytemuck::Zeroable))]
 {%- endif %}
 {%- if self_t == "Mat4" and is_scalar %}
 #[cfg_attr(
diff --git a/templates/quat.rs.tera b/templates/quat.rs.tera
index 714bd221..48c643b6 100644
--- a/templates/quat.rs.tera
+++ b/templates/quat.rs.tera
@@ -104,7 +104,7 @@ pub const fn {{ self_t | lower }}(x: {{ scalar_t }}, y: {{ scalar_t }}, z: {{ sc
 /// This type is 16 byte aligned.
 {%- endif %}
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(all(feature = "bytemuck", not(target_arch = "spirv")), derive(bytemuck::Pod, bytemuck::Zeroable))]
 {%- if is_scalar %}
 {%- if scalar_t == "f32" %}
 #[cfg_attr(not(any(feature = "scalar-math", target_arch = "spirv")), repr(align(16)))]
diff --git a/templates/vec.rs.tera b/templates/vec.rs.tera
index 4d7ddb0f..7497eaf6 100644
--- a/templates/vec.rs.tera
+++ b/templates/vec.rs.tera
@@ -312,9 +312,9 @@ pub const fn {{ self_t | lower }}(
     {% endif %}
 )]
 {%- if self_t == "Vec3A" and is_scalar %}
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::AnyBitPattern))]
+#[cfg_attr(all(feature = "bytemuck", not(target_arch = "spirv")), derive(bytemuck::AnyBitPattern))]
 {%- else %}
-#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+#[cfg_attr(all(feature = "bytemuck", not(target_arch = "spirv")), derive(bytemuck::Pod, bytemuck::Zeroable))]
 {%- endif %}
 {%- if self_t == "Vec3A" and is_scalar %}
 #[cfg_attr(not(target_arch = "spirv"), repr(align(16)))]