Index: src/libcfa/concurrency/coroutine
===================================================================
--- src/libcfa/concurrency/coroutine	(revision 533804b9d3f229207fdb883014466e94b874e1f9)
+++ src/libcfa/concurrency/coroutine	(revision 83a071f98d287fe0dd150376b0c6ea5ff812b18b)
@@ -26,9 +26,9 @@
 // Anything that is resumed is a coroutine.
 trait is_coroutine(dtype T) {
-      void main(T * this);
-      coroutine_desc * get_coroutine(T * this);
+      void main(T & this);
+      coroutine_desc * get_coroutine(T & this);
 };
 
-#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->__cor; } void main(X* this)
+#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
 
 //-----------------------------------------------------------------------------
@@ -45,8 +45,8 @@
 
 forall(dtype T | is_coroutine(T))
-static inline void resume(T * cor);
+static inline void resume(T & cor);
 
 forall(dtype T | is_coroutine(T))
-void prime(T * cor);
+void prime(T & cor);
 
 //-----------------------------------------------------------------------------
@@ -87,5 +87,5 @@
 // Resume implementation inlined for performance
 forall(dtype T | is_coroutine(T))
-static inline void resume(T * cor) {
+static inline void resume(T & cor) {
 	coroutine_desc * src = this_coroutine;		// optimization
 	coroutine_desc * dst = get_coroutine(cor);
@@ -93,5 +93,5 @@
 	if( unlikely(!dst->stack.base) ) {
 		create_stack(&dst->stack, dst->stack.size);
-		CtxStart(cor, CtxInvokeCoroutine);
+		CtxStart(&cor, CtxInvokeCoroutine);
 	}
 
Index: src/libcfa/concurrency/coroutine.c
===================================================================
--- src/libcfa/concurrency/coroutine.c	(revision 533804b9d3f229207fdb883014466e94b874e1f9)
+++ src/libcfa/concurrency/coroutine.c	(revision 83a071f98d287fe0dd150376b0c6ea5ff812b18b)
@@ -93,5 +93,5 @@
 // Not inline since only ever called once per coroutine
 forall(dtype T | is_coroutine(T))
-void prime(T* cor) {
+void prime(T& cor) {
 	coroutine_desc* this = get_coroutine(cor);
 	assert(this->state == Start);
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 533804b9d3f229207fdb883014466e94b874e1f9)
+++ src/libcfa/concurrency/kernel.c	(revision 83a071f98d287fe0dd150376b0c6ea5ff812b18b)
@@ -139,5 +139,5 @@
 }
 
-void ?{}(processor & this, cluster * cltr, processorCtx_t * runner) {
+void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) {
 	this.cltr = cltr;
 	(this.terminated){ 0 };
@@ -148,12 +148,12 @@
 	this.kernel_thread = pthread_self();
 
-	this.runner = runner;
-	LIB_DEBUG_PRINT_SAFE("Kernel : constructing system processor context %p\n", runner);
-	(*runner){ &this };
+	this.runner = &runner;
+	LIB_DEBUG_PRINT_SAFE("Kernel : constructing system processor context %p\n", &runner);
+	runner{ &this };
 }
 
 LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )
 
-void ?{}(system_proc_t & this, cluster * cltr, processorCtx_t * runner) {
+void ?{}(system_proc_t & this, cluster * cltr, processorCtx_t & runner) {
 	(this.alarms){};
 	(this.alarm_lock){};
@@ -187,6 +187,6 @@
 //=============================================================================================
 //Main of the processor contexts
-void main(processorCtx_t * runner) {
-	processor * this = runner->proc;
+void main(processorCtx_t & runner) {
+	processor * this = runner.proc;
 
 	LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
@@ -233,5 +233,5 @@
 // from the processor coroutine to the target thread
 void runThread(processor * this, thread_desc * dst) {
-	coroutine_desc * proc_cor = get_coroutine(this->runner);
+	coroutine_desc * proc_cor = get_coroutine(*this->runner);
 	coroutine_desc * thrd_cor = get_coroutine(dst);
 
@@ -315,5 +315,5 @@
 	// appropriate stack.
 	proc_cor_storage.__cor.state = Active;
-	main( &proc_cor_storage );
+	main( proc_cor_storage );
 	proc_cor_storage.__cor.state = Halted;
 
@@ -455,5 +455,5 @@
 	mainThread = (thread_desc *)&mainThreadStorage;
 	current_stack_info_t info;
-	mainThread{ &info };
+	(*mainThread){ &info };
 
 	LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
@@ -461,5 +461,5 @@
 	// Initialize the system cluster
 	systemCluster = (cluster *)&systemClusterStorage;
-	systemCluster{};
+	(*systemCluster){};
 
 	LIB_DEBUG_PRINT_SAFE("Kernel : System cluster ready\n");
@@ -468,5 +468,5 @@
 	// (the coroutine that contains the processing control flow)
 	systemProcessor = (system_proc_t *)&systemProcessorStorage;
-	(*systemProcessor){ systemCluster, (processorCtx_t *)&systemProcessorCtxStorage };
+	(*systemProcessor){ systemCluster, *(processorCtx_t *)&systemProcessorCtxStorage };
 
 	// Add the main thread to the ready queue
@@ -486,5 +486,5 @@
 	// context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
 	// mainThread is on the ready queue when this call is made.
-	resume( systemProcessor->proc.runner );
+	resume( *systemProcessor->proc.runner );
 
 
@@ -514,5 +514,5 @@
 	// Destroy the system processor and its context in reverse order of construction
 	// These were manually constructed so we need manually destroy them
-	^(systemProcessor->proc.runner){};
+	^(*systemProcessor->proc.runner){};
 	^(systemProcessor){};
 
Index: src/libcfa/concurrency/thread
===================================================================
--- src/libcfa/concurrency/thread	(revision 533804b9d3f229207fdb883014466e94b874e1f9)
+++ src/libcfa/concurrency/thread	(revision 83a071f98d287fe0dd150376b0c6ea5ff812b18b)
@@ -30,17 +30,17 @@
 trait is_thread(dtype T) {
       void ^?{}(T& mutex this);
-      void main(T* this);
-      thread_desc* get_thread(T* this);
+      void main(T& this);
+      thread_desc* get_thread(T& this);
 };
 
-#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->__thrd; } void main(X* this)
+#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this)
 
 forall( dtype T | is_thread(T) )
-static inline coroutine_desc* get_coroutine(T* this) {
+static inline coroutine_desc* get_coroutine(T & this) {
 	return &get_thread(this)->cor;
 }
 
 forall( dtype T | is_thread(T) )
-static inline monitor_desc* get_monitor(T * this) {
+static inline monitor_desc* get_monitor(T & this) {
 	return &get_thread(this)->mon;
 }
@@ -57,5 +57,5 @@
 
 forall( dtype T | is_thread(T) )
-void __thrd_start( T* this );
+void __thrd_start( T & this );
 
 //-----------------------------------------------------------------------------
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 533804b9d3f229207fdb883014466e94b874e1f9)
+++ src/libcfa/concurrency/thread.c	(revision 83a071f98d287fe0dd150376b0c6ea5ff812b18b)
@@ -51,5 +51,5 @@
 void ?{}( scoped(T)& this ) {
 	(this.handle){};
-	__thrd_start(&this.handle);
+	__thrd_start(this.handle);
 }
 
@@ -57,5 +57,5 @@
 void ?{}( scoped(T)& this, P params ) {
 	(this.handle){ params };
-	__thrd_start(&this.handle);
+	__thrd_start(this.handle);
 }
 
@@ -68,5 +68,5 @@
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
-void __thrd_start( T* this ) {
+void __thrd_start( T& this ) {
 	coroutine_desc* thrd_c = get_coroutine(this);
 	thread_desc*  thrd_h = get_thread   (this);
@@ -78,5 +78,5 @@
 	create_stack(&thrd_c->stack, thrd_c->stack.size);
 	this_coroutine = thrd_c;
-	CtxStart(this, CtxInvokeThread);
+	CtxStart(&this, CtxInvokeThread);
 	assert( thrd_c->last->stack.context );
 	CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context );
Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision 533804b9d3f229207fdb883014466e94b874e1f9)
+++ src/libcfa/stdlib	(revision 83a071f98d287fe0dd150376b0c6ea5ff812b18b)
@@ -135,6 +135,6 @@
 // allocation/deallocation and constructor/destructor, non-array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );
-forall( dtype T | { void ^?{}( T & ); } ) void delete( T * ptr );
-forall( dtype T, ttype Params | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest );
+forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );
+forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest );
 
 // allocation/deallocation and constructor/destructor, array types
Index: src/libcfa/stdlib.c
===================================================================
--- src/libcfa/stdlib.c	(revision 533804b9d3f229207fdb883014466e94b874e1f9)
+++ src/libcfa/stdlib.c	(revision 83a071f98d287fe0dd150376b0c6ea5ff812b18b)
@@ -44,16 +44,16 @@
 } // new
 
-forall( dtype T | { void ^?{}( T & ); } )
+forall( dtype T | sized(T) | { void ^?{}( T & ); } )
 void delete( T * ptr ) {
 	if ( ptr ) {										// ignore null
-		^ptr{};											// run destructor
+		^(*ptr){};											// run destructor
 		free( ptr );
 	} // if
 } // delete
 
-forall( dtype T, ttype Params | { void ^?{}( T & ); void delete( Params ); } )
+forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } )
 void delete( T * ptr, Params rest ) {
 	if ( ptr ) {										// ignore null
-		^ptr{};											// run destructor
+		^(*ptr){};											// run destructor
 		free( ptr );
 	} // if