►
From YouTube: Jos van den Oever - Qt GUIs with Rust
Description
Rust Qt Binding Generator
Build a graphical application with Qt and Rust. Qt is a mature GUI library. Rust is a new, exciting and strict programming language. You can build most of your application logic in Rust and write the GUI in QML or Qt Widgets.
This talks will walk through how to do this with Rust Qt Binding Generator.
Jos van den Oever represents the Dutch government on the ODF Technical Committee. He has worked in the Free Software community for over a decade. He created WebODF, an ODF editor for the browser. He is active in the KDE community.
Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_qt_binding_generator/
These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en
A
B
A
B
So
this
is
like
a
logo
which
was
on
the
top
of
the
documentation
of
cute
one
there
about.
So
it's
like
somewhere
in
the
90s,
but
considering
that
combining
worst
and
cute
is
not
so
easy.
I
thought
this
sort
of
man
looking
a
bit
distraught
would
be
a
good
opening
image
for
this
talk,
but
the
good
news
is,
it's
actually
totally
feasible
to
combine
those
two
things
and
the
rest
cute,
binding
generator
will
help
you
with
that.
B
To
start
us
off
well,
a
takeaway
I
think
this
talk
would
be
good
for
for
us
developers
for
cue
developers
for
people
developing
cute,
because
I
think
they
can
learn
enough
a
lot
from
the
worst
language,
but
also
people
who
are
interested
in
writing.
A
native
ques
native
rust,
UI
learning
from
what
cute
has
done
over
the
past
20
years
could
also
be
very
insightful,
so
for
them
I
hope
this
talk
is
also
one
that
has
some
nice
messages.
So
here
are
three
applications.
B
This
is
a
tiny
one
that
I
blogged
a
while
back
and
which
was
also
on
the
west
reddit
as
a
tutorial.
This
is
basically
a
qml
application.
I'll
explain
later
what
qml
is
that
is
powered
by
rust,
and
all
that
was
does
here
is
it
has
a
threat,
and
it
gives
some
seconds
of
every
second
has
an
event,
and
then
this
rust
mogul
rotates
the
rustic
you'd
binding
generator
repository
has
a
demo
application,
which
showcases
all
the
different
styles
of
widgets
you
have
in
cute.
B
So
this
is
just
a
different
styling,
but
you
can
also
use
cute
quick,
which
is
a
type
of
widget.
That
is
very
much
optimized
for
your
graphics
processor
and
we
also
have
cute
quick
controls
too,
which
is
more
in
line
with
what
you
see
on
mobile
devices,
and
all
of
these
things
are
bundled
into
one
application
here,
but
later
on,
in
this
talk
will
mostly
be
talking
about
this
demo
application
we're
going
to
walk
through
how
to
write
code
like
this
to
power,
a
to-do
application
with
rust
and
cute.
So
back
to
the
slides.
B
The
goal
of
this
project
was
to
find
a
way
to
write
programs
that
combine
Q
robust,
but
since
I
was
doing
in
the
server
as
a
hobby,
it
should
be
a
small
effort
to
create
this
tool,
but
when
it's
finished
it
should
also
be
small,
I've
had
to
actually
use
it.
It
should
be
easy
to
combine
these
two
languages,
even
though
C++
arrests
also
very
different.
It
should
be
simple
with
minimal
dependencies,
and
this
is
very
important
to
me.
B
B
Here's
one
that
Linus
Torvalds
helps
coding.
Vlc,
you
all
know
the
KDE
community
is
basically
built
on
cute.
The
the
plasma
desktop
uses
cutes.
You
can
write,
3d
applications
with
cute
and
there
you
have
a
sort
of
state
state
machine
to
steer
everything.
So
it's
a
very
rich,
very
large
set
of
libraries
to
write
your
user
interface
in
and
therefore
it
would
be
great
if
you
could
use
it
with
worst.
B
Also
in
the
embedded
world.
Cute
is
used
a
lot.
Here's
a
picture
from
a
promo
video,
and
you
see
that
they're
pointing
the
cute
logo
to
lots
of
parts
of
the
car,
not
exactly
sure
what
they
mean
by
that.
But
I
think.
The
overall
message
is:
we
have
some
low-power
processors
and
a
display
on
it
and
we
power
it
with
cute.
So
you
can
also
put
it
on
your
fridge
or
on
your
thermostat.
Whatever
there
are
tons
of
bindings
already
for
cute
lots
of
different
languages
and
yeah,
why
do
you
normally
have
bindings?
B
Do
you
want
to
use
a
language
which
is
more
familiar
to
you?
Cute
itself?
Is
written
in
C++
and
maybe
you're
more
familiar
with
one
of
the
languages
on
top
here
or
you
have
a
large
project
and
maybe
all
the
guys
from
the
lots
of
logos
before
existing
projects
are
interested
in
adding
some
rest
into
their
into
their
mix
into
the
projects,
so
you
might
want
to
combine
existing
code
with
it,
and
then
you
also
need
a
library.
B
The
typical
approach
to
do
a
binding
is
to
take
the
cute
C++
base,
build
a
binding
on
top
and
then
put
the
other
language
there,
and
that's
not
the
approach
I'm
going
to
take
here
and
I'll
explain
later
what
we
are
going
to
do.
Well,
I,
guess
you
know
these
advantages
by
heart,
why
it
was
so
cool.
It's
very
safe
one
of
my
favorite
things.
The
first
is
the
algebraic
data
types
also
known
as
simply
the
in
Arms.
That's
something
that
C++
simply
doesn't
have
I.
Think
it's
great,
the
markers
are
very
clever.
B
Cargo
is
great,
but
all
of
these
things
are
not
really
there
in
C++,
at
least
not
in
the
way
that
QED
uses
them.
It's
a
great
library,
but
these
innovations
in
rust
simply
haven't
made
it
into
cutely.
Yet
so,
if
you're
going
to
make
an
API
of
rust
on
top
of
cute,
then
we're
leaving
a
lot
of
advantages
on
the
table.
So
that's
why
I
think
that
wrapping
a
cute
API
in
rust
would
be
like
fitting
a
square
peg
in
a
round
hole.
That's
not
going
to
work,
but
there's
a
solution.
B
What
we
could
do
is
just
shine
a
light
differently
on
it
and
well
here's
the
square
year's
round
great.
We
just
put
some
JSON
in
the
middle,
so
yeah.
How
will
that
work?
Okay,
so
we're
going
to
do
the
binding
in
two
directions.
First,
you're
gonna
write
your
data
model
in
JSON
and
I'll
show
you
later
how
to
do
that
and
then
you
generate
bindings
from
that
and
these
bindings
talk
to
your
user
interface
and
to
us
and
all
the
purple
boxes
here,
stuff
that
you
have
to
write.
B
So
if
you
came
in
here
thinking,
I'm
gonna
write
a
user
interface
only
arrest,
that's
not
what
this
talk
is
about.
You
still
will
have
to
either
use
qml,
which
is
a
very
nice
declarative,
language
or
cute,
which
is
C++
on
top
of
your
worst,
but
the
advantages.
If
you
take
this
approach,
then
you
have
separated
the
logic
of
your
application
very
well,
and
if
you
want,
you
could
also
put
then
a
different
UI
on
top
like
HTML.
B
So
this
is
the
approach
we're
going
to
take
now.
I
need
to
explain
a
bit
about
the
core
principle
of
how
cute
works.
The
basic
thing
in
cute
is
Q
objects,
a
Q
object
is
a
class
and
you
can
give
it
signals
and
slots
and
outside
of
cute
people
call
these
things,
events
and
listeners,
and
so
you
combine
build
a
loosely
coupled
system
and
it's
loosely
coupled.
If
one
of
the
object
is
destroyed,
then
the
connection
is
broken.
It's
the
same
as
what
you
have
in
JavaScript
I.
B
Imagine
so
it
takes
care
of
memory
manager
because
you
have
hierarchical
ownership.
You
just
say
when
you
create
something.
This
is
the
parent
when
you
destroyed
the
whole
hayek
hierarchies,
destroyed
and
objects,
have
properties
now,
there's
another
important
building
block
in
cute
and
that's
the
cue
abstract
item
model
a
long,
complex
name,
but
basically
what
it
is
it's
the
way
data
is
represented
from
your
logic
to
to
the
user
interface
and
it's
used
everywhere.
B
So
here
is
a
table
and
a
graph
and
there's
one
data
model
underneath
which
is
an
implementation
of
this
model,
and
it's
used
in
two
places
in
a
very
different
way,
and
here
you
see
a
table
I'm,
not
sure
if
everybody
in
the
back
and
see
it
here,
but
one
of
the
cells
on
the
table
shows
a
percentage
and
it's
filled
partially
and
that's
also
a
trick.
We
she's
implemented
on
the
UI
level,
but
the
data
underneath
is
provided
by
this
abstract
item
model
and
you
can
also
have
trees.
B
Okay,
so
how
it's
gonna
work,
we
write
a
model
description
in
Jason
and
then
the
tool
would
generate
a
binding
dot,
H
and
a
binding
dot
CPP
file,
which
we
use
in
our
C++
code
and
an
interface
RS,
which
will
contain
a
trait
arrest
rate
which
you
have
to
implement.
And
then
you
compile
your
rest
code
into
a
static
library
which
you
link
to
your
C++
application
and
you
either
import
it
with
binding
dot
H
or,
if
you're,
using
qml
with
import
lost
code.
The
rest
code
is
the
name
you
can
use.
B
Cute
modeling
language:
this
is
a
very
nice
innovation
which
was
triggered
when
Nokia
bought
cute.
They
wanted
to
make
phones
with
very
performant
and
easy
to
write
user
interfaces.
So
what
they
did
is
they
came
up
with
a
declarative
user
interface
language
and
it
can
do
to
the
do
to
deal
programs
or
3d
even
and
it's
used
in
lots
of
mobile
applications.
So
it
started
off
at
Nokia
megaphones,
the
bunch
of
phones
are
using
it
everywhere.
Sailfish
KDE
plasma
desktop
KDE
plasma
mobile,
and
you
can
also
use
it
for
iOS
and
Android
apps.
B
Okay.
So
now
we're
going
to
write
a
small
application,
so
you
understand
a
bit
more
of
how
all
of
this
works
together.
This
is
a
to
do
application
and
this
application
there
is
a
website
called
to
do.
Mvc
comm,
where
the
same
specification
is
implemented
in
like
20
or
30
different
JavaScript
frameworks
and
I
took
that
specification
and
implemented
this
with
qml
arrests.
Just
because
I
didn't
really
know
what
I
should
write.
I
thought:
well,
here's
a
specification
already
given:
let's
just
implement
that
and
I
can
look
at
application
here
a
bit.
B
So
what
else
should
I
need
to
do?
Well?
Keep
talking,
I,
guess
and
you
can
tick
off
stuff
here
and
you
can
just
see
the
active
parts
or
only
the
completed
ones.
I
can
come
clear.
The
stuff
that's
completed,
go
back
to
all.
I
can
toggle
here
everything,
so
it
has
some
basic
functionality,
and
this
is
the
UI
part
of
this
is
about
150
lines
of
code
and
the
model
beneath
is
is
fairly
simple.
So
if
you
want
to
build
this,
how
do
we
start?
First?
B
B
B
B
Okay,
let's
checked
off
now
we
need
to
run
the
generator.
So
that's
just
one
executable,
you
call
it
with
the
file-
and
this
is
set
up
like
this,
so
that
you
can
integrate
it
at
sea,
make
over
its
cargo
and
build
RS,
and
this
generates.
So
these
three
files
that
I
mentioned
and
then
what
I
need
to
do
is
I
need
to
write
an
implementation,
dot
RS,
which
is
a
rest
file.
B
B
It
has
a
constructor,
a
destructor,
it
declares
and
properties,
and
it
declares
also
some
functions
for
setting
and
getting
the
values.
So
this
is
fairly
simple
and
there's
an
implementation
along
with
it.
So
here
is
the
foreign
function
interface
that
talks
to
us,
so
these
functions
are
declared
in
the
C++
part
and
should
be
implemented
by
rusts.
You
also
won't
have
to
do
this,
but
this
is
the
point
where
the
two
languages
meet
where
they
connect
up-
and
here
is
a
bit
of
example,
code,
which
is
typical
for
this
data
model.
B
You
have
the
class
and
as
a
function
data
you
give
it
an
index
and
a
world
and
the
role
can
be
I
would
like
to
have
a
display
or
a
color
or
in
our
case
the
description
or
if
it's
completed
or
not,
that
can
also
be
your
world
and
then
here's
this
big
switch
statement
which
calls
into
the
worst
code.
So
it
calls
to
rust
and
asks
get
me
the
completed
version
for
this
index
or
the
description
for
this
index
and
again
all
of
this
is
generated.
So
you
don't
have
to
worry
about
it.
B
But
how
does
it
look
on
the
rough
side?
Well,
on
the
west
side,
we
have
a
trait
called
the
tool
to
deuce
trait
and
it
has
a
constructor
which
you
need
to
implement
and
it
has
an
emitter.
The
emitter
is
there
so
that
you
can
emit
signals
when
something
has
changed.
So
you
can
signal
to
the
user
interface
that
something
has
changed.
B
So
2
items
left,
and
this
is
the
work
that
you
will
have
to
do
when
you
write
connection
when
you
write
an
application
with
rust
and
cute,
so
we
need
to
implement
the
rust
part
and
the
cute
part
so
hurt
the
rust
part.
We
are
implementing
a
list.
The
list
has
items,
so
we
just
have
a
struct
with
a
boolean
and
a
string
so
far
so
good,
and
then
we
have
the
object
that
contains
the
whole
list
of
these
items,
and
it
also
contains
a
account
of
how
many
items
have
not
been
finished.
B
So
the
how
now
we
implement
implement
the
trade-
and
this
is
also
fairly
simple-
we
need
to
get
the
value
for
the
active
count
and
we
just
return
the
value
also
for
the
total
count.
We
just
return
the
the
length
of
the
list
and
when
we
want
to
know
the
description
at
a
certain
index,
we
just
give
back
that
value.
So
this
is
quite
straightforward
and
simple,
and
this
is
the
part
which
you
will
have
to
implement
when
you
are.
Writing
a
connection
between
wealth
and
cubes.
B
So
how
do
we
do
the
last
bit
of
it
and
that's
the
qml
part?
In
our
case,
we
have
created
this
object
and
this
object.
We
want
to
expose
to
this
rust
code
to
this
cute
code,
so
we
import
the
rust
code.
We
have
called
version
1.
Well,
you
can
give
it
any
number.
You
like
the
application
window
is
basically
something
between
brackets
here.
B
So
this
is
qml
if
in
case,
you've
never
seen
it
it's
a
very
fairly
simple
language,
and
here
we
have
our
object,
so
object
here
is
what
we
have
implemented
with
rust
and
we
give
it
an
ID.
So
all
of
our
to-do
information
is
in
this
object
and
we
put
it
here-
it's
not
a
graphical
thing,
but
we
we
put
it
here
so
that
we
can
access
it
from
our
graphical
interface
and
our
main
graphical
interface
is
below
here.
That
is
applicable
list
view
and
it
has
a
model.
B
The
model
is
the
to
do
model
which
we
have
defined
here
and
we
have
a
delegate
and
the
delegate
is
the
UI
item
that
we
show
for
every
item
in
the
list
and
that's
defined
here.
So
it's
a
component
and
it
has
a
pain
and
it
has
a
checkbox.
The
checkbox
is
the
checkbox
checked
or
not
it's
a
declarative
language.
It
is
checked
if
the
value
of
completed
is
true,
so
this
is
the
information
which
is
gotten
from
the
rust
side,
and
this
description
is
also
gotten
from
the
website.
B
B
So,
in
conclusion,
if
you
want
to
combine
rust
and
cute,
you
should
not,
in
my
opinion
at
least
shoehorn
the
whole
of
cute
into
a
REST
API,
but
instead
you
should
wrap
your
rust
code
in
a
cue
object
or
acute
abstract
item
model,
which
you
can
then
naturally
use
in
your
cute
or
qml
application,
and
by
doing
that-
and
you
don't
actually
have
to
do
it
yourself,
because
the
prosecute
binding
generator
does
it
for
you.
You
get
good
cute
code
and
good
westco's.
B
A
B
Okay,
so
the
question
is:
how
do
you
deal
with
different
threats,
because
cute
must
have
a
user
interface
threat?
Well,
it
does
if
you
have
a
cute
application,
the
main
threat,
the
threat
that
you
start
is
the
cute
threat,
and
if
you
want
additional
threats
in
your
rest
code,
you
will
simply
start
when
you
construct
your
object.
You
start
a
separate
threat
and
that
is
then
alive
as
long
as
your
object
is
kept
alive
by
your
cute
code,
so
you
can
do
any
type
of
number
of
threats
you
can.
B
You
can
keep
the
running
and
the
signals
you
send
to
the
user
interface.
Those
are
threat
safe,
but
you
don't
have
to
worry
about
that.
It's
automatically
taken
care
of
what
you
need
to
know
is
that
in
rust
you
can
just
start
as
many
sets
as
you
want
in
the
object
that
is
generated
for
you.
So
in
your
implementation,
dot
RS,
you
can
go
wild
with
the
threats
you
want.
B
B
B
All
you
need
to
do
is
call
this
binary
to
generate
the
code
for
you,
and
we
have
some
templates
that
have
C
make
which
call
into
cargo.
But
if
you
don't
like
that,
if
you
would
like
to
put
everything
in
cargo
you're
free
to
do
that,
but
this
project
doesn't
currently
do
it,
but
it's
a
matter
of
just
calling
calling
that
in
in
build
RS
in
cargo
yeah,
so
it's
not
in
the
box,
but
you
can
do
it.
B
B
Yeah,
the
question
is:
how
do
you
do
asynchronous
work
like
with
hyper,
for
example,
or
other
Tokyo
things
that
works
exactly
perfectly
fine?
What
you
do
is
you
your
implementation,
those
RS.
You
set
up
your
hyper
or
tokyo
loop,
and
that
is
running
in
your
rust
threat
then,
which
you
sit,
which
you
create
yourself
and
there
you
you
set
up
everything
for
asynchronous
IO
and
Q.
It
is
not
involved
at
all.
Whenever
you
get
asynchronous
information,
you
can
decide
if
it
wants
a
signal
to
the
user
interface
and
then
the
user
interface
is
updated.
B
B
B
They're
initiating
the
qml
scene-
yes,
okay,
so
the
question
is:
how
did
you
create
the
qml
scene
and
how
did
you
tie
the
the
rough
stuff
into
qml?
That
was
a
10
line,
c++
file,
which
I
write
I
didn't
show,
but
it's
mainly
always
the
same.
You
initiate
your
qml
scene,
you
instantiate
you!
Sorry,
you
you!
You
register
your
rust
object
into
the
UML
scene
and
you're
done
it's
off
to
the
races
yeah,
but
it's
always
the
same.
So
you
can
copy
the
file
from
a
template.
Yeah.
A
B
A
B
B
Right
yeah,
the
question
again
is:
how
do
you
register
the
the
rust
cute
objects
to
the
qml
and
can
I
do
it
live
as
well?
The
answer
is
the
same.
You
do
what
you
normally
do
on
the
C++
site.
Is
you
have
a
cue
object?
You
instantiate
it
and
you
register
it
to
the
qml
scene
and
yes,
I
am
pretty
sure
you
can
do
it
life,
although
I
don't
have
an
example
which
does
that,
yes,.
B
A
B
B
In
fact,
all
the
demo
codes
and
the
testing
code,
which
is
in
the
project
which
is
generated,
is
also
committed
so
that
whenever
I
change,
the
generator
to
that
I
have
a
sort
of
testing
that
the
code
is
still
the
same,
and
if
I
would
have
done
it
way
to
derive,
then
it
would
be
only
there
during
the
compile
step
and
it
would
a
bit
I
would
need
to
do
some
different
things
to
actually
check,
but
it's
perfectly
possible.
Yes,
yes,
oh
yeah,
that's
fine,
yep.