►
From YouTube: Rust, WebAssembly, and Browser Games - Justin Worthe
Description
Say you're writing a computer game. For argument sake, you've decided not to take the easy (and much more efficient) route of using an existing game engine like Unreal or Unity. No, you've decided to write your own game engine.
Unfortunately, when choosing a programming language, you've run into a conflict! When you finally ship your game, you want to take advantage of all the high performance of running a native application. A language like Rust is an excellent fit for this. On the other hand, it will be much easier to share your game if you were to write it with web technologies and embed it in a web page, so maybe you should be writing it in JavaScript?
One way to reconcile this conflict is by using WebAssembly. In this talk, you'll see how it's done in an example of a game written in the Rust programming language, running both natively and embedded in a web browser.
You can find more of Justin at https://www.worthe-it.co.za
This talk was recorded at the Jozi.JS meetup group on 19 July 2018.
https://www.meetup.com/Jozi-JS/events/249460508/
Disclaimer: The opinions in this talk are those of the individual and do not necessarily represent those of this channel, the meetup group, or it’s sponsors.
A
A
This
is
real.
Superb
work
in
progress.
You
know
nothing's
automated
the
cursor
is
sort
of
temporary,
but
that's
the
problem
with
desktop
applications.
Wrong
with
us
is
that
it's
really
difficult
for
me
to
take
it
and
share
it
with
people
I
mean
you
can
say,
hey
and
install
this
thing
there
on
a
flash
drive,
I
promise,
it's
not
malicious,
but
like
the
really
easy
way
to
share
things.
A
The
way
they've
been
sharing
games
on
the
web
pages
is
here's
this
link
and
you
go
there
and
Tricia
need
opened
up
like
flash
or
something
but
right,
but
there's
newer
ways,
and
so
what
I've
also
got
running
in
the
background,
then
we
close
this
and
just
to
show
my
hypocrisy.
The
presentation
is
actually
in
the
web.
Browser
as
well
is.
This
is
exactly
the
same
game
from
the
same
codebase
building
to
run
in
a
web
browser,
instead
of
as
a
native
desktop
application.
A
That's
what
I'm
getting
at
the
end
condition.
So,
of
course,
out
of
the
way
the
thing
that's
the
beginning,
I
told
you
that
this
was
a
rust
game.
What
is
rust
rust
is
a
programming
language
meant
to
be
a
drop-in
replacement
for
C
and
C++,
because
we're
not
really
sure
if
anyone
wants
to
work
in
C
and
C++
anymore,
because
languages
have
a
lot
of
foot
guns
which
is
features
that
make
it
easy
to
shoot
yourself
in
the
foot
and
they
still
have
their
place.
A
Though
you
want
something
that
can
compile
and
end
up
with
what
C++
calls
a
zero
cost.
Abstractions,
where
you
don't
pay
a
runtime
cost
for
your
higher-level
language
features,
and
you
can
take
it
and
throw
it
on
a
microcontroller
or
you
can
get
all
the
performance
benefits
that
you'd
need
to
write
a
high-end
game.
Engine
and
rust
gives
you
those
benefits
and
high
level
things,
but
it's
got
a
very
smart
compiler,
so
it
picks
up
things
like
the
possibility
of
race
conditions
by
being
very
strict
about
what
is
mutable
data.
A
A
So
what
happens
we
want
to
put
this
on
the
web
with
webassembly,
as
you
saw,
got
a
rest,
goes
through
same
compiler
and
instead
of
putting
up
like
an
exe
or
other
type
of
executable,
it's
the
stuff
wasm
file.
So
what
is
what
is
this
way?
The
same
thing?
It's
an
assembly
target
for
the
web,
there's
actually
a
great
name
for
what
it
is.
A
I,
don't
know
how
many
people
here
remember
that
point
where
Scott
Hanselman
was
saying
that
JavaScript
is
the
assembly
language
of
the
web
and
all
these
things
can
compile
to
JavaScript
and
they
were
like.
Maybe
JavaScript,
isn't
the
best
thing
to
compile
to
it's,
not
a
great
compiler
we're,
but
simply
is
the
good
compiled
target
that
comes
out
of
that
sort
of
line
of
thinking.
You
take
your
other
languages,
you
pass
them
through
a
compiler,
you
get
out
web
assembly
and
that
plays
well
alongside
your
JavaScript.
A
Alongside
your
CSS
and
your
HTML
that
game
that's
a
full
screen,
HTML
canvas,
it's
got
some
WebGL
going,
it's
actually
the
next
slide
WebGL
and
it's
the
same
code,
but
it's
the
JavaScript
managing
this
little
sandbox.
That
is
the
way
the
same
theme
and
something
really
cool
about
WebGL,
no
stay,
because
it's
actually
just
OpenGL.
It's
pretending
to
be
a
different
thing
as
a
specific
version
of
OpenGL.
A
Then
in
JavaScript,
things
like
forcing
the
compilers
are
actually
in
line
this
function
and
eagerly
computes
things,
and
they
made
it
something
like
five
times
faster
by
changing
it
to
know
where
the
same
buddy
code
and
then
some
Google
engineer
that
works
on
the
JavaScript
compiler
came
and
said.
No.
This
is
nonsense.
You
can
have
obviously
do
all
of
this
in
JavaScript
and
he
wrote
the
most
amazing
JavaScript
that
nobody
could
read
like
Springs
and
but
it
it
did
actually
meet
the
same
performance.
A
Yeah,
so
I
want
to
get
into
some
of
the
differences
between
like
the
desktop
games
and
the
web
games
and
like
the
first
difference.
One
point
out
is
that
web
pages
hate
infinite
loops,
and
you
probably
have
seen
this
before
where
it's
is.
The
script
isn't
responding.
It's
making
this
web
page,
slow
and
I
think
Mercer
handles
it
a
bit
better.
Now,
where
it's
like
this
little
red
thing
at
the
top,
rather
than
a
massive
pop-up
in
the
middle
of
the
screen.
That'll
stop
you
from
doing
anything,
but
you
know
the
traditional
desktop
one.
A
Is
you
bootstrapping
you've
got
an
infinite
game.
You
know
check
what
the
user
has
done
and
then
update
the
game
state
and
then
render
stuff
to
the
screen
the
way
of
assembly
route.
You
have
to
follow
the
desktop
version.
Those
JavaScript
is
all
single
thread.
Is
everything
in
the
way
the
same
of
these
eyelets
single
threaded?
Do
you
have
to
cede
control?
A
You
ask
the
web
browser
in
a
request,
animation
frame
its
function,
call
and
you
give
it
a
callback
and
use
that
to
call
into
your
thing,
and
you
need
to
do
that
on
every
frame.
Otherwise,
everything
stops
working
and
it
completes.
The
other
thing
is
not
to
forget
loading
time.
I,
don't
actually
have
a
loading
bar
on
that
little
game
then,
but
found
that
your
performance
characteristics
of
just
loading
a
file
are
quite
different
if
they're
on
your
hard
drive
already
versus
if
you're
getting
them
off
the
internet.
A
All
right,
I
was,
we
have
assembly
thing
it's
actually
available
now
the
version
1.0
which
they
call
the
Minimum
Viable
Product
version.
It's
everything
you
need
to
sort
of
go,
but
it
doesn't
have
things
like
multi-threading.
It
doesn't
have
sim
D,
which
means
some
of
the
tricks
that
you'd
use
to
have
high-performance
code
in
rust,
like
just
making
it
multi-threaded,
which
is
much
easier
in
rust
than
it
is
in
C++
because
of
the
whole
immutable
state,
avoiding
rape,
race
conditions
thing.
You
can't
do
that
with
web
assembly
you're
going
to
be
single
threaded.
A
There
are
plans,
you
know
future
release
to
add
these
things,
but
yeah
for
right.
Now
you
can't
target
that
you
have
to
work
the
single
thread.
One
garbage
collection
is
something
about
planning.
I,
think
the
JavaScript
is
a
garbage
collected
language,
but
the
web
assembly
doesn't
actually
expose
that.
So,
if
you
want
to
take
a
garbage
collected
language
like
C,
sharp
and
people
have
done
this,
they
call
it
experimental.
You
compile
the
entire
runtime,
including
the
c-sharp
garbage
collector,
to
webassembly.
A
I
said
yo
the
language
sport
is
growing,
the
sort
of
premier
languages,
you
know,
C
C++
and
rust
rust
actually
comes
out
of
a
Mozilla
project
and
is
highly
funded
by
Mozilla.
So
they're
pushing
the
way
by
saying
anything,
really
hard
and
I'm,
adding
things
like
trying
to
make
it
seamless
to
take
a
rust
project,
compile
to
web
assembly
and
upload
to
NPM,
and
so
so,
maybe
one
day
I'll
be
able
to
write
front-end
code.
That
is
actually
just
rust,
and
nobody
will
know
that.
I'm
not
writing.
Java
scripts
got
other
languages.
A
A
It's
just
the
api's
might
change
yeah,
that's
a
the
tooling
is
changing.
Best
approaches
are
evolving.
If
you
listen
to
my
dev
talk
a
while
back.
I
talked
about
this
crazy
way
that
you
needed
to
call
stuff
in
grab
assembly
by
first
creating
a
pointer
with
a
reference
to
memory
and
the
web
assembly
space
and
then
from
JavaScript
passed
the
pointer
through,
and
it
was
probably
fine
and
the
new
approach
is
that
there's
a
tool
that
generates
that
boilerplate?
A
So
you
don't
have
to
look
at
it
because
it's
scary
stuff,
so
the
best
approaches
are
being
established.
Sometimes
the
tools
are
a
little
unstable,
but
it's
a
good
place
to
be
and
I
think
it's
on
the
right
track.
It's
a
good
time
to
sort
of
take
a
look
and
we'll
run
in
all
major
browsers,
which
is
a
lot
of
fun,
and
so
that's
that's
what
I
have
here
today.
Does
anyone
have
any
questions
about
webassembly
or
rust.