Index: src/libcfa/concurrency/alarm.c
===================================================================
--- src/libcfa/concurrency/alarm.c	(revision c5ac6d50679bfa2c0447315ee7255a5bdfb68af2)
+++ src/libcfa/concurrency/alarm.c	(revision fbefc4d3828f1aefa33a88c51be496688bb6e6dd)
@@ -104,6 +104,6 @@
 
 static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) {
-	assert( it );
-	assert( (*it)->next == n );
+	verify( it );
+	verify( (*it)->next == n );
 
 	(*it)->next = n->next;
Index: src/libcfa/concurrency/coroutine
===================================================================
--- src/libcfa/concurrency/coroutine	(revision c5ac6d50679bfa2c0447315ee7255a5bdfb68af2)
+++ src/libcfa/concurrency/coroutine	(revision fbefc4d3828f1aefa33a88c51be496688bb6e6dd)
@@ -71,5 +71,5 @@
 // Suspend implementation inlined for performance
 static inline void suspend() {
-      coroutine_desc * src = this_coroutine();		// optimization
+	coroutine_desc * src = this_coroutine();		// optimization
 
 	assertf( src->last != 0,
@@ -91,10 +91,10 @@
 	coroutine_desc * dst = get_coroutine(cor);
 
-      if( unlikely(!dst->stack.base) ) {
+	if( unlikely(!dst->stack.base) ) {
 		create_stack(&dst->stack, dst->stack.size);
 		CtxStart(cor, CtxInvokeCoroutine);
 	}
 
-      // not resuming self ?
+	// not resuming self ?
 	if ( src != dst ) {
 		assertf( dst->state != Halted ,
@@ -103,9 +103,9 @@
 			src->name, src, dst->name, dst );
 
-            // set last resumer
+		// set last resumer
 		dst->last = src;
 	} // if
 
-      // always done for performance testing
+	// always done for performance testing
 	CoroutineCtxSwitch( src, dst );
 }
@@ -114,5 +114,5 @@
 	coroutine_desc * src = this_coroutine();		// optimization
 
-      // not resuming self ?
+	// not resuming self ?
 	if ( src != dst ) {
 		assertf( dst->state != Halted ,
@@ -121,9 +121,9 @@
 			src->name, src, dst->name, dst );
 
-            // set last resumer
+		// set last resumer
 		dst->last = src;
 	} // if
 
-      // always done for performance testing
+	// always done for performance testing
 	CoroutineCtxSwitch( src, dst );
 }
Index: src/libcfa/concurrency/coroutine.c
===================================================================
--- src/libcfa/concurrency/coroutine.c	(revision c5ac6d50679bfa2c0447315ee7255a5bdfb68af2)
+++ src/libcfa/concurrency/coroutine.c	(revision fbefc4d3828f1aefa33a88c51be496688bb6e6dd)
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision c5ac6d50679bfa2c0447315ee7255a5bdfb68af2)
+++ src/libcfa/concurrency/kernel.c	(revision fbefc4d3828f1aefa33a88c51be496688bb6e6dd)
@@ -311,6 +311,6 @@
 	// appropriate stack.
 	proc_cor_storage.__cor.state = Active;
-      main( &proc_cor_storage );
-      proc_cor_storage.__cor.state = Halted;
+	main( &proc_cor_storage );
+	proc_cor_storage.__cor.state = Halted;
 
 	// Main routine of the core returned, the core is now fully terminated
@@ -333,5 +333,5 @@
 	if( !thrd ) return;
 
-	assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
+	verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 	
 	lock( &systemProcessor->proc.cltr->lock );
@@ -577,5 +577,5 @@
 
 void append( __thread_queue_t * this, thread_desc * t ) {
-	assert(this->tail != NULL);
+	verify(this->tail != NULL);
 	*this->tail = t;
 	this->tail = &t->next;
@@ -599,5 +599,5 @@
 
 void push( __condition_stack_t * this, __condition_criterion_t * t ) {
-	assert( !t->next );
+	verify( !t->next );
 	t->next = this->top;
 	this->top = t;
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision c5ac6d50679bfa2c0447315ee7255a5bdfb68af2)
+++ src/libcfa/concurrency/kernel_private.h	(revision fbefc4d3828f1aefa33a88c51be496688bb6e6dd)
@@ -22,4 +22,6 @@
 
 #include "alarm.h"
+
+#include "libhdr.h"
 
 //-----------------------------------------------------------------------------
@@ -66,11 +68,11 @@
 
 static inline void enable_interrupts_noRF() {
-	unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
-	assert( prev != (unsigned short) 0 );
+	__attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+	verify( prev != (unsigned short) 0 );
 }
 
 static inline void enable_interrupts() {
-	unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
-	assert( prev != (unsigned short) 0 );
+	__attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+	verify( prev != (unsigned short) 0 );
 	if( prev == 1 && this_processor->pending_preemption ) {
 		ScheduleInternal( this_processor->current_thread );
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision c5ac6d50679bfa2c0447315ee7255a5bdfb68af2)
+++ src/libcfa/concurrency/monitor	(revision fbefc4d3828f1aefa33a88c51be496688bb6e6dd)
@@ -26,5 +26,5 @@
 static inline void ?{}(monitor_desc * this) {
 	this->owner = NULL;
-      this->stack_owner = NULL;
+	this->stack_owner = NULL;
 	this->recursion = 0;
 }
@@ -33,6 +33,6 @@
 	monitor_desc ** m;
 	int count;
-      monitor_desc ** prev_mntrs;
-      unsigned short  prev_count;
+	monitor_desc ** prev_mntrs;
+	unsigned short  prev_count;
 };
 
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision c5ac6d50679bfa2c0447315ee7255a5bdfb68af2)
+++ src/libcfa/concurrency/monitor.c	(revision fbefc4d3828f1aefa33a88c51be496688bb6e6dd)
@@ -56,5 +56,5 @@
 		else if( this->owner == thrd) {
 			//We already have the monitor, just not how many times we took it
-			assert( this->recursion > 0 );
+			verify( this->recursion > 0 );
 			this->recursion += 1;
 		}
@@ -78,8 +78,6 @@
 		lock( &this->lock );
 
-		thread_desc * thrd = this_thread();
-
 		LIB_DEBUG_PRINT_SAFE("%p Leaving %p (o: %p, r: %i)\n", thrd, this, this->owner, this->recursion);
-		assertf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i)", thrd, this->owner, this->recursion );
+		verifyf( this_thread() == this->owner, "Expected owner to be %p, got %p (r: %i)", this_thread(), this->owner, this->recursion );
 
 		//Leaving a recursion level, decrement the counter
@@ -167,6 +165,6 @@
 	//Check that everything is as expected
 	assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
-	assertf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
-	assertf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count );
+	verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+	verifyf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count );
 
 	unsigned short count = this->monitor_count;
@@ -229,6 +227,6 @@
 
 	//Check that everything is as expected
-	assert( this->monitors );
-	assert( this->monitor_count != 0 );
+	verify( this->monitors );
+	verify( this->monitor_count != 0 );
 
 	unsigned short count = this->monitor_count;
@@ -278,6 +276,6 @@
 
 	//Check that everything is as expected
-	assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
-	assertf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+	verifyf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
+	verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
 
 	unsigned short count = this->monitor_count;
@@ -327,9 +325,7 @@
 
 uintptr_t front( condition * this ) {
-	LIB_DEBUG_DO(
-		if( is_empty(this) ) {
-			abortf( "Attempt to access user data on an empty condition.\n"
-                    "Possible cause is not checking if the condition is empty before reading stored data." );
-		}
+	verifyf( !is_empty(this), 
+		"Attempt to access user data on an empty condition.\n"
+		"Possible cause is not checking if the condition is empty before reading stored data."
 	);
 	return this->blocked.head->user_info;
@@ -491,5 +487,5 @@
 
 void append( __condition_blocked_queue_t * this, __condition_node_t * c ) {
-	assert(this->tail != NULL);
+	verify(this->tail != NULL);
 	*this->tail = c;
 	this->tail = &c->next;
