diff --git a/pw_assert/assert_backend_compile_test.cc b/pw_assert/assert_backend_compile_test.cc
index 372810b..da19e34 100644
--- a/pw_assert/assert_backend_compile_test.cc
+++ b/pw_assert/assert_backend_compile_test.cc
@@ -134,13 +134,14 @@
   float x_float = 50.5;
   float y_float = 66.5;
 
-  PW_CHECK_FLOAT_LE(x_float, y_float);
-  PW_CHECK_FLOAT_LE(x_float, y_float, "FLOAT: " FAIL_IF_DISPLAYED);
-  PW_CHECK_FLOAT_LE(x_float, y_float, "FLOAT: " FAIL_IF_DISPLAYED_ARGS, z);
+  PW_CHECK_FLOAT_EXACT_LE(x_float, y_float);
+  PW_CHECK_FLOAT_EXACT_LE(x_float, y_float, "FLOAT: " FAIL_IF_DISPLAYED);
+  PW_CHECK_FLOAT_EXACT_LE(
+      x_float, y_float, "FLOAT: " FAIL_IF_DISPLAYED_ARGS, z);
 
-  PW_CHECK_FLOAT_GE(x_float, y_float);
-  PW_CHECK_FLOAT_GE(x_float, y_float, "FLOAT: " FAIL_IF_HIDDEN);
-  PW_CHECK_FLOAT_GE(x_float, y_float, "FLOAT: " FAIL_IF_HIDDEN_ARGS, z);
+  PW_CHECK_FLOAT_EXACT_GE(x_float, y_float);
+  PW_CHECK_FLOAT_EXACT_GE(x_float, y_float, "FLOAT: " FAIL_IF_HIDDEN);
+  PW_CHECK_FLOAT_EXACT_GE(x_float, y_float, "FLOAT: " FAIL_IF_HIDDEN_ARGS, z);
 }
 
 // Don't exhaustively test the DCHECKs but have a sampling of them.
@@ -150,7 +151,7 @@
   PW_DCHECK(5 == 10, "Message");
   PW_DCHECK(5 == 10, "Message: %d", 5);
   PW_DCHECK_INT_LE(5.4, 10.0);
-  PW_DCHECK_FLOAT_EQ(5.4, 10.0, "Message");
+  PW_DCHECK_FLOAT_EXACT_EQ(5.4, 10.0, "Message");
 }
 
 static int Add3(int a, int b, int c) { return a + b + c; }
diff --git a/pw_assert/assert_backend_compile_test_c.c b/pw_assert/assert_backend_compile_test_c.c
index fb81a94..cecc756 100644
--- a/pw_assert/assert_backend_compile_test_c.c
+++ b/pw_assert/assert_backend_compile_test_c.c
@@ -122,13 +122,14 @@
     float x_float = 50.5;
     float y_float = 66.5;
 
-    PW_CHECK_FLOAT_LE(x_float, y_float);
-    PW_CHECK_FLOAT_LE(x_float, y_float, "FLOAT: " FAIL_IF_DISPLAYED);
-    PW_CHECK_FLOAT_LE(x_float, y_float, "FLOAT: " FAIL_IF_DISPLAYED_ARGS, z);
+    PW_CHECK_FLOAT_EXACT_LE(x_float, y_float);
+    PW_CHECK_FLOAT_EXACT_LE(x_float, y_float, "FLOAT: " FAIL_IF_DISPLAYED);
+    PW_CHECK_FLOAT_EXACT_LE(
+        x_float, y_float, "FLOAT: " FAIL_IF_DISPLAYED_ARGS, z);
 
-    PW_CHECK_FLOAT_GE(x_float, y_float);
-    PW_CHECK_FLOAT_GE(x_float, y_float, "FLOAT: " FAIL_IF_HIDDEN);
-    PW_CHECK_FLOAT_GE(x_float, y_float, "FLOAT: " FAIL_IF_HIDDEN_ARGS, z);
+    PW_CHECK_FLOAT_EXACT_GE(x_float, y_float);
+    PW_CHECK_FLOAT_EXACT_GE(x_float, y_float, "FLOAT: " FAIL_IF_HIDDEN);
+    PW_CHECK_FLOAT_EXACT_GE(x_float, y_float, "FLOAT: " FAIL_IF_HIDDEN_ARGS, z);
   }
 
   // Don't exhaustively test the DCHECKs but have a sampling of them.
@@ -138,7 +139,7 @@
     PW_DCHECK(5 == 10, "Message");
     PW_DCHECK(5 == 10, "Message: %d", 5);
     PW_DCHECK_INT_LE(5.4, 10.0);
-    PW_DCHECK_FLOAT_EQ(5.4, 10.0, "Message");
+    PW_DCHECK_FLOAT_EXACT_EQ(5.4, 10.0, "Message");
   }
 
   {  // TEST(Check, ComparisonArgumentsWithCommas)
diff --git a/pw_assert/assert_facade_test.cc b/pw_assert/assert_facade_test.cc
index a234562..fc48268 100644
--- a/pw_assert/assert_facade_test.cc
+++ b/pw_assert/assert_facade_test.cc
@@ -228,56 +228,99 @@
 TEST_F(AssertFail, PtrNotNull) { PW_CHECK_NOTNULL(0x0); }
 
 // PW_CHECK_FLOAT_*(...)
-// Binary checks with floats, comparisons: <, <=, =, !=, >, >=.
+// Binary checks with floats, comparisons: EXACT_LT, EXACT_LE, NEAR, EXACT_EQ,
+// EXACT_NE, EXACT_GE, EXACT_GT.
 
 // Test message formatting separate from the triggering.
 // Only test formatting for the type once.
 TEST_F(AssertFail, FloatLessThanNoMessageNoArguments) {
-  PW_CHECK_FLOAT_LT(5.2, 2.3);
+  PW_CHECK_FLOAT_EXACT_LT(5.2, 2.3);
   EXPECT_MESSAGE("Check failed: 5.2 (=5.200000) < 2.3 (=2.300000). ");
 }
 TEST_F(AssertFail, FloatLessThanMessageNoArguments) {
-  PW_CHECK_FLOAT_LT(5.2, 2.3, "msg");
+  PW_CHECK_FLOAT_EXACT_LT(5.2, 2.3, "msg");
   EXPECT_MESSAGE("Check failed: 5.2 (=5.200000) < 2.3 (=2.300000). msg");
 }
 TEST_F(AssertFail, FloatLessThanMessageArguments) {
-  PW_CHECK_FLOAT_LT(5.2, 2.3, "msg: %d", 6);
+  PW_CHECK_FLOAT_EXACT_LT(5.2, 2.3, "msg: %d", 6);
   EXPECT_MESSAGE("Check failed: 5.2 (=5.200000) < 2.3 (=2.300000). msg: 6");
 }
-
+// Check float NEAR both above and below the permitted range.
+TEST_F(AssertFail, FloatNearAboveNoMessageNoArguments) {
+  PW_CHECK_FLOAT_NEAR(5.2, 2.3, 0.1);
+  EXPECT_MESSAGE(
+      "Check failed: 5.2 (=5.200000) <= 2.3 + abs_tolerance (=2.400000). ");
+}
+TEST_F(AssertFail, FloatNearAboveMessageNoArguments) {
+  PW_CHECK_FLOAT_NEAR(5.2, 2.3, 0.1, "msg");
+  EXPECT_MESSAGE(
+      "Check failed: 5.2 (=5.200000) <= 2.3 + abs_tolerance (=2.400000). msg");
+}
+TEST_F(AssertFail, FloatNearAboveMessageArguments) {
+  PW_CHECK_FLOAT_NEAR(5.2, 2.3, 0.1, "msg: %d", 6);
+  EXPECT_MESSAGE(
+      "Check failed: 5.2 (=5.200000) <= 2.3 + abs_tolerance (=2.400000). msg: "
+      "6");
+}
+TEST_F(AssertFail, FloatNearBelowNoMessageNoArguments) {
+  PW_CHECK_FLOAT_NEAR(1.2, 2.3, 0.1);
+  EXPECT_MESSAGE(
+      "Check failed: 1.2 (=1.200000) >= 2.3 - abs_tolerance (=2.200000). ");
+}
+TEST_F(AssertFail, FloatNearBelowMessageNoArguments) {
+  PW_CHECK_FLOAT_NEAR(1.2, 2.3, 0.1, "msg");
+  EXPECT_MESSAGE(
+      "Check failed: 1.2 (=1.200000) >= 2.3 - abs_tolerance (=2.200000). msg");
+}
+TEST_F(AssertFail, FloatNearBelowMessageArguments) {
+  PW_CHECK_FLOAT_NEAR(1.2, 2.3, 0.1, "msg: %d", 6);
+  EXPECT_MESSAGE(
+      "Check failed: 1.2 (=1.200000) >= 2.3 - abs_tolerance (=2.200000). msg: "
+      "6");
+}
 // Test comparison boundaries.
 // Note: The below example numbers all round to integer 1, to detect accidental
 // integer conversions in the asserts.
 
 // FLOAT <
-TEST_F(AssertPass, FloatLt1) { PW_CHECK_FLOAT_LT(1.1, 1.2); }
-TEST_F(AssertFail, FloatLt2) { PW_CHECK_FLOAT_LT(1.2, 1.2); }
-TEST_F(AssertFail, FloatLt3) { PW_CHECK_FLOAT_LT(1.2, 1.1); }
+TEST_F(AssertPass, FloatLt1) { PW_CHECK_FLOAT_EXACT_LT(1.1, 1.2); }
+TEST_F(AssertFail, FloatLt2) { PW_CHECK_FLOAT_EXACT_LT(1.2, 1.2); }
+TEST_F(AssertFail, FloatLt3) { PW_CHECK_FLOAT_EXACT_LT(1.2, 1.1); }
 
 // FLOAT <=
-TEST_F(AssertPass, FloatLe1) { PW_CHECK_FLOAT_LE(1.1, 1.2); }
-TEST_F(AssertPass, FloatLe2) { PW_CHECK_FLOAT_LE(1.2, 1.2); }
-TEST_F(AssertFail, FloatLe3) { PW_CHECK_FLOAT_LE(1.2, 1.1); }
+TEST_F(AssertPass, FloatLe1) { PW_CHECK_FLOAT_EXACT_LE(1.1, 1.2); }
+TEST_F(AssertPass, FloatLe2) { PW_CHECK_FLOAT_EXACT_LE(1.2, 1.2); }
+TEST_F(AssertFail, FloatLe3) { PW_CHECK_FLOAT_EXACT_LE(1.2, 1.1); }
+
+// FLOAT ~= based on absolute error.
+TEST_F(AssertFail, FloatNearAbs1) { PW_CHECK_FLOAT_NEAR(1.09, 1.2, 0.1); }
+TEST_F(AssertPass, FloatNearAbs2) { PW_CHECK_FLOAT_NEAR(1.1, 1.2, 0.1); }
+TEST_F(AssertPass, FloatNearAbs3) { PW_CHECK_FLOAT_NEAR(1.2, 1.2, 0.1); }
+TEST_F(AssertPass, FloatNearAbs4) { PW_CHECK_FLOAT_NEAR(1.2, 1.1, 0.1); }
+TEST_F(AssertFail, FloatNearAbs5) { PW_CHECK_FLOAT_NEAR(1.21, 1.1, 0.1); }
+// Make sure the abs_tolerance is asserted to be >= 0.
+TEST_F(AssertFail, FloatNearAbs6) { PW_CHECK_FLOAT_NEAR(1.2, 1.2, -0.1); }
+TEST_F(AssertPass, FloatNearAbs7) { PW_CHECK_FLOAT_NEAR(1.2, 1.2, 0.0); }
 
 // FLOAT ==
-TEST_F(AssertFail, FloatEq1) { PW_CHECK_FLOAT_EQ(1.1, 1.2); }
-TEST_F(AssertPass, FloatEq2) { PW_CHECK_FLOAT_EQ(1.2, 1.2); }
-TEST_F(AssertFail, FloatEq3) { PW_CHECK_FLOAT_EQ(1.2, 1.1); }
+TEST_F(AssertFail, FloatEq1) { PW_CHECK_FLOAT_EXACT_EQ(1.1, 1.2); }
+TEST_F(AssertPass, FloatEq2) { PW_CHECK_FLOAT_EXACT_EQ(1.2, 1.2); }
+TEST_F(AssertFail, FloatEq3) { PW_CHECK_FLOAT_EXACT_EQ(1.2, 1.1); }
 
 // FLOAT !=
-TEST_F(AssertPass, FloatNe1) { PW_CHECK_FLOAT_NE(1.1, 1.2); }
-TEST_F(AssertFail, FloatNe2) { PW_CHECK_FLOAT_NE(1.2, 1.2); }
-TEST_F(AssertPass, FloatNe3) { PW_CHECK_FLOAT_NE(1.2, 1.1); }
+TEST_F(AssertPass, FloatNe1) { PW_CHECK_FLOAT_EXACT_NE(1.1, 1.2); }
+TEST_F(AssertFail, FloatNe2) { PW_CHECK_FLOAT_EXACT_NE(1.2, 1.2); }
+TEST_F(AssertPass, FloatNe3) { PW_CHECK_FLOAT_EXACT_NE(1.2, 1.1); }
 
 // FLOAT >
-TEST_F(AssertFail, FloatGt1) { PW_CHECK_FLOAT_GT(1.1, 1.2); }
-TEST_F(AssertFail, FloatGt2) { PW_CHECK_FLOAT_GT(1.2, 1.2); }
-TEST_F(AssertPass, FloatGt3) { PW_CHECK_FLOAT_GT(1.2, 1.1); }
+TEST_F(AssertFail, FloatGt1) { PW_CHECK_FLOAT_EXACT_GT(1.1, 1.2); }
+TEST_F(AssertFail, FloatGt2) { PW_CHECK_FLOAT_EXACT_GT(1.2, 1.2); }
+TEST_F(AssertPass, FloatGt3) { PW_CHECK_FLOAT_EXACT_GT(1.2, 1.1); }
 
 // FLOAT >=
-TEST_F(AssertFail, FloatGe1) { PW_CHECK_FLOAT_GE(1.1, 1.2); }
-TEST_F(AssertPass, FloatGe2) { PW_CHECK_FLOAT_GE(1.2, 1.2); }
-TEST_F(AssertPass, FloatGe3) { PW_CHECK_FLOAT_GE(1.2, 1.1); }
+TEST_F(AssertFail, FloatGe1) { PW_CHECK_FLOAT_EXACT_GE(1.1, 1.2); }
+TEST_F(AssertPass, FloatGe2) { PW_CHECK_FLOAT_EXACT_GE(1.2, 1.2); }
+TEST_F(AssertPass, FloatGe3) { PW_CHECK_FLOAT_EXACT_GE(1.2, 1.1); }
 
 // Nested comma handling.
 static int Add3(int a, int b, int c) { return a + b + c; }
diff --git a/pw_assert/docs.rst b/pw_assert/docs.rst
index b3c6452..eb061b8 100644
--- a/pw_assert/docs.rst
+++ b/pw_assert/docs.rst
@@ -111,8 +111,8 @@
 Why isn't there a ``PW_CHECK_LE``? Why is the type (e.g. ``INT``) needed?
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 The problem with asserts like ``PW_CHECK_LE(a, b)`` instead of
-``PW_CHECK_INT_LE(a, b)`` or ``PW_CHECK_FLOAT_LE(a, b)`` is that to capture the
-arguments with the tokenizer, we need to know the types. Using the
+``PW_CHECK_INT_LE(a, b)`` or ``PW_CHECK_FLOAT_EXACT_LE(a, b)`` is that to
+capture the arguments with the tokenizer, we need to know the types. Using the
 preprocessor, it is impossible to dispatch based on the types of ``a`` and
 ``b``, so unfortunately having a separate macro for each of the types commonly
 asserted on is necessary.
@@ -193,7 +193,8 @@
     +------------------------------------+-------------------------------------+
     | ``PW_CHECK(a_ptr <= b_ptr)``       | ``PW_CHECK_PTR_LE(a_ptr, b_ptr)``   |
     +------------------------------------+-------------------------------------+
-    | ``PW_CHECK(Temp() <= 10.0)``       | ``PW_CHECK_FLOAT_LE(Temp(), 10.0)`` |
+    | ``PW_CHECK(Temp() <= 10.0)``       | ``PW_CHECK_FLOAT_EXACT_LE(``        |
+    |                                    | ``    Temp(), 10.0)``               |
     +------------------------------------+-------------------------------------+
     | ``PW_CHECK(Foo() == Status::OK)``  | ``PW_CHECK_OK(Foo())``              |
     +------------------------------------+-------------------------------------+
@@ -242,118 +243,156 @@
 
   .. code-block:: cpp
 
-    PW_CHECK_FLOAT_GE(BatteryVoltage(), 3.2, "System state=%s", SysState());
+    PW_CHECK_FLOAT_EXACT_GE(BatteryVoltage(), 3.2,
+                            "System state=%s", SysState());
 
   Below is the full list of binary comparison assert macros, along with the
   type specifier. The specifier is irrelevant to application authors but is
   needed for backend implementers.
 
-  +-------------------+--------------+-----------+-----------------------+
-  | Macro             | a, b type    | condition | a, b format specifier |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_INT_LE   | int          | a <= b    | %d                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_INT_LT   | int          | a <  b    | %d                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_INT_GE   | int          | a >= b    | %d                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_INT_GT   | int          | a >  b    | %d                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_INT_EQ   | int          | a == b    | %d                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_INT_NE   | int          | a != b    | %d                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_UINT_LE  | unsigned int | a <= b    | %u                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_UINT_LT  | unsigned int | a <  b    | %u                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_UINT_GE  | unsigned int | a >= b    | %u                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_UINT_GT  | unsigned int | a >  b    | %u                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_UINT_EQ  | unsigned int | a == b    | %u                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_UINT_NE  | unsigned int | a != b    | %u                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_PTR_LE   | void*        | a <= b    | %p                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_PTR_LT   | void*        | a <  b    | %p                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_PTR_GE   | void*        | a >= b    | %p                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_PTR_GT   | void*        | a >  b    | %p                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_PTR_EQ   | void*        | a == b    | %p                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_PTR_NE   | void*        | a != b    | %p                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_FLOAT_LE | float        | a <= b    | %f                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_FLOAT_LT | float        | a <  b    | %f                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_FLOAT_GE | float        | a >= b    | %f                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_FLOAT_GT | float        | a >  b    | %f                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_FLOAT_EQ | float        | a == b    | %f                    |
-  +-------------------+--------------+-----------+-----------------------+
-  | PW_CHECK_FLOAT_NE | float        | a != b    | %f                    |
-  +-------------------+--------------+-----------+-----------------------+
+  +-------------------------+--------------+-----------+-----------------------+
+  | Macro                   | a, b type    | condition | a, b format specifier |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_INT_LE         | int          | a <= b    | %d                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_INT_LT         | int          | a <  b    | %d                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_INT_GE         | int          | a >= b    | %d                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_INT_GT         | int          | a >  b    | %d                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_INT_EQ         | int          | a == b    | %d                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_INT_NE         | int          | a != b    | %d                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_UINT_LE        | unsigned int | a <= b    | %u                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_UINT_LT        | unsigned int | a <  b    | %u                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_UINT_GE        | unsigned int | a >= b    | %u                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_UINT_GT        | unsigned int | a >  b    | %u                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_UINT_EQ        | unsigned int | a == b    | %u                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_UINT_NE        | unsigned int | a != b    | %u                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_PTR_LE         | void*        | a <= b    | %p                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_PTR_LT         | void*        | a <  b    | %p                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_PTR_GE         | void*        | a >= b    | %p                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_PTR_GT         | void*        | a >  b    | %p                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_PTR_EQ         | void*        | a == b    | %p                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_PTR_NE         | void*        | a != b    | %p                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_FLOAT_EXACT_LE | float        | a <= b    | %f                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_FLOAT_EXACT_LT | float        | a <  b    | %f                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_FLOAT_EXACT_GE | float        | a >= b    | %f                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_FLOAT_EXACT_GT | float        | a >  b    | %f                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_FLOAT_EXACT_EQ | float        | a == b    | %f                    |
+  +-------------------------+--------------+-----------+-----------------------+
+  | PW_CHECK_FLOAT_EXACT_NE | float        | a != b    | %f                    |
+  +-------------------------+--------------+-----------+-----------------------+
 
   The above ``CHECK_*_*()`` are also available in DCHECK variants, which will
   only evaluate their arguments and trigger if the ``NDEBUG`` macro is defined.
 
-  +--------------------+--------------+-----------+-----------------------+
-  | Macro              | a, b type    | condition | a, b format specifier |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_INT_LE   | int          | a <= b    | %d                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_INT_LT   | int          | a <  b    | %d                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_INT_GE   | int          | a >= b    | %d                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_INT_GT   | int          | a >  b    | %d                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_INT_EQ   | int          | a == b    | %d                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_INT_NE   | int          | a != b    | %d                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_UINT_LE  | unsigned int | a <= b    | %u                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_UINT_LT  | unsigned int | a <  b    | %u                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_UINT_GE  | unsigned int | a >= b    | %u                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_UINT_GT  | unsigned int | a >  b    | %u                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_UINT_EQ  | unsigned int | a == b    | %u                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_UINT_NE  | unsigned int | a != b    | %u                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_PTR_LE   | void*        | a <= b    | %p                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_PTR_LT   | void*        | a <  b    | %p                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_PTR_GE   | void*        | a >= b    | %p                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_PTR_GT   | void*        | a >  b    | %p                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_PTR_EQ   | void*        | a == b    | %p                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_PTR_NE   | void*        | a != b    | %p                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_FLOAT_LE | float        | a <= b    | %f                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_FLOAT_LT | float        | a <  b    | %f                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_FLOAT_GE | float        | a >= b    | %f                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_FLOAT_GT | float        | a >  b    | %f                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_FLOAT_EQ | float        | a == b    | %f                    |
-  +--------------------+--------------+-----------+-----------------------+
-  | PW_DCHECK_FLOAT_NE | float        | a != b    | %f                    |
-  +--------------------+--------------+-----------+-----------------------+
+  +--------------------------+--------------+-----------+----------------------+
+  | Macro                    | a, b type    | condition | a, b format          |
+  |                          |              |           | specifier            |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_INT_LE         | int          | a <= b    | %d                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_INT_LT         | int          | a <  b    | %d                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_INT_GE         | int          | a >= b    | %d                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_INT_GT         | int          | a >  b    | %d                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_INT_EQ         | int          | a == b    | %d                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_INT_NE         | int          | a != b    | %d                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_UINT_LE        | unsigned int | a <= b    | %u                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_UINT_LT        | unsigned int | a <  b    | %u                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_UINT_GE        | unsigned int | a >= b    | %u                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_UINT_GT        | unsigned int | a >  b    | %u                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_UINT_EQ        | unsigned int | a == b    | %u                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_UINT_NE        | unsigned int | a != b    | %u                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_PTR_LE         | void*        | a <= b    | %p                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_PTR_LT         | void*        | a <  b    | %p                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_PTR_GE         | void*        | a >= b    | %p                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_PTR_GT         | void*        | a >  b    | %p                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_PTR_EQ         | void*        | a == b    | %p                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_PTR_NE         | void*        | a != b    | %p                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_FLOAT_EXACT_LE | float        | a <= b    | %f                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_FLOAT_EXACT_LT | float        | a <  b    | %f                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_FLOAT_EXACT_GE | float        | a >= b    | %f                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_FLOAT_EXACT_GT | float        | a >  b    | %f                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_FLOAT_EXACT_EQ | float        | a == b    | %f                   |
+  +--------------------------+--------------+-----------+----------------------+
+  | PW_DCHECK_FLOAT_EXACT_NE | float        | a != b    | %f                   |
+  +--------------------------+--------------+-----------+----------------------+
+
+.. attention::
+
+  For float, proper comparator checks which take floating point
+  precision and ergo error accumulation into account are not provided on
+  purpose as this comes with some complexity and requires application
+  specific tolerances in terms of Units of Least Precision (ULP). Instead,
+  we recommend developers carefully consider how floating point precision and
+  error impact the data they are bounding and whether checks are appropriate.
+
+.. cpp:function:: PW_CHECK_FLOAT_NEAR(a, b, abs_tolerance)
+.. cpp:function:: PW_CHECK_FLOAT_NEAR(a, b, abs_tolerance, format, ...)
+.. cpp:function:: PW_DCHECK_FLOAT_NEAR(a, b, abs_tolerance)
+.. cpp:function:: PW_DCHECK_FLOAT_NEAR(a, b, abs_tolerance, format, ...)
+
+  Asserts that ``(a >= b - abs_tolerance) && (a <= b + abs_tolerance)`` is true,
+  where ``a``, ``b``, and ``abs_tolerance`` are converted to ``float``.
+
+  .. note::
+    This also asserts that ``abs_tolerance >= 0``.
+
+  The ``DCHECK`` variants only run if ``NDEBUG`` is defined; otherwise, the
+  entire statement is removed (and the expression not evaluated).
+
+  Example, with no message:
+
+  .. code-block:: cpp
+
+    PW_CHECK_FLOAT_NEAR(cos(0.0f), 1, 0.001);
+
+  Example, with an included message and arguments:
+
+  .. code-block:: cpp
+
+    PW_CHECK_FLOAT_NEAR(FirstOperation(), RedundantOperation(), 0.1,
+                        "System state=%s", SysState());
 
 .. cpp:function:: PW_CHECK_OK(status)
 .. cpp:function:: PW_CHECK_OK(status, format, ...)
diff --git a/pw_assert/public/pw_assert/assert.h b/pw_assert/public/pw_assert/assert.h
index 43cd8ce..36082c5 100644
--- a/pw_assert/public/pw_assert/assert.h
+++ b/pw_assert/public/pw_assert/assert.h
@@ -26,38 +26,65 @@
 //   Trigger a crash with a message. Replaces LOG_FATAL() in other systems.
 //   PW_CRASH(msg, ...)
 //
+//   In all below cases, the message argument is optional:
+//   PW_CHECK_INT_LE(x, y) or
+//   PW_CHECK_INT_LE(x, y, "Was booting %s subsystem", subsystem_name)
+//
 //   Asserts the condition, crashes on failure. Equivalent to assert.
 //   PW_CHECK(condition) or
 //   PW_CHECK(condition, msg, ...)
 //
+//   Some common typed checks.
+//   PW_CHECK_OK(status, msg, ...)  Asserts status == PW_STATUS_OK
+//   PW_CHECK_NOTNULL(ptr, msg, ...)  Asserts ptr != NULL
+//
 //   In many cases an assert is a binary comparison. In those cases, using the
 //   special binary assert macros below for <, <=, >, >=, == enables reporting
 //   the values of the operands in addition to the string of the condition.
 //
-//   In all cases, the message argument is optional:
-//   PW_CHECK_INT_LE(x, y) or
-//   PW_CHECK_INT_LE(x, y, "Was booting %s subsystem", subsystem_name)
-//
 //   Binary comparison asserts for 'int' type ("%d" in format strings):
-//   PW_CHECK_INT_LE  (a, b, msg, ...)  Asserts a <= b
-//   PW_CHECK_INT_LT  (a, b, msg, ...)  Asserts a <  b
-//   PW_CHECK_INT_GE  (a, b, msg, ...)  Asserts a >= b
-//   PW_CHECK_INT_GT  (a, b, msg, ...)  Asserts a >  b
-//   PW_CHECK_INT_EQ  (a, b, msg, ...)  Asserts a == b
+//   PW_CHECK_INT_LE(a, b, msg, ...)  Asserts a <= b
+//   PW_CHECK_INT_LT(a, b, msg, ...)  Asserts a <  b
+//   PW_CHECK_INT_GE(a, b, msg, ...)  Asserts a >= b
+//   PW_CHECK_INT_GT(a, b, msg, ...)  Asserts a >  b
+//   PW_CHECK_INT_EQ(a, b, msg, ...)  Asserts a == b
+//   PW_CHECK_INT_NE(a, b, msg, ...)  Asserts a != b
 //
 //   Binary comparison asserts for 'unsigned int' type ("%u" in format strings):
-//   PW_CHECK_UINT_LE (a, b, msg, ...)  Asserts a <= b
-//   PW_CHECK_UINT_LT (a, b, msg, ...)  Asserts a <  b
-//   PW_CHECK_UINT_GE (a, b, msg, ...)  Asserts a >= b
-//   PW_CHECK_UINT_GT (a, b, msg, ...)  Asserts a >  b
-//   PW_CHECK_UINT_EQ (a, b, msg, ...)  Asserts a == b
+//   PW_CHECK_UINT_LE(a, b, msg, ...)  Asserts a <= b
+//   PW_CHECK_UINT_LT(a, b, msg, ...)  Asserts a <  b
+//   PW_CHECK_UINT_GE(a, b, msg, ...)  Asserts a >= b
+//   PW_CHECK_UINT_GT(a, b, msg, ...)  Asserts a >  b
+//   PW_CHECK_UINT_EQ(a, b, msg, ...)  Asserts a == b
+//   PW_CHECK_UINT_NE(a, b, msg, ...)  Asserts a != b
+//
+//   Binary comparison asserts for 'void*' type ("%p" in format strings):
+//   PW_CHECK_PTR_LE(a, b, msg, ...)  Asserts a <= b
+//   PW_CHECK_PTR_LT(a, b, msg, ...)  Asserts a <  b
+//   PW_CHECK_PTR_GE(a, b, msg, ...)  Asserts a >= b
+//   PW_CHECK_PTR_GT(a, b, msg, ...)  Asserts a >  b
+//   PW_CHECK_PTR_EQ(a, b, msg, ...)  Asserts a == b
+//   PW_CHECK_PTR_NE(a, b, msg, ...)  Asserts a != b
 //
 //   Binary comparison asserts for 'float' type ("%f" in format strings):
-//   PW_CHECK_FLOAT_LE(a, b, msg, ...)  Asserts a <= b
-//   PW_CHECK_FLOAT_LT(a, b, msg, ...)  Asserts a <  b
-//   PW_CHECK_FLOAT_GE(a, b, msg, ...)  Asserts a >= b
-//   PW_CHECK_FLOAT_GT(a, b, msg, ...)  Asserts a >  b
-//   PW_CHECK_FLOAT_EQ(a, b, msg, ...)  Asserts a == b
+//   PW_CHECK_FLOAT_NEAR(a, b, abs_tolerance, msg, ...)
+//     Asserts (a >= (b - abs_tolerance)) && (a <= (b + abs_tolerance))
+//   PW_CHECK_FLOAT_EXACT_LE(a, b, msg, ...)  Asserts a <= b
+//   PW_CHECK_FLOAT_EXACT_LT(a, b, msg, ...)  Asserts a <  b
+//   PW_CHECK_FLOAT_EXACT_GE(a, b, msg, ...)  Asserts a >= b
+//   PW_CHECK_FLOAT_EXACT_GT(a, b, msg, ...)  Asserts a >  b
+//   PW_CHECK_FLOAT_EXACT_EQ(a, b, msg, ...)  Asserts a == b
+//   PW_CHECK_FLOAT_EXACT_NE(a, b, msg, ...)  Asserts a != b
+//
+//   The above CHECK_*_*() are also available in DCHECK variants, which will
+//   only evaluate their arguments and trigger if the NDEBUG macro is defined.
+//
+//   Note: For float, proper comparator checks which take floating point
+//   precision and ergo error accumulation into account are not provided on
+//   purpose as this comes with some complexity and requires application
+//   specific tolerances in terms of Units of Least Precision (ULP). Instead,
+//   we recommend developers carefully consider how floating point precision and
+//   error impact the data they are bounding and whether CHECKs are appropriate.
 //
 //   Note: PW_CRASH is the equivalent of LOG_FATAL in other systems, where a
 //   device crash is triggered with a message. In Pigweed, logging and
diff --git a/pw_assert/public/pw_assert/internal/assert_impl.h b/pw_assert/public/pw_assert/internal/assert_impl.h
index 7814340..4b1d594 100644
--- a/pw_assert/public/pw_assert/internal/assert_impl.h
+++ b/pw_assert/public/pw_assert/internal/assert_impl.h
@@ -86,45 +86,47 @@
 #define PW_DCHECK_UINT_EQ(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_UINT_EQ(__VA_ARGS__)
 #define PW_DCHECK_UINT_NE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_UINT_NE(__VA_ARGS__)
 
-// Checks for pointer: LE, LT, GE, GT, EQ, NE.
+// Checks for pointer: LE, LT, GE, GT, EQ, NE, and NOTNULL.
 #define PW_CHECK_PTR_LE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, <=, argb, void*, "%p", __VA_ARGS__)
 #define PW_CHECK_PTR_LT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, < , argb, void*, "%p", __VA_ARGS__)
 #define PW_CHECK_PTR_GE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, >=, argb, void*, "%p", __VA_ARGS__)
 #define PW_CHECK_PTR_GT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, > , argb, void*, "%p", __VA_ARGS__)
 #define PW_CHECK_PTR_EQ(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, ==, argb, void*, "%p", __VA_ARGS__)
 #define PW_CHECK_PTR_NE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, !=, argb, void*, "%p", __VA_ARGS__)
-
-// For implementation simplicity, re-use PTR_NE for NOTNULL.
 #define PW_CHECK_NOTNULL(arga, ...) \
   _PW_CHECK_BINARY_CMP_IMPL(arga, !=, NULL, void*, "%p", __VA_ARGS__)
 
-// Debug checks for pointer: LE, LT, GE, GT, EQ, NE.
+// Debug checks for pointer: LE, LT, GE, GT, EQ, NE, and NOTNULL.
 #define PW_DCHECK_PTR_LE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_LE(__VA_ARGS__)
 #define PW_DCHECK_PTR_LT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_LT(__VA_ARGS__)
 #define PW_DCHECK_PTR_GE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_GE(__VA_ARGS__)
 #define PW_DCHECK_PTR_GT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_GT(__VA_ARGS__)
 #define PW_DCHECK_PTR_EQ(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_EQ(__VA_ARGS__)
 #define PW_DCHECK_PTR_NE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_NE(__VA_ARGS__)
-
-// For implementation simplicity, re-use PTR_NE for NOTNULL.
 #define PW_DCHECK_NOTNULL(...) \
   if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_NOTNULL(__VA_ARGS__)
 
-// Checks for float: LE, LT, GE, GT, EQ.
-#define PW_CHECK_FLOAT_LE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, <=, argb, float, "%f", __VA_ARGS__)
-#define PW_CHECK_FLOAT_LT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, < , argb, float, "%f", __VA_ARGS__)
-#define PW_CHECK_FLOAT_GE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, >=, argb, float, "%f", __VA_ARGS__)
-#define PW_CHECK_FLOAT_GT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, > , argb, float, "%f", __VA_ARGS__)
-#define PW_CHECK_FLOAT_EQ(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, ==, argb, float, "%f", __VA_ARGS__)
-#define PW_CHECK_FLOAT_NE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, !=, argb, float, "%f", __VA_ARGS__)
+// Checks for float: EXACT_LE, EXACT_LT, EXACT_GE, EXACT_GT, EXACT_EQ, EXACT_NE,
+// NEAR.
+#define PW_CHECK_FLOAT_NEAR(arga, argb, abs_tolerance, ...) \
+  _PW_CHECK_FLOAT_NEAR(arga, argb, abs_tolerance, __VA_ARGS__)
+#define PW_CHECK_FLOAT_EXACT_LE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, <=, argb, float, "%f", __VA_ARGS__)
+#define PW_CHECK_FLOAT_EXACT_LT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, < , argb, float, "%f", __VA_ARGS__)
+#define PW_CHECK_FLOAT_EXACT_GE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, >=, argb, float, "%f", __VA_ARGS__)
+#define PW_CHECK_FLOAT_EXACT_GT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, > , argb, float, "%f", __VA_ARGS__)
+#define PW_CHECK_FLOAT_EXACT_EQ(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, ==, argb, float, "%f", __VA_ARGS__)
+#define PW_CHECK_FLOAT_EXACT_NE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, !=, argb, float, "%f", __VA_ARGS__)
 
-// Debug checks for float: LE, LT, GE, GT, EQ.
-#define PW_DCHECK_FLOAT_LE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_LE(__VA_ARGS__)
-#define PW_DCHECK_FLOAT_LT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_LT(__VA_ARGS__)
-#define PW_DCHECK_FLOAT_GE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_GE(__VA_ARGS__)
-#define PW_DCHECK_FLOAT_GT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_GT(__VA_ARGS__)
-#define PW_DCHECK_FLOAT_EQ(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EQ(__VA_ARGS__)
-#define PW_DCHECK_FLOAT_NE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_NE(__VA_ARGS__)
+// Debug checks for float: NEAR, EXACT_LE, EXACT_LT, EXACT_GE, EXACT_GT,
+// EXACT_EQ.
+#define PW_DCHECK_FLOAT_NEAR(...) \
+  if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_NEAR(__VA_ARGS__)
+#define PW_DCHECK_FLOAT_EXACT_LE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_LE(__VA_ARGS__)
+#define PW_DCHECK_FLOAT_EXACT_LT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_LT(__VA_ARGS__)
+#define PW_DCHECK_FLOAT_EXACT_GE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_GE(__VA_ARGS__)
+#define PW_DCHECK_FLOAT_EXACT_GT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_GT(__VA_ARGS__)
+#define PW_DCHECK_FLOAT_EXACT_EQ(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_EQ(__VA_ARGS__)
+#define PW_DCHECK_FLOAT_EXACT_NE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_NE(__VA_ARGS__)
 
 // clang-format on
 
@@ -146,7 +148,9 @@
 // =========================================================================
 // Implementation for PW_CHECK
 
-// TODO: Explain why we must expand another time.
+// Two layers of select macros are used to enable the preprocessor to expand
+// macros in the arguments to ultimately token paste the final macro name based
+// on whether there are printf-style arguments.
 #define _PW_CHECK_SELECT_MACRO(condition, has_args, ...) \
   _PW_CHECK_SELECT_MACRO_EXPANDED(condition, has_args, __VA_ARGS__)
 
@@ -165,7 +169,9 @@
 // =========================================================================
 // Implementation for PW_CHECK_<type>_<comparison>
 
-// TODO: Explain why we must expand another time.
+// Two layers of select macros are used to enable the preprocessor to expand
+// macros in the arguments to ultimately token paste the final macro name based
+// on whether there are printf-style arguments.
 #define _PW_CHECK_BINARY_COMPARISON_SELECT_MACRO(argument_a_str,       \
                                                  argument_a_val,       \
                                                  comparison_op_str,    \
@@ -232,8 +238,8 @@
                                           type_fmt,              \
                                           __VA_ARGS__)
 
-// For the binary assertions, this private macro is re-used for all the
-// variants. Due to limitations of C formatting, it is necessary to have
+// For the binary assertions, this private macro is re-used for almost all of
+// the variants. Due to limitations of C formatting, it is necessary to have
 // separate macros for the types.
 //
 // The macro avoids evaluating the arguments multiple times at the cost of some
@@ -255,10 +261,42 @@
     }                                                                    \
   } while (0)
 
+// Custom implementation for FLOAT_NEAR which is implemented through two
+// underlying checks which are not trivially replaced through the use of
+// FLOAT_EXACT_LE & FLOAT_EXACT_GE.
+#define _PW_CHECK_FLOAT_NEAR(argument_a, argument_b, abs_tolerance, ...)       \
+  do {                                                                         \
+    PW_CHECK_FLOAT_EXACT_GE(abs_tolerance, 0.0f);                              \
+    float evaluated_argument_a = (float)(argument_a);                          \
+    float evaluated_argument_b_min = (float)(argument_b)-abs_tolerance;        \
+    float evaluated_argument_b_max = (float)(argument_b) + abs_tolerance;      \
+    if (!(evaluated_argument_a >= evaluated_argument_b_min)) {                 \
+      _PW_CHECK_BINARY_COMPARISON_SELECT_MACRO(#argument_a,                    \
+                                               evaluated_argument_a,           \
+                                               ">=",                           \
+                                               #argument_b " - abs_tolerance", \
+                                               evaluated_argument_b_min,       \
+                                               "%f",                           \
+                                               PW_HAS_ARGS(__VA_ARGS__),       \
+                                               __VA_ARGS__);                   \
+    } else if (!(evaluated_argument_a <= evaluated_argument_b_max)) {          \
+      _PW_CHECK_BINARY_COMPARISON_SELECT_MACRO(#argument_a,                    \
+                                               evaluated_argument_a,           \
+                                               "<=",                           \
+                                               #argument_b " + abs_tolerance", \
+                                               evaluated_argument_b_max,       \
+                                               "%f",                           \
+                                               PW_HAS_ARGS(__VA_ARGS__),       \
+                                               __VA_ARGS__);                   \
+    }                                                                          \
+  } while (0)
+
 // =========================================================================
 // Implementation for PW_CHECK_OK
 
-// TODO: Explain why we must expand another time.
+// Two layers of select macros are used to enable the preprocessor to expand
+// macros in the arguments to ultimately token paste the final macro name based
+// on whether there are printf-style arguments.
 #define _PW_CHECK_OK_SELECT_MACRO(                    \
     status_expr_str, status_value_str, has_args, ...) \
   _PW_CHECK_OK_SELECT_MACRO_EXPANDED(                 \
@@ -298,63 +336,65 @@
 #if PW_ASSERT_USE_SHORT_NAMES
 
 // Checks that always run even in production.
-#define CRASH           PW_CRASH
-#define CHECK           PW_CHECK
-#define CHECK_PTR_LE    PW_CHECK_PTR_LE
-#define CHECK_PTR_LT    PW_CHECK_PTR_LT
-#define CHECK_PTR_GE    PW_CHECK_PTR_GE
-#define CHECK_PTR_GT    PW_CHECK_PTR_GT
-#define CHECK_PTR_EQ    PW_CHECK_PTR_EQ
-#define CHECK_PTR_NE    PW_CHECK_PTR_NE
-#define CHECK_NOTNULL   PW_CHECK_NOTNULL
-#define CHECK_INT_LE    PW_CHECK_INT_LE
-#define CHECK_INT_LT    PW_CHECK_INT_LT
-#define CHECK_INT_GE    PW_CHECK_INT_GE
-#define CHECK_INT_GT    PW_CHECK_INT_GT
-#define CHECK_INT_EQ    PW_CHECK_INT_EQ
-#define CHECK_INT_NE    PW_CHECK_INT_NE
-#define CHECK_UINT_LE   PW_CHECK_UINT_LE
-#define CHECK_UINT_LT   PW_CHECK_UINT_LT
-#define CHECK_UINT_GE   PW_CHECK_UINT_GE
-#define CHECK_UINT_GT   PW_CHECK_UINT_GT
-#define CHECK_UINT_EQ   PW_CHECK_UINT_EQ
-#define CHECK_UINT_NE   PW_CHECK_UINT_NE
-#define CHECK_FLOAT_LE  PW_CHECK_FLOAT_LE
-#define CHECK_FLOAT_LT  PW_CHECK_FLOAT_LT
-#define CHECK_FLOAT_GE  PW_CHECK_FLOAT_GE
-#define CHECK_FLOAT_GT  PW_CHECK_FLOAT_GT
-#define CHECK_FLOAT_EQ  PW_CHECK_FLOAT_EQ
-#define CHECK_FLOAT_NE  PW_CHECK_FLOAT_NE
-#define CHECK_OK        PW_CHECK_OK
+#define CRASH                 PW_CRASH
+#define CHECK                 PW_CHECK
+#define CHECK_PTR_LE          PW_CHECK_PTR_LE
+#define CHECK_PTR_LT          PW_CHECK_PTR_LT
+#define CHECK_PTR_GE          PW_CHECK_PTR_GE
+#define CHECK_PTR_GT          PW_CHECK_PTR_GT
+#define CHECK_PTR_EQ          PW_CHECK_PTR_EQ
+#define CHECK_PTR_NE          PW_CHECK_PTR_NE
+#define CHECK_NOTNULL         PW_CHECK_NOTNULL
+#define CHECK_INT_LE          PW_CHECK_INT_LE
+#define CHECK_INT_LT          PW_CHECK_INT_LT
+#define CHECK_INT_GE          PW_CHECK_INT_GE
+#define CHECK_INT_GT          PW_CHECK_INT_GT
+#define CHECK_INT_EQ          PW_CHECK_INT_EQ
+#define CHECK_INT_NE          PW_CHECK_INT_NE
+#define CHECK_UINT_LE         PW_CHECK_UINT_LE
+#define CHECK_UINT_LT         PW_CHECK_UINT_LT
+#define CHECK_UINT_GE         PW_CHECK_UINT_GE
+#define CHECK_UINT_GT         PW_CHECK_UINT_GT
+#define CHECK_UINT_EQ         PW_CHECK_UINT_EQ
+#define CHECK_UINT_NE         PW_CHECK_UINT_NE
+#define CHECK_FLOAT_NEAR      PW_CHECK_FLOAT_NEAR
+#define CHECK_FLOAT_EXACT_LE  PW_CHECK_FLOAT_EXACT_LE
+#define CHECK_FLOAT_EXACT_LT  PW_CHECK_FLOAT_EXACT_LT
+#define CHECK_FLOAT_EXACT_GE  PW_CHECK_FLOAT_EXACT_GE
+#define CHECK_FLOAT_EXACT_GT  PW_CHECK_FLOAT_EXACT_GT
+#define CHECK_FLOAT_EXACT_EQ  PW_CHECK_FLOAT_EXACT_EQ
+#define CHECK_FLOAT_EXACT_NE  PW_CHECK_FLOAT_EXACT_NE
+#define CHECK_OK              PW_CHECK_OK
 
 // Checks that are disabled if NDEBUG is not defined.
-#define DCHECK          PW_DCHECK
-#define DCHECK_PTR_LE   PW_DCHECK_PTR_LE
-#define DCHECK_PTR_LT   PW_DCHECK_PTR_LT
-#define DCHECK_PTR_GE   PW_DCHECK_PTR_GE
-#define DCHECK_PTR_GT   PW_DCHECK_PTR_GT
-#define DCHECK_PTR_EQ   PW_DCHECK_PTR_EQ
-#define DCHECK_PTR_NE   PW_DCHECK_PTR_NE
-#define DCHECK_NOTNULL  PW_DCHECK_NOTNULL
-#define DCHECK_INT_LE   PW_DCHECK_INT_LE
-#define DCHECK_INT_LT   PW_DCHECK_INT_LT
-#define DCHECK_INT_GE   PW_DCHECK_INT_GE
-#define DCHECK_INT_GT   PW_DCHECK_INT_GT
-#define DCHECK_INT_EQ   PW_DCHECK_INT_EQ
-#define DCHECK_INT_NE   PW_DCHECK_INT_NE
-#define DCHECK_UINT_LE  PW_DCHECK_UINT_LE
-#define DCHECK_UINT_LT  PW_DCHECK_UINT_LT
-#define DCHECK_UINT_GE  PW_DCHECK_UINT_GE
-#define DCHECK_UINT_GT  PW_DCHECK_UINT_GT
-#define DCHECK_UINT_EQ  PW_DCHECK_UINT_EQ
-#define DCHECK_UINT_NE  PW_DCHECK_UINT_NE
-#define DCHECK_FLOAT_LE PW_DCHECK_FLOAT_LE
-#define DCHECK_FLOAT_LT PW_DCHECK_FLOAT_LT
-#define DCHECK_FLOAT_GE PW_DCHECK_FLOAT_GE
-#define DCHECK_FLOAT_GT PW_DCHECK_FLOAT_GT
-#define DCHECK_FLOAT_EQ PW_DCHECK_FLOAT_EQ
-#define DCHECK_FLOAT_NE PW_DCHECK_FLOAT_NE
-#define DCHECK_OK       PW_DCHECK_OK
+#define DCHECK                PW_DCHECK
+#define DCHECK_PTR_LE         PW_DCHECK_PTR_LE
+#define DCHECK_PTR_LT         PW_DCHECK_PTR_LT
+#define DCHECK_PTR_GE         PW_DCHECK_PTR_GE
+#define DCHECK_PTR_GT         PW_DCHECK_PTR_GT
+#define DCHECK_PTR_EQ         PW_DCHECK_PTR_EQ
+#define DCHECK_PTR_NE         PW_DCHECK_PTR_NE
+#define DCHECK_NOTNULL        PW_DCHECK_NOTNULL
+#define DCHECK_INT_LE         PW_DCHECK_INT_LE
+#define DCHECK_INT_LT         PW_DCHECK_INT_LT
+#define DCHECK_INT_GE         PW_DCHECK_INT_GE
+#define DCHECK_INT_GT         PW_DCHECK_INT_GT
+#define DCHECK_INT_EQ         PW_DCHECK_INT_EQ
+#define DCHECK_INT_NE         PW_DCHECK_INT_NE
+#define DCHECK_UINT_LE        PW_DCHECK_UINT_LE
+#define DCHECK_UINT_LT        PW_DCHECK_UINT_LT
+#define DCHECK_UINT_GE        PW_DCHECK_UINT_GE
+#define DCHECK_UINT_GT        PW_DCHECK_UINT_GT
+#define DCHECK_UINT_EQ        PW_DCHECK_UINT_EQ
+#define DCHECK_UINT_NE        PW_DCHECK_UINT_NE
+#define DCHECK_FLOAT_NEAR     PW_DCHECK_FLOAT_NEAR
+#define DCHECK_FLOAT_EXACT_LT PW_DCHECK_FLOAT_EXACT_LT
+#define DCHECK_FLOAT_EXACT_LE PW_DCHECK_FLOAT_EXACT_LE
+#define DCHECK_FLOAT_EXACT_GT PW_DCHECK_FLOAT_EXACT_GT
+#define DCHECK_FLOAT_EXACT_GE PW_DCHECK_FLOAT_EXACT_GE
+#define DCHECK_FLOAT_EXACT_EQ PW_DCHECK_FLOAT_EXACT_EQ
+#define DCHECK_FLOAT_EXACT_NE PW_DCHECK_FLOAT_EXACT_NE
+#define DCHECK_OK             PW_DCHECK_OK
 
 #endif  // PW_ASSERT_SHORT_NAMES
 // clang-format on
diff --git a/pw_assert_basic/public/pw_assert_basic/assert_basic.h b/pw_assert_basic/public/pw_assert_basic/assert_basic.h
index f2186c2..269c0a6 100644
--- a/pw_assert_basic/public/pw_assert_basic/assert_basic.h
+++ b/pw_assert_basic/public/pw_assert_basic/assert_basic.h
@@ -52,7 +52,7 @@
 
 // Sample assert failure message produced by the below implementation:
 //
-//   Check failed: current_sensor (=610) < new_sensor (=50): More details!
+//   Check failed: current_sensor (=610) < new_sensor (=50). More details!
 //
 // Putting the value next to the operand makes the string easier to read.