Now let me quickly start this before something else happens.
So for the record, apologies Stefan couldn't make it, so but instead because he fell sick ahead of
forst him, which is the first, usually it's the other way around, so it's a recording
and so for the radio, Stefan and Lova.
So for the record, it's the other way around, and it's the other way around, and it's the other way around.
It's the other way around, and it's the other way around, and it's the other way around, and it's the other way around.
So that's the last piece.
What doesn't work that nicely is that
and scripting has this idea that if you block the browser main thread with your code, then some of the
scripting simulation doesn't work well, so scripting tries to simulate for your
example.
It creates to create your scripts, but they don't work if you don't block the main thread for the
browser, but usually all of the application code does run on the main thread, so this doesn't fit.
So what scripting has there is a built-in switch to move all of the replication code off the main thread.
So the main thread of the to do it, the work is supposed to do by a browser, then
not get blocked by your application code, and there's some mechanisms that
have scripted to make that work more or less, but apparently we had to hack a few places in the
code to also adapt to that, because then can't do any more in your application code
is accessed all the browser data like this, which I just went to object.
So we had to hack a few places with a proxy over to the other thread to get that working
well, and yeah, the more or less less it works, and the canvas is also transparency
handed over by the script to the other thread to make that work.
So a few hexons should find in the Q5 code, and all of this works.
But Q5 is old by now, and Q6 is available for quite a while, and some of the things
were even work way better, and know that if you use Q6 rather than Q5,
like a copy paste is a place where they had many improvements at the time.
You'll be nice and be close to Q5, Q6.
But thanks of, I mean, changed massively in the Q2 code since then.
This is a longer single canvas element, for example, but each window is its own canvas.
So there is the script and hack of moving this one, canvas over to the additional
proxy to pithread thread.
Can't work anymore because we don't have a single canvas that we can move up
front before we start up, we need to listen tap into the whatever in the canvas is generated
on the fly by the Q4, we need to tap into that.
And it says to the James window, data in all of that is now spread all over the place
on the Q4 code.
So instead of a handful of places that I want to change over, we need to change hundreds,
thousands.
I gave up.
I asked on the Q8 list and they said, yes, sure, if you can get that work in a way that doesn't spoil
the existing code and just add to that an additional option.
Go ahead, send it to the page.
But I see the way for that.
So what was disappointed in thought?
There's no way for ever to have flow further.
Six.
About that time, I discovered a new WebAssembly extension that allows to, without changing your
button code at all, or is it plus plus code, without changing that having the illusion,
that at some point in time you suspend your resin code, give access to the browser main
loop again.
And when that is done, go back into the exactly the place in your resin code you were
in before.
Now what it should use there for something else completely for the model dialogue issue.
And there it works as well.
Kind of well.
But that also gave me an idea I could leverage this for my six problems.
So what we have this, we have the main browser threat, the browser event loop, the Q2 event
handling, the load event handling, and running all of the labor office code.
We wanted it to originally, or what we do with Q5, this have the split between the browser
and the Q2 event handling.
If that overture a different threat, now let's see if that doesn't work anymore.
So Q6.
But what if we do that split not the head of the Q2 event handling, but head of the new
event handling.
By using this JSPI machinery to when the Q2 event handling sees the new event that it wants
to hand over to the new office event handling, make it stop, make it proxy that event over
to an additional threat, make it go back to the browser event loop, by the other threat
is doing the new office work, and then that is done.
Just go back into the Q2 event handling as if nothing had happened in between.
And it starts off again from the place where it had been interrupted.
And that works, and that works even quite well.
And then because the new office code is already prepared to run on different threats,
we even see outcome of this event.
And most of the time expect to be run on the main threat.
There is some places in Q2 that are picky about which they are on.
So when we call into that, from all of this event, we need to make sure that we are on the right
threat.
There is some extraction there.
And that takes lambda, and that's it.
I don't want them to be the threat you are on.
So for the general non-lover Q case, or proxy that over to the transcript and main threat,
for all the main threat, for the lower case.
And that's all of kind of works.
And didn't need the Q2 to be modified at all, which is great.
So I will see a variety of documents, even start out.
Some places, the crashes, or various very mental codes still on my machine only,
and then what happens to it.
Yeah, but promising.
And if you want to see at least the five codes in action, then you can try it out here.
And always tell us thanks.
Thank you.