Index: src/benchmark/bench.c
===================================================================
--- src/benchmark/bench.c	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/benchmark/bench.c	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -150,5 +150,5 @@
 //=======================================
 
-struct ThreadDummy { thread t; };
+struct ThreadDummy { thread_desc t; };
 DECL_THREAD(ThreadDummy);
 void main(ThreadDummy * this) {}
@@ -180,5 +180,5 @@
     int N;
     long long result;
-    thread t;
+    thread_desc t;
 };
 
Index: src/examples/multicore.c
===================================================================
--- src/examples/multicore.c	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/examples/multicore.c	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -2,5 +2,5 @@
 #include <thread>
 
-struct MyThread { thread t; };
+struct MyThread { thread_desc t; };
 
 DECL_THREAD(MyThread);
Index: src/libcfa/concurrency/invoke.c
===================================================================
--- src/libcfa/concurrency/invoke.c	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/libcfa/concurrency/invoke.c	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -29,5 +29,5 @@
 
 extern void __suspend_internal(void);
-extern void __thread_signal_termination(struct thread*);
+extern void __thread_signal_termination(struct thread_desc*);
 
 void CtxInvokeCoroutine(
@@ -57,10 +57,10 @@
 void CtxInvokeThread(
       void (*main)(void *), 
-      struct thread *(*get_thread)(void *), 
+      struct thread_desc *(*get_thread)(void *), 
       void *this
 ) {
       __suspend_internal();
 
-      struct thread* thrd = get_thread( this );
+      struct thread_desc* thrd = get_thread( this );
       struct coroutine_desc* cor = &thrd->c;
       cor->state = Active;
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/libcfa/concurrency/invoke.h	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -35,6 +35,6 @@
 
       struct simple_thread_list {
-            struct thread * head;
-            struct thread ** tail;
+            struct thread_desc * head;
+            struct thread_desc ** tail;
       };
 
@@ -48,6 +48,6 @@
       extern "Cforall" {
             void ?{}( struct simple_thread_list * );
-            void append( struct simple_thread_list *, struct thread * );
-            struct thread * pop_head( struct simple_thread_list * );
+            void append( struct simple_thread_list *, struct thread_desc * );
+            struct thread_desc * pop_head( struct simple_thread_list * );
 
             void ?{}(spinlock * this);
@@ -80,8 +80,8 @@
       };
 
-      struct thread {
+      struct thread_desc {
             struct coroutine_desc c;                 // coroutine body used to store context
             struct signal_once terminated;      // indicate if execuation state is not halted
-            struct thread * next;               // instrusive link field for threads
+            struct thread_desc * next;               // instrusive link field for threads
       };
 
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/libcfa/concurrency/kernel	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -49,5 +49,5 @@
 struct FinishAction {
 	FinishOpCode action_code;
-	thread * thrd;
+	thread_desc * thrd;
 	spinlock * lock;
 };
@@ -63,5 +63,5 @@
 	cluster * cltr;
 	coroutine_desc * current_coroutine;
-	thread * current_thread;
+	thread_desc * current_thread;
 	pthread_t kernel_thread;
 	
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/libcfa/concurrency/kernel.c	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -43,10 +43,10 @@
 KERNEL_STORAGE(cluster, systemCluster);
 KERNEL_STORAGE(processor, systemProcessor);
-KERNEL_STORAGE(thread, mainThread);
+KERNEL_STORAGE(thread_desc, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThread_context);
 
 cluster * systemCluster;
 processor * systemProcessor;
-thread * mainThread;
+thread_desc * mainThread;
 
 //-----------------------------------------------------------------------------
@@ -59,5 +59,5 @@
 }
 
-thread * this_thread(void) {
+thread_desc * this_thread(void) {
 	return this_processor->current_thread;
 }
@@ -106,5 +106,5 @@
 }
 
-void ?{}( thread * this, current_stack_info_t * info) {
+void ?{}( thread_desc * this, current_stack_info_t * info) {
 	(&this->c){ info };
 }
@@ -175,5 +175,5 @@
 	LIB_DEBUG_PRINTF("Kernel : core %p starting\n", this);
 
-	thread * readyThread = NULL;
+	thread_desc * readyThread = NULL;
 	for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
 	{
@@ -202,5 +202,5 @@
 // runThread runs a thread by context switching 
 // from the processor coroutine to the target thread 
-void runThread(processor * this, thread * dst) {
+void runThread(processor * this, thread_desc * dst) {
 	coroutine_desc * proc_cor = get_coroutine(this->runner);
 	coroutine_desc * thrd_cor = get_coroutine(dst);
@@ -293,5 +293,5 @@
 //-----------------------------------------------------------------------------
 // Scheduler routines
-void ScheduleThread( thread * thrd ) {
+void ScheduleThread( thread_desc * thrd ) {
 	assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
 	
@@ -301,7 +301,7 @@
 }
 
-thread * nextThread(cluster * this) {
+thread_desc * nextThread(cluster * this) {
 	lock( &this->lock );
-	thread * head = pop_head( &this->ready_queue );
+	thread_desc * head = pop_head( &this->ready_queue );
 	unlock( &this->lock );
 	return head;
@@ -318,5 +318,5 @@
 }
 
-void ScheduleInternal( thread * thrd ) {
+void ScheduleInternal( thread_desc * thrd ) {
 	this_processor->finish.action_code = Schedule;
 	this_processor->finish.thrd = thrd;
@@ -324,5 +324,5 @@
 }
 
-void ScheduleInternal( spinlock * lock, thread * thrd ) {
+void ScheduleInternal( spinlock * lock, thread_desc * thrd ) {
 	this_processor->finish.action_code = Release_Schedule;
 	this_processor->finish.lock = lock;
@@ -339,5 +339,5 @@
 	// SKULLDUGGERY: the mainThread steals the process main thread 
 	// which will then be scheduled by the systemProcessor normally
-	mainThread = (thread *)&mainThread_storage;
+	mainThread = (thread_desc *)&mainThread_storage;
 	current_stack_info_t info;
 	mainThread{ &info };
@@ -436,5 +436,5 @@
 		this->condition = true;
 
-		thread * it;
+		thread_desc * it;
 		while( it = pop_head( &this->blocked) ) {
 			ScheduleThread( it );
@@ -451,5 +451,5 @@
 }
 
-void append( simple_thread_list * this, thread * t ) {
+void append( simple_thread_list * this, thread_desc * t ) {
 	assert(this->tail != NULL);
 	*this->tail = t;
@@ -457,6 +457,6 @@
 }
 
-thread * pop_head( simple_thread_list * this ) {
-	thread * head = this->head;
+thread_desc * pop_head( simple_thread_list * this ) {
+	thread_desc * head = this->head;
 	if( head ) {
 		this->head = head->next;
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/libcfa/concurrency/kernel_private.h	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -23,11 +23,11 @@
 //-----------------------------------------------------------------------------
 // Scheduler
-void ScheduleThread( thread * );
-thread * nextThread(cluster * this);
+void ScheduleThread( thread_desc * );
+thread_desc * nextThread(cluster * this);
 
 void ScheduleInternal();
 void ScheduleInternal(spinlock * lock);
-void ScheduleInternal(thread * thrd);
-void ScheduleInternal(spinlock * lock, thread * thrd);
+void ScheduleInternal(thread_desc * thrd);
+void ScheduleInternal(spinlock * lock, thread_desc * thrd);
 
 //-----------------------------------------------------------------------------
@@ -42,5 +42,5 @@
 void main(processorCtx_t *);
 void start(processor * this);
-void runThread(processor * this, thread * dst);
+void runThread(processor * this, thread_desc * dst);
 void finishRunning(processor * this);
 void spin(processor * this, unsigned int * spin_count);
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/libcfa/concurrency/monitor	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -24,5 +24,5 @@
 struct monitor_desc {
 	spinlock lock;
-	thread * owner;
+	thread_desc * owner;
 	simple_thread_list entry_queue;
 	unsigned int recursion;
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/libcfa/concurrency/monitor.c	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -21,5 +21,5 @@
 void enter(monitor_desc * this) {
 	lock( &this->lock );
-	thread * thrd = this_thread();
+	thread_desc * thrd = this_thread();
 
 	if( !this->owner ) {
@@ -48,5 +48,5 @@
 	lock( &this->lock );
 
-	thread * thrd = this_thread();
+	thread_desc * thrd = this_thread();
 	assert( thrd == this->owner );
 
@@ -55,5 +55,5 @@
 
 	//If we left the last level of recursion it means we are changing who owns the monitor
-	thread * new_owner = 0;
+	thread_desc * new_owner = 0;
 	if( this->recursion == 0) {
 		//Get the next thread in the list
Index: src/libcfa/concurrency/thread
===================================================================
--- src/libcfa/concurrency/thread	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/libcfa/concurrency/thread	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -29,8 +29,8 @@
 trait is_thread(dtype T) {
       void main(T* this);
-      thread* get_thread(T* this);
+      thread_desc* get_thread(T* this);
 };
 
-#define DECL_THREAD(X) thread* get_thread(X* this) { return &this->t; } void main(X* this)
+#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->t; } void main(X* this)
 
 forall( dtype T | is_thread(T) )
@@ -39,14 +39,14 @@
 }
 
-static inline coroutine_desc* get_coroutine(thread* this) {
+static inline coroutine_desc* get_coroutine(thread_desc* this) {
 	return &this->c;
 }
 
-thread * this_thread(void);
+thread_desc * this_thread(void);
 
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(thread* this);
-void ^?{}(thread* this);
+void ?{}(thread_desc* this);
+void ^?{}(thread_desc* this);
 
 //-----------------------------------------------------------------------------
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/libcfa/concurrency/thread.c	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -41,5 +41,5 @@
 // Thread ctors and dtors
 
-void ?{}(thread* this) {
+void ?{}(thread_desc* this) {
 	(&this->c){};
 	this->c.name = "Anonymous Coroutine";
@@ -48,5 +48,5 @@
 }
 
-void ^?{}(thread* this) {
+void ^?{}(thread_desc* this) {
 	^(&this->c){};
 }
@@ -75,5 +75,5 @@
 void start( T* this ) {
 	coroutine_desc* thrd_c = get_coroutine(this);
-	thread*  thrd_h = get_thread   (this);
+	thread_desc*  thrd_h = get_thread   (this);
 	thrd_c->last = this_coroutine();
 	this_processor->current_coroutine = thrd_c;
@@ -116,8 +116,8 @@
 }
 
-// C Helper to signal the termination of a thread
+// C Helper to signal the termination of a thread_desc
 // Used in invoke.c
 extern "C" {
-	void __thread_signal_termination( thread * this ) {
+	void __thread_signal_termination( thread_desc * this ) {
 		this->c.state = Halted;
 		LIB_DEBUG_PRINTF("Thread end : %p\n", this);
Index: src/tests/monitor.c
===================================================================
--- src/tests/monitor.c	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/tests/monitor.c	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -27,5 +27,5 @@
 }
 
-struct MyThread { thread t; };
+struct MyThread { thread_desc t; };
 
 DECL_THREAD(MyThread);
Index: src/tests/multi-monitor.c
===================================================================
--- src/tests/multi-monitor.c	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/tests/multi-monitor.c	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -15,5 +15,5 @@
 
 struct MyThread { 
-	thread t; 
+	thread_desc t; 
 	int target;
 };
Index: src/tests/thread.c
===================================================================
--- src/tests/thread.c	(revision 84c52a8bfe9692c48d8a2e8ec4ebafbccff7ba79)
+++ src/tests/thread.c	(revision 348006f9bbb24c9257fa8be8d10695e6da14597d)
@@ -4,6 +4,6 @@
 #include <thread>
 
-struct First { thread t; signal_once* lock; };
-struct Second { thread t; signal_once* lock; };
+struct First { thread_desc t; signal_once* lock; };
+struct Second { thread_desc t; signal_once* lock; };
 
 DECL_THREAD(First);