diff --git a/crates/bevy_gizmos/src/arcs.rs b/crates/bevy_gizmos/src/arcs.rs
index c44ecd22b9d83..a3f9e6287aaa3 100644
--- a/crates/bevy_gizmos/src/arcs.rs
+++ b/crates/bevy_gizmos/src/arcs.rs
@@ -5,7 +5,7 @@
 
 use crate::circles::DEFAULT_CIRCLE_SEGMENTS;
 use crate::prelude::Gizmos;
-use bevy_math::Vec2;
+use bevy_math::{Angle, Radians, Vec2};
 use bevy_render::color::Color;
 use std::f32::consts::TAU;
 
@@ -17,9 +17,9 @@ impl<'s> Gizmos<'s> {
     /// # Arguments
     /// - `position` sets the center of this circle.
     /// - `radius` controls the distance from `position` to this arc, and thus its curvature.
-    /// - `direction_angle` sets the clockwise  angle in radians between `Vec2::Y` and
+    /// - `direction_angle` sets the clockwise angle between `Vec2::Y` and
     /// the vector from `position` to the midpoint of the arc.
-    /// - `arc_angle` sets the length of this arc, in radians.
+    /// - `arc_angle` sets the length of this arc.
     ///
     /// # Example
     /// ```
@@ -28,12 +28,24 @@ impl<'s> Gizmos<'s> {
     /// # use bevy_math::prelude::*;
     /// # use std::f32::consts::PI;
     /// fn system(mut gizmos: Gizmos) {
-    ///     gizmos.arc_2d(Vec2::ZERO, 0., PI / 4., 1., Color::GREEN);
+    ///     gizmos.arc_2d(
+    ///         Vec2::ZERO,
+    ///         Radians::ZERO,
+    ///         Radians::FRAC_PI_4,
+    ///         1.,
+    ///         Color::GREEN
+    ///     );
     ///
     ///     // Arcs have 32 line-segments by default.
     ///     // You may want to increase this for larger arcs.
     ///     gizmos
-    ///         .arc_2d(Vec2::ZERO, 0., PI / 4., 5., Color::RED)
+    ///         .arc_2d(
+    ///             Vec2::ZERO,
+    ///             Radians::ZERO,
+    ///             Radians::FRAC_PI_4,
+    ///             5.,
+    ///             Color::RED
+    ///         )
     ///         .segments(64);
     /// }
     /// # bevy_ecs::system::assert_is_system(system);
@@ -42,16 +54,16 @@ impl<'s> Gizmos<'s> {
     pub fn arc_2d(
         &mut self,
         position: Vec2,
-        direction_angle: f32,
-        arc_angle: f32,
+        direction_angle: impl Into<Radians>,
+        arc_angle: impl Into<Radians>,
         radius: f32,
         color: Color,
     ) -> Arc2dBuilder<'_, 's> {
         Arc2dBuilder {
             gizmos: self,
             position,
-            direction_angle,
-            arc_angle,
+            direction_angle: direction_angle.into(),
+            arc_angle: arc_angle.into(),
             radius,
             color,
             segments: None,
@@ -63,8 +75,8 @@ impl<'s> Gizmos<'s> {
 pub struct Arc2dBuilder<'a, 's> {
     gizmos: &'a mut Gizmos<'s>,
     position: Vec2,
-    direction_angle: f32,
-    arc_angle: f32,
+    direction_angle: Radians,
+    arc_angle: Radians,
     radius: f32,
     color: Color,
     segments: Option<usize>,
@@ -84,7 +96,9 @@ impl Drop for Arc2dBuilder<'_, '_> {
             Some(segments) => segments,
             // Do a linear interpolation between 1 and `DEFAULT_CIRCLE_SEGMENTS`
             // using the arc angle as scalar.
-            None => ((self.arc_angle.abs() / TAU) * DEFAULT_CIRCLE_SEGMENTS as f32).ceil() as usize,
+            None => {
+                ((self.arc_angle.abs().0 / TAU) * DEFAULT_CIRCLE_SEGMENTS as f32).ceil() as usize
+            }
         };
 
         let positions = arc_inner(self.direction_angle, self.arc_angle, self.radius, segments)
@@ -94,8 +108,8 @@ impl Drop for Arc2dBuilder<'_, '_> {
 }
 
 fn arc_inner(
-    direction_angle: f32,
-    arc_angle: f32,
+    direction_angle: Radians,
+    arc_angle: Radians,
     radius: f32,
     segments: usize,
 ) -> impl Iterator<Item = Vec2> {
diff --git a/crates/bevy_math/src/angle/degrees.rs b/crates/bevy_math/src/angle/degrees.rs
new file mode 100644
index 0000000000000..3a671de4cc664
--- /dev/null
+++ b/crates/bevy_math/src/angle/degrees.rs
@@ -0,0 +1,202 @@
+use std::{
+    fmt::Debug,
+    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign},
+};
+
+use crate::{Angle, Radians};
+
+/// An angle in degrees.
+///
+/// # Example
+///
+/// ```
+/// use std::f32::consts::PI;
+/// use bevy_math::{Angle, Degrees, Radians};
+///
+/// // Create angles from radians or degrees
+/// let alpha = Degrees(180.0);
+/// let beta = Degrees::from_radians(PI);
+/// assert_eq!(alpha, beta);
+/// assert_eq!(beta, Radians(PI));
+///
+/// // Add degrees and radians together (result is always radians)
+/// assert_eq!(Radians(PI) + Degrees(180.0), Radians(2.0 * PI));
+///
+/// // Get float values
+/// assert_eq!(alpha.0, 180.0);
+/// assert_eq!(alpha.to_radians().0, PI);
+///
+/// // Use trigonometric operations
+/// assert_eq!(alpha.cos(), -1.0);
+///
+/// // Normalize 540 degrees to range [0, 360) to get 180 degrees
+/// let gamma = 3.0 * alpha;
+/// let normalized = gamma.normalized();
+///
+/// // Small threshold for floating point error
+/// assert!((normalized - alpha).abs() < Degrees(0.000001));
+/// ```
+// TODO: Reflect
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+pub struct Degrees(pub f32);
+
+impl Degrees {
+    /// Creates an angle in [`Degrees`] from radians.
+    #[inline]
+    pub fn from_radians(radians: f32) -> Self {
+        Self(radians.to_degrees())
+    }
+
+    /// Returns the angle in [`Radians`].
+    #[inline]
+    pub fn to_radians(self) -> Radians {
+        Radians::from_degrees(self.0)
+    }
+}
+
+impl Angle for Degrees {
+    const ZERO: Self = Self(0.0);
+    const EIGHTH: Self = Self(45.0);
+    const QUARTER: Self = Self(90.0);
+    const HALF: Self = Self(180.0);
+    const FULL: Self = Self(360.0);
+
+    #[inline]
+    fn new(angle: f32) -> Self {
+        Self(angle)
+    }
+
+    #[inline]
+    fn value(self) -> f32 {
+        self.0
+    }
+
+    #[inline]
+    fn sin(self) -> f32 {
+        self.to_radians().sin()
+    }
+
+    #[inline]
+    fn cos(self) -> f32 {
+        self.to_radians().cos()
+    }
+
+    #[inline]
+    fn tan(self) -> f32 {
+        self.to_radians().tan()
+    }
+
+    #[inline]
+    fn sin_cos(self) -> (f32, f32) {
+        self.to_radians().sin_cos()
+    }
+}
+
+impl From<Radians> for Degrees {
+    fn from(angle: Radians) -> Self {
+        angle.to_degrees()
+    }
+}
+
+impl Add for Degrees {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl Sub for Degrees {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Self(self.0 - rhs.0)
+    }
+}
+
+impl Mul<f32> for Degrees {
+    type Output = Self;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        Self(self.0 * rhs)
+    }
+}
+
+impl Mul<Degrees> for f32 {
+    type Output = Degrees;
+
+    fn mul(self, rhs: Degrees) -> Self::Output {
+        Degrees(self * rhs.0)
+    }
+}
+
+impl Div for Degrees {
+    type Output = f32;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        self.0 / rhs.0
+    }
+}
+
+impl Div<f32> for Degrees {
+    type Output = Self;
+
+    fn div(self, rhs: f32) -> Self::Output {
+        Self(self.0 / rhs)
+    }
+}
+
+impl Rem for Degrees {
+    type Output = f32;
+
+    fn rem(self, rhs: Self) -> Self::Output {
+        self.0 % rhs.0
+    }
+}
+
+impl Rem<f32> for Degrees {
+    type Output = Self;
+
+    fn rem(self, rhs: f32) -> Self::Output {
+        Self(self.0 % rhs)
+    }
+}
+
+impl Neg for Degrees {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        Self(-self.0)
+    }
+}
+
+impl AddAssign for Degrees {
+    fn add_assign(&mut self, rhs: Degrees) {
+        self.0 += rhs.0;
+    }
+}
+
+impl SubAssign for Degrees {
+    fn sub_assign(&mut self, rhs: Degrees) {
+        self.0 -= rhs.0;
+    }
+}
+
+impl MulAssign<f32> for Degrees {
+    fn mul_assign(&mut self, rhs: f32) {
+        self.0 *= rhs;
+    }
+}
+
+impl DivAssign<f32> for Degrees {
+    fn div_assign(&mut self, rhs: f32) {
+        self.0 /= rhs;
+    }
+}
+
+impl RemAssign<f32> for Degrees {
+    fn rem_assign(&mut self, rhs: f32) {
+        self.0 %= rhs;
+    }
+}
diff --git a/crates/bevy_math/src/angle/mod.rs b/crates/bevy_math/src/angle/mod.rs
new file mode 100644
index 0000000000000..03a467e66897d
--- /dev/null
+++ b/crates/bevy_math/src/angle/mod.rs
@@ -0,0 +1,222 @@
+use std::ops::{Add, AddAssign, Div, Neg, Rem, Sub, SubAssign};
+
+mod degrees;
+mod radians;
+
+pub use degrees::Degrees;
+pub use radians::Radians;
+
+/// A trait for functionality and constants shared by the [`Degrees`] and [`Radians`] types.
+pub trait Angle:
+    Sized
+    + Clone
+    + Copy
+    + Add<Output = Self>
+    + Sub<Output = Self>
+    + Div<Output = f32>
+    + Rem<Output = f32>
+    + Neg<Output = Self>
+    + PartialEq
+    + PartialOrd
+    + From<Degrees>
+    + From<Radians>
+where
+    Degrees: From<Self>,
+    Radians: From<Self>,
+{
+    /// An angle of zero.
+    const ZERO: Self;
+    /// A `45` degree angle. Equivalent to `π/4` radians.
+    const EIGHTH: Self;
+    /// A `90` degree angle (right angle). Equivalent to `π/2` radians.
+    #[doc(alias = "RIGHT_ANGLE")]
+    const QUARTER: Self;
+    /// A `180` degree angle (straight angle). Equivalent to `π` radians.
+    #[doc(alias = "STRAIGHT_ANGLE")]
+    const HALF: Self;
+    /// A `360` degree angle (perigon). Equivalent to `2π` radians.
+    #[doc(alias("PERIGON", "FULL_ANGLE"))]
+    const FULL: Self;
+
+    /// Creates a new angle.
+    fn new(angle: f32) -> Self;
+
+    /// Returns the angle value contained within `self`.
+    fn value(self) -> f32;
+
+    /// Returns the sine of the angle.
+    fn sin(self) -> f32;
+
+    /// Returns the cosine of the angle.
+    fn cos(self) -> f32;
+
+    /// Returns the tangent of the angle.
+    fn tan(self) -> f32;
+
+    /// Returns the sine and cosine of the angle.
+    fn sin_cos(self) -> (f32, f32);
+
+    /// Returns the absolute angle.
+    #[inline]
+    fn abs(self) -> Self {
+        Self::new(self.value().abs())
+    }
+
+    /// Returns the minimum of the two angles, ignoring NaN.
+    #[inline]
+    fn min(self, other: Self) -> Self {
+        Self::new(self.value().min(other.value()))
+    }
+
+    /// Returns the maximum of the two angles, ignoring NaN.
+    #[inline]
+    fn max(self, other: Self) -> Self {
+        Self::new(self.value().max(other.value()))
+    }
+
+    /// Normalizes the angle to be within the range of `[0, 360)` degrees or `[0, 2π)` radians.
+    #[inline]
+    fn normalized(self) -> Self {
+        if self < Self::FULL && self >= Self::ZERO {
+            self
+        } else {
+            let remainder = Self::new(self % Self::FULL);
+            if remainder >= Self::ZERO {
+                remainder
+            } else {
+                remainder + Self::FULL
+            }
+        }
+    }
+
+    /// Returns the largest integer angle less than or equal to `self`.
+    #[inline]
+    fn floor(self) -> Self {
+        Self::new(self.value().floor())
+    }
+
+    /// Returns the smallest integer angle greater than or equal to `self`.
+    #[inline]
+    fn ceil(self) -> Self {
+        Self::new(self.value().ceil())
+    }
+
+    /// Returns the nearest integer to `self`. If a value is half-way
+    /// between two integers, round away from `0.0`.
+    #[inline]
+    fn round(self) -> Self {
+        Self::new(self.value().round())
+    }
+}
+
+impl PartialEq<Radians> for Degrees {
+    fn eq(&self, other: &Radians) -> bool {
+        *self == other.to_degrees()
+    }
+}
+
+impl PartialEq<Degrees> for Radians {
+    fn eq(&self, other: &Degrees) -> bool {
+        self.to_degrees() == *other
+    }
+}
+
+impl PartialOrd<Radians> for Degrees {
+    fn partial_cmp(&self, other: &Radians) -> Option<std::cmp::Ordering> {
+        self.partial_cmp(&other.to_degrees())
+    }
+}
+
+impl PartialOrd<Degrees> for Radians {
+    fn partial_cmp(&self, other: &Degrees) -> Option<std::cmp::Ordering> {
+        self.to_degrees().partial_cmp(other)
+    }
+}
+
+impl Add<Radians> for Degrees {
+    type Output = Degrees;
+
+    fn add(self, rhs: Radians) -> Self::Output {
+        self + rhs.to_degrees()
+    }
+}
+
+impl Add<Degrees> for Radians {
+    type Output = Radians;
+
+    fn add(self, rhs: Degrees) -> Self::Output {
+        self + rhs.to_radians()
+    }
+}
+
+impl Sub<Radians> for Degrees {
+    type Output = Degrees;
+
+    fn sub(self, rhs: Radians) -> Self::Output {
+        self - rhs.to_degrees()
+    }
+}
+
+impl Sub<Degrees> for Radians {
+    type Output = Radians;
+
+    fn sub(self, rhs: Degrees) -> Self::Output {
+        self - rhs.to_radians()
+    }
+}
+
+impl Div<Radians> for Degrees {
+    type Output = f32;
+
+    fn div(self, rhs: Radians) -> Self::Output {
+        self.0 / rhs.0.to_degrees()
+    }
+}
+
+impl Div<Degrees> for Radians {
+    type Output = f32;
+
+    fn div(self, rhs: Degrees) -> Self::Output {
+        self.0.to_degrees() / rhs.0
+    }
+}
+
+impl Rem<Radians> for Degrees {
+    type Output = f32;
+
+    fn rem(self, rhs: Radians) -> Self::Output {
+        self.0 % rhs.0.to_degrees()
+    }
+}
+
+impl Rem<Degrees> for Radians {
+    type Output = f32;
+
+    fn rem(self, rhs: Degrees) -> Self::Output {
+        self.0.to_degrees() % rhs.0
+    }
+}
+
+impl AddAssign<Radians> for Degrees {
+    fn add_assign(&mut self, rhs: Radians) {
+        *self += rhs.to_degrees();
+    }
+}
+
+impl AddAssign<Degrees> for Radians {
+    fn add_assign(&mut self, rhs: Degrees) {
+        *self += rhs.to_radians();
+    }
+}
+
+impl SubAssign<Radians> for Degrees {
+    fn sub_assign(&mut self, rhs: Radians) {
+        *self -= rhs.to_degrees();
+    }
+}
+
+impl SubAssign<Degrees> for Radians {
+    fn sub_assign(&mut self, rhs: Degrees) {
+        *self -= rhs.to_radians();
+    }
+}
diff --git a/crates/bevy_math/src/angle/radians.rs b/crates/bevy_math/src/angle/radians.rs
new file mode 100644
index 0000000000000..1e36d27905309
--- /dev/null
+++ b/crates/bevy_math/src/angle/radians.rs
@@ -0,0 +1,219 @@
+use std::{
+    fmt::Debug,
+    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign},
+};
+
+use crate::{Angle, Degrees};
+
+/// An angle in radians.
+///
+/// # Example
+///
+/// ```
+/// use std::f32::consts::PI;
+/// use bevy_math::{Angle, Degrees, Radians};
+///
+/// // Create angles from radians or degrees
+/// let alpha = Radians(PI);
+/// let beta = Radians::from_degrees(180.0);
+/// assert_eq!(alpha, beta);
+/// assert_eq!(beta, Degrees(180.0));
+///
+/// // Add degrees and radians together (result is always radians)
+/// assert_eq!(Radians(PI) + Degrees(180.0), Radians(2.0 * PI));
+///
+/// // Get float values
+/// assert_eq!(alpha.0, PI);
+/// assert_eq!(alpha.to_degrees().0, 180.0);
+///
+/// // Use trigonometric operations
+/// assert_eq!(alpha.cos(), -1.0);
+///
+/// // Normalize 3π to range [0, 2π) to get π
+/// let gamma = 3.0 * alpha;
+/// let normalized = gamma.normalized();
+///
+/// // Small threshold for floating point error
+/// assert!((normalized - alpha).abs() < Radians(0.000001));
+/// ```
+// TODO: Reflect
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+pub struct Radians(pub f32);
+
+impl Radians {
+    /// The angle 2π. Equivalent to `Radians::FULL`.
+    #[doc(alias = "TWO_PI")]
+    pub const TAU: Self = Self(std::f32::consts::TAU);
+    /// The angle π (π). Equivalent to `Radians::HALF`.
+    pub const PI: Self = Self(std::f32::consts::PI);
+    /// The angle π/2. Equivalent to `Radians::QUARTER`.
+    #[doc(alias = "HALF_PI")]
+    pub const FRAC_PI_2: Self = Self(std::f32::consts::FRAC_PI_2);
+    /// The angle π/3.
+    pub const FRAC_PI_3: Self = Self(std::f32::consts::FRAC_PI_3);
+    /// The angle π/4. Equivalent to `Radians::EIGHTH`.
+    pub const FRAC_PI_4: Self = Self(std::f32::consts::FRAC_PI_4);
+    /// The angle π/6.
+    pub const FRAC_PI_6: Self = Self(std::f32::consts::FRAC_PI_6);
+    /// The angle π/8.
+    pub const FRAC_PI_8: Self = Self(std::f32::consts::FRAC_PI_8);
+
+    /// Creates an angle in [`Radians`] from degrees.
+    #[inline]
+    pub fn from_degrees(degrees: f32) -> Self {
+        Self(degrees.to_radians())
+    }
+
+    /// Returns the angle in [`Degrees`].
+    #[inline]
+    pub fn to_degrees(self) -> Degrees {
+        Degrees::from_radians(self.0)
+    }
+}
+
+impl Angle for Radians {
+    const ZERO: Self = Self(0.0);
+    const EIGHTH: Self = Self::FRAC_PI_4;
+    const QUARTER: Self = Self::FRAC_PI_2;
+    const HALF: Self = Self::PI;
+    const FULL: Self = Self::TAU;
+
+    #[inline]
+    fn new(angle: f32) -> Self {
+        Self(angle)
+    }
+
+    #[inline]
+    fn value(self) -> f32 {
+        self.0
+    }
+
+    #[inline]
+    fn sin(self) -> f32 {
+        self.0.sin()
+    }
+
+    #[inline]
+    fn cos(self) -> f32 {
+        self.0.cos()
+    }
+
+    #[inline]
+    fn tan(self) -> f32 {
+        self.0.tan()
+    }
+
+    #[inline]
+    fn sin_cos(self) -> (f32, f32) {
+        self.0.sin_cos()
+    }
+}
+
+impl From<Degrees> for Radians {
+    fn from(angle: Degrees) -> Self {
+        angle.to_radians()
+    }
+}
+
+impl Add for Radians {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl Sub for Radians {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Self(self.0 - rhs.0)
+    }
+}
+
+impl Mul<f32> for Radians {
+    type Output = Self;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        Self(self.0 * rhs)
+    }
+}
+
+impl Mul<Radians> for f32 {
+    type Output = Radians;
+
+    fn mul(self, rhs: Radians) -> Self::Output {
+        Radians(self * rhs.0)
+    }
+}
+
+impl Div for Radians {
+    type Output = f32;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        self.0 / rhs.0
+    }
+}
+
+impl Div<f32> for Radians {
+    type Output = Self;
+
+    fn div(self, rhs: f32) -> Self::Output {
+        Self(self.0 / rhs)
+    }
+}
+
+impl Rem for Radians {
+    type Output = f32;
+
+    fn rem(self, rhs: Self) -> Self::Output {
+        self.0 % rhs.0
+    }
+}
+
+impl Rem<f32> for Radians {
+    type Output = Self;
+
+    fn rem(self, rhs: f32) -> Self::Output {
+        Self(self.0 % rhs)
+    }
+}
+
+impl Neg for Radians {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        Self(-self.0)
+    }
+}
+
+impl AddAssign for Radians {
+    fn add_assign(&mut self, rhs: Radians) {
+        self.0 += rhs.0;
+    }
+}
+
+impl SubAssign for Radians {
+    fn sub_assign(&mut self, rhs: Radians) {
+        self.0 -= rhs.0;
+    }
+}
+
+impl MulAssign<f32> for Radians {
+    fn mul_assign(&mut self, rhs: f32) {
+        self.0 *= rhs;
+    }
+}
+
+impl DivAssign<f32> for Radians {
+    fn div_assign(&mut self, rhs: f32) {
+        self.0 /= rhs;
+    }
+}
+
+impl RemAssign<f32> for Radians {
+    fn rem_assign(&mut self, rhs: f32) {
+        self.0 %= rhs;
+    }
+}
diff --git a/crates/bevy_math/src/lib.rs b/crates/bevy_math/src/lib.rs
index c6fb416d7eacf..f035abc3c02fc 100644
--- a/crates/bevy_math/src/lib.rs
+++ b/crates/bevy_math/src/lib.rs
@@ -7,6 +7,7 @@
 #![warn(missing_docs)]
 
 mod affine3;
+mod angle;
 mod aspect_ratio;
 pub mod cubic_splines;
 pub mod primitives;
@@ -14,6 +15,7 @@ mod ray;
 mod rects;
 
 pub use affine3::*;
+pub use angle::{Angle, Degrees, Radians};
 pub use aspect_ratio::AspectRatio;
 pub use ray::{Ray2d, Ray3d};
 pub use rects::*;
@@ -22,6 +24,7 @@ pub use rects::*;
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
+        angle::{Angle, Degrees, Radians},
         cubic_splines::{
             CubicBSpline, CubicBezier, CubicCardinalSpline, CubicGenerator, CubicHermite,
             CubicSegment,
diff --git a/crates/bevy_pbr/src/light.rs b/crates/bevy_pbr/src/light.rs
index c67d0cfe578cd..00a36c283282f 100644
--- a/crates/bevy_pbr/src/light.rs
+++ b/crates/bevy_pbr/src/light.rs
@@ -2,7 +2,8 @@ use std::collections::HashSet;
 
 use bevy_ecs::prelude::*;
 use bevy_math::{
-    AspectRatio, Mat4, UVec2, UVec3, Vec2, Vec3, Vec3A, Vec3Swizzles, Vec4, Vec4Swizzles,
+    Angle, AspectRatio, Mat4, Radians, UVec2, UVec3, Vec2, Vec3, Vec3A, Vec3Swizzles, Vec4,
+    Vec4Swizzles,
 };
 use bevy_reflect::prelude::*;
 use bevy_render::{
@@ -102,6 +103,7 @@ pub struct SpotLight {
     /// shadow map's texel size so that it can be small close to the camera and gets larger further
     /// away.
     pub shadow_normal_bias: f32,
+    // TODO: Replace these with `Radians` once it implements `Reflect`
     /// Angle defining the distance from the spot light direction to the outer limit
     /// of the light's cone of effect.
     /// `outer_angle` should be < `PI / 2.0`.
@@ -1155,7 +1157,7 @@ pub(crate) struct PointLightAssignmentData {
     transform: GlobalTransform,
     range: f32,
     shadows_enabled: bool,
-    spot_light_angle: Option<f32>,
+    spot_light_angle: Option<Radians>,
     render_layers: RenderLayers,
 }
 
@@ -1254,7 +1256,7 @@ pub(crate) fn assign_lights_to_clusters(
                         transform: *transform,
                         shadows_enabled: spot_light.shadows_enabled,
                         range: spot_light.range,
-                        spot_light_angle: Some(spot_light.outer_angle),
+                        spot_light_angle: Some(Radians(spot_light.outer_angle)),
                         render_layers: maybe_layers.copied().unwrap_or_default(),
                     }
                 },
@@ -1950,7 +1952,7 @@ pub fn update_spot_light_frusta(
         let view_backward = transform.back();
 
         let spot_view = spot_light_view_matrix(transform);
-        let spot_projection = spot_light_projection_matrix(spot_light.outer_angle);
+        let spot_projection = spot_light_projection_matrix(Radians(spot_light.outer_angle));
         let view_projection = spot_projection * spot_view.inverse();
 
         *frustum = Frustum::from_view_projection_custom_far(
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
index 9b9b635ab0f83..901688cfd6bb4 100644
--- a/crates/bevy_pbr/src/render/light.rs
+++ b/crates/bevy_pbr/src/render/light.rs
@@ -1,6 +1,6 @@
 use bevy_core_pipeline::core_3d::{Transparent3d, CORE_3D_DEPTH_FORMAT};
 use bevy_ecs::prelude::*;
-use bevy_math::{Mat4, UVec3, UVec4, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
+use bevy_math::{Angle, Mat4, Radians, UVec3, UVec4, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
 use bevy_render::{
     camera::Camera,
     color::Color,
@@ -35,7 +35,7 @@ pub struct ExtractedPointLight {
     shadows_enabled: bool,
     shadow_depth_bias: f32,
     shadow_normal_bias: f32,
-    spot_light_angles: Option<(f32, f32)>,
+    spot_light_angles: Option<(Radians, Radians)>,
 }
 
 #[derive(Component, Debug)]
@@ -415,7 +415,10 @@ pub fn extract_lights(
                         shadow_normal_bias: spot_light.shadow_normal_bias
                             * texel_size
                             * std::f32::consts::SQRT_2,
-                        spot_light_angles: Some((spot_light.inner_angle, spot_light.outer_angle)),
+                        spot_light_angles: Some((
+                            Radians(spot_light.inner_angle),
+                            Radians(spot_light.outer_angle),
+                        )),
                     },
                     render_visible_entities,
                 ),
@@ -635,9 +638,9 @@ pub(crate) fn spot_light_view_matrix(transform: &GlobalTransform) -> Mat4 {
     )
 }
 
-pub(crate) fn spot_light_projection_matrix(angle: f32) -> Mat4 {
+pub(crate) fn spot_light_projection_matrix(angle: Radians) -> Mat4 {
     // spot light projection FOV is 2x the angle from spot light center to outer edge
-    Mat4::perspective_infinite_reverse_rh(angle * 2.0, 1.0, POINT_LIGHT_NEAR_Z)
+    Mat4::perspective_infinite_reverse_rh(angle.0 * 2.0, 1.0, POINT_LIGHT_NEAR_Z)
 }
 
 #[allow(clippy::too_many_arguments)]
diff --git a/crates/bevy_transform/src/components/transform.rs b/crates/bevy_transform/src/components/transform.rs
index 316ee97719d7e..42ff19f60eea0 100644
--- a/crates/bevy_transform/src/components/transform.rs
+++ b/crates/bevy_transform/src/components/transform.rs
@@ -1,5 +1,6 @@
 use super::GlobalTransform;
 use bevy_ecs::{component::Component, reflect::ReflectComponent};
+use bevy_math::Radians;
 use bevy_math::{Affine3A, Mat3, Mat4, Quat, Vec3};
 use bevy_reflect::prelude::*;
 use bevy_reflect::Reflect;
@@ -251,36 +252,36 @@ impl Transform {
         self.rotation = rotation * self.rotation;
     }
 
-    /// Rotates this [`Transform`] around the given `axis` by `angle` (in radians).
+    /// Rotates this [`Transform`] around the given `axis` by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the `axis` is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_axis(&mut self, axis: Vec3, angle: f32) {
-        self.rotate(Quat::from_axis_angle(axis, angle));
+    pub fn rotate_axis(&mut self, axis: Vec3, angle: impl Into<Radians>) {
+        self.rotate(Quat::from_axis_angle(axis, angle.into().0));
     }
 
-    /// Rotates this [`Transform`] around the `X` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around the `X` axis by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_x(&mut self, angle: f32) {
-        self.rotate(Quat::from_rotation_x(angle));
+    pub fn rotate_x(&mut self, angle: impl Into<Radians>) {
+        self.rotate(Quat::from_rotation_x(angle.into().0));
     }
 
-    /// Rotates this [`Transform`] around the `Y` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around the `Y` axis by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_y(&mut self, angle: f32) {
-        self.rotate(Quat::from_rotation_y(angle));
+    pub fn rotate_y(&mut self, angle: impl Into<Radians>) {
+        self.rotate(Quat::from_rotation_y(angle.into().0));
     }
 
-    /// Rotates this [`Transform`] around the `Z` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around the `Z` axis by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_z(&mut self, angle: f32) {
-        self.rotate(Quat::from_rotation_z(angle));
+    pub fn rotate_z(&mut self, angle: impl Into<Radians>) {
+        self.rotate(Quat::from_rotation_z(angle.into().0));
     }
 
     /// Rotates this [`Transform`] by the given `rotation`.
@@ -291,28 +292,28 @@ impl Transform {
         self.rotation *= rotation;
     }
 
-    /// Rotates this [`Transform`] around its local `axis` by `angle` (in radians).
+    /// Rotates this [`Transform`] around its local `axis` by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_axis(&mut self, axis: Vec3, angle: f32) {
-        self.rotate_local(Quat::from_axis_angle(axis, angle));
+    pub fn rotate_local_axis(&mut self, axis: Vec3, angle: impl Into<Radians>) {
+        self.rotate_local(Quat::from_axis_angle(axis, angle.into().0));
     }
 
-    /// Rotates this [`Transform`] around its local `X` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around its local `X` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_x(&mut self, angle: f32) {
-        self.rotate_local(Quat::from_rotation_x(angle));
+    pub fn rotate_local_x(&mut self, angle: impl Into<Radians>) {
+        self.rotate_local(Quat::from_rotation_x(angle.into().0));
     }
 
-    /// Rotates this [`Transform`] around its local `Y` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around its local `Y` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_y(&mut self, angle: f32) {
-        self.rotate_local(Quat::from_rotation_y(angle));
+    pub fn rotate_local_y(&mut self, angle: impl Into<Radians>) {
+        self.rotate_local(Quat::from_rotation_y(angle.into().0));
     }
 
-    /// Rotates this [`Transform`] around its local `Z` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around its local `Z` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_z(&mut self, angle: f32) {
-        self.rotate_local(Quat::from_rotation_z(angle));
+    pub fn rotate_local_z(&mut self, angle: impl Into<Radians>) {
+        self.rotate_local(Quat::from_rotation_z(angle.into().0));
     }
 
     /// Translates this [`Transform`] around a `point` in space.
diff --git a/examples/2d/2d_gizmos.rs b/examples/2d/2d_gizmos.rs
index d3dcd7c960f6a..d5eccfc487f24 100644
--- a/examples/2d/2d_gizmos.rs
+++ b/examples/2d/2d_gizmos.rs
@@ -52,7 +52,13 @@ fn system(mut gizmos: Gizmos, time: Res<Time>) {
 
     // Arcs default amount of segments is linearly interpolated between
     // 1 and 32, using the arc length as scalar.
-    gizmos.arc_2d(Vec2::ZERO, sin / 10., PI / 2., 350., Color::ORANGE_RED);
+    gizmos.arc_2d(
+        Vec2::ZERO,
+        Radians(sin / 10.),
+        Radians::FRAC_PI_2,
+        350.,
+        Color::ORANGE_RED,
+    );
 
     gizmos.arrow_2d(
         Vec2::ZERO,
diff --git a/examples/2d/pixel_grid_snap.rs b/examples/2d/pixel_grid_snap.rs
index 15e573299380a..d675a19b4c28f 100644
--- a/examples/2d/pixel_grid_snap.rs
+++ b/examples/2d/pixel_grid_snap.rs
@@ -156,7 +156,7 @@ fn setup_camera(mut commands: Commands, mut images: ResMut<Assets<Image>>) {
 fn rotate(time: Res<Time>, mut transforms: Query<&mut Transform, With<Rotate>>) {
     for mut transform in &mut transforms {
         let dt = time.delta_seconds();
-        transform.rotate_z(dt);
+        transform.rotate_z(Radians(dt));
     }
 }
 
diff --git a/examples/2d/rotation.rs b/examples/2d/rotation.rs
index 75e80548c7c75..31db43c98d6e1 100644
--- a/examples/2d/rotation.rs
+++ b/examples/2d/rotation.rs
@@ -138,7 +138,9 @@ fn player_movement_system(
     }
 
     // update the ship rotation around the Z axis (perpendicular to the 2D plane of the screen)
-    transform.rotate_z(rotation_factor * ship.rotation_speed * time.delta_seconds());
+    transform.rotate_z(Radians(
+        rotation_factor * ship.rotation_speed * time.delta_seconds(),
+    ));
 
     // get the ship's forward vector by applying the current rotation to the ships initial facing
     // vector
@@ -242,11 +244,11 @@ fn rotate_to_player_system(
 
         // limit rotation so we don't overshoot the target. We need to convert our dot product to
         // an angle here so we can get an angle of rotation to clamp against.
-        let max_angle = forward_dot_player.clamp(-1.0, 1.0).acos(); // clamp acos for safety
+        let max_angle = Radians(forward_dot_player.clamp(-1.0, 1.0).acos());
 
         // calculate angle of rotation with limit
         let rotation_angle =
-            rotation_sign * (config.rotation_speed * time.delta_seconds()).min(max_angle);
+            Radians(rotation_sign * (config.rotation_speed * time.delta_seconds())).min(max_angle);
 
         // rotate the enemy to face the player
         enemy_transform.rotate_z(rotation_angle);
diff --git a/examples/3d/3d_shapes.rs b/examples/3d/3d_shapes.rs
index 999d11a74c878..160541ddfe13e 100644
--- a/examples/3d/3d_shapes.rs
+++ b/examples/3d/3d_shapes.rs
@@ -88,7 +88,7 @@ fn setup(
 
 fn rotate(mut query: Query<&mut Transform, With<Shape>>, time: Res<Time>) {
     for mut transform in &mut query {
-        transform.rotate_y(time.delta_seconds() / 2.);
+        transform.rotate_y(Radians(time.delta_seconds() / 2.));
     }
 }
 
diff --git a/examples/3d/deferred_rendering.rs b/examples/3d/deferred_rendering.rs
index 6b5dbbe466715..aec9a86d2c678 100644
--- a/examples/3d/deferred_rendering.rs
+++ b/examples/3d/deferred_rendering.rs
@@ -240,7 +240,7 @@ fn animate_light_direction(
         return;
     }
     for mut transform in &mut query {
-        transform.rotate_y(time.delta_seconds() * PI / 5.0);
+        transform.rotate_y(Radians(time.delta_seconds() * PI / 5.0));
     }
 }
 
@@ -282,7 +282,9 @@ fn setup_parallax(
             transform: Transform::from_xyz(0.4, 0.2, -0.8),
             ..default()
         },
-        Spin { speed: 0.3 },
+        Spin {
+            speed: Radians(0.3),
+        },
     ));
 }
 
@@ -309,7 +311,7 @@ fn update_normal(
 
 #[derive(Component)]
 struct Spin {
-    speed: f32,
+    speed: Radians,
 }
 
 fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>, pause: Res<Pause>) {
diff --git a/examples/3d/generate_custom_mesh.rs b/examples/3d/generate_custom_mesh.rs
index aada1df1b7275..a8ded2ed028cc 100644
--- a/examples/3d/generate_custom_mesh.rs
+++ b/examples/3d/generate_custom_mesh.rs
@@ -98,17 +98,17 @@ fn input_handler(
     }
     if keyboard_input.pressed(KeyCode::KeyX) {
         for mut transform in &mut query {
-            transform.rotate_x(time.delta_seconds() / 1.2);
+            transform.rotate_x(Radians(time.delta_seconds() / 1.2));
         }
     }
     if keyboard_input.pressed(KeyCode::KeyY) {
         for mut transform in &mut query {
-            transform.rotate_y(time.delta_seconds() / 1.2);
+            transform.rotate_y(Radians(time.delta_seconds() / 1.2));
         }
     }
     if keyboard_input.pressed(KeyCode::KeyZ) {
         for mut transform in &mut query {
-            transform.rotate_z(time.delta_seconds() / 1.2);
+            transform.rotate_z(Radians(time.delta_seconds() / 1.2));
         }
     }
     if keyboard_input.pressed(KeyCode::KeyR) {
diff --git a/examples/3d/lighting.rs b/examples/3d/lighting.rs
index e82e50145a5d3..25a967aaf23c5 100644
--- a/examples/3d/lighting.rs
+++ b/examples/3d/lighting.rs
@@ -36,7 +36,7 @@ fn setup(
 
     // left wall
     let mut transform = Transform::from_xyz(2.5, 2.5, 0.0);
-    transform.rotate_z(PI / 2.);
+    transform.rotate_z(Radians::FRAC_PI_2);
     commands.spawn(PbrBundle {
         mesh: meshes.add(Mesh::from(shape::Box::new(5.0, 0.15, 5.0))),
         transform,
@@ -49,7 +49,7 @@ fn setup(
     });
     // back (right) wall
     let mut transform = Transform::from_xyz(0.0, 2.5, -2.5);
-    transform.rotate_x(PI / 2.);
+    transform.rotate_x(Radians::FRAC_PI_2);
     commands.spawn(PbrBundle {
         mesh: meshes.add(Mesh::from(shape::Box::new(5.0, 0.15, 5.0))),
         transform,
@@ -63,7 +63,7 @@ fn setup(
 
     // Bevy logo to demonstrate alpha mask shadows
     let mut transform = Transform::from_xyz(-2.2, 0.5, 1.0);
-    transform.rotate_y(PI / 8.);
+    transform.rotate_y(Radians::FRAC_PI_8);
     commands.spawn((
         PbrBundle {
             mesh: meshes.add(Mesh::from(shape::Quad::new(Vec2::new(2.0, 0.5)))),
@@ -256,7 +256,7 @@ fn animate_light_direction(
     mut query: Query<&mut Transform, With<DirectionalLight>>,
 ) {
     for mut transform in &mut query {
-        transform.rotate_y(time.delta_seconds() * 0.5);
+        transform.rotate_y(Radians(time.delta_seconds() * 0.5));
     }
 }
 
diff --git a/examples/3d/parallax_mapping.rs b/examples/3d/parallax_mapping.rs
index dfdca7d2e222c..df002e2bb3156 100644
--- a/examples/3d/parallax_mapping.rs
+++ b/examples/3d/parallax_mapping.rs
@@ -27,7 +27,7 @@ fn main() {
 
 #[derive(Component)]
 struct Spin {
-    speed: f32,
+    speed: Radians,
 }
 
 /// The camera, used to move camera on click.
@@ -291,7 +291,9 @@ fn setup(
             material: parallax_material.clone_weak(),
             ..default()
         },
-        Spin { speed: 0.3 },
+        Spin {
+            speed: Radians(0.3),
+        },
     ));
 
     let background_cube = meshes.add(
@@ -308,7 +310,9 @@ fn setup(
                 material: parallax_material.clone(),
                 ..default()
             },
-            Spin { speed: -0.1 },
+            Spin {
+                speed: Radians(-0.1),
+            },
         )
     };
     commands.spawn(background_cube_bundle(Vec3::new(45., 0., 0.)));
diff --git a/examples/3d/parenting.rs b/examples/3d/parenting.rs
index 827d8ffbec782..79359d2da2e07 100644
--- a/examples/3d/parenting.rs
+++ b/examples/3d/parenting.rs
@@ -18,7 +18,7 @@ struct Rotator;
 /// rotates the parent, which will result in the child also rotating
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotator>>) {
     for mut transform in &mut query {
-        transform.rotate_x(3.0 * time.delta_seconds());
+        transform.rotate_x(Radians(3.0 * time.delta_seconds()));
     }
 }
 
diff --git a/examples/3d/render_to_texture.rs b/examples/3d/render_to_texture.rs
index a319e7d6e4e03..39a5a18c173c7 100644
--- a/examples/3d/render_to_texture.rs
+++ b/examples/3d/render_to_texture.rs
@@ -150,15 +150,15 @@ fn setup(
 /// Rotates the inner cube (first pass)
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<FirstPassCube>>) {
     for mut transform in &mut query {
-        transform.rotate_x(1.5 * time.delta_seconds());
-        transform.rotate_z(1.3 * time.delta_seconds());
+        transform.rotate_x(Radians(1.5 * time.delta_seconds()));
+        transform.rotate_z(Radians(1.3 * time.delta_seconds()));
     }
 }
 
 /// Rotates the outer cube (main pass)
 fn cube_rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<MainPassCube>>) {
     for mut transform in &mut query {
-        transform.rotate_x(1.0 * time.delta_seconds());
-        transform.rotate_y(0.7 * time.delta_seconds());
+        transform.rotate_x(Radians(1.0 * time.delta_seconds()));
+        transform.rotate_y(Radians(0.7 * time.delta_seconds()));
     }
 }
diff --git a/examples/3d/skybox.rs b/examples/3d/skybox.rs
index faca13bf1f4f6..3398f484883e5 100644
--- a/examples/3d/skybox.rs
+++ b/examples/3d/skybox.rs
@@ -166,7 +166,7 @@ fn animate_light_direction(
     mut query: Query<&mut Transform, With<DirectionalLight>>,
 ) {
     for mut transform in &mut query {
-        transform.rotate_y(time.delta_seconds() * 0.5);
+        transform.rotate_y(Radians(time.delta_seconds() * 0.5));
     }
 }
 
diff --git a/examples/ecs/hierarchy.rs b/examples/ecs/hierarchy.rs
index f4cb13141c7ab..79fdb744b36a2 100644
--- a/examples/ecs/hierarchy.rs
+++ b/examples/ecs/hierarchy.rs
@@ -66,14 +66,14 @@ fn rotate(
 ) {
     for (parent, children) in &mut parents_query {
         if let Ok(mut transform) = transform_query.get_mut(parent) {
-            transform.rotate_z(-PI / 2. * time.delta_seconds());
+            transform.rotate_z(Radians(-PI / 2. * time.delta_seconds()));
         }
 
         // To iterate through the entities children, just treat the Children component as a Vec
         // Alternatively, you could query entities that have a Parent component
         for child in children {
             if let Ok(mut transform) = transform_query.get_mut(*child) {
-                transform.rotate_z(PI * time.delta_seconds());
+                transform.rotate_z(Radians(PI * time.delta_seconds()));
             }
         }
 
diff --git a/examples/games/alien_cake_addict.rs b/examples/games/alien_cake_addict.rs
index a7f9b46805a70..dd51a0f4aabc7 100644
--- a/examples/games/alien_cake_addict.rs
+++ b/examples/games/alien_cake_addict.rs
@@ -360,7 +360,7 @@ fn spawn_bonus(
 fn rotate_bonus(game: Res<Game>, time: Res<Time>, mut transforms: Query<&mut Transform>) {
     if let Some(entity) = game.bonus.entity {
         if let Ok(mut cake_transform) = transforms.get_mut(entity) {
-            cake_transform.rotate_y(time.delta_seconds());
+            cake_transform.rotate_y(Radians(time.delta_seconds()));
             cake_transform.scale =
                 Vec3::splat(1.0 + (game.score as f32 / 10.0 * time.elapsed_seconds().sin()).abs());
         }
diff --git a/examples/games/contributors.rs b/examples/games/contributors.rs
index 4fd8309a2f8f5..155bd8c328cac 100644
--- a/examples/games/contributors.rs
+++ b/examples/games/contributors.rs
@@ -64,7 +64,7 @@ struct Contributor {
 #[derive(Component)]
 struct Velocity {
     translation: Vec3,
-    rotation: f32,
+    rotation: Radians,
 }
 
 const GRAVITY: f32 = 9.821 * 100.0;
@@ -115,7 +115,7 @@ fn setup_contributor_selection(mut commands: Commands, asset_server: Res<AssetSe
                 Contributor { name, hue },
                 Velocity {
                     translation: velocity,
-                    rotation: -dir * 5.0,
+                    rotation: Radians(-dir * 5.0),
                 },
                 SpriteBundle {
                     sprite: Sprite {
diff --git a/examples/shader/post_processing.rs b/examples/shader/post_processing.rs
index ad684675d806b..96939d99edcc1 100644
--- a/examples/shader/post_processing.rs
+++ b/examples/shader/post_processing.rs
@@ -342,8 +342,8 @@ struct Rotates;
 /// Rotates any entity around the x and y axis
 fn rotate(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
     for mut transform in &mut query {
-        transform.rotate_x(0.55 * time.delta_seconds());
-        transform.rotate_z(0.15 * time.delta_seconds());
+        transform.rotate_x(Radians(0.55 * time.delta_seconds()));
+        transform.rotate_z(Radians(0.15 * time.delta_seconds()));
     }
 }
 
diff --git a/examples/stress_tests/many_cubes.rs b/examples/stress_tests/many_cubes.rs
index 6a1542a025fab..d6886196f69af 100644
--- a/examples/stress_tests/many_cubes.rs
+++ b/examples/stress_tests/many_cubes.rs
@@ -267,12 +267,13 @@ fn move_camera(
     mut camera_query: Query<&mut Transform, With<Camera>>,
 ) {
     let mut camera_transform = camera_query.single_mut();
-    let delta = 0.15
-        * if args.benchmark {
+    let delta = Radians(
+        0.15 * if args.benchmark {
             1.0 / 60.0
         } else {
             time.delta_seconds()
-        };
+        },
+    );
     camera_transform.rotate_z(delta);
     camera_transform.rotate_x(delta);
 }
diff --git a/examples/stress_tests/many_foxes.rs b/examples/stress_tests/many_foxes.rs
index 1c75de1bc95c1..d6f2c6eb77c3a 100644
--- a/examples/stress_tests/many_foxes.rs
+++ b/examples/stress_tests/many_foxes.rs
@@ -147,7 +147,7 @@ fn setup(
 
         let circumference = PI * 2. * radius;
         let foxes_in_ring = ((circumference / FOX_SPACING) as usize).min(foxes_remaining);
-        let fox_spacing_angle = circumference / (foxes_in_ring as f32 * radius);
+        let fox_spacing_angle = Radians(circumference / (foxes_in_ring as f32 * radius));
 
         for fox_i in 0..foxes_in_ring {
             let fox_angle = fox_i as f32 * fox_spacing_angle;
@@ -159,7 +159,7 @@ fn setup(
                     scene: fox_handle.clone(),
                     transform: Transform::from_xyz(x, 0.0, z)
                         .with_scale(Vec3::splat(0.01))
-                        .with_rotation(base_rotation * Quat::from_rotation_y(-fox_angle)),
+                        .with_rotation(base_rotation * Quat::from_rotation_y(-fox_angle.0)),
                     ..default()
                 });
             });
@@ -242,7 +242,7 @@ fn update_fox_rings(
 
     let dt = time.delta_seconds();
     for (ring, rotation_direction, mut transform) in &mut rings {
-        let angular_velocity = foxes.speed / ring.radius;
+        let angular_velocity = Radians(foxes.speed / ring.radius);
         transform.rotate_y(rotation_direction.sign() * angular_velocity * dt);
     }
 }
diff --git a/examples/stress_tests/many_gizmos.rs b/examples/stress_tests/many_gizmos.rs
index 20296f9f91ae4..a2797eb4aef8f 100644
--- a/examples/stress_tests/many_gizmos.rs
+++ b/examples/stress_tests/many_gizmos.rs
@@ -61,7 +61,7 @@ fn system(config: Res<Config>, time: Res<Time>, mut draw: Gizmos) {
         }
     } else {
         for i in 0..(config.line_count / SYSTEM_COUNT) {
-            let angle = i as f32 / (config.line_count / SYSTEM_COUNT) as f32 * TAU;
+            let angle = Radians(i as f32 / (config.line_count / SYSTEM_COUNT) as f32 * TAU);
 
             let vector = Vec2::from(angle.sin_cos()).extend(time.elapsed_seconds().sin());
             let start_color = Color::rgb(vector.x, vector.z, 0.5);
diff --git a/examples/stress_tests/many_lights.rs b/examples/stress_tests/many_lights.rs
index c36a04920c792..024a22c85217c 100644
--- a/examples/stress_tests/many_lights.rs
+++ b/examples/stress_tests/many_lights.rs
@@ -135,7 +135,7 @@ fn spherical_polar_to_cartesian(p: DVec2) -> DVec3 {
 // System for rotating the camera
 fn move_camera(time: Res<Time>, mut camera_query: Query<&mut Transform, With<Camera>>) {
     let mut camera_transform = camera_query.single_mut();
-    let delta = time.delta_seconds() * 0.15;
+    let delta = Radians(time.delta_seconds() * 0.15);
     camera_transform.rotate_z(delta);
     camera_transform.rotate_x(delta);
 }
diff --git a/examples/stress_tests/many_sprites.rs b/examples/stress_tests/many_sprites.rs
index a357fbba057e2..3304ad7cf86d4 100644
--- a/examples/stress_tests/many_sprites.rs
+++ b/examples/stress_tests/many_sprites.rs
@@ -101,7 +101,7 @@ fn setup(mut commands: Commands, assets: Res<AssetServer>, color_tint: Res<Color
 // System for rotating and translating the camera
 fn move_camera(time: Res<Time>, mut camera_query: Query<&mut Transform, With<Camera>>) {
     let mut camera_transform = camera_query.single_mut();
-    camera_transform.rotate_z(time.delta_seconds() * 0.5);
+    camera_transform.rotate_z(Radians(time.delta_seconds() * 0.5));
     *camera_transform = *camera_transform
         * Transform::from_translation(Vec3::X * CAMERA_SPEED * time.delta_seconds());
 }
diff --git a/examples/stress_tests/transform_hierarchy.rs b/examples/stress_tests/transform_hierarchy.rs
index 3e6064971e79a..71b15db5a1550 100644
--- a/examples/stress_tests/transform_hierarchy.rs
+++ b/examples/stress_tests/transform_hierarchy.rs
@@ -247,12 +247,12 @@ struct UpdateValue(f32);
 fn update(time: Res<Time>, mut query: Query<(&mut Transform, &mut UpdateValue)>) {
     for (mut t, mut u) in &mut query {
         u.0 += time.delta_seconds() * 0.1;
-        set_translation(&mut t.translation, u.0);
+        set_translation(&mut t.translation, Radians(u.0));
     }
 }
 
 /// set translation based on the angle `a`
-fn set_translation(translation: &mut Vec3, a: f32) {
+fn set_translation(translation: &mut Vec3, a: Radians) {
     translation.x = a.cos() * 32.0;
     translation.y = a.sin() * 32.0;
 }
@@ -409,7 +409,7 @@ fn spawn_tree(
                 let mut translation = Vec3::ZERO;
                 // use the same placement fn as the `update` system
                 // this way the entities won't be all at (0, 0, 0) when they don't have an `Update` component
-                set_translation(&mut translation, sep);
+                set_translation(&mut translation, Radians(sep));
                 Transform::from_translation(translation)
             };
 
diff --git a/examples/tools/gamepad_viewer.rs b/examples/tools/gamepad_viewer.rs
index 29ef2c5af2386..d302eee239528 100644
--- a/examples/tools/gamepad_viewer.rs
+++ b/examples/tools/gamepad_viewer.rs
@@ -1,7 +1,5 @@
 //! Shows a visualization of gamepad buttons, sticks, and triggers
 
-use std::f32::consts::PI;
-
 use bevy::{
     input::gamepad::{
         GamepadAxisChangedEvent, GamepadButton, GamepadButtonChangedEvent, GamepadSettings,
@@ -107,8 +105,8 @@ impl GamepadButtonBundle {
         }
     }
 
-    pub fn with_rotation(mut self, angle: f32) -> Self {
-        self.mesh_bundle.transform.rotation = Quat::from_rotation_z(angle);
+    pub fn with_rotation(mut self, angle: impl Into<Radians>) -> Self {
+        self.mesh_bundle.transform.rotation = Quat::from_rotation_z(angle.into().0);
         self
     }
 }
@@ -216,7 +214,7 @@ fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<Butto
                     0.,
                     -BUTTON_CLUSTER_RADIUS,
                 )
-                .with_rotation(PI),
+                .with_rotation(Radians::PI),
             );
             parent.spawn(
                 GamepadButtonBundle::new(
@@ -226,7 +224,7 @@ fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<Butto
                     -BUTTON_CLUSTER_RADIUS,
                     0.,
                 )
-                .with_rotation(PI / 2.),
+                .with_rotation(Radians::FRAC_PI_2),
             );
             parent.spawn(
                 GamepadButtonBundle::new(
@@ -236,7 +234,7 @@ fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<Butto
                     BUTTON_CLUSTER_RADIUS,
                     0.,
                 )
-                .with_rotation(-PI / 2.),
+                .with_rotation(-Radians::FRAC_PI_2),
             );
         });
 
diff --git a/examples/transforms/3d_rotation.rs b/examples/transforms/3d_rotation.rs
index ddedbbae859e9..b4a4e73cb76b8 100644
--- a/examples/transforms/3d_rotation.rs
+++ b/examples/transforms/3d_rotation.rs
@@ -7,7 +7,7 @@ use std::f32::consts::TAU;
 // Define a component to designate a rotation speed to an entity.
 #[derive(Component)]
 struct Rotatable {
-    speed: f32,
+    speed: Radians,
 }
 
 fn main() {
@@ -31,7 +31,9 @@ fn setup(
             transform: Transform::from_translation(Vec3::ZERO),
             ..default()
         },
-        Rotatable { speed: 0.3 },
+        Rotatable {
+            speed: Radians(0.3),
+        },
     ));
 
     // Spawn a camera looking at the entities to show what's happening in this example.
diff --git a/examples/window/low_power.rs b/examples/window/low_power.rs
index 00a211cf0637f..4a4194d9a8886 100644
--- a/examples/window/low_power.rs
+++ b/examples/window/low_power.rs
@@ -117,8 +117,8 @@ pub(crate) mod test_setup {
         mut cube_transform: Query<&mut Transform, With<Rotator>>,
     ) {
         for mut transform in &mut cube_transform {
-            transform.rotate_x(time.delta_seconds());
-            transform.rotate_local_y(time.delta_seconds());
+            transform.rotate_x(Radians(time.delta_seconds()));
+            transform.rotate_local_y(Radians(time.delta_seconds()));
         }
     }