Index: src/benchmark/CorCtxSwitch.c
===================================================================
--- src/benchmark/CorCtxSwitch.c	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/benchmark/CorCtxSwitch.c	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -24,5 +24,5 @@
 
 struct GreatSuspender {
-	coroutine c;
+	coroutine_desc c;
 };
 
Index: src/benchmark/bench.c
===================================================================
--- src/benchmark/bench.c	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/benchmark/bench.c	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -86,5 +86,5 @@
 //=======================================
 
-struct CoroutineDummy { coroutine c; };
+struct CoroutineDummy { coroutine_desc c; };
 DECL_COROUTINE(CoroutineDummy);
 void main(CoroutineDummy * this) {}
@@ -119,5 +119,5 @@
 struct CoroutineResume {
     int N;
-    coroutine c;
+    coroutine_desc c;
 };
 
Index: src/benchmark/csv-data.c
===================================================================
--- src/benchmark/csv-data.c	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/benchmark/csv-data.c	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -26,5 +26,5 @@
 
 struct GreatSuspender {
-	coroutine c;
+	coroutine_desc c;
 };
 
Index: src/libcfa/concurrency/coroutine
===================================================================
--- src/libcfa/concurrency/coroutine	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/libcfa/concurrency/coroutine	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -27,16 +27,16 @@
 trait is_coroutine(dtype T) {
       void main(T * this);
-      coroutine * get_coroutine(T * this);
+      coroutine_desc * get_coroutine(T * this);
 };
 
-#define DECL_COROUTINE(X) static inline coroutine* get_coroutine(X* this) { return &this->c; } void main(X* this)
+#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->c; } void main(X* this)
 
 //-----------------------------------------------------------------------------
 // Ctors and dtors
 void ?{}(coStack_t * this);
-void ?{}(coroutine * this);
-void ?{}(coroutine * this, const char * name);
+void ?{}(coroutine_desc * this);
+void ?{}(coroutine_desc * this, const char * name);
 void ^?{}(coStack_t * this);
-void ^?{}(coroutine * this);
+void ^?{}(coroutine_desc * this);
 
 //-----------------------------------------------------------------------------
@@ -63,13 +63,13 @@
 
 // Get current coroutine
-coroutine * this_coroutine(void);
+coroutine_desc * this_coroutine(void);
 
 // Private wrappers for context switch and stack creation
-extern void CoroutineCtxSwitch(coroutine * src, coroutine * dst);
+extern void CoroutineCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
 extern void create_stack( coStack_t * this, unsigned int storageSize );
 
 // Suspend implementation inlined for performance
 static inline void suspend() {
-      coroutine * src = this_coroutine();		// optimization
+      coroutine_desc * src = this_coroutine();		// optimization
 
 	assertf( src->last != 0,
@@ -88,6 +88,6 @@
 forall(dtype T | is_coroutine(T))
 static inline void resume(T * cor) {
-	coroutine * src = this_coroutine();		// optimization
-	coroutine * dst = get_coroutine(cor);
+	coroutine_desc * src = this_coroutine();		// optimization
+	coroutine_desc * dst = get_coroutine(cor);
 
       if( unlikely(!dst->stack.base) ) {
@@ -111,6 +111,6 @@
 }
 
-static inline void resume(coroutine * dst) {
-	coroutine * src = this_coroutine();		// optimization
+static inline void resume(coroutine_desc * dst) {
+	coroutine_desc * src = this_coroutine();		// optimization
 
       // not resuming self ?
Index: src/libcfa/concurrency/coroutine.c
===================================================================
--- src/libcfa/concurrency/coroutine.c	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/libcfa/concurrency/coroutine.c	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -60,9 +60,9 @@
 }
 
-void ?{}(coroutine* this) {
+void ?{}(coroutine_desc* this) {
 	this{ "Anonymous Coroutine" };
 }
 
-void ?{}(coroutine* this, const char * name) {
+void ?{}(coroutine_desc* this, const char * name) {
 	this->name = name;
 	this->errno_ = 0;
@@ -72,5 +72,5 @@
 }
 
-void ?{}(coroutine* this, size_t size) {
+void ?{}(coroutine_desc* this, size_t size) {
 	this{};
 	(&this->stack){size};
@@ -88,5 +88,5 @@
 }
 
-void ^?{}(coroutine* this) {}
+void ^?{}(coroutine_desc* this) {}
 
 // Part of the Public API
@@ -94,5 +94,5 @@
 forall(dtype T | is_coroutine(T))
 void prime(T* cor) {
-	coroutine* this = get_coroutine(cor);
+	coroutine_desc* this = get_coroutine(cor);
 	assert(this->state == Start);
 
@@ -102,5 +102,5 @@
 
 // Wrapper for co
-void CoroutineCtxSwitch(coroutine* src, coroutine* dst) {
+void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
 	// THREAD_GETMEM( This )->disableInterrupts();
 
Index: src/libcfa/concurrency/invoke.c
===================================================================
--- src/libcfa/concurrency/invoke.c	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/libcfa/concurrency/invoke.c	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -33,10 +33,10 @@
 void CtxInvokeCoroutine(
       void (*main)(void *), 
-      struct coroutine *(*get_coroutine)(void *), 
+      struct coroutine_desc *(*get_coroutine)(void *), 
       void *this
 ) {
       // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
 
-      struct coroutine* cor = get_coroutine( this );
+      struct coroutine_desc* cor = get_coroutine( this );
 
       if(cor->state == Primed) {
@@ -63,5 +63,5 @@
 
       struct thread* thrd = get_thread( this );
-      struct coroutine* cor = &thrd->c;
+      struct coroutine_desc* cor = &thrd->c;
       cor->state = Active;
 
@@ -79,5 +79,5 @@
 void CtxStart(
       void (*main)(void *), 
-      struct coroutine *(*get_coroutine)(void *), 
+      struct coroutine_desc *(*get_coroutine)(void *), 
       void *this, 
       void (*invoke)(void *)
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/libcfa/concurrency/invoke.h	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -71,15 +71,15 @@
       enum coroutine_state { Halted, Start, Inactive, Active, Primed };
 
-      struct coroutine {
+      struct coroutine_desc {
             struct coStack_t stack;
             const char *name;			      // textual name for coroutine/task, initialized by uC++ generated code
             int errno_;				      // copy of global UNIX variable errno
             enum coroutine_state state;	      // current execution status for coroutine
-            struct coroutine *starter;	      // first coroutine to resume this one
-            struct coroutine *last;		      // last coroutine to resume this one
+            struct coroutine_desc *starter;	      // first coroutine to resume this one
+            struct coroutine_desc *last;		      // last coroutine to resume this one
       };
 
       struct thread {
-            struct coroutine c;                 // coroutine body used to store context
+            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
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/libcfa/concurrency/kernel	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -62,5 +62,5 @@
 	struct processorCtx_t * runner;
 	cluster * cltr;
-	coroutine * current_coroutine;
+	coroutine_desc * current_coroutine;
 	thread * current_thread;
 	pthread_t kernel_thread;
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/libcfa/concurrency/kernel.c	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -55,5 +55,5 @@
 thread_local processor * this_processor;
 
-coroutine * this_coroutine(void) {
+coroutine_desc * this_coroutine(void) {
 	return this_processor->current_coroutine;
 }
@@ -99,5 +99,5 @@
 }
 
-void ?{}( coroutine * this, current_stack_info_t * info) {
+void ?{}( coroutine_desc * this, current_stack_info_t * info) {
 	(&this->stack){ info };	
 	this->name = "Main Thread";
@@ -203,6 +203,6 @@
 // from the processor coroutine to the target thread 
 void runThread(processor * this, thread * dst) {
-	coroutine * proc_cor = get_coroutine(this->runner);
-	coroutine * thrd_cor = get_coroutine(dst);
+	coroutine_desc * proc_cor = get_coroutine(this->runner);
+	coroutine_desc * thrd_cor = get_coroutine(dst);
 	
 	//Reset the terminating actions here
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/libcfa/concurrency/kernel_private.h	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -35,5 +35,5 @@
 struct processorCtx_t {
 	processor * proc;
-	coroutine c;
+	coroutine_desc c;
 };
 
@@ -53,5 +53,5 @@
 }
 
-extern void ThreadCtxSwitch(coroutine * src, coroutine * dst);
+extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
 
 #endif //KERNEL_PRIVATE_H
Index: src/libcfa/concurrency/thread
===================================================================
--- src/libcfa/concurrency/thread	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/libcfa/concurrency/thread	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -35,9 +35,9 @@
 
 forall( dtype T | is_thread(T) )
-static inline coroutine* get_coroutine(T* this) {
+static inline coroutine_desc* get_coroutine(T* this) {
 	return &get_thread(this)->c;
 }
 
-static inline coroutine* get_coroutine(thread* this) {
+static inline coroutine_desc* get_coroutine(thread* this) {
 	return &this->c;
 }
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/libcfa/concurrency/thread.c	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -74,5 +74,5 @@
 forall( dtype T | is_thread(T) )
 void start( T* this ) {
-	coroutine* thrd_c = get_coroutine(this);
+	coroutine_desc* thrd_c = get_coroutine(this);
 	thread*  thrd_h = get_thread   (this);
 	thrd_c->last = this_coroutine();
@@ -97,5 +97,5 @@
 }
 
-void ThreadCtxSwitch(coroutine* src, coroutine* dst) {
+void ThreadCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
 	// set state of current coroutine to inactive
 	src->state = Inactive;
Index: src/tests/coroutine.c
===================================================================
--- src/tests/coroutine.c	(revision 0e7b95c8b6e96fa15d9a05af23bbbdb80933a7ce)
+++ src/tests/coroutine.c	(revision c3acb841f4d192142b1ebb1e1c00c6cf23e0a7c7)
@@ -4,5 +4,5 @@
 struct Fibonacci {
       int fn; // used for communication
-      coroutine c;
+      coroutine_desc c;
 };
 
@@ -11,5 +11,5 @@
 }
 
-coroutine* get_coroutine(Fibonacci* this) {
+coroutine_desc* get_coroutine(Fibonacci* this) {
       return &this->c;
 }
@@ -47,7 +47,7 @@
 #ifdef MORE_DEBUG      
       Fibonacci *pf1 = &f1, *pf2 = &f2;
-      coroutine *cf1 = &f1.c, *cf2 = &f2.c;
+      coroutine_desc *cf1 = &f1.c, *cf2 = &f2.c;
       covptr_t  *vf1 = vtable(pf1), *vf2 = vtable(pf2);
-      coroutine *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
+      coroutine_desc *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
       Fibonacci *ov1 = (Fibonacci *)get_object(vf1), *ov2 = (Fibonacci *)get_object(vf2);