GLM 5.3 Flash Is HERE – Is THIS Better Than the FULL GLM 5.3?

0:00 Let's see how ye eatable this city is. Yep. Oh, look at it's spraying water. Good, good attention to detail. GLM 5.3 Flash has been released and revealed to be the mysterious ox alpha model that

0:12 was on Open Router for free for the past week or so. This is something that I think got one of the largest amounts of interest for a stealth model that I've seen before. And now that we see that it

0:22 is existing in the world, it's open weights, it's not super large, and it is pretty darn cheap, I think the excitement was warranted. So before we get into it, do feel free to subscribe

0:31 so we can hit the 75K figure and then onwards to the 100K plaque. In additionally to that, let's take a look at some of the interesting things about this model and then we'll jump into some

0:40 fun testing which is going to be slightly different from some of our normal tests. I don't want there to be a lot of fatigue and like the same exact test. So GLM 5.3 flash is a 320 billion

0:51 parameter mixture of experts model with 18 billion active. And they mention here that it is basically within striking distance of Claude Opus 4.8 which is still a very highly regarded model as it

1:02 seems Opus 5 has a lot of love it or hate it experience from the community. So, additionally to this and something that I think is worthy of specific mention is the fact that throughout this

1:13 free period on open router when it was stealth, the amount of free tokens that folks had allocated, whether it be open code saying that I think they could handle 100 trillion tokens per day and

1:24 then essentially it was like almost unlimited. This was served entirely on domestic Chinese AI chips. And I think that is something to really kind of mention because currently Nvidia is like

1:36 the de facto provider for a lot of AI inference. This is basically saying and showcasing, hey, we just had this model that was incredibly incredibly popular and it was all served on our own

1:47 domestic chips, our own serving stack, and something that is definitely a consideration when I don't know, just it's interesting to see the evolution of other ways of doing things that are born

2:00 out of competition. And it's definitely worthy of specifically mentioning that. And I would imagine almost more importantly than this model is the validation of that domestic serving

2:11 right there. So just something I wanted to specifically take note of a couple of things in terms of like tech specs of this model. They mentioned that it has several architectural improvements. One

2:21 of them being a hybrid architecture combining different types of attention. So essentially it can serve long context for cheaper but also maintain quality in longer generations. Something else is

2:31 they have adopted MHC which is something that was proposed by DeepSeek in December of 2025 just in a way to as it says improve scaling efficiency. There is a technical paper for that that you

2:43 can find online if you just search MHC DeepS. It should pop up pretty high in these search results. Now in terms of cost this model is incredibly cheap. Now we can see here on Open Router it is

2:54 currently listed at 50% off. So let's assume that promotion has ended. That would essentially make this 15 cents per million in and 50 cents per million out. If this is truly competitive with

3:05 something like Deep Seek Flash Vision Experimental, this is quite a bit cheaper than that model. So, it's interesting to see competition in that size range as well. Additionally to

3:14 that, we have some benchmark information right here. But being that this was stealth as ox alpha, we are somewhat familiar with at least some of its capabilities, scoring pretty decently on

3:23 deep s. When I started filming this, this was not currently available on hugging face. If you clicked the link, it was just 404ing. That has actually changed. So, if we click that right

3:32 here, this model is truly open weights right now. I don't specifically know how much system memory you're going to need to run this. I don't believe we have any specific like VRAM figure and they'll

3:43 inevitably have some like unsloth dynamic one-bit quant that will probably allow this to run on something that is not outrageous in the scheme of like a local AI system. So, for how we're going

3:54 to be testing this today, I do have like the mid tier of the GLM coding plan. It's been hit or miss over the course of the few months I've had it. Sometimes it works great. Sometimes the models can be

4:04 a bit frustrating. And that is something also folks were noticing. When this was free as ox alpha, it would sometimes stop or hit errors. I wouldn't necessarily judge this based off of that

4:15 performance being that that thing was getting hammered pretty darn hard. We can see even in some of the graphs here in terms of how much use it had over the week that it was free on open router.

4:24 But I currently am just going to be testing this and for the duration of the video using Zcode which is their native coding application. It is very very similar to codeex which I do like as I

4:34 like codecs and this works very nicely on Ubuntu. I also want to mention that all cache for any previous runs using ZAI models or really anything has been removed. So there will be no

4:45 contamination from previous model results. And because this model is something that's going to be pretty heavily compared to the Deepseek Flash Light Vision Experimental, I am going to

4:55 give this the browser OS test that we gave to that model as well where it's the traditional one. However, included is this reference photo and it is told that we would like a pixel perfect

5:04 replication of this as a browser OS and then including the GTA clone and things like this. This is of course a Mac OS 9 screenshot. All right. So, after an hour and 7 minutes, which okay, it was on

5:16 Mac's thinking, but not necessarily flash speed, it has completed the browser OS. Let's take a look at it. I have not seen this yet. So, here's our Mac OS 9 inspired browser OS. Okay,

5:27 interesting. Good. Something I wanted to know is for the procedural wallpaper movement, would it still try to mirror what was shown in the image as like a reference? And it does. Okay, I will say

5:38 the menu bars here are pretty good. The apple that was also shown in the image is perhaps a bit mangled, but we have chronos snap, which is going to be the special feature. Something I noticed

5:49 about this specific test is that it's got a lot of like visual stuff. Okay, the hover effects here are more or less correct. These are black and that is kind of how it would look if

6:00 actually using this Mac OS system. We have a bit of about Mac OS 9. Me close that. And I'm also going to turn the sound on as there is a speaker icon here. So there must be sound

6:12 effects when we're actually clicking on things. We have a terminal or a text app editor. There are little button presses. Oh, okay. You have to press it twice. That works. But it's got cute little

6:23 like beeps, I guess could be said now. Okay. It did actually make all of these selectable folders, but most of them, if not all, are probably just going to be empty. That was something I wanted to

6:34 see as well because it just shows like attention to detail and whether or not it actually makes these more interactive. Permanently delete the items in the trash and it had a sound

6:43 effect. That's good. We do have the correct time in our local in the top right. And I would imagine my home will probably have our applications in it. All right. Now is where the fun starts.

6:53 I guess we'll just look through them one by one. This mail client does look very very period correct and I like seeing that. John Apples Seed. Okay. wallpaper lab department and like meta references

7:04 to this rogue city.gov. It has a reference here to the GTA game. I have no idea what vehicle you're talking about. This is actually kind of clever. Dear citizen, we keep getting reports

7:14 about a light blue compact doing donuts on Avenue approximately 900 mph in reverse. Drive friendly. And then we have a response to that that it's included as

7:23 well. I have no idea what vehicle car was stolen anyway. Technically the city's fault for leaving keys in it. regards a concerned citizen. Clever. I like seeing a lot of these models like

7:33 to put little like bits of creative writing in the email results. I believe we looked at my pad, which was the writing app. And with that, let's take a look at our GTA clone.

7:44 Nice. Oh, all right. Particle effects. It's inverted a bit. This is it's troubled, but it's the movement here is is not right.

8:06 It's it's difficult to move around. Is that a vehicle? I think it's like a statue or a fountain, but you never know. Okay, I don't see any vehicles, unfortunately. All

8:15 right, let's see if we can. Okay, at least there's some interest. Okay, it's it could benefit from some improvement,

8:35 but it spent 67 minutes on this. So, and it was looking at these and just doing some Oh, okay. That's wonderful. That's great. fly again. This is actually uh impossible to play. All right. Again, I

8:50 think both of the games have perhaps some of the same issues. Now, this is actually kind of cool. This wallpaper lab speed, we have hue. It doesn't actually reflect here, but it does show

9:00 on the preview that that's either there or not. So, that's cool. We have some other options here as well. Sunset Ridge, Vapor Grid,

9:11 Deep Space. Good. And the movement does work. That one's actually pretty nice. Terminal Rain. Oh, a bit chaotic. Cool. And the color change does actually

9:25 work. The hue tint to it. Nice. So, the final thing here, I believe, is the chronos snap. I do like how it properly kept the style of like OS9 Windows more or less. Press this or use take snapshot

9:41 now. Windows may be snapshotted mid task. Games are stored closed. Okay, cool. We have a snapshot. So, let's close these all except this. We'll do restore last session. Rewind.

9:56 Oh, I thought it would have opened the Is there a right click? No, there isn't. That's more forgivable in this. Secrets.txt.

10:04 Type rose bud anywhere on the desktop. There's no sled loaded yet. Okay. It made a Citizen Cane reference. I don't know why. It mentioned something about the GTA game when I typed Rose Bud. The

10:19 models seem to like to be a little more clever when given this specific prompt. Interesting. All right, let's try one more time. Rose Bud

10:30 open Rogue City. I did. All right. Well, this was interesting. Not bad at all. I think the Deepseek result may have beat this out, but it's definitely up for debate. So, next up, we're going to be

10:41 doing something that was not able to be done when testing Ox Alpha. This is the wrestling game, the mid80s 3D wrestling game. The prompt is right here. It's basically just give us a cool fun 3D

10:52 wrestling game that is styled like it was in the mid80s. I was unfortunately not able to get a conclusion for the results for this when using this as ox alpha. So I'm very eager to see what it

11:02 would have done here. Again, these are some results where we have direct comparisons to the Deepseek V4 Flash Vision model and its results which did perform very well across these tests.

11:11 All right, so it is the next day and the reason for delaying this video a bit is because I know folks sometimes get a little fatigued with doing the same exact tests each time. So I did end up

11:21 running a few more that are a bit more complex. But with that, we did leave off in the wrestling game. We do see a bit of a spoiler for it right here. However, I have not seen any of this result

11:30 except for this spoiler. And this result took an hour and 25 minutes just for some reference as to how long this took. Okay, we do have sound. So, I will turn the speaker up, but it should be playing

11:41 already. So, it's possible I have to click into it to enable sound. Are there two instances of this playing? No. Okay. So, the music is just really odd with that. Uh maybe we'll Oh, okay.

12:01 Okay. We have Rex Tracker, El Tormenta, Iron Ivan, or Rockin Randy Riot. It's interesting. Different models have like very similar choices for which wrestlers they choose. Okay.

12:19 Okay. Okay. It's doing like an introduction. Let's get it on. Okay, maybe an interesting thing. Look at the ropes in the ring now. Okay.

12:35 This game is difficult to play. Mash space to kick out. Okay, let's let me try this again. Liberty Slam. All right. Still, this is pretty good for a flash model. I believe

13:01 this is a better result than the full-on GLM53 produced, which is interesting. These games are still not super playable. Oh no.

13:17 All right, someone's picked up a chair. And unfortunately, it's still they're sinking under the ring, which happened as well with the Quen Next model. All

13:36 right, I think I've seen enough of this, but I'll say this is actually pretty well done, especially considering that this is a Flash variant. So, our next test is a C++ one. However, it's not

13:46 something we've ever done before. And I've started it out just by asking, "Can you search the web?" The model said yes. And I said, "I want you to find an early game demo called Terrup 2. I would like

13:56 you to use the reference photos as well as the concept and create a game just like it using C++ with no RALI." It did find the correct information about this game, also known as deformers from 1996,

14:08 is a Hungarian Freeware MS DOS off-road driving demo written in x86 assembly rendering to VGA. It features a software rendered texture height map terrain, buggies and bronos, spring mass physics

14:20 where cars visibly crumble in crashes, hence deformers, multiple surface types affecting handling, free roaming, etc. We do have a reference photo of that game. So this is a reference photo of

14:30 the actual game that I've told it I would like a replication of, not what it made itself. So we can see for 1996, this was pretty impressive, especially given like the soft body physics that it

14:40 included. So it culminated in building a 2700 line C++ script, a replication of this, which I do believe it has called retro race. Good. A playable recreation of Terab 2 in 53 and 1/2 minutes. So

14:53 let's take a peek at this. All right, we do have sound. I'd say this is actually not bad. Okay, good. That's something we want to make sure and test is is there the element of

15:07 like emulated suspension in this? Now, this is not as close to the vehicle models at least. But look at this. There's actually some gameplay logic where we do need to get to these

15:17 checkpoints. And when we go through them, it does actually give us like checkpoint too. And we have a mini map. I'll say this did a faithful job of getting the overall vibe and feel of

15:28 this result, even if it's not directly the same in terms of aesthetics. I think the Source one had some cooler looking car models, but we do have what else? So, we should also have some different

15:41 Oh, so here's the Bronco. Okay, so I did just mess up by unfortunately resetting our progress, but yeah. So, air. What happens if we go in the water? And the original said the terrain

15:54 affects like the speed and things. So good. That's exactly what we wanted to see. So going in the water kind of stalls our progress. And look at the way it's drawn it. This is actually kind of

16:02 I'm impressed with this especially because we gave it a pretty static example of what we wanted it to replicate for us. Says F9 for a different camera. Oh, look at that.

16:13 Okay. So the So the arrow keys and WD controls these. So, I'm controlling both right now, but using separate keys. The blue car is WD. The buggy is red. I mean, the buggy's

16:29 arrows. Still, this was actually I would say this is pretty well done. If we go back, we have some other things. P is for pause. F10 is a map toggle. Okay, so

16:42 that just hides or shows the mini map. There's another one that I can't quite make out right here. F1 or F5. Let's try F1. And then F5 is just so these are different camera views. Overall, I'm

16:54 actually I'm satisfied with this and it did a nice job on the mini map as well. So, backed by popular demand because some folks had mentioned missing this in our Quen result is the C++

17:05 self-contained skateboard game. This is the one where the map needs to be an early 2000's New York City block. We can see this was a longer generation working for 2 hours and 17 minutes. It's given

17:15 us just what's in the game. And the culmination of this was about 2400 lines. Oh, no. It's saying 4,000 lines, single file C++, not using Ray as well. I'm pretty sure that is included. Yes.

17:26 So, let's take a peek at what this made. And I'm expecting something pretty decent. So, here's the New York City skate map. Okay. It's

17:36 troubled. It's got some troubled issues. I'll say the NPCs there walking are not too bad. Let's see if any of the tricks work. Okay, they do. And the board does move independently of

17:50 the player, which is nice to which is nice to see. Now, something I'm going to notice here is that it's not really clearcut that we can move back and forth. It does have a mini map, which is

18:00 interesting as well. It seems like the textures that are applied to this taxi are either Z fighting and there's like actually I think there's a bunch of car models stacked and spawned in right

18:08 there. So, that is some issue. And then we can see the rendering is just not all there. Sometimes we can see further down the block. I think this is a result that could be made competent, but I'm not as

18:19 impressed with this as I had hoped to be to be totally honest with you. I do believe now because we didn't do this specific test with the Quenext model, I can't say definitively, but based off of

18:30 the C++ result that model had made, I would assess that would probably have outperformed this on this specific task. So make of that what you will and it's somewhat that's just like not right. But

18:44 other than that it's okay. Now this next test was intended to be something that is pretty darn difficult and it's going to take a little bit of prior knowledge just to get what exactly was supposed to

18:55 happen here. So initially I had wanted this to take this board right here which is a Ragsta Pi 3W. It's like a Raspberry Pi clone and it has some decent performance and I wanted it to optimize

19:07 an AI model on this without web searching to see how much it could speed it up and just optimize this in running an AI model. I couldn't get this board working and believe me I tried. Fable

19:17 also was having trouble with it. So I canned that idea and instead I grabbed this which is a USB Google Coral AI accelerator. I do believe this is a few years old at this point. However, the

19:28 task for this model was to using this AI accelerator and when given a simple motorcycle driving game that I had Fable make to train a tiny little neural net to be able to drive the motorcycle

19:41 through traffic without crashing. Now, this is something that truthfully does not require an external little USB AI accelerator like this. It's more than small enough to run on this laptop,

19:51 which is even too much power for a tiny little thing like this. However, the reason for adding the coral was just to kind of implement a more difficult and constrained way of getting this done.

20:01 Now, unfortunately, we see that the coral itself apparently was not working for some reason. I have not really tried that device on this computer before, so I can't definitively confirm or deny

20:11 that there's some hangup that either this flash model missed itself or whether or not the Coral was just problematic. However, it did actually figure out a way to look at the game,

20:21 watch it run, cycle through, and then autonomously play it, take frames, create this little tiny neural net model to actually know when to move side to side so the motorcycle does not collide

20:32 with cars. Now, the culmination of this right here is something this run.sh where it will actually open the game and using this tiny little model that it trained, it will autonomously drive the

20:42 motorcycle around and try not to crash. So, first off, let's just take a look at the actual source of the game that this is going to be trained on to play. Now, this was not made by the Flash model.

20:52 This was made by Fable. So, essentially, it's supposed to have trained a model just so this motorcycle can drive around here and weave through traffic without crashing. We can see this result by

21:02 itself is pretty darn impressive. But again, this was the job of Fable that created this and not GLM Flash. Although, that model in our OX alpha stealth testing did actually make a

21:11 pretty competent motorcycle game. So the whole point is to be able to drive like this autonomously without that happening. So with that, let's close this now and then go into the specific

21:20 directory for this. And it said that to see it drive, we are just going to type. So I'm doing nothing right here. And we're going to actually see that this is a tiny little trained model that this

21:30 has created that is actually controlling the movements of this motorcycle designed to avoid obstacles. And the model did this entirely by itself. I gave it the script and a prompt that

21:41 we'll take a look at more in depth once we have a better like understanding of this. So, okay, like a car just swerved in front of us and that became an issue. And again, this is like a tiny little

21:53 like I wouldn't expect super performance from this, but the fact is it's something really different that the model had to show some capability in a few different areas. See, so now it's

22:02 like trying to at least respond to the fact that it sees a car in traffic in front of us and then try not to hit it, which it did seem to fail at doing. And now we're having a bit of issues here.

22:12 Although I suppose that would be like a it's like a hack to make sure that it doesn't collide with anything because it's kind of just now riding the center line where there would be no vehicles.

22:22 So I think a good way to go about this is basically reading this plain English version of what exactly this agent did. So, because this game is an infinite runner and it never actually ends, the

22:32 agent invented its own scorecard first. Four fixed random seeds and 45 seconds of sim time each measuring how many collisions per kilometer, the average speed, and then the lane fraction. So,

22:43 how often the bike was actually in bounds of a lane and not just on the shoulder as we did see it riding in one of the examples. Additionally to that, it made the game deterministic just by

22:53 having seated random numbers and timed key presses to rendered frames. So the same policy on the same seed replays almost exactly. That's what let it compare models fairly instead of against

23:04 noise. Then we have the reference models. So random keys as we saw right here had a higher value for how many times you crash into a car per kilometer. And then we have our inlane

23:13 percentages and the average speed at which these runs occurred. Just holding W had higher hits, but we did have a higher average speed. and we stayed in the lane more often because when you

23:24 spawn in and just hold W, you're likely going to be in a lane anyway and not off to the side. The scripted expert was the one that could basically just read the car positions from the actual game. So

23:33 naturally, it had no issues at all and it was essentially a perfect run. And then the best neural net that this produced had a hits per kilometer value of 0.48, an average speed of 150, and

23:45 then 63% in lane. So this value, the average speed was good. the average hits had gone down significantly over just random which is essentially what we wanted to see in this creating a little

23:55 model to make this better. We have our randomized baseline here non-scientifically and it definitely outperformed that by a large margin although the percentage that it stayed

24:05 in lane was not necessarily the best. Now in terms of how it trained the network we have this right here behavioral cloning. So it would drive with the expert, record around 12,000

24:14 pairs of 160x40 pixel grayscale screenshots, which keys the expert pressed and then train a 41k parameter CNN to copy that. All nine models are variations of that one idea. Training

24:25 data is the 170 megabytes in data. Then we have nine different versions of models and these are actually visible in the folder right here. So if we go into models right here, we have all of these

24:34 specific ones. And if we go in some of these, we actually see like these are specific things you may be familiar with if you've played with tiny little models like this on edge devices or something

24:43 of the sort. So, it's really kind of interesting how it went about doing all of this. And it did also, as part of the prompt, it was told to essentially give us then a self-contained HTML file with

24:53 a report of these like pieces of information. Okay, cool. It stylized this in the same way as the game. So, this is kind of what we were just looking at right there where we were

25:02 reading through in plain English. We have our architecture. We have the loop budget and these are just giving us more bits of information. Things like how much lag is there between like pressing

25:11 the key and then like making an effect. It has to measure that as well, especially if it was going to use the coral which would introduce some level of latency being that it would be

25:21 processed on this and then have to traverse through USB to then make a key press and things of that sort. Now, additionally, something to talk about is we do have mentions of quantization kind

25:31 of making things become problematic. So let's take a look at what exactly happened with that right here. So we can see here's what the model did. Standard post-training quantization take the

25:39 train float model feed it 800 real frames so the converter can learn the range of every activation and convert everything to 8bit integers which would be required for the Google coral. It

25:49 then compiled that and the coral compiler mapped all 14 operations to the TPU which is the tensor processing unit inside this little coral with no CPU fallback. So the deployment side was

26:00 right and that's cool to see. So, here's what broke. And essentially, throttle and braking survived. But it's actually kind of interesting to see what happened. Steering collapsed from 74 to

26:09 47% with three steering choices. That's barely better than guessing. On the road, that shows up as the INT8 bike swerving onto the shoulder and staying there at 184 km. The better collision

26:20 number is fake because, as we saw when we first ran this, riding on the shoulder is like an infinite cheat for this. So, in some ways, it's actually kind of interesting, but there are no

26:30 cars on the shoulder. or the agent said so explicitly. Here's steering like why did steering die? Essentially TLDDR is mentioned right here. The difference between hold and nudge left is a few

26:40 pixels of lane marker position in a 160x40 pixel image. Brake and throttle or coarse decisions. Is there a big dark blob ahead or no? An 8bit precision is plenty for that. Steering relies on

26:51 small activation differences that 8bit rounding flattens. That's the typical pattern for tiny nets on tiny inputs. There's no capacity to spare. So every bit of precision was doing work. So

27:02 basically there wasn't enough fine grain detail that was preserved to determine the proper like left right steering I guess could be said and then we have a bit of information here on how it tried

27:12 to fix it and then a summary just of like what exactly went wrong. So it's very interesting to see this stuff and I know this is again a little outside the scope but there's a whole bunch of like

27:22 cool information and experiments that can be done with things like these tiny little models on relatively cheap devices like this. definitely provide a fantastic learning opportunity for like

27:32 some of the lower level concepts of things like in these gigantic AI models that we use all the time. So, it's pretty cool to see. And again, this did a pretty strong job, I would say, for a

27:42 flash model in something that's not like, oh, I'm going to go on GitHub and figure out how to map a little neural net to play this motorcycle game. So, it went about approaching this even from

27:52 the ground up just doing this. And I find this is pretty darn cool and perhaps something we'll keep in the repertoire of more difficult tests. So we also did the Street Yeet game.

28:02 However, this had to make the assets for this from within Blender and then build the game itself in GDAU. We can see it took around 52 minutes which really is not bad. 51 minutes I should round down

28:12 17 different models. The Yeet, we have the Punch Windup and Strike Sound and then City of Life. This is not the one that has the cinematic cutscene in the beginning of it. And I have not at all

28:21 seen this, so I'm pretty darn exciting. Excited. Open the folder and press F5 or run out. SH. So, here is our street eat game. Okay, we have music. We've got pedestrians. Oh, the arms seem like

28:34 they're somewhat detached. All right, let's just There's a police vehicle. Hey, it made these models as well and did not do a bad job. There are mesh colliders.

28:46 That's good. I like this. It's pretty like pretty good actually. Can we eat this fire hydrant? Which I do have to say that's a pretty good model of a fire hydrant. Let's see how ye

28:59 eatable this city is. Yep. Oh, look at it's spraying water. Good. Good attention to detail. All right. Sorry. I just got like excited. Look at this city. Like how much there's

29:11 drawn in the distance there. Oh. All right. We got to find some people. All right. Yeah, there's like a green annory space as I call them. No, I'm kidding.

29:26 This This is a very very very good result. I am quite quite pleased with what I'm seeing right here. Gone. And then they do run away from us. Insane ye.

29:40 Oh, we're getting combos, too. Can we double ye? Oh, yeah, we can. That's messed up. Oh, that bar that was there is like a combo timer. So, if we don't have

29:52 another yeet by the time that color runs out there in that bar, then it like the combo ends. This is like, if I were to make a complaint, okay, it'd be cool if the cars were moving and

30:05 not static, but like honestly, it's not really a big deal. It placed them nicely as if they would have been moving. There's good feel to these. Like the mass of these cars just Oh, a double

30:18 whoosh. All right, one more. Quick, quick. Oh, our combo ran out. Can we eat the street light? A All right. If anyone's interested in this, you'll be able to find it on Steam

30:44 for $1.99. No, I'm kidding. I don't I don't actually I don't do that and tell people that I've done it. That was awesome. That was very very well done. It was just like it was

30:57 competent, I could say. So, overall, that is going to conclude our first look and test of the newly releasleased GLM53 flash model. Now, for this test, I have been using it through the mid tier of

31:09 the Zcode subscription. And from our usage right here, we can see that overall every single test we ran today culminated in 23% of our weekly usage limit getting used up. So, we have 77%

31:21 of the weekly usage limit. I think it's subjective to judge whether that's good or bad, but I can say in specific the test where it had to train the model for the Google Coral, that took I believe

31:31 over four hours that it was working for. So, it did do a bit of work. Now, I think we should just do like a brief results overview as at least with this browser OS. I kind of haven't seen this

31:42 since yesterday. Oh, it's already open here. Good. I think because the Quen Next model also was given basically the identical test, it's harder to judge this one. The Quen model basically did a

31:52 pixel perfect replication of this. This didn't, however, this had some better elements such as the GTA game being better, and it was still overall a very well done result, especially the way the

32:01 hover effects look here and just some of the other things like including all of these photos and a nice replication, but with movement of the background scene in that. Next up, we had our Super Slam 86

32:13 wrestling game. Now, this is one that we can't compare to the Quen Next result because this just used 3JS for it instead of using GDAU and Blender. Though, I have to say I almost think

32:23 that this is a better result than what the full-size GLM 5.3 did. Oh, look at that. Like, don't quote me on this 100%, but this is actually quite impressive. I've only run this test a few times in

32:35 the history of the tests we've done on this channel, but I'll say this is quite well done. It's clean. It's got some nice bounce effects to the actual ring. There's some good effects and movements

32:45 and the tricks and everything like that. It's nicely done. The scenery is good. the environment fits and it's it's a well done result. Iron curtain trouble.

32:57 See, like that's pretty good. So, I was impressed with this. Then we had our C++ game where it needed to create a replica of the game that is shown right here in this reference photo. Okay, not that

33:09 one. In this reference photo right here. So, I think it did a pretty nice job of this. One thing I'd say where I knock it is it didn't really properly recreate these vehicles in the same style. These

33:19 vehicle models are better than what we received from our GLM model. This second reference photo is of the game that spawned from this one called insane but with a one in the title. So, one insane.

33:29 And we can probably ignore that. It had some nice elements to it here though. The mini map was well done and the way that the terrain actually affected the vehicle model. So, when we went into the

33:38 water, it bogged down. There's some bounce to the suspension and some of that soft body physics style. But the really cool thing was the split screen that it implemented here. So, we can

33:47 drive both of these vehicles from either WD for the bottom one or the up, down, left, right arrow keys for the top one. And this was a pretty nice bit to include. Both of them do have mini maps

33:58 and things like this. I like that it did this and it just gives us a pretty cool visual if nothing more. It did definitely keep the style of this game similar to the reference and there's not

34:07 a bunch of information out there for that reference. So, it was pretty darn cool to see what it did. Then, we had our skate game. Now, unfortunately, this just was not it. The bail effect is one

34:18 kind of disturbing, but two also kind of funny. And there are elements here that look decent, like the pedestrian, some angle of the tree, the street light. It has a pretty darn populated mini map

34:28 here as well. But unfortunately, there's just a lot of visual artifacting and glitching. And this is something that I think the I will say comparatively to its larger sibling of the full-size

34:41 GLM53, I think this model is actually pretty darn good. And that can be judged based off this result in specific, this is not as good as the big sibling of this model. However, considering this is

34:52 much smaller, it's still fairly decent, I would say. Then we had our Google Coral model and we kind of spent a bit of time going over how exactly it did this. So I won't say too much more about

35:02 it, but I think it's pretty interesting to see how this model performed. When given a task that didn't really have concrete steps to achieve the goal, it was basically just like here's a game.

35:11 Train a tiny little neural network that will actually play the game without the motorcycle crashing into cars. Like good luck, go ahead. And it did a good enough job. We actually saw some improvement in

35:20 the models and we saw the way that it went about training them. Unfortunately, it didn't successfully get it deployed to the coral TPU over USB. However, we saw in our overview that the actual

35:30 model was mapping to the tensor chip in this. So, it did do some level of competence in terms of getting this all done. And it gave us a really nice overall report of what it did here as

35:40 well. And this worked for over 4 hours in doing this task. A bit over 4 hours, I believe. So, a longer drawn out task that was definitely more technically challenging. Then finally, we had our

35:50 Street Eat game where it did use GDAU and Blender for the assets and for the game. This was exceptionally well done. The music fit this well. The aesthetics are nice looking. Just the overall

36:02 gameplay here. You can get a vibe for it. The feel of the vehicles when you actually hit them, they feel good. It's like they have the correct amount of mass that you would expect they would in

36:10 this game. And this one overall, this was exceptionally well done. I have not really done this test very often in which they must use GDO and Blender for this game, but I think as we do this

36:20 specific test more and more, we'll see this definitely holds its own over time as we see other bigger models perform this as well. So, that is pro I'm like not even going to

36:31 be able to post this video. I'm going to be stuck here playing this game. Oh, W. That is probably going to conclude our first look and test of GLM 5.3 Flash, which was also known in stealth as ox

36:42 alpha. So, overall, if you have any questions, please feel free to leave them in the comments. And thanks for watching. One more yeet. Yeah, this is this is quite well