Update

Kha/Tools/windows_x64/std/sys/thread/Condition.hx

@@ -0,0 +1,58 @@
+package sys.thread;
+
+#if (!target.threaded)
+#error "This class is not available on this target"
+#end
+
+/**
+	Creates a new condition variable.
+	Conditions variables can be used to block one or more threads at the same time,
+	until another thread modifies a shared variable (the condition)
+	and signals the condition variable.
+**/
+@:coreApi extern class Condition {
+	/**
+		Create a new condition variable.
+		A thread that waits on a newly created condition variable will block.
+	**/
+	function new():Void;
+
+	/**
+		Acquires the internal mutex.
+	**/
+	function acquire():Void;
+
+	/**
+		Tries to acquire the internal mutex.
+		@see `Mutex.tryAcquire`
+	**/
+	function tryAcquire():Bool;
+
+	/***
+		Releases the internal mutex.
+	**/
+	function release():Void;
+
+	/**
+		Atomically releases the mutex and blocks until the condition variable pointed is signaled by a call to
+		`signal` or to `broadcast`. When the calling thread becomes unblocked it
+		acquires the internal mutex.
+		The internal mutex should be locked before this function is called.
+	**/
+	function wait():Void;
+
+	/**
+		Unblocks one of the threads that are blocked on the
+		condition variable at the time of the call. If no threads are blocked
+		on the condition variable at the time of the call, the function does nothing.
+	**/
+	function signal():Void;
+
+	/**
+		Unblocks all of the threads that are blocked on the
+		condition variable at the time of the call. If no threads are blocked
+		on the condition variable at the time of the call, the function does
+		nothing.
+	**/
+	function broadcast():Void;
+}

Kha/Tools/windows_x64/std/sys/thread/EventLoop.hx

@@ -28,8 +28,13 @@ class EventLoop {
 	final waitLock = new Lock();
 	var promisedEventsCount = 0;
 	var regularEvents:Null<RegularEvent>;
+	var isMainThread:Bool;
+	static var CREATED : Bool;
 
-	public function new():Void {}
+	public function new():Void {
+		isMainThread = !CREATED;
+		CREATED = true;
+	}
 
 	/**
 		Schedule event for execution every `intervalMs` milliseconds in current loop.
@@ -93,13 +98,14 @@ class EventLoop {
 			case null:
 			case e: e.next = event.next;
 		}
+		event.next = event.previous = null;
 		mutex.release();
 	}
 
 	/**
 		Notify this loop about an upcoming event.
-		This makes the thread to stay alive and wait for as many events as many times
-		`.promise()` was called. These events should be added via `.runPromised()`
+		This makes the thread stay alive and wait for as many events as the number of
+		times `.promise()` was called. These events should be added via `.runPromised()`.
 	**/
 	public function promise():Void {
 		mutex.acquire();
@@ -164,8 +170,8 @@ class EventLoop {
 
 	/**
 		Execute all pending events.
-		Wait and execute as many events as many times `promiseEvent()` was called.
-		Runs until all repeating events are cancelled and no more events is expected.
+		Wait and execute as many events as the number of times `promise()` was called.
+		Runs until all repeating events are cancelled and no more events are expected.
 
 		Depending on a target platform this method may be non-reentrant. It must
 		not be called from event callbacks.
@@ -221,7 +227,7 @@ class EventLoop {
 
 		// Run regular events
 		for(i in 0...eventsToRunIdx) {
-			if(!regularsToRun[i].cancelled) 
+			if(!regularsToRun[i].cancelled)
 				regularsToRun[i].run();
 			regularsToRun[i] = null;
 		}
@@ -249,6 +255,16 @@ class EventLoop {
 			oneTimersToRun[i] = null;
 		}
 
+		// run main events
+		if( isMainThread ) {
+			var next = @:privateAccess haxe.MainLoop.tick();
+			if( haxe.MainLoop.hasEvents() ) {
+				eventsToRunIdx++;
+				if( nextEventAt > next )
+					nextEventAt = next;
+			}
+		}
+
 		// Some events were executed. They could add new events to run.
 		if(eventsToRunIdx > 0) {
 			nextEventAt = -2;
@@ -272,4 +288,4 @@ private class RegularEvent {
 		this.nextRunTime = nextRunTime;
 		this.interval = interval;
 	}
-}
+}

Kha/Tools/windows_x64/std/sys/thread/Semaphore.hx

@@ -0,0 +1,33 @@
+package sys.thread;
+
+#if (!target.threaded)
+#error "This class is not available on this target"
+#end
+@:coreApi extern class Semaphore {
+	/**
+		Creates a new semaphore with an initial value.
+	**/
+	public function new(value:Int):Void;
+
+	/**
+		Locks the semaphore.
+		If the value of the semaphore is zero, then the thread will block until it is able to lock the semaphore.
+		If the value is non-zero, it is decreased by one.
+	**/
+	public function acquire():Void;
+
+	/**
+		Try to lock the semaphore.
+		If the value of the semaphore is zero, `false` is returned, else the value is increased.
+
+		If `timeout` is specified, this function will block until the thread is able to acquire the semaphore, or the timout expires.
+		`timeout` is in seconds.
+	**/
+	public function tryAcquire(?timeout:Float):Bool;
+
+	/**
+		Release the semaphore.
+		The value of the semaphore is increased by one.
+	**/
+	public function release():Void;
+}