Hello ladies and gentlemen, it's Mike here at Gay From Scratch, and today we're going to talk about GDNative Rust. Now, what is GDNative Rust? Well, this is a project that enables you to use GDNative with the Rust programming language. Yeah, there's

actually two versions of this, one that used GDNative, which was for GDNative 3, as well as one now that uses GD extensions, which is GDNative 4. And what we're going to do is talk about how to get up and running with this and what it allows you

to do is basically, again, program or extend the GDNative game using the Rust programming language. So Rust is an alternative to GDScript with different trade-offs for users. Uh, while GDScript enables fast prototyping and short feedback cycles, games of larger scale may benefit from a stronger type system,

a rich library ecosystem, and native performance. The Rust bindings focus on safety despite interacting with other engines over FFI. Many APIs are designed to catch errors at compile time, while others offer runtime checks to prevent undefined behaviors. Again, there is a GDNative version of this for GDNative 3 and

the GD extension version of this for GDNative 4. Now, one thing you might be wondering is what the heck is an FFI? Well, FFI is a foreign function interface. Basically, uh, it is a way for, um, the Rust language to call external APIs, such as the GDNative

bindings. And on top of that, you may be thinking, 'Huh, we've covered this before, haven't we?' And definitely yes, we have. Uh, back in 2022, I covered the GDNative extensions for GDNative 4, uh, but there is a reason why I am talking about it today.

specifically, and that is because earlier this month they released the uh 2.0 version. So yeah, that was the 1.0 version I covered in 2022. So this doesn't develop at uh lightning speed by any means, uh but it is an updated

version of it now in terms of what's actually improved, uh a lot of it is um about like the plumbing and how things work and how the interactions work between uh GDAU and Rust, uh and there's a little bit more here as well, things like generating GDAU docs from Rust, do

and so on, uh and as well as the addition of the RPC attribute and and some quality of life features as well and a bunch of performance improvements as well. So there has been a major update, the release 2.0 of GDAU 0.2. I suppose I

should say of the Gill Rust. So what I'm going to do is quickly show you how to go about and get started with this guy now. I'm not going to go into much detail because quite frankly I never really jelled with the Rust programming language. It's not one that I know

incredibly well. So instead I'm going to show you how you can get up and going with this one and decide if this works well for you or not. Now you're going to notice is I am at their GitHub Page by the way. This is available under the MPL2

license, uh you go ahead and grab the repository like so and now what I'm going to do is open up a command prompt like this guy right here. We will full screen with that and let's make it so you can actually see what I'm doing and

we're going to go to the temp directory because that's where all things should live, get clone, and then just clone down the repository. This has got everything you need in it, so GD extension, not the greatest name for the project by the way, but that's what

they went with. And what we're going to do is go into this examples folder right here, but otherwise you can see all of the the GD specific stuff, the FFI I was talking about earlier, the bindings, uh and so on, they're all available here. Uh but what you're going to want to do

is go into the examples folder to get things started, like so. You'll notice there's two different examples. We've got Dodge the Creeps, which is uh a game that's been implemented entirely using Rust uh on the Rust side of things, and Hot Reload. It's Hot Reload we're

actually going to illustrate today. CU it's the simplest example of EX how GD native Rust works, so let's go into Hot Reload. And what you're going to notice is there's two directories here, so you've got a GD native folder and a Rust folder, and

there's instructions by the way. There is a complete manual that walks you through how to set up your own project. There's quite a few hoops you've got to run through to be honest, but you'll notice if we go into the GD native folder, it's a

GD native project, so you see here you've got uh the GD native scene here, you've got uh like a main scene, a project, and then the GD extension. This GD extension is important because it tells um where all of the various different Rust dependencies are in this case, and then

we've got some test stuff with some scenes and so on in it so we also have this other folder here though this rust directory and this one is your rust project so this is where all your code is all your code is in the source source folder here so your example here is uh

lib RS like so so what you're going to want to do uh is in the rust folder you're going to first off want to make sure that you have rust installed to check if you got rust installed uh the easiest way to do it well try and run

the command C cargo if cargo doesn't run you don't have rust installed by the way if you do have it and you haven't used rust in a while what you're going to want to do is a cargo followed by the word update just to make sure that your

tool chain is the most current as possible it updates quite often so there you see I have updated my project now what you're going to notice here is there is this cargo.toml file in here you can use that to build your project so what I'm going to just do is say

cargo build and this runs and basically compiles my rust source code it pulls down of the relevant dependencies that this project might have this is basically the build process From the Rough Side of things so we've actually uh compiled our code and we're good to

go so now I'm going to do control shift 2 just opening up basically another command prompt so you notice here tabbed we got the two command prompts going that's all I've done there so that's control shift 2 to do that and of course we go back to our

temp directory GD extension like so and I'm going to go into the examples and this is uh what the heck was actually it's called hot reload all hot reload we go to the gdau project right here so there is your gdau you're going to want

to open this one up in gdau I have gdau in my system path so I can go ahead like this and we can go gdau project. gdau so all we're doing here is opening it up in gdau you could also just load it in gdau

file browse to this directory and had the same result all right so what you're going to notice here is we have this um main scene so open up main scene and then we have reloadable so how the heck is this working well let's head back

over here and we will switch switch over to our other tab like so so we're still in the rust and we'll just do Visual Studio code and we'll open up this directory all right so you're going to notice here is our source code is here

in source and it's list guy right here so what we've done is we've defined a class in Rust programming called reloadable so the structure is available here it's inheriting from I Node um so again there's bindings for all of the various different uh GDScript um classes and

names etc out there and basically what you've done is just created this very very simple class and it's exposing this enum over here so uh this is how you would create your own extended class but you could use it on the Rust side of

things to notice here you have this full namespace goo up here uh so we've created this class called Reloadable and then that is linked through the project again using that GD extension side of things so we've created an instance of Reloadable so you see here Reloadable is

available as a not like so so that is how you would extend your code and basically you could write new classes in Rust that you could then implement inside of the engine or you could like interface with a GD script if you wanted or whatever and you notice with this guy

selected we have this favorite planet so we got Earth Mars Venus and so on so why is this example called hot reload well it's because of this so what we can do here is come on down here and we will add a new planet to the list Bob like so

and go ahead we'll save our code uh we'll go back to to our Command Prompt over here uh right here and then we just go cargo build because we did an update of our code it's going to notice that one file changed it will rebuild it and I'm going

to head back on over here to the GDScript game engine and you'll notice Reloadable over here Bob so it gives you the ability basically to uh write your game logic in uh the Rust programming language but you can then uh obviously have live reloading of it inside of the

GDScript game engine that's one of the features that has been added I think in 0.2 I don't think that was there all along by the way if you are interested uh you can also come back over here so CD dot dot CD dot dot we have that Dodge

the creeps and you're going to notice here in the rust side of things, uh, we have a more in-depth example. So here you can see, boom, and this is more like creating here, here's the bindings for a main scene and you got game over, new game callbacks and so on. So this is a more complicated game, um, full example. Uh, here again is your player logic here, uh, so a bit more of an in-depth example than the hot reload one. It's also more complicated to actually grock what's going on here. It's why I

went with the other example. So ladies and gentlemen, that is it. Uh, let me just go on back over to the web page, which would be over here. So again, it is available up on GitHub. What you're interested in, it is called GDAu Rust. It's available at GDAu Rust.

github.io. Again, there is a book to get you up and going, uh, that walks you through all of the instructions that you need to know more. Obviously, you need to have something that I don't have right now, which is competency in the Rust programming language. But if you've

always wanted to do your game logic in Rust, you can now. You're not going to be doing it like this. I showed you a C++ extension ago. This doesn't integrate directly inside of the editor, so you don't write your code inside of GDAu like

you would with GD Script or C, etc. It's kind of an extension mechanism for bringing Rust to GDAu. So let me know what you think. Comments down below. I'll talk to you all later. Goodbye.

Rust Comes to Godot

Gamefromscratch is the video channel of http://www.gamefromscratch.com.

We cover all things game development related, with a focus on tutorials.  Game engines, art tools, programming languages, you name it, we will cover it.  After doing text based tutorials for several years we have started slowly making more video content.  Keep your eyes on this channel for more and more content as time goes on.

Of course, we create this stuff for you, so we would absolutely love to hear from you if there is something game development related that you would like to see covered!

If you enjoy this videos and tutorials, please consider supporting GameFromScratch on Patreon: https://www.patreon.com/gamefromscratch   Thanks!