WEBVTT

00:00.000 --> 00:13.000
All right, we are ready for, hello.

00:13.000 --> 00:16.000
We are starting with the next presentation.

00:16.000 --> 00:22.000
We have a Steve to tell us about the Rostu client's library for Rust.

00:23.000 --> 00:24.000
Hi.

00:29.000 --> 00:36.000
I feel like this has been so much Rust in this track that's next year we're going to take over the Rust truck.

00:36.000 --> 00:43.000
So I'm Mr. Fernandez. I'm one of the original authors of Rust too.

00:44.000 --> 00:48.000
I was a member of the Core Rust one team.

00:48.000 --> 00:52.000
I'm doing up in source for more than 20 years.

00:52.000 --> 00:54.000
I'm a member of the Pikes Self Foundation.

00:54.000 --> 00:58.000
In a previous life, I used to do a lot of C++ with both.

00:58.000 --> 01:03.000
I was a Commuter Boost C++ and Python interested in many other projects.

01:03.000 --> 01:12.000
In 2017, I started the Rostu Rust project with the goal of adding support for Rust.

01:13.000 --> 01:18.000
I didn't support for Rust to Rust you and make it official.

01:18.000 --> 01:25.000
I don't know how many Rust farmers you've met before, but a good friend of mine, David,

01:25.000 --> 01:30.000
said this is the previous Rostu client that we are basically the vegans of the developer community.

01:30.000 --> 01:33.000
I don't know how to share this because my vegan friends are super family and chill,

01:33.000 --> 01:37.000
but Rust farmers are definitely not chill.

01:37.000 --> 01:39.000
We are not chill. We're very obnoxious.

01:39.000 --> 01:45.000
We want to rewrite everything into Rust. We want to replace.

01:45.000 --> 01:50.000
We want to replace C++ with Rust and everything.

01:50.000 --> 01:55.000
He's one of the best engineers I've ever met in my life. He's giving our target the end of the day,

01:55.000 --> 01:58.000
and he's going to be super awesome.

01:58.000 --> 02:07.000
In this start, I'm going to lay out why you should be using Rust for robotics.

02:07.000 --> 02:16.000
Then once I've sold you the idea, you're going to see how you can use Rostu with Rust.

02:16.000 --> 02:24.000
Why would we want to use Rust for robotics? There's C++. There's other languages.

02:24.000 --> 02:31.000
There's Go, there's TypeScript, apparently.

02:31.000 --> 02:36.000
I never thought that a robot could run JavaScript, but there you go.

02:36.000 --> 02:42.000
So, how's many advantages? It's fast.

02:42.000 --> 02:50.000
It's speed is always comparable to C, and there was a new, like two or three weeks ago,

02:50.000 --> 02:55.000
that announced the Rust experiment, the Linux kernel is over.

02:55.000 --> 02:58.000
They're removing Rust. No, no, no. It's not an Linux experiment.

02:58.000 --> 03:02.000
It's now part of the Linux kernel.

03:02.000 --> 03:08.000
It's the only language besides C that's approved to be used in the kernel.

03:08.000 --> 03:16.000
It's reliable. The compiler, it's like a very strict tutor.

03:16.000 --> 03:20.000
If you want to compile something, it's not going to pass.

03:20.000 --> 03:26.000
It's not going to lead you to compile it, but it's for your own good.

03:26.000 --> 03:29.000
So, trust the compiler, trust the Rust compiler.

03:29.000 --> 03:33.000
If you are familiar with Automotive, ISO 262, all those standards,

03:33.000 --> 03:44.000
Misra, the Misra C guidelines is a book that you can buy, and it's like 300 pages long.

03:44.000 --> 03:52.000
I've never done an analysis, but I would say that maybe 200 of those pages are gone if you

03:52.000 --> 04:00.000
migrate to Rust, because many of those suggestions, many of those guidelines are already built into the language.

04:00.000 --> 04:05.000
And we say a thing in the Rust community, a fearless concurrency.

04:05.000 --> 04:11.000
That means that if you're from Compiles, you're not going to have data races.

04:11.000 --> 04:14.000
You're not going to have concurrency issues.

04:14.000 --> 04:17.000
And that opens the door to a thing.

04:17.000 --> 04:25.000
Well, it's a several things, but one of them is Rayan. Rayan is a work stealing library.

04:25.000 --> 04:30.000
If you've used, you know, training building blocks or silk.

04:30.000 --> 04:37.000
It's basically the same principle, except that with training building blocks,

04:37.000 --> 04:42.000
you could replace your full loop with a pile of full loop.

04:42.000 --> 04:48.000
And across your fingers, then maybe you're not going to have data races, and maybe your program is not going to crash.

04:48.000 --> 04:55.000
With this, with Rust, you're for sure, for sure, it's going to be safe.

04:55.000 --> 05:02.000
And if it compounds, Rayan is going to be using all the CPUs in your program and your computer.

05:02.000 --> 05:04.000
Basically, for free, just replace a full loop.

05:04.000 --> 05:09.000
It's just one of the many structures, but replace a full loop with a pile of full loop.

05:09.000 --> 05:13.000
And it's proactive. And it's 2026.

05:13.000 --> 05:20.000
And I wonder why language, programming language, wouldn't have tooling,

05:20.000 --> 05:29.000
why would it have management system, why is it not cross platform?

05:29.000 --> 05:36.000
Well, we have C++, and have none of those things.

05:36.000 --> 05:47.000
But I'm not going to be offending the C++ level up here too much.

05:47.000 --> 05:54.000
But it's not the ecosystem, it's not as mature as C and C++, of course.

05:54.000 --> 06:04.000
C, the first list of C of the C language was in late 60s.

06:04.000 --> 06:12.000
So, of course, there's a lot of time, and all that experience shouldn't be dismissed.

06:12.000 --> 06:15.000
And the other thing is certification.

06:15.000 --> 06:25.000
If you take your software to, for example, to in Munich, or you want to, you know,

06:25.000 --> 06:32.000
you want to certify your software, there's only certification for C, C++, and ADA.

06:32.000 --> 06:39.000
There's no such thing for Rust, but there's good news.

06:39.000 --> 06:45.000
There's this, there's a team, slash company called first scene.

06:45.000 --> 06:51.000
Outside, and they have a compiler called first scene, that's a downstream fork of the Rust compiler.

06:51.000 --> 06:57.000
And they managed to certify it for ISO 262.

06:57.000 --> 07:02.000
And I see and all that.

07:02.000 --> 07:12.000
And about a month or two months ago, they also managed to certify parts of the core library in Rust.

07:12.000 --> 07:14.000
So, it's there.

07:14.000 --> 07:22.000
It's going to be, eventually, we're going to have a certified version of Rust that's going to be great for, you know,

07:22.000 --> 07:27.000
critical systems and so on.

07:27.000 --> 07:34.000
So, there's, like, lots and lots of robots using Rust.

07:34.000 --> 07:42.000
Many, many of them use C++, and Rust.

07:42.000 --> 07:47.000
There was, as we used from, you know, academia, but also production.

07:47.000 --> 07:53.000
And so, I don't know why some people keep insisting that Rust is not in production,

07:53.000 --> 08:03.000
when, you know, a lot of robotics uses, has, as 15,000 robots in warehouses all over the world, running Rust.

08:03.000 --> 08:11.000
Vexory, they built more than 200 robots, all of them using Rust.

08:11.000 --> 08:18.000
Rust has been to space, twice, NASA used it in two separate space missions.

08:18.000 --> 08:20.000
They were going to use it for a third one.

08:20.000 --> 08:27.000
I was going to go to the moon, but with the change of the government that was cancelled.

08:27.000 --> 08:31.000
So, I'm guessing that Trump doesn't like Ross, or, I don't know.

08:31.000 --> 08:37.000
But that's unfortunate, because there was going to be a robot on the moon called Viper,

08:37.000 --> 08:41.000
and it's going to be, it was going to be using Ross.

08:41.000 --> 08:44.000
It broke my heart when I saw the news.

08:45.000 --> 08:51.000
So, as I said, many, many robots, so we're not going to replace all the robots with something new,

08:51.000 --> 08:54.000
because it works for, for, for them.

08:54.000 --> 09:00.000
But we can improve the, we can improve their situation, right?

09:00.000 --> 09:02.000
We can use Ross, too.

09:02.000 --> 09:12.000
I, we can use Rust, and continue using all the Ross tooling, all the, you know,

09:12.000 --> 09:17.000
gazebo, and all that stuff, and that's, that's, that's great.

09:17.000 --> 09:22.000
So, I started this project in 2017.

09:22.000 --> 09:30.000
Mostly, because I wanted to learn Rust, and I sort of know Rust.

09:30.000 --> 09:36.000
And it was a good excuse, and then I saw this thing, this Rust thing is really good for robotics,

09:36.000 --> 09:43.000
and you had all the good things that I thought C++ would have for so many years.

09:43.000 --> 09:45.000
And I really like the language.

09:45.000 --> 09:49.000
It doesn't have inheritance, which for me is a big plus.

09:49.000 --> 09:54.000
Once you do a, like, a big cod base inheritance is a, is a math.

09:54.000 --> 09:59.000
And it has more semantics by default and so on.

09:59.000 --> 10:04.000
So, with Ross Ross, what we are aiming is a complete,

10:04.000 --> 10:10.000
cross-true pipeline, from co-generation to the client library,

10:10.000 --> 10:14.000
then tie a thing is going to be Rust.

10:14.000 --> 10:23.000
So, for that, for the co-generation, we, I started the Ross ideal generator, which generates,

10:23.000 --> 10:32.000
Ross code based on on Ross messages, co-connecration, co-connecration, co-conne the build tool that Ross uses.

10:32.000 --> 10:40.000
And this has this ad support for cargo, playing cargo projects, and what we call Ross cargo,

10:40.000 --> 10:44.000
which are cargo projects that have a bit of special Ross sauce.

10:44.000 --> 10:47.000
And a client library, RCLRS.

10:47.000 --> 10:50.000
It's entirely community driven.

10:50.000 --> 10:54.000
I've been doing up in search for, like, more than 20 years,

10:54.000 --> 11:00.000
for me up in search and free software, is for some of the most community.

11:00.000 --> 11:05.000
And so, I think that one thing that I'm really proud of, Ross Ross,

11:05.000 --> 11:13.000
that I sort of steer healthy community, people from, you know, lots of,

11:13.000 --> 11:17.000
from different affiliations, there's Kim Belly here.

11:17.000 --> 11:19.000
She is the Windows teamer.

11:19.000 --> 11:21.000
I'm sorry for you.

11:21.000 --> 11:25.000
If you're the one who's fixing all the Windows issues in Rust,

11:25.000 --> 11:28.000
and we are grateful for that.

11:28.000 --> 11:33.000
We got Sam, who works at Jason and Johnson,

11:33.000 --> 11:40.000
people from Inchinsik, Gray and Luca.

11:40.000 --> 11:47.000
There's Jacob, who works for the US government, people Nathan,

11:47.000 --> 11:50.000
from ClearPass and Natasha.

11:50.000 --> 11:53.000
Natasha's from ClearPass and so many others.

11:53.000 --> 11:58.000
So, we have community and it's great.

11:58.000 --> 12:00.000
And it's already been used.

12:00.000 --> 12:04.000
I forgot to update this, but it's already been used by OpenRMF,

12:04.000 --> 12:10.000
the Fleet Management, software developed by, by Inchinsik,

12:10.000 --> 12:13.000
but also, I forgot the name.

12:13.000 --> 12:17.000
There's a company in Japan that uses it for mission control,

12:18.000 --> 12:21.000
for space missions.

12:21.000 --> 12:26.000
The folks from Botronics are going to give a talk about,

12:26.000 --> 12:30.000
about how they use Rust.

12:30.000 --> 12:34.000
So, it's already been used for something that's still,

12:34.000 --> 12:39.000
more or less on the path of being integrated into Rust.

12:39.000 --> 12:45.000
If you've been to a Rust gun, you'll have seen this.

12:45.000 --> 12:51.000
This is what I call the Lasagna architecture.

12:51.000 --> 12:54.000
A bunch of layers on top of each other.

12:54.000 --> 12:58.000
Basically, I'm saying that Rust 1 was spaghetti.

12:58.000 --> 13:00.000
We can all agree on that.

13:00.000 --> 13:04.000
And this architecture where the enables us is that we focus

13:04.000 --> 13:08.000
on the user application that will be in Rust.

13:08.000 --> 13:13.000
The client library, and we have LCLTP, LCLP and LCL Java.

13:13.000 --> 13:15.000
We're going to have CLOS.

13:15.000 --> 13:19.000
But the rest, we don't really care.

13:19.000 --> 13:21.000
We don't care about the transport.

13:21.000 --> 13:25.000
We're not going to be doing anything with the transport.

13:25.000 --> 13:28.000
I mean, we're not going to have to know anything about the transport.

13:28.000 --> 13:31.000
Because then, if you have the place Rust2,

13:31.000 --> 13:33.000
and we're all going to use isorics.

13:33.000 --> 13:34.000
Or use Zeno.

13:34.000 --> 13:35.000
Or use cycling.

13:35.000 --> 13:39.000
Or use some custom transport that you've developed.

13:39.000 --> 13:42.000
Or you bought a license for one of these certified,

13:42.000 --> 13:46.000
DDS, implementations, or any of that.

13:46.000 --> 13:49.000
You can still use that.

13:49.000 --> 13:55.000
And just on top of all that, you can use Rust.

13:55.000 --> 14:00.000
So in order to achieve that, for Rust we have,

14:00.000 --> 14:04.000
the problem is how do you conserve these two worlds?

14:04.000 --> 14:08.000
How do you marry Rust and Rust?

14:08.000 --> 14:15.000
The two ecosystems are very opinionated for a good reason.

14:15.000 --> 14:19.000
Rust comes with cargo, as the built-in tool,

14:19.000 --> 14:22.000
and crates as a dependency system.

14:22.000 --> 14:28.000
Rust comes with Colkan and Rust app as a dependency system.

14:28.000 --> 14:31.000
That's where the fun begins,

14:31.000 --> 14:34.000
because how are we going to do that?

14:34.000 --> 14:39.000
Well, the built tool sort of we solved that more or less.

14:39.000 --> 14:43.000
But the dependencies system, that's way tricky.

14:43.000 --> 14:44.000
Way tricky.

14:44.000 --> 14:48.000
Jose has talked about the build farm, the VOS build farm,

14:48.000 --> 14:55.000
adding support for crates for Rust projects through cargo.

14:55.000 --> 14:59.000
If you're using Pixi, which I'm a huge fan of,

14:59.000 --> 15:03.000
all that you don't have to worry, you're not using the VOS build farm.

15:03.000 --> 15:09.000
You can use Pixi, because Pixi has support for Rust.

15:09.000 --> 15:17.000
So I've actually used RCLRS with Pixi and Rust packages,

15:17.000 --> 15:19.000
and what to read.

15:19.000 --> 15:22.000
So as I said, we have the co-generator.

15:22.000 --> 15:27.000
The co-generator, we've released it onto the Rust build farm

15:27.000 --> 15:31.000
for all the currently supported distros.

15:31.000 --> 15:36.000
Handball, Jazzy, Kilted, and Rolling, which will become

15:36.000 --> 15:39.000
lyrical in May.

15:39.000 --> 15:43.000
But do you know why Rust is released on the 20th of May,

15:43.000 --> 15:46.000
because it's international turtle day?

15:46.000 --> 15:48.000
Now, give me a look it up,

15:48.000 --> 15:52.000
and turtles are the mascot of Rust.

15:52.000 --> 15:55.000
And for Rust, you're lyrical.

15:55.000 --> 15:58.000
And for me, it's really exciting.

15:58.000 --> 16:03.000
It's going to come with the Rust generator

16:03.000 --> 16:05.000
as one of the fold ones.

16:05.000 --> 16:09.000
If you download Rolling right now,

16:09.000 --> 16:13.000
you're going to see that the message packages

16:13.000 --> 16:15.000
also contain Rust.

16:15.000 --> 16:20.000
And that means they can just use RCLRS from crates

16:20.000 --> 16:23.000
without having to download anything extra,

16:23.000 --> 16:25.000
because it already comes with Rust.

16:25.000 --> 16:30.000
It's a huge achievement for Rust being added

16:30.000 --> 16:33.000
as one of the fold generators.

16:33.000 --> 16:36.000
And being one of the, it's the first co-generator

16:36.000 --> 16:42.000
that's being developed outside the Rust team,

16:42.000 --> 16:45.000
despite me being in the Rust team.

16:45.000 --> 16:48.000
So it's really cool.

16:48.000 --> 16:51.000
It's what's every standard feature that comes

16:51.000 --> 16:55.000
without the other generators, like MSG and ADL formats.

16:55.000 --> 16:57.000
There's no extra compiled costs,

16:57.000 --> 17:01.000
because with Rust, you only compile at the very end

17:01.000 --> 17:03.000
when you compile your application,

17:03.000 --> 17:06.000
but the code, the messages are not compiled,

17:06.000 --> 17:09.000
and it can be interred into any workspace.

17:09.000 --> 17:11.000
The Rust claim library,

17:11.000 --> 17:14.000
basically we build on top of RCL.

17:14.000 --> 17:17.000
The API, we try to make it as similar,

17:17.000 --> 17:20.000
as familiar as possible to RCLCP.

17:20.000 --> 17:24.000
But we also wanted to make it automatic.

17:24.000 --> 17:28.000
We want to make it familiar for Rust developers.

17:28.000 --> 17:31.000
And we have some extra features that are not

17:31.000 --> 17:34.000
could be possible in C++,

17:34.000 --> 17:36.000
but very difficult to implement,

17:36.000 --> 17:38.000
and much easier to implement in Rust,

17:38.000 --> 17:40.000
like async workers.

17:40.000 --> 17:43.000
For example, in Rust2, you have a service,

17:43.000 --> 17:46.000
and you want to make that service asynchronous.

17:46.000 --> 17:48.000
You want to make the handler asynchronous.

17:48.000 --> 17:52.000
You want it to return a feature or something,

17:52.000 --> 17:55.000
a calculation that's not immediate,

17:55.000 --> 17:58.000
with RCLCP that's really difficult

17:58.000 --> 18:02.000
to make it safe with RCLOS.

18:02.000 --> 18:04.000
It's really simple.

18:04.000 --> 18:06.000
It's purely written in Rust,

18:06.000 --> 18:08.000
released on crates.

18:08.000 --> 18:12.000
It has support for all these things.

18:12.000 --> 18:16.000
We'll see later some of those features in a more detail,

18:16.000 --> 18:20.000
but basically right now, basically right now,

18:20.000 --> 18:22.000
it has, I would say,

18:22.000 --> 18:26.000
the 80% of the 1890% of the feature

18:26.000 --> 18:32.000
said that anyone would expect from a client library.

18:32.000 --> 18:34.000
As I said before,

18:34.000 --> 18:36.000
there's more code in the following slides,

18:36.000 --> 18:38.000
but I'm not going to bore you with that,

18:38.000 --> 18:42.000
because no one likes looking at source code on the slide.

18:42.000 --> 18:45.000
But I'm going to show you how we are doing things.

18:45.000 --> 18:48.000
You're from Lee, the approach.

18:48.000 --> 18:52.000
If you use RCLCPP,

18:52.000 --> 18:56.000
you must be familiar with the right part,

18:56.000 --> 18:58.000
but then there are things on the right part

18:58.000 --> 19:01.000
that maybe don't make much sense.

19:01.000 --> 19:08.000
Why there's implicitly a context that's created

19:08.000 --> 19:11.000
inside RCLCPP,

19:11.000 --> 19:15.000
as usually not a good pattern, it's a code smell.

19:15.000 --> 19:20.000
Rust makes it very difficult to have global states,

19:20.000 --> 19:22.000
which is a good thing.

19:22.000 --> 19:24.000
Instead of that,

19:24.000 --> 19:25.000
we make it explicit.

19:25.000 --> 19:26.000
From the context,

19:26.000 --> 19:28.000
we create an executor.

19:28.000 --> 19:30.000
From the executor we create a node.

19:30.000 --> 19:34.000
It's very unlikely that you're going to create a node,

19:34.000 --> 19:36.000
and then add it to an executor,

19:36.000 --> 19:37.000
remove it from the executor,

19:37.000 --> 19:38.000
and add it to an executor.

19:38.000 --> 19:40.000
That's something that theoretically

19:40.000 --> 19:42.000
it's possible to see++,

19:42.000 --> 19:44.000
but it's very unsafe.

19:44.000 --> 19:45.000
We decided,

19:45.000 --> 19:48.000
well, we should change the flow,

19:48.000 --> 19:50.000
and make it safer.

19:50.000 --> 19:53.000
That's why we do it differently.

19:53.000 --> 19:55.000
We do this order.

19:55.000 --> 19:58.000
As I said, publishers, descriptions, services,

19:58.000 --> 20:00.000
clients, async workers,

20:00.000 --> 20:01.000
more features.

20:01.000 --> 20:04.000
We got actions.

20:04.000 --> 20:06.000
We got dynamic positions,

20:06.000 --> 20:11.000
as you can create publishers and

20:11.000 --> 20:15.000
subscribers without knowing the message messages

20:15.000 --> 20:16.000
at compile time.

20:16.000 --> 20:19.000
You can create a Rust bag to

20:19.000 --> 20:21.000
in Rust.

20:21.000 --> 20:23.000
You got to put out our timers.

20:23.000 --> 20:25.000
We support zero copy.

20:25.000 --> 20:28.000
It's safe with Rust.

20:28.000 --> 20:31.000
It's full Rust async.

20:31.000 --> 20:35.000
We support any async framework

20:35.000 --> 20:37.000
that's in Rust.

20:37.000 --> 20:39.000
The examples we have,

20:39.000 --> 20:40.000
you're stuck here,

20:40.000 --> 20:41.000
but you can you stuck here,

20:41.000 --> 20:42.000
asynchronous it,

20:42.000 --> 20:44.000
anything else.

20:44.000 --> 20:46.000
We now have someone developed

20:46.000 --> 20:48.000
a support for TF2,

20:48.000 --> 20:49.000
for transforms,

20:49.000 --> 20:51.000
so basically you're done.

20:51.000 --> 20:53.000
Is that you?

20:53.000 --> 20:56.000
You're awesome.

20:56.000 --> 20:58.000
You're awesome, man.

20:58.000 --> 20:59.000
That's great.

20:59.000 --> 21:00.000
Awesome.

21:00.000 --> 21:03.000
We have the data as well.

21:03.000 --> 21:04.000
A future.

21:04.000 --> 21:06.000
We want to release our CLRS

21:06.000 --> 21:07.000
onto the Rust build firm.

21:07.000 --> 21:08.000
As I said,

21:08.000 --> 21:09.000
work is being done.

21:09.000 --> 21:11.000
We want to support the Rust graph.

21:11.000 --> 21:13.000
The message generation story

21:13.000 --> 21:16.000
is really, really, really.

21:16.000 --> 21:20.000
It's a headache.

21:20.000 --> 21:22.000
It's a Python.

21:22.000 --> 21:24.000
It's a CMake project that calls

21:24.000 --> 21:26.000
a Python script that uses

21:26.000 --> 21:29.000
a Python template system to generate

21:29.000 --> 21:31.000
Rust code.

21:31.000 --> 21:33.000
It's always needed a pink

21:33.000 --> 21:35.000
after looking at it,

21:35.000 --> 21:37.000
and I wrote it.

21:37.000 --> 21:38.000
If we want to support

21:38.000 --> 21:40.000
dynamic clients and services,

21:40.000 --> 21:42.000
because a bunch of links here,

21:42.000 --> 21:44.000
they can check later.

21:44.000 --> 21:47.000
If you want to say hi,

21:47.000 --> 21:49.000
feel free to say me any mail.

21:49.000 --> 21:50.000
That's it.

21:50.000 --> 21:51.000
Thank you so much.

21:51.000 --> 22:06.000
Thank you.

22:06.000 --> 22:09.000
Are you planning to support

22:09.000 --> 22:11.000
Kolba Groups?

22:11.000 --> 22:14.000
The things thatacing workers

22:14.000 --> 22:17.000
are an evolution of Kolba Groups.

22:18.000 --> 22:21.000
Conceptually, they are very, very similar

22:21.000 --> 22:25.000
with the addition thatacing workers

22:25.000 --> 22:31.000
can let you have all this in a safe way.

22:31.000 --> 22:34.000
We basically support that with a different name.

22:34.000 --> 22:36.000
Okay. Thank you.

22:40.000 --> 22:41.000
Hi.

22:41.000 --> 22:43.000
I was using R2R,

22:43.000 --> 22:45.000
which is a different project,

22:45.000 --> 22:47.000
which is very similar to Rust.

22:47.000 --> 22:49.000
The program I have,

22:49.000 --> 22:51.000
if I have a lot of messages

22:51.000 --> 22:53.000
completion times are really long,

22:53.000 --> 22:55.000
because it's all in one grade.

22:55.000 --> 22:57.000
Do you think your R2Rs

22:57.000 --> 22:59.000
is compatible or could be compatible

22:59.000 --> 23:01.000
with those other projects somehow?

23:01.000 --> 23:03.000
Did you look at it?

23:03.000 --> 23:05.000
Anyway, R2R,

23:05.000 --> 23:07.000
excellent project as well.

23:07.000 --> 23:09.000
The approaches are a bit different.

23:09.000 --> 23:11.000
They are first and foremost a Rust project

23:11.000 --> 23:13.000
that can interact

23:13.000 --> 23:15.000
with Rust.

23:15.000 --> 23:17.000
We are the opposite.

23:17.000 --> 23:19.000
We are a Rust project that allows you to use Rust.

23:19.000 --> 23:23.000
It would be really cold now that we have the generator

23:23.000 --> 23:25.000
released onto the Bill Fund

23:25.000 --> 23:28.000
and being part of the next Rustisto

23:28.000 --> 23:30.000
collaborate with R2R,

23:30.000 --> 23:33.000
so that we can define sort of like a standard

23:33.000 --> 23:37.000
of how to create Rust messages.

23:37.000 --> 23:41.000
There's another project called Rust Client.

23:41.000 --> 23:43.000
If I'm not mistaken,

23:43.000 --> 23:47.000
and it's also another Rust library for Rust,

23:47.000 --> 23:49.000
and it would be really good if we all

23:49.000 --> 23:51.000
can find some common ground.

23:51.000 --> 23:53.000
Thanks.

23:59.000 --> 24:01.000
This is an online question.

24:01.000 --> 24:03.000
Somebody is asking,

24:03.000 --> 24:05.000
how good is the documentation to use Rust

24:05.000 --> 24:07.000
for a first Rust project?

24:07.000 --> 24:09.000
Is there any other more questions?

24:09.000 --> 24:11.000
Do I have to answer there?

24:13.000 --> 24:19.000
We've done a bit for the latest release.

24:19.000 --> 24:27.000
I did a push to improve the documentation.

24:27.000 --> 24:31.000
But I wish you were better.

24:31.000 --> 24:34.000
There's not much time in the day,

24:34.000 --> 24:36.000
unfortunately only 24 hours.

24:36.000 --> 24:40.000
But the condition is sparse

24:40.000 --> 24:44.000
and can get you somewhere with the basic

24:44.000 --> 24:46.000
we have a bunch of examples.

24:46.000 --> 24:48.000
If you follow the documentation,

24:48.000 --> 24:50.000
you're going to get the example running.

24:50.000 --> 24:54.000
But it's true that there's always room for improvement.

24:54.000 --> 24:56.000
Basically, I'm saying that it's not great.

24:56.000 --> 25:00.000
Thanks a lot.

25:00.000 --> 25:02.000
Thank you so much.

25:06.000 --> 25:08.000
Thank you.