Index: libcfa/src/concurrency/kernel/fwd.hfa
===================================================================
--- libcfa/src/concurrency/kernel/fwd.hfa	(revision 1f45c7df4a45479fa7e834a868fd6f3e589e7c0f)
+++ libcfa/src/concurrency/kernel/fwd.hfa	(revision c86ee4c231ebc9741af2b213eeee262a4249894c)
@@ -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 1f45c7df4a45479fa7e834a868fd6f3e589e7c0f)
+++ libcfa/src/concurrency/kernel/startup.cfa	(revision c86ee4c231ebc9741af2b213eeee262a4249894c)
@@ -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;
@@ -507,5 +507,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;
@@ -546,5 +546,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 ){};
@@ -664,5 +664,5 @@
 }
 
-void doregister( cluster * cltr, $thread & thrd ) {
+void doregister( cluster * cltr, thread$ & thrd ) {
 	lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
 	cltr->nthreads += 1;
@@ -671,5 +671,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 );