Index: libcfa/prelude/builtins.c
===================================================================
--- libcfa/prelude/builtins.c	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/prelude/builtins.c	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -57,14 +57,14 @@
 
 // generator support
-struct $generator {
+struct generator$ {
 	inline int;
 };
 
-static inline void  ?{}($generator & this) { ((int&)this) = 0; }
-static inline void ^?{}($generator &) {}
+static inline void  ?{}(generator$ & this) { ((int&)this) = 0; }
+static inline void ^?{}(generator$ &) {}
 
 trait is_generator(T &) {
       void main(T & this);
-      $generator * get_generator(T & this);
+      generator$ * get_generator(T & this);
 };
 
Index: libcfa/src/bits/weakso_locks.cfa
===================================================================
--- libcfa/src/bits/weakso_locks.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/bits/weakso_locks.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -24,5 +24,5 @@
 bool try_lock( blocking_lock & ) { return false; }
 void unlock( blocking_lock & ) {}
-void on_notify( blocking_lock &, struct $thread * ) {}
+void on_notify( blocking_lock &, struct thread$ * ) {}
 size_t on_wait( blocking_lock & ) { return 0; }
 void on_wakeup( blocking_lock &, size_t ) {}
Index: libcfa/src/bits/weakso_locks.hfa
===================================================================
--- libcfa/src/bits/weakso_locks.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/bits/weakso_locks.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -23,5 +23,5 @@
 #include "containers/list.hfa"
 
-struct $thread;
+struct thread$;
 
 //-----------------------------------------------------------------------------
@@ -32,5 +32,5 @@
 
 	// List of blocked threads
-	dlist( $thread ) blocked_threads;
+	dlist( thread$ ) blocked_threads;
 
 	// Count of current blocked threads
@@ -44,5 +44,5 @@
 
 	// Current thread owning the lock
-	struct $thread * owner;
+	struct thread$ * owner;
 
 	// Number of recursion level
@@ -56,5 +56,5 @@
 bool try_lock( blocking_lock & this ) OPTIONAL_THREAD;
 void unlock( blocking_lock & this ) OPTIONAL_THREAD;
-void on_notify( blocking_lock & this, struct $thread * t ) OPTIONAL_THREAD;
+void on_notify( blocking_lock & this, struct thread$ * t ) OPTIONAL_THREAD;
 size_t on_wait( blocking_lock & this ) OPTIONAL_THREAD;
 void on_wakeup( blocking_lock & this, size_t ) OPTIONAL_THREAD;
@@ -74,3 +74,3 @@
 static inline size_t on_wait  ( multiple_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
 static inline void   on_wakeup( multiple_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
-static inline void   on_notify( multiple_acquisition_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
+static inline void   on_notify( multiple_acquisition_lock & this, struct thread$ * t ){ on_notify( (blocking_lock &)this, t ); }
Index: libcfa/src/concurrency/alarm.cfa
===================================================================
--- libcfa/src/concurrency/alarm.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/alarm.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -51,5 +51,5 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t & this, $thread * thrd, Duration alarm, Duration period) with( this ) {
+void ?{}( alarm_node_t & this, thread$ * thrd, Duration alarm, Duration period) with( this ) {
 	this.initial = alarm;
 	this.period  = period;
Index: libcfa/src/concurrency/alarm.hfa
===================================================================
--- libcfa/src/concurrency/alarm.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/alarm.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -25,5 +25,5 @@
 #include "containers/list.hfa"
 
-struct $thread;
+struct thread$;
 struct processor;
 
@@ -52,5 +52,5 @@
 
 	union {
-		$thread * thrd;			// thrd who created event
+		thread$ * thrd;			// thrd who created event
 		processor * proc;			// proc who created event
 		Alarm_Callback callback;	// callback to handle event
@@ -63,5 +63,5 @@
 P9_EMBEDDED( alarm_node_t, dlink(alarm_node_t) )
 
-void ?{}( alarm_node_t & this, $thread * thrd, Duration alarm, Duration period );
+void ?{}( alarm_node_t & this, thread$ * thrd, Duration alarm, Duration period );
 void ?{}( alarm_node_t & this, processor * proc, Duration alarm, Duration period );
 void ?{}( alarm_node_t & this, Alarm_Callback callback, Duration alarm, Duration period );
Index: libcfa/src/concurrency/clib/cfathread.cfa
===================================================================
--- libcfa/src/concurrency/clib/cfathread.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/clib/cfathread.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -23,5 +23,5 @@
 #include "cfathread.h"
 
-extern void ?{}(processor &, const char[], cluster &, $thread *);
+extern void ?{}(processor &, const char[], cluster &, thread$ *);
 extern "C" {
       extern void __cfactx_invoke_thread(void (*main)(void *), void * this);
@@ -34,5 +34,5 @@
 
 struct cfathread_object {
-	$thread self;
+	thread$ self;
 	void * (*themain)( void * );
 	void * arg;
@@ -42,5 +42,5 @@
 void ^?{}(cfathread_object & mutex this);
 
-static inline $thread * get_thread( cfathread_object & this ) { return &this.self; }
+static inline thread$ * get_thread( cfathread_object & this ) { return &this.self; }
 
 typedef ThreadCancelled(cfathread_object) cfathread_exception;
@@ -81,5 +81,5 @@
 // Special Init Thread responsible for the initialization or processors
 struct __cfainit {
-	$thread self;
+	thread$ self;
 	void (*init)( void * );
 	void * arg;
@@ -88,5 +88,5 @@
 void ^?{}(__cfainit & mutex this);
 
-static inline $thread * get_thread( __cfainit & this ) { return &this.self; }
+static inline thread$ * get_thread( __cfainit & this ) { return &this.self; }
 
 typedef ThreadCancelled(__cfainit) __cfainit_exception;
@@ -109,5 +109,5 @@
 
 	// Don't use __thrd_start! just prep the context manually
-	$thread * this_thrd = get_thread(this);
+	thread$ * this_thrd = get_thread(this);
 	void (*main_p)(__cfainit &) = main;
 
Index: libcfa/src/concurrency/coroutine.cfa
===================================================================
--- libcfa/src/concurrency/coroutine.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/coroutine.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -37,5 +37,5 @@
 
 extern "C" {
-	void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
+	void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine$ *) __attribute__ ((__noreturn__));
 	static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) __attribute__ ((__noreturn__));
 	static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) {
@@ -62,5 +62,5 @@
 forall(T & | is_coroutine(T))
 void __cfaehm_cancelled_coroutine(
-		T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) {
+		T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) {
 	verify( desc->cancellation );
 	desc->state = Cancelled;
@@ -114,5 +114,5 @@
 }
 
-void ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize ) with( this ) {
+void ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize ) with( this ) {
 	(this.context){0p, 0p};
 	(this.stack){storage, storageSize};
@@ -124,8 +124,8 @@
 }
 
-void ^?{}($coroutine& this) {
+void ^?{}(coroutine$& this) {
 	if(this.state != Halted && this.state != Start && this.state != Primed) {
-		$coroutine * src = active_coroutine();
-		$coroutine * dst = &this;
+		coroutine$ * src = active_coroutine();
+		coroutine$ * dst = &this;
 
 		struct _Unwind_Exception storage;
@@ -148,5 +148,5 @@
 forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
 void prime(T& cor) {
-	$coroutine* this = get_coroutine(cor);
+	coroutine$* this = get_coroutine(cor);
 	assert(this->state == Start);
 
@@ -248,6 +248,6 @@
 // is not inline (We can't inline Cforall in C)
 extern "C" {
-	void __cfactx_cor_leave( struct $coroutine * src ) {
-		$coroutine * starter = src->cancellation != 0 ? src->last : src->starter;
+	void __cfactx_cor_leave( struct coroutine$ * src ) {
+		coroutine$ * starter = src->cancellation != 0 ? src->last : src->starter;
 
 		src->state = Halted;
@@ -265,9 +265,9 @@
 	}
 
-	struct $coroutine * __cfactx_cor_finish(void) {
-		struct $coroutine * cor = active_coroutine();
+	struct coroutine$ * __cfactx_cor_finish(void) {
+		struct coroutine$ * cor = active_coroutine();
 
 		// get the active thread once
-		$thread * athrd = active_thread();
+		thread$ * athrd = active_thread();
 
 		/* paranoid */ verify( athrd->corctx_flag );
Index: libcfa/src/concurrency/coroutine.hfa
===================================================================
--- libcfa/src/concurrency/coroutine.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/coroutine.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -39,8 +39,8 @@
 trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) {
 	void main(T & this);
-	$coroutine * get_coroutine(T & this);
+	coroutine$ * get_coroutine(T & this);
 };
 
-#define DECL_COROUTINE(X) static inline $coroutine* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
+#define DECL_COROUTINE(X) static inline coroutine$* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
 
 //-----------------------------------------------------------------------------
@@ -49,12 +49,12 @@
 // void ^?{}( coStack_t & this );
 
-void  ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize );
-void ^?{}( $coroutine & this );
-
-static inline void ?{}( $coroutine & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
-static inline void ?{}( $coroutine & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
-static inline void ?{}( $coroutine & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
-static inline void ?{}( $coroutine & this, const char name[])                    { this{ name, 0p, 0 }; }
-static inline void ?{}( $coroutine & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
+void  ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize );
+void ^?{}( coroutine$ & this );
+
+static inline void ?{}( coroutine$ & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
+static inline void ?{}( coroutine$ & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
+static inline void ?{}( coroutine$ & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
+static inline void ?{}( coroutine$ & this, const char name[])                    { this{ name, 0p, 0 }; }
+static inline void ?{}( coroutine$ & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
 
 //-----------------------------------------------------------------------------
@@ -63,5 +63,5 @@
 void prime(T & cor);
 
-static inline struct $coroutine * active_coroutine() { return active_thread()->curr_cor; }
+static inline struct coroutine$ * active_coroutine() { return active_thread()->curr_cor; }
 
 //-----------------------------------------------------------------------------
@@ -73,7 +73,7 @@
 
 	forall(T &)
-	void __cfactx_start(void (*main)(T &), struct $coroutine * cor, T & this, void (*invoke)(void (*main)(void *), void *));
-
-	extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
+	void __cfactx_start(void (*main)(T &), struct coroutine$ * cor, T & this, void (*invoke)(void (*main)(void *), void *));
+
+	extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ *) __attribute__ ((__noreturn__));
 
 	extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
@@ -82,10 +82,10 @@
 // Private wrappers for context switch and stack creation
 // Wrapper for co
-static inline void $ctx_switch( $coroutine * src, $coroutine * dst ) __attribute__((nonnull (1, 2))) {
+static inline void $ctx_switch( coroutine$ * src, coroutine$ * dst ) __attribute__((nonnull (1, 2))) {
 	// set state of current coroutine to inactive
 	src->state = src->state == Halted ? Halted : Blocked;
 
 	// get the active thread once
-	$thread * athrd = active_thread();
+	thread$ * athrd = active_thread();
 
 	// Mark the coroutine
@@ -124,5 +124,5 @@
 		// will also migrate which means this value will
 		// stay in syn with the TLS
-		$coroutine * src = active_coroutine();
+		coroutine$ * src = active_coroutine();
 
 		assertf( src->last != 0,
@@ -141,5 +141,5 @@
 forall(T & | is_coroutine(T))
 void __cfaehm_cancelled_coroutine(
-	T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) );
+	T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) );
 
 // Resume implementation inlined for performance
@@ -151,6 +151,6 @@
 	// will also migrate which means this value will
 	// stay in syn with the TLS
-	$coroutine * src = active_coroutine();
-	$coroutine * dst = get_coroutine(cor);
+	coroutine$ * src = active_coroutine();
+	coroutine$ * dst = get_coroutine(cor);
 
 	if( unlikely(dst->context.SP == 0p) ) {
@@ -180,5 +180,5 @@
 }
 
-static inline void resume( $coroutine * dst ) __attribute__((nonnull (1))) {
+static inline void resume( coroutine$ * dst ) __attribute__((nonnull (1))) {
 	// optimization : read TLS once and reuse it
 	// Safety note: this is preemption safe since if
@@ -186,5 +186,5 @@
 	// will also migrate which means this value will
 	// stay in syn with the TLS
-	$coroutine * src = active_coroutine();
+	coroutine$ * src = active_coroutine();
 
 	// not resuming self ?
Index: libcfa/src/concurrency/exception.cfa
===================================================================
--- libcfa/src/concurrency/exception.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/exception.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -20,5 +20,5 @@
 #include "coroutine.hfa"
 
-extern struct $thread * mainThread;
+extern struct thread$ * mainThread;
 extern "C" {
 extern void __cfactx_thrd_leave();
@@ -55,6 +55,6 @@
 
 STOP_AT_END_FUNCTION(coroutine_cancelstop,
-	struct $coroutine * src = ($coroutine *)stop_param;
-	struct $coroutine * dst = src->last;
+	struct coroutine$ * src = (coroutine$ *)stop_param;
+	struct coroutine$ * dst = src->last;
 
 	$ctx_switch( src, dst );
@@ -72,7 +72,7 @@
 	void * stop_param;
 
-	struct $thread * this_thread = active_thread();
+	struct thread$ * this_thread = active_thread();
 	if ( &this_thread->self_cor != this_thread->curr_cor ) {
-		struct $coroutine * cor = this_thread->curr_cor;
+		struct coroutine$ * cor = this_thread->curr_cor;
 		cor->cancellation = unwind_exception;
 
Index: libcfa/src/concurrency/future.hfa
===================================================================
--- libcfa/src/concurrency/future.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/future.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -37,5 +37,5 @@
 
 		// Fulfil the future, returns whether or not someone was unblocked
-		$thread * fulfil( future(T) & this, T result ) {
+		thread$ * fulfil( future(T) & this, T result ) {
 			this.result = result;
 			return fulfil( (future_t&)this );
Index: libcfa/src/concurrency/invoke.c
===================================================================
--- libcfa/src/concurrency/invoke.c	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/invoke.c	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -29,6 +29,6 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
-extern struct $coroutine * __cfactx_cor_finish(void);
-extern void __cfactx_cor_leave ( struct $coroutine * );
+extern struct coroutine$ * __cfactx_cor_finish(void);
+extern void __cfactx_cor_leave ( struct coroutine$ * );
 extern void __cfactx_thrd_leave();
 
@@ -41,5 +41,5 @@
 ) {
 	// Finish setting up the coroutine by setting its state
-	struct $coroutine * cor = __cfactx_cor_finish();
+	struct coroutine$ * cor = __cfactx_cor_finish();
 
 	// Call the main of the coroutine
@@ -70,6 +70,6 @@
 }
 
-void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) __attribute__ ((__noreturn__));
-void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) {
+void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ * cor) __attribute__ ((__noreturn__));
+void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ * cor) {
 	_Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, __cfactx_coroutine_unwindstop, cor );
 	printf("UNWIND ERROR %d after force unwind\n", ret);
@@ -100,5 +100,5 @@
 void __cfactx_start(
 	void (*main)(void *),
-	struct $coroutine * cor,
+	struct coroutine$ * cor,
 	void *this,
 	void (*invoke)(void *)
Index: libcfa/src/concurrency/invoke.h
===================================================================
--- libcfa/src/concurrency/invoke.h	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/invoke.h	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -71,5 +71,5 @@
 	enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active, Cancelled, Halting };
 
-	struct $coroutine {
+	struct coroutine$ {
 		// context that is switch during a __cfactx_switch
 		struct __stack_context_t context;
@@ -85,8 +85,8 @@
 
 		// first coroutine to resume this one
-		struct $coroutine * starter;
+		struct coroutine$ * starter;
 
 		// last coroutine to resume this one
-		struct $coroutine * last;
+		struct coroutine$ * last;
 
 		// If non-null stack must be unwound with this exception
@@ -95,7 +95,7 @@
 	};
 	// Wrapper for gdb
-	struct cfathread_coroutine_t { struct $coroutine debug; };
-
-	static inline struct __stack_t * __get_stack( struct $coroutine * cor ) {
+	struct cfathread_coroutine_t { struct coroutine$ debug; };
+
+	static inline struct __stack_t * __get_stack( struct coroutine$ * cor ) {
 		return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2));
 	}
@@ -110,13 +110,13 @@
 	};
 
-	struct $monitor {
+	struct monitor$ {
 		// spinlock to protect internal data
 		struct __spinlock_t lock;
 
 		// current owner of the monitor
-		struct $thread * owner;
+		struct thread$ * owner;
 
 		// queue of threads that are blocked waiting for the monitor
-		__queue_t(struct $thread) entry_queue;
+		__queue_t(struct thread$) entry_queue;
 
 		// stack of conditions to run next once we exit the monitor
@@ -133,9 +133,9 @@
 	};
 	// Wrapper for gdb
-	struct cfathread_monitor_t { struct $monitor debug; };
+	struct cfathread_monitor_t { struct monitor$ debug; };
 
 	struct __monitor_group_t {
 		// currently held monitors
-		__cfa_anonymous_object( __small_array_t($monitor*) );
+		__cfa_anonymous_object( __small_array_t(monitor$*) );
 
 		// last function that acquired monitors
@@ -146,9 +146,9 @@
 	// instrusive link field for threads
 	struct __thread_desc_link {
-		struct $thread * next;
+		struct thread$ * next;
 		volatile unsigned long long ts;
 	};
 
-	struct $thread {
+	struct thread$ {
 		// Core threading fields
 		// context that is switch during a __cfactx_switch
@@ -179,14 +179,14 @@
 
 		// coroutine body used to store context
-		struct $coroutine  self_cor;
+		struct coroutine$  self_cor;
 
 		// current active context
-		struct $coroutine * curr_cor;
+		struct coroutine$ * curr_cor;
 
 		// monitor body used for mutual exclusion
-		struct $monitor    self_mon;
+		struct monitor$    self_mon;
 
 		// pointer to monitor with sufficient lifetime for current monitors
-		struct $monitor *  self_mon_p;
+		struct monitor$ *  self_mon_p;
 
 		// monitors currently held by this thread
@@ -195,14 +195,14 @@
 		// used to put threads on user data structures
 		struct {
-			struct $thread * next;
-			struct $thread * back;
+			struct thread$ * next;
+			struct thread$ * back;
 		} seqable;
 
 		// used to put threads on dlist data structure
-		__cfa_dlink($thread);
+		__cfa_dlink(thread$);
 
 		struct {
-			struct $thread * next;
-			struct $thread * prev;
+			struct thread$ * next;
+			struct thread$ * prev;
 		} node;
 
@@ -214,11 +214,11 @@
 	};
 	#ifdef __cforall
-		P9_EMBEDDED( $thread, dlink($thread) )
+		P9_EMBEDDED( thread$, dlink(thread$) )
 	#endif
 	// Wrapper for gdb
-	struct cfathread_thread_t { struct $thread debug; };
+	struct cfathread_thread_t { struct thread$ debug; };
 
 	#ifdef __CFA_DEBUG__
-		void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]);
+		void __cfaabi_dbg_record_thrd(thread$ & this, bool park, const char prev_name[]);
 	#else
 		#define __cfaabi_dbg_record_thrd(x, y, z)
@@ -228,25 +228,25 @@
 	extern "Cforall" {
 
-		static inline $thread *& get_next( $thread & this ) __attribute__((const)) {
+		static inline thread$ *& get_next( thread$ & this ) __attribute__((const)) {
 			return this.link.next;
 		}
 
-		static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) {
+		static inline [thread$ *&, thread$ *& ] __get( thread$ & this ) __attribute__((const)) {
 			return this.node.[next, prev];
 		}
 
-		static inline $thread * volatile & ?`next ( $thread * this )  __attribute__((const)) {
+		static inline thread$ * volatile & ?`next ( thread$ * this )  __attribute__((const)) {
 			return this->seqable.next;
 		}
 
-		static inline $thread *& Back( $thread * this ) __attribute__((const)) {
+		static inline thread$ *& Back( thread$ * this ) __attribute__((const)) {
 			return this->seqable.back;
 		}
 
-		static inline $thread *& Next( $thread * this ) __attribute__((const)) {
+		static inline thread$ *& Next( thread$ * this ) __attribute__((const)) {
 				return this->seqable.next;
 		}
 
-		static inline bool listed( $thread * this ) {
+		static inline bool listed( thread$ * this ) {
 			return this->seqable.next != 0p;
 		}
@@ -258,5 +258,5 @@
 		}
 
-		static inline void ?{}(__monitor_group_t & this, struct $monitor ** data, __lock_size_t size, fptr_t func) {
+		static inline void ?{}(__monitor_group_t & this, struct monitor$ ** data, __lock_size_t size, fptr_t func) {
 			(this.data){data};
 			(this.size){size};
Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/io.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -90,5 +90,5 @@
 	static inline unsigned __flush( struct $io_context & );
 	static inline __u32 __release_sqes( struct $io_context & );
-	extern void __kernel_unpark( $thread * thrd );
+	extern void __kernel_unpark( thread$ * thrd );
 
 	bool __cfa_io_drain( processor * proc ) {
Index: libcfa/src/concurrency/io/types.hfa
===================================================================
--- libcfa/src/concurrency/io/types.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/io/types.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -179,5 +179,5 @@
 
 static inline {
-	$thread * fulfil( io_future_t & this, __s32 result, bool do_unpark = true ) {
+	thread$ * fulfil( io_future_t & this, __s32 result, bool do_unpark = true ) {
 		this.result = result;
 		return fulfil(this.self, do_unpark);
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/kernel.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -110,13 +110,13 @@
 #endif
 
-extern $thread * mainThread;
+extern thread$ * mainThread;
 extern processor * mainProcessor;
 
 //-----------------------------------------------------------------------------
 // Kernel Scheduling logic
-static $thread * __next_thread(cluster * this);
-static $thread * __next_thread_slow(cluster * this);
-static inline bool __must_unpark( $thread * thrd ) __attribute((nonnull(1)));
-static void __run_thread(processor * this, $thread * dst);
+static thread$ * __next_thread(cluster * this);
+static thread$ * __next_thread_slow(cluster * this);
+static inline bool __must_unpark( thread$ * thrd ) __attribute((nonnull(1)));
+static void __run_thread(processor * this, thread$ * dst);
 static void __wake_one(cluster * cltr);
 
@@ -181,5 +181,5 @@
 		__cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this);
 
-		$thread * readyThread = 0p;
+		thread$ * readyThread = 0p;
 		MAIN_LOOP:
 		for() {
@@ -388,5 +388,5 @@
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
-static void __run_thread(processor * this, $thread * thrd_dst) {
+static void __run_thread(processor * this, thread$ * thrd_dst) {
 	/* paranoid */ verify( ! __preemption_enabled() );
 	/* paranoid */ verifyf( thrd_dst->state == Ready || thrd_dst->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", thrd_dst->state, thrd_dst->preempted);
@@ -396,5 +396,5 @@
 	__cfadbg_print_safe(runtime_core, "Kernel : core %p running thread %p (%s)\n", this, thrd_dst, thrd_dst->self_cor.name);
 
-	$coroutine * proc_cor = get_coroutine(this->runner);
+	coroutine$ * proc_cor = get_coroutine(this->runner);
 
 	// set state of processor coroutine to inactive
@@ -415,6 +415,6 @@
 		/* paranoid */ verify( thrd_dst->context.SP );
 		/* paranoid */ verify( thrd_dst->state != Halted );
-		/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
-		/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
+		/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
+		/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
 		/* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary );
 
@@ -428,6 +428,6 @@
 
 		/* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary );
-		/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
-		/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
+		/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
+		/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
 		/* paranoid */ verify( thrd_dst->context.SP );
 		/* paranoid */ verify( thrd_dst->curr_cluster == this->cltr );
@@ -497,6 +497,6 @@
 void returnToKernel() {
 	/* paranoid */ verify( ! __preemption_enabled() );
-	$coroutine * proc_cor = get_coroutine(kernelTLS().this_processor->runner);
-	$thread * thrd_src = kernelTLS().this_thread;
+	coroutine$ * proc_cor = get_coroutine(kernelTLS().this_processor->runner);
+	thread$ * thrd_src = kernelTLS().this_thread;
 
 	__STATS( thrd_src->last_proc = kernelTLS().this_processor; )
@@ -526,6 +526,6 @@
 
 	/* paranoid */ verify( ! __preemption_enabled() );
-	/* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ) || thrd_src->corctx_flag, "ERROR : Returning $thread %p has been corrupted.\n StackPointer too small.\n", thrd_src );
-	/* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit) || thrd_src->corctx_flag, "ERROR : Returning $thread %p has been corrupted.\n StackPointer too large.\n", thrd_src );
+	/* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ) || thrd_src->corctx_flag, "ERROR : Returning thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_src );
+	/* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit) || thrd_src->corctx_flag, "ERROR : Returning thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_src );
 }
 
@@ -533,5 +533,5 @@
 // Scheduler routines
 // KERNEL ONLY
-static void __schedule_thread( $thread * thrd ) {
+static void __schedule_thread( thread$ * thrd ) {
 	/* paranoid */ verify( ! __preemption_enabled() );
 	/* paranoid */ verify( ready_schedule_islocked());
@@ -583,5 +583,5 @@
 }
 
-void schedule_thread$( $thread * thrd ) {
+void schedule_thread$( thread$ * thrd ) {
 	ready_schedule_lock();
 		__schedule_thread( thrd );
@@ -590,9 +590,9 @@
 
 // KERNEL ONLY
-static inline $thread * __next_thread(cluster * this) with( *this ) {
+static inline thread$ * __next_thread(cluster * this) with( *this ) {
 	/* paranoid */ verify( ! __preemption_enabled() );
 
 	ready_schedule_lock();
-		$thread * thrd = pop_fast( this );
+		thread$ * thrd = pop_fast( this );
 	ready_schedule_unlock();
 
@@ -602,9 +602,9 @@
 
 // KERNEL ONLY
-static inline $thread * __next_thread_slow(cluster * this) with( *this ) {
+static inline thread$ * __next_thread_slow(cluster * this) with( *this ) {
 	/* paranoid */ verify( ! __preemption_enabled() );
 
 	ready_schedule_lock();
-		$thread * thrd;
+		thread$ * thrd;
 		for(25) {
 			thrd = pop_slow( this );
@@ -620,5 +620,5 @@
 }
 
-static inline bool __must_unpark( $thread * thrd ) {
+static inline bool __must_unpark( thread$ * thrd ) {
 	int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
 	switch(old_ticket) {
@@ -636,5 +636,5 @@
 }
 
-void __kernel_unpark( $thread * thrd ) {
+void __kernel_unpark( thread$ * thrd ) {
 	/* paranoid */ verify( ! __preemption_enabled() );
 	/* paranoid */ verify( ready_schedule_islocked());
@@ -651,5 +651,5 @@
 }
 
-void unpark( $thread * thrd ) {
+void unpark( thread$ * thrd ) {
 	if( !thrd ) return;
 
@@ -675,6 +675,6 @@
 	// Should never return
 	void __cfactx_thrd_leave() {
-		$thread * thrd = active_thread();
-		$monitor * this = &thrd->self_mon;
+		thread$ * thrd = active_thread();
+		monitor$ * this = &thrd->self_mon;
 
 		// Lock the monitor now
@@ -688,6 +688,6 @@
 		/* paranoid */ verify( kernelTLS().this_thread == thrd );
 		/* paranoid */ verify( thrd->context.SP );
-		/* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : $thread %p has been corrupted.\n StackPointer too large.\n", thrd );
-		/* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : $thread %p has been corrupted.\n StackPointer too small.\n", thrd );
+		/* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : thread$ %p has been corrupted.\n StackPointer too large.\n", thrd );
+		/* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : thread$ %p has been corrupted.\n StackPointer too small.\n", thrd );
 
 		thrd->state = Halting;
@@ -707,5 +707,5 @@
 bool force_yield( __Preemption_Reason reason ) {
 	__disable_interrupts_checked();
-		$thread * thrd = kernelTLS().this_thread;
+		thread$ * thrd = kernelTLS().this_thread;
 		/* paranoid */ verify(thrd->state == Active);
 
@@ -819,5 +819,5 @@
 //=============================================================================================
 void __kernel_abort_msg( char * abort_text, int abort_text_size ) {
-	$thread * thrd = __cfaabi_tls.this_thread;
+	thread$ * thrd = __cfaabi_tls.this_thread;
 
 	if(thrd) {
Index: libcfa/src/concurrency/kernel.hfa
===================================================================
--- libcfa/src/concurrency/kernel.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/kernel.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -115,5 +115,5 @@
 	// it is not a particularly safe scheme as it can make processors less homogeneous
 	struct {
-		$thread * thrd;
+		thread$ * thrd;
 	} init;
 
@@ -215,5 +215,5 @@
 	// List of threads
 	__spinlock_t thread_list_lock;
-	__dllist_t(struct $thread) threads;
+	__dllist_t(struct thread$) threads;
 	unsigned int nthreads;
 
Index: libcfa/src/concurrency/kernel/fwd.hfa
===================================================================
--- libcfa/src/concurrency/kernel/fwd.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/kernel/fwd.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -24,5 +24,5 @@
 #endif
 
-struct $thread;
+struct thread$;
 struct processor;
 struct cluster;
@@ -36,5 +36,5 @@
 	extern "Cforall" {
 		extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
-			struct $thread          * volatile this_thread;
+			struct thread$          * volatile this_thread;
 			struct processor        * volatile this_processor;
 			volatile bool sched_lock;
@@ -120,7 +120,7 @@
 	extern "Cforall" {
 		extern void park( void );
-		extern void unpark( struct $thread * this );
-		static inline struct $thread * active_thread () {
-			struct $thread * t = publicTLS_get( this_thread );
+		extern void unpark( struct thread$ * this );
+		static inline struct thread$ * active_thread () {
+			struct thread$ * t = publicTLS_get( this_thread );
 			/* paranoid */ verify( t );
 			return t;
@@ -144,5 +144,5 @@
 		// Semaphore which only supports a single thread
 		struct single_sem {
-			struct $thread * volatile ptr;
+			struct thread$ * volatile ptr;
 		};
 
@@ -156,5 +156,5 @@
 			bool wait(single_sem & this) {
 				for() {
-					struct $thread * expected = this.ptr;
+					struct thread$ * expected = this.ptr;
 					if(expected == 1p) {
 						if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
@@ -175,5 +175,5 @@
 			bool post(single_sem & this) {
 				for() {
-					struct $thread * expected = this.ptr;
+					struct thread$ * expected = this.ptr;
 					if(expected == 1p) return false;
 					if(expected == 0p) {
@@ -200,5 +200,5 @@
 			//     1p     : fulfilled (wait won't block)
 			// any thread : a thread is currently waiting
-			struct $thread * volatile ptr;
+			struct thread$ * volatile ptr;
 		};
 
@@ -214,5 +214,5 @@
 			bool wait(oneshot & this) {
 				for() {
-					struct $thread * expected = this.ptr;
+					struct thread$ * expected = this.ptr;
 					if(expected == 1p) return false;
 					/* paranoid */ verify( expected == 0p );
@@ -227,6 +227,6 @@
 			// Mark as fulfilled, wake thread if needed
 			// return true if a thread was unparked
-			$thread * post(oneshot & this, bool do_unpark = true) {
-				struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
+			thread$ * post(oneshot & this, bool do_unpark = true) {
+				struct thread$ * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
 				if( got == 0p ) return 0p;
 				if(do_unpark) unpark( got );
@@ -343,5 +343,5 @@
 			// from the server side, mark the future as fulfilled
 			// delete it if needed
-			$thread * fulfil( future_t & this, bool do_unpark = true  ) {
+			thread$ * fulfil( future_t & this, bool do_unpark = true  ) {
 				for() {
 					struct oneshot * expected = this.ptr;
@@ -364,5 +364,5 @@
 					if(__atomic_compare_exchange_n(&this.ptr, &expected, want, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
 						if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return 0p; }
-						$thread * ret = post( *expected, do_unpark );
+						thread$ * ret = post( *expected, do_unpark );
 						__atomic_store_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
 						return ret;
Index: libcfa/src/concurrency/kernel/startup.cfa
===================================================================
--- libcfa/src/concurrency/kernel/startup.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/kernel/startup.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -77,5 +77,5 @@
 static void __kernel_first_resume( processor * this );
 static void __kernel_last_resume ( processor * this );
-static void init(processor & this, const char name[], cluster & _cltr, $thread * initT);
+static void init(processor & this, const char name[], cluster & _cltr, thread$ * initT);
 static void deinit(processor & this);
 static void doregister( struct cluster & cltr );
@@ -83,6 +83,6 @@
 static void register_tls( processor * this );
 static void unregister_tls( processor * this );
-static void ?{}( $coroutine & this, current_stack_info_t * info);
-static void ?{}( $thread & this, current_stack_info_t * info);
+static void ?{}( coroutine$ & this, current_stack_info_t * info);
+static void ?{}( thread$ & this, current_stack_info_t * info);
 static void ?{}(processorCtx_t & this) {}
 static void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info);
@@ -105,5 +105,5 @@
 KERNEL_STORAGE(cluster,	             mainCluster);
 KERNEL_STORAGE(processor,            mainProcessor);
-KERNEL_STORAGE($thread,	             mainThread);
+KERNEL_STORAGE(thread$,	             mainThread);
 KERNEL_STORAGE(__stack_t,            mainThreadCtx);
 KERNEL_STORAGE(__scheduler_RWLock_t, __scheduler_lock);
@@ -114,5 +114,5 @@
 cluster              * mainCluster;
 processor            * mainProcessor;
-$thread              * mainThread;
+thread$              * mainThread;
 __scheduler_RWLock_t * __scheduler_lock;
 
@@ -203,5 +203,5 @@
 	// SKULLDUGGERY: the mainThread steals the process main thread
 	// which will then be scheduled by the mainProcessor normally
-	mainThread = ($thread *)&storage_mainThread;
+	mainThread = (thread$ *)&storage_mainThread;
 	current_stack_info_t info;
 	info.storage = (__stack_t*)&storage_mainThreadCtx;
@@ -397,6 +397,6 @@
 
 static void __kernel_first_resume( processor * this ) {
-	$thread * src = mainThread;
-	$coroutine * dst = get_coroutine(this->runner);
+	thread$ * src = mainThread;
+	coroutine$ * dst = get_coroutine(this->runner);
 
 	/* paranoid */ verify( ! __preemption_enabled() );
@@ -430,6 +430,6 @@
 // KERNEL_ONLY
 static void __kernel_last_resume( processor * this ) {
-	$coroutine * src = &mainThread->self_cor;
-	$coroutine * dst = get_coroutine(this->runner);
+	coroutine$ * src = &mainThread->self_cor;
+	coroutine$ * dst = get_coroutine(this->runner);
 
 	/* paranoid */ verify( ! __preemption_enabled() );
@@ -459,5 +459,5 @@
 //-----------------------------------------------------------------------------
 // Main thread construction
-static void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) {
+static void ?{}( coroutine$ & this, current_stack_info_t * info) with( this ) {
 	stack.storage = info->storage;
 	with(*stack.storage) {
@@ -474,5 +474,5 @@
 }
 
-static void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
+static void ?{}( thread$ & this, current_stack_info_t * info) with( this ) {
 	ticket = TICKET_RUNNING;
 	state = Start;
@@ -506,5 +506,5 @@
 }
 
-static void init(processor & this, const char name[], cluster & _cltr, $thread * initT) with( this ) {
+static void init(processor & this, const char name[], cluster & _cltr, thread$ * initT) with( this ) {
 	this.name = name;
 	this.cltr = &_cltr;
@@ -545,5 +545,5 @@
 }
 
-void ?{}(processor & this, const char name[], cluster & _cltr, $thread * initT) {
+void ?{}(processor & this, const char name[], cluster & _cltr, thread$ * initT) {
 	( this.terminated ){};
 	( this.runner ){};
@@ -663,5 +663,5 @@
 }
 
-void doregister( cluster * cltr, $thread & thrd ) {
+void doregister( cluster * cltr, thread$ & thrd ) {
 	lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
 	cltr->nthreads += 1;
@@ -670,5 +670,5 @@
 }
 
-void unregister( cluster * cltr, $thread & thrd ) {
+void unregister( cluster * cltr, thread$ & thrd ) {
 	lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
 	remove(cltr->threads, thrd );
Index: libcfa/src/concurrency/kernel_private.hfa
===================================================================
--- libcfa/src/concurrency/kernel_private.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/kernel_private.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -46,10 +46,10 @@
 }
 
-void schedule_thread$( $thread * ) __attribute__((nonnull (1)));
+void schedule_thread$( thread$ * ) __attribute__((nonnull (1)));
 
 extern bool __preemption_enabled();
 
 //release/wake-up the following resources
-void __thread_finish( $thread * thrd );
+void __thread_finish( thread$ * thrd );
 
 //-----------------------------------------------------------------------------
@@ -95,6 +95,6 @@
 
 __cfaabi_dbg_debug_do(
-	extern void __cfaabi_dbg_thread_register  ( $thread * thrd );
-	extern void __cfaabi_dbg_thread_unregister( $thread * thrd );
+	extern void __cfaabi_dbg_thread_register  ( thread$ * thrd );
+	extern void __cfaabi_dbg_thread_unregister( thread$ * thrd );
 )
 
@@ -105,6 +105,6 @@
 //-----------------------------------------------------------------------------
 // Utils
-void doregister( struct cluster * cltr, struct $thread & thrd );
-void unregister( struct cluster * cltr, struct $thread & thrd );
+void doregister( struct cluster * cltr, struct thread$ & thrd );
+void unregister( struct cluster * cltr, struct thread$ & thrd );
 
 //-----------------------------------------------------------------------------
@@ -300,5 +300,5 @@
 // push thread onto a ready queue for a cluster
 // returns true if the list was previously empty, false otherwise
-__attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool local);
+__attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool local);
 
 //-----------------------------------------------------------------------
@@ -306,5 +306,5 @@
 // returns 0p if empty
 // May return 0p spuriously
-__attribute__((hot)) struct $thread * pop_fast(struct cluster * cltr);
+__attribute__((hot)) struct thread$ * pop_fast(struct cluster * cltr);
 
 //-----------------------------------------------------------------------
@@ -312,5 +312,5 @@
 // returns 0p if empty
 // May return 0p spuriously
-__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr);
+__attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr);
 
 //-----------------------------------------------------------------------
@@ -318,5 +318,5 @@
 // returns 0p if empty
 // guaranteed to find any threads added before this call
-__attribute__((hot)) struct $thread * pop_search(struct cluster * cltr);
+__attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr);
 
 //-----------------------------------------------------------------------
Index: libcfa/src/concurrency/locks.cfa
===================================================================
--- libcfa/src/concurrency/locks.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/locks.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -32,5 +32,5 @@
 
 		// waiting thread
-		struct $thread * t;
+		struct thread$ * t;
 
 		// shadow field
@@ -45,5 +45,5 @@
 	P9_EMBEDDED( info_thread(L), dlink(info_thread(L)) )
 
-	void ?{}( info_thread(L) & this, $thread * t, uintptr_t info, L * l ) {
+	void ?{}( info_thread(L) & this, thread$ * t, uintptr_t info, L * l ) {
 		this.t = t;
 		this.info = info;
@@ -71,5 +71,5 @@
 void lock( blocking_lock & this ) with( this ) {
 	lock( lock __cfaabi_dbg_ctx2 );
-	$thread * thrd = active_thread();
+	thread$ * thrd = active_thread();
 
 	// single acquisition lock is held by current thread
@@ -117,5 +117,5 @@
 
 void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
-	$thread * t = &try_pop_front( blocked_threads );
+	thread$ * t = &try_pop_front( blocked_threads );
 	owner = t;
 	recursion_count = ( t ? 1 : 0 );
@@ -142,5 +142,5 @@
 }
 
-void on_notify( blocking_lock & this, $thread * t ) with( this ) {
+void on_notify( blocking_lock & this, thread$ * t ) with( this ) {
 	lock( lock __cfaabi_dbg_ctx2 );
 	// lock held
@@ -366,6 +366,6 @@
 }
 
-$thread * V (semaphore & this, const bool doUnpark ) with( this ) {
-	$thread * thrd = 0p;
+thread$ * V (semaphore & this, const bool doUnpark ) with( this ) {
+	thread$ * thrd = 0p;
 	lock( lock __cfaabi_dbg_ctx2 );
 	count += 1;
@@ -384,10 +384,10 @@
 
 bool V(semaphore & this) with( this ) {
-	$thread * thrd = V(this, true);
+	thread$ * thrd = V(this, true);
 	return thrd != 0p;
 }
 
 bool V(semaphore & this, unsigned diff) with( this ) {
-	$thread * thrd = 0p;
+	thread$ * thrd = 0p;
 	lock( lock __cfaabi_dbg_ctx2 );
 	int release = max(-count, (int)diff);
Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/locks.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -39,8 +39,8 @@
 struct Semaphore0nary {
 	__spinlock_t lock; // needed to protect
-	mpsc_queue($thread) queue;
-};
-
-static inline bool P(Semaphore0nary & this, $thread * thrd) {
+	mpsc_queue(thread$) queue;
+};
+
+static inline bool P(Semaphore0nary & this, thread$ * thrd) {
 	/* paranoid */ verify(!thrd`next);
 	/* paranoid */ verify(!(&(*thrd)`next));
@@ -51,5 +51,5 @@
 
 static inline bool P(Semaphore0nary & this) {
-    $thread * thrd = active_thread();
+    thread$ * thrd = active_thread();
     P(this, thrd);
     park();
@@ -57,6 +57,6 @@
 }
 
-static inline $thread * V(Semaphore0nary & this, bool doUnpark = true) {
-	$thread * next;
+static inline thread$ * V(Semaphore0nary & this, bool doUnpark = true) {
+	thread$ * next;
 	lock(this.lock __cfaabi_dbg_ctx2);
 		for (;;) {
@@ -124,5 +124,5 @@
 static inline bool P(ThreadBenaphore & this, bool wait)   { return wait ? P(this) : tryP(this); }
 
-static inline $thread * V(ThreadBenaphore & this, bool doUnpark = true) {
+static inline thread$ * V(ThreadBenaphore & this, bool doUnpark = true) {
 	if (V(this.ben)) return 0p;
 	return V(this.sem, doUnpark);
@@ -134,5 +134,5 @@
 	__spinlock_t lock;
 	int count;
-	__queue_t($thread) waiting;
+	__queue_t(thread$) waiting;
 };
 
@@ -142,5 +142,5 @@
 bool   V (semaphore & this);
 bool   V (semaphore & this, unsigned count);
-$thread * V (semaphore & this, bool );
+thread$ * V (semaphore & this, bool );
 
 //----------
@@ -156,5 +156,5 @@
 static inline size_t on_wait  ( single_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
 static inline void   on_wakeup( single_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
-static inline void   on_notify( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline void   on_notify( single_acquisition_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
 
 //----------
@@ -170,8 +170,8 @@
 static inline size_t on_wait  ( owner_lock & this ) { return on_wait ( (blocking_lock &)this ); }
 static inline void   on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
-static inline void   on_notify( owner_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline void   on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
 
 struct fast_lock {
-	$thread * volatile owner;
+	thread$ * volatile owner;
 	ThreadBenaphore sem;
 };
@@ -179,6 +179,6 @@
 static inline void ?{}(fast_lock & this) { this.owner = 0p; }
 
-static inline bool $try_lock(fast_lock & this, $thread * thrd) {
-    $thread * exp = 0p;
+static inline bool $try_lock(fast_lock & this, thread$ * thrd) {
+    thread$ * exp = 0p;
     return __atomic_compare_exchange_n(&this.owner, &exp, thrd, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED);
 }
@@ -186,5 +186,5 @@
 static inline void lock( fast_lock & this ) __attribute__((artificial));
 static inline void lock( fast_lock & this ) {
-	$thread * thrd = active_thread();
+	thread$ * thrd = active_thread();
 	/* paranoid */verify(thrd != this.owner);
 
@@ -197,11 +197,11 @@
 static inline bool try_lock( fast_lock & this ) __attribute__((artificial));
 static inline bool try_lock ( fast_lock & this ) {
-	$thread * thrd = active_thread();
+	thread$ * thrd = active_thread();
 	/* paranoid */ verify(thrd != this.owner);
 	return $try_lock(this, thrd);
 }
 
-static inline $thread * unlock( fast_lock & this ) __attribute__((artificial));
-static inline $thread * unlock( fast_lock & this ) {
+static inline thread$ * unlock( fast_lock & this ) __attribute__((artificial));
+static inline thread$ * unlock( fast_lock & this ) {
 	/* paranoid */ verify(active_thread() == this.owner);
 
@@ -216,5 +216,5 @@
 static inline size_t on_wait( fast_lock & this ) { unlock(this); return 0; }
 static inline void on_wakeup( fast_lock & this, size_t ) { lock(this); }
-static inline void on_notify( fast_lock &, struct $thread * t ) { unpark(t); }
+static inline void on_notify( fast_lock &, struct thread$ * t ) { unpark(t); }
 
 struct mcs_node {
@@ -248,8 +248,8 @@
 
 	// Current thread owning the lock
-	struct $thread * owner;
+	struct thread$ * owner;
 
 	// List of blocked threads
-	dlist( $thread ) blocked_threads;
+	dlist( thread$ ) blocked_threads;
 
 	// Used for comparing and exchanging
@@ -343,5 +343,5 @@
 	// block until signalled
 	while (block(this)) if(try_lock_contention(this)) return true;
-	
+
 	// this should never be reached as block(this) always returns true
 	return false;
@@ -385,5 +385,5 @@
 	// block until signalled
 	while (block(this)) if(try_lock_contention(this)) return true;
-	
+
 	// this should never be reached as block(this) always returns true
 	return false;
@@ -395,10 +395,10 @@
     if (__atomic_exchange_n(&lock_value, 0, __ATOMIC_RELEASE) == 1) return;
 	lock( spinlock __cfaabi_dbg_ctx2 );
-	$thread * t = &try_pop_front( blocked_threads );
+	thread$ * t = &try_pop_front( blocked_threads );
 	unlock( spinlock );
 	unpark( t );
 }
 
-static inline void on_notify(linear_backoff_then_block_lock & this, struct $thread * t ) { unpark(t); }
+static inline void on_notify(linear_backoff_then_block_lock & this, struct thread$ * t ) { unpark(t); }
 static inline size_t on_wait(linear_backoff_then_block_lock & this) { unlock(this); return 0; }
 static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) { lock_improved(this); }
@@ -408,5 +408,5 @@
 trait is_blocking_lock(L & | sized(L)) {
 	// For synchronization locks to use when acquiring
-	void on_notify( L &, struct $thread * );
+	void on_notify( L &, struct thread$ * );
 
 	// For synchronization locks to use when releasing
@@ -442,5 +442,5 @@
 		int count;
 	};
-	
+
 
 	void  ?{}( condition_variable(L) & this );
Index: libcfa/src/concurrency/monitor.cfa
===================================================================
--- libcfa/src/concurrency/monitor.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/monitor.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// $monitor.c --
+// monitor.cfa --
 //
 // Author           : Thierry Delisle
@@ -28,31 +28,31 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-static inline void __set_owner ( $monitor * this, $thread * owner );
-static inline void __set_owner ( $monitor * storage [], __lock_size_t count, $thread * owner );
-static inline void set_mask  ( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
-static inline void reset_mask( $monitor * this );
-
-static inline $thread * next_thread( $monitor * this );
-static inline bool is_accepted( $monitor * this, const __monitor_group_t & monitors );
+static inline void __set_owner ( monitor$ * this, thread$ * owner );
+static inline void __set_owner ( monitor$ * storage [], __lock_size_t count, thread$ * owner );
+static inline void set_mask  ( monitor$ * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
+static inline void reset_mask( monitor$ * this );
+
+static inline thread$ * next_thread( monitor$ * this );
+static inline bool is_accepted( monitor$ * this, const __monitor_group_t & monitors );
 
 static inline void lock_all  ( __spinlock_t * locks [], __lock_size_t count );
-static inline void lock_all  ( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
+static inline void lock_all  ( monitor$ * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
 static inline void unlock_all( __spinlock_t * locks [], __lock_size_t count );
-static inline void unlock_all( $monitor * locks [], __lock_size_t count );
-
-static inline void save   ( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
-static inline void restore( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
-
-static inline void init     ( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-
-static inline $thread *        check_condition   ( __condition_criterion_t * );
+static inline void unlock_all( monitor$ * locks [], __lock_size_t count );
+
+static inline void save   ( monitor$ * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
+static inline void restore( monitor$ * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
+
+static inline void init     ( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+static inline void init_push( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+
+static inline thread$ *        check_condition   ( __condition_criterion_t * );
 static inline void                 brand_condition   ( condition & );
-static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count );
+static inline [thread$ *, int] search_entry_queue( const __waitfor_mask_t &, monitor$ * monitors [], __lock_size_t count );
 
 forall(T & | sized( T ))
 static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val );
 static inline __lock_size_t count_max    ( const __waitfor_mask_t & mask );
-static inline __lock_size_t aggregate    ( $monitor * storage [], const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate    ( monitor$ * storage [], const __waitfor_mask_t & mask );
 
 //-----------------------------------------------------------------------------
@@ -69,5 +69,5 @@
 
 #define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
-	$monitor ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
+	monitor$ ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
 	__lock_size_t count = cnt;                                /* Save the count to a local variable                                                  */ \
 	unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
@@ -82,6 +82,6 @@
 // Enter/Leave routines
 // Enter single monitor
-static void __enter( $monitor * this, const __monitor_group_t & group ) {
-	$thread * thrd = active_thread();
+static void __enter( monitor$ * this, const __monitor_group_t & group ) {
+	thread$ * thrd = active_thread();
 
 	// Lock the monitor spinlock
@@ -141,6 +141,6 @@
 }
 
-static void __dtor_enter( $monitor * this, fptr_t func, bool join ) {
-	$thread * thrd = active_thread();
+static void __dtor_enter( monitor$ * this, fptr_t func, bool join ) {
+	thread$ * thrd = active_thread();
 	#if defined( __CFA_WITH_VERIFY__ )
 		bool is_thrd = this == &thrd->self_mon;
@@ -173,5 +173,5 @@
 	// because join will not release the monitor after it executed.
 	// to avoid that it sets the owner to the special value thrd | 1p before exiting
-	else if( this->owner == ($thread*)(1 | (uintptr_t)thrd) ) {
+	else if( this->owner == (thread$*)(1 | (uintptr_t)thrd) ) {
 		// restore the owner and just return
 		__cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
@@ -191,5 +191,5 @@
 
 	__lock_size_t count = 1;
-	$monitor ** monitors = &this;
+	monitor$ ** monitors = &this;
 	__monitor_group_t group = { &this, 1, func };
 	if( is_accepted( this, group) ) {
@@ -243,5 +243,5 @@
 
 // Leave single monitor
-void __leave( $monitor * this ) {
+void __leave( monitor$ * this ) {
 	// Lock the monitor spinlock
 	lock( this->lock __cfaabi_dbg_ctx2 );
@@ -263,5 +263,5 @@
 
 	// Get the next thread, will be null on low contention monitor
-	$thread * new_owner = next_thread( this );
+	thread$ * new_owner = next_thread( this );
 
 	// Check the new owner is consistent with who we wake-up
@@ -278,5 +278,5 @@
 
 // Leave single monitor for the last time
-void __dtor_leave( $monitor * this, bool join ) {
+void __dtor_leave( monitor$ * this, bool join ) {
 	__cfaabi_dbg_debug_do(
 		if( active_thread() != this->owner ) {
@@ -288,9 +288,9 @@
 	)
 
-	this->owner = ($thread*)(1 | (uintptr_t)this->owner);
-}
-
-void __thread_finish( $thread * thrd ) {
-	$monitor * this = &thrd->self_mon;
+	this->owner = (thread$*)(1 | (uintptr_t)this->owner);
+}
+
+void __thread_finish( thread$ * thrd ) {
+	monitor$ * this = &thrd->self_mon;
 
 	// Lock the monitor now
@@ -298,6 +298,6 @@
 	/* paranoid */ verify( this->lock.lock );
 	/* paranoid */ verify( thrd->context.SP );
-	/* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : $thread %p has been corrupted.\n StackPointer too large.\n", thrd );
-	/* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : $thread %p has been corrupted.\n StackPointer too small.\n", thrd );
+	/* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : thread$ %p has been corrupted.\n StackPointer too large.\n", thrd );
+	/* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : thread$ %p has been corrupted.\n StackPointer too small.\n", thrd );
 	/* paranoid */ verify( ! __preemption_enabled() );
 
@@ -311,5 +311,5 @@
 
 	// Fetch the next thread, can be null
-	$thread * new_owner = next_thread( this );
+	thread$ * new_owner = next_thread( this );
 
 	// Mark the state as fully halted
@@ -336,5 +336,5 @@
 // Leave multiple monitor
 // relies on the monitor array being sorted
-static inline void leave($monitor * monitors [], __lock_size_t count) {
+static inline void leave(monitor$ * monitors [], __lock_size_t count) {
 	for( __lock_size_t i = count - 1; i >= 0; i--) {
 		__leave( monitors[i] );
@@ -344,6 +344,6 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, $monitor * m [], __lock_size_t count, fptr_t func ) {
-	$thread * thrd = active_thread();
+void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count, fptr_t func ) {
+	thread$ * thrd = active_thread();
 
 	// Store current array
@@ -385,7 +385,7 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func, bool join ) {
+void ?{}( monitor_dtor_guard_t & this, monitor$ * m [], fptr_t func, bool join ) {
 	// optimization
-	$thread * thrd = active_thread();
+	thread$ * thrd = active_thread();
 
 	// Store current array
@@ -415,5 +415,5 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling types
-void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
+void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
 	this.waiting_thread = waiting_thread;
 	this.count = count;
@@ -429,5 +429,5 @@
 }
 
-void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) {
+void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t & owner ) {
 	this.ready  = false;
 	this.target = target;
@@ -463,5 +463,5 @@
 	// Find the next thread(s) to run
 	__lock_size_t thread_count = 0;
-	$thread * threads[ count ];
+	thread$ * threads[ count ];
 	__builtin_memset( threads, 0, sizeof( threads ) );
 
@@ -471,5 +471,5 @@
 	// Remove any duplicate threads
 	for( __lock_size_t i = 0; i < count; i++) {
-		$thread * new_owner = next_thread( monitors[i] );
+		thread$ * new_owner = next_thread( monitors[i] );
 		insert_unique( threads, thread_count, new_owner );
 	}
@@ -501,5 +501,5 @@
 	//Some more checking in debug
 	__cfaabi_dbg_debug_do(
-		$thread * this_thrd = active_thread();
+		thread$ * this_thrd = active_thread();
 		if ( this.monitor_count != this_thrd->monitors.size ) {
 			abort( "Signal on condition %p made with different number of monitor(s), expected %zi got %zi", &this, this.monitor_count, this_thrd->monitors.size );
@@ -555,5 +555,5 @@
 
 	//Find the thread to run
-	$thread * signallee = pop_head( this.blocked )->waiting_thread;
+	thread$ * signallee = pop_head( this.blocked )->waiting_thread;
 	__set_owner( monitors, count, signallee );
 
@@ -608,5 +608,5 @@
 	// Create one!
 	__lock_size_t max = count_max( mask );
-	$monitor * mon_storage[max];
+	monitor$ * mon_storage[max];
 	__builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
 	__lock_size_t actual_count = aggregate( mon_storage, mask );
@@ -626,5 +626,5 @@
 	{
 		// Check if the entry queue
-		$thread * next; int index;
+		thread$ * next; int index;
 		[next, index] = search_entry_queue( mask, monitors, count );
 
@@ -636,5 +636,5 @@
 				verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
-				$monitor * mon2dtor = accepted[0];
+				monitor$ * mon2dtor = accepted[0];
 				verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
 
@@ -730,5 +730,5 @@
 // Utilities
 
-static inline void __set_owner( $monitor * this, $thread * owner ) {
+static inline void __set_owner( monitor$ * this, thread$ * owner ) {
 	/* paranoid */ verify( this->lock.lock );
 
@@ -740,5 +740,5 @@
 }
 
-static inline void __set_owner( $monitor * monitors [], __lock_size_t count, $thread * owner ) {
+static inline void __set_owner( monitor$ * monitors [], __lock_size_t count, thread$ * owner ) {
 	/* paranoid */ verify ( monitors[0]->lock.lock );
 	/* paranoid */ verifyf( monitors[0]->owner == active_thread(), "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), monitors[0]->owner, monitors[0]->recursion, monitors[0] );
@@ -753,5 +753,5 @@
 }
 
-static inline void set_mask( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
+static inline void set_mask( monitor$ * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
 	for( __lock_size_t i = 0; i < count; i++) {
 		storage[i]->mask = mask;
@@ -759,5 +759,5 @@
 }
 
-static inline void reset_mask( $monitor * this ) {
+static inline void reset_mask( monitor$ * this ) {
 	this->mask.accepted = 0p;
 	this->mask.data = 0p;
@@ -765,5 +765,5 @@
 }
 
-static inline $thread * next_thread( $monitor * this ) {
+static inline thread$ * next_thread( monitor$ * this ) {
 	//Check the signaller stack
 	__cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
@@ -781,5 +781,5 @@
 	// No signaller thread
 	// Get the next thread in the entry_queue
-	$thread * new_owner = pop_head( this->entry_queue );
+	thread$ * new_owner = pop_head( this->entry_queue );
 	/* paranoid */ verifyf( !this->owner || active_thread() == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), this->owner, this->recursion, this );
 	/* paranoid */ verify( !new_owner || new_owner->link.next == 0p );
@@ -789,5 +789,5 @@
 }
 
-static inline bool is_accepted( $monitor * this, const __monitor_group_t & group ) {
+static inline bool is_accepted( monitor$ * this, const __monitor_group_t & group ) {
 	__acceptable_t * it = this->mask.data; // Optim
 	__lock_size_t count = this->mask.size;
@@ -811,5 +811,5 @@
 }
 
-static inline void init( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
 	for( __lock_size_t i = 0; i < count; i++) {
 		(criteria[i]){ monitors[i], waiter };
@@ -819,5 +819,5 @@
 }
 
-static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init_push( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
 	for( __lock_size_t i = 0; i < count; i++) {
 		(criteria[i]){ monitors[i], waiter };
@@ -835,5 +835,5 @@
 }
 
-static inline void lock_all( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
+static inline void lock_all( monitor$ * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
 	for( __lock_size_t i = 0; i < count; i++ ) {
 		__spinlock_t * l = &source[i]->lock;
@@ -849,5 +849,5 @@
 }
 
-static inline void unlock_all( $monitor * locks [], __lock_size_t count ) {
+static inline void unlock_all( monitor$ * locks [], __lock_size_t count ) {
 	for( __lock_size_t i = 0; i < count; i++ ) {
 		unlock( locks[i]->lock );
@@ -856,5 +856,5 @@
 
 static inline void save(
-	$monitor * ctx [],
+	monitor$ * ctx [],
 	__lock_size_t count,
 	__attribute((unused)) __spinlock_t * locks [],
@@ -869,5 +869,5 @@
 
 static inline void restore(
-	$monitor * ctx [],
+	monitor$ * ctx [],
 	__lock_size_t count,
 	__spinlock_t * locks [],
@@ -887,5 +887,5 @@
 // 2 - Checks if all the monitors are ready to run
 //     if so return the thread to run
-static inline $thread * check_condition( __condition_criterion_t * target ) {
+static inline thread$ * check_condition( __condition_criterion_t * target ) {
 	__condition_node_t * node = target->owner;
 	unsigned short count = node->count;
@@ -910,5 +910,5 @@
 
 static inline void brand_condition( condition & this ) {
-	$thread * thrd = active_thread();
+	thread$ * thrd = active_thread();
 	if( !this.monitors ) {
 		// __cfaabi_dbg_print_safe( "Branding\n" );
@@ -916,5 +916,5 @@
 		this.monitor_count = thrd->monitors.size;
 
-		this.monitors = ($monitor **)malloc( this.monitor_count * sizeof( *this.monitors ) );
+		this.monitors = (monitor$ **)malloc( this.monitor_count * sizeof( *this.monitors ) );
 		for( int i = 0; i < this.monitor_count; i++ ) {
 			this.monitors[i] = thrd->monitors[i];
@@ -923,10 +923,10 @@
 }
 
-static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t & mask, $monitor * monitors [], __lock_size_t count ) {
-
-	__queue_t($thread) & entry_queue = monitors[0]->entry_queue;
+static inline [thread$ *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor$ * monitors [], __lock_size_t count ) {
+
+	__queue_t(thread$) & entry_queue = monitors[0]->entry_queue;
 
 	// For each thread in the entry-queue
-	for(	$thread ** thrd_it = &entry_queue.head;
+	for(	thread$ ** thrd_it = &entry_queue.head;
 		(*thrd_it) != 1p;
 		thrd_it = &(*thrd_it)->link.next
@@ -972,5 +972,5 @@
 }
 
-static inline __lock_size_t aggregate( $monitor * storage [], const __waitfor_mask_t & mask ) {
+static inline __lock_size_t aggregate( monitor$ * storage [], const __waitfor_mask_t & mask ) {
 	__lock_size_t size = 0;
 	for( __lock_size_t i = 0; i < mask.size; i++ ) {
Index: libcfa/src/concurrency/monitor.hfa
===================================================================
--- libcfa/src/concurrency/monitor.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/monitor.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -23,9 +23,9 @@
 
 trait is_monitor(T &) {
-	$monitor * get_monitor( T & );
+	monitor$ * get_monitor( T & );
 	void ^?{}( T & mutex );
 };
 
-static inline void ?{}($monitor & this) with( this ) {
+static inline void ?{}(monitor$ & this) with( this ) {
 	lock{};
 	entry_queue{};
@@ -39,22 +39,22 @@
 }
 
-static inline void ^?{}($monitor & ) {}
+static inline void ^?{}(monitor$ & ) {}
 
 struct monitor_guard_t {
-	$monitor ** 	m;
+	monitor$ ** 	m;
 	__lock_size_t   	count;
 	__monitor_group_t prev;
 };
 
-void ?{}( monitor_guard_t & this, $monitor ** m, __lock_size_t count, void (*func)() );
+void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)() );
 void ^?{}( monitor_guard_t & this );
 
 struct monitor_dtor_guard_t {
-	$monitor *    m;
+	monitor$ *    m;
 	__monitor_group_t prev;
 	bool join;
 };
 
-void ?{}( monitor_dtor_guard_t & this, $monitor ** m, void (*func)(), bool join );
+void ?{}( monitor_dtor_guard_t & this, monitor$ ** m, void (*func)(), bool join );
 void ^?{}( monitor_dtor_guard_t & this );
 
@@ -73,5 +73,5 @@
 
 	// The monitor this criterion concerns
-	$monitor * target;
+	monitor$ * target;
 
 	// The parent node to which this criterion belongs
@@ -88,5 +88,5 @@
 struct __condition_node_t {
 	// Thread that needs to be woken when all criteria are met
-	$thread * waiting_thread;
+	thread$ * waiting_thread;
 
 	// Array of criteria (Criterions are contiguous in memory)
@@ -107,7 +107,7 @@
 }
 
-void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info );
+void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info );
 void ?{}(__condition_criterion_t & this );
-void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t * owner );
+void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t * owner );
 
 struct condition {
@@ -116,5 +116,5 @@
 
 	// Array of monitor pointers (Monitors are NOT contiguous in memory)
-	$monitor ** monitors;
+	monitor$ ** monitors;
 
 	// Number of monitors in the array
Index: libcfa/src/concurrency/mutex.cfa
===================================================================
--- libcfa/src/concurrency/mutex.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/mutex.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -122,5 +122,5 @@
 	recursion_count--;
 	if( recursion_count == 0 ) {
-		$thread * thrd = pop_head( blocked_threads );
+		thread$ * thrd = pop_head( blocked_threads );
 		owner = thrd;
 		recursion_count = (thrd ? 1 : 0);
Index: libcfa/src/concurrency/mutex.hfa
===================================================================
--- libcfa/src/concurrency/mutex.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/mutex.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -36,5 +36,5 @@
 
 	// List of blocked threads
-	__queue_t(struct $thread) blocked_threads;
+	__queue_t(struct thread$) blocked_threads;
 
 	// Locked flag
@@ -55,8 +55,8 @@
 
 	// List of blocked threads
-	__queue_t(struct $thread) blocked_threads;
+	__queue_t(struct thread$) blocked_threads;
 
 	// Current thread owning the lock
-	struct $thread * owner;
+	struct thread$ * owner;
 
 	// Number of recursion level
@@ -83,5 +83,5 @@
 
 	// List of blocked threads
-	__queue_t(struct $thread) blocked_threads;
+	__queue_t(struct thread$) blocked_threads;
 };
 
Index: libcfa/src/concurrency/preemption.cfa
===================================================================
--- libcfa/src/concurrency/preemption.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/preemption.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -61,5 +61,5 @@
 // FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
-static void timeout( $thread * this );
+static void timeout( thread$ * this );
 
 // FwdDeclarations : Signal handlers
@@ -420,5 +420,5 @@
 
 // reserved for future use
-static void timeout( $thread * this ) {
+static void timeout( thread$ * this ) {
 	unpark( this );
 }
Index: libcfa/src/concurrency/ready_queue.cfa
===================================================================
--- libcfa/src/concurrency/ready_queue.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/ready_queue.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -67,7 +67,7 @@
 #endif
 
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats));
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats));
-static inline struct $thread * search(struct cluster * cltr);
+static inline struct thread$ * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats));
+static inline struct thread$ * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats));
+static inline struct thread$ * search(struct cluster * cltr);
 static inline [unsigned, bool] idx_from_r(unsigned r, unsigned preferred);
 
@@ -274,5 +274,5 @@
 //-----------------------------------------------------------------------
 #if defined(USE_CPU_WORK_STEALING)
-	__attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) {
+	__attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) {
 		__cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
 
@@ -316,5 +316,5 @@
 
 	// Pop from the ready queue from a given cluster
-	__attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
+	__attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
 		/* paranoid */ verify( lanes.count > 0 );
 		/* paranoid */ verify( kernelTLS().this_processor );
@@ -371,5 +371,5 @@
 				proc->rdq.target = -1u;
 				if(lanes.tscs[target].tv < cutoff && ts(lanes.data[target]) < cutoff) {
-					$thread * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
+					thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
 					proc->rdq.last = target;
 					if(t) return t;
@@ -379,5 +379,5 @@
 			unsigned last = proc->rdq.last;
 			if(last != -1u && lanes.tscs[last].tv < cutoff && ts(lanes.data[last]) < cutoff) {
-				$thread * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.help));
+				thread$ * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.help));
 				if(t) return t;
 			}
@@ -389,5 +389,5 @@
 		for(READYQ_SHARD_FACTOR) {
 			unsigned i = start + (proc->rdq.itr++ % READYQ_SHARD_FACTOR);
-			if($thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
+			if(thread$ * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
 		}
 
@@ -396,9 +396,9 @@
 	}
 
-	__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
+	__attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
 		processor * const proc = kernelTLS().this_processor;
 		unsigned last = proc->rdq.last;
 		if(last != -1u) {
-			struct $thread * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.steal));
+			struct thread$ * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.steal));
 			if(t) return t;
 			proc->rdq.last = -1u;
@@ -408,5 +408,5 @@
 		return try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal));
 	}
-	__attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) {
+	__attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) {
 		return search(cltr);
 	}
@@ -435,5 +435,5 @@
 	}
 
-	__attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) {
+	__attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) {
 		__cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
 
@@ -482,5 +482,5 @@
 
 	// Pop from the ready queue from a given cluster
-	__attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
+	__attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
 		/* paranoid */ verify( lanes.count > 0 );
 		/* paranoid */ verify( kernelTLS().this_processor );
@@ -506,5 +506,5 @@
 
 			// try popping from the 2 picked lists
-			struct $thread * thrd = try_pop(cltr, i, j __STATS(, *(locali || localj ? &__tls_stats()->ready.pop.local : &__tls_stats()->ready.pop.help)));
+			struct thread$ * thrd = try_pop(cltr, i, j __STATS(, *(locali || localj ? &__tls_stats()->ready.pop.local : &__tls_stats()->ready.pop.help)));
 			if(thrd) {
 				return thrd;
@@ -516,11 +516,11 @@
 	}
 
-	__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) { return pop_fast(cltr); }
-	__attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) {
+	__attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) { return pop_fast(cltr); }
+	__attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) {
 		return search(cltr);
 	}
 #endif
 #if defined(USE_WORK_STEALING)
-	__attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) {
+	__attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) {
 		__cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
 
@@ -576,5 +576,5 @@
 
 	// Pop from the ready queue from a given cluster
-	__attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
+	__attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
 		/* paranoid */ verify( lanes.count > 0 );
 		/* paranoid */ verify( kernelTLS().this_processor );
@@ -598,5 +598,5 @@
 			const unsigned long long cutoff = proc->rdq.cutoff > bias ? proc->rdq.cutoff - bias : proc->rdq.cutoff;
 			if(lanes.tscs[target].tv < cutoff && ts(lanes.data[target]) < cutoff) {
-				$thread * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
+				thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
 				if(t) return t;
 			}
@@ -605,15 +605,15 @@
 		for(READYQ_SHARD_FACTOR) {
 			unsigned i = proc->rdq.id + (proc->rdq.itr++ % READYQ_SHARD_FACTOR);
-			if($thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
+			if(thread$ * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
 		}
 		return 0p;
 	}
 
-	__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
+	__attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
 		unsigned i = __tls_rand() % lanes.count;
 		return try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal));
 	}
 
-	__attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) with (cltr->ready_queue) {
+	__attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) with (cltr->ready_queue) {
 		return search(cltr);
 	}
@@ -628,5 +628,5 @@
 //-----------------------------------------------------------------------
 // try to pop from a lane given by index w
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
+static inline struct thread$ * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
 	__STATS( stats.attempt++; )
 
@@ -651,5 +651,5 @@
 
 	// Actually pop the list
-	struct $thread * thrd;
+	struct thread$ * thrd;
 	unsigned long long tsv;
 	[thrd, tsv] = pop(lane);
@@ -678,5 +678,5 @@
 // try to pop from any lanes making sure you don't miss any threads push
 // before the start of the function
-static inline struct $thread * search(struct cluster * cltr) with (cltr->ready_queue) {
+static inline struct thread$ * search(struct cluster * cltr) with (cltr->ready_queue) {
 	/* paranoid */ verify( lanes.count > 0 );
 	unsigned count = __atomic_load_n( &lanes.count, __ATOMIC_RELAXED );
@@ -684,5 +684,5 @@
 	for(i; count) {
 		unsigned idx = (offset + i) % count;
-		struct $thread * thrd = try_pop(cltr, idx __STATS(, __tls_stats()->ready.pop.search));
+		struct thread$ * thrd = try_pop(cltr, idx __STATS(, __tls_stats()->ready.pop.search));
 		if(thrd) {
 			return thrd;
@@ -719,5 +719,5 @@
 //-----------------------------------------------------------------------
 // Given 2 indexes, pick the list with the oldest push an try to pop from it
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
+static inline struct thread$ * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
 	// Pick the bet list
 	int w = i;
@@ -854,5 +854,5 @@
 				// As long as we can pop from this lane to push the threads somewhere else in the queue
 				while(!is_empty(lanes.data[idx])) {
-					struct $thread * thrd;
+					struct thread$ * thrd;
 					unsigned long long _;
 					[thrd, _] = pop(lanes.data[idx]);
Index: libcfa/src/concurrency/ready_subqueue.hfa
===================================================================
--- libcfa/src/concurrency/ready_subqueue.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/ready_subqueue.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -7,5 +7,5 @@
 // Intrusives lanes which are used by the relaxed ready queue
 struct __attribute__((aligned(128))) __intrusive_lane_t {
-	struct $thread * prev;
+	struct thread$ * prev;
 
 	// spin lock protecting the queue
@@ -20,7 +20,7 @@
 
 // Get the head pointer (one before the first element) from the anchor
-static inline $thread * mock_head(const __intrusive_lane_t & this) {
-	$thread * rhead = ($thread *)(
-		(uintptr_t)( &this.anchor ) - __builtin_offsetof( $thread, link )
+static inline thread$ * mock_head(const __intrusive_lane_t & this) {
+	thread$ * rhead = (thread$ *)(
+		(uintptr_t)( &this.anchor ) - __builtin_offsetof( thread$, link )
 	);
 	return rhead;
@@ -38,7 +38,7 @@
 
 	// We add a boat-load of assertions here because the anchor code is very fragile
-	/* paranoid */ _Static_assert( offsetof( $thread, link ) == offsetof(__intrusive_lane_t, anchor) );
-	/* paranoid */ verify( offsetof( $thread, link ) == offsetof(__intrusive_lane_t, anchor) );
-	/* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( $thread, link )) == (uintptr_t)(&this.anchor) );
+	/* paranoid */ _Static_assert( offsetof( thread$, link ) == offsetof(__intrusive_lane_t, anchor) );
+	/* paranoid */ verify( offsetof( thread$, link ) == offsetof(__intrusive_lane_t, anchor) );
+	/* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( thread$, link )) == (uintptr_t)(&this.anchor) );
 	/* paranoid */ verify( &mock_head(this)->link.next == &this.anchor.next );
 	/* paranoid */ verify( &mock_head(this)->link.ts   == &this.anchor.ts   );
@@ -61,5 +61,5 @@
 // Push a thread onto this lane
 // returns true of lane was empty before push, false otherwise
-static inline void push( __intrusive_lane_t & this, $thread * node ) {
+static inline void push( __intrusive_lane_t & this, thread$ * node ) {
 	/* paranoid */ verify( this.lock );
 	/* paranoid */ verify( node->link.next == 0p );
@@ -91,5 +91,5 @@
 // returns popped
 // returns true of lane was empty before push, false otherwise
-static inline [* $thread, unsigned long long] pop( __intrusive_lane_t & this ) {
+static inline [* thread$, unsigned long long] pop( __intrusive_lane_t & this ) {
 	/* paranoid */ verify( this.lock );
 	/* paranoid */ verify( this.anchor.next != 0p );
@@ -99,5 +99,5 @@
 	// Get the relevant nodes locally
 	unsigned long long ts = this.anchor.ts;
-	$thread * node = this.anchor.next;
+	thread$ * node = this.anchor.next;
 	this.anchor.next = node->link.next;
 	this.anchor.ts   = node->link.ts;
Index: libcfa/src/concurrency/thread.cfa
===================================================================
--- libcfa/src/concurrency/thread.cfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/thread.cfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -27,5 +27,5 @@
 //-----------------------------------------------------------------------------
 // Thread ctors and dtors
-void ?{}($thread & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
+void ?{}(thread$ & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
 	context{ 0p, 0p };
 	self_cor{ name, storage, storageSize };
@@ -57,5 +57,5 @@
 }
 
-void ^?{}($thread& this) with( this ) {
+void ^?{}(thread$& this) with( this ) {
 	#if defined( __CFA_WITH_VERIFY__ )
 		canary = 0xDEADDEADDEADDEADp;
@@ -87,6 +87,6 @@
 void ?{}( thread_dtor_guard_t & this,
 		T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) {
-	$monitor * m = get_monitor(thrd);
-	$thread * desc = get_thread(thrd);
+	monitor$ * m = get_monitor(thrd);
+	thread$ * desc = get_thread(thrd);
 
 	// Setup the monitor guard
@@ -130,5 +130,5 @@
 forall( T & | is_thread(T) )
 void __thrd_start( T & this, void (*main_p)(T &) ) {
-	$thread * this_thrd = get_thread(this);
+	thread$ * this_thrd = get_thread(this);
 
 	disable_interrupts();
Index: libcfa/src/concurrency/thread.hfa
===================================================================
--- libcfa/src/concurrency/thread.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/thread.hfa	(revision b16e15e447aa742b41820a2e48e0d1f91984db43)
@@ -29,5 +29,5 @@
 	void ^?{}(T& mutex this);
 	void main(T& this);
-	$thread* get_thread(T& this);
+	thread$ * get_thread(T& this);
 };
 
@@ -45,11 +45,11 @@
 // Inline getters for threads/coroutines/monitors
 forall( T & | is_thread(T) )
-static inline $coroutine* get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; }
+static inline coroutine$ * get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; }
 
 forall( T & | is_thread(T) )
-static inline $monitor  * get_monitor  (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; }
+static inline monitor$   * get_monitor  (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; }
 
-static inline $coroutine* get_coroutine($thread * this) __attribute__((const)) { return &this->self_cor; }
-static inline $monitor  * get_monitor  ($thread * this) __attribute__((const)) { return &this->self_mon; }
+static inline coroutine$ * get_coroutine(thread$ * this) __attribute__((const)) { return &this->self_cor; }
+static inline monitor$   * get_monitor  (thread$ * this) __attribute__((const)) { return &this->self_mon; }
 
 //-----------------------------------------------------------------------------
@@ -62,16 +62,16 @@
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}($thread & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
-void ^?{}($thread & this);
+void ?{}(thread$ & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
+void ^?{}(thread$ & this);
 
-static inline void ?{}($thread & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
-static inline void ?{}($thread & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
-static inline void ?{}($thread & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
-static inline void ?{}($thread & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
-static inline void ?{}($thread & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
-static inline void ?{}($thread & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
-static inline void ?{}($thread & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
-static inline void ?{}($thread & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
-static inline void ?{}($thread & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
+static inline void ?{}(thread$ & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
+static inline void ?{}(thread$ & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
+static inline void ?{}(thread$ & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
+static inline void ?{}(thread$ & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
+static inline void ?{}(thread$ & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
+static inline void ?{}(thread$ & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
+static inline void ?{}(thread$ & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
+static inline void ?{}(thread$ & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
+static inline void ?{}(thread$ & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
 
 struct thread_dtor_guard_t {
@@ -111,5 +111,5 @@
 // Unpark a thread, if the thread is already blocked, schedule it
 //                  if the thread is not yet block, signal that it should rerun immediately
-void unpark( $thread * this );
+void unpark( thread$ * this );
 
 forall( T & | is_thread(T) )
