Index: libcfa/src/concurrency/alarm.cfa
===================================================================
--- libcfa/src/concurrency/alarm.cfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/alarm.cfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -47,5 +47,5 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period ) with( this ) {
+void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period ) with( this ) {
 	this.thrd = thrd;
 	this.alarm = alarm;
Index: libcfa/src/concurrency/alarm.hfa
===================================================================
--- libcfa/src/concurrency/alarm.hfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/alarm.hfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -23,5 +23,5 @@
 #include "time.hfa"
 
-struct thread_desc;
+struct $thread;
 struct processor;
 
@@ -43,5 +43,5 @@
 
 	union {
-		thread_desc * thrd;	// thrd who created event
+		$thread * thrd;	// thrd who created event
 		processor * proc;		// proc who created event
 	};
@@ -53,5 +53,5 @@
 typedef alarm_node_t ** __alarm_it_t;
 
-void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period );
+void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period );
 void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period );
 void ^?{}( alarm_node_t & this );
Index: libcfa/src/concurrency/coroutine.cfa
===================================================================
--- libcfa/src/concurrency/coroutine.cfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/coroutine.cfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -37,5 +37,5 @@
 
 extern "C" {
-	void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __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 *) {
@@ -89,5 +89,5 @@
 }
 
-void ?{}( coroutine_desc & 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};
@@ -99,8 +99,8 @@
 }
 
-void ^?{}(coroutine_desc& this) {
+void ^?{}($coroutine& this) {
 	if(this.state != Halted && this.state != Start && this.state != Primed) {
-		coroutine_desc * src = TL_GET( this_thread )->curr_cor;
-		coroutine_desc * dst = &this;
+		$coroutine * src = TL_GET( this_thread )->curr_cor;
+		$coroutine * dst = &this;
 
 		struct _Unwind_Exception storage;
@@ -115,5 +115,5 @@
 		}
 
-		CoroutineCtxSwitch( src, dst );
+		$ctx_switch( src, dst );
 	}
 }
@@ -123,5 +123,5 @@
 forall(dtype T | is_coroutine(T))
 void prime(T& cor) {
-	coroutine_desc* this = get_coroutine(cor);
+	$coroutine* this = get_coroutine(cor);
 	assert(this->state == Start);
 
@@ -187,6 +187,6 @@
 // is not inline (We can't inline Cforall in C)
 extern "C" {
-	void __cfactx_cor_leave( struct coroutine_desc * src ) {
-		coroutine_desc * 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;
@@ -201,9 +201,9 @@
 			src->name, src, starter->name, starter );
 
-		CoroutineCtxSwitch( src, starter );
-	}
-
-	struct coroutine_desc * __cfactx_cor_finish(void) {
-		struct coroutine_desc * cor = kernelTLS.this_thread->curr_cor;
+		$ctx_switch( src, starter );
+	}
+
+	struct $coroutine * __cfactx_cor_finish(void) {
+		struct $coroutine * cor = kernelTLS.this_thread->curr_cor;
 
 		if(cor->state == Primed) {
Index: libcfa/src/concurrency/coroutine.hfa
===================================================================
--- libcfa/src/concurrency/coroutine.hfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/coroutine.hfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -25,8 +25,8 @@
 trait is_coroutine(dtype T) {
       void main(T & this);
-      coroutine_desc * get_coroutine(T & this);
+      $coroutine * get_coroutine(T & this);
 };
 
-#define DECL_COROUTINE(X) static inline coroutine_desc* 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)
 
 //-----------------------------------------------------------------------------
@@ -35,12 +35,12 @@
 // void ^?{}( coStack_t & this );
 
-void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize );
-void ^?{}( coroutine_desc & this );
+void  ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize );
+void ^?{}( $coroutine & this );
 
-static inline void ?{}( coroutine_desc & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
-static inline void ?{}( coroutine_desc & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
-static inline void ?{}( coroutine_desc & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
-static inline void ?{}( coroutine_desc & this, const char name[])                    { this{ name, 0p, 0 }; }
-static inline void ?{}( coroutine_desc & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
+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 }; }
 
 //-----------------------------------------------------------------------------
@@ -54,5 +54,5 @@
 void prime(T & cor);
 
-static inline struct coroutine_desc * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
+static inline struct $coroutine * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
 
 //-----------------------------------------------------------------------------
@@ -64,7 +64,7 @@
 
 	forall(dtype T)
-	void __cfactx_start(void (*main)(T &), struct coroutine_desc * cor, T & this, void (*invoke)(void (*main)(void *), void *));
+	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_desc *) __attribute__ ((__noreturn__));
+	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");
@@ -73,5 +73,5 @@
 // Private wrappers for context switch and stack creation
 // Wrapper for co
-static inline void CoroutineCtxSwitch( coroutine_desc * src, coroutine_desc * 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 : Inactive;
@@ -102,5 +102,5 @@
 	// will also migrate which means this value will
 	// stay in syn with the TLS
-	coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+	$coroutine * src = TL_GET( this_thread )->curr_cor;
 
 	assertf( src->last != 0,
@@ -113,5 +113,5 @@
 		src->name, src, src->last->name, src->last );
 
-	CoroutineCtxSwitch( src, src->last );
+	$ctx_switch( src, src->last );
 }
 
@@ -124,6 +124,6 @@
 	// will also migrate which means this value will
 	// stay in syn with the TLS
-	coroutine_desc * src = TL_GET( this_thread )->curr_cor;
-	coroutine_desc * dst = get_coroutine(cor);
+	$coroutine * src = TL_GET( this_thread )->curr_cor;
+	$coroutine * dst = get_coroutine(cor);
 
 	if( unlikely(dst->context.SP == 0p) ) {
@@ -147,10 +147,10 @@
 
 	// always done for performance testing
-	CoroutineCtxSwitch( src, dst );
+	$ctx_switch( src, dst );
 
 	return cor;
 }
 
-static inline void resume( coroutine_desc * 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
@@ -158,5 +158,5 @@
 	// will also migrate which means this value will
 	// stay in syn with the TLS
-	coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+	$coroutine * src = TL_GET( this_thread )->curr_cor;
 
 	// not resuming self ?
@@ -172,5 +172,5 @@
 
 	// always done for performance testing
-	CoroutineCtxSwitch( src, dst );
+	$ctx_switch( src, dst );
 }
 
Index: libcfa/src/concurrency/invoke.c
===================================================================
--- libcfa/src/concurrency/invoke.c	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/invoke.c	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -29,6 +29,6 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
-extern struct coroutine_desc * __cfactx_cor_finish(void);
-extern void __cfactx_cor_leave ( struct coroutine_desc * );
+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_desc * 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_desc * cor) __attribute__ ((__noreturn__));
-void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine_desc * 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_desc * cor,
+	struct $coroutine * cor,
 	void *this,
 	void (*invoke)(void *)
Index: libcfa/src/concurrency/invoke.h
===================================================================
--- libcfa/src/concurrency/invoke.h	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/invoke.h	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -47,5 +47,5 @@
 	extern "Cforall" {
 		extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
-			struct thread_desc    * volatile this_thread;
+			struct $thread    * volatile this_thread;
 			struct processor      * volatile this_processor;
 
@@ -95,5 +95,5 @@
 	enum __Preemption_Reason { __NO_PREEMPTION, __ALARM_PREEMPTION, __POLL_PREEMPTION, __MANUAL_PREEMPTION };
 
-	struct coroutine_desc {
+	struct $coroutine {
 		// context that is switch during a __cfactx_switch
 		struct __stack_context_t context;
@@ -109,8 +109,8 @@
 
 		// first coroutine to resume this one
-		struct coroutine_desc * starter;
+		struct $coroutine * starter;
 
 		// last coroutine to resume this one
-		struct coroutine_desc * last;
+		struct $coroutine * last;
 
 		// If non-null stack must be unwound with this exception
@@ -128,13 +128,13 @@
 	};
 
-	struct monitor_desc {
+	struct $monitor {
 		// spinlock to protect internal data
 		struct __spinlock_t lock;
 
 		// current owner of the monitor
-		struct thread_desc * owner;
+		struct $thread * owner;
 
 		// queue of threads that are blocked waiting for the monitor
-		__queue_t(struct thread_desc) entry_queue;
+		__queue_t(struct $thread) entry_queue;
 
 		// stack of conditions to run next once we exit the monitor
@@ -153,5 +153,5 @@
 	struct __monitor_group_t {
 		// currently held monitors
-		__cfa_anonymous_object( __small_array_t(monitor_desc*) );
+		__cfa_anonymous_object( __small_array_t($monitor*) );
 
 		// last function that acquired monitors
@@ -159,5 +159,5 @@
 	};
 
-	struct thread_desc {
+	struct $thread {
 		// Core threading fields
 		// context that is switch during a __cfactx_switch
@@ -171,14 +171,14 @@
 
 		// coroutine body used to store context
-		struct coroutine_desc  self_cor;
+		struct $coroutine  self_cor;
 
 		// current active context
-		struct coroutine_desc * curr_cor;
+		struct $coroutine * curr_cor;
 
 		// monitor body used for mutual exclusion
-		struct monitor_desc    self_mon;
+		struct $monitor    self_mon;
 
 		// pointer to monitor with sufficient lifetime for current monitors
-		struct monitor_desc *  self_mon_p;
+		struct $monitor *  self_mon_p;
 
 		// pointer to the cluster on which the thread is running
@@ -190,9 +190,9 @@
 		// Link lists fields
 		// instrusive link field for threads
-		struct thread_desc * next;
+		struct $thread * next;
 
 		struct {
-			struct thread_desc * next;
-			struct thread_desc * prev;
+			struct $thread * next;
+			struct $thread * prev;
 		} node;
 	};
@@ -200,9 +200,9 @@
 	#ifdef __cforall
 	extern "Cforall" {
-		static inline thread_desc *& get_next( thread_desc & this ) __attribute__((const)) {
+		static inline $thread *& get_next( $thread & this ) __attribute__((const)) {
 			return this.next;
 		}
 
-		static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) __attribute__((const)) {
+		static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) {
 			return this.node.[next, prev];
 		}
@@ -214,5 +214,5 @@
 		}
 
-		static inline void ?{}(__monitor_group_t & this, struct monitor_desc ** 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/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/kernel.cfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -117,10 +117,10 @@
 KERNEL_STORAGE(cluster,		mainCluster);
 KERNEL_STORAGE(processor,	mainProcessor);
-KERNEL_STORAGE(thread_desc,	mainThread);
+KERNEL_STORAGE($thread,	mainThread);
 KERNEL_STORAGE(__stack_t, 	mainThreadCtx);
 
 cluster     * mainCluster;
 processor   * mainProcessor;
-thread_desc * mainThread;
+$thread * mainThread;
 
 extern "C" {
@@ -164,5 +164,5 @@
 // Main thread construction
 
-void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
+void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) {
 	stack.storage = info->storage;
 	with(*stack.storage) {
@@ -179,5 +179,5 @@
 }
 
-void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
+void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
 	state = Start;
 	self_cor{ info };
@@ -264,6 +264,6 @@
 // Kernel Scheduling logic
 //=============================================================================================
-static thread_desc * __next_thread(cluster * this);
-static void __run_thread(processor * this, thread_desc * dst);
+static $thread * __next_thread(cluster * this);
+static void __run_thread(processor * this, $thread * dst);
 static void __halt(processor * this);
 
@@ -287,5 +287,5 @@
 		__cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
 
-		thread_desc * readyThread = 0p;
+		$thread * readyThread = 0p;
 		for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
 			readyThread = __next_thread( this->cltr );
@@ -323,6 +323,6 @@
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
-static void __run_thread(processor * this, thread_desc * thrd_dst) {
-	coroutine_desc * proc_cor = get_coroutine(this->runner);
+static void __run_thread(processor * this, $thread * thrd_dst) {
+	$coroutine * proc_cor = get_coroutine(this->runner);
 
 	// Update global state
@@ -400,6 +400,6 @@
 void returnToKernel() {
 	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-	coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
-	thread_desc * thrd_src = kernelTLS.this_thread;
+	$coroutine * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
+	$thread * thrd_src = kernelTLS.this_thread;
 
 	// Run the thread on this processor
@@ -495,6 +495,6 @@
 // KERNEL_ONLY
 static void __kernel_first_resume( processor * this ) {
-	thread_desc * src = mainThread;
-	coroutine_desc * dst = get_coroutine(this->runner);
+	$thread * src = mainThread;
+	$coroutine * dst = get_coroutine(this->runner);
 
 	verify( ! kernelTLS.preemption_state.enabled );
@@ -527,6 +527,6 @@
 // KERNEL_ONLY
 static void __kernel_last_resume( processor * this ) {
-	coroutine_desc * src = &mainThread->self_cor;
-	coroutine_desc * dst = get_coroutine(this->runner);
+	$coroutine * src = &mainThread->self_cor;
+	$coroutine * dst = get_coroutine(this->runner);
 
 	verify( ! kernelTLS.preemption_state.enabled );
@@ -541,5 +541,5 @@
 // Scheduler routines
 // KERNEL ONLY
-void __schedule_thread( thread_desc * thrd ) with( *thrd->curr_cluster ) {
+void __schedule_thread( $thread * thrd ) with( *thrd->curr_cluster ) {
 	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 	/* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
@@ -571,9 +571,9 @@
 
 // KERNEL ONLY
-static thread_desc * __next_thread(cluster * this) with( *this ) {
+static $thread * __next_thread(cluster * this) with( *this ) {
 	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
 	lock( ready_queue_lock __cfaabi_dbg_ctx2 );
-	thread_desc * head = pop_head( ready_queue );
+	$thread * head = pop_head( ready_queue );
 	unlock( ready_queue_lock );
 
@@ -582,5 +582,5 @@
 }
 
-void unpark( thread_desc * thrd ) {
+void unpark( $thread * thrd ) {
 	if( !thrd ) return;
 
@@ -639,5 +639,5 @@
 	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
-	thread_desc * thrd = kernelTLS.this_thread;
+	$thread * thrd = kernelTLS.this_thread;
 	/* paranoid */ verify(thrd->state == Active || thrd->state == Rerun);
 
@@ -683,5 +683,5 @@
 	// SKULLDUGGERY: the mainThread steals the process main thread
 	// which will then be scheduled by the mainProcessor normally
-	mainThread = (thread_desc *)&storage_mainThread;
+	mainThread = ($thread *)&storage_mainThread;
 	current_stack_info_t info;
 	info.storage = (__stack_t*)&storage_mainThreadCtx;
@@ -835,5 +835,5 @@
 
 void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
-	thread_desc * thrd = kernel_data;
+	$thread * thrd = kernel_data;
 
 	if(thrd) {
@@ -900,5 +900,5 @@
 
 void V(semaphore & this) with( this ) {
-	thread_desc * thrd = 0p;
+	$thread * thrd = 0p;
 	lock( lock __cfaabi_dbg_ctx2 );
 	count += 1;
@@ -928,5 +928,5 @@
 }
 
-void doregister( cluster * cltr, thread_desc & thrd ) {
+void doregister( cluster * cltr, $thread & thrd ) {
 	lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
 	cltr->nthreads += 1;
@@ -935,5 +935,5 @@
 }
 
-void unregister( cluster * cltr, thread_desc & thrd ) {
+void unregister( cluster * cltr, $thread & thrd ) {
 	lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
 	remove(cltr->threads, thrd );
Index: libcfa/src/concurrency/kernel.hfa
===================================================================
--- libcfa/src/concurrency/kernel.hfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/kernel.hfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -32,5 +32,5 @@
 	__spinlock_t lock;
 	int count;
-	__queue_t(thread_desc) waiting;
+	__queue_t($thread) waiting;
 };
 
@@ -67,5 +67,5 @@
 	// RunThread data
 	// Action to do after a thread is ran
-	thread_desc * destroyer;
+	$thread * destroyer;
 
 	// Preemption data
@@ -117,5 +117,5 @@
 
 	// Ready queue for threads
-	__queue_t(thread_desc) ready_queue;
+	__queue_t($thread) ready_queue;
 
 	// Name of the cluster
@@ -133,5 +133,5 @@
 	// List of threads
 	__spinlock_t thread_list_lock;
-	__dllist_t(struct thread_desc) threads;
+	__dllist_t(struct $thread) threads;
 	unsigned int nthreads;
 
Index: libcfa/src/concurrency/kernel_private.hfa
===================================================================
--- libcfa/src/concurrency/kernel_private.hfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/kernel_private.hfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -31,5 +31,5 @@
 }
 
-void __schedule_thread( thread_desc * ) __attribute__((nonnull (1)));
+void __schedule_thread( $thread * ) __attribute__((nonnull (1)));
 
 //Block current thread and release/wake-up the following resources
@@ -74,9 +74,7 @@
 }
 
-extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
-
 __cfaabi_dbg_debug_do(
-	extern void __cfaabi_dbg_thread_register  ( thread_desc * thrd );
-	extern void __cfaabi_dbg_thread_unregister( thread_desc * thrd );
+	extern void __cfaabi_dbg_thread_register  ( $thread * thrd );
+	extern void __cfaabi_dbg_thread_unregister( $thread * thrd );
 )
 
@@ -96,6 +94,6 @@
 void unregister( struct cluster & cltr );
 
-void doregister( struct cluster * cltr, struct thread_desc & thrd );
-void unregister( struct cluster * cltr, struct thread_desc & thrd );
+void doregister( struct cluster * cltr, struct $thread & thrd );
+void unregister( struct cluster * cltr, struct $thread & thrd );
 
 void doregister( struct cluster * cltr, struct processor * proc );
Index: libcfa/src/concurrency/monitor.cfa
===================================================================
--- libcfa/src/concurrency/monitor.cfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/monitor.cfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// monitor_desc.c --
+// $monitor.c --
 //
 // Author           : Thierry Delisle
@@ -27,31 +27,31 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-static inline void __set_owner ( monitor_desc * this, thread_desc * owner );
-static inline void __set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner );
-static inline void set_mask  ( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
-static inline void reset_mask( monitor_desc * this );
-
-static inline thread_desc * next_thread( monitor_desc * this );
-static inline bool is_accepted( monitor_desc * 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_desc * 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_desc * locks [], __lock_size_t count );
-
-static inline void save   ( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
-static inline void restore( monitor_desc * 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_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-
-static inline thread_desc *        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_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc * monitors [], __lock_size_t count );
+static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count );
 
 forall(dtype 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_desc * storage [], const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate    ( $monitor * storage [], const __waitfor_mask_t & mask );
 
 //-----------------------------------------------------------------------------
@@ -68,5 +68,5 @@
 
 #define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
-	monitor_desc ** 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                             */ \
@@ -81,9 +81,9 @@
 // Enter/Leave routines
 // Enter single monitor
-static void __enter( monitor_desc * this, const __monitor_group_t & group ) {
+static void __enter( $monitor * this, const __monitor_group_t & group ) {
 	// Lock the monitor spinlock
 	lock( this->lock __cfaabi_dbg_ctx2 );
 	// Interrupts disable inside critical section
-	thread_desc * thrd = kernelTLS.this_thread;
+	$thread * thrd = kernelTLS.this_thread;
 
 	__cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
@@ -137,9 +137,9 @@
 }
 
-static void __dtor_enter( monitor_desc * this, fptr_t func ) {
+static void __dtor_enter( $monitor * this, fptr_t func ) {
 	// Lock the monitor spinlock
 	lock( this->lock __cfaabi_dbg_ctx2 );
 	// Interrupts disable inside critical section
-	thread_desc * thrd = kernelTLS.this_thread;
+	$thread * thrd = kernelTLS.this_thread;
 
 	__cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
@@ -164,5 +164,5 @@
 
 	__lock_size_t count = 1;
-	monitor_desc ** monitors = &this;
+	$monitor ** monitors = &this;
 	__monitor_group_t group = { &this, 1, func };
 	if( is_accepted( this, group) ) {
@@ -216,5 +216,5 @@
 
 // Leave single monitor
-void __leave( monitor_desc * this ) {
+void __leave( $monitor * this ) {
 	// Lock the monitor spinlock
 	lock( this->lock __cfaabi_dbg_ctx2 );
@@ -236,5 +236,5 @@
 
 	// Get the next thread, will be null on low contention monitor
-	thread_desc * new_owner = next_thread( this );
+	$thread * new_owner = next_thread( this );
 
 	// Check the new owner is consistent with who we wake-up
@@ -251,5 +251,5 @@
 
 // Leave single monitor for the last time
-void __dtor_leave( monitor_desc * this ) {
+void __dtor_leave( $monitor * this ) {
 	__cfaabi_dbg_debug_do(
 		if( TL_GET( this_thread ) != this->owner ) {
@@ -267,6 +267,6 @@
 	// Should never return
 	void __cfactx_thrd_leave() {
-		thread_desc * thrd = TL_GET( this_thread );
-		monitor_desc * this = &thrd->self_mon;
+		$thread * thrd = TL_GET( this_thread );
+		$monitor * this = &thrd->self_mon;
 
 		// Lock the monitor now
@@ -287,5 +287,5 @@
 
 		// Fetch the next thread, can be null
-		thread_desc * new_owner = next_thread( this );
+		$thread * new_owner = next_thread( this );
 
 		// Release the monitor lock
@@ -317,5 +317,5 @@
 // Leave multiple monitor
 // relies on the monitor array being sorted
-static inline void leave(monitor_desc * 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] );
@@ -325,6 +325,6 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, monitor_desc * m [], __lock_size_t count, fptr_t func ) {
-	thread_desc * thrd = TL_GET( this_thread );
+void ?{}( monitor_guard_t & this, $monitor * m [], __lock_size_t count, fptr_t func ) {
+	$thread * thrd = TL_GET( this_thread );
 
 	// Store current array
@@ -366,7 +366,7 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_dtor_guard_t & this, monitor_desc * m [], fptr_t func ) {
+void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func ) {
 	// optimization
-	thread_desc * thrd = TL_GET( this_thread );
+	$thread * thrd = TL_GET( this_thread );
 
 	// Store current array
@@ -393,5 +393,5 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling types
-void ?{}(__condition_node_t & this, thread_desc * 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;
@@ -407,5 +407,5 @@
 }
 
-void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t & owner ) {
+void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) {
 	this.ready  = false;
 	this.target = target;
@@ -441,5 +441,5 @@
 	// Find the next thread(s) to run
 	__lock_size_t thread_count = 0;
-	thread_desc * threads[ count ];
+	$thread * threads[ count ];
 	__builtin_memset( threads, 0, sizeof( threads ) );
 
@@ -449,5 +449,5 @@
 	// Remove any duplicate threads
 	for( __lock_size_t i = 0; i < count; i++) {
-		thread_desc * new_owner = next_thread( monitors[i] );
+		$thread * new_owner = next_thread( monitors[i] );
 		insert_unique( threads, thread_count, new_owner );
 	}
@@ -479,5 +479,5 @@
 	//Some more checking in debug
 	__cfaabi_dbg_debug_do(
-		thread_desc * this_thrd = TL_GET( this_thread );
+		$thread * this_thrd = TL_GET( this_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 );
@@ -533,5 +533,5 @@
 
 	//Find the thread to run
-	thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
+	$thread * signallee = pop_head( this.blocked )->waiting_thread;
 	/* paranoid */ verify( signallee->next == 0p );
 	__set_owner( monitors, count, signallee );
@@ -587,5 +587,5 @@
 	// Create one!
 	__lock_size_t max = count_max( mask );
-	monitor_desc * mon_storage[max];
+	$monitor * mon_storage[max];
 	__builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
 	__lock_size_t actual_count = aggregate( mon_storage, mask );
@@ -605,5 +605,5 @@
 	{
 		// Check if the entry queue
-		thread_desc * next; int index;
+		$thread * next; int index;
 		[next, index] = search_entry_queue( mask, monitors, count );
 
@@ -615,5 +615,5 @@
 				verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
-				monitor_desc * mon2dtor = accepted[0];
+				$monitor * mon2dtor = accepted[0];
 				verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
 
@@ -709,5 +709,5 @@
 // Utilities
 
-static inline void __set_owner( monitor_desc * this, thread_desc * owner ) {
+static inline void __set_owner( $monitor * this, $thread * owner ) {
 	/* paranoid */ verify( this->lock.lock );
 
@@ -719,5 +719,5 @@
 }
 
-static inline void __set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * 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 == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[0]->owner, monitors[0]->recursion, monitors[0] );
@@ -732,5 +732,5 @@
 }
 
-static inline void set_mask( monitor_desc * 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;
@@ -738,5 +738,5 @@
 }
 
-static inline void reset_mask( monitor_desc * this ) {
+static inline void reset_mask( $monitor * this ) {
 	this->mask.accepted = 0p;
 	this->mask.data = 0p;
@@ -744,5 +744,5 @@
 }
 
-static inline thread_desc * next_thread( monitor_desc * 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);
@@ -760,5 +760,5 @@
 	// No signaller thread
 	// Get the next thread in the entry_queue
-	thread_desc * new_owner = pop_head( this->entry_queue );
+	$thread * new_owner = pop_head( this->entry_queue );
 	/* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
 	/* paranoid */ verify( !new_owner || new_owner->next == 0p );
@@ -768,5 +768,5 @@
 }
 
-static inline bool is_accepted( monitor_desc * 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;
@@ -790,5 +790,5 @@
 }
 
-static inline void init( __lock_size_t count, monitor_desc * 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 };
@@ -798,5 +798,5 @@
 }
 
-static inline void init_push( __lock_size_t count, monitor_desc * 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 };
@@ -814,5 +814,5 @@
 }
 
-static inline void lock_all( monitor_desc * 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;
@@ -828,5 +828,5 @@
 }
 
-static inline void unlock_all( monitor_desc * 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 );
@@ -835,5 +835,5 @@
 
 static inline void save(
-	monitor_desc * ctx [],
+	$monitor * ctx [],
 	__lock_size_t count,
 	__attribute((unused)) __spinlock_t * locks [],
@@ -848,5 +848,5 @@
 
 static inline void restore(
-	monitor_desc * ctx [],
+	$monitor * ctx [],
 	__lock_size_t count,
 	__spinlock_t * locks [],
@@ -866,5 +866,5 @@
 // 2 - Checks if all the monitors are ready to run
 //     if so return the thread to run
-static inline thread_desc * 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;
@@ -889,5 +889,5 @@
 
 static inline void brand_condition( condition & this ) {
-	thread_desc * thrd = TL_GET( this_thread );
+	$thread * thrd = TL_GET( this_thread );
 	if( !this.monitors ) {
 		// __cfaabi_dbg_print_safe( "Branding\n" );
@@ -895,5 +895,5 @@
 		this.monitor_count = thrd->monitors.size;
 
-		this.monitors = (monitor_desc **)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];
@@ -902,10 +902,10 @@
 }
 
-static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc * monitors [], __lock_size_t count ) {
-
-	__queue_t(thread_desc) & 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_desc ** thrd_it = &entry_queue.head;
+	for(	$thread ** thrd_it = &entry_queue.head;
 		*thrd_it != 1p;
 		thrd_it = &(*thrd_it)->next
@@ -951,5 +951,5 @@
 }
 
-static inline __lock_size_t aggregate( monitor_desc * 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 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/monitor.hfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -23,9 +23,9 @@
 
 trait is_monitor(dtype T) {
-	monitor_desc * get_monitor( T & );
+	$monitor * get_monitor( T & );
 	void ^?{}( T & mutex );
 };
 
-static inline void ?{}(monitor_desc & this) with( this ) {
+static inline void ?{}($monitor & this) with( this ) {
 	lock{};
 	entry_queue{};
@@ -39,21 +39,21 @@
 }
 
-static inline void ^?{}(monitor_desc & ) {}
+static inline void ^?{}($monitor & ) {}
 
 struct monitor_guard_t {
-	monitor_desc ** 	m;
+	$monitor ** 	m;
 	__lock_size_t   	count;
 	__monitor_group_t prev;
 };
 
-void ?{}( monitor_guard_t & this, monitor_desc ** 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_desc *    m;
+	$monitor *    m;
 	__monitor_group_t prev;
 };
 
-void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, void (*func)() );
+void ?{}( monitor_dtor_guard_t & this, $monitor ** m, void (*func)() );
 void ^?{}( monitor_dtor_guard_t & this );
 
@@ -72,5 +72,5 @@
 
 	// The monitor this criterion concerns
-	monitor_desc * target;
+	$monitor * target;
 
 	// The parent node to which this criterion belongs
@@ -87,5 +87,5 @@
 struct __condition_node_t {
 	// Thread that needs to be woken when all criteria are met
-	thread_desc * waiting_thread;
+	$thread * waiting_thread;
 
 	// Array of criteria (Criterions are contiguous in memory)
@@ -106,7 +106,7 @@
 }
 
-void ?{}(__condition_node_t & this, thread_desc * 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_desc * target, __condition_node_t * owner );
+void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t * owner );
 
 struct condition {
@@ -115,5 +115,5 @@
 
 	// Array of monitor pointers (Monitors are NOT contiguous in memory)
-	monitor_desc ** monitors;
+	$monitor ** monitors;
 
 	// Number of monitors in the array
Index: libcfa/src/concurrency/mutex.cfa
===================================================================
--- libcfa/src/concurrency/mutex.cfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/mutex.cfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -120,5 +120,5 @@
 	recursion_count--;
 	if( recursion_count == 0 ) {
-		thread_desc * 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 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/mutex.hfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -36,5 +36,5 @@
 
 	// List of blocked threads
-	__queue_t(struct thread_desc) blocked_threads;
+	__queue_t(struct $thread) blocked_threads;
 
 	// Locked flag
@@ -55,8 +55,8 @@
 
 	// List of blocked threads
-	__queue_t(struct thread_desc) blocked_threads;
+	__queue_t(struct $thread) blocked_threads;
 
 	// Current thread owning the lock
-	struct thread_desc * owner;
+	struct $thread * owner;
 
 	// Number of recursion level
@@ -83,5 +83,5 @@
 
 	// List of blocked threads
-	__queue_t(struct thread_desc) blocked_threads;
+	__queue_t(struct $thread) blocked_threads;
 };
 
Index: libcfa/src/concurrency/preemption.cfa
===================================================================
--- libcfa/src/concurrency/preemption.cfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/preemption.cfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -39,5 +39,5 @@
 // FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
-static void timeout( thread_desc * this );
+static void timeout( $thread * this );
 
 // FwdDeclarations : Signal handlers
@@ -267,5 +267,5 @@
 
 // reserved for future use
-static void timeout( thread_desc * this ) {
+static void timeout( $thread * this ) {
 	//TODO : implement waking threads
 }
Index: libcfa/src/concurrency/thread.cfa
===================================================================
--- libcfa/src/concurrency/thread.cfa	(revision 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/thread.cfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -25,5 +25,5 @@
 //-----------------------------------------------------------------------------
 // Thread ctors and dtors
-void ?{}(thread_desc & 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 };
@@ -44,5 +44,5 @@
 }
 
-void ^?{}(thread_desc& this) with( this ) {
+void ^?{}($thread& this) with( this ) {
 	unregister(curr_cluster, this);
 	^self_cor{};
@@ -53,5 +53,5 @@
 forall( dtype T | is_thread(T) )
 void __thrd_start( T & this, void (*main_p)(T &) ) {
-	thread_desc * 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 0f2c555fede9fc75e1da22291f41adaa9bd0262e)
+++ libcfa/src/concurrency/thread.hfa	(revision 3c64c6684cc8f107bdea7411e2d29dfffaa2a544)
@@ -28,19 +28,19 @@
       void ^?{}(T& mutex this);
       void main(T& this);
-      thread_desc* get_thread(T& this);
+      $thread* get_thread(T& this);
 };
 
 // define that satisfies the trait without using the thread keyword
-#define DECL_THREAD(X) thread_desc* get_thread(X& this) __attribute__((const)) { return &this.__thrd; } void main(X& this)
+#define DECL_THREAD(X) $thread* get_thread(X& this) __attribute__((const)) { return &this.__thrd; } void main(X& this)
 
 // Inline getters for threads/coroutines/monitors
 forall( dtype T | is_thread(T) )
-static inline coroutine_desc* 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( dtype T | is_thread(T) )
-static inline monitor_desc  * 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_desc* get_coroutine(thread_desc * this) __attribute__((const)) { return &this->self_cor; }
-static inline monitor_desc  * get_monitor  (thread_desc * 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; }
 
 //-----------------------------------------------------------------------------
@@ -53,16 +53,16 @@
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(thread_desc & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
-void ^?{}(thread_desc & this);
+void ?{}($thread & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
+void ^?{}($thread & this);
 
-static inline void ?{}(thread_desc & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
-static inline void ?{}(thread_desc & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
-static inline void ?{}(thread_desc & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
-static inline void ?{}(thread_desc & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
-static inline void ?{}(thread_desc & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
-static inline void ?{}(thread_desc & 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 }; }
 
 //-----------------------------------------------------------------------------
@@ -85,5 +85,5 @@
 //-----------------------------------------------------------------------------
 // Thread getters
-static inline struct thread_desc * active_thread () { return TL_GET( this_thread ); }
+static inline struct $thread * active_thread () { return TL_GET( this_thread ); }
 
 //-----------------------------------------------------------------------------
@@ -97,5 +97,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_desc * this );
+void unpark( $thread * this );
 
 forall( dtype T | is_thread(T) )