Index: src/libcfa/concurrency/invoke.c
===================================================================
--- src/libcfa/concurrency/invoke.c	(revision 8def349b0537df4d0b760ecaa43ce8f6d6fe9e94)
+++ src/libcfa/concurrency/invoke.c	(revision e15df4c2fcf95d96cb620db7060d7c9e78f55d63)
@@ -29,5 +29,5 @@
 
 extern void __suspend_no_inline__F___1(void);
-extern void __signal_termination__F_P9sthread_h__1(struct thread_h*);
+extern void __signal_termination__F_P9sthread_h__1(struct thread*);
 
 void CtxInvokeCoroutine(
@@ -58,5 +58,5 @@
 void CtxInvokeThread(
       void (*main)(void *), 
-      struct thread_h *(*get_thread)(void *), 
+      struct thread *(*get_thread)(void *), 
       void *this
 ) {
@@ -65,5 +65,5 @@
       __suspend_no_inline__F___1();
 
-      struct thread_h* thrd = get_thread( this );
+      struct thread* thrd = get_thread( this );
       struct coroutine* cor = &thrd->c;
       cor->state = Active;
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 8def349b0537df4d0b760ecaa43ce8f6d6fe9e94)
+++ src/libcfa/concurrency/invoke.h	(revision e15df4c2fcf95d96cb620db7060d7c9e78f55d63)
@@ -31,6 +31,6 @@
 
       struct simple_thread_list {
-            struct thread_h * head;
-            struct thread_h ** tail;
+            struct thread * head;
+            struct thread ** tail;
       };
 
@@ -38,6 +38,6 @@
       extern "Cforall" {
             void ?{}( struct simple_thread_list * );
-            void append( struct simple_thread_list *, struct thread_h * );
-            struct thread_h * pop_head( struct simple_thread_list * );
+            void append( struct simple_thread_list *, struct thread * );
+            struct thread * pop_head( struct simple_thread_list * );
       }
       #endif
@@ -70,8 +70,8 @@
       };
 
-      struct thread_h {
+      struct thread {
             struct coroutine c;
             struct simple_lock lock;
-            struct thread_h * next;
+            struct thread * next;
       };
 
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision 8def349b0537df4d0b760ecaa43ce8f6d6fe9e94)
+++ src/libcfa/concurrency/kernel	(revision e15df4c2fcf95d96cb620db7060d7c9e78f55d63)
@@ -42,5 +42,5 @@
 	cluster * cltr;
 	coroutine * current_coroutine;
-	thread_h * current_thread;
+	thread * current_thread;
 	pthread_t kernel_thread;
 	simple_lock lock;
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 8def349b0537df4d0b760ecaa43ce8f6d6fe9e94)
+++ src/libcfa/concurrency/kernel.c	(revision e15df4c2fcf95d96cb620db7060d7c9e78f55d63)
@@ -46,10 +46,10 @@
 KERNEL_STORAGE(cluster, systemCluster);
 KERNEL_STORAGE(processor, systemProcessor);
-KERNEL_STORAGE(thread_h, mainThread);
+KERNEL_STORAGE(thread, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThread_context);
 
 cluster * systemCluster;
 processor * systemProcessor;
-thread_h * mainThread;
+thread * mainThread;
 
 void kernel_startup(void)  __attribute__((constructor(101)));
@@ -69,5 +69,5 @@
 }
 
-thread_h * this_thread(void) {
+thread * this_thread(void) {
 	return this_processor->current_thread;
 }
@@ -117,5 +117,5 @@
 }
 
-void ?{}( thread_h * this, current_stack_info_t * info) {
+void ?{}( thread * this, current_stack_info_t * info) {
 	(&this->c){ info };
 }
@@ -183,6 +183,6 @@
 // Processor running routines
 void main(processorCtx_t * ctx);
-thread_h * nextThread(cluster * this);
-void runThread(processor * this, thread_h * dst);
+thread * nextThread(cluster * this);
+void runThread(processor * this, thread * dst);
 void spin(processor * this, unsigned int * spin_count);
 
@@ -191,5 +191,5 @@
 	LIB_DEBUG_PRINTF("Kernel : core %p starting\n", this);
 
-	thread_h * readyThread = NULL;
+	thread * readyThread = NULL;
 	for( unsigned int spin_count = 0; ! this->terminated; spin_count++ ) {
 		
@@ -209,5 +209,5 @@
 }
 
-void runThread(processor * this, thread_h * dst) {
+void runThread(processor * this, thread * dst) {
 	coroutine * proc_ctx = get_coroutine(this->ctx);
 	coroutine * thrd_ctx = get_coroutine(dst);
@@ -284,5 +284,5 @@
 //-----------------------------------------------------------------------------
 // Scheduler routines
-void thread_schedule( thread_h * thrd ) {
+void thread_schedule( thread * thrd ) {
 	assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
 	
@@ -291,5 +291,5 @@
 }
 
-thread_h * nextThread(cluster * this) {
+thread * nextThread(cluster * this) {
 	pthread_spinlock_guard guard = { &this->lock };
 	return pop_head( &this->ready_queue );
@@ -314,5 +314,5 @@
 
 	// Start by initializing the main thread
-	mainThread = (thread_h *)&mainThread_storage;
+	mainThread = (thread *)&mainThread_storage;
 	mainThread{ &info };
 
@@ -391,5 +391,5 @@
 
 void unlock( simple_lock * this ) {
-	thread_h * it;
+	thread * it;
 	while( it = pop_head( &this->blocked) ) {
 		thread_schedule( it );
@@ -404,5 +404,5 @@
 }
 
-void append( simple_thread_list * this, thread_h * t ) {
+void append( simple_thread_list * this, thread * t ) {
 	assert( t->next == NULL );
 	*this->tail = t;
@@ -410,6 +410,6 @@
 }
 
-thread_h * pop_head( simple_thread_list * this ) {
-	thread_h * head = this->head;
+thread * pop_head( simple_thread_list * this ) {
+	thread * head = this->head;
 	if( head ) {
 		this->head = head->next;
Index: src/libcfa/concurrency/threads
===================================================================
--- src/libcfa/concurrency/threads	(revision 8def349b0537df4d0b760ecaa43ce8f6d6fe9e94)
+++ src/libcfa/concurrency/threads	(revision e15df4c2fcf95d96cb620db7060d7c9e78f55d63)
@@ -29,8 +29,8 @@
 trait is_thread(dtype T | sized(T)) {
       void main(T* this);
-      thread_h* get_thread(T* this);
+      thread* get_thread(T* this);
 };
 
-#define DECL_THREAD(X) static inline thread_h* get_thread(X* this) { return &this->t; } void main(X* this);
+#define DECL_THREAD(X) static inline thread* get_thread(X* this) { return &this->t; } void main(X* this);
 
 forall( dtype T | sized(T) | is_thread(T) )
@@ -39,14 +39,14 @@
 }
 
-static inline coroutine* get_coroutine(thread_h* this) {
+static inline coroutine* get_coroutine(thread* this) {
 	return &this->c;
 }
 
-thread_h * this_thread(void);
+thread * this_thread(void);
 
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(thread_h* this);
-void ^?{}(thread_h* this);
+void ?{}(thread* this);
+void ^?{}(thread* this);
 
 //-----------------------------------------------------------------------------
@@ -54,16 +54,16 @@
 // Structure that actually start and stop threads
 forall( dtype T | sized(T) | is_thread(T) )
-struct thread {
+struct scoped {
 	T handle;
 };
 
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } )
-void ?{}( thread(T)* this );
+void ?{}( scoped(T)* this );
 
 forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } )
-void ?{}( thread(T)* this, P params );
+void ?{}( scoped(T)* this, P params );
 
 forall( dtype T | sized(T) | is_thread(T) | { void ^?{}(T*); } )
-void ^?{}( thread(T)* this );
+void ^?{}( scoped(T)* this );
 
 void yield();
Index: src/libcfa/concurrency/threads.c
===================================================================
--- src/libcfa/concurrency/threads.c	(revision 8def349b0537df4d0b760ecaa43ce8f6d6fe9e94)
+++ src/libcfa/concurrency/threads.c	(revision e15df4c2fcf95d96cb620db7060d7c9e78f55d63)
@@ -40,5 +40,5 @@
 // Thread ctors and dtors
 
-void ?{}(thread_h* this) {
+void ?{}(thread* this) {
 	(&this->c){};
 	this->c.name = "Anonymous Coroutine";
@@ -47,10 +47,10 @@
 }
 
-void ^?{}(thread_h* this) {
+void ^?{}(thread* this) {
 	^(&this->c){};
 }
 
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } )
-void ?{}( thread(T)* this ) {
+void ?{}( scoped(T)* this ) {
 	(&this->handle){};
 	start(&this->handle);
@@ -58,5 +58,5 @@
 
 forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } )
-void ?{}( thread(T)* this, P params ) {
+void ?{}( scoped(T)* this, P params ) {
 	(&this->handle){ params };
 	start(&this->handle);
@@ -64,5 +64,5 @@
 
 forall( dtype T | sized(T) | is_thread(T) | { void ^?{}(T*); } )
-void ^?{}( thread(T)* this ) {
+void ^?{}( scoped(T)* this ) {
 	stop(&this->handle);
 	^(&this->handle){};
@@ -76,10 +76,10 @@
 }
 
-extern void thread_schedule( thread_h * );
+extern void thread_schedule( thread * );
 
 forall( dtype T | sized(T) | is_thread(T) )
 void start( T* this ) {
 	coroutine* thrd_c = get_coroutine(this);
-	thread_h*  thrd_h = get_thread   (this);
+	thread*  thrd_h = get_thread   (this);
 	thrd_c->last = this_coroutine();
 	get_this_processor()->current_coroutine = thrd_c;
@@ -96,5 +96,5 @@
 forall( dtype T | sized(T) | is_thread(T) )
 void stop( T* this ) {
-	thread_h*  thrd = get_thread(this);
+	thread*  thrd = get_thread(this);
 	if( thrd->c.notHalted ) {
 		lock( &thrd->lock );
@@ -102,5 +102,5 @@
 }
 
-void signal_termination( thread_h * this ) {
+void signal_termination( thread * this ) {
 	this->c.state = Halt;
       this->c.notHalted = false;