Index: src/Concurrency/Keywords.cc
===================================================================
--- src/Concurrency/Keywords.cc	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/Concurrency/Keywords.cc	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -17,9 +17,9 @@
 #include "Concurrency/Keywords.h"
 
+#include "InitTweak/InitTweak.h"
 #include "SymTab/AddVisit.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Initializer.h"
-#include "SynTree/Mutator.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
@@ -38,4 +38,46 @@
 	// Visitors declaration
 	//=============================================================================================
+
+	//-----------------------------------------------------------------------------
+	//Handles sue type declarations :
+	// sue MyType {                             struct MyType {
+	// 	int data;                                  int data;
+	// 	a_struct_t more_data;                      a_struct_t more_data;
+	//                                =>             NewField_t newField;
+	// };                                        };
+	//                                           static inline NewField_t * getter_name( MyType * this ) { return &this->newField; }
+	//
+	class ConcurrentSueKeyword : public Visitor {
+	  protected:
+	    template< typename Visitor >
+	    friend void SymTab::acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
+	  public:
+
+	  	ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main ) :
+		  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ) {}
+
+		virtual ~ConcurrentSueKeyword() {}
+
+		using Visitor::visit;
+		virtual void visit( StructDecl * decl ) override final;
+
+		void handle( StructDecl * );
+		FunctionDecl * forwardDeclare( StructDecl * );
+		ObjectDecl * addField( StructDecl * );
+		void addRoutines( StructDecl *, ObjectDecl *, FunctionDecl * );
+
+		virtual bool is_target( StructDecl * decl ) = 0;
+
+	  private:
+		const std::string type_name;
+		const std::string field_name;
+		const std::string getter_name;
+		const std::string context_error;
+		bool needs_main;
+
+		std::list< Declaration * > declsToAdd, declsToAddAfter;
+		StructDecl* type_decl = nullptr;
+	};
+
 
 	//-----------------------------------------------------------------------------
@@ -47,10 +89,25 @@
 	// };                                        };
 	//                                           static inline thread_desc * get_thread( MyThread * this ) { return &this->__thrd_d; }
-	//                                           void main( MyThread * this );
 	//
-	class ThreadKeyword final : public Mutator {
+	class ThreadKeyword final : public ConcurrentSueKeyword {
 	  public:
 
-		static void implement( std::list< Declaration * > & translationUnit ) {}
+	  	ThreadKeyword() : ConcurrentSueKeyword(
+			"thread_desc",
+			"__thrd",
+			"get_thread",
+			"thread keyword requires threads to be in scope, add #include <thread>",
+			true
+		)
+		{}
+
+		virtual ~ThreadKeyword() {}
+
+		virtual bool is_target( StructDecl * decl ) override final { return decl->is_thread(); }
+
+		static void implement( std::list< Declaration * > & translationUnit ) {
+			ThreadKeyword impl;
+			SymTab::acceptAndAdd( translationUnit, impl );
+		}
 	};
 
@@ -63,17 +120,20 @@
 	// };                                        };
 	//                                           static inline coroutine_desc * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
-	//                                           void main( MyCoroutine * this );
 	//
-	class CoroutineKeyword final : public Visitor {
-	    template< typename Visitor >
-	    friend void SymTab::acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
+	class CoroutineKeyword final : public ConcurrentSueKeyword {
 	  public:
 
-		using Visitor::visit;
-		virtual void visit( StructDecl * decl ) override final;
-
-		void handle( StructDecl * );
-		Declaration * addField( StructDecl * );
-		void addRoutines( StructDecl *, Declaration * );
+	  	CoroutineKeyword() : ConcurrentSueKeyword(
+			"coroutine_desc",
+			"__cor",
+			"get_coroutine",
+			"coroutine keyword requires coroutines to be in scope, add #include <coroutine>",
+			true
+		)
+		{}
+
+		virtual ~CoroutineKeyword() {}
+
+		virtual bool is_target( StructDecl * decl ) override final { return decl->is_coroutine(); }
 
 		static void implement( std::list< Declaration * > & translationUnit ) {
@@ -81,8 +141,4 @@
 			SymTab::acceptAndAdd( translationUnit, impl );
 		}
-
-	  private:
-		std::list< Declaration * > declsToAdd, declsToAddAfter;
-		StructDecl* coroutine_decl = nullptr;
 	};
 
@@ -95,10 +151,25 @@
 	// };                                        };
 	//                                           static inline monitor_desc * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
-	//                                           void main( MyMonitor * this );
 	//
-	class MonitorKeyword final : public Mutator {
+	class MonitorKeyword final : public ConcurrentSueKeyword {
 	  public:
 
-		static void implement( std::list< Declaration * > & translationUnit ) {}
+	  	MonitorKeyword() : ConcurrentSueKeyword(
+			"monitor_desc",
+			"__mon",
+			"get_monitor",
+			"monitor keyword requires monitors to be in scope, add #include <monitor>",
+			false
+		)
+		{}
+
+		virtual ~MonitorKeyword() {}
+
+		virtual bool is_target( StructDecl * decl ) override final { return decl->is_monitor(); }
+
+		static void implement( std::list< Declaration * > & translationUnit ) {
+			MonitorKeyword impl;
+			SymTab::acceptAndAdd( translationUnit, impl );
+		}
 	};
 
@@ -132,4 +203,26 @@
 	};
 
+	//-----------------------------------------------------------------------------
+	//Handles mutex routines definitions :
+	// void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
+	// 	                                                                 monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
+	// 	                                                                 monitor_guard_t __guard = { __monitors, 2 };
+	//    /*Some code*/                                       =>           /*Some code*/
+	// }                                                               }
+	//
+	class ThreadStarter final : public Visitor {
+	  public:
+
+		using Visitor::visit;
+		virtual void visit( FunctionDecl * decl ) override final;
+
+		void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
+
+		static void implement( std::list< Declaration * > & translationUnit ) {
+			ThreadStarter impl;
+			acceptAll( translationUnit, impl );
+		}
+	};
+
 	//=============================================================================================
 	// General entry routine
@@ -139,16 +232,23 @@
 		CoroutineKeyword	::implement( translationUnit );
 		MonitorKeyword	::implement( translationUnit );
+	}
+
+	void implementMutexFuncs( std::list< Declaration * > & translationUnit ) {
 		MutexKeyword	::implement( translationUnit );
 	}
 
-	//=============================================================================================
-	// Coroutine keyword implementation
-	//=============================================================================================
-	void CoroutineKeyword::visit(StructDecl * decl) {
-		if( decl->get_name() == "coroutine_desc" ) {
-			assert( !coroutine_decl );
-			coroutine_decl = decl;
-		}
-		else if ( decl->is_coroutine() ) {
+	void implementThreadStarter( std::list< Declaration * > & translationUnit ) {
+		ThreadStarter	::implement( translationUnit );
+	}
+
+	//=============================================================================================
+	// Generic keyword implementation
+	//=============================================================================================
+	void ConcurrentSueKeyword::visit(StructDecl * decl) {
+		if( decl->get_name() == type_name ) {
+			assert( !type_decl );
+			type_decl = decl;
+		}
+		else if ( is_target(decl) ) {
 			handle( decl );
 		}
@@ -156,50 +256,39 @@
 	}
 
-	void CoroutineKeyword::handle( StructDecl * decl ) {
+	void ConcurrentSueKeyword::handle( StructDecl * decl ) {
 		if( ! decl->has_body() ) return;
 
-		if( !coroutine_decl ) throw SemanticError( "coroutine keyword requires coroutines to be in scope, add #include <coroutine>", decl );
-
-		Declaration * field = addField( decl );
-		addRoutines( decl, field );
-	}
-
-	Declaration * CoroutineKeyword::addField( StructDecl * decl ) {
-		Declaration * cor = new ObjectDecl(
-			"__cor",
+		if( !type_decl ) throw SemanticError( context_error, decl );
+
+		FunctionDecl * func = forwardDeclare( decl );
+		ObjectDecl * field = addField( decl );
+		addRoutines( decl, field, func );
+	}
+
+	FunctionDecl * ConcurrentSueKeyword::forwardDeclare( StructDecl * decl ) {
+
+		StructDecl * forward = decl->clone();
+		forward->set_body( false );
+		deleteAll( forward->get_members() );
+		forward->get_members().clear();
+
+		FunctionType * get_type = new FunctionType( noQualifiers, false );
+		ObjectDecl * this_decl = new ObjectDecl(
+			"this",
 			noStorage,
 			LinkageSpec::Cforall,
 			nullptr,
-			new StructInstType(
+			new PointerType(
 				noQualifiers,
-				coroutine_decl
+				new StructInstType(
+					noQualifiers,
+					decl
+				)
 			),
 			nullptr
 		);
 
-		decl->get_members().push_back( cor );
-
-		return cor;
-	}
-
-	void CoroutineKeyword::addRoutines( StructDecl * decl, Declaration * field ) {
-		FunctionType * type = new FunctionType( noQualifiers, false );
-		type->get_parameters().push_back(
-			new ObjectDecl(
-				"this",
-				noStorage,
-				LinkageSpec::Cforall,
-				nullptr,
-				new PointerType(
-					noQualifiers,
-					new StructInstType(
-						noQualifiers,
-						decl
-					)
-				),
-				nullptr
-			)
-		);
-		type->get_returnVals().push_back(
+		get_type->get_parameters().push_back( this_decl );
+		get_type->get_returnVals().push_back(
 			new ObjectDecl(
 				"ret",
@@ -211,5 +300,5 @@
 					new StructInstType(
 						noQualifiers,
-						coroutine_decl
+						type_decl
 					)
 				),
@@ -218,4 +307,56 @@
 		);
 
+		FunctionDecl * get_decl = new FunctionDecl(
+			getter_name,
+			Type::Static,
+			LinkageSpec::Cforall,
+			get_type,
+			nullptr,
+			noAttributes,
+			Type::Inline
+		);
+
+		FunctionDecl * main_decl = nullptr;
+
+		if( needs_main ) {
+			FunctionType * main_type = new FunctionType( noQualifiers, false );
+			
+			main_type->get_parameters().push_back( this_decl->clone() );
+
+			main_decl = new FunctionDecl(
+				"main",
+				noStorage,
+				LinkageSpec::Cforall,
+				main_type,
+				nullptr
+			);
+		}
+
+		declsToAdd.push_back( forward );
+		if( needs_main ) declsToAdd.push_back( main_decl );
+		declsToAdd.push_back( get_decl );
+
+		return get_decl;
+	}
+
+	ObjectDecl * ConcurrentSueKeyword::addField( StructDecl * decl ) {
+		ObjectDecl * field = new ObjectDecl(
+			field_name,
+			noStorage,
+			LinkageSpec::Cforall,
+			nullptr,
+			new StructInstType(
+				noQualifiers,
+				type_decl
+			),
+			nullptr
+		);
+
+		decl->get_members().push_back( field );
+
+		return field;
+	}
+
+	void ConcurrentSueKeyword::addRoutines( StructDecl * decl, ObjectDecl * field, FunctionDecl * func ) {
 		CompoundStmt * statement = new CompoundStmt( noLabels );
 		statement->push_back( 
@@ -223,10 +364,7 @@
 				noLabels,
 				new AddressExpr(
-					new UntypedMemberExpr(
-						new NameExpr( "__cor" ),
-						new UntypedExpr(
-							new NameExpr( "*?" ),
-							{ new NameExpr( "this" ) }
-						)
+					new MemberExpr(
+						field,
+						UntypedExpr::createDeref( new VariableExpr( func->get_functionType()->get_parameters().front() ) )
 					)
 				)
@@ -234,19 +372,12 @@
 		);
 
-		FunctionDecl * get_decl = new FunctionDecl(
-			"get_coroutine",
-			Type::Static,
-			LinkageSpec::Cforall,
-			type,
-			statement,
-			noAttributes,
-			Type::Inline
-		);
+		FunctionDecl * get_decl = func->clone();
+
+		get_decl->set_statements( statement );
 
 		declsToAddAfter.push_back( get_decl );
 
-		get_decl->fixUniqueId();
-	}
-	
+		// get_decl->fixUniqueId();
+	}
 
 	//=============================================================================================
@@ -368,3 +499,35 @@
 		body->push_front( new DeclStmt( noLabels, monitors) );
 	}
+
+	//=============================================================================================
+	// General entry routine
+	//=============================================================================================
+	void ThreadStarter::visit(FunctionDecl * decl) {
+		if( ! InitTweak::isConstructor(decl->get_name()) ) return;
+
+		DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
+		auto ptr = dynamic_cast< PointerType * >( param->get_type() );
+		// if( ptr ) std::cerr << "FRED1" << std::endl;
+		auto type  = dynamic_cast< StructInstType * >( ptr->get_base() );
+		// if( type ) std::cerr << "FRED2" << std::endl;
+		if( type && type->get_baseStruct()->is_thread() ) {
+			addStartStatement( decl, param );
+		}
+	}
+
+	void ThreadStarter::addStartStatement( FunctionDecl * decl, DeclarationWithType * param ) {
+		CompoundStmt * stmt = decl->get_statements();
+
+		if( ! stmt ) return;
+
+		stmt->push_back( 
+			new ExprStmt(
+				noLabels,
+				new UntypedExpr(
+					new NameExpr( "__thrd_start" ),
+					{ new VariableExpr( param ) }
+				)
+			)
+		);
+	}
 };
Index: src/Concurrency/Keywords.h
===================================================================
--- src/Concurrency/Keywords.h	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/Concurrency/Keywords.h	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -24,4 +24,6 @@
 namespace Concurrency {
 	void applyKeywords( std::list< Declaration * > & translationUnit );
+	void implementMutexFuncs( std::list< Declaration * > & translationUnit );
+	void implementThreadStarter( std::list< Declaration * > & translationUnit );
 };
 
Index: src/Parser/lex.ll
===================================================================
--- src/Parser/lex.ll	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/Parser/lex.ll	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -236,5 +236,5 @@
 long			{ KEYWORD_RETURN(LONG); }
 lvalue			{ KEYWORD_RETURN(LVALUE); }				// CFA
-_Monitor		{ KEYWORD_RETURN(MONITOR); }			// CFA
+monitor		{ KEYWORD_RETURN(MONITOR); }			// CFA
 mutex			{ KEYWORD_RETURN(MUTEX); }				// CFA
 _Noreturn		{ KEYWORD_RETURN(NORETURN); }			// C11
@@ -256,5 +256,5 @@
 struct			{ KEYWORD_RETURN(STRUCT); }
 switch			{ KEYWORD_RETURN(SWITCH); }
-_Thread			{ KEYWORD_RETURN(THREAD); }				// C11
+thread			{ KEYWORD_RETURN(THREAD); }				// C11
 _Thread_local	{ KEYWORD_RETURN(THREADLOCAL); }		// C11
 throw			{ KEYWORD_RETURN(THROW); }				// CFA
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/SymTab/Autogen.cc	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -218,7 +218,12 @@
 
 		/// generates a function (?{}, ?=?, ^?{}) based on the data argument and members. If function is generated, inserts the type into the map.
-		void gen( const FuncData & data ) {
+		void gen( const FuncData & data, bool concurrent_type ) {
 			if ( ! shouldGenerate( data.map, aggregateDecl ) ) return;
 			FunctionType * ftype = data.genType( refType );
+
+			if(concurrent_type && InitTweak::isDestructor( data.fname )) {
+				ftype->get_parameters().front()->get_type()->set_mutex( true );
+			}
+
 			cloneAll( typeParams, ftype->get_forall() );
 			*out++ = genFunc( data.fname, ftype, functionNesting );
@@ -403,6 +408,7 @@
 		auto generator = makeFuncGenerator( aggregateDecl, refType, functionNesting, typeParams, back_inserter( newFuncs ) );
 		for ( const FuncData & d : data ) {
-			generator.gen( d );
-		}
+			generator.gen( d, aggregateDecl->is_thread() || aggregateDecl->is_monitor() );
+		}
+
 		// field ctors are only generated if default constructor and copy constructor are both generated
 		unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return InitTweak::isConstructor( dcl->get_name() ); } );
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/SymTab/Validate.cc	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -43,4 +43,5 @@
 #include "Common/utility.h"
 #include "Common/UniqueName.h"
+#include "Concurrency/Keywords.h"
 #include "Validate.h"
 #include "SynTree/Visitor.h"
@@ -225,5 +226,8 @@
 		ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
 		acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+		Concurrency::applyKeywords( translationUnit );
 		autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass
+		Concurrency::implementMutexFuncs( translationUnit );
+		Concurrency::implementThreadStarter( translationUnit );
 		acceptAll( translationUnit, epc );
 		ReturnChecker::checkFunctionReturns( translationUnit );
Index: src/libcfa/concurrency/thread
===================================================================
--- src/libcfa/concurrency/thread	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/libcfa/concurrency/thread	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -56,4 +56,7 @@
 thread_desc * this_thread(void);
 
+forall( dtype T | is_thread(T) )
+void __thrd_start( T* this );
+
 //-----------------------------------------------------------------------------
 // Ctors and dtors
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/libcfa/concurrency/thread.c	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -31,9 +31,4 @@
 
 //-----------------------------------------------------------------------------
-// Forward declarations
-forall( dtype T | is_thread(T) )
-void start( T* this );
-
-//-----------------------------------------------------------------------------
 // Thread ctors and dtors
 
@@ -53,5 +48,5 @@
 void ?{}( scoped(T)* this ) {
 	(&this->handle){};
-	start(&this->handle);
+	__thrd_start(&this->handle);
 }
 
@@ -59,5 +54,5 @@
 void ?{}( scoped(T)* this, P params ) {
 	(&this->handle){ params };
-	start(&this->handle);
+	__thrd_start(&this->handle);
 }
 
@@ -70,5 +65,5 @@
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
-void start( T* this ) {
+void __thrd_start( T* this ) {
 	coroutine_desc* thrd_c = get_coroutine(this);
 	thread_desc*  thrd_h = get_thread   (this);
Index: src/main.cc
===================================================================
--- src/main.cc	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/main.cc	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -216,4 +216,7 @@
 		} // if
 
+		// OPTPRINT( "Concurrency" )
+		// Concurrency::applyKeywords( translationUnit );
+
 		// add the assignment statement after the initialization of a type parameter
 		OPTPRINT( "validate" )
@@ -237,6 +240,4 @@
 		OPTPRINT( "mutate" )
 		ControlStruct::mutate( translationUnit );
-		OPTPRINT( "Concurrency" )
-		Concurrency::applyKeywords( translationUnit );
 		OPTPRINT( "fixNames" )
 		CodeGen::fixNames( translationUnit );
Index: src/tests/monitor.c
===================================================================
--- src/tests/monitor.c	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/tests/monitor.c	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -4,15 +4,10 @@
 #include <thread>
 
-struct global_t {
+monitor global_t {
 	int value;
-	monitor_desc m;
 };
 
 void ?{}(global_t * this) {
 	this->value = 0;
-}
-
-monitor_desc * get_monitor( global_t * this ) {
-	return &this->m;
 }
 
@@ -31,10 +26,5 @@
 }
 
-struct MyThread { thread_desc __thrd; };
-
-DECL_THREAD(MyThread);
-
-void ?{}( MyThread * this ) {}
-void ^?{}( MyThread * mutex this ) {}
+thread MyThread {};
 
 void main( MyThread* this ) {
@@ -45,8 +35,8 @@
 
 int main(int argc, char* argv[]) {
-	assert( global.m.entry_queue.tail != NULL );
+	assert( global.__mon.entry_queue.tail != NULL );
 	processor p;
 	{
-		scoped(MyThread) f[4];
+		MyThread f[4];
 	}
 	sout | global.value | endl;
Index: src/tests/multi-monitor.c
===================================================================
--- src/tests/multi-monitor.c	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/tests/multi-monitor.c	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -6,11 +6,5 @@
 static int global12, global23, global13;
 
-struct monitor_t {
-	monitor_desc m;
-};
-
-monitor_desc * get_monitor( monitor_t * this ) {
-	return &this->m;
-}
+monitor monitor_t {};
 
 static monitor_t m1, m2, m3;
Index: src/tests/thread.c
===================================================================
--- src/tests/thread.c	(revision 31ee19ffaf4a0680cf508ae188ea319eb5f8573e)
+++ src/tests/thread.c	(revision 89ae7f46a494f2bdc682e89b30a0d28f572bee65)
@@ -4,15 +4,15 @@
 #include <thread>
 
-struct First { thread_desc __thrd; signal_once* lock; };
-struct Second { thread_desc __thrd; signal_once* lock; };
+// thread First;
+// void main(First* this);
 
-DECL_THREAD(First);
-DECL_THREAD(Second);
+// thread Second;
+// void main(Second* this);
+
+thread First  { signal_once* lock; };
+thread Second { signal_once* lock; };
 
 void ?{}( First * this, signal_once* lock ) { this->lock = lock; }
 void ?{}( Second * this, signal_once* lock ) { this->lock = lock; }
-
-void ^?{}( First  * mutex this ) {}
-void ^?{}( Second * mutex this ) {}
 
 void main(First* this) {
@@ -39,6 +39,6 @@
 		processor p;
 		{
-			scoped(First)  f = { &lock };
-			scoped(Second) s = { &lock };
+			First  f = { &lock };
+			Second s = { &lock };
 		}
 	}