Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision c7a900a12cc0fbe737f58157787bd96980702780)
+++ libcfa/src/concurrency/kernel.cfa	(revision a037f85b49948fe9469b696edd2db5dd4ad8751d)
@@ -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 );