Index: libcfa/src/concurrency/future.hfa
===================================================================
--- libcfa/src/concurrency/future.hfa	(revision fbaea97009f70b67f476a193ca6b049a1100402d)
+++ libcfa/src/concurrency/future.hfa	(revision 00aa122cd8a610fd71bc1afaa8e4910742e18a62)
@@ -10,6 +10,6 @@
 // Created On       : Wed Jan 06 17:33:18 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Nov 23 22:48:08 2025
-// Update Count     : 208
+// Last Modified On : Mon Nov 24 16:08:52 2025
+// Update Count     : 222
 //
 
@@ -100,5 +100,4 @@
  			except = 0p;
  			state = FUTURE_EMPTY$;
- 			lock{};
  		}
 
@@ -320,13 +319,12 @@
 
 //--------------------------------------------------------------------------------------------------------
-// These futures below do not support waituntil statements so they may not have as many features as 'future'
-//  however the 'single_future' is cheap and cheerful and is most likely more performant than 'future'
-//  since it uses raw atomics and no locks
-//
-// As far as 'multi_future' goes I can't see many use cases as it will be less performant than 'future'
-//  since it is monitor based and also is not compatible with waituntil statement.
+// This future does not support waituntil statements so it does not have as many features as 'future'.
+// However, it is cheap and cheerful and is more performant than 'future' since it uses raw atomics
+// and no locks
 //--------------------------------------------------------------------------------------------------------
 
 forall( T ) {
+	// PUBLIC
+
 	struct single_future {
 		inline future_t;
@@ -335,94 +333,21 @@
 
 	static inline {
-		// Reset future back to original state
-		void reset(single_future(T) & this) { reset( (future_t&)this ); }
-
-		// check if the future is available
-		bool available( single_future(T) & this ) { return available( (future_t&)this ); }
-
-		// Mark the future as abandoned, meaning it will be deleted by the server
-		// This doesn't work beause of the potential need for a destructor
-		// void abandon( single_future(T) & this );
-
-		// Fulfil the future, returns whether or not someone was unblocked
-		thread$ * fulfil( single_future(T) & this, T result ) {
-			this.result = result;
-			return fulfil( (future_t&)this );
-		}
-
-		// Wait for the future to be fulfilled
-		// Also return whether the thread had to block or not
-		[T, bool] wait( single_future(T) & this ) {
-			bool r = wait( (future_t&)this );
-			return [this.result, r];
-		}
-
-		// Wait for the future to be fulfilled
-		T wait( single_future(T) & this ) {
-			[T, bool] tt;
-			tt = wait( this );
-			return tt.0;
-		}
-	}
-}
-
-forall( T ) {
-	monitor multi_future {
-		inline future_t;
-		condition blocked;
-		bool has_first;
-		T result;
-	};
-
-	static inline {
-		void ?{}(multi_future(T) & this) {
-			this.has_first = false;
-		}
-
-		bool $first( multi_future(T) & mutex this ) {
-			if ( this.has_first ) {
-				wait( this.blocked );
-				return false;
-			}
-
-			this.has_first = true;
-			return true;
-		}
-
-		void $first_done( multi_future(T) & mutex this ) {
-			this.has_first = false;
-			signal_all( this.blocked );
-		}
-
-		// Reset future back to original state
-		void reset(multi_future(T) & mutex this) {
-			if ( this.has_first != false ) abort("Attempting to reset a multi_future with at least one blocked threads");
-			if ( ! empty( this.blocked ) ) abort("Attempting to reset a multi_future with multiple blocked threads");
-			reset( (future_t&)*(future_t*)((uintptr_t)&this + sizeof(monitor$)) );
-		}
-
-		// Fulfil the future, returns whether or not someone was unblocked
-		bool fulfil( multi_future(T) & this, T result ) {
-			this.result = result;
-			return fulfil( (future_t&)*(future_t*)((uintptr_t)&this + sizeof(monitor$)) ) != 0p;
-		}
-
-		// Wait for the future to be fulfilled
-		// Also return whether the thread had to block or not
-		[T, bool] wait( multi_future(T) & this ) {
-			bool sw = $first( this );
-			bool w = !sw;
-			if ( sw ) {
-				w = wait( (future_t&)*(future_t*)((uintptr_t)&this + sizeof(monitor$)) );
-				$first_done( this );
-			}
-
-			return [this.result, w];
-		}
-
-		// Wait for the future to be fulfilled
-		T wait( multi_future(T) & this ) {
-			return wait( this ).0;
-		}
-	}
-}
+		// PUBLIC
+
+		bool available( single_future(T) & fut ) { return available( (future_t &)fut ); } // future result available ?
+
+		// Return a value/exception from the future.
+		[T, bool] get( single_future(T) & fut ) { return [fut.result, wait( fut )]; }
+		T get( single_future(T) & fut ) { wait( fut ); return fut.result; }
+		T ?()( single_future(T) & fut ) { return get( fut ); }	// alternate interface
+
+		// Load a value into the future, returns whether or not waiting threads.
+		bool fulfil( single_future(T) & fut, T result ) {
+			fut.result = result;
+			return fulfil( (future_t &)fut ) != 0p;
+		}
+		bool ?()( single_future(T) & fut, T val ) { return fulfil( fut, val ); } // alternate interface
+
+		void reset( single_future(T) & fut ) { reset( (future_t &)fut ); } // mark future as empty (for reuse)
+	} // static inline
+} // forall( T )
Index: sts/concurrency/futures/.expect/multi.txt
===================================================================
--- tests/concurrency/futures/.expect/multi.txt	(revision fbaea97009f70b67f476a193ca6b049a1100402d)
+++ 	(revision )
@@ -1,2 +1,0 @@
-start
-done
Index: tests/concurrency/futures/.expect/multi.txt.off
===================================================================
--- tests/concurrency/futures/.expect/multi.txt.off	(revision 00aa122cd8a610fd71bc1afaa8e4910742e18a62)
+++ tests/concurrency/futures/.expect/multi.txt.off	(revision 00aa122cd8a610fd71bc1afaa8e4910742e18a62)
@@ -0,0 +1,2 @@
+start
+done
Index: tests/concurrency/futures/multi.cfa
===================================================================
--- tests/concurrency/futures/multi.cfa	(revision fbaea97009f70b67f476a193ca6b049a1100402d)
+++ tests/concurrency/futures/multi.cfa	(revision 00aa122cd8a610fd71bc1afaa8e4910742e18a62)
@@ -1,2 +1,4 @@
+// DEPRECATED future type multi_future. Eventually remove this test.
+
 #include <thread.hfa>
 #include <future.hfa>
Index: tests/concurrency/futures/typed.cfa
===================================================================
--- tests/concurrency/futures/typed.cfa	(revision fbaea97009f70b67f476a193ca6b049a1100402d)
+++ tests/concurrency/futures/typed.cfa	(revision 00aa122cd8a610fd71bc1afaa8e4910742e18a62)
@@ -8,31 +8,31 @@
 };
 
-void ?{}( Server & this ) {
-	this.cnt = 0;
-	for(i; NFUTURES) {
-		this.requests[i] = 0p;
+void ?{}( Server & server ) with( server ) {
+	cnt = 0;
+	for ( i; NFUTURES ) {
+		requests[i] = 0p;
 	}
 }
 
-void ^?{}( Server & mutex this ) {
-	assert(this.cnt == 0);
-	for(i; NFUTURES) {
-		this.requests[i] = 0p;
+void ^?{}( Server & mutex server ) with( server )  {
+	assert( cnt == 0 );
+	for ( i; NFUTURES ) {
+		requests[i] = 0p;
 	}
 }
 
-void process( Server & this, int i ) {
-	if( this.requests[i] == 0p ) return;
-	single_future(int) * f = this.requests[i];
-	this.requests[i] = 0p;
-	this.cnt--;
-	fulfil( *f , i);
+void process( Server & server, int i ) with( server )  {
+  if ( requests[i] == 0p ) return;
+	single_future(int) * f = requests[i];
+	requests[i] = 0p;
+	cnt--;
+	(*f)( i );											// fulfil
 }
 
-void call( Server & mutex this, single_future(int) & f ) {
-	for(i; NFUTURES) {
-		if( this.requests[i] == 0p ) {
-			this.requests[i] = &f;
-			this.cnt++;
+void call( Server & mutex server, single_future(int) & f ) with( server ) {
+	for ( i; NFUTURES ) {
+		if ( requests[i] == 0p ) {
+			requests[i] = &f;
+			cnt++;
 			return;
 		}
@@ -41,19 +41,18 @@
 }
 
-void main( Server & this ) {
+void main( Server & server ) {
 	unsigned i = 0;
-	for() {
-		waitfor( ^?{} : this ) {
+	for () {
+		waitfor ( ^?{} : server ) {
 			break;
-		}
-		or when( this.cnt < NFUTURES ) waitfor( call: this ) {}
+		} or when( server.cnt < NFUTURES ) waitfor( call : server ) {}
 		or else {
-			process( this, i % NFUTURES );
+			process( server, i % NFUTURES );
 			i++;
 		}
 	}
 
-	for(i; NFUTURES) {
-		process( this, i );
+	for ( i; NFUTURES ) {
+		process( server, i );
 	}
 }
@@ -62,19 +61,19 @@
 thread Worker {};
 
-void thrash(void) {
+void thrash() {
 	volatile int locals[250];
-	for(i; 250) {
+	for ( i; 250 ) {
 		locals[i] = 0xdeadbeef;
 	}
 }
 
-void work(void) {
+void work() {
 	single_future(int) mine;
 	call( *the_server, mine );
-	wait( mine );
+	mine();												// get
 }
 
 void main( Worker & ) {
-	for(150) {
+	for ( 150 ) {
 		thrash();
 		work();
@@ -84,5 +83,5 @@
 
 int main() {
-	printf( "start\n" );				// non-empty .expect file
+	printf( "start\n" );								// non-empty .expect file
 	processor procs[2];
 	{
@@ -93,5 +92,4 @@
 		}
 	}
-	printf( "done\n" );				// non-empty .expect file
-
+	printf( "done\n" );									// non-empty .expect file
 }