That's easier than you think. Joshua, go ahead.
Commodore is having a good time so far. Hopefully, you're in the right room.
We might have to sign a new civil order in August.
Unfortunately, we have a little bit of technical trouble, but I think they're
still gonna be on time. We have a lot to talk about today.
And there's gonna be quite a bit of government for questions that we get after
you hold them. And I gotta go through these slides pretty quickly here.
So when you hear this presentation for some of our office today,
okay, cause some of you probably have a few questions in your head and be like, rust?
Why? Why rust? Why not this? Why not that? Why use cutene with rust and all
that kind of, all those kind of questions.
I just want you to hold those in your head for a moment and just let me trace you for a little bit.
And I'm not trying to like, I'm not coming here to try to convert you to some
kind of like close lover of a salad or something like that.
But I think this is something that was really, you know, considered.
And I could a lot more be more knowledgeable about this.
So, what are we going to be talking about today? We're going to be talking about the work of office.
We have, I'm going to try to split this up into kind of the two different sections
here. So, I'm going to go over sort of the non-technical.
Well, things that maybe what non-people might understand and know about.
And then in the later half, I'm going to go over the actual technologies that
you can use to engineer and see what slots you can get together.
Hopefully, okay, so I just want to ask everybody a question.
How many people in here, raise your hand if you're interested in this.
Okay hold them drop your hands up well
keep your hand raised if you know that there's already
process that it can't even say there's a
if there's if we raise the chamber of hand
raised if you know that there's rust inside of tv held right
now before this time okay that's a
lot of these amount of people so uh hopefully this
okay yeah so i
split uh since west is a relatively new thing i was really curious if someone
did a talk about this before the previous academy so there was uh three major
instances that i defined we have um bias talking about of trusts but flint in
uh master's academy which of course i haven't said you know too,
um the mom would talk about us and we also have a talk about rest supporting
chain at all So hopefully this is sort of a new topic to a lot of us here.
And who am I? Who is the person you're going to be staring at for the next hour or so?
I'm Joshua Gollins, also known as Brett String, I've been a software engineer here at KDAB.
You can see our nice little logo there on the front.
And I've been hacking away from KD for a couple of years now.
You probably know who I am, hopefully. But I've been also using Rust outside
of work for a lot of personal projects, and I find, of course,
some better work in DE I really like to do.
So I'm really, really interested in how to glue those two things together,
my two favorite technologies.
Anyway, we're going to go into some surface level details about what Rust is,
sort of the purported benefits of it.
But in case this is going to be really quickly for people who already know Rust,
it's probably going to be really boring for anybody who's not familiar.
Hopefully this will shed a little bit of light for you.
So what is Rust? It's a instance like, what did you just like? C++ or C?
It's relatively new. I think 1.0 came out in 2015.
It's been a development earlier than that, but obviously it's pretty young compared to like C or C++.
And a really big talking point, which we'll get into later, is safety.
We're considering a lot of safety systems language, especially compared to C++.
And on the surface level, it has a lot of similar syntax and concepts, has few differences.
Pretty big differences that we'll be able to go over here. But what are some other rough features?
We already know that it's safe. We already know that it's new and shiny.
But what's some other, like, kind of benefits that people go on and on about in Rust?
Kind of my favorite thing is a lot of, there's a lot of matters included.
So, for example, it has its own testing suite. That's all those C++ developers
and guys will know we have, like, a bajillion of those.
So, it's nice that they have standard ones. not even working on a standard benchmark tool.
We, um, and also the problem is, obviously it has its own real system that had
to enter, which C++ also, uh, C++ doesn't.
So that's kind of an interesting difference between the two languages.
Um, RUN almost has a pretty large and rich standard library, a lot of library.
Um, it's probably not, I think I'm hearing it's not as big as C++,
but it's still pretty sizable, I think.
And also another thing I've kind of loved about this language is that it makes
tool chain management really easy.
A lot of secure targets for like, I don't know, embedded, you have like web
assembly and stuff like that.
Stuff that we also have in C++ land, but I like that it's all centralized and rough.
There's usually not like a bunch of boards so the last compile of that you have
these are like a million years out of date.
So, what are some of the kind of props to that cluster? Rust attempts to me.
It tries to be more safe than C++. It does stuff like tracks for memory safety.
Threats to safety. It has much stronger ownership battle, which we'll get into
in the technical words at the top.
But next I'm going to talk about Rust's ID, and I have to say which one I have.
I did not even start this ad with that slide. So, my show of cancer earlier,
not that people know that there's actually rust inside of the kidney today,
but I just want to go over, like, our kidney is mostly C++ code,
so why do we care about rust at all?
And I want to kind of go over like what can be brought to the table and I just
want to say don't ask my lesson not x, y, z or your mates for the table like
which you're on h, x, or m.
But I feel like the lesson is also kind of special because it has a lot and
a lot of ways to deal with C and C plus us and since it's so similar it's also a system language.
I think it's a pretty good candidate if we want a second language or a third
language to be count five on this IDE.
I think Rust is a pretty good candidate for that.
Um something um the kind of the
cost of my talk is uh there's a lot and
a lot of talk especially this year about how can
we attract link contributors to kd and if you ever get inside of i don't know
if you ever looked at one of the contributors saying uh when they're first contributed
uh a really close like every few months someone asked us why can i not use rust And if I think,
I think Rust is a much more interesting language for contributors, I think,
well, the thought process with them is that they think C++ is a legacy language.
They think it's like a waste of time, like, why should I even bother learning this?
And I know for a lot of us in the audience, we would disagree, I disagree too.
I think C++ is so long enough, I feel like there's still a reason to learn it.
But we can't deny this is kind of what people think.
For example, if they wanted to choose the open source, are they going to choose
K-E, which forces them to learn C++?
Are they going to go to another blockchain that uses Rust, because they might
be interested in Rust only?
So I think it's worth looking at Rust, even for this point of all,
to find out the facts and contributors.
And I feel like we kind of see a microcosm of this already. For example,
how many people here, or how many people have you seen, that only started off
working in the Q part of Blackboard, or like a TE organization?
And then they slowly, but surely, maybe they make like a C++ pitch here,
or C++ pitch there, and it's sort of like that, but it has to be other languages, like a TE.
So I'm like thinking, maybe we have a few REST boxes in TE that people like
to work on. And new contributors can go like, oh, I want to learn this.
I don't really care about D++ that much. I'll get shipping to this.
And it's sort of just like the down-nose off of there.
And I'm going to go over a little bit of statistical data to kind of back up this claim.
So this is an answer from the Stack Overflow developer survey reporting to my core.
Also, just noting that I have QR codes for all the.
Your phone camera but that goes to uh it's just a link on this slide in this to your progress walls,
but um i really don't like this section but it's basically let's see if i'm
basically we're gonna share this red part is what they call desire like desire
to use a language so as you can see,
this line here run it needs to prevent and blue line here is what i use it uh
you can actually to use the language inside your day job.
So if we compare this to C++, 82% of respondents want to use refs and unfortunately,
C++ is lower, it is like 53.1%.
So that's a very good number. So I don't really trust this survey because it
says 18% of people use C++ in their daily work,
but then they go ahead and say like 28% use Rust, which I don't blame at all.
But I hope you guys see here that in general, Rust is obviously much more popular
than C++ right now, but C++ is still a lot better.
It's not the only way in people's minds to get the jobs.
But if you were to take this language here, I'd be putting in Rust, right?
This is kind of, I think I've said much of this before, but...
But in the context of Rust inside of KDE, I feel like we're kind of in a special situation here.
So to anybody who is very active in the Rust ecosystem, and to let the people
outside of the know, Rust doesn't really have a user interface library.
For example, when you think of C++, and you're like, I want to write this C++
application that needs to do what, by one of the first things that comes to mind.
It's Qube, obviously, but when it comes to not really their own Qube,
there's like a bunch of like different user interface libraries that they're
developing, but since it's so new, it's sort of like the no man's land,
where they're quickly trying to develop a solution, but there's like nothing like Qube.
And so I think we can both benefit from this arrangement.
If Rust needs a UR library and Qt wants to try to meet the distributors,
why don't we start Rust Pro?
I feel like making it easier to write Qt-enabled Rust programs and sort of programming
Rust within the Qt community can help both sides.
And I'll get into this more later about how we can even use T inside of like Rust, Qt, S.
But I don't think it's really an unpopular opinion that would come from people
using Qt, but we want more people using KDE software.
So we can make it easier to use like KDE libraries like Kirigami or our translation
framework and they make it advertising enough.
I think people will use it. And I don't know if you can catch on the side of
the rest of the media and to catch on the side of not teaching me to kind of
like benefit both parties here.
So I also want to go over the kind of safety point for us because for Kiki,
I feel like it's not too important.
Of course we do handle like a little bit of security stuff by them.
I think we generally make like that some software that doesn't really have to
be secure, but that doesn't mean we still can't benefit from this point.
For example, I'll go into this later, but for example, we recently, inside of Convive,
there's an optional REST thing that we can use for the SQL parsing that,
since anything we can do with it, it's just real practice.
So I think, I'll get into this more later, but I feel like I've kind of got it across,
uh could be beneficial beneficial to us as well i
mean to uh as well so um another
point i want to know is i personally don't care about
the safety stuff too much when it comes to us oh what's way more interesting
to me is the is the thing that people build in us people build these libraries
what they call it basically there's like tons and tons and tons of useful base builds and Rust.
Well, a little bit more how we can actually learn from those later,
but I just want to show you what I mean with a really, really good example.
How many people in here have heard of the servo validation? Nice.
So here's a really good case right here with Rust.
So here at TeamLab, we've developed a QML component that if you use this on
your criminal application will show you a servo value and,
this is sort of like the perfect case right where
um if you don't know servo it's written in rust but
since it's quickly developing they don't want to exactly commit
to a c or c plus lcmi so it's
going to be very hard for c++ applications to use it so we can use for us to
kind of glue those two things together and i'll go into what css2 is here but
that's kind of one of the examples of like a really cool rust thing um that we can then uh find to,
and then use to try a few applications uh and definitely the work i think for
like mobile c++ new applications so if you want to use the server menu i would
suggest using that because that's just a prototype, but that just goes to show,
that there is, there's a new system for Rust, even if you're more of Rust-like.
So another thing I want to avoid is I'm not here to tell you to rewrite your
KDE code in Rust. I also find that to be a pretty clueless endeavor.
I don't think I need to go on this point too much because I think it's,
I think the period, the honeymoon period, everyone's going to rewrite everything in Rust.
Post code and start throwing everything in Rust. I like to take a much more
focused, pragmatic approach with them.
So, I think it's about time to start going into the technical bits of how we
actually integrate these two things together.
So, how do we integrate VOS and C++?
Real quick, I just want to go over how we've already done the integration on the KDE side.
So, as I already mentioned, Like Kondai uses a crate for Haitian wildflowers to move security.
In our progressive drawing application, we also use a rust pick or tessellation
analysis to find the game.
In Angelfish, and I think I've seen it now as well, we use an ad-locking crate. And I...
Put one... To this.
So, clearly, Kenny is on straight from us, and all of these will be using technology that we already did.
But since we're in the tentacle bit, I kind of want to give a good showcase
of rough safety for anyone who's not familiar with the ownership model,
and just to give you the idea of like,
Like, what are some of the technical and safety reasons why you might want to adopt a dog?
And let's see, Sharon.
Okay so i'm going to give you a really contract example in z plus plus of something
that russ kind of tries to pick over a little bit.
So if you look here i'm defining a some class
uh with formatting that the
browser is deciding to describe we have a
method here called do your thing we have a list of
values uh that are integers and then this
do your thing has uh it calls
to clear this list and then in
my name i set the list from array to one to five and then
i lift through those and print the values but you
see here i'm changing the values too and then i call do your thing and for all
the c plus plus burgers and audience you're probably screaming at me right now
you're saying you should not do this because what will happen is we'll you will
invalidate your iterators here and then this This thing will completely explode.
Here the compiler for some reason printed through the whole list, and you can stop it too.
But what I'm going to go into is sort of what does this look like in Rust?
If we try to rewrite the same thing in Rust, what does it look like?
And here's the Rust version. So you can see we define the struct in Rust.
We say it's a list of values. We also clear the values in the do your thing function.
We set the values to one, two, three, four, five. You can't see the five because
it's behind the bubble. Then we loop through the values.
And we do the same thing here. When the value equals two, we say do your thing.
But can anybody tell me what happens here?
Do you like the one? Yes. And so I know my talk is a little bit of a mess,
but this is what's really cool. cool to me.
So yes, you're right, it does not compile.
And we can actually see the error message right here.
And in my opinion, this is really cool.
So this is part of what makes rust safer than C++. And.
I feel like when people talk about mass safety, they sort of pretend that you
can't make safe C++ code.
But it's not, I don't think it's as simple as that. I think it's just harder to write safe C++.
For example, there's ways to make them a previous C++ snippet like safer.
Like obviously you should be reading the documentation for a clear function
to know that it actually has a and it's a really weird side effect.
But the fact that Rust does not allow you to do it at all, it doesn't even allow
all these unsafe mirrors to happen, is really cool.
And so, I would say that when we're working with Rust,
as a C++ developer, in my experience, it's made me a better C++ developer,
because I've definitely written code like this before.
And because the compiler or the optimizer
sort of just like nothing airs
out nothing no warnings come out this stuff kind
of like slips live with what's this really cool because it points out hey you
really should not be doing this day this really unsafe thing and i know this
is kind of the time to sample but this is sort of this is sort of my experience
with uh when learning ruts this out it kind of makes it without a program in
general this even when i go back to c plus.
Of course, it's not a silver bullet, there's, for example, watching bugs are
still very much possible, there's like this C++.
Even though there are security benefits here, I feel like when it comes to running
code in non-configured scenarios, it's probably a better idea if you're already using C++.
Plus to just learn how to write same person plus plus and.
I want to quickly go through some of the libraries that we use to integrate
this new technology. So, I think I'm going to mention...
Okay, I think I'm going to mention first is called Corrosion. So, for...
We still... Okay, so, when you... In your projects, you probably still want to use Scenic.
But, as you know, as I mentioned, I have a system called Argo.
So, how you sort of unify those things. Obviously, you don't want to like call
cargo and then you sort of like manually link it then.
So, this is a really cool, it's a thing you can include in CMA that would basically
allow you to invoke cargo.
Also, it works here if you have like a Rust function, I don't know,
to code some user table data.
You can simply print that little Rust library, include it in your project,
then call corrosion gear.
And it will auto-build it and it will also expose it as a normal CMA target
to use like anything else.
Of course, we want to build more on top of this.
So how do we do that? We use a framework called CSS.
It includes C++ and Rust together in sort of like this high-profile fashion.
So it's possible to use Rust-type C++ as if they were C++-types,
and you can also do vice versa.
And I will say this is very opinionated, so if you take a look at their website,
they have a very specific way of doing things.
But the point is to make it feel random on both sides and just to make you pay
yourself for having to go through like the scene FFI layer.
And it also can like see like, wait a sec, function.
What is it, it's like the...
Oh.
So a little bit of background is that I did it in the C as a bottom end and
I gave myself a couple of bottom ends that I also did compute and I decided
kind of incorrectly that I wasn't going to use CSS and I was going to create
a C API instead and I will say please do not do that just because you create CSS.
I'll go into a little bit of an example. Yes, in the next slide I'll show you
an example, a real world example of things that we had inside of KDE and it's,
Trust me, it's so much better.
You don't want to use crates like this. You don't want to try running C API's.
Oh, what's also cool is that it also handles C++ population.
So for example, if you did some C++ blue code, it will also handle the boolean,
the, they also handle the boolean compiler and all that fun stuff.
So, so I want to go into how simple this can be. So here, this is actually all
of the rest of, let's say, the non-condi right now. We're gluing these two things together.
So also the H1 parts are pretty identical to us. Just give us three.
So if we want to call it for C++, that's all we need.
We define the function right here. We say this function is from green,
H0 as my H0 dot len. And then I don't have the C++ side, but it's literally
just like one function call.
Then I just want to be ready with this candy symbol. I just want to point that out that.
Your life doesn't have to be difficult when you're done, but of course,
this is a really simple example, but when you sort of get into more complex
applications, you can kind of go with them.
But this is not an unsolved problem. I just want to put it that way.
And now I'm going to get into this logic version of the talk.
Okay, so this is all really cool, but this has nothing to do with Qube, right?
So if we want to build Rust, KDAF, V6, and Rust, how do we do that?
We use a tool called CXXQ.
It's created by my company, KDAF. It was created in about 2021,
and it's still being maintained today by Andrew and Leon, and it's been updating
continually ever since.
We think this is the future of Rust plus Qt.
We aren't the first people to do it. But in my opinion, we are following the
most leisure-filled and complete solution for using QT in Rust.
So I also wanted to mention that the maintainers are very receptive to contributions.
To be clear, this is not a problem if we're trying to sell you and we have to,
you know, license or anything like that.
There's also a little CLA as well. So if you know a
little bit of Rust and you want to try to help merge these two worlds
together that'd be very appreciated oh and another thing
i was told to mention is that css can be a single partner development
but as you can see it's still um it is usable but just keep that in mind guys
we're always trying to improve this thing uh i said this kind of unsolved album
version us as rustin can you take the item russ and c++ together but there's
still ways to improve for the developers.
So now I'm going to go to the example of what CXXQ allows you to do.
And I just want to make this disclaimer that this is really focused on the QML side.
We don't have that much QT widgets at all support in CXXQ right now because,
as you may know, it's a huge C++ API.
So we figured it's probably easier to define the interface with QLite.
QLite is the latest part of that. With QML, it's actually right and close to
QObjects to properly single and multiple sets of probably a much easier place to start.
But I want to say that it's not impossible to maybe write the Qt widgets application to us.
I just will not recommend it. And I don't think there's many tools for that right now.
So for all the people who know how to write QML applications,
you probably have a good idea in your head of like how to
set up a Q object to cover to uh attach properties to
it and how to register and stuff like that and eventually in
CXXQ that's much much similar so you have to look through all the rust systems
right here you can see in the very small time sorry about that that we have
a sort of same system so we have a Q object macro being called uh to of course
register with the metatype system.
We have a QML underscore element, just like in C++.
You can define properties and stuff like that.
And so I don't have it on the slide, but you see right there this myOpticRust,
that's just a normal Rust drum set.
So you can define variables on it, if there's two even arbitrary properties for that.
For example, this number is a number.
You can also just do normal setters, getters, and singles and stuff like that.
But really, this is all the glue code you need. And then the rest of the snippet,
of course, we just need like normal rust code.
And so with this, you can build fully rust QML applications today just using this system.
And even though there's a really simple example, we also support looking into
Qt in much more ways. For example, you can, of course, pay the inviolables and
those can be called from all three sides, the June 1st and June 12th plus from QML, of course.
We also support fund inheritance.
So whenever you have to create a queue with apps like Aiva model,
we also support overriding the base magnets.
We also support also looking into the Qt and Qt-Driving system.
We also support WordPress for Qt.
Names, engines, all that kind of stuff, you expect.
And, of course, there's also a huge swath of CXQ that's just exposing normal
Qt core types like Qt.NET or whatever.
And examples for all this can also be found in our repository.
I'm not going to make you think of why I flipped through a million writing clients.
But as I just said, I wish there was a real-world example that you use today,
showcasing that you can write your best Canadian applications,
like your normal QL applications that we have today in Canadian.
And I already said, please don't start rewriting everything in Rust.
I was starting to know people about that.
I'm gonna make it one exception here.
So, who knows contrast, the simple QML map.
Yeah, not that many people. It's like a contrast chart you can put two different
colors or sample it from your desktop.
It's really helpful to find the colors that contrast enough so it's actually
accessible to people like you will.
And so, what Zone has made is basically a rough version of that.
So that's something you can try out any now. Now you can see it uses Turing-Garmin.
It's certainly a little bit hard. You don't worry about that,
but it's a good showcase because core simple, at least the simple female applications,
we have all the tools available.
This is fully processed. There's no C++ in the repository at all.
I'll link to the repository in the next slide as well. But I just want to show
you, just looks like any other regular application.
There's nothing special that needs C++ here. So we have like,
it's not that complex as like your models involved, but you have like the queue
properties, of course, the color.
We have signals because you have to be able to like change the queue and that
also changes the hex code and the actual contrast that it shows.
We have the totals because of course the buttons have to do stuff.
But it's just just, it just shows that we already have all these tools to create
for us to be able to get the animation. So I'm just asking how they're doing.
Here's a little bit more information about the project. I'm not the one who created it.
Here with our fun in the king rustling which i'll
also link to later in the slide i just i'll just clean it up a little bit and
yeah this whole rust and q amount no c++ involved it just used it's like a normal
rust project so you just like include cxx uh q and cxx obviously and and.
And since this is a rewrite, we can actually do a little bit of statistical analysis about this.
Even though I really don't like comparing lines of thought between languages,
I still think this is kind of interesting to go over.
So obviously with C++, you have like a header and a definition file, it runs like one day.
So actually this rush to rewrite it is smaller than the contrast that we have right now.
Of course, this is only like a simple case. I'm sure for bigger applications
that actually might be different funds.
I mentioned that this also needs some KDE technologies. So how do we do that for us?
I haven't showcased that yet. It's called Sanscript-KDE frameworks.
And just to clean the room, this is not supposed to be official in any sort
of the class that you've awarded.
So I guess this is also created by George Hahn and I've been trying to help out a little bit with it.
So like, for example, in that contrast, we were like, we still use Gerigami.
We still use TmCore Downs for TML data.
We still use the regular KDE translation systems.
And we all be buying that across the disease. So having to do that at C++ and
then for QL applications.
You can check it out here. It's not really, it really only has the bare minimum.
But I also, oh, oh, yeah.
I have to say something about what the AGI looks like. And again,
what's very similar to what you can do But if we have our valve damper right
here, our application gate, you can see it actually lines up quite well with
Rust, certainly in the concept.
Of course, we initialized the localization engine here. That's all the normal.
In order to have really ugly wire rubs, I'm not using a local module.
That's something I'd actually work on soon.
But I also wanted to, I actually have some open questions about this project.
Do we even want this to become a visual? And if it does become a visual,
and we're putting that out there, what would the sort of layout look like?
And I'm also curious what kind of outer frame response we need to worry about mining and rust.
Because of course, I'm thinking like the next one, I would be like,
can't think for configuration.
Also, I wonder actually how much we can actually have to worry about.
And I have to, if there's any digital people I'm really curious much what the
situation with the hack issue and distributing REST applications are.
Because obviously I think this is still pretty new.
I personally haven't used the rest of those Qt applications.
I'm really curious that there's like some sort of, if there's going to be a
huge roadblock or something that we might run into a question that we might have to solve.
So how much time do I have?
Oh, perfect, perfect, perfect, because I'm mapping that. So I know that was
kind of a method of talk, but I hope you probably took the idea that not a lot
of people know about Rust.
Okay, I'm on my side. A lot of people don't know that he already has Rust,
and I think this is a real shame, because I think this is the way to go,
that more and more people want to use Rust,
and I feel like we, of course, want games to survive, even outside of C++,
so I think it's worthwhile.
To think about this kind of things and encourage more and more people to use
us inside of TV and show teams that this is actually possible today.
We just have to start about putting more effort.
And here's also some more links. So like I said, we're not trying to develop
CMS Institute as a product of the acne, question, statistical, or conceptual.
They are available in this dual chat. This is all the links in the workbook.
So don't worry about like, worry about uh losing
this link it's not the rust zula it's a separate zulu
chat um they're of course also receptive on makeup
so if you want to raise that issue if you're like why does this work
and why is this difficult go while they answer you also
on the kitty side we have a kitty rust mixture i very very much suggest even
if you have no interest in rust at all i suggest just being that road because
our fun working is gone off uh and it's really really impressive and I think
that's it I think I'm going to open up for a short question,
for what 10 minutes.
And hopefully they'll ask for it.
I was not aware that Russ is in KDE today.
You mentioned that there are questions about packaging and the development,
which means the build system, also dependency management.
And I agree with you that this is probably the most irritating or biggest hurdle
to entrance to this. And you also mentioned two possible solutions to that,
if I understood this correctly.
Do you have more resources on that? What are people doing?
Or if you have an idea for a tutorial or anything,
we say, okay, well, this is a way you can start, or this is a way that you can
look into starting to set up some reasonable development workflow that doesn't
end up in chaos with build systems fighting against each other in the end. Thank you.
I mean, so for it.
Yeah, well, this whole part of it, of the library that I mentioned earlier,
a condiment cost, so it had something else. I ate no fish.
Those are good examples of how to just add a little bit small rust without going
insane and messing up your bell system.
And I sort of don't have the answer for you because I don't know if anyone's
shipping a Rust application right now publicly on my distribution.
I would love to hear how it's going to make it.
But I don't have the answer for you. Hopefully, once we're starting to break
through a couple of ideas of like a real world application, that's not going
to be right. That's not a toy.
And we'll kind of cross that bridge when we get back.
But hopefully it's not a huge deal for packagers and global.
Thank you.
For example, with calling out the internet HTML parts, does that end up being
static linked or is it dynamic linked?
Okay, this is a good question. For that, for the HTML parts,
I believe it's static linked.
Totally possible since you're dynamic linked. I believe if you build concepts
right now, it will, I don't know if it will try to static link GT and stuff like that.
But it will never do same dynamic it's a little bit more complex when it comes
to rust there are like only rust and stuff like that like the HL brush it's not impossible I think,
but it's I think when it comes to rust they're much more it's like statically
linking and it's sort of like bypassing everything you do in the shared linker so,
it's possible to do dynamic linking but you have to sort of be cautious about
it and make sure your dependency is supported and that kind of stuff,
will be able to make it really easy.
I have a question with the get capability. To use Kirigami, is DXX cute enough
or is DXX KDE frameworks required?
You're asking me if Kirigami... Sorry, I don't understand your question.
The example you showed was using Kirigami, right?
Yes. And if I would want to write a Rust application using Kirigami is CXX cute
enough or do I need the CXX KDE framework?
Because Kirigami is a tier 1 framework it doesn't require any other framework,
so CXX KDE is enough But of course, as a KDE developer, I would suggest you use.
But that's also a good thing, because if you want to use Curriculum application,
then you basically are now reaching into this writing and CSS framework, right?
And threading libraries or frameworks we normally care about in ADI.
What's your feeling for that version of Rust in the direction you want to use in ADI?
Sorry, so you're saying my view is about something, Rust is changing something while it's in ADI?
What do you mean by that? More like it evolved.
If I understand correctly, do you think, like, it will start,
if we start using this in production, will, like, will, like,
NDI issues sort of snowball into something greater?
I would say that's probably not.
I feel like that's something we're going to have to go out in the hallway and discuss.
That's also something I'm interested in. And then sort of like,
again, with the packaging, it's something I feel like could be a little bit
more, you know, that's where I want.
It could be a little bit more awkward to it.
But I'm pretty confident it's
a solvable issue. It's just an issue I don't know off the top of my head.
That's also something that I don't know how I should discuss,
I don't, nothing off the top of my head, I'm not sure.
This is also one of those things that we are, I don't think about.
I'm sitting in the hallway right now. That's an interesting question.
I can answer it for you, but I can't just do it right now.
I don't think anything should be a problem in that area.
It's sort of like, do the Python lines have that issue?
I mean, that's sort of the same idea. DR. DR. DR. DR. DR. DR.
DR.