diff --git a/src/default-implementations.lisp b/src/default-implementations.lisp
index 33d6532..2aad9dd 100644
--- a/src/default-implementations.lisp
+++ b/src/default-implementations.lisp
@@ -319,3 +319,37 @@ support WITH-TIMEOUT natively and don't support threads either it has no effect.
   has already terminated, return immediately."
   (declare (ignore thread))
   (error (make-threading-support-error)))
+
+(defvar *thread-wait-granularity* .01)
+
+(defdfun thread-wait (whostate predicate &rest args)
+  "Wait until the predicate, a function applied to args, returns
+   a true value.  whostate is a string indicating why we are waiting.
+
+   THIS FUNCTION IS FOR COMPATIBILITY PURPOSE ONLY,
+   with the PROCESS-WAIT function of legacy Lisp APIs.
+   The API kind of made sense in old single-processor timesharing
+   architectures, but is necessarily inefficient on modern multiprocessors.
+   Please use a more modern API if you can."
+  (declare (ignore whostate))
+  (declare (dynamic-extent args))
+  (loop until (apply predicate args)
+        do (sleep *thread-wait-granularity*)))
+
+(defdfun thread-wait-with-timeout (whostate seconds predicate &rest args)
+  "Wait until the predicate, a function applied to args, returns
+   a true value, or until the number of seconds has passed.
+   whostate is a string indicating why we are waiting.
+
+   THIS FUNCTION IS FOR COMPATIBILITY PURPOSE ONLY,
+   with the PROCESS-WAIT-WITH-TIMEOUT function of legacy Lisp APIs.
+   The API kind of made sense in old single-processor timesharing
+   architectures, but is necessarily inefficient on modern multiprocessors.
+   Please use a more modern API if you can."
+  (declare (ignore whostate))
+  (declare (dynamic-extent args))
+  (loop until (apply predicate args)
+        while (plusp seconds)
+        do (let ((g *thread-wait-granularity*))
+             (sleep (min seconds g))
+             (decf seconds g))))
diff --git a/src/impl-allegro.lisp b/src/impl-allegro.lisp
index 0031bfe..4040ca3 100644
--- a/src/impl-allegro.lisp
+++ b/src/impl-allegro.lisp
@@ -98,4 +98,10 @@ Distributed under the MIT license (see LICENSE file)
                    (complement #'mp:process-alive-p)
                    thread))
 
+(defun thread-wait (wait-reason wait-function &rest wait-arguments)
+  (apply #'mp:process-wait wait-reason wait-function wait-arguments))
+
+(defun thread-wait-with-timeout (wait-reason timeout wait-function &rest wait-arguments)
+  (apply #'mp:process-wait-with-timeout wait-reason timeout wait-function wait-arguments))
+
 (mark-supported)
diff --git a/src/impl-clisp.lisp b/src/impl-clisp.lisp
index fde6b42..f9cc504 100644
--- a/src/impl-clisp.lisp
+++ b/src/impl-clisp.lisp
@@ -5,7 +5,6 @@ Copyright 2006, 2007 Greg Pfeil
 
 Distributed under the MIT license (see LICENSE file)
 |#
-
 (in-package #:bordeaux-threads)
 
 (deftype thread ()
diff --git a/src/impl-clozure.lisp b/src/impl-clozure.lisp
index dd16c00..cf1811e 100644
--- a/src/impl-clozure.lisp
+++ b/src/impl-clozure.lisp
@@ -96,4 +96,10 @@ Distributed under the MIT license (see LICENSE file)
 (defun join-thread (thread)
   (ccl:join-process thread))
 
+(defun thread-wait (wait-reason wait-function &rest wait-arguments)
+  (apply #'ccl:process-wait wait-reason wait-function wait-arguments))
+
+(defun thread-wait-with-timeout (wait-reason timeout wait-function &rest wait-arguments)
+  (apply #'ccl:process-wait-with-timeout wait-reason timeout wait-function wait-arguments))
+
 (mark-supported)
diff --git a/src/impl-cmucl.lisp b/src/impl-cmucl.lisp
index ae08144..e6460c9 100644
--- a/src/impl-cmucl.lisp
+++ b/src/impl-cmucl.lisp
@@ -117,4 +117,7 @@ Distributed under the MIT license (see LICENSE file)
   (mp:process-wait (format nil "Waiting for thread ~A to complete" thread)
                    (lambda () (not (mp:process-alive-p thread)))))
 
+(defun thread-wait (wait-reason wait-function &rest wait-arguments)
+  (apply #'mp:process-wait wait-reason wait-function wait-arguments))
+
 (mark-supported)
diff --git a/src/impl-lispworks-condition-variables.lisp b/src/impl-lispworks-condition-variables.lisp
index 297c1df..c5091a6 100644
--- a/src/impl-lispworks-condition-variables.lisp
+++ b/src/impl-lispworks-condition-variables.lisp
@@ -17,6 +17,7 @@
 ;; While not true zero like a true native solution, the use of the Lispworks native checks appear
 ;; fast enough to be an equivalent substitute (thread count will cause issue before the
 ;; waiting overhead becomes significant)
+
 (defstruct (condition-variable (:constructor make-lw-condition (name)))
   name
   (lock (mp:make-lock :name "For condition-variable") :type mp:lock :read-only t)
diff --git a/src/impl-lispworks.lisp b/src/impl-lispworks.lisp
index 949e7ff..df4b018 100644
--- a/src/impl-lispworks.lisp
+++ b/src/impl-lispworks.lisp
@@ -103,4 +103,10 @@ Distributed under the MIT license (see LICENSE file)
                    (complement #'mp:process-alive-p)
                    thread))
 
+(defun thread-wait (wait-reason wait-function &rest wait-arguments)
+  (apply #'mp:process-wait wait-reason wait-function wait-arguments))
+
+(defun thread-wait-with-timeout (wait-reason timeout wait-function &rest wait-arguments)
+  (apply #'mp:process-wait-with-timeout wait-reason timeout wait-function wait-arguments))
+
 (mark-supported)
diff --git a/src/impl-scl.lisp b/src/impl-scl.lisp
index 3909bab..5942bb9 100644
--- a/src/impl-scl.lisp
+++ b/src/impl-scl.lisp
@@ -87,4 +87,13 @@ Distributed under the MIT license (see LICENSE file)
   (mp:process-wait (format nil "Waiting for thread ~A to complete" thread)
                    (lambda () (not (mp:process-alive-p thread)))))
 
+(defun thread-wait (whostate timeout wait-function &rest wait-arguments)
+  (mp:process-wait
+   whostate (lambda () (apply wait-function wait-arguments))))
+
+(defun thread-wait-with-timeout (whostate timeout wait-function &rest wait-arguments)
+  (mp:process-wait-with-timeout
+   whostate timeout
+   (lambda () (apply wait-function wait-arguments))))
+
 (mark-supported)
diff --git a/src/pkgdcl.lisp b/src/pkgdcl.lisp
index 3ff164a..cd6bf4d 100644
--- a/src/pkgdcl.lisp
+++ b/src/pkgdcl.lisp
@@ -19,7 +19,8 @@
            #:with-timeout #:timeout
 
            #:all-threads #:interrupt-thread #:destroy-thread #:thread-alive-p
-           #:join-thread #:thread-yield)
+           #:join-thread #:thread-yield
+           #:thread-wait #:thread-wait-with-timeout)
   (:documentation "BORDEAUX-THREADS is a proposed standard for a minimal
   MP/threading interface. It is similar to the CLIM-SYS threading and
   lock support, but for the following broad differences:
