Unity 3D Project Tiny Version 3 with WebAssembly Support🙌🏿

– This is really exciting. The brand new Project Tiny Version 3.0 has finally arrived, and I’m
so excited to share with you all the new features, and
the new roadmap ahead. (easygoing digital music) Let’s talk about it. Project Tiny has now been
redone for the third time, which is great. The first time, Version
1.0 was done in Typescript. That was really more of a proof of concept to see if it’s possible
to take Project Tiny and bring it into Unity world, and use something that is similar to C#, which is Typescript, which is also made and
pushed by Microsoft, and see if that will work
in building web tools, and it did, it worked, just
it was a different workflow and a new language, which
really isn’t Unity’s thing. C# is Unity’s main language,
so Version 2.0 came out, and that brought in C#, and that brought in a
complete version of DOTS, because the Typescript version
had its own version of DOTS, once again, it was more of a port, and more of a minimum viable
product to see if it will work. Version 2.0 fully supported C#, and added support for the DOTS framework. The difference with Version 2.0 was Version 2.0 actually supported DOTS, but in a weird new Unity editor workflow, so you actually had to switch editors, which was really weird, jarring, and sometimes things didn’t work when you were switching the editors. When I say switching the editors, we’re still using the Unity editor, but it would just snap,
and it would reload itself, and it was just a new experience, and it just really wasn’t comfortable for Unity developers in
general, including myself. One of the main features
of both Version 1.0 and 2.0 were 2D support. Now, 3D support was lacking, however, it was something that
was always thought to be coming soon in the roadmap. Now, we come to Version 3.0, which is now starting with 3D support, and now 2D support is
gonna be coming later on. One of the biggest, biggest
changes in Version 3.0 now is full support for the DOTS framework in the current Unity editor. This is major, this means
everything that we’ve worked on in the new DOTS workflow,
including creating game objects and having the game objects
and any conversion system is all baked in. Also, using fully DOTS-oriented Stack, the Data-Oriented Technology Stack, you’re gonna have the ability to now use Unity’s new future-proof coding standards. There are also changes that
are coming down the pipeline, as this is still an early build, but we do have Jobs
support, which is great, which means multi-threading support. We do have full support for
the web, which is amazing. We have both ASMJS as well as WebAssembly. Now, the difference between the two is ASMJS was the first iteration of being able to do higher-quality, bigger builds on the web, and is supported, or has a
wider support net currently. WebAssembly is now the next version, and that will give us even more power as well as better performance. Now, a couple of noted
features that are missing are going to be your 2D support, that’s coming in the future, UI support, that’s also
coming in the future, as well as a couple of other things, including the Unity physics system, so you’re going to be doing
some workarounds right now when usin’ Project Tiny, but the performance
and the future-proofing of Project Tiny is finally here. All right, enough talking about it, let’s jump in and actually see the first demo of Project Tiny working in the Chrome browser. Here it is, Project Tiny’s
first working example, and it’s “Tiny Racing”,
working in the Chrome browser. Now, I’m going to be using Chrome 79, which just came out. However, it’ll work on any version. Different browsers will have just slightly different performances, and that’s really based on the support for either ASMJS or WebAssembly. So let’s just jump right into this. As you can see, we have our start-off, and the cars are going,
I’m using the keyboards, so keyboard support is also included. I have a little booster there, and I can go around the track, you can see the particle
system on the cars with the exhaust pipes. And if I jump into that little oil spill, you can see that I slow down, and just to know, this is using
Unity’s new DOTS framework, that’s the Data-Oriented Tech Stack, which this is amazing to see this in a web browser coming out of Unity. One of the downsides currently on the web is that the authoring
workflow is terrible. It is so difficult to
iterate over creating 3D or Canvas, really any Canvas-type
application on the web, because the authoring
is just really difficult for you to add items and
script at the same time, so if you’re adding visuals and scripting, it’s really difficult. Now, you can hear the audio support, so we have audio support. We do not have animation support. This physics is a simple
iteration of physics, because Unity’s current
physics implementations are not supported in Project Tiny yet, but they will be coming soon. The UI is also bit of a hack, however, UI support is something
that is going to be coming as soon as possible in 2020. Jobs is supported, which means we do have access to multi-threading. Burst is not fully supported,
it is partially supported, and it’s only supported
for build releases, which is cool, because when
you’re building out to the web, you want it to be as small as possible. Project Tiny’s here now, we can begin our beta-testing
development workflows now, start working on game slices, and doing our minimum viable
products, or MVP for short, and start really testing out
and breaking Project Tiny because of our support in
Version 1.0, 2.0, and now 3.0, Project Tiny has seen so many
improvements in the workflow and how it actually functions, and that is because of the testers, so please, beta-test this thing, try some things that are normal, try some things that are odd,
and try to push the boundaries so that we can get Project
Tiny in production quality as soon as possible. (easygoing digital music) While we’re playing this, I wanna draw your attention to
the frames-per-second meter. While I’m running, you can
see up here in the corner I am running at roughly
59.9 frames per second, so we’re talking about almost
a solid 60 frames per second, and as far as the GPU goes, you can see I’m using
only 4.4 megabytes of GPU. Now, my max is you know,
obviously the system’s max. However, you can see, nowhere near the max,
and we’re staying roughly in that same 60 frames per second range. Now, I’m gonna try to do a
whole bunch of other things and see if I can get it to
slow down a little bit, nope, not slowin’ down, and
this is very impressive. Very impressive to have audio running as well as the DOTS framework and the custom physics all
running at 60 frames per second. That’s very important for
quality as well as performance. That means we have a lot to work on without the worry of breaking the system, so this is solid, this is a good one. (easygoing digital music)

Leave a Reply

Your email address will not be published. Required fields are marked *