diff --git a/pw_sync/BUILD b/pw_sync/BUILD
index b882e47..f1c6620 100644
--- a/pw_sync/BUILD
+++ b/pw_sync/BUILD
@@ -26,6 +26,7 @@
 PW_SYNC_BINARY_SEMAPHORE_BACKEND = "//pw_sync_stl:binary_semaphore"
 PW_SYNC_COUNTING_SEMAPHORE_BACKEND = "//pw_sync_stl:counting_semaphore"
 PW_SYNC_MUTEX_BACKEND = "//pw_sync_stl:mutex"
+PW_SYNC_TIMED_MUTEX_BACKEND = "//pw_sync_stl:timed_mutex"
 PW_SYNC_INTERRUPT_SPIN_LOCK_BACKEND = "//pw_sync_stl:interrupt_spin_lock"
 
 pw_cc_library(
@@ -101,7 +102,6 @@
     ],
     deps = [
         PW_SYNC_MUTEX_BACKEND + "_headers",
-        "//pw_chrono:system_clock",
         "//pw_preprocessor",
     ],
 )
@@ -122,6 +122,38 @@
 )
 
 pw_cc_library(
+    name = "timed_mutex_facade",
+    hdrs = [
+        "public/pw_sync/timed_mutex.h",
+    ],
+    includes = ["public"],
+    srcs = [
+        "timed_mutex.cc"
+    ],
+    deps = [
+        PW_SYNC_TIMED_MUTEX_BACKEND + "_headers",
+        "//pw_chrono:system_clock",
+        ":mutex_facade",
+        "//pw_preprocessor",
+    ],
+)
+
+pw_cc_library(
+    name = "timed_mutex",
+    deps = [
+        ":timed_mutex_facade",
+        PW_SYNC_TIMED_MUTEX_BACKEND + "_headers",
+    ],
+)
+
+pw_cc_library(
+    name = "timed_mutex_backend",
+    deps = [
+       PW_SYNC_TIMED_MUTEX_BACKEND,
+    ],
+)
+
+pw_cc_library(
     name = "interrupt_spin_lock_facade",
     hdrs = [
         "public/pw_sync/interrupt_spin_lock.h",
@@ -199,6 +231,19 @@
 )
 
 pw_cc_test(
+    name = "timed_mutex_facade_test",
+    srcs = [
+        "timed_mutex_facade_test.cc",
+        "timed_mutex_facade_test_c.c",
+    ],
+    deps = [
+        ":timed_mutex",
+        "//pw_preprocessor",
+        "//pw_unit_test",
+    ],
+)
+
+pw_cc_test(
     name = "interrupt_spin_lock_facade_test",
     srcs = [
         "interrupt_spin_lock_facade_test.cc",
diff --git a/pw_sync/BUILD.gn b/pw_sync/BUILD.gn
index eeaf60e..673f80b 100644
--- a/pw_sync/BUILD.gn
+++ b/pw_sync/BUILD.gn
@@ -51,11 +51,20 @@
   backend = pw_sync_MUTEX_BACKEND
   public_configs = [ ":public_include_path" ]
   public = [ "public/pw_sync/mutex.h" ]
+  public_deps = [ "$dir_pw_preprocessor" ]
+  sources = [ "mutex.cc" ]
+}
+
+pw_facade("timed_mutex") {
+  backend = pw_sync_TIMED_MUTEX_BACKEND
+  public_configs = [ ":public_include_path" ]
+  public = [ "public/pw_sync/timed_mutex.h" ]
   public_deps = [
+    ":mutex",
     "$dir_pw_chrono:system_clock",
     "$dir_pw_preprocessor",
   ]
-  sources = [ "mutex.cc" ]
+  sources = [ "timed_mutex.cc" ]
 }
 
 pw_facade("interrupt_spin_lock") {
@@ -76,6 +85,7 @@
     ":binary_semaphore_facade_test",
     ":counting_semaphore_facade_test",
     ":mutex_facade_test",
+    ":timed_mutex_facade_test",
     ":interrupt_spin_lock_facade_test",
   ]
 }
@@ -119,6 +129,19 @@
   ]
 }
 
+pw_test("timed_mutex_facade_test") {
+  enable_if = pw_sync_TIMED_MUTEX_BACKEND != ""
+  sources = [
+    "timed_mutex_facade_test.cc",
+    "timed_mutex_facade_test_c.c",
+  ]
+  deps = [
+    ":timed_mutex",
+    "$dir_pw_preprocessor",
+    pw_sync_TIMED_MUTEX_BACKEND,
+  ]
+}
+
 pw_test("interrupt_spin_lock_facade_test") {
   enable_if = pw_sync_INTERRUPT_SPIN_LOCK_BACKEND != ""
   sources = [
diff --git a/pw_sync/backend.gni b/pw_sync/backend.gni
index 21091eb..8f6605a 100644
--- a/pw_sync/backend.gni
+++ b/pw_sync/backend.gni
@@ -22,6 +22,9 @@
   # Backend for the pw_sync module's mutex.
   pw_sync_MUTEX_BACKEND = ""
 
+  # Backend for the pw_sync module's timed mutex.
+  pw_sync_TIMED_MUTEX_BACKEND = ""
+
   # Backend for the pw_sync module's interrupt spin lock.
   pw_sync_INTERRUPT_SPIN_LOCK_BACKEND = ""
 
diff --git a/pw_sync/docs.rst b/pw_sync/docs.rst
index aec5900..de5a125 100644
--- a/pw_sync/docs.rst
+++ b/pw_sync/docs.rst
@@ -45,15 +45,10 @@
 the classic priority-inversion problem.
 
 The Mutex's API is C++11 STL
-`std::timed_mutex <https://en.cppreference.com/w/cpp/thread/timed_mutex>`_ like,
+`std::mutex <https://en.cppreference.com/w/cpp/thread/mutex>`_ like,
 meaning it is a
-`BasicLockable <https://en.cppreference.com/w/cpp/named_req/BasicLockable>`_,
-`Lockable <https://en.cppreference.com/w/cpp/named_req/Lockable>`_, and
-`TimedLockable <https://en.cppreference.com/w/cpp/named_req/TimedLockable>`_.
-
-.. Warning::
-  This interface will likely be split between a Mutex and TimedMutex to ease
-  portability for baremetal support.
+`BasicLockable <https://en.cppreference.com/w/cpp/named_req/BasicLockable>`_
+and `Lockable <https://en.cppreference.com/w/cpp/named_req/Lockable>`_.
 
 .. list-table::
 
@@ -93,6 +88,177 @@
      **Precondition:** The lock isn't already held by this thread. Recursive
      locking is undefined behavior.
 
+  .. cpp:function:: void unlock()
+
+     Unlocks the mutex. Failures are fatal.
+
+     **Precondition:** The mutex is held by this thread.
+
+
+  .. list-table::
+
+    * - *Safe to use in context*
+      - *Thread*
+      - *Interrupt*
+      - *NMI*
+    * - ``Mutex::Mutex``
+      - ✔
+      -
+      -
+    * - ``Mutex::~Mutex``
+      - ✔
+      -
+      -
+    * - ``void Mutex::lock``
+      - ✔
+      -
+      -
+    * - ``bool Mutex::try_lock``
+      - ✔
+      -
+      -
+    * - ``void Mutex::unlock``
+      - ✔
+      -
+      -
+
+Examples in C++
+^^^^^^^^^^^^^^^
+.. code-block:: cpp
+
+  #include "pw_sync/mutex.h"
+
+  pw::sync::Mutex mutex;
+
+  void ThreadSafeCriticalSection() {
+    mutex.lock();
+    NotThreadSafeCriticalSection();
+    mutex.unlock();
+  }
+
+
+Alternatively you can use C++'s RAII helpers to ensure you always unlock.
+
+.. code-block:: cpp
+
+  #include <mutex>
+
+  #include "pw_sync/mutex.h"
+
+  pw::sync::Mutex mutex;
+
+  void ThreadSafeCriticalSection() {
+    std::lock_guard lock(mutex);
+    NotThreadSafeCriticalSection();
+  }
+
+
+C
+-
+The Mutex must be created in C++, however it can be passed into C using the
+``pw_sync_Mutex`` opaque struct alias.
+
+.. cpp:function:: void pw_sync_Mutex_Lock(pw_sync_Mutex* mutex)
+
+  Invokes the ``Mutex::lock`` member function on the given ``mutex``.
+
+.. cpp:function:: bool pw_sync_Mutex_TryLock(pw_sync_Mutex* mutex)
+
+  Invokes the ``Mutex::try_lock`` member function on the given ``mutex``.
+
+.. cpp:function:: void pw_sync_Mutex_Unlock(pw_sync_Mutex* mutex)
+
+  Invokes the ``Mutex::unlock`` member function on the given ``mutex``.
+
+.. list-table::
+
+  * - *Safe to use in context*
+    - *Thread*
+    - *Interrupt*
+    - *NMI*
+  * - ``void pw_sync_Mutex_Lock``
+    - ✔
+    -
+    -
+  * - ``bool pw_sync_Mutex_TryLock``
+    - ✔
+    -
+    -
+  * - ``void pw_sync_Mutex_Unlock``
+    - ✔
+    -
+    -
+
+Example in C
+^^^^^^^^^^^^
+.. code-block:: cpp
+
+  #include "pw_sync/mutex.h"
+
+  pw::sync::Mutex mutex;
+
+  extern pw_sync_Mutex mutex;  // This can only be created in C++.
+
+  void ThreadSafeCriticalSection(void) {
+    pw_sync_Mutex_Lock(&mutex);
+    NotThreadSafeCriticalSection();
+    pw_sync_Mutex_Unlock(&mutex);
+  }
+
+TimedMutex
+==========
+The TimedMutex is an extension of the Mutex which offers timeout and deadline
+based semantics.
+
+The TimedMutex's API is C++11 STL
+`std::timed_mutex <https://en.cppreference.com/w/cpp/thread/timed_mutex>`_ like,
+meaning it is a
+`BasicLockable <https://en.cppreference.com/w/cpp/named_req/BasicLockable>`_,
+`Lockable <https://en.cppreference.com/w/cpp/named_req/Lockable>`_, and
+`TimedLockable <https://en.cppreference.com/w/cpp/named_req/TimedLockable>`_.
+
+Note that the ``TimedMutex`` is a derived ``Mutex`` class, meaning that
+a ``TimedMutex`` can be used by someone who needs the basic ``Mutex``. This is
+in stark contrast to the C++ STL's
+`std::timed_mutex <https://en.cppreference.com/w/cpp/thread/timed_mutex>`_.
+
+
+.. list-table::
+
+  * - *Supported on*
+    - *Backend module*
+  * - FreeRTOS
+    - :ref:`module-pw_sync_freertos`
+  * - ThreadX
+    - :ref:`module-pw_sync_threadx`
+  * - embOS
+    - :ref:`module-pw_sync_embos`
+  * - STL
+    - :ref:`module-pw_sync_stl`
+  * - Zephyr
+    - Planned
+  * - CMSIS-RTOS API v2 & RTX5
+    - Planned
+
+C++
+---
+.. cpp:class:: pw::sync::TimedMutex
+
+  .. cpp:function:: void lock()
+
+     Locks the mutex, blocking indefinitely. Failures are fatal.
+
+     **Precondition:** The lock isn't already held by this thread. Recursive
+     locking is undefined behavior.
+
+  .. cpp:function:: bool try_lock()
+
+     Attempts to lock the mutex in a non-blocking manner.
+     Returns true if the mutex was successfully acquired.
+
+     **Precondition:** The lock isn't already held by this thread. Recursive
+     locking is undefined behavior.
+
   .. cpp:function:: bool try_lock_for(chrono::SystemClock::duration for_at_least)
 
      Attempts to lock the mutex where, if needed, blocking for at least the
@@ -124,31 +290,31 @@
       - *Thread*
       - *Interrupt*
       - *NMI*
-    * - ``Mutex::Mutex``
+    * - ``TimedMutex::TimedMutex``
       - ✔
       -
       -
-    * - ``Mutex::~Mutex``
+    * - ``TimedMutex::~TimedMutex``
       - ✔
       -
       -
-    * - ``void Mutex::lock``
+    * - ``void TimedMutex::lock``
       - ✔
       -
       -
-    * - ``bool Mutex::try_lock``
+    * - ``bool TimedMutex::try_lock``
       - ✔
       -
       -
-    * - ``bool Mutex::try_lock_for``
+    * - ``bool TimedMutex::try_lock_for``
       - ✔
       -
       -
-    * - ``bool Mutex::try_lock_until``
+    * - ``bool TimedMutex::try_lock_until``
       - ✔
       -
       -
-    * - ``void Mutex::unlock``
+    * - ``void TimedMutex::unlock``
       - ✔
       -
       -
@@ -158,15 +324,9 @@
 .. code-block:: cpp
 
   #include "pw_chrono/system_clock.h"
-  #include "pw_sync/mutex.h"
+  #include "pw_sync/timed_mutex.h"
 
-  pw::sync::Mutex mutex;
-
-  void ThreadSafeCriticalSection() {
-    mutex.lock();
-    NotThreadSafeCriticalSection();
-    mutex.unlock();
-  }
+  pw::sync::TimedMutex mutex;
 
   bool ThreadSafeCriticalSectionWithTimeout(
       const SystemClock::duration timeout) {
@@ -186,14 +346,9 @@
   #include <mutex>
 
   #include "pw_chrono/system_clock.h"
-  #include "pw_sync/mutex.h"
+  #include "pw_sync/timed_mutex.h"
 
-  pw::sync::Mutex mutex;
-
-  void ThreadSafeCriticalSection() {
-    std::lock_guard lock(mutex);
-    NotThreadSafeCriticalSection();
-  }
+  pw::sync::TimedMutex mutex;
 
   bool ThreadSafeCriticalSectionWithTimeout(
       const SystemClock::duration timeout) {
@@ -209,28 +364,28 @@
 
 C
 -
-The Mutex must be created in C++, however it can be passed into C using the
-``pw_sync_Mutex`` opaque struct alias.
+The TimedMutex must be created in C++, however it can be passed into C using the
+``pw_sync_TimedMutex`` opaque struct alias.
 
-.. cpp:function:: void pw_sync_Mutex_Lock(pw_sync_Mutex* mutex)
+.. cpp:function:: void pw_sync_TimedMutex_Lock(pw_sync_TimedMutex* mutex)
 
-  Invokes the ``Mutex::lock`` member function on the given ``mutex``.
+  Invokes the ``TimedMutex::lock`` member function on the given ``mutex``.
 
-.. cpp:function:: bool pw_sync_Mutex_TryLock(pw_sync_Mutex* mutex)
+.. cpp:function:: bool pw_sync_TimedMutex_TryLock(pw_sync_TimedMutex* mutex)
 
-  Invokes the ``Mutex::try_lock`` member function on the given ``mutex``.
+  Invokes the ``TimedMutex::try_lock`` member function on the given ``mutex``.
 
-.. cpp:function:: bool pw_sync_Mutex_TryLockFor(pw_sync_Mutex* mutex, pw_chrono_SystemClock_Duration for_at_least)
+.. cpp:function:: bool pw_sync_TimedMutex_TryLockFor(pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_Duration for_at_least)
 
-  Invokes the ``Mutex::try_lock_for`` member function on the given ``mutex``.
+  Invokes the ``TimedMutex::try_lock_for`` member function on the given ``mutex``.
 
-.. cpp:function:: bool pw_sync_Mutex_TryLockUntil(pw_sync_Mutex* mutex, pw_chrono_SystemClock_TimePoint until_at_least)
+.. cpp:function:: bool pw_sync_TimedMutex_TryLockUntil(pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_TimePoint until_at_least)
 
-  Invokes the ``Mutex::try_lock_until`` member function on the given ``mutex``.
+  Invokes the ``TimedMutex::try_lock_until`` member function on the given ``mutex``.
 
-.. cpp:function:: void pw_sync_Mutex_Unlock(pw_sync_Mutex* mutex)
+.. cpp:function:: void pw_sync_TimedMutex_Unlock(pw_sync_TimedMutex* mutex)
 
-  Invokes the ``Mutex::unlock`` member function on the given ``mutex``.
+  Invokes the ``TimedMutex::unlock`` member function on the given ``mutex``.
 
 .. list-table::
 
@@ -238,23 +393,23 @@
     - *Thread*
     - *Interrupt*
     - *NMI*
-  * - ``void pw_sync_Mutex_Lock``
+  * - ``void pw_sync_TimedMutex_Lock``
     - ✔
     -
     -
-  * - ``bool pw_sync_Mutex_TryLock``
+  * - ``bool pw_sync_TimedMutex_TryLock``
     - ✔
     -
     -
-  * - ``bool pw_sync_Mutex_TryLockFor``
+  * - ``bool pw_sync_TimedMutex_TryLockFor``
     - ✔
     -
     -
-  * - ``bool pw_sync_Mutex_TryLockUntil``
+  * - ``bool pw_sync_TimedMutex_TryLockUntil``
     - ✔
     -
     -
-  * - ``void pw_sync_Mutex_Unlock``
+  * - ``void pw_sync_TimedMutex_Unlock``
     - ✔
     -
     -
@@ -264,25 +419,19 @@
 .. code-block:: cpp
 
   #include "pw_chrono/system_clock.h"
-  #include "pw_sync/mutex.h"
+  #include "pw_sync/timed_mutex.h"
 
-  pw::sync::Mutex mutex;
+  pw::sync::TimedMutex mutex;
 
-  extern pw_sync_Mutex mutex;  // This can only be created in C++.
-
-  void ThreadSafeCriticalSection(void) {
-    pw_sync_Mutex_Lock(&mutex);
-    NotThreadSafeCriticalSection();
-    pw_sync_Mutex_Unlock(&mutex);
-  }
+  extern pw_sync_TimedMutex mutex;  // This can only be created in C++.
 
   bool ThreadSafeCriticalSectionWithTimeout(
       const pw_chrono_SystemClock_Duration timeout) {
-    if (!pw_sync_Mutex_TryLockFor(&mutex, timeout)) {
+    if (!pw_sync_TimedMutex_TryLockFor(&mutex, timeout)) {
       return false;
     }
     NotThreadSafeCriticalSection();
-    pw_sync_Mutex_Unlock(&mutex);
+    pw_sync_TimedMutex_Unlock(&mutex);
     return true;
   }
 
diff --git a/pw_sync/mutex.cc b/pw_sync/mutex.cc
index 416182e..1932c5a 100644
--- a/pw_sync/mutex.cc
+++ b/pw_sync/mutex.cc
@@ -14,22 +14,10 @@
 
 #include "pw_sync/mutex.h"
 
-using pw::chrono::SystemClock;
-
 extern "C" void pw_sync_Mutex_Lock(pw_sync_Mutex* mutex) { mutex->lock(); }
 
 extern "C" bool pw_sync_Mutex_TryLock(pw_sync_Mutex* mutex) {
   return mutex->try_lock();
 }
 
-extern "C" bool pw_sync_Mutex_TryLockFor(
-    pw_sync_Mutex* mutex, pw_chrono_SystemClock_Duration for_at_least) {
-  return mutex->try_lock_for(SystemClock::duration(for_at_least.ticks));
-}
-
-extern "C" bool pw_sync_Mutex_TryLockUntil(
-    pw_sync_Mutex* mutex, pw_chrono_SystemClock_TimePoint until_at_least) {
-  return mutex->try_lock_until(SystemClock::time_point(
-      SystemClock::duration(until_at_least.duration_since_epoch.ticks)));
-}
 extern "C" void pw_sync_Mutex_Unlock(pw_sync_Mutex* mutex) { mutex->unlock(); }
diff --git a/pw_sync/mutex_facade_test.cc b/pw_sync/mutex_facade_test.cc
index ca47cfe..0fc7203 100644
--- a/pw_sync/mutex_facade_test.cc
+++ b/pw_sync/mutex_facade_test.cc
@@ -15,12 +15,8 @@
 #include <chrono>
 
 #include "gtest/gtest.h"
-#include "pw_chrono/system_clock.h"
 #include "pw_sync/mutex.h"
 
-using pw::chrono::SystemClock;
-using namespace std::chrono_literals;
-
 namespace pw::sync {
 namespace {
 
@@ -29,22 +25,10 @@
 // Functions defined in mutex_facade_test_c.c which call the API from C.
 void pw_sync_Mutex_CallLock(pw_sync_Mutex* mutex);
 bool pw_sync_Mutex_CallTryLock(pw_sync_Mutex* mutex);
-bool pw_sync_Mutex_CallTryLockFor(pw_sync_Mutex* mutex,
-                                  pw_chrono_SystemClock_Duration for_at_least);
-bool pw_sync_Mutex_CallTryLockUntil(
-    pw_sync_Mutex* mutex, pw_chrono_SystemClock_TimePoint until_at_least);
 void pw_sync_Mutex_CallUnlock(pw_sync_Mutex* mutex);
 
 }  // extern "C"
 
-// We can't control the SystemClock's period configuration, so just in case
-// duration cannot be accurately expressed in integer ticks, round the
-// duration up.
-constexpr SystemClock::duration kRoundedArbitraryDuration =
-    SystemClock::for_at_least(42ms);
-constexpr pw_chrono_SystemClock_Duration kRoundedArbitraryDurationInC =
-    PW_SYSTEM_CLOCK_MS(42);
-
 // TODO(pwbug/291): Add real concurrency tests once we have pw::thread.
 
 TEST(Mutex, LockUnlock) {
@@ -71,39 +55,6 @@
   mutex.unlock();
 }
 
-TEST(Mutex, TryLockUnlockFor) {
-  pw::sync::Mutex mutex;
-
-  SystemClock::time_point before = SystemClock::now();
-  ASSERT_TRUE(mutex.try_lock_for(kRoundedArbitraryDuration));
-  SystemClock::duration time_elapsed = SystemClock::now() - before;
-  EXPECT_LT(time_elapsed, kRoundedArbitraryDuration);
-
-  // TODO(pwbug/291): Ensure it blocks fails to lock when already held.
-  // before = SystemClock::now();
-  // EXPECT_FALSE(mutex.try_lock_for(kRoundedArbitraryDuration));
-  // time_elapsed = SystemClock::now() - before;
-  /// EXPECT_GE(time_elapsed, kRoundedArbitraryDuration);
-
-  mutex.unlock();
-}
-
-TEST(Mutex, TryLockUnlockUntil) {
-  pw::sync::Mutex mutex;
-
-  const SystemClock::time_point deadline =
-      SystemClock::now() + kRoundedArbitraryDuration;
-  ASSERT_TRUE(mutex.try_lock_until(deadline));
-  EXPECT_LT(SystemClock::now(), deadline);
-
-  // TODO(pwbug/291): Ensure it blocks fails to lock when already held.
-  // EXPECT_FALSE(
-  //     mutex.try_lock_until(SystemClock::now() + kRoundedArbitraryDuration));
-  // EXPECT_GE(SystemClock::now(), deadline);
-
-  mutex.unlock();
-}
-
 TEST(Mutex, LockUnlockInC) {
   pw::sync::Mutex mutex;
   pw_sync_Mutex_CallLock(&mutex);
@@ -118,44 +69,5 @@
   pw_sync_Mutex_CallUnlock(&mutex);
 }
 
-TEST(Mutex, TryLockUnlockForInC) {
-  pw::sync::Mutex mutex;
-
-  pw_chrono_SystemClock_TimePoint before = pw_chrono_SystemClock_Now();
-  ASSERT_TRUE(
-      pw_sync_Mutex_CallTryLockFor(&mutex, kRoundedArbitraryDurationInC));
-  pw_chrono_SystemClock_Duration time_elapsed =
-      pw_chrono_SystemClock_TimeElapsed(before, pw_chrono_SystemClock_Now());
-  EXPECT_LT(time_elapsed.ticks, kRoundedArbitraryDurationInC.ticks);
-
-  // TODO(pwbug/291): Ensure it blocks fails to lock when already held.
-  // before = pw_chrono_SystemClock_Now();
-  // EXPECT_FALSE(
-  //     pw_sync_Mutex_CallTryLockFor(&mutex, kRoundedArbitraryDurationInC));
-  // time_elapsed =
-  //    pw_chrono_SystemClock_TimeElapsed(before, pw_chrono_SystemClock_Now());
-  // EXPECT_GE(time_elapsed.ticks, kRoundedArbitraryDurationInC.ticks);
-
-  pw_sync_Mutex_CallUnlock(&mutex);
-}
-
-TEST(Mutex, TryLockUnlockUntilInC) {
-  pw::sync::Mutex mutex;
-  pw_chrono_SystemClock_TimePoint deadline;
-  deadline.duration_since_epoch.ticks =
-      pw_chrono_SystemClock_Now().duration_since_epoch.ticks +
-      kRoundedArbitraryDurationInC.ticks;
-  ASSERT_TRUE(pw_sync_Mutex_CallTryLockUntil(&mutex, deadline));
-  EXPECT_LT(pw_chrono_SystemClock_Now().duration_since_epoch.ticks,
-            deadline.duration_since_epoch.ticks);
-
-  // TODO(pwbug/291): Ensure it blocks fails to lock when already held.
-  // EXPECT_FALSE(pw_sync_Mutex_CallTryLockUntil(&mutex, deadline));
-  // EXPECT_GE(pw_chrono_SystemClock_Now().duration_since_epoch.ticks,
-  //           deadline.duration_since_epoch.ticks);
-
-  mutex.unlock();
-}
-
 }  // namespace
 }  // namespace pw::sync
diff --git a/pw_sync/mutex_facade_test_c.c b/pw_sync/mutex_facade_test_c.c
index 5b1e631..5196d51 100644
--- a/pw_sync/mutex_facade_test_c.c
+++ b/pw_sync/mutex_facade_test_c.c
@@ -25,16 +25,6 @@
   return pw_sync_Mutex_TryLock(mutex);
 }
 
-bool pw_sync_Mutex_CallTryLockFor(pw_sync_Mutex* mutex,
-                                  pw_chrono_SystemClock_Duration for_at_least) {
-  return pw_sync_Mutex_TryLockFor(mutex, for_at_least);
-}
-
-bool pw_sync_Mutex_CallTryLockUntil(
-    pw_sync_Mutex* mutex, pw_chrono_SystemClock_TimePoint until_at_least) {
-  return pw_sync_Mutex_TryLockUntil(mutex, until_at_least);
-}
-
 void pw_sync_Mutex_CallUnlock(pw_sync_Mutex* mutex) {
   pw_sync_Mutex_Unlock(mutex);
 }
diff --git a/pw_sync/public/pw_sync/mutex.h b/pw_sync/public/pw_sync/mutex.h
index c451581..ef4f220 100644
--- a/pw_sync/public/pw_sync/mutex.h
+++ b/pw_sync/public/pw_sync/mutex.h
@@ -15,7 +15,6 @@
 
 #include <stdbool.h>
 
-#include "pw_chrono/system_clock.h"
 #include "pw_preprocessor/util.h"
 
 #ifdef __cplusplus
@@ -60,24 +59,6 @@
   //   undefined behavior.
   bool try_lock();
 
-  // Attempts to lock the mutex where, if needed, blocking for at least the
-  // specified duration.
-  // Returns true if the mutex was successfully acquired.
-  //
-  // PRECONDITION:
-  //   The lock isn't already held by this thread. Recursive locking is
-  //   undefined behavior.
-  bool try_lock_for(chrono::SystemClock::duration for_at_least);
-
-  // Attempts to lock the mutex where, if needed, blocking until at least the
-  // specified time_point.
-  // Returns true if the mutex was successfully acquired.
-  //
-  // PRECONDITION:
-  //   The lock isn't already held by this thread. Recursive locking is
-  //   undefined behavior.
-  bool try_lock_until(chrono::SystemClock::time_point until_at_least);
-
   // Unlocks the mutex. Failures are fatal.
   //
   // PRECONDITION:
@@ -107,10 +88,6 @@
 
 void pw_sync_Mutex_Lock(pw_sync_Mutex* mutex);
 bool pw_sync_Mutex_TryLock(pw_sync_Mutex* mutex);
-bool pw_sync_Mutex_TryLockFor(pw_sync_Mutex* mutex,
-                              pw_chrono_SystemClock_Duration for_at_least);
-bool pw_sync_Mutex_TryLockUntil(pw_sync_Mutex* mutex,
-                                pw_chrono_SystemClock_TimePoint until_at_least);
 void pw_sync_Mutex_Unlock(pw_sync_Mutex* mutex);
 
 PW_EXTERN_C_END
diff --git a/pw_sync/public/pw_sync/timed_mutex.h b/pw_sync/public/pw_sync/timed_mutex.h
new file mode 100644
index 0000000..7774c8f
--- /dev/null
+++ b/pw_sync/public/pw_sync/timed_mutex.h
@@ -0,0 +1,87 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+#pragma once
+
+#include <stdbool.h>
+
+#include "pw_chrono/system_clock.h"
+#include "pw_preprocessor/util.h"
+#include "pw_sync/mutex.h"
+
+#ifdef __cplusplus
+
+namespace pw::sync {
+
+// The TimedMutex is a synchronization primitive that can be used to protect
+// shared data from being simultaneously accessed by multiple threads with
+// timeouts and deadlines, extending the Mutex.
+// It offers exclusive, non-recursive ownership semantics where priority
+// inheritance is used to solve the classic priority-inversion problem.
+// This is thread safe, but NOT IRQ safe.
+//
+// WARNING: In order to support global statically constructed TimedMutexes, the
+// user and/or backend MUST ensure that any initialization required in your
+// environment is done prior to the creation and/or initialization of the native
+// synchronization primitives (e.g. kernel initialization).
+class TimedMutex : public Mutex {
+ public:
+  TimedMutex() = default;
+  ~TimedMutex() = default;
+  TimedMutex(const TimedMutex&) = delete;
+  TimedMutex(TimedMutex&&) = delete;
+  TimedMutex& operator=(const TimedMutex&) = delete;
+  TimedMutex& operator=(TimedMutex&&) = delete;
+
+  // Attempts to lock the mutex where, if needed, blocking for at least the
+  // specified duration.
+  // Returns true if the mutex was successfully acquired.
+  //
+  // PRECONDITION:
+  //   The lock isn't already held by this thread. Recursive locking is
+  //   undefined behavior.
+  bool try_lock_for(chrono::SystemClock::duration for_at_least);
+
+  // Attempts to lock the mutex where, if needed, blocking until at least the
+  // specified time_point.
+  // Returns true if the mutex was successfully acquired.
+  //
+  // PRECONDITION:
+  //   The lock isn't already held by this thread. Recursive locking is
+  //   undefined behavior.
+  bool try_lock_until(chrono::SystemClock::time_point until_at_least);
+};
+
+}  // namespace pw::sync
+
+#include "pw_sync_backend/timed_mutex_inline.h"
+
+using pw_sync_TimedMutex = pw::sync::TimedMutex;
+
+#else  // !defined(__cplusplus)
+
+typedef struct pw_sync_TimedMutex pw_sync_TimedMutex;
+
+#endif  // __cplusplus
+
+PW_EXTERN_C_START
+
+void pw_sync_TimedMutex_Lock(pw_sync_TimedMutex* mutex);
+bool pw_sync_TimedMutex_TryLock(pw_sync_TimedMutex* mutex);
+bool pw_sync_TimedMutex_TryLockFor(pw_sync_TimedMutex* mutex,
+                                   pw_chrono_SystemClock_Duration for_at_least);
+bool pw_sync_TimedMutex_TryLockUntil(
+    pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_TimePoint until_at_least);
+void pw_sync_TimedMutex_Unlock(pw_sync_TimedMutex* mutex);
+
+PW_EXTERN_C_END
diff --git a/pw_sync/timed_mutex.cc b/pw_sync/timed_mutex.cc
new file mode 100644
index 0000000..512d4c4
--- /dev/null
+++ b/pw_sync/timed_mutex.cc
@@ -0,0 +1,40 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+
+#include "pw_sync/timed_mutex.h"
+
+using pw::chrono::SystemClock;
+
+extern "C" void pw_sync_TimedMutex_Lock(pw_sync_TimedMutex* mutex) {
+  mutex->lock();
+}
+
+extern "C" bool pw_sync_TimedMutex_TryLock(pw_sync_TimedMutex* mutex) {
+  return mutex->try_lock();
+}
+
+extern "C" bool pw_sync_TimedMutex_TryLockFor(
+    pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_Duration for_at_least) {
+  return mutex->try_lock_for(SystemClock::duration(for_at_least.ticks));
+}
+
+extern "C" bool pw_sync_TimedMutex_TryLockUntil(
+    pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_TimePoint until_at_least) {
+  return mutex->try_lock_until(SystemClock::time_point(
+      SystemClock::duration(until_at_least.duration_since_epoch.ticks)));
+}
+
+extern "C" void pw_sync_TimedMutex_Unlock(pw_sync_TimedMutex* mutex) {
+  mutex->unlock();
+}
diff --git a/pw_sync/timed_mutex_facade_test.cc b/pw_sync/timed_mutex_facade_test.cc
new file mode 100644
index 0000000..7b81d99
--- /dev/null
+++ b/pw_sync/timed_mutex_facade_test.cc
@@ -0,0 +1,162 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+
+#include <chrono>
+
+#include "gtest/gtest.h"
+#include "pw_chrono/system_clock.h"
+#include "pw_sync/timed_mutex.h"
+
+using pw::chrono::SystemClock;
+using namespace std::chrono_literals;
+
+namespace pw::sync {
+namespace {
+
+extern "C" {
+
+// Functions defined in mutex_facade_test_c.c which call the API from C.
+void pw_sync_TimedMutex_CallLock(pw_sync_TimedMutex* mutex);
+bool pw_sync_TimedMutex_CallTryLock(pw_sync_TimedMutex* mutex);
+bool pw_sync_TimedMutex_CallTryLockFor(
+    pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_Duration for_at_least);
+bool pw_sync_TimedMutex_CallTryLockUntil(
+    pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_TimePoint until_at_least);
+void pw_sync_TimedMutex_CallUnlock(pw_sync_TimedMutex* mutex);
+
+}  // extern "C"
+
+// We can't control the SystemClock's period configuration, so just in case
+// duration cannot be accurately expressed in integer ticks, round the
+// duration up.
+constexpr SystemClock::duration kRoundedArbitraryDuration =
+    SystemClock::for_at_least(42ms);
+constexpr pw_chrono_SystemClock_Duration kRoundedArbitraryDurationInC =
+    PW_SYSTEM_CLOCK_MS(42);
+
+// TODO(pwbug/291): Add real concurrency tests once we have pw::thread.
+
+TEST(TimedMutex, LockUnlock) {
+  pw::sync::TimedMutex mutex;
+  mutex.lock();
+  // TODO(pwbug/291): Ensure it fails to lock when already held.
+  // EXPECT_FALSE(mutex.try_lock());
+  mutex.unlock();
+}
+
+TimedMutex static_mutex;
+TEST(TimedMutex, LockUnlockStatic) {
+  static_mutex.lock();
+  // TODO(pwbug/291): Ensure it fails to lock when already held.
+  // EXPECT_FALSE(static_mutex.try_lock());
+  static_mutex.unlock();
+}
+
+TEST(TimedMutex, TryLockUnlock) {
+  pw::sync::TimedMutex mutex;
+  ASSERT_TRUE(mutex.try_lock());
+  // TODO(pwbug/291): Ensure it fails to lock when already held.
+  // EXPECT_FALSE(mutex.try_lock());
+  mutex.unlock();
+}
+
+TEST(TimedMutex, TryLockUnlockFor) {
+  pw::sync::TimedMutex mutex;
+
+  SystemClock::time_point before = SystemClock::now();
+  ASSERT_TRUE(mutex.try_lock_for(kRoundedArbitraryDuration));
+  SystemClock::duration time_elapsed = SystemClock::now() - before;
+  EXPECT_LT(time_elapsed, kRoundedArbitraryDuration);
+
+  // TODO(pwbug/291): Ensure it blocks fails to lock when already held.
+  // before = SystemClock::now();
+  // EXPECT_FALSE(mutex.try_lock_for(kRoundedArbitraryDuration));
+  // time_elapsed = SystemClock::now() - before;
+  /// EXPECT_GE(time_elapsed, kRoundedArbitraryDuration);
+
+  mutex.unlock();
+}
+
+TEST(TimedMutex, TryLockUnlockUntil) {
+  pw::sync::TimedMutex mutex;
+
+  const SystemClock::time_point deadline =
+      SystemClock::now() + kRoundedArbitraryDuration;
+  ASSERT_TRUE(mutex.try_lock_until(deadline));
+  EXPECT_LT(SystemClock::now(), deadline);
+
+  // TODO(pwbug/291): Ensure it blocks fails to lock when already held.
+  // EXPECT_FALSE(
+  //     mutex.try_lock_until(SystemClock::now() + kRoundedArbitraryDuration));
+  // EXPECT_GE(SystemClock::now(), deadline);
+
+  mutex.unlock();
+}
+
+TEST(TimedMutex, LockUnlockInC) {
+  pw::sync::TimedMutex mutex;
+  pw_sync_TimedMutex_CallLock(&mutex);
+  pw_sync_TimedMutex_CallUnlock(&mutex);
+}
+
+TEST(TimedMutex, TryLockUnlockInC) {
+  pw::sync::TimedMutex mutex;
+  ASSERT_TRUE(pw_sync_TimedMutex_CallTryLock(&mutex));
+  // TODO(pwbug/291): Ensure it fails to lock when already held.
+  // EXPECT_FALSE(pw_sync_TimedMutex_CallTryLock(&mutex));
+  pw_sync_TimedMutex_CallUnlock(&mutex);
+}
+
+TEST(TimedMutex, TryLockUnlockForInC) {
+  pw::sync::TimedMutex mutex;
+
+  pw_chrono_SystemClock_TimePoint before = pw_chrono_SystemClock_Now();
+  ASSERT_TRUE(
+      pw_sync_TimedMutex_CallTryLockFor(&mutex, kRoundedArbitraryDurationInC));
+  pw_chrono_SystemClock_Duration time_elapsed =
+      pw_chrono_SystemClock_TimeElapsed(before, pw_chrono_SystemClock_Now());
+  EXPECT_LT(time_elapsed.ticks, kRoundedArbitraryDurationInC.ticks);
+
+  // TODO(pwbug/291): Ensure it blocks fails to lock when already held.
+  // before = pw_chrono_SystemClock_Now();
+  // EXPECT_FALSE(
+  //     pw_sync_TimedMutex_CallTryLockFor(&mutex,
+  //     kRoundedArbitraryDurationInC));
+  // time_elapsed =
+  //    pw_chrono_SystemClock_TimeElapsed(before, pw_chrono_SystemClock_Now());
+  // EXPECT_GE(time_elapsed.ticks, kRoundedArbitraryDurationInC.ticks);
+
+  pw_sync_TimedMutex_CallUnlock(&mutex);
+}
+
+TEST(TimedMutex, TryLockUnlockUntilInC) {
+  pw::sync::TimedMutex mutex;
+  pw_chrono_SystemClock_TimePoint deadline;
+  deadline.duration_since_epoch.ticks =
+      pw_chrono_SystemClock_Now().duration_since_epoch.ticks +
+      kRoundedArbitraryDurationInC.ticks;
+  ASSERT_TRUE(pw_sync_TimedMutex_CallTryLockUntil(&mutex, deadline));
+  EXPECT_LT(pw_chrono_SystemClock_Now().duration_since_epoch.ticks,
+            deadline.duration_since_epoch.ticks);
+
+  // TODO(pwbug/291): Ensure it blocks fails to lock when already held.
+  // EXPECT_FALSE(pw_sync_TimedMutex_CallTryLockUntil(&mutex, deadline));
+  // EXPECT_GE(pw_chrono_SystemClock_Now().duration_since_epoch.ticks,
+  //           deadline.duration_since_epoch.ticks);
+
+  mutex.unlock();
+}
+
+}  // namespace
+}  // namespace pw::sync
diff --git a/pw_sync/timed_mutex_facade_test_c.c b/pw_sync/timed_mutex_facade_test_c.c
new file mode 100644
index 0000000..50f5dcb
--- /dev/null
+++ b/pw_sync/timed_mutex_facade_test_c.c
@@ -0,0 +1,42 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+
+// These tests call the pw_sync module mutex API from C. The return values are
+// checked in the main C++ tests.
+
+#include <stdbool.h>
+
+#include "pw_sync/timed_mutex.h"
+
+void pw_sync_TimedMutex_CallLock(pw_sync_TimedMutex* mutex) {
+  pw_sync_TimedMutex_Lock(mutex);
+}
+
+bool pw_sync_TimedMutex_CallTryLock(pw_sync_TimedMutex* mutex) {
+  return pw_sync_TimedMutex_TryLock(mutex);
+}
+
+bool pw_sync_TimedMutex_CallTryLockFor(
+    pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_Duration for_at_least) {
+  return pw_sync_TimedMutex_TryLockFor(mutex, for_at_least);
+}
+
+bool pw_sync_TimedMutex_CallTryLockUntil(
+    pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_TimePoint until_at_least) {
+  return pw_sync_TimedMutex_TryLockUntil(mutex, until_at_least);
+}
+
+void pw_sync_TimedMutex_CallUnlock(pw_sync_TimedMutex* mutex) {
+  pw_sync_TimedMutex_Unlock(mutex);
+}
diff --git a/pw_sync_embos/BUILD b/pw_sync_embos/BUILD
index 1adc21c..da66e9e 100644
--- a/pw_sync_embos/BUILD
+++ b/pw_sync_embos/BUILD
@@ -101,24 +101,51 @@
     deps = [
         # TODO(pwbug/317): This should depend on embOS but our third parties
         # currently do not have Bazel support.
-        "//pw_chrono:system_clock",
-        "//pw_chrono_embos:system_clock_headers",
+        "//pw_sync:mutex_facade",
     ],
 )
 
 pw_cc_library(
     name = "mutex",
-    srcs = [
-        "mutex.cc",
-    ],
     deps = [
         ":mutex_headers",
-        "//pw_interrupt:context",
         "//pw_sync:mutex_facade",
     ],
 )
 
 pw_cc_library(
+    name = "timed_mutex_headers",
+    hdrs = [
+        "public/pw_sync_embos/timed_mutex_inline.h",
+        "public_overrides/pw_sync_backend/timed_mutex_inline.h",
+    ],
+    includes = [
+        "public",
+        "public_overrides",
+    ],
+    deps = [
+        # TODO(pwbug/317): This should depend on embOS but our third parties
+        # currently do not have Bazel support.
+        "//pw_chrono:system_clock",
+        "//pw_sync:timed_mutex_facade",
+    ],
+)
+
+pw_cc_library(
+    name = "timed_mutex",
+    srcs = [
+        "timed_mutex.cc",
+    ],
+    deps = [
+        ":timed_mutex_headers",
+        "//pw_interrupt:context",
+        "//pw_sync:timed_mutex_facade",
+        "//pw_chrono_embos:system_clock_headers",
+    ],
+)
+
+
+pw_cc_library(
     name = "interrupt_spin_lock_headers",
     hdrs = [
         "public/pw_sync_embos/interrupt_spin_lock_inline.h",
diff --git a/pw_sync_embos/BUILD.gn b/pw_sync_embos/BUILD.gn
index 8d9a0f4..043ae72 100644
--- a/pw_sync_embos/BUILD.gn
+++ b/pw_sync_embos/BUILD.gn
@@ -98,13 +98,33 @@
   ]
   public_deps = [
     "$dir_pw_assert",
+    "$dir_pw_interrupt:context",
+    "$dir_pw_sync:mutex.facade",
+    "$dir_pw_third_party/embos",
+  ]
+}
+
+# This target provides the backend for pw::sync::TimedMutex.
+pw_source_set("timed_mutex") {
+  public_configs = [
+    ":public_include_path",
+    ":backend_config",
+  ]
+  public = [
+    "public/pw_sync_embos/timed_mutex_inline.h",
+    "public_overrides/pw_sync_backend/timed_mutex_inline.h",
+  ]
+  public_deps = [
     "$dir_pw_chrono:system_clock",
+    "$dir_pw_sync:timed_mutex.facade",
+  ]
+  sources = [ "timed_mutex.cc" ]
+  deps = [
+    "$dir_pw_assert",
     "$dir_pw_chrono_embos:system_clock",
     "$dir_pw_interrupt:context",
     "$dir_pw_third_party/embos",
   ]
-  sources = [ "mutex.cc" ]
-  deps = [ "$dir_pw_sync:mutex.facade" ]
   assert(
       pw_chrono_SYSTEM_CLOCK_BACKEND == "" ||
           pw_chrono_SYSTEM_CLOCK_BACKEND == "$dir_pw_chrono_embos:system_clock",
diff --git a/pw_sync_embos/public/pw_sync_embos/mutex_inline.h b/pw_sync_embos/public/pw_sync_embos/mutex_inline.h
index a8dd26e..9f8c147 100644
--- a/pw_sync_embos/public/pw_sync_embos/mutex_inline.h
+++ b/pw_sync_embos/public/pw_sync_embos/mutex_inline.h
@@ -15,8 +15,6 @@
 
 #include "RTOS.h"
 #include "pw_assert/light.h"
-#include "pw_chrono/system_clock.h"
-#include "pw_chrono_embos/system_clock_constants.h"
 #include "pw_interrupt/context.h"
 #include "pw_sync/mutex.h"
 
@@ -37,13 +35,6 @@
   return OS_Request(&native_type_) != 0;
 }
 
-inline bool Mutex::try_lock_until(
-    chrono::SystemClock::time_point until_at_least) {
-  // Note that if this deadline is in the future, it will get rounded up by
-  // one whole tick due to how try_lock_for is implemented.
-  return try_lock_for(until_at_least - chrono::SystemClock::now());
-}
-
 inline void Mutex::unlock() {
   PW_ASSERT(!interrupt::InInterruptContext());
   OS_Unuse(&native_type_);
diff --git a/pw_sync_embos/public/pw_sync_embos/timed_mutex_inline.h b/pw_sync_embos/public/pw_sync_embos/timed_mutex_inline.h
new file mode 100644
index 0000000..2ea7bff
--- /dev/null
+++ b/pw_sync_embos/public/pw_sync_embos/timed_mutex_inline.h
@@ -0,0 +1,28 @@
+// Copyright 2021 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+#pragma once
+
+#include "pw_chrono/system_clock.h"
+#include "pw_sync/timed_mutex.h"
+
+namespace pw::sync {
+
+inline bool TimedMutex::try_lock_until(
+    chrono::SystemClock::time_point until_at_least) {
+  // Note that if this deadline is in the future, it will get rounded up by
+  // one whole tick due to how try_lock_for is implemented.
+  return try_lock_for(until_at_least - chrono::SystemClock::now());
+}
+
+}  // namespace pw::sync
diff --git a/pw_sync_embos/public_overrides/pw_sync_backend/timed_mutex_inline.h b/pw_sync_embos/public_overrides/pw_sync_backend/timed_mutex_inline.h
new file mode 100644
index 0000000..467eb9f
--- /dev/null
+++ b/pw_sync_embos/public_overrides/pw_sync_backend/timed_mutex_inline.h
@@ -0,0 +1,16 @@
+// Copyright 2021 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+#pragma once
+
+#include "pw_sync_embos/timed_mutex_inline.h"
diff --git a/pw_sync_embos/mutex.cc b/pw_sync_embos/timed_mutex.cc
similarity index 87%
rename from pw_sync_embos/mutex.cc
rename to pw_sync_embos/timed_mutex.cc
index fb33d9f..c08bef4 100644
--- a/pw_sync_embos/mutex.cc
+++ b/pw_sync_embos/timed_mutex.cc
@@ -12,7 +12,7 @@
 // License for the specific language governing permissions and limitations under
 // the License.
 
-#include "pw_sync/mutex.h"
+#include "pw_sync/timed_mutex.h"
 
 #include <algorithm>
 
@@ -26,7 +26,7 @@
 
 namespace pw::sync {
 
-bool Mutex::try_lock_for(SystemClock::duration for_at_least) {
+bool TimedMutex::try_lock_for(SystemClock::duration for_at_least) {
   PW_DCHECK(!interrupt::InInterruptContext());
 
   // Use non-blocking try_lock for negative and zero length durations.
@@ -40,7 +40,7 @@
       pw::chrono::embos::kMaxTimeout - SystemClock::duration(1);
   while (for_at_least > kMaxTimeoutMinusOne) {
     const int lock_count = OS_UseTimed(
-        &native_type_, static_cast<OS_TIME>(kMaxTimeoutMinusOne.count()));
+        &native_handle(), static_cast<OS_TIME>(kMaxTimeoutMinusOne.count()));
     if (lock_count != 0) {
       PW_CHECK_UINT_EQ(1, lock_count, "Recursive locking is not permitted");
       return true;
@@ -48,7 +48,7 @@
     for_at_least -= kMaxTimeoutMinusOne;
   }
   const int lock_count = OS_UseTimed(
-      &native_type_, static_cast<OS_TIME>(for_at_least.count() + 1));
+      &native_handle(), static_cast<OS_TIME>(for_at_least.count() + 1));
   PW_CHECK_UINT_LE(1, lock_count, "Recursive locking is not permitted");
   return lock_count == 1;
 }
diff --git a/pw_sync_freertos/BUILD b/pw_sync_freertos/BUILD
index f82c95a..7ad2759 100644
--- a/pw_sync_freertos/BUILD
+++ b/pw_sync_freertos/BUILD
@@ -100,24 +100,50 @@
     deps = [
         # TODO: This should depend on FreeRTOS but our third parties currently
         # do not have Bazel support.
-        "//pw_chrono:system_clock",
-        "//pw_chrono_freertos:system_clock_headers",
+        "//pw_sync:mutex_facade",
     ],
 )
 
 pw_cc_library(
     name = "mutex",
-    srcs = [
-        "mutex.cc",
-    ],
     deps = [
         ":mutex_headers",
-        "//pw_interrupt:context",
         "//pw_sync:mutex_facade",
     ],
 )
 
 pw_cc_library(
+    name = "timed_mutex_headers",
+    hdrs = [
+        "public/pw_sync_freertos/timed_mutex_inline.h",
+        "public_overrides/pw_sync_backend/timed_mutex_inline.h",
+    ],
+    includes = [
+        "public",
+        "public_overrides",
+    ],
+    deps = [
+        # TODO: This should depend on FreeRTOS but our third parties currently
+        # do not have Bazel support.
+        "//pw_chrono:system_clock",
+        "//pw_chrono_freertos:system_clock_headers",
+        "//pw_sync:timed_mutex_facade",
+    ],
+)
+
+pw_cc_library(
+    name = "timed_mutex",
+    srcs = [
+        "timed_mutex.cc",
+    ],
+    deps = [
+        ":timed_mutex_headers",
+        "//pw_interrupt:context",
+        "//pw_sync:timed_mutex_facade",
+    ],
+)
+
+pw_cc_library(
     name = "interrupt_spin_lock_headers",
     hdrs = [
         "public/pw_sync_freertos/interrupt_spin_lock_inline.h",
diff --git a/pw_sync_freertos/BUILD.gn b/pw_sync_freertos/BUILD.gn
index 20782e3..425ef4a 100644
--- a/pw_sync_freertos/BUILD.gn
+++ b/pw_sync_freertos/BUILD.gn
@@ -98,13 +98,33 @@
   ]
   public_deps = [
     "$dir_pw_assert",
+    "$dir_pw_interrupt:context",
+    "$dir_pw_sync:mutex.facade",
+    "$dir_pw_third_party/freertos",
+  ]
+}
+
+# This target provides the backend for pw::sync::TimedMutex.
+pw_source_set("timed_mutex") {
+  public_configs = [
+    ":public_include_path",
+    ":backend_config",
+  ]
+  public = [
+    "public/pw_sync_freertos/timed_mutex_inline.h",
+    "public_overrides/pw_sync_backend/timed_mutex_inline.h",
+  ]
+  public_deps = [
     "$dir_pw_chrono:system_clock",
+    "$dir_pw_sync:timed_mutex.facade",
+  ]
+  sources = [ "timed_mutex.cc" ]
+  deps = [
+    "$dir_pw_assert",
     "$dir_pw_chrono_freertos:system_clock",
     "$dir_pw_interrupt:context",
     "$dir_pw_third_party/freertos",
   ]
-  sources = [ "mutex.cc" ]
-  deps = [ "$dir_pw_sync:mutex.facade" ]
   assert(pw_chrono_SYSTEM_CLOCK_BACKEND == "" ||
              pw_chrono_SYSTEM_CLOCK_BACKEND ==
                  "$dir_pw_chrono_freertos:system_clock",
diff --git a/pw_sync_freertos/public/pw_sync_freertos/mutex_inline.h b/pw_sync_freertos/public/pw_sync_freertos/mutex_inline.h
index 534e9ce..92f7c07 100644
--- a/pw_sync_freertos/public/pw_sync_freertos/mutex_inline.h
+++ b/pw_sync_freertos/public/pw_sync_freertos/mutex_inline.h
@@ -15,13 +15,19 @@
 
 #include "FreeRTOS.h"
 #include "pw_assert/light.h"
-#include "pw_chrono/system_clock.h"
-#include "pw_chrono_freertos/system_clock_constants.h"
 #include "pw_interrupt/context.h"
 #include "pw_sync/mutex.h"
 #include "semphr.h"
 
 namespace pw::sync {
+namespace backend {
+
+static_assert(configUSE_MUTEXES != 0, "FreeRTOS mutexes aren't enabled.");
+
+static_assert(configSUPPORT_STATIC_ALLOCATION != 0,
+              "FreeRTOS static allocations are required for this backend.");
+
+}  // namespace backend
 
 inline Mutex::Mutex() : native_type_() {
   const SemaphoreHandle_t handle = xSemaphoreCreateMutexStatic(&native_type_);
@@ -51,13 +57,6 @@
   return xSemaphoreTake(&native_type_, 0) == pdTRUE;
 }
 
-inline bool Mutex::try_lock_until(
-    chrono::SystemClock::time_point until_at_least) {
-  // Note that if this deadline is in the future, it will get rounded up by
-  // one whole tick due to how try_lock_for is implemented.
-  return try_lock_for(until_at_least - chrono::SystemClock::now());
-}
-
 inline void Mutex::unlock() {
   PW_ASSERT(!interrupt::InInterruptContext());
   // Unlocking only fails if it was not locked first.
diff --git a/pw_sync_freertos/public/pw_sync_freertos/timed_mutex_inline.h b/pw_sync_freertos/public/pw_sync_freertos/timed_mutex_inline.h
new file mode 100644
index 0000000..bc114b9
--- /dev/null
+++ b/pw_sync_freertos/public/pw_sync_freertos/timed_mutex_inline.h
@@ -0,0 +1,28 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+#pragma once
+
+#include "pw_chrono/system_clock.h"
+#include "pw_sync/timed_mutex.h"
+
+namespace pw::sync {
+
+inline bool TimedMutex::try_lock_until(
+    chrono::SystemClock::time_point until_at_least) {
+  // Note that if this deadline is in the future, it will get rounded up by
+  // one whole tick due to how try_lock_for is implemented.
+  return try_lock_for(until_at_least - chrono::SystemClock::now());
+}
+
+}  // namespace pw::sync
diff --git a/pw_sync_freertos/public_overrides/pw_sync_backend/timed_mutex_inline.h b/pw_sync_freertos/public_overrides/pw_sync_backend/timed_mutex_inline.h
new file mode 100644
index 0000000..e833723
--- /dev/null
+++ b/pw_sync_freertos/public_overrides/pw_sync_backend/timed_mutex_inline.h
@@ -0,0 +1,16 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+#pragma once
+
+#include "pw_sync_freertos/timed_mutex_inline.h"
diff --git a/pw_sync_freertos/mutex.cc b/pw_sync_freertos/timed_mutex.cc
similarity index 80%
rename from pw_sync_freertos/mutex.cc
rename to pw_sync_freertos/timed_mutex.cc
index 7cdfef5..0143b84 100644
--- a/pw_sync_freertos/mutex.cc
+++ b/pw_sync_freertos/timed_mutex.cc
@@ -12,7 +12,7 @@
 // License for the specific language governing permissions and limitations under
 // the License.
 
-#include "pw_sync/mutex.h"
+#include "pw_sync/timed_mutex.h"
 
 #include <algorithm>
 
@@ -26,16 +26,8 @@
 using pw::chrono::SystemClock;
 
 namespace pw::sync {
-namespace {
 
-static_assert(configUSE_MUTEXES != 0, "FreeRTOS mutexes aren't enabled.");
-
-static_assert(configSUPPORT_STATIC_ALLOCATION != 0,
-              "FreeRTOS static allocations are required for this backend.");
-
-}  // namespace
-
-bool Mutex::try_lock_for(SystemClock::duration for_at_least) {
+bool TimedMutex::try_lock_for(SystemClock::duration for_at_least) {
   PW_DCHECK(!interrupt::InInterruptContext());
 
   // Use non-blocking try_acquire for negative and zero length durations.
@@ -48,14 +40,14 @@
   constexpr SystemClock::duration kMaxTimeoutMinusOne =
       pw::chrono::freertos::kMaxTimeout - SystemClock::duration(1);
   while (for_at_least > kMaxTimeoutMinusOne) {
-    if (xSemaphoreTake(&native_type_,
+    if (xSemaphoreTake(&native_handle(),
                        static_cast<TickType_t>(kMaxTimeoutMinusOne.count())) ==
         pdTRUE) {
       return true;
     }
     for_at_least -= kMaxTimeoutMinusOne;
   }
-  return xSemaphoreTake(&native_type_,
+  return xSemaphoreTake(&native_handle(),
                         static_cast<TickType_t>(for_at_least.count() + 1)) ==
          pdTRUE;
 }
diff --git a/pw_sync_stl/BUILD b/pw_sync_stl/BUILD
index 9ee8784..c2f39a7 100644
--- a/pw_sync_stl/BUILD
+++ b/pw_sync_stl/BUILD
@@ -92,7 +92,7 @@
         "public_overrides",
     ],
     deps = [
-        "//pw_chrono:system_clock",
+        "//pw_sync:mutex_facade",
     ],
 )
 
@@ -100,12 +100,35 @@
     name = "mutex",
     deps = [
         ":mutex_headers",
-        "//pw_chrono:system_clock",
         "//pw_sync:mutex_facade",
     ],
 )
 
 pw_cc_library(
+    name = "timed_mutex_headers",
+    hdrs = [
+        "public/pw_sync_stl/timed_mutex_inline.h",
+        "public_overrides/pw_sync_backend/timed_mutex_inline.h",
+    ],
+    includes = [
+        "public",
+        "public_overrides",
+    ],
+    deps = [
+        "//pw_chrono:system_clock",
+        "//pw_sync:timed_mutex_facade",
+    ],
+)
+
+pw_cc_library(
+    name = "timed_mutex",
+    deps = [
+        ":timed_mutex_headers",
+        "//pw_sync:timed_mutex_facade",
+    ],
+)
+
+pw_cc_library(
     name = "interrupt_spin_lock_headers",
     hdrs = [
         "public/pw_sync_stl/interrupt_spin_lock_inline.h",
diff --git a/pw_sync_stl/BUILD.gn b/pw_sync_stl/BUILD.gn
index 2e71713..0b7e56b 100644
--- a/pw_sync_stl/BUILD.gn
+++ b/pw_sync_stl/BUILD.gn
@@ -90,14 +90,25 @@
     "public_overrides/pw_sync_backend/mutex_inline.h",
     "public_overrides/pw_sync_backend/mutex_native.h",
   ]
-  deps = [
-    "$dir_pw_chrono:system_clock",
-    "$dir_pw_sync:mutex.facade",
+  public_deps = [ "$dir_pw_sync:mutex.facade" ]
+}
+
+# This target provides the backend for pw::sync::TimedMutex.
+pw_source_set("timed_mutex_backend") {
+  public_configs = [
+    ":public_include_path",
+    ":backend_config",
   ]
+  public = [
+    "$dir_pw_sync:timed_mutex.facade",
+    "public/pw_sync_stl/timed_mutex_inline.h",
+    "public_overrides/pw_sync_backend/timed_mutex_inline.h",
+  ]
+  public_deps = [ "$dir_pw_chrono:system_clock" ]
   assert(
       pw_chrono_SYSTEM_CLOCK_BACKEND == "" ||
           pw_chrono_SYSTEM_CLOCK_BACKEND == "$dir_pw_chrono_stl:system_clock",
-      "The STL pw::sync::Mutex backend only works with the STL " +
+      "The STL pw::sync::TimedMutex backend only works with the STL " +
           "pw::chrono::SystemClock backend.")
 }
 
diff --git a/pw_sync_stl/public/pw_sync_stl/mutex_inline.h b/pw_sync_stl/public/pw_sync_stl/mutex_inline.h
index b4459eb..88548c4 100644
--- a/pw_sync_stl/public/pw_sync_stl/mutex_inline.h
+++ b/pw_sync_stl/public/pw_sync_stl/mutex_inline.h
@@ -13,7 +13,6 @@
 // the License.
 #pragma once
 
-#include "pw_chrono/system_clock.h"
 #include "pw_sync/mutex.h"
 
 namespace pw::sync {
@@ -26,15 +25,6 @@
 
 inline bool Mutex::try_lock() { return native_type_.try_lock(); }
 
-inline bool Mutex::try_lock_for(chrono::SystemClock::duration for_at_least) {
-  return native_type_.try_lock_for(for_at_least);
-}
-
-inline bool Mutex::try_lock_until(
-    chrono::SystemClock::time_point until_at_least) {
-  return native_type_.try_lock_until(until_at_least);
-}
-
 inline void Mutex::unlock() { native_type_.unlock(); }
 
 inline Mutex::native_handle_type Mutex::native_handle() { return native_type_; }
diff --git a/pw_sync_stl/public/pw_sync_stl/timed_mutex_inline.h b/pw_sync_stl/public/pw_sync_stl/timed_mutex_inline.h
new file mode 100644
index 0000000..5bfd340
--- /dev/null
+++ b/pw_sync_stl/public/pw_sync_stl/timed_mutex_inline.h
@@ -0,0 +1,31 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+#pragma once
+
+#include "pw_chrono/system_clock.h"
+#include "pw_sync/mutex.h"
+
+namespace pw::sync {
+
+inline bool TimedMutex::try_lock_for(
+    chrono::SystemClock::duration for_at_least) {
+  return native_handle().try_lock_for(for_at_least);
+}
+
+inline bool TimedMutex::try_lock_until(
+    chrono::SystemClock::time_point until_at_least) {
+  return native_handle().try_lock_until(until_at_least);
+}
+
+}  // namespace pw::sync
diff --git a/pw_sync_stl/public_overrides/pw_sync_backend/timed_mutex_inline.h b/pw_sync_stl/public_overrides/pw_sync_backend/timed_mutex_inline.h
new file mode 100644
index 0000000..e8ddcc1
--- /dev/null
+++ b/pw_sync_stl/public_overrides/pw_sync_backend/timed_mutex_inline.h
@@ -0,0 +1,16 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+#pragma once
+
+#include "pw_sync_stl/timed_mutex_inline.h"
diff --git a/pw_sync_threadx/BUILD b/pw_sync_threadx/BUILD
index 837ed0f..b9129f9 100644
--- a/pw_sync_threadx/BUILD
+++ b/pw_sync_threadx/BUILD
@@ -100,20 +100,46 @@
     deps = [
         # TODO: This should depend on ThreadX but our third parties currently
         # do not have Bazel support.
-        "//pw_chrono:system_clock",
+        "//pw_sync:mutex_facade",
     ],
 )
 
 pw_cc_library(
     name = "mutex",
-    srcs = [
-        "mutex.cc",
-    ],
     deps = [
         ":mutex_headers",
+        "//pw_sync:mutex_facade",
+    ],
+)
+
+pw_cc_library(
+    name = "timed_mutex_headers",
+    hdrs = [
+        "public/pw_sync_threadx/timed_mutex_inline.h",
+        "public_overrides/pw_sync_backend/timed_mutex_inline.h",
+    ],
+    includes = [
+        "public",
+        "public_overrides",
+    ],
+    deps = [
+        # TODO: This should depend on ThreadX but our third parties currently
+        # do not have Bazel support.
+        "//pw_chrono:system_clock",
+        "//pw_sync:timed_mutex_facade",
+    ],
+)
+
+pw_cc_library(
+    name = "timed_mutex",
+    srcs = [
+        "timed_mutex.cc",
+    ],
+    deps = [
+        ":timed_mutex_headers",
         "//pw_chrono_threadx:system_clock_headers",
         "//pw_interrupt:context",
-        "//pw_sync:mutex_facade",
+        "//pw_sync:timed_mutex_facade",
     ],
 )
 
diff --git a/pw_sync_threadx/BUILD.gn b/pw_sync_threadx/BUILD.gn
index 41d5b32..b02d757 100644
--- a/pw_sync_threadx/BUILD.gn
+++ b/pw_sync_threadx/BUILD.gn
@@ -29,6 +29,26 @@
   visibility = [ ":*" ]
 }
 
+# This target provides the backend for pw::sync::Mutex.
+pw_source_set("mutex") {
+  public_configs = [
+    ":public_include_path",
+    ":backend_config",
+  ]
+  public = [
+    "public/pw_sync_threadx/mutex_inline.h",
+    "public/pw_sync_threadx/mutex_native.h",
+    "public_overrides/pw_sync_backend/mutex_inline.h",
+    "public_overrides/pw_sync_backend/mutex_native.h",
+  ]
+  public_deps = [
+    "$dir_pw_assert",
+    "$dir_pw_interrupt:context",
+    "$dir_pw_sync:mutex.facade",
+    "$dir_pw_third_party/threadx",
+  ]
+}
+
 if (pw_chrono_SYSTEM_CLOCK_BACKEND != "") {
   # This target provides the backend for pw::sync::BinarySemaphore.
   pw_source_set("binary_semaphore") {
@@ -91,27 +111,25 @@
                "the ThreadX pw::chrono::SystemClock backend.")
   }
 
-  # This target provides the backend for pw::sync::Mutex.
-  pw_source_set("mutex") {
+  # This target provides the backend for pw::sync::TimedMutex.
+  pw_source_set("timed_mutex") {
     public_configs = [
       ":public_include_path",
       ":backend_config",
     ]
     public = [
-      "public/pw_sync_threadx/mutex_inline.h",
-      "public/pw_sync_threadx/mutex_native.h",
-      "public_overrides/pw_sync_backend/mutex_inline.h",
-      "public_overrides/pw_sync_backend/mutex_native.h",
+      "public/pw_sync_threadx/timed_mutex_inline.h",
+      "public_overrides/pw_sync_backend/timed_mutex_inline.h",
     ]
     public_deps = [
-      "$dir_pw_assert",
       "$dir_pw_chrono:system_clock",
+      "$dir_pw_sync:timed_mutex.facade",
+    ]
+    sources = [ "timed_mutex.cc" ]
+    deps = [
+      "$dir_pw_assert",
       "$dir_pw_interrupt:context",
       "$dir_pw_third_party/threadx",
-    ]
-    sources = [ "mutex.cc" ]
-    deps = [
-      "$dir_pw_sync:mutex.facade",
       pw_chrono_SYSTEM_CLOCK_BACKEND,
     ]
     assert(pw_sync_OVERRIDE_SYSTEM_CLOCK_BACKEND_CHECK ||
diff --git a/pw_sync_threadx/public/pw_sync_threadx/mutex_inline.h b/pw_sync_threadx/public/pw_sync_threadx/mutex_inline.h
index af537bf..564b24e 100644
--- a/pw_sync_threadx/public/pw_sync_threadx/mutex_inline.h
+++ b/pw_sync_threadx/public/pw_sync_threadx/mutex_inline.h
@@ -14,7 +14,6 @@
 #pragma once
 
 #include "pw_assert/light.h"
-#include "pw_chrono/system_clock.h"
 #include "pw_interrupt/context.h"
 #include "pw_sync/mutex.h"
 #include "tx_api.h"
@@ -53,13 +52,6 @@
   return true;
 }
 
-inline bool Mutex::try_lock_until(
-    chrono::SystemClock::time_point until_at_least) {
-  // Note that if this deadline is in the future, it will get rounded up by
-  // one whole tick due to how try_lock_for is implemented.
-  return try_lock_for(until_at_least - chrono::SystemClock::now());
-}
-
 inline void Mutex::unlock() {
   // Enforce the pw::sync::Mutex IRQ contract.
   PW_ASSERT(!interrupt::InInterruptContext());
diff --git a/pw_sync_threadx/public/pw_sync_threadx/timed_mutex_inline.h b/pw_sync_threadx/public/pw_sync_threadx/timed_mutex_inline.h
new file mode 100644
index 0000000..8644046
--- /dev/null
+++ b/pw_sync_threadx/public/pw_sync_threadx/timed_mutex_inline.h
@@ -0,0 +1,28 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+#pragma once
+
+#include "pw_chrono/system_clock.h"
+#include "pw_sync/timed_mutex.h"
+
+namespace pw::sync {
+
+inline bool Mutex::try_lock_until(
+    chrono::SystemClock::time_point until_at_least) {
+  // Note that if this deadline is in the future, it will get rounded up by
+  // one whole tick due to how try_lock_for is implemented.
+  return try_lock_for(until_at_least - chrono::SystemClock::now());
+}
+
+}  // namespace pw::sync
diff --git a/pw_sync_threadx/public_overrides/pw_sync_backend/timed_mutex_inline.h b/pw_sync_threadx/public_overrides/pw_sync_backend/timed_mutex_inline.h
new file mode 100644
index 0000000..8bacb62
--- /dev/null
+++ b/pw_sync_threadx/public_overrides/pw_sync_backend/timed_mutex_inline.h
@@ -0,0 +1,16 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+#pragma once
+
+#include "pw_sync_threadx/timed_mutex_inline.h"
diff --git a/pw_sync_threadx/mutex.cc b/pw_sync_threadx/timed_mutex.cc
similarity index 92%
rename from pw_sync_threadx/mutex.cc
rename to pw_sync_threadx/timed_mutex.cc
index ce05399..92b14ed 100644
--- a/pw_sync_threadx/mutex.cc
+++ b/pw_sync_threadx/timed_mutex.cc
@@ -12,7 +12,7 @@
 // License for the specific language governing permissions and limitations under
 // the License.
 
-#include "pw_sync/mutex.h"
+#include "pw_sync/timed_mutex.h"
 
 #include <algorithm>
 
@@ -26,8 +26,8 @@
 
 namespace pw::sync {
 
-bool Mutex::try_lock_for(SystemClock::duration for_at_least) {
-  // Enforce the pw::sync::Mutex IRQ contract.
+bool TimedMutex::try_lock_for(SystemClock::duration for_at_least) {
+  // Enforce the pw::sync::TimedMutex IRQ contract.
   PW_DCHECK(!interrupt::InInterruptContext());
 
   // Use non-blocking try_lock for negative or zero length durations.
diff --git a/targets/host/target_toolchains.gni b/targets/host/target_toolchains.gni
index 7f3411a..6ff3789 100644
--- a/targets/host/target_toolchains.gni
+++ b/targets/host/target_toolchains.gni
@@ -87,6 +87,7 @@
   pw_sync_COUNTING_SEMAPHORE_BACKEND =
       "$dir_pw_sync_stl:counting_semaphore_backend"
   pw_sync_MUTEX_BACKEND = "$dir_pw_sync_stl:mutex_backend"
+  pw_sync_TIMED_MUTEX_BACKEND = "$dir_pw_sync_stl:timed_mutex_backend"
 
   # Configure backends for pw_thread's facades.
   pw_thread_ID_BACKEND = "$dir_pw_thread_stl:id"