diff --git a/pw_sync/BUILD.bazel b/pw_sync/BUILD.bazel
index cd0c326..079d8ca 100644
--- a/pw_sync/BUILD.bazel
+++ b/pw_sync/BUILD.bazel
@@ -388,6 +388,42 @@
     includes = ["public"],
 )
 
+pw_cc_facade(
+    name = "condition_variable_facade",
+    hdrs = [
+        "public/pw_sync/condition_variable.h",
+    ],
+    includes = ["public"],
+    deps = [
+        "//pw_chrono:system_clock",
+        "//pw_sync:mutex",
+    ],
+)
+
+# TODO(b/228998350): This needs to be instantiated for each platform that
+# provides an implementation of $dir_pw_thread:test_threads and
+# $dir_pw_sync:condition_variable.
+# pw_cc_library(
+#     name = "condition_variable_test",
+#     srcs = ["condition_variable_test.cc"],
+#     deps = [
+#         ":condition_variable_facade",
+#         "//pw_containers:vector",
+#         "//pw_sync:mutex",
+#         "//pw_sync:timed_thread_notification",
+#         "//pw_thread:sleep",
+#         "//pw_thread:test_threads_header",
+#         "//pw_thread:thread",
+#         "//pw_unit_test",
+#     ],
+# )
+#
+# Filegroup to mark `condition_variable_test.cc` as used for the linter:
+filegroup(
+    name = "condition_variable_test_filegroup",
+    srcs = ["condition_variable_test.cc"],
+)
+
 pw_cc_test(
     name = "borrow_test",
     srcs = [
diff --git a/pw_sync/BUILD.gn b/pw_sync/BUILD.gn
index 1f4dbf6..2da99c0 100644
--- a/pw_sync/BUILD.gn
+++ b/pw_sync/BUILD.gn
@@ -185,6 +185,16 @@
   public_configs = [ ":public_include_path" ]
 }
 
+pw_facade("condition_variable") {
+  backend = pw_sync_CONDITION_VARIABLE_BACKEND
+  public_configs = [ ":public_include_path" ]
+  public = [ "public/pw_sync/condition_variable.h" ]
+  public_deps = [
+    "$dir_pw_chrono:system_clock",
+    "$dir_pw_sync:mutex",
+  ]
+}
+
 pw_test_group("tests") {
   tests = [
     ":borrow_test",
@@ -304,6 +314,23 @@
   ]
 }
 
+# This needs to be instantiated per platform that provides
+# an implementation of $dir_pw_thread:test_threads and
+# $dir_pw_sync:condition_variable.
+pw_source_set("condition_variable_test") {
+  sources = [ "condition_variable_test.cc" ]
+  deps = [
+    ":condition_variable",
+    "$dir_pw_containers:vector",
+    "$dir_pw_sync:mutex",
+    "$dir_pw_sync:timed_thread_notification",
+    "$dir_pw_thread:sleep",
+    "$dir_pw_thread:test_threads",
+    "$dir_pw_thread:thread",
+    "$dir_pw_unit_test",
+  ]
+}
+
 pw_doc_group("docs") {
   sources = [ "docs.rst" ]
 }
diff --git a/pw_sync/CMakeLists.txt b/pw_sync/CMakeLists.txt
index 596a7f6..192a0b1 100644
--- a/pw_sync/CMakeLists.txt
+++ b/pw_sync/CMakeLists.txt
@@ -173,6 +173,16 @@
     public
 )
 
+pw_add_facade(pw_sync.condition_variable
+  HEADERS
+    public/pw_sync/condition_variable.h
+  PUBLIC_INCLUDES
+    public
+  PUBLIC_DEPS
+    pw_chrono.system_clock
+    pw_sync.mutex
+)
+
 pw_add_test(pw_sync.borrow_test
   SOURCES
     borrow_test.cc
@@ -284,3 +294,17 @@
       pw_sync
   )
 endif()
+
+pw_add_module_library(pw_sync.condition_variable_test
+  PUBLIC_DEPS
+    pw_sync.condition_variable
+    pw_containers.vector
+    pw_sync.mutex
+    pw_sync.timed_thread_notification
+    pw_thread.sleep
+    pw_thread.test_threads
+    pw_thread.thread
+    pw_unit_test
+  SOURCES
+    condition_variable_test.cc
+)
diff --git a/pw_sync/backend.gni b/pw_sync/backend.gni
index 6663972..2327640 100644
--- a/pw_sync/backend.gni
+++ b/pw_sync/backend.gni
@@ -16,6 +16,9 @@
   # Backend for the pw_sync module's binary semaphore.
   pw_sync_BINARY_SEMAPHORE_BACKEND = ""
 
+  # Backend for the pw_sync module's condition variable.
+  pw_sync_CONDITION_VARIABLE_BACKEND = ""
+
   # Backend for the pw_sync module's counting semaphore.
   pw_sync_COUNTING_SEMAPHORE_BACKEND = ""
 
diff --git a/pw_sync/condition_variable_test.cc b/pw_sync/condition_variable_test.cc
new file mode 100644
index 0000000..c0ddc4d
--- /dev/null
+++ b/pw_sync/condition_variable_test.cc
@@ -0,0 +1,356 @@
+// Copyright 2022 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/condition_variable.h"
+
+#include <chrono>
+#include <functional>
+
+#include "gtest/gtest.h"
+#include "pw_containers/vector.h"
+#include "pw_sync/mutex.h"
+#include "pw_sync/timed_thread_notification.h"
+#include "pw_thread/sleep.h"
+#include "pw_thread/test_threads.h"
+#include "pw_thread/thread.h"
+
+namespace pw::sync {
+namespace {
+
+using namespace std::chrono_literals;
+
+// A timeout for tests where successful behaviour involves waiting.
+constexpr auto kRequiredTimeout = 100ms;
+
+// Maximum extra wait time allowed for test that ensure something waits for
+// `kRequiredTimeout`.
+const auto kAllowedSlack = kRequiredTimeout * 1.5;
+
+// A timeout that should only be hit if something goes wrong.
+constexpr auto kFailureTimeout = 5s;
+
+using StateLock = std::unique_lock<Mutex>;
+
+struct ThreadInfo {
+  explicit ThreadInfo(int id) : thread_id(id) {}
+
+  // waiting_notifier is signalled in predicates to indicate that the predicate
+  // has been evaluated. This guarantees (via insider information) that the
+  // thread will acquire the internal ThreadNotification.
+  TimedThreadNotification waiting_notifier;
+
+  // Signals when the worker thread is done.
+  TimedThreadNotification done_notifier;
+
+  // The result of the predicate the worker thread uses with wait*(). Set from
+  // the main test thread and read by the worker thread.
+  bool predicate_result = false;
+
+  // Stores the result of ConditionVariable::wait_for() or ::wait_until() for
+  // use in test asserts.
+  bool wait_result = false;
+
+  // For use in recording the order in which threads block on a condition.
+  const int thread_id;
+
+  // Returns a function which will return the current value of
+  //`predicate_result` and release `waiting_notifier`.
+  std::function<bool()> Predicate() {
+    return [this]() {
+      bool result = this->predicate_result;
+      this->waiting_notifier.release();
+      return result;
+    };
+  }
+};
+
+// A `ThreadCore` implementation that delegates to an `std::function`.
+class LambdaThreadCore : public pw::thread::ThreadCore {
+ public:
+  explicit LambdaThreadCore(std::function<void()> work)
+      : work_(std::move(work)) {}
+
+ private:
+  void Run() override { work_(); }
+
+  std::function<void()> work_;
+};
+
+class LambdaThread {
+ public:
+  // Starts a new thread which runs `work`, joining the thread on destruction.
+  explicit LambdaThread(
+      std::function<void()> work,
+      pw::thread::Options options = pw::thread::test::TestOptionsThread0())
+      : thread_core_(std::move(work)), thread_(options, thread_core_) {}
+  ~LambdaThread() { thread_.join(); }
+  LambdaThread(const LambdaThread&) = delete;
+  LambdaThread(LambdaThread&&) = delete;
+  LambdaThread& operator=(const LambdaThread&) = delete;
+  LambdaThread&& operator=(LambdaThread&&) = delete;
+
+ private:
+  LambdaThreadCore thread_core_;
+  pw::thread::Thread thread_;
+};
+
+TEST(Wait, PredicateTrueNoWait) {
+  Mutex mutex;
+  ConditionVariable condvar;
+  ThreadInfo thread_info(0);
+
+  LambdaThread thread([&mutex, &condvar, &info = thread_info] {
+    StateLock l{mutex};
+    condvar.wait(l, [] { return true; });
+
+    info.done_notifier.release();
+  });
+  EXPECT_TRUE(thread_info.done_notifier.try_acquire_for(kFailureTimeout));
+}
+
+TEST(NotifyOne, BlocksUntilSignaled) {
+  Mutex mutex;
+  ConditionVariable condvar;
+  ThreadInfo thread_info(0);
+
+  LambdaThread thread([&mutex, &condvar, &info = thread_info] {
+    StateLock l{mutex};
+    condvar.wait(l, info.Predicate());
+    info.done_notifier.release();
+  });
+  ASSERT_TRUE(thread_info.waiting_notifier.try_acquire_for(kFailureTimeout));
+  {
+    StateLock l{mutex};
+    thread_info.predicate_result = true;
+  }
+  condvar.notify_one();
+  ASSERT_TRUE(thread_info.done_notifier.try_acquire_for(kFailureTimeout));
+}
+
+TEST(NotifyOne, UnblocksOne) {
+  Mutex mutex;
+  ConditionVariable condvar;
+  std::array<ThreadInfo, 2> thread_info = {ThreadInfo(0), ThreadInfo(1)};
+  pw::Vector<int, 2> wait_order;
+
+  LambdaThread thread_1(
+      [&mutex, &condvar, &info = thread_info[0], &wait_order] {
+        StateLock l{mutex};
+        auto predicate = [&info, &wait_order] {
+          wait_order.push_back(info.thread_id);
+          auto result = info.predicate_result;
+          info.waiting_notifier.release();
+          return result;
+        };
+        condvar.wait(l, predicate);
+        info.done_notifier.release();
+      },
+      pw::thread::test::TestOptionsThread0());
+  LambdaThread thread_2(
+      [&mutex, &condvar, &info = thread_info[1], &wait_order] {
+        StateLock l{mutex};
+        auto predicate = [&info, &wait_order] {
+          wait_order.push_back(info.thread_id);
+          auto result = info.predicate_result;
+          info.waiting_notifier.release();
+          return result;
+        };
+        condvar.wait(l, predicate);
+        info.done_notifier.release();
+      },
+      pw::thread::test::TestOptionsThread1());
+
+  ASSERT_TRUE(thread_info[0].waiting_notifier.try_acquire_for(kFailureTimeout));
+  ASSERT_TRUE(thread_info[1].waiting_notifier.try_acquire_for(kFailureTimeout));
+
+  {
+    StateLock l{mutex};
+    thread_info[1].predicate_result = true;
+    thread_info[0].predicate_result = true;
+  }
+  condvar.notify_one();
+  ASSERT_TRUE(thread_info[wait_order[0]].done_notifier.try_acquire_for(
+      kFailureTimeout));
+  ASSERT_FALSE(thread_info[wait_order[0]].done_notifier.try_acquire());
+  condvar.notify_one();
+  ASSERT_TRUE(thread_info[wait_order[1]].done_notifier.try_acquire_for(
+      kFailureTimeout));
+}
+
+TEST(NotifyAll, UnblocksMultiple) {
+  Mutex mutex;
+  ConditionVariable condvar;
+  std::array<ThreadInfo, 2> thread_info = {ThreadInfo(0), ThreadInfo(1)};
+
+  LambdaThread thread_1(
+      [&mutex, &condvar, &info = thread_info[0]] {
+        StateLock l{mutex};
+        condvar.wait(l, info.Predicate());
+        info.done_notifier.release();
+      },
+      pw::thread::test::TestOptionsThread0());
+  LambdaThread thread_2(
+      [&mutex, &condvar, &info = thread_info[1]] {
+        StateLock l{mutex};
+        condvar.wait(l, info.Predicate());
+        info.done_notifier.release();
+      },
+      pw::thread::test::TestOptionsThread1());
+
+  ASSERT_TRUE(thread_info[0].waiting_notifier.try_acquire_for(kFailureTimeout));
+  ASSERT_TRUE(thread_info[1].waiting_notifier.try_acquire_for(kFailureTimeout));
+  {
+    StateLock l{mutex};
+    thread_info[0].predicate_result = true;
+    thread_info[1].predicate_result = true;
+  }
+  condvar.notify_all();
+  ASSERT_TRUE(thread_info[0].done_notifier.try_acquire_for(kFailureTimeout));
+  ASSERT_TRUE(thread_info[1].done_notifier.try_acquire_for(kFailureTimeout));
+}
+
+TEST(WaitFor, ReturnsTrueIfSignalled) {
+  Mutex mutex;
+  ConditionVariable condvar;
+  ThreadInfo thread_info(0);
+
+  LambdaThread thread([&mutex, &condvar, &info = thread_info] {
+    StateLock l{mutex};
+    info.wait_result = condvar.wait_for(l, kFailureTimeout, info.Predicate());
+    info.done_notifier.release();
+  });
+
+  ASSERT_TRUE(thread_info.waiting_notifier.try_acquire_for(kFailureTimeout));
+  {
+    StateLock l{mutex};
+    thread_info.predicate_result = true;
+  }
+  condvar.notify_one();
+  ASSERT_TRUE(thread_info.done_notifier.try_acquire_for(kFailureTimeout));
+  ASSERT_TRUE(thread_info.wait_result);
+}
+
+TEST(WaitFor, ReturnsFalseIfTimesOut) {
+  Mutex mutex;
+  ConditionVariable condvar;
+  ThreadInfo thread_info(0);
+
+  LambdaThread thread([&mutex, &condvar, &info = thread_info] {
+    StateLock l{mutex};
+    info.wait_result = condvar.wait_for(l, 0ms, info.Predicate());
+    info.done_notifier.release();
+  });
+
+  ASSERT_TRUE(thread_info.waiting_notifier.try_acquire_for(kFailureTimeout));
+  ASSERT_TRUE(thread_info.done_notifier.try_acquire_for(kFailureTimeout));
+  ASSERT_FALSE(thread_info.wait_result);
+}
+
+// NOTE: This test waits even in successful circumstances.
+TEST(WaitFor, TimeoutApproximatelyCorrect) {
+  Mutex mutex;
+  ConditionVariable condvar;
+  ThreadInfo thread_info(0);
+  pw::chrono::SystemClock::duration wait_duration{};
+
+  LambdaThread thread([&mutex, &condvar, &info = thread_info, &wait_duration] {
+    StateLock l{mutex};
+    auto start = pw::chrono::SystemClock::now();
+    info.wait_result = condvar.wait_for(l, kRequiredTimeout, info.Predicate());
+    wait_duration = pw::chrono::SystemClock::now() - start;
+    info.done_notifier.release();
+  });
+
+  ASSERT_TRUE(thread_info.waiting_notifier.try_acquire_for(kFailureTimeout));
+  // Wake up thread multiple times. Make sure the timeout is observed.
+  for (int i = 0; i < 5; ++i) {
+    condvar.notify_one();
+    pw::this_thread::sleep_for(kRequiredTimeout / 6);
+  }
+  ASSERT_TRUE(thread_info.done_notifier.try_acquire_for(kFailureTimeout));
+  EXPECT_FALSE(thread_info.wait_result);
+  EXPECT_GE(wait_duration, kRequiredTimeout);
+  EXPECT_LT(wait_duration, (kRequiredTimeout + kAllowedSlack));
+}
+
+TEST(WaitUntil, ReturnsTrueIfSignalled) {
+  Mutex mutex;
+  ConditionVariable condvar;
+  ThreadInfo thread_info(0);
+
+  LambdaThread thread([&mutex, &condvar, &info = thread_info] {
+    StateLock l{mutex};
+    info.wait_result = condvar.wait_until(
+        l, pw::chrono::SystemClock::now() + kRequiredTimeout, info.Predicate());
+    info.done_notifier.release();
+  });
+
+  ASSERT_TRUE(thread_info.waiting_notifier.try_acquire_for(kFailureTimeout));
+  {
+    StateLock l{mutex};
+    thread_info.predicate_result = true;
+  }
+  condvar.notify_one();
+  ASSERT_TRUE(thread_info.done_notifier.try_acquire_for(kFailureTimeout));
+  ASSERT_TRUE(thread_info.wait_result);
+}
+
+// NOTE: This test waits even in successful circumstances.
+TEST(WaitUntil, ReturnsFalseIfTimesOut) {
+  Mutex mutex;
+  ConditionVariable condvar;
+  ThreadInfo thread_info(0);
+
+  LambdaThread thread([&mutex, &condvar, &info = thread_info] {
+    StateLock l{mutex};
+    info.wait_result = condvar.wait_until(
+        l, pw::chrono::SystemClock::now() + kRequiredTimeout, info.Predicate());
+    info.done_notifier.release();
+  });
+
+  ASSERT_TRUE(thread_info.waiting_notifier.try_acquire_for(kFailureTimeout));
+  ASSERT_TRUE(thread_info.done_notifier.try_acquire_for(kFailureTimeout));
+  ASSERT_FALSE(thread_info.wait_result);
+}
+
+// NOTE: This test waits even in successful circumstances.
+TEST(WaitUntil, TimeoutApproximatelyCorrect) {
+  Mutex mutex;
+  ConditionVariable condvar;
+  ThreadInfo thread_info(0);
+  pw::chrono::SystemClock::duration wait_duration{};
+
+  LambdaThread thread([&mutex, &condvar, &info = thread_info, &wait_duration] {
+    StateLock l{mutex};
+    auto start = pw::chrono::SystemClock::now();
+    info.wait_result = condvar.wait_until(
+        l, pw::chrono::SystemClock::now() + kRequiredTimeout, info.Predicate());
+    wait_duration = pw::chrono::SystemClock::now() - start;
+    info.done_notifier.release();
+  });
+
+  ASSERT_TRUE(thread_info.waiting_notifier.try_acquire_for(kFailureTimeout));
+  // Wake up thread multiple times. Make sure the timeout is observed.
+  for (int i = 0; i < 5; ++i) {
+    condvar.notify_one();
+    pw::this_thread::sleep_for(kRequiredTimeout / 6);
+  }
+  ASSERT_TRUE(thread_info.done_notifier.try_acquire_for(kFailureTimeout));
+  ASSERT_FALSE(thread_info.wait_result);
+  ASSERT_GE(wait_duration, kRequiredTimeout);
+  ASSERT_LE(wait_duration, kRequiredTimeout + kAllowedSlack);
+}
+
+}  // namespace
+}  // namespace pw::sync
diff --git a/pw_sync/docs.rst b/pw_sync/docs.rst
index 8673d13..a4fc780 100644
--- a/pw_sync/docs.rst
+++ b/pw_sync/docs.rst
@@ -1856,11 +1856,7 @@
 
 Conditional Variables
 =====================
-We've decided for now to skip on conditional variables. These are constructs,
-which are typically not natively available on RTOSes. CVs would have to be
-backed by a multiple hidden semaphore(s) in addition to the explicit public
-mutex. In other words a CV typically ends up as a a composition of
-synchronization primitives on RTOSes. That being said, one could implement them
-using our semaphore and mutex layers and we may consider providing this in the
-future. However for most of our resource constrained customers they will mostly
-likely be using semaphores more often than CVs.
+``pw::sync::ConditionVariable`` provides a condition variable implementation
+that provides semantics and an API very similar to `std::condition_variable
+<https://en.cppreference.com/w/cpp/thread/condition_variable>`_ in the C++
+Standard Library.
diff --git a/pw_sync/public/pw_sync/condition_variable.h b/pw_sync/public/pw_sync/condition_variable.h
new file mode 100644
index 0000000..7aa16ae
--- /dev/null
+++ b/pw_sync/public/pw_sync/condition_variable.h
@@ -0,0 +1,91 @@
+// Copyright 2022 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 <mutex>
+
+#include "pw_chrono/system_clock.h"
+#include "pw_sync/mutex.h"
+#include "pw_sync_backend/condition_variable_native.h"
+
+namespace pw::sync {
+
+// ConditionVariable represents a condition variable using an API very similar
+// to std::condition_variable. Implementations of this class should share the
+// same semantics as std::condition_variable.
+class ConditionVariable {
+ public:
+  using native_handle_type = backend::NativeConditionVariableHandle;
+
+  ConditionVariable() = default;
+
+  ConditionVariable(const ConditionVariable&) = delete;
+
+  ~ConditionVariable() = default;
+
+  ConditionVariable& operator=(const ConditionVariable&) = delete;
+
+  // Wake up one thread waiting on a condition.
+  //
+  // The thread will re-evaluate the condition via its predicate. Threads where
+  // the predicate evaluates false will go back to waiting. The new order of
+  // waiting threads is undefined.
+  void notify_one();
+
+  // Wake up all threads waiting on the condition variable.
+  //
+  // Woken threads will re-evaluate the condition via their predicate. Threads
+  // where the predicate evaluates false will go back to waiting. The new order
+  // of waiting threads is undefined.
+  void notify_all();
+
+  // Block the current thread until predicate() == true.
+  //
+  // Precondition: the provided lock must be locked.
+  template <typename Predicate>
+  void wait(std::unique_lock<Mutex>& lock, Predicate predicate);
+
+  // Block the current thread for a duration up to the given timeout or
+  // until predicate() == true whichever comes first.
+  //
+  // Returns: true if predicate() == true.
+  //          false if timeout expired.
+  //
+  // Precondition: the provided lock must be locked.
+  template <typename Predicate>
+  bool wait_for(std::unique_lock<Mutex>& lock,
+                pw::chrono::SystemClock::duration timeout,
+                Predicate predicate);
+
+  // Block the current thread until given point in time or until predicate() ==
+  // true whichever comes first.
+  //
+  // Returns: true if predicate() == true.
+  //          false if the deadline was reached.
+  //
+  // Precondition: the provided lock must be locked.
+  template <typename Predicate>
+  bool wait_until(std::unique_lock<Mutex>& lock,
+                  pw::chrono::SystemClock::time_point deadline,
+                  Predicate predicate);
+
+  native_handle_type native_handle();
+
+ private:
+  backend::NativeConditionVariable native_type_;
+};
+
+}  // namespace pw::sync
+
+#include "pw_sync_backend/condition_variable_inline.h"
diff --git a/pw_sync_stl/BUILD.bazel b/pw_sync_stl/BUILD.bazel
index 19eca46..d0e62b8 100644
--- a/pw_sync_stl/BUILD.bazel
+++ b/pw_sync_stl/BUILD.bazel
@@ -193,3 +193,36 @@
         "//pw_sync:yield_core",
     ],
 )
+
+pw_cc_library(
+    name = "condition_variable_headers",
+    hdrs = [
+        "public/pw_sync_stl/condition_variable_inline.h",
+        "public/pw_sync_stl/condition_variable_native.h",
+        "public_overrides/pw_sync_backend/condition_variable_inline.h",
+        "public_overrides/pw_sync_backend/condition_variable_native.h",
+    ],
+    includes = [
+        "public",
+        "public_overrides",
+    ],
+    target_compatible_with = select(TARGET_COMPATIBLE_WITH_HOST_SELECT),
+)
+
+pw_cc_library(
+    name = "condition_variable",
+    target_compatible_with = select(TARGET_COMPATIBLE_WITH_HOST_SELECT),
+    deps = [
+        ":condition_variable_headers",
+        "//pw_sync:condition_variable_facade",
+    ],
+)
+
+# TODO(b/228998350): Figure out how to conditionally enable this test like GN
+# pw_cc_test(
+#     name = "condition_variable_test",
+#     deps = [
+#         "//pw_sync:condition_variable_test",
+#         "//pw_thread_stl:test_threads",
+#     ]
+# )
diff --git a/pw_sync_stl/BUILD.gn b/pw_sync_stl/BUILD.gn
index 984f734..e5b2d5d 100644
--- a/pw_sync_stl/BUILD.gn
+++ b/pw_sync_stl/BUILD.gn
@@ -18,6 +18,8 @@
 import("$dir_pw_build/target_types.gni")
 import("$dir_pw_chrono/backend.gni")
 import("$dir_pw_docgen/docs.gni")
+import("$dir_pw_sync/backend.gni")
+import("$dir_pw_thread/backend.gni")
 import("$dir_pw_unit_test/test.gni")
 
 config("public_include_path") {
@@ -150,9 +152,36 @@
   ]
 }
 
+# This target provides the backend for pw::sync::ConditionVariable.
+pw_source_set("condition_variable_backend") {
+  allow_circular_includes_from = [ "$dir_pw_sync:condition_variable.facade" ]
+  public_configs = [
+    ":public_include_path",
+    ":backend_config",
+  ]
+  public = [
+    "public/pw_sync_stl/condition_variable_inline.h",
+    "public/pw_sync_stl/condition_variable_native.h",
+    "public_overrides/pw_sync_backend/condition_variable_inline.h",
+    "public_overrides/pw_sync_backend/condition_variable_native.h",
+  ]
+  public_deps = [ "$dir_pw_sync:condition_variable.facade" ]
+}
+
+pw_test("condition_variable_test") {
+  enable_if = pw_thread_THREAD_BACKEND == "$dir_pw_thread_stl:thread" &&
+              pw_sync_CONDITION_VARIABLE_BACKEND ==
+              "$dir_pw_sync_stl:condition_variable"
+  deps = [
+    "$dir_pw_sync:condition_variable_test",
+    "$dir_pw_thread_stl:test_threads",
+  ]
+}
+
 pw_doc_group("docs") {
   sources = [ "docs.rst" ]
 }
 
 pw_test_group("tests") {
+  tests = [ ":condition_variable_test" ]
 }
diff --git a/pw_sync_stl/CMakeLists.txt b/pw_sync_stl/CMakeLists.txt
index e2d4433..8e4fbbc 100644
--- a/pw_sync_stl/CMakeLists.txt
+++ b/pw_sync_stl/CMakeLists.txt
@@ -33,6 +33,19 @@
     pw_chrono.system_clock
 )
 
+pw_add_module_library(pw_sync_stl.condition_variable_backend
+  IMPLEMENTS_FACADES
+    pw_sync.condition_variable
+  HEADERS
+    public/pw_sync_stl/condition_variable_inline.h
+    public/pw_sync_stl/condition_variable_native.h
+    public_overrides/pw_sync_backend/condition_variable_inline.h
+    public_overrides/pw_sync_backend/condition_variable_native.h
+  PUBLIC_INCLUDES
+    public
+    public_overrides
+)
+
 # This target provides the backend for pw::sync::CountingSemaphore.
 pw_add_module_library(pw_sync_stl.counting_semaphore_backend
   IMPLEMENTS_FACADES
diff --git a/pw_sync_stl/public/pw_sync_stl/condition_variable_inline.h b/pw_sync_stl/public/pw_sync_stl/condition_variable_inline.h
new file mode 100644
index 0000000..2c84902
--- /dev/null
+++ b/pw_sync_stl/public/pw_sync_stl/condition_variable_inline.h
@@ -0,0 +1,50 @@
+// Copyright 2022 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 <mutex>
+
+#include "pw_sync/condition_variable.h"
+
+namespace pw::sync {
+
+inline void ConditionVariable::notify_one() { native_type_.notify_one(); }
+
+inline void ConditionVariable::notify_all() { native_type_.notify_all(); }
+
+template <typename Predicate>
+void ConditionVariable::wait(std::unique_lock<Mutex>& lock,
+                             Predicate predicate) {
+  native_type_.wait(lock, std::move(predicate));
+}
+
+template <typename Predicate>
+bool ConditionVariable::wait_for(std::unique_lock<Mutex>& lock,
+                                 pw::chrono::SystemClock::duration timeout,
+                                 Predicate predicate) {
+  return native_type_.wait_for(lock, timeout, std::move(predicate));
+}
+
+template <typename Predicate>
+bool ConditionVariable::wait_until(std::unique_lock<Mutex>& lock,
+                                   pw::chrono::SystemClock::time_point deadline,
+                                   Predicate predicate) {
+  return native_type_.wait_until(lock, deadline, std::move(predicate));
+}
+
+inline auto ConditionVariable::native_handle() -> native_handle_type {
+  return native_type_;
+}
+
+}  // namespace pw::sync
diff --git a/pw_sync_stl/public/pw_sync_stl/condition_variable_native.h b/pw_sync_stl/public/pw_sync_stl/condition_variable_native.h
new file mode 100644
index 0000000..e3032a5
--- /dev/null
+++ b/pw_sync_stl/public/pw_sync_stl/condition_variable_native.h
@@ -0,0 +1,25 @@
+// Copyright 2022 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 <condition_variable>
+
+#include "pw_sync/condition_variable.h"
+
+namespace pw::sync::backend {
+
+using NativeConditionVariable = std::condition_variable_any;
+using NativeConditionVariableHandle = std::condition_variable_any&;
+
+}  // namespace pw::sync::backend
diff --git a/pw_sync_stl/public_overrides/pw_sync_backend/condition_variable_inline.h b/pw_sync_stl/public_overrides/pw_sync_backend/condition_variable_inline.h
new file mode 100644
index 0000000..c6579c6
--- /dev/null
+++ b/pw_sync_stl/public_overrides/pw_sync_backend/condition_variable_inline.h
@@ -0,0 +1,16 @@
+// Copyright 2022 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/condition_variable_inline.h"
diff --git a/pw_sync_stl/public_overrides/pw_sync_backend/condition_variable_native.h b/pw_sync_stl/public_overrides/pw_sync_backend/condition_variable_native.h
new file mode 100644
index 0000000..bb31927
--- /dev/null
+++ b/pw_sync_stl/public_overrides/pw_sync_backend/condition_variable_native.h
@@ -0,0 +1,16 @@
+// Copyright 2022 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/condition_variable_native.h"
diff --git a/pw_system/stl_backends.gni b/pw_system/stl_backends.gni
index 7956f6a..de2f0c2 100644
--- a/pw_system/stl_backends.gni
+++ b/pw_system/stl_backends.gni
@@ -17,10 +17,12 @@
 PW_SYSTEM_STL_BACKENDS = {
   pw_chrono_SYSTEM_CLOCK_BACKEND = "$dir_pw_chrono_stl:system_clock"
   pw_chrono_SYSTEM_TIMER_BACKEND = "$dir_pw_chrono_stl:system_timer"
-  pw_sync_INTERRUPT_SPIN_LOCK_BACKEND = "$dir_pw_sync_stl:interrupt_spin_lock"
   pw_sync_BINARY_SEMAPHORE_BACKEND = "$dir_pw_sync_stl:binary_semaphore_backend"
+  pw_sync_CONDITION_VARIABLE_BACKEND =
+      "$dir_pw_sync_stl:condition_variable_backend"
   pw_sync_COUNTING_SEMAPHORE_BACKEND =
       "$dir_pw_sync_stl:counting_semaphore_backend"
+  pw_sync_INTERRUPT_SPIN_LOCK_BACKEND = "$dir_pw_sync_stl:interrupt_spin_lock"
   pw_sync_MUTEX_BACKEND = "$dir_pw_sync_stl:mutex_backend"
   pw_sync_TIMED_MUTEX_BACKEND = "$dir_pw_sync_stl:timed_mutex_backend"
   pw_sync_THREAD_NOTIFICATION_BACKEND =
diff --git a/targets/host/target_toolchains.gni b/targets/host/target_toolchains.gni
index df99ece..0bccc4c 100644
--- a/targets/host/target_toolchains.gni
+++ b/targets/host/target_toolchains.gni
@@ -43,10 +43,12 @@
   pw_string_CONFIG = "$dir_pw_string:enable_decimal_float_expansion"
 
   # Configure backends for pw_sync's facades.
-  pw_sync_INTERRUPT_SPIN_LOCK_BACKEND = "$dir_pw_sync_stl:interrupt_spin_lock"
   pw_sync_BINARY_SEMAPHORE_BACKEND = "$dir_pw_sync_stl:binary_semaphore_backend"
+  pw_sync_CONDITION_VARIABLE_BACKEND =
+      "$dir_pw_sync_stl:condition_variable_backend"
   pw_sync_COUNTING_SEMAPHORE_BACKEND =
       "$dir_pw_sync_stl:counting_semaphore_backend"
+  pw_sync_INTERRUPT_SPIN_LOCK_BACKEND = "$dir_pw_sync_stl:interrupt_spin_lock"
   pw_sync_MUTEX_BACKEND = "$dir_pw_sync_stl:mutex_backend"
   pw_sync_RECURSIVE_MUTEX_BACKEND = "$dir_pw_sync_stl:recursive_mutex_backend"
   pw_sync_TIMED_MUTEX_BACKEND = "$dir_pw_sync_stl:timed_mutex_backend"