diff --git a/.github/workflows/ci-full-test-suite.yml b/.github/workflows/ci-full-test-suite.yml
index 8d6c70fd..2d70e0fc 100644
--- a/.github/workflows/ci-full-test-suite.yml
+++ b/.github/workflows/ci-full-test-suite.yml
@@ -48,7 +48,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --verbose --no-default-features --features "autoconvert f32 si use_serde"
+          args: --verbose --no-default-features --features "autoconvert f32 si use_serde libm"
 
       - name: Test si with underlying storage types
         uses: actions-rs/cargo@v1
diff --git a/Cargo.toml b/Cargo.toml
index ee755126..772e825d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,6 +42,7 @@ typenum = "1.13"
 
 [dev-dependencies]
 approx = "0.5"
+libm = "0.2"
 quickcheck = "1.0"
 serde_json = "1.0"
 static_assertions = "1.1"
@@ -85,6 +86,8 @@ use_serde = ["serde"]
 rational-support = ["num-rational"]
 bigint-support = ["num-bigint", "num-rational/num-bigint-std"]
 complex-support = ["num-complex"]
+# enable sin/cos for no_std builds, via libm
+libm = [ "num-traits/libm" ]
 
 [[example]]
 name = "base"
diff --git a/src/features.rs b/src/features.rs
index ba4aa4f4..68a08b46 100644
--- a/src/features.rs
+++ b/src/features.rs
@@ -81,19 +81,19 @@ macro_rules! si {
     ($($tt:tt)*) => {};
 }
 
-/// Expands the given block of code when `uom` is compiled with the `std` feature.
+/// Expands the given block of code when `uom` is compiled with either the `std` or the `libm` feature.
 #[doc(hidden)]
 #[macro_export]
-#[cfg(feature = "std")]
-macro_rules! std {
+#[cfg(any(feature = "std", feature = "libm"))]
+macro_rules! std_or_libm {
     ($($tt:tt)*) => { $($tt)* };
 }
 
-/// Does not expand the given block of code when `uom` is compiled without the `std` feature.
+/// Does not expand the given block of code when `uom` is compiled without both the `std` and the `libm` feature.
 #[doc(hidden)]
 #[macro_export]
-#[cfg(not(feature = "std"))]
-macro_rules! std {
+#[cfg(not(any(feature = "std", feature = "libm")))]
+macro_rules! std_or_libm {
     ($($tt:tt)*) => {};
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 6d8edcdd..9a140dbb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -97,6 +97,7 @@
 //!    `uom` with `no_std`. Enabled by default.
 //!  * `use_serde` -- Feature to enable support for serialization and deserialization of quantities
 //!    with the [Serde][serde] crate. Disabled by default.
+//!  * `libm` -- Enable advanced floatingpoint functions (sin, cos, ...) on no_std targets
 //!
 //!    [Serde][serde] support for the `big*` and `rational*` underlying storage types requires
 //!    manually enabling the `serde` feature for the `num-rational` and `num-bigint` crates. To do
@@ -277,9 +278,9 @@ pub mod lib {
 // Conditionally import num sub-crate types based on feature selection.
 #[doc(hidden)]
 pub mod num {
-    #[cfg(feature = "std")]
+    #[cfg(any(feature = "std", feature = "libm"))]
     pub use num_traits::float::Float;
-    #[cfg(not(feature = "std"))]
+    #[cfg(not(any(feature = "std", feature = "libm")))]
     pub use num_traits::float::FloatCore as Float;
 
     pub use num_traits::{pow, FromPrimitive, Num, One, Saturating, Signed, ToPrimitive, Zero};
diff --git a/src/si/angle.rs b/src/si/angle.rs
index 171a7c0d..adf150e2 100644
--- a/src/si/angle.rs
+++ b/src/si/angle.rs
@@ -1,6 +1,6 @@
 //! Angle (dimensionless quantity).
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", feature = "libm"))]
 use super::ratio::Ratio;
 
 quantity! {
@@ -64,7 +64,7 @@ impl Angle<crate::si::SI<f64>, f64> {
 }
 
 /// Implementation of various stdlib trigonometric functions
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", feature = "libm"))]
 impl<U, V> Angle<U, V>
 where
     U: crate::si::Units<V> + ?Sized,
@@ -121,7 +121,7 @@ where
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", feature = "libm"))]
 impl<D, U, V> crate::si::Quantity<D, U, V>
 where
     D: crate::si::Dimension + ?Sized,
@@ -161,7 +161,7 @@ mod tests {
         }
     }
 
-    #[cfg(feature = "std")]
+    #[cfg(any(feature = "std", feature = "libm"))]
     mod trig {
         storage_types! {
             types: Float;
@@ -216,7 +216,12 @@ mod tests {
             quickcheck! {
                 #[allow(trivial_casts)]
                 fn atan2(y: V, x: V) -> bool {
-                    Test::eq(&y.atan2(x),
+                    let desired_value = if cfg!(feature = "libm"){
+                        libm::atan2f(y, x)
+                    } else {
+                        y.atan2(x)
+                    };
+                    Test::eq(&desired_value,
                         &Length::new::<l::meter>(y).atan2(Length::new::<l::meter>(x)).get::<a::radian>())
                 }
             }
diff --git a/src/si/ratio.rs b/src/si/ratio.rs
index bd789871..f4305179 100644
--- a/src/si/ratio.rs
+++ b/src/si/ratio.rs
@@ -1,7 +1,7 @@
 //! Ratio (dimensionless quantity).
 
-#[cfg(feature = "std")]
-use super::angle::{Angle, radian};
+#[cfg(any(feature = "std", feature = "libm"))]
+use super::angle::{radian, Angle};
 
 quantity! {
     /// Ratio (dimensionless quantity).
@@ -33,7 +33,7 @@ quantity! {
 }
 
 /// Implementation of various stdlib functions.
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", feature = "libm"))]
 impl<U, V> Ratio<U, V>
 where
     U: crate::si::Units<V> + ?Sized,
@@ -220,7 +220,7 @@ mod tests {
         }
     }
 
-    #[cfg(feature = "std")]
+    #[cfg(any(feature = "std", feature = "libm"))]
     mod float {
         storage_types! {
             types: Float;
@@ -232,59 +232,129 @@ mod tests {
 
             quickcheck! {
                 fn acos(x: V) -> bool {
-                    Test::eq(&x.acos(), &Ratio::from(x).acos().get::<a::radian>())
+                    let desired_value = if cfg!(feature = "libm") {
+                        libm::acosf(x)
+                    } else {
+                        x.acos()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).acos().get::<a::radian>())
                 }
 
                 fn acosh(x: V) -> bool {
-                    Test::eq(&x.acosh(), &Ratio::from(x).acosh().get::<a::radian>())
+                    let desired_value = if cfg!(feature = "libm") {
+                        libm::acoshf(x)
+                    } else {
+                        x.acosh()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).acosh().get::<a::radian>())
                 }
 
                 fn asin(x: V) -> bool {
-                    Test::eq(&x.asin(), &Ratio::from(x).asin().get::<a::radian>())
+                    let desired_value = if cfg!(feature = "libm") {
+                        libm::asinf(x)
+                    } else {
+                        x.asin()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).asin().get::<a::radian>())
                 }
 
                 fn asinh(x: V) -> bool {
-                    Test::eq(&x.asinh(), &Ratio::from(x).asinh().get::<a::radian>())
+                    let desired_value = if cfg!(feature = "libm") {
+                        libm::asinhf(x)
+                    } else {
+                        x.asinh()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).asinh().get::<a::radian>())
                 }
 
                 fn atan(x: V) -> bool {
-                    Test::eq(&x.atan(), &Ratio::from(x).atan().get::<a::radian>())
+                    let desired_value = if cfg!(feature = "libm") {
+                        libm::atanf(x)
+                    } else {
+                        x.atan()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).atan().get::<a::radian>())
                 }
 
                 fn atanh(x: V) -> bool {
-                    Test::eq(&x.atanh(), &Ratio::from(x).atanh().get::<a::radian>())
+                    let desired_value = if cfg!(feature = "libm") {
+                        libm::atanhf(x)
+                    } else {
+                        x.atanh()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).atanh().get::<a::radian>())
                 }
 
                 fn exp(x: V) -> bool {
-                    Test::eq(&x.exp(), &Ratio::from(x).exp().get::<r::ratio>())
+                    let desired_value = if cfg!(feature = "libm"){
+                        libm::expf(x)
+                    } else {
+                        x.exp()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).exp().get::<r::ratio>())
                 }
 
                 fn exp2(x: V) -> bool {
-                    Test::eq(&x.exp2(), &Ratio::from(x).exp2().get::<r::ratio>())
+                    let desired_value = if cfg!(feature = "libm"){
+                        libm::exp2f(x)
+                    } else {
+                        x.exp2()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).exp2().get::<r::ratio>())
                 }
 
                 fn ln(x: V) -> bool {
-                    Test::eq(&x.ln(), &Ratio::from(x).ln().get::<r::ratio>())
+                    let desired_value = if cfg!(feature = "libm"){
+                        libm::logf(x)
+                    } else {
+                        x.ln()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).ln().get::<r::ratio>())
                 }
 
                 fn log(x: V, y: V) -> bool {
-                    Test::eq(&x.log(y), &Ratio::from(x).log(y).get::<r::ratio>())
+                    let desired_value = if cfg!(feature = "libm"){
+                        libm::logf(x) / libm::logf(y)
+                    } else {
+                        x.log(y)
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).log(y).get::<r::ratio>())
                 }
 
                 fn log2(x: V) -> bool {
-                    Test::eq(&x.log2(), &Ratio::from(x).log2().get::<r::ratio>())
+                    let desired_value = if cfg!(feature = "libm"){
+                        libm::log2f(x)
+                    } else {
+                        x.log2()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).log2().get::<r::ratio>())
                 }
 
                 fn log10(x: V) -> bool {
-                    Test::eq(&x.log10(), &Ratio::from(x).log10().get::<r::ratio>())
+                    let desired_value = if cfg!(feature = "libm"){
+                        libm::log10f(x)
+                    } else {
+                        x.log10()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).log10().get::<r::ratio>())
                 }
 
                 fn exp_m1(x: V) -> bool {
-                    Test::eq(&x.exp_m1(), &Ratio::from(x).exp_m1().get::<r::ratio>())
+                    let desired_value = if cfg!(feature = "libm"){
+                        libm::expm1f(x)
+                    } else {
+                        x.exp_m1()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).exp_m1().get::<r::ratio>())
                 }
 
                 fn ln_1p(x: V) -> bool {
-                    Test::eq(&x.ln_1p(), &Ratio::from(x).ln_1p().get::<r::ratio>())
+                    let desired_value = if cfg!(feature = "libm"){
+                        libm::log1pf(x)
+                    } else {
+                        x.ln_1p()
+                    };
+                    Test::eq(&desired_value, &Ratio::from(x).ln_1p().get::<r::ratio>())
                 }
             }
         }
diff --git a/src/system.rs b/src/system.rs
index a9fb3b70..dca9dfa1 100644
--- a/src/system.rs
+++ b/src/system.rs
@@ -611,7 +611,7 @@ macro_rules! system {
                 self.value.classify()
             }
 
-            std! {
+            std_or_libm! {
             autoconvert! {
             /// Calculates the length of the hypotenuse of a right-angle triangle given the legs.
             #[must_use = "method returns a new number and does not mutate the original value"]
@@ -807,7 +807,7 @@ macro_rules! system {
                         self.value.is_normal()
                     }
 
-                    std! {
+                    std_or_libm! {
                     /// Takes the cubic root of a number.
                     ///
                     #[cfg_attr(all(feature = "si", feature = "f32"), doc = " ```rust")]
diff --git a/src/tests/quantity.rs b/src/tests/quantity.rs
index 00ceced5..4e8190a3 100644
--- a/src/tests/quantity.rs
+++ b/src/tests/quantity.rs
@@ -468,16 +468,21 @@ mod float {
             Test::assert_eq(&3.3.fract(), &m1.fract::<kilogram>().get::<kilogram>());
         }
 
-        #[cfg(feature = "std")]
+        #[cfg(any(feature = "std", feature = "libm"))]
         quickcheck! {
             #[allow(trivial_casts)]
             fn hypot_same(l: V, r: V) -> bool {
-                Test::eq(&l.hypot(r),
+                let desired_value = if cfg!(feature="libm") && ! cfg!(feature="std") {
+                    libm::hypotf(l, r)
+                } else {
+                    l.hypot(r)
+                };
+                Test::eq(&desired_value,
                     &f::Length::new::<meter>(l).hypot(f::Length::new::<meter>(r)).get::<meter>())
             }
         }
 
-        #[cfg(all(feature = "std", feature = "autoconvert"))]
+        #[cfg(all(any(feature = "std", feature = "libm"), feature = "autoconvert"))]
         quickcheck! {
             #[allow(trivial_casts)]
             fn hypot_mixed(l: V, r: V) -> bool {
diff --git a/src/tests/system.rs b/src/tests/system.rs
index 1b5399f5..1e078642 100644
--- a/src/tests/system.rs
+++ b/src/tests/system.rs
@@ -286,7 +286,7 @@ mod float {
                 v.classify() == Length::new::<meter>(*v).classify()
             }
 
-            #[cfg(feature = "std")]
+            #[cfg(any(feature = "std", feature = "libm"))]
             #[allow(trivial_casts)]
             fn cbrt(v: A<V>) -> bool {
                 let l: Quantity<Q<P1, Z0, Z0>, U<V>, V> = Quantity::<Q<P3, Z0, Z0>, U<V>, V> {
@@ -298,10 +298,15 @@ mod float {
                 Test::eq(&v.cbrt(), &l.value)
             }
 
-            #[cfg(feature = "std")]
+            #[cfg(any(feature = "std", feature = "libm"))]
             #[allow(trivial_casts)]
             fn hypot(l: A<V>, r: A<V>) -> bool {
-                Test::eq(&Length::new::<meter>(l.hypot(*r)),
+                let desired_value = if cfg!(feature="libm"){
+                    libm::hypotf(*l, *r)
+                } else {
+                    l.hypot(*r)
+                };
+                Test::eq(&Length::new::<meter>(desired_value),
                     &Length::new::<meter>(*l).hypot(Length::new::<meter>(*r)))
             }
 
@@ -315,7 +320,7 @@ mod float {
                 v.is_sign_negative() == Length::new::<meter>(*v).is_sign_negative()
             }
 
-            #[cfg(feature = "std")]
+            #[cfg(any(feature = "std", feature = "libm"))]
             #[allow(trivial_casts)]
             fn mul_add(s: A<V>, a: A<V>, b: A<V>) -> bool {
                 let r: Quantity<Q<P2, Z0, Z0>, U<V>, V> = Length::new::<meter>(*s).mul_add(
@@ -340,13 +345,13 @@ mod float {
                 Test::eq(&v.recip(), &a.value)
             }
 
-            #[cfg(feature = "std")]
+            #[cfg(any(feature = "std", feature = "libm"))]
             #[allow(trivial_casts)]
             fn powi(v: A<V>) -> bool {
                 Test::eq(&v.powi(3), &Length::new::<meter>(*v).powi(P3::new()).value)
             }
 
-            #[cfg(feature = "std")]
+            #[cfg(any(feature = "std", feature = "libm"))]
             #[allow(trivial_casts)]
             fn sqrt(v: A<V>) -> TestResult {
                 if *v < V::zero() {
@@ -647,7 +652,7 @@ mod complex {
                 v.is_normal() == Length::new::<meter>(*v).is_normal()
             }
 
-            #[cfg(feature = "std")]
+            #[cfg(any(feature = "std", feature = "libm"))]
             #[allow(trivial_casts)]
             fn cbrt(v: A<V>) -> bool {
                 let l: Quantity<Q<P1, Z0, Z0>, U<V>, V> = Quantity::<Q<P3, Z0, Z0>, U<V>, V> {
@@ -659,7 +664,7 @@ mod complex {
                 Test::eq(&v.cbrt(), &l.value)
             }
 
-            #[cfg(feature = "std")]
+            #[cfg(any(feature = "std", feature = "libm"))]
             #[allow(trivial_casts)]
             fn mul_add(s: A<V>, a: A<V>, b: A<V>) -> bool {
                 #[allow(unused_imports)]