WEBVTT

00:00.000 --> 00:19.500
OK, OK, how's the sound?

00:19.500 --> 00:21.320
Do you have an in sound?

00:21.320 --> 00:23.260
Hey, welcome everyone.

00:23.260 --> 00:24.600
I'm Graham.

00:24.600 --> 00:29.720
And we make the first, we pass the Blippower at GameConsons of World.

00:29.720 --> 00:34.680
But no spoilers, you will see it, and we go a bit through history of the game console.

00:34.680 --> 00:38.360
And fun fact, it started on the previous first game.

00:38.360 --> 00:43.720
So it started here at now, it comes here, and maybe it will inspire

00:43.720 --> 00:47.800
some of you to make your new projects this way, pass them to the end.

00:47.800 --> 00:53.400
Oh, we'll get to it. But let's start, do we have Mike for people?

00:53.400 --> 00:56.200
Is that I can use? Is that I can give thousands?

00:56.200 --> 00:57.720
Okay, we'll make it easier.

00:57.720 --> 01:00.280
So who knows what pass them please?

01:00.280 --> 01:02.920
A trick question, right? And what pass them to the bottom?

01:02.920 --> 01:05.800
Who can say it in the mic?

01:07.800 --> 01:11.160
Okay, let's, Frank, give it a try.

01:12.200 --> 01:16.440
It's like a JVM for the web browser, but not only the web browser,

01:16.440 --> 01:18.600
it could also run without a browser.

01:18.600 --> 01:22.520
That's perfect. That's the answer, because

01:22.520 --> 01:26.680
some people say that the first thing about what pass them is the name.

01:26.760 --> 01:29.480
It's not as simple, and it's not only for web.

01:29.480 --> 01:32.360
And when I started to go into the pass, simply,

01:32.360 --> 01:37.000
all of you, it's just web without JavaScript.

01:37.000 --> 01:40.120
That's it. But that was enough to get me hooked.

01:40.120 --> 01:44.840
Because you can take normal human programming language,

01:44.840 --> 01:48.520
compile it into binary executable.

01:48.520 --> 01:53.000
And now you have front end without touching JavaScript, and it's wonderful.

01:53.000 --> 01:56.120
But indeed, the pass them is much, much, much,

01:56.120 --> 01:57.960
oh, I have a clicker.

01:57.960 --> 02:02.120
The pass them is much, much more than just Z.

02:02.120 --> 02:03.880
It's a part of programming.

02:03.880 --> 02:09.640
It has lots of features that make it a clip applicable everywhere.

02:09.640 --> 02:12.840
It's a part of lots of programming languages.

02:12.840 --> 02:16.280
C++, Z, Rust, Go.

02:16.280 --> 02:21.080
And the best one of them is actually C because there are lots of

02:21.080 --> 02:24.600
entrepreneurs in C. We have Python running and browser.

02:24.600 --> 02:27.640
We have Lua, we have operating systems.

02:27.640 --> 02:29.960
Windows 95, running and browser.

02:29.960 --> 02:32.120
We have Doom, running and browser.

02:32.120 --> 02:33.640
It's amazing technology.

02:33.640 --> 02:38.360
It's universal glue that allows you to take any application

02:38.360 --> 02:40.440
and bring it anywhere.

02:40.440 --> 02:41.960
It's very, very fast.

02:41.960 --> 02:45.880
It's slower than if you would write a nice application in C

02:45.880 --> 02:47.800
and optimize service.

02:47.880 --> 02:50.920
It probably cannot do good drivers in my pass them,

02:50.920 --> 02:53.960
but it's designed in a way to be very close

02:53.960 --> 02:56.920
to how actual processor works.

02:56.920 --> 02:59.880
It has amazing observability features.

02:59.880 --> 03:01.160
It's a virtual machine.

03:01.160 --> 03:03.800
And you know how many instructions are executed.

03:03.800 --> 03:06.280
Which functions are called at any point?

03:06.280 --> 03:09.880
And you can limit, you can prevent applications going

03:09.880 --> 03:11.240
into an infinite loop.

03:11.240 --> 03:14.440
You can see what are Z doing, create now.

03:14.440 --> 03:16.840
How they are doing it.

03:16.840 --> 03:19.640
And with observability, it's wonderful.

03:19.640 --> 03:20.440
It's just wonderful.

03:20.440 --> 03:23.000
And I will show you examples how they use it.

03:23.000 --> 03:26.440
It has amazing security features and desolations.

03:26.440 --> 03:30.440
Desolations, you cannot everything

03:30.440 --> 03:34.680
that a pass-ample application does, your environment controls it.

03:34.680 --> 03:37.560
You know, which files it access, which functions.

03:37.560 --> 03:40.840
It cannot just get random value from anywhere.

03:40.840 --> 03:45.160
It's full control from you as an environment writer.

03:45.160 --> 03:48.200
And there are lots of projects that bring you

03:48.200 --> 03:50.760
a good outside of just web.

03:50.760 --> 03:55.880
So the biggest initiative is the VAC, the pass-ample system

03:55.880 --> 03:56.920
interface.

03:56.920 --> 04:00.520
It describes names and signatures of functions,

04:00.520 --> 04:03.000
so how the pass-ample application works.

04:03.000 --> 04:06.200
If it needs access, something from the environment,

04:06.200 --> 04:08.680
it declares list of imports.

04:08.680 --> 04:11.240
And with simple, with our names of functions,

04:11.240 --> 04:14.120
it can call and their signatures.

04:14.120 --> 04:18.120
And VAC describes the state of this functions,

04:18.120 --> 04:21.240
the application can call, and the environment needs to provide

04:21.240 --> 04:25.880
for application to make fully, fully compatible

04:25.880 --> 04:27.160
post-explications.

04:27.160 --> 04:28.520
So what does it mean?

04:28.520 --> 04:30.760
You can access, using VAC, you can access

04:30.760 --> 04:35.240
environment variables, files, in files system, random values,

04:35.240 --> 04:36.440
and so on and so forth.

04:36.440 --> 04:38.920
And it's working.

04:38.920 --> 04:41.880
And of course, again, the same applies here.

04:41.880 --> 04:45.160
The environment can provide fake values.

04:45.160 --> 04:47.800
If we have an application in the pass-ample,

04:47.800 --> 04:51.400
and we want to test it, and that it uses, for instance, time,

04:51.400 --> 04:53.080
we can provide it fake time.

04:53.080 --> 04:55.880
We can pull it in any point in time.

04:55.880 --> 04:59.800
And there are so many applications for it,

04:59.800 --> 05:03.160
billions that I can just make examples out of my head.

05:03.160 --> 05:07.080
We will find more and more, as we explore, with my exact knowledge.

05:07.080 --> 05:11.320
And in the previous fast-diam, Ron, here is Ron,

05:11.320 --> 05:12.600
say hi to Ron.

05:12.600 --> 05:14.200
Hi, Ron.

05:15.400 --> 05:20.360
Ron is one of the main contributors in tiny gotium.

05:20.360 --> 05:24.840
And the tiny go is compiler for go for small places.

05:24.840 --> 05:27.160
So go is pretty small language.

05:27.160 --> 05:29.800
You can read the whole specification for the language

05:29.800 --> 05:32.280
in an evening court.

05:32.280 --> 05:37.400
And they wrote alternative compiler for go,

05:37.400 --> 05:39.880
which I was here to write go application,

05:39.880 --> 05:43.560
and compile it into very, very small places.

05:43.560 --> 05:46.040
You will see some examples from Ron.

05:46.040 --> 05:47.880
I'm pretty sure about it.

05:47.880 --> 05:52.840
But there are applications, go applications,

05:52.840 --> 05:54.680
written with the compiler to stay in go,

05:54.680 --> 05:58.360
running in keyboards, in drones.

05:58.360 --> 06:00.760
You can buy from them, if you go to their stand,

06:00.760 --> 06:04.040
in a double built-in, you can buy from IK as a creator

06:04.040 --> 06:05.240
of tiny go.

06:05.240 --> 06:10.440
Irjans of this size, the drone go on it.

06:10.440 --> 06:14.120
And last fast-diam was asked, OK, what if we take

06:14.120 --> 06:18.520
pure go of some interpreter, compile it with tiny go,

06:18.520 --> 06:22.280
and run it on embedded systems?

06:22.280 --> 06:27.160
And what we end up with, I just want a good run correction.

06:27.160 --> 06:30.600
So we got by zero, which is pure go on interpreter,

06:30.600 --> 06:31.880
for awesome.

06:31.880 --> 06:35.000
I think there were already a few talks about it earlier.

06:35.000 --> 06:39.640
And we made mechanoid, which is with framework for writing

06:39.640 --> 06:43.720
applications in go, host applications in go,

06:43.720 --> 06:46.600
so that you can utilize full power of the possible

06:46.600 --> 06:52.360
what I mean, you can make, for instance, home automation system,

06:52.360 --> 06:56.200
write it in go, compile it with tiny go, run it on Raspberry Pi,

06:56.200 --> 07:00.200
or even some fixed smaller, like a speed source, too.

07:00.200 --> 07:03.880
And let people write extensions for it in any program

07:03.880 --> 07:07.480
in language using the power of the possible.

07:07.480 --> 07:10.040
And run will show you.

07:10.040 --> 07:14.520
So the previous conference, he was running a drone,

07:14.520 --> 07:18.760
the first drone in the world, controlled by the possible.

07:18.760 --> 07:20.600
And you will see more drones.

07:20.600 --> 07:25.800
I'm not that brave as run to get moving objects,

07:25.800 --> 07:29.600
but all his presentation is in my own objects.

07:29.600 --> 07:33.440
And what we end up with is this thing.

07:33.440 --> 07:36.720
This is the smallest game console in the world.

07:36.720 --> 07:40.160
You can see it on this screen next to the other coin.

07:40.160 --> 07:43.280
And here, there is a call saying hello.

07:43.280 --> 07:47.480
It doesn't look like much, but it runs the possible.

07:47.480 --> 07:49.160
And this is what we did.

07:49.160 --> 07:52.440
And the next thing, and this was a big moment

07:52.440 --> 07:56.920
of realization for me, that if we can run the possible,

07:56.920 --> 08:00.120
in the smallest game console, in the world,

08:00.120 --> 08:02.960
we can run it anywhere.

08:02.960 --> 08:06.400
And the next thing, so I wanted to do something interesting.

08:06.400 --> 08:09.440
There is framework called Wasom4.

08:09.440 --> 08:11.360
It is fantasy game console.

08:11.360 --> 08:15.760
What is fantasy game console is?

08:15.760 --> 08:16.800
A few people.

08:16.800 --> 08:21.800
So it started with project called Pika8.

08:21.800 --> 08:25.920
A guy made this fantasy game console, that's me.

08:25.920 --> 08:29.360
Fantasy means that the game console never existed.

08:29.360 --> 08:33.200
There is just a multimeter for your computer for it.

08:33.200 --> 08:36.960
But it's kind of framework for making games,

08:36.960 --> 08:40.760
but it has limitations, specifically in post limitations,

08:40.760 --> 08:43.800
to make games feel retro.

08:43.800 --> 08:45.880
So you have only a bit of RAM.

08:45.880 --> 08:48.160
You have only a bit of colors.

08:48.160 --> 08:50.880
You have specific smoke, screen resolution,

08:50.880 --> 08:54.160
so I play Game Boy Advance, and it's very pixelated.

08:54.160 --> 08:58.400
And it caught attention of many people, many game developers.

08:58.400 --> 09:02.160
People started to make lots of fun games for it.

09:02.160 --> 09:05.760
And Wasom4 is the same thing.

09:05.760 --> 09:08.200
But you can write games for it.

09:08.200 --> 09:10.400
Again, the name programming code, which is a person who

09:10.400 --> 09:14.360
has a password, and they compare it into a password.

09:14.360 --> 09:18.120
So they provide zero and host functions for drawing,

09:18.120 --> 09:24.040
triangle, square, sprite, playing sound.

09:24.040 --> 09:25.760
And it runs in browser.

09:25.760 --> 09:27.880
So this is browser environment.

09:27.880 --> 09:32.200
And what I decided to do, I decided to take rest.

09:32.200 --> 09:34.840
So I switched from goal to rest, because I wanted

09:34.840 --> 09:37.400
zero and some reason, I pass on the interpreter.

09:37.400 --> 09:39.800
I was showed to you for rest.

09:39.800 --> 09:43.360
And because I wanted to save every byte of performance

09:43.360 --> 09:45.840
for the actual game.

09:45.840 --> 09:48.840
And what I ended up, and I got was me.

09:48.840 --> 09:52.840
Wasme is the pass on the interpreter for rest,

09:52.840 --> 09:55.600
designed for constraint environments.

09:55.600 --> 10:01.120
It is designed to run on such a very, very small.

10:01.120 --> 10:05.960
And what I learned at the top is this, this is pay batch.

10:05.960 --> 10:07.280
Pay batch from other fruits.

10:07.280 --> 10:10.720
It has some, like, 100 tits of kilobytes of RAM.

10:10.720 --> 10:12.200
Again, it's very small.

10:12.200 --> 10:17.280
At the trans, I ran out of juice, but we have a photo.

10:17.280 --> 10:19.280
It always happens with live-domas.

10:19.280 --> 10:22.840
So always have a backup.

10:22.840 --> 10:27.200
This is game written for web for vasomfor.

10:27.200 --> 10:28.800
It was never designed to run here.

10:28.800 --> 10:31.920
But since this is the pass, and since I

10:31.920 --> 10:34.360
control the whole environment, I can run it here.

10:34.360 --> 10:37.160
It runs just perfectly.

10:37.160 --> 10:42.600
And the next thing I say, OK, if we take our own hardware,

10:42.600 --> 10:47.960
what if we make hardware designed for a new pass?

10:47.960 --> 10:54.720
What if I not try to copy, like, vasomfor tries to mimic the API?

10:54.720 --> 11:01.280
The API of actual game consoles of all-teral,

11:01.280 --> 11:02.840
like, game-buy advance.

11:02.840 --> 11:06.120
There is lots of direct memory manipulation stuff.

11:06.120 --> 11:09.640
What if I understand vasomfor, work,

11:09.640 --> 11:17.800
have vasomba pass on the works, make it native to a pass on the API.

11:17.800 --> 11:21.240
It's designed to mimic the pass on the games.

11:21.240 --> 11:24.480
So for the chip, for the hardware, we took vis-Bit's full-fink.

11:24.480 --> 11:27.200
It's pizzer's toy's free.

11:27.200 --> 11:30.160
And the cool thing about it is very small.

11:30.160 --> 11:32.080
It's actually the dev board.

11:32.080 --> 11:34.520
Zack's show-fink is this small chip.

11:34.520 --> 11:38.280
And it's very, very small, like, my thumbnail.

11:38.280 --> 11:39.440
And it's very cheap.

11:39.440 --> 11:42.800
You can buy one for four euros.

11:42.800 --> 11:46.280
And it has Wi-Fi on board.

11:46.280 --> 11:48.600
And it will get to Z.

11:48.600 --> 11:51.080
And we took it as hardware.

11:51.080 --> 11:55.120
Then you can, well, skip it.

11:55.120 --> 12:00.160
There is good ecosystem for writing applications

12:00.160 --> 12:03.440
in Rust for ESP.

12:03.440 --> 12:06.600
And we made FireFlyZero.

12:06.600 --> 12:08.360
I will show your photo.

12:08.360 --> 12:10.720
So we have two prototypes.

12:10.720 --> 12:13.200
We have stand here in the same building.

12:13.200 --> 12:15.400
Find us, we're just around the corner, right?

12:15.400 --> 12:16.880
And the first floor.

12:16.880 --> 12:21.320
And we made two prototypes here.

12:21.320 --> 12:24.640
And you see why are with people having so much fun?

12:24.640 --> 12:28.800
Because it has multi-player.

12:28.800 --> 12:33.080
And everything is fun when you do it together.

12:33.080 --> 12:34.640
And this is why we took ESP.

12:34.640 --> 12:39.640
Because ESP, 32, has Wi-Fi on board.

12:39.640 --> 12:42.200
And we just finished writing this physical product.

12:42.200 --> 12:43.000
We only have two.

12:43.000 --> 12:43.880
And there are the stand.

12:43.920 --> 12:45.920
This way, I'm just going, if I'm waiting here.

12:45.920 --> 12:50.360
So please come down to us and give it a try.

12:50.360 --> 12:54.920
And I will show you how beautiful and how easy

12:54.920 --> 12:59.320
it is to make multi-player games for FireFly.

12:59.320 --> 13:01.120
And it's actually a thing.

13:01.120 --> 13:02.120
It actually happened.

13:02.120 --> 13:02.960
We have it.

13:02.960 --> 13:03.960
It works.

13:03.960 --> 13:06.040
And we will be allowed to take starter this year.

13:06.040 --> 13:07.760
We will be mass-producing them.

13:07.760 --> 13:10.520
And of course, since I'm at first there,

13:10.520 --> 13:11.640
it's open source.

13:11.640 --> 13:13.080
Everything is open source.

13:13.080 --> 13:19.680
Software, hardware, case, developer tools, SDKs, everything.

13:19.680 --> 13:23.000
You can make your own FireFly or you can fork it

13:23.000 --> 13:24.240
and make something fun with it.

13:24.240 --> 13:26.320
We don't mind.

13:26.320 --> 13:31.320
And this is how it looks naked without case.

13:31.320 --> 13:33.080
And the cool thing.

13:33.080 --> 13:34.040
So let me show you.

13:34.040 --> 13:39.200
So we have, first of all, we have emulator.

13:39.200 --> 13:43.760
You can already run, and again, the power of the possible.

13:43.760 --> 13:45.160
How if emulator is possible?

13:45.160 --> 13:48.360
We don't emulate here, it's pure source at all here.

13:48.360 --> 13:52.160
But since it's the same interpreter for the possible here

13:52.160 --> 13:55.960
and on the device, how your application works here,

13:55.960 --> 14:00.320
it will exactly the same way it will work on the device.

14:00.320 --> 14:02.240
It's beautiful.

14:02.240 --> 14:04.680
And we have lots of games.

14:04.680 --> 14:08.120
As you can see, so this is naked.

14:08.200 --> 14:11.400
This is written in go, 300 lines of go.

14:11.400 --> 14:14.240
Again, it's very easy to write games for it.

14:14.240 --> 14:19.080
And let me launch a two-quarter so it.

14:19.080 --> 14:21.640
And I will show you something.

14:21.640 --> 14:23.760
So how to start multiplayer?

14:23.760 --> 14:27.800
And again, the same on the actual device.

14:27.800 --> 14:29.400
You press start multiplayer.

14:29.400 --> 14:30.720
They discover each other.

14:30.720 --> 14:33.840
You can feel them.

14:33.840 --> 14:36.240
And now we have two snakes.

14:36.240 --> 14:39.000
And we can have four, eight.

14:39.000 --> 14:43.320
As many as performance will be enough.

14:43.320 --> 14:47.480
And see, I move on here and it moves on the other screen as well.

14:47.480 --> 14:48.200
Beautiful.

14:48.200 --> 14:50.480
How it works?

14:50.480 --> 14:52.800
Since, again, it's very possible.

14:52.800 --> 14:54.440
We control inputs.

14:54.440 --> 14:58.000
We, if when application asks for random values,

14:58.000 --> 14:59.360
we give it to it.

14:59.360 --> 15:02.320
When it asks for buttons, we give it to it.

15:02.320 --> 15:06.760
If we take two devices and run on them,

15:06.760 --> 15:11.560
exactly the same application and exactly the same initial state.

15:11.560 --> 15:14.160
And then in both of them, we give the same inputs.

15:14.160 --> 15:17.840
So when they ask for a random input, we synchronize it

15:17.840 --> 15:19.560
and we give it to both applications.

15:19.560 --> 15:22.640
When they ask for input, we say, this is input from the device one.

15:22.640 --> 15:26.520
This is input for the device two on both of them.

15:26.520 --> 15:28.840
The transition is the same state.

15:28.840 --> 15:30.200
And this is how much player works.

15:30.200 --> 15:33.800
And this is how it's the easiest game console in the world

15:33.800 --> 15:35.640
for writing multiple player.

15:35.640 --> 15:40.760
For your application, just looks like several inputs.

15:40.760 --> 15:42.320
You don't care about latency.

15:42.320 --> 15:45.000
You don't care about synchronizing state about devices.

15:45.000 --> 15:47.480
You don't care about any of those stuff.

15:47.480 --> 15:51.480
We take care of that on the environment level.

15:51.480 --> 15:54.600
For you, just read a few buttons.

15:54.600 --> 15:58.560
And synchronize it because it's very fast.

15:58.560 --> 16:02.360
It's changing through the air.

16:02.360 --> 16:04.360
We have air in the small sphere.

16:04.360 --> 16:11.040
Inputs, it's like 16 bytes of data, nothing.

16:11.040 --> 16:14.200
And this is an example of the code for a small sphere.

16:14.200 --> 16:15.960
When I wanted to make a listening game,

16:15.960 --> 16:20.040
a small player from single player, I changed for lines of code.

16:20.040 --> 16:23.280
I say, hey, I made loop.

16:23.280 --> 16:26.440
And now I just draw first next in the loop.

16:26.440 --> 16:27.960
That's it.

16:28.880 --> 16:33.680
And let me show you how you can make your own decision.

16:33.680 --> 16:35.120
It's very, very simple.

16:35.120 --> 16:40.440
So we have two code, Firefly CLI.

16:40.440 --> 16:47.960
And it takes care of all your needs for writing your own application.

16:47.960 --> 16:49.200
Install your applications.

16:49.200 --> 16:52.600
You can install, export, build applications.

16:52.600 --> 16:54.880
And there is a comment called new.

16:54.880 --> 16:57.360
That's close with a numerator.

16:57.400 --> 17:00.320
Firefly, you say language, which you want to use.

17:00.320 --> 17:03.320
We already saw a contrast, go C, C++.

17:03.320 --> 17:06.160
We will support more, ZIG, Python,

17:06.160 --> 17:09.560
Lua, JavaScript, for all of that we have

17:09.560 --> 17:13.280
prototype, so we know that it will work.

17:13.280 --> 17:14.840
And you specify the name.

17:14.840 --> 17:17.920
It says project created.

17:17.920 --> 17:19.480
We go here.

17:19.480 --> 17:23.920
We say Firefly CLI build.

17:23.920 --> 17:25.920
I will make a new fire system.

17:25.960 --> 17:28.360
So that we have clean start.

17:28.360 --> 17:33.320
And now we do Firefly emulator.

17:33.320 --> 17:37.920
We specify the VizFire system that I just created.

17:37.920 --> 17:38.920
And we have it.

17:38.920 --> 17:40.560
This is your first application.

17:40.560 --> 17:42.280
It just draws triangle.

17:42.280 --> 17:43.440
I'll show you the source code.

17:50.680 --> 17:52.280
This is the source code.

17:52.280 --> 17:54.240
You have several callbacks.

17:54.240 --> 17:56.960
In boot, you initialize your application.

17:56.960 --> 17:58.920
In update, you update the state.

17:58.920 --> 18:00.400
In render your draw stuff.

18:00.400 --> 18:02.800
So I clear screen with the side color.

18:02.800 --> 18:05.520
And I draw a triangle.

18:05.520 --> 18:09.720
And that's how you make your own application.

18:09.720 --> 18:12.600
Few seconds, and you already have your first step.

18:12.600 --> 18:14.560
And of course, you can build on top of that.

18:14.560 --> 18:16.000
You will build on top of that.

18:16.000 --> 18:17.760
You need to build on top of that.

18:17.760 --> 18:23.360
But again, 300 lines of code and you have mouse player snake.

18:23.400 --> 18:26.440
We have an workstation framework for Python.

18:26.440 --> 18:29.800
Again, since everything is open source and since it's

18:29.800 --> 18:32.800
rust, we can embed it into Python applications.

18:32.800 --> 18:36.440
And from Python, you can say, this is my application.

18:36.440 --> 18:41.840
Start it run on update cycle, get a segment of the screen,

18:41.840 --> 18:45.680
and check that this segment matches this pattern.

18:45.680 --> 18:47.960
Let's say it.

18:47.960 --> 18:51.880
And this is, yeah, I just show it to you, right?

18:53.560 --> 18:55.340
There are some challenges.

18:55.340 --> 18:57.920
I will briefly go through, so it's hard

18:57.920 --> 19:01.420
to work with complex types.

19:01.420 --> 19:05.640
There is just interstit 2 and 64.

19:05.640 --> 19:08.800
Float 34 and 64 that's it.

19:08.800 --> 19:12.720
OK, whereas the strings were bytes, were lists,

19:12.720 --> 19:13.800
were structs.

19:13.800 --> 19:17.520
Well, you need to define how you pass it around.

19:17.520 --> 19:19.520
And we don't pass much of that around.

19:19.520 --> 19:29.520
So first of all, we designed API in a way that you don't need to pass tracks around.

19:29.520 --> 19:34.520
So we think, in advance, for instance, there is no function to read configuration file

19:34.520 --> 19:39.520
all at once from the runtime, but you can read name of application.

19:39.520 --> 19:42.520
It would just be binary string and zero.

19:42.520 --> 19:50.520
There is no observability in allocator, because allocator is part of the guest environment.

19:50.520 --> 19:53.520
It's just some code that runs here in the pass environment.

19:53.520 --> 19:55.520
We don't know how it works.

19:55.520 --> 19:58.520
We only know how many pages of memory are allocated.

19:58.520 --> 20:02.520
And again, I want to have good observability.

20:02.520 --> 20:03.520
Let me actually show it to you.

20:03.520 --> 20:06.520
So we have here application running.

20:06.520 --> 20:16.520
And what I can do is I can say Firefly, CLI, Firefly, CLI, Monitor.

20:16.520 --> 20:20.520
I promised to show your observability.

20:20.520 --> 20:28.520
And from the running emulator, it collects information about the number of instructions executed per second.

20:28.520 --> 20:33.520
In each callback, that we ever call, amount of memory allocated.

20:33.520 --> 20:42.520
If the game lacks, behind how much CPU, how many resources it has, it's the beginning of the pass assembly.

20:42.520 --> 20:45.520
But looking into memory is hard.

20:45.520 --> 20:48.520
It's hard to run enterprise languages.

20:48.520 --> 20:51.520
So what happens is we have this environment in Rust.

20:51.520 --> 20:53.520
It runs the pass assembly interpreter.

20:53.520 --> 20:58.520
In the inside of it, we run the pass assembly interpreter for Python.

20:59.520 --> 21:04.520
It runs the actual Python application.

21:04.520 --> 21:07.520
It's lots of layers, lots of glue.

21:07.520 --> 21:10.520
Again, it's a post of work and hopefully it will work.

21:10.520 --> 21:13.520
We have prototypes for it.

21:13.520 --> 21:16.520
But it can get pretty messy.

21:16.520 --> 21:19.520
So you need to be very mindful about performance here.

21:19.520 --> 21:21.520
Multiplayer was a challenge.

21:21.520 --> 21:24.520
But we are managing pretty well.

21:25.520 --> 21:28.520
And working with limited resources is hard.

21:28.520 --> 21:30.520
So we have these pitchers to freeze.

21:30.520 --> 21:34.520
There is just 400 kilobytes of RAM, actual RAM.

21:34.520 --> 21:42.520
We have 8 megabytes of the first RAM, which is slower, but we provide the application if it really needs it.

21:42.520 --> 21:50.520
But working with the resources is required as to find a healthy, draw stuff on the screen.

21:50.520 --> 21:51.520
OK, let's see.

21:51.520 --> 21:54.520
Can we avoid allocations here and there?

21:54.520 --> 21:58.520
It's all about saving every small resource of it.

21:58.520 --> 22:05.520
And being myself a Python developer for 10 years, I didn't get used to think about these things.

22:05.520 --> 22:07.520
But yeah, conclusions.

22:07.520 --> 22:09.520
Awesome is great.

22:09.520 --> 22:14.520
I didn't talk about Rust, but I have live-hate relations with it.

22:14.520 --> 22:19.520
I cannot imagine myself writing with all complex systems in traffic like this.

22:19.520 --> 22:23.520
In traffic like C, with many other locations and all the stuff.

22:23.520 --> 22:25.520
It will be crazy.

22:25.520 --> 22:32.520
But every day when I write something in Rust, I fight with Borough Chaker and I have the idea how to make it work.

22:32.520 --> 22:34.520
But hey, now it works.

22:34.520 --> 22:36.520
And yeah, I'm glad that it's playing.

22:36.520 --> 22:39.520
And so we have booth downstairs.

22:39.520 --> 22:40.520
We have website.

22:40.520 --> 22:42.520
This year we will have Kickstarter.

22:42.520 --> 22:44.520
We have all socials.

22:44.520 --> 22:49.520
And I'm very happy to talk to all of you about WebAssembly.

22:49.520 --> 22:54.520
So you can ask questions now and you can just come to me and ask more questions later.

22:54.520 --> 22:55.520
Thank you.

22:55.520 --> 23:05.520
Let's run the minutes of questions.

23:06.520 --> 23:11.520
So I can imagine how you do when reading on the guest visit the two.

23:11.520 --> 23:13.520
Let's talk about this before.

23:13.520 --> 23:15.520
How you do when reading on the computer?

23:15.520 --> 23:16.520
Rendering.

23:16.520 --> 23:17.520
Yeah.

23:17.520 --> 23:18.520
Like I'm using SDL also.

23:18.520 --> 23:20.520
So the question, how we render?

23:20.520 --> 23:24.520
There is library for WebAssembly called Embedded Graphics.

23:24.520 --> 23:26.520
It's great.

23:26.520 --> 23:31.520
It's designed to save memory for you.

23:31.520 --> 23:33.520
And there are a few tricks we do.

23:33.520 --> 23:35.520
First of all, the actual game.

23:35.520 --> 23:38.520
It can use on the same screen at the same time

23:38.520 --> 23:40.520
on the 16 bytes of RAM.

23:40.520 --> 23:43.520
So each pixel is 4 bytes.

23:43.520 --> 23:44.520
16 colors.

23:44.520 --> 23:46.520
Sorry, it can use on the 16 colors.

23:46.520 --> 23:48.520
Each pixel is 4 bytes.

23:48.520 --> 23:53.520
And the screen itself has the same size as Game Boy Advance.

23:53.520 --> 23:55.520
So it's very pixel.

23:55.520 --> 24:00.520
So the whole frame buffer that we store is 32 kilobytes of 32 kilobytes.

24:00.520 --> 24:03.520
So it's 16 color of 16 bytes.

24:03.520 --> 24:05.520
16 colors and 4 bits.

24:05.520 --> 24:06.520
Yes.

24:06.520 --> 24:11.520
But the game can change it between different screens.

24:11.520 --> 24:14.520
Game can change it as we render.

24:14.520 --> 24:16.520
Why do you buy it?

24:16.520 --> 24:22.520
And then what we also do is we render it on this.

24:22.520 --> 24:24.520
We have very cool screen.

24:24.520 --> 24:29.520
We have 16 wires, bars and there.

24:29.520 --> 24:31.520
This is why we have to use pixels.

24:31.520 --> 24:34.520
We just ran out of pins on the first one.

24:34.520 --> 24:39.520
And all the 16 bits they read from DMA,

24:39.520 --> 24:42.520
they image that we want to render.

24:42.520 --> 24:45.520
And then it renders it.

24:45.520 --> 24:46.520
Yes.

24:46.520 --> 24:48.520
It's parallel of 16 bits.

24:48.520 --> 24:51.520
I ate stuff.

24:51.520 --> 24:55.520
More questions.

24:55.520 --> 24:56.520
Yes.

24:56.520 --> 25:00.520
Can you say something more about how you do the synchronization of this report when

25:00.520 --> 25:01.520
you multiply it?

25:01.520 --> 25:02.520
Yes.

25:02.520 --> 25:04.520
So how synchronization of input works.

