All right, we are ready for, hello.
We are starting with the next presentation.
We have a Steve to tell us about the Rostu client's library for Rust.
Hi.
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.
So I'm Mr. Fernandez. I'm one of the original authors of Rust too.
I was a member of the Core Rust one team.
I'm doing up in source for more than 20 years.
I'm a member of the Pikes Self Foundation.
In a previous life, I used to do a lot of C++ with both.
I was a Commuter Boost C++ and Python interested in many other projects.
In 2017, I started the Rostu Rust project with the goal of adding support for Rust.
I didn't support for Rust to Rust you and make it official.
I don't know how many Rust farmers you've met before, but a good friend of mine, David,
said this is the previous Rostu client that we are basically the vegans of the developer community.
I don't know how to share this because my vegan friends are super family and chill,
but Rust farmers are definitely not chill.
We are not chill. We're very obnoxious.
We want to rewrite everything into Rust. We want to replace.
We want to replace C++ with Rust and everything.
He's one of the best engineers I've ever met in my life. He's giving our target the end of the day,
and he's going to be super awesome.
In this start, I'm going to lay out why you should be using Rust for robotics.
Then once I've sold you the idea, you're going to see how you can use Rostu with Rust.
Why would we want to use Rust for robotics? There's C++. There's other languages.
There's Go, there's TypeScript, apparently.
I never thought that a robot could run JavaScript, but there you go.
So, how's many advantages? It's fast.
It's speed is always comparable to C, and there was a new, like two or three weeks ago,
that announced the Rust experiment, the Linux kernel is over.
They're removing Rust. No, no, no. It's not an Linux experiment.
It's now part of the Linux kernel.
It's the only language besides C that's approved to be used in the kernel.
It's reliable. The compiler, it's like a very strict tutor.
If you want to compile something, it's not going to pass.
It's not going to lead you to compile it, but it's for your own good.
So, trust the compiler, trust the Rust compiler.
If you are familiar with Automotive, ISO 262, all those standards,
Misra, the Misra C guidelines is a book that you can buy, and it's like 300 pages long.
I've never done an analysis, but I would say that maybe 200 of those pages are gone if you
migrate to Rust, because many of those suggestions, many of those guidelines are already built into the language.
And we say a thing in the Rust community, a fearless concurrency.
That means that if you're from Compiles, you're not going to have data races.
You're not going to have concurrency issues.
And that opens the door to a thing.
Well, it's a several things, but one of them is Rayan. Rayan is a work stealing library.
If you've used, you know, training building blocks or silk.
It's basically the same principle, except that with training building blocks,
you could replace your full loop with a pile of full loop.
And across your fingers, then maybe you're not going to have data races, and maybe your program is not going to crash.
With this, with Rust, you're for sure, for sure, it's going to be safe.
And if it compounds, Rayan is going to be using all the CPUs in your program and your computer.
Basically, for free, just replace a full loop.
It's just one of the many structures, but replace a full loop with a pile of full loop.
And it's proactive. And it's 2026.
And I wonder why language, programming language, wouldn't have tooling,
why would it have management system, why is it not cross platform?
Well, we have C++, and have none of those things.
But I'm not going to be offending the C++ level up here too much.
But it's not the ecosystem, it's not as mature as C and C++, of course.
C, the first list of C of the C language was in late 60s.
So, of course, there's a lot of time, and all that experience shouldn't be dismissed.
And the other thing is certification.
If you take your software to, for example, to in Munich, or you want to, you know,
you want to certify your software, there's only certification for C, C++, and ADA.
There's no such thing for Rust, but there's good news.
There's this, there's a team, slash company called first scene.
Outside, and they have a compiler called first scene, that's a downstream fork of the Rust compiler.
And they managed to certify it for ISO 262.
And I see and all that.
And about a month or two months ago, they also managed to certify parts of the core library in Rust.
So, it's there.
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,
critical systems and so on.
So, there's, like, lots and lots of robots using Rust.
Many, many of them use C++, and Rust.
There was, as we used from, you know, academia, but also production.
And so, I don't know why some people keep insisting that Rust is not in production,
when, you know, a lot of robotics uses, has, as 15,000 robots in warehouses all over the world, running Rust.
Vexory, they built more than 200 robots, all of them using Rust.
Rust has been to space, twice, NASA used it in two separate space missions.
They were going to use it for a third one.
I was going to go to the moon, but with the change of the government that was cancelled.
So, I'm guessing that Trump doesn't like Ross, or, I don't know.
But that's unfortunate, because there was going to be a robot on the moon called Viper,
and it's going to be, it was going to be using Ross.
It broke my heart when I saw the news.
So, as I said, many, many robots, so we're not going to replace all the robots with something new,
because it works for, for, for them.
But we can improve the, we can improve their situation, right?
We can use Ross, too.
I, we can use Rust, and continue using all the Ross tooling, all the, you know,
gazebo, and all that stuff, and that's, that's, that's great.
So, I started this project in 2017.
Mostly, because I wanted to learn Rust, and I sort of know Rust.
And it was a good excuse, and then I saw this thing, this Rust thing is really good for robotics,
and you had all the good things that I thought C++ would have for so many years.
And I really like the language.
It doesn't have inheritance, which for me is a big plus.
Once you do a, like, a big cod base inheritance is a, is a math.
And it has more semantics by default and so on.
So, with Ross Ross, what we are aiming is a complete,
cross-true pipeline, from co-generation to the client library,
then tie a thing is going to be Rust.
So, for that, for the co-generation, we, I started the Ross ideal generator, which generates,
Ross code based on on Ross messages, co-connecration, co-connecration, co-conne the build tool that Ross uses.
And this has this ad support for cargo, playing cargo projects, and what we call Ross cargo,
which are cargo projects that have a bit of special Ross sauce.
And a client library, RCLRS.
It's entirely community driven.
I've been doing up in search for, like, more than 20 years,
for me up in search and free software, is for some of the most community.
And so, I think that one thing that I'm really proud of, Ross Ross,
that I sort of steer healthy community, people from, you know, lots of,
from different affiliations, there's Kim Belly here.
She is the Windows teamer.
I'm sorry for you.
If you're the one who's fixing all the Windows issues in Rust,
and we are grateful for that.
We got Sam, who works at Jason and Johnson,
people from Inchinsik, Gray and Luca.
There's Jacob, who works for the US government, people Nathan,
from ClearPass and Natasha.
Natasha's from ClearPass and so many others.
So, we have community and it's great.
And it's already been used.
I forgot to update this, but it's already been used by OpenRMF,
the Fleet Management, software developed by, by Inchinsik,
but also, I forgot the name.
There's a company in Japan that uses it for mission control,
for space missions.
The folks from Botronics are going to give a talk about,
about how they use Rust.
So, it's already been used for something that's still,
more or less on the path of being integrated into Rust.
If you've been to a Rust gun, you'll have seen this.
This is what I call the Lasagna architecture.
A bunch of layers on top of each other.
Basically, I'm saying that Rust 1 was spaghetti.
We can all agree on that.
And this architecture where the enables us is that we focus
on the user application that will be in Rust.
The client library, and we have LCLTP, LCLP and LCL Java.
We're going to have CLOS.
But the rest, we don't really care.
We don't care about the transport.
We're not going to be doing anything with the transport.
I mean, we're not going to have to know anything about the transport.
Because then, if you have the place Rust2,
and we're all going to use isorics.
Or use Zeno.
Or use cycling.
Or use some custom transport that you've developed.
Or you bought a license for one of these certified,
DDS, implementations, or any of that.
You can still use that.
And just on top of all that, you can use Rust.
So in order to achieve that, for Rust we have,
the problem is how do you conserve these two worlds?
How do you marry Rust and Rust?
The two ecosystems are very opinionated for a good reason.
Rust comes with cargo, as the built-in tool,
and crates as a dependency system.
Rust comes with Colkan and Rust app as a dependency system.
That's where the fun begins,
because how are we going to do that?
Well, the built tool sort of we solved that more or less.
But the dependencies system, that's way tricky.
Way tricky.
Jose has talked about the build farm, the VOS build farm,
adding support for crates for Rust projects through cargo.
If you're using Pixi, which I'm a huge fan of,
all that you don't have to worry, you're not using the VOS build farm.
You can use Pixi, because Pixi has support for Rust.
So I've actually used RCLRS with Pixi and Rust packages,
and what to read.
So as I said, we have the co-generator.
The co-generator, we've released it onto the Rust build farm
for all the currently supported distros.
Handball, Jazzy, Kilted, and Rolling, which will become
lyrical in May.
But do you know why Rust is released on the 20th of May,
because it's international turtle day?
Now, give me a look it up,
and turtles are the mascot of Rust.
And for Rust, you're lyrical.
And for me, it's really exciting.
It's going to come with the Rust generator
as one of the fold ones.
If you download Rolling right now,
you're going to see that the message packages
also contain Rust.
And that means they can just use RCLRS from crates
without having to download anything extra,
because it already comes with Rust.
It's a huge achievement for Rust being added
as one of the fold generators.
And being one of the, it's the first co-generator
that's being developed outside the Rust team,
despite me being in the Rust team.
So it's really cool.
It's what's every standard feature that comes
without the other generators, like MSG and ADL formats.
There's no extra compiled costs,
because with Rust, you only compile at the very end
when you compile your application,
but the code, the messages are not compiled,
and it can be interred into any workspace.
The Rust claim library,
basically we build on top of RCL.
The API, we try to make it as similar,
as familiar as possible to RCLCP.
But we also wanted to make it automatic.
We want to make it familiar for Rust developers.
And we have some extra features that are not
could be possible in C++,
but very difficult to implement,
and much easier to implement in Rust,
like async workers.
For example, in Rust2, you have a service,
and you want to make that service asynchronous.
You want to make the handler asynchronous.
You want it to return a feature or something,
a calculation that's not immediate,
with RCLCP that's really difficult
to make it safe with RCLOS.
It's really simple.
It's purely written in Rust,
released on crates.
It has support for all these things.
We'll see later some of those features in a more detail,
but basically right now, basically right now,
it has, I would say,
the 80% of the 1890% of the feature
said that anyone would expect from a client library.
As I said before,
there's more code in the following slides,
but I'm not going to bore you with that,
because no one likes looking at source code on the slide.
But I'm going to show you how we are doing things.
You're from Lee, the approach.
If you use RCLCPP,
you must be familiar with the right part,
but then there are things on the right part
that maybe don't make much sense.
Why there's implicitly a context that's created
inside RCLCPP,
as usually not a good pattern, it's a code smell.
Rust makes it very difficult to have global states,
which is a good thing.
Instead of that,
we make it explicit.
From the context,
we create an executor.
From the executor we create a node.
It's very unlikely that you're going to create a node,
and then add it to an executor,
remove it from the executor,
and add it to an executor.
That's something that theoretically
it's possible to see++,
but it's very unsafe.
We decided,
well, we should change the flow,
and make it safer.
That's why we do it differently.
We do this order.
As I said, publishers, descriptions, services,
clients, async workers,
more features.
We got actions.
We got dynamic positions,
as you can create publishers and
subscribers without knowing the message messages
at compile time.
You can create a Rust bag to
in Rust.
You got to put out our timers.
We support zero copy.
It's safe with Rust.
It's full Rust async.
We support any async framework
that's in Rust.
The examples we have,
you're stuck here,
but you can you stuck here,
asynchronous it,
anything else.
We now have someone developed
a support for TF2,
for transforms,
so basically you're done.
Is that you?
You're awesome.
You're awesome, man.
That's great.
Awesome.
We have the data as well.
A future.
We want to release our CLRS
onto the Rust build firm.
As I said,
work is being done.
We want to support the Rust graph.
The message generation story
is really, really, really.
It's a headache.
It's a Python.
It's a CMake project that calls
a Python script that uses
a Python template system to generate
Rust code.
It's always needed a pink
after looking at it,
and I wrote it.
If we want to support
dynamic clients and services,
because a bunch of links here,
they can check later.
If you want to say hi,
feel free to say me any mail.
That's it.
Thank you so much.
Thank you.
Are you planning to support
Kolba Groups?
The things thatacing workers
are an evolution of Kolba Groups.
Conceptually, they are very, very similar
with the addition thatacing workers
can let you have all this in a safe way.
We basically support that with a different name.
Okay. Thank you.
Hi.
I was using R2R,
which is a different project,
which is very similar to Rust.
The program I have,
if I have a lot of messages
completion times are really long,
because it's all in one grade.
Do you think your R2Rs
is compatible or could be compatible
with those other projects somehow?
Did you look at it?
Anyway, R2R,
excellent project as well.
The approaches are a bit different.
They are first and foremost a Rust project
that can interact
with Rust.
We are the opposite.
We are a Rust project that allows you to use Rust.
It would be really cold now that we have the generator
released onto the Bill Fund
and being part of the next Rustisto
collaborate with R2R,
so that we can define sort of like a standard
of how to create Rust messages.
There's another project called Rust Client.
If I'm not mistaken,
and it's also another Rust library for Rust,
and it would be really good if we all
can find some common ground.
Thanks.
This is an online question.
Somebody is asking,
how good is the documentation to use Rust
for a first Rust project?
Is there any other more questions?
Do I have to answer there?
We've done a bit for the latest release.
I did a push to improve the documentation.
But I wish you were better.
There's not much time in the day,
unfortunately only 24 hours.
But the condition is sparse
and can get you somewhere with the basic
we have a bunch of examples.
If you follow the documentation,
you're going to get the example running.
But it's true that there's always room for improvement.
Basically, I'm saying that it's not great.
Thanks a lot.
Thank you so much.
Thank you.