So, hello again, now we'll have the Gium Bine, there's going to talk to us about Copa Rres,
Opposen Trost, something for robotics, thank you so much, welcome everyone, welcome on
this stream too. So, yeah, I'm Gium, I'm the author of like a Copa Rres, like a Rust engine for
robotics. So, probably most of you read that, oh yeah, I know they'll do that just like
takes to something, we'll watch it in the rest, come on, they're another spin of it, no, let me give me a chance.
So, yeah, that doesn't work. Right, so the stuff to wear engine for robots, I have a good
like way of kind of having a grown Copa Rres in what happened in another industry, which is the
gaming industry, anyway, it's me. So, for those all enough to remember, okay, who knows what's
the game on the left-hand side? Wow, nice, oh my god, like the geek, the geek dumb is here.
Friends of Persia, that's the dude, I don't remember, he's never actually took his son,
he's like a roto-friend thing to actually make the animations of a feast game, everything
that was anchored with assembly language. And it was amazing, like back then you looked at that,
I don't know, I'm gonna get up at Apple 2, it was absolutely incredible. It completely
changed the way you see animations in the game, that something was like striking, it's like everything
was really anchored for that game. Nothing was ever used from that implementation, but something
something happening in the 90s, probably everybody knows this one in the middle, but
and this one has been bought for on every single platform's ever. Let's do my
doom, basically created what we call the now a game engine. And there will
have something back then when they make that engine, is that a little bit lacking
on a robot, you, you don't, I mean people working on a codebase and assets of
a game, they are not coming from the same place. Some of them are, yeah,
hardcore developers that are making algorithms, but you have like a
people specialized in sounds, people specialized in 3D graphics and so on.
Like in robotics, you have people that are coming from a mechanical engineering
or like controls or like physics and, and the EE and so you have a lot of people
that are actually working around a robot. And the industry can kind of match
your from that point on. And you have like all the games today, you have triple
games, you see like full studios of people that, yeah, just have like a specific view
of their own games or their own like development or
contributions to the game depending on where they are coming from. And you see
all those games where you have today. So, compared to that page,
out of the of that story and really try to really from scratch like two years ago,
when I spent like 10 years really trying to to support like like robotics engineers
or what he says, trying to to think what would be the best tool today. So those people
can all work together on a robot efficiently and not shooting themselves in the
university in the process. So what's wrong with was, that's going to be my first question
for that, that you would ask. So things like Ross is amazing in it. I mean, I've seen
so many students going to, I don't know, you've a university of austine or other universities
here and so on. Look, look at what they can do with like so little, just few Python scripts
scrap together, they have like those, they have their components, they can actually
log on their on their system. But it has like, it has like, it has like,
say I use flows for me when you try to get that from like a prototype to a natural product.
It's actually fighting you a lot. One of the key reasons is, it is completely asynchronous.
So people are going to that way because they think like, yeah, you have like a big,
I don't know, multi-sweeted machine with GPUs and so on. So yeah, as a college city is good,
like you have an event and then you can search to that event. So you try to optimize that,
that aspect of the robot. The huge issue with as a college city, like it is done on Ross,
it is non-deterministic. So what I say by non-deterministic is that you grab your
your boss bags, you look them in your robot, but you never have any guarantees that when you get
back your your boss bags and you try to replay your code, that your code is going to replay
the same thing as what happened on the robot. And that has like a lot of like a kind of like
cascading consequences when you are trying to, yeah, and make, for example, like autonomous robots,
like things that are needs to be safe and where also you have like a lot of people working on
that needs to reproduce a lot of cases out of the out of your robot, that they either encounter
on the wild or in simulation. There is also the C++ situation. I mean, I spent literally nights
on the passenger side of a cellar rinkar, wondering what the hell is going on with this code
base, everything passed, like all the all the leaders passed, and I remember one that was very
serious, where are like some kind of like to search the perception system, who was actually less
this performance that was supposed to be, and it was a corruption, that was the limit of our
user code and the and the transroarty layer, and that was a stupid for loop that somebody did
where there was like an undefined behavior, and you look, seriously, like a lot of people are
there are eyes on this thing, and it went through all the ways through the car. So C++, again,
think about like what I said about the game engines, people are like roboticists, usually they are
they see really C++ as a tool, like a school driver, they don't care, they don't care yet,
they don't care about like complexity of the language and so on, they want something that is safe
to run and to implement what they have in mind, which is usually math, usually both are like
pure transforms, for your robots, for any algorithms including a machine learning, and yeah,
C++ doesn't, and the thing also is that people often switch back to Python then, because Python
is actually safe, it's hard to actually crash Python and easy to use, and then you have like
questions where yeah, you have a management on your back, saying you need a robot,
that needs to go to production, like as the code is in Python, and you're like now, it doesn't
even keep real time, it calls in the lab, not trained on the public rules, performance is horrible,
it's just terrible, you'll see with copper, I think the compulsion is more about like
was being slow than actually copper being fast, also the fact is it's really dependent on your
system, people try to port, was to value systems, I have it on my arch Linux, it's terrible,
because like you have like so many system dependencies and package dependencies, out of the systems,
something also that that really hinders people to actually have a system that is really
heavily in production where you can update it and put it in the wild, yeah, and like you'll see
also on the safety, so okay I took a lot of games, so about what let's let's look at
at copper, so copper is when I really started it from scratch, the non-negotiable
first principle I wanted to implement in there was determinism, so to be sure that what you run,
so literally you run let's say something simulation even with copper, you can try it actually on
the repo, you run your robot on simulation, it plugs the robot, you strip out the outputs,
you rerun the product, you replay basically with a whisperer that that log, you compare the
binaries of the two logs, they are exactly the same, so think about it for a roboticist, it means
that those logs you can put them in the in the cloud and you can be sure that when your test
gets passes, it will always pass, and when it doesn't pass, you know that you you you
regress somewhere, so it's also designed for safety, conceptually, so conceptually actually copper
is a lot of things, one it's a compiler, I just basically copper extends with macros in rest,
the rest compiler to actually create your run time, we don't depend on anything, so much that
you could say that copper is an actual operating system, you say Ross is an operating system,
it's not, that is an operating system, I have a file system, I have a scalar and I run like
bare metal, you can run on STM32 if you want, but it runs off course on standard process,
we'll time a minute, but you can also run it like bare metal, because yeah, I depend on nothing,
it's very performant, like like high bond wave, low latency, we are like out of the box,
if you want to do, I have some examples in the repo, if you want to do the same chain of tasks
that you run and log for each of them, for the latency, I have 100x faster than Ross, so that's
100x, yeah, because like it generates basically the operating system to run your robot, you design
your robot, you say to copper what you want to run and it accommodates you, the system around
your your the architecture of your robot, so it's very out to be, I mean it tries to chain up like
all the tasks back to back in memory, with like that architecture, so it's always like hitting
all the cashees and the linearity of all your systems, same thing for logging, actually,
logging with log, we don't log, like Ross bugs are kind of like indexed and all over the
place on an hard wife, we log so linearly that we don't need a file system, so you give it a partition
linearity, we log back to back to back to back to back, so for an NVMe for example,
it's the difference between seven gigabytes per second to something that is five on the right
of the megabytes or six on the megabytes per second, that's the difference of successful
product or not, because yeah, if you want to match that performance, you need 10 times more like
NVMe's, how do I know? Actually, actually I can still set the ring cards, we're hard to put like
a raise of NVMe's, where I was like what the hell are we doing? And the digital also is
important, something that you realize quickly with robots in a conformant environment, you're
robots will run nicely, but also the need you have more people or more objects around your
your thing and if your own system adds some noise into the measurement, you don't know
in terms of performance like, okay, what three girls that kind of like randomness into your
the execution of your own right? So yeah, all in all, that's all those people to focus on algorithms
and not all the details I told you, compared to that for you, on at compile time. Should we try
a demo? Can you make a prayer to the demo girls? So that's on the repo, you can actually try it
yourself and one thing I tried really hard to do is that you know what, that's just a rest up,
you don't have cool cool things off, special makes fires or whatever, that's it, that's my
non-negotiable, you can go on and it should run each, maybe.
Come on, no, yes, yes, yes, yes, yes, yes, yes, maybe I'll make it.
Here we go, so that's a very simple robot, which is like a safe balancing rod. I do that because
I don't want to explain to you a robot, so everybody knows this example actually, you don't see
my cursor but you try to try to show you, so that's just a self balancing rod like in a
run in a simulator, I do have the actual robot at home. It runs exactly the same code,
if I can't really see what I'm doing, but so you see, so that's basically bevy, bevy is like
a game engine in in copper, but we do, we do support like values like simulator, it's just one
that is easy because because of this copper run, like that's like a rust deponentive, so I can run it
straight away, you can see a little bit like the console, there is a console like to monitor real
time what is happening on the robot, so it shows you, here the structure of the robot itself,
so that's a big config file that is modular, you can add that, so the big difference between
was and copper is that you actually define your robot a lot of time, so you say what's going to be
connected to what and who is sending a message to what, that's part of the determinism aspect of it,
but still, still at the same concept, you have a task, you have input outwards and you
talk like you can have send messages even if you don't really send messages in that example
and you can visualize that they are like this little kind of dag, where you have on the left-hand side
sensors, those are, this was a Raspberry Pi running, like some algorithms, the PID is really simple
and the actual output on the right-hand side, so this thing also, when you look at the other latency,
so you have some zeros, because some of them are actually simulated, the other ones are actually
executed, so I give you the number on the simulator there, but you will have the same thing on the robot,
you see, I mean that's a small laptop, it's measured in microsegons and if I run that on my
desktop, it's going to be in nanoseconds, basically, sometimes it's zero because with the super
scale of the CPU, you can have actually data that is going so fast and we measure twice,
the same timestamp on the CPU clock, and I'm talking like that, but you would say like,
why do you need nanoseconds of latency, but think about it, like when you have a good
logger, like we have, and a low latency, suddenly you can think about your robot and actually
subdivides your robot with like blocks that are that are as small as possible, so these
you visibility on every single blocks input out, input out, input out, input out, and basically for free,
so you can, I don't know, you can put like 10 12 layers of of of blocks like that and you have like,
I don't know, one microsegons of latency and two, and if this is pure CPU, that's pretty cool,
I mean, over at the top of what you're doing, of course, if you're spending three seconds on
your past, it will show. In terms of bandwidth, so that's kept to the simulator, like 60
frames per second, something, like that's where you can see what's the efficiency of the
logging, what's the bandwidth you use, because often like what happens when you are building a robot,
you hit, you hit like limits on your system that are actually not CPUs, there are either Io,
or or memory bandwidth, often, because you're drawing like images or light up points, like super
AV things, that's why I really want you to have that view where robotics is can show like, oh,
wait, I just I did like a camera, a camera, or like a new light up, what's going to be the
cost in terms of performance, and yeah, that's pretty it. I can show you something I have seven
minutes, so I try to, can show you how it looks like, so you define your tasks on, that's the one
you've shown a little graph, and it's just like you tell it basically an ID, so you can collect them
and refer to them in the logs, you give them a type that is kind of, it's just like a rust type,
that implements like few traits depending on what type of component you are building,
and yeah, you can give it like those ones are like other configurations, those are tuning for
PIDs, so it's pretty self-explanatory, and you, you connect them, so basically you say, oh, I want
to connect this source with this destination, with this message, very, very simple.
Yeah, let's go back to the plantation. So yeah, I want to be sure that you have some
times for questions, which is usually, I trigger a lot of questions that would have that presentation,
so I would like to explain the amazing community, I've like a bunch of contributors,
now on copper, and yeah, we are moving forward a lot, we just, we aren't exactly like this,
bunch of like either middleware, like they know, or I saw eggs, we do, I think we've actually
exceeded the algorithm, like cornea, we are like hanging face and fire and algebra, the algebraic,
systems on unrest, so it's really copper is one thing that is actually growing together, a
little bit, all that risk of, of like in robotics, that is actually growing, and re-inventing a
little bit like what I did with copper, a lot of things are actually not just re-wrote in
unrest, but actually re-inventing unrest, and that's quite amazing, and I'm super happy to be part of
that ecosystem. Of course, like the two ones, at the bottom we talked about like re-run and first
glove, so for example, it's more like a, you saw that before, like a visualizer, re-run as also,
as also like an amazing integration with copper, because it integrates, of course, at the
rest of the value API level, so it's in two lines, of course, you can actually show what's going on
in re-run for, or what's going on in copper, always re-run. One small ask, if you like
what I'm doing, you are supporting a project, yeah, please, stay on a little report would be amazing.
The first thing to thank you very much, that's a lot of work and I appreciate that.
How does this framework interact with the programming languages, in particular Python, which is
taking our robotics with all the machine learning approaches, which in there, this calling
it's supposed to last, I know, but how does it interact? Yeah, no good question, so we do have already
Python API, but for the logs, because for example, you don't want to do that analytics in
the rest of the year, so our rest, our logging is actually an API, and so we can use that to
explore that to other systems, like we said, for folks love, but also you can get that and get
straight, you get your robot, you can have your Python worksheet, and you can actually get the
data straight out of Python interface. Life data, too? Life data, too? Life, the topic is looking at
that data, you could do it, we don't support it yet, but we could, so we do have what we call
like bridges, also, where you can integrate with your Python code, we use zero, for example, for
that, where you can actually, like to meet the data, to a channel, and you have bindings for those
like types in Python, so you can do that, like remotely. What we haven't done yet is actually
enabling Python itself in the tasks of the robot, it's not hard to do, like you know, like
tooling in rest, that is doing that very nicely, but I'm a little bit scared, because like then you
have like the, a little bit the duration, a lot of like people contribute just Python, while
I really, especially where I am in the community today, I really want like solid like building blocks
for basic things, like drivers or like, I don't know, ICP, and those kind of like simple things
that I really want to be nailed. At some point I will implement like a first class Python,
super, for sure. So you have bridges, like let's say we have our system, we want to migrate towards
your system, so we start with whatever we have, I'm going to say Ross, because that's what we have.
And we want to migrate some elements to your OS, do you have bridges set up, so you can
correct. Yes, so we do have a translation layer for Ross too, so you can also talk to Ross
too soon, but that also one of your escape arch from Ross.
Thanks so much for the talk, I'm really calling concepts and I think that Ross could learn a lot from
from that, but I, this thing on your website that you say that you have a patent on copper,
could you verify that? Actually, yeah, actually I let it expire. So I had a provisionary patent on
on it and it's not that much, but what's going to happen now? What's going to happen with
Arcas, I'm not even going to touch suffer that. Yeah, no, it's not patent today, actually.
Okay, it's it was a pre-minuary patent, so basically it's not a patent just like saying maybe
we, I would, I would patent it and I decided to not, to not, it would be good if you updated the
website because for me, it was like, it's very, yeah, yeah, I'm going to touch this. Okay, cool, thank you.
Goodmath, thank you for one more.
Hey, my question is, if you, if you have a system that's built on Ross too already,
what is the migration path if I, I really like what you're doing? Yeah, I, I don't understand
like, do we have to start from scratch and we'll build everything? There are like, there will be
questions. So, so we have a system and one of our users is doing that actually and what are
recommend usually is to, so we have a bridge between copper and Ross too and so you can send
messages from one to another. So your, your copper system can act as like a big,