►
Description
CGI is back! The experimental WAGI project allows you to write HTTP handlers as WebAssembly binaries. And the best thing: You don't need any libraries for it.
Stefan and Rainer experimented with WAGI. They would like to present a brief intro to this project consisting of some architectural background and Rust sample code.
About Stefan Baumgartner and Rainer Stropek
Stefan and Rainer are the founders and moderators of the Rust Linz meetup. Both have many years of practical experience in full-stack development and cloud computing.
Material, links, and slides: https://fettblog.eu/slides/introduction-to-wagi/
Thanks to Microsoft for their support!
Rust Linz:
https://rust-linz.at
https://sessionize.com/rust-linz
https://twitter.com/rustlinz
A
A
Let
me
get
on
my
notes
alrighty,
so
this
is
a
little
impromptu
talk.
So
over
the
weekend,
we
we
asked
around
for
for
a
second
speaker,
second
group
for
our
meetup,
and
we
decided
in
the
end
since,
since
we
found
nobody
that
we
have
a
little
topic
up,
our
sleeves
that
we
want
to
present
to
you,
which
is
an
introduction
to
waki
or
marci
or
the
web
assembly
gateway
interface
and
what
it
means.
A
I'm
coming
to
that
in
a
couple
of
minutes
and
ryan,
and
I
picked
up,
I
created
some
slides
reina
created
a
ton
of
great
examples,
so
I
already
looked
through
the
repo,
and
this
is
fantastic,
so
there's
lots
of
good
stuff
in
there,
but
before
we
give
you
an
introduction
to
to
wagy,
I
want
to
create
some
some
context
why
we
are
having
a
tool
like
that.
What's
the
deal
behind
it-
and
I
want
to
open
with
this-
I
guess
now
famous
quote
by
solomon
hikes.
A
If
you
don't
know
about
solomon
hacks,
he
is
the
creator
of
docker
in
a
couple
of
years.
He
said
a
couple
of
years
ago.
He
said
that
if
wasm
webassembly
and
wazi
web
assembly
systems
interface
had
already
existed
back
in
the
day
when
he
created
docker,
he
wouldn't
have
had
the
need
to
create
docker.
Those
are
some
some
big
words
and
everybody
wondered
what
do
they
mean?
Why?
Why
is
he
tweeting
something
like
that?
A
So
for
you
who
don't
know,
a
webassembly
is
a
binary
instruction
format
for
a
stack-based
virtual
machine
machine.
It
has
been
designed
first
for
the
browser,
but
it's
actually
intended
for
much
much
more.
This
is
what
we're
going
to
look
on
today.
We
are
going
to
look
about
webassembly
outside
the
browser.
A
Why
it's
a
good
fit
for
outside
the
browser
is
because
there
are
two
very
important
principles
baked
into
web
assembly.
The
first
one
is
that
web
assembly
is
an
assembly
language
for
a
conceptual
machine.
This
means
that
it
needs
a
runtime
and
this
random
can
across
a
variety
of
different
machine
architectures.
A
This
makes
webassembly
programs
incredibly
portable,
and
this
is
something
that
we
see
already
so.
Wesm
is
available
in
all
major
browsers.
This
is
this
is
peak
portability
and
the
other
one,
since
it's
available
in
all
available
browsers,
web
assembly
needs
to
be
really
really
well
sandboxed
code
that
runs
in
the
web
assembly
vm
is
not
allowed
to
talk
directly
to
anything
on
the
operating
system.
The
host
needs
to
provide
functions
to
access
operating
system
capabilities,
and
those
exceptions
need
to
be
made
explicit
and
trust
is
web
assembly
is
a
language
for
a
conceptual
machine.
A
A
What
the
webassembly
systems
interface
allows
us
is
to
access
stuff
in
the
real
world
from
our
wasm
code,
like
files,
sockets
io,
all
that
good
stuff.
That
makes
software
really
really
fun,
and
this
allows
us
to
run
web
assembly
outside
the
browser.
So
instead
of
compiling
our
software
down
to
different
operating
specific
targets
and
run
them
on
the
system,
interface
of
the
respective
operating
systems,
we
compile
it
to
wesen,
run
it
in
a
web
assembly.
Runtime
that
has
access
to
operating
system
specifics.
A
This
is
from
an
article
by
link
clark
on
mozilla.org,
which
is
a
great
introduction
to
the
entire
web
assembly
system
interface
topic,
which
I
can
highly
recommend.
Also
I'm
going
to
link
that
after
the
show,
so
some
really
quick
code
on
how
this
looks
like
this
is,
if
you
will,
the
the
hello
world
of
wazi
and
what
you
see
here
is
some
some
rust
code.
A
So
this
is
all
it
does,
and
this
would
work
totally
fine
if
you
compile
it
down
to
a
binary
on
your
respective
architecture.
You
run
it
and
as
long
as
your
unix
linux,
rights
or
windows
writes
are
correct,
you
can
access
the
files
and
put
them
out,
but
if
you
run
it,
if
you
compile
it
down
to
westminst32.
A
And
run
it
with
a
web
assembly
runtime,
it
will
amp,
do
it
where's
the
animation
here
it
is,
it
will
error-
and
this
is
great
because
this
is
pure
isolation.
The
web
assembly
random,
has
no
access
to
anything
outside
until
we
give
it
access
to,
for
example,
a
lyrics
folder,
and
then
you
can
find
stuff.
Then
you
can
load
files
and
this
happens
via
the
system's
interface.
It
doesn't
seem
like
much,
but
this
is
exactly
the
kind
of
isolation
that
solomon
hacks
was
referring
to.
So
you
have
to
explicitly
open
ports.
A
Everybody
did
that
with
the
best
intentions
like
oh.
If
the
script
doesn't
run
777,
then
it
should
work.
Of
course
it
did,
but
there
were
also
some
implications
and
that's
right.
I'm
talking
about
cgi
the
common
gateway
interface,
the
most
used
technology
back
then,
to
execute
some
code
on
the
backend
still
used
today.
So
if
you
run
some
php,
you
have
to
have
some
cgi,
because
the
principle
is
still
the
same.
A
It
looks
like
that
it's
meant
for
http
requests
that
come
to
a
server.
The
server
is
cj
capable
and
based
on
the
request
can
execute
the
cgi
script
quote
unquote
over
the
cgi
gateway
back
in
the
90s.
They
were
mostly
written
in
perl
php,
but
there
has
been
also
some
cnc
plus
programs
that
have
that
are
executed
like
that,
and
this
means
this
is
really
an
execution.
This
is
an
invocation,
so
you
kick
of
the
software.
The
software
writes
on
standard
out
and
what
you
read
from
standard
out.
A
A
Every
time
a
request
hits
this
process
gets,
kicked
off
on
you,
and-
and
this
should
remind
you
of
something.
So
if
you
squint
a
little,
if
you
look
a
little
closer,
that's
that's
like
serverless
apps.
This
is
yeah,
there's
some
nuances
like
how
runtimes
are
bootstrapped
and
if
you
have
a
warm
container
and
how
you
send
responses,
but
the
main
concept
and
the
main
idea
behind
that
is
roughly
the
same.
A
A
request
triggers
a
fresh
invocation
and
with
cgi
we
have
the
problem
that
we
have
insufficient
isolation
with
serverless
f's.
We
have
really
really
good
isolation,
but
they
come
with
this
random
thing
and
lots
of
implications
on
top
of
it,
and
this
is
where
we
can
rely
on
vagi
the
weber's
implicatory
interface,
so.
A
This
is
a
hello
world
in
baji.
I
don't
want
to
bother
you
too
long,
because
rhino
is
going
to
to
give
you
a
ton
of
examples
there.
But
one
thing
that
is
important
here
are
those
three
print
lines
I
want
to.
I
want
to
focus
a
little
bit
on
them
just
for
a
second,
the
first
line.
We
are
defining
a
content
type
to
explain.
Then
we
have
an
empty
line
and
then
we
are
writing
hello
world.
This
is
http
http1.
A
A
This
is
this
is
an
undeniable
beauty
here,
because
this
line
here
this
line
break
the
notes
when
the
header
ends
and
the
body
starts
when
you
basically
are
done
with
all
the
head
information
from
your
response
and
then
you
can
start
with
the
actual
body,
and
this
is
a
sample
configuration
from
a
modules
file,
but
I
don't
want
to
go
into
detail
here.
This
is
what
we're
going
to
see
right
now,
I'm
going
to
stop
sharing
and
hand
it
over
to
johanna.
B
B
I
split
them
up
into
levels,
so
we
have
level
one
until
level,
four
with
raising
complexity,
and
I
will
try
to
show
you
all
of
the
things
that
stefan
just
told
you
with
live
live
code.
Of
course
I
will
not
type
everything
because
I'm
too
slow
in
typing
and
it
would
be
too
much
code,
so
I
will
copy
in
some
stuff,
but
I
will
definitely
make
sure
that
you
can
follow
and
that
you
understand
all
the
things
that
are
going
on.
B
One
note
at
the
beginning,
all
the
stuff
that
I'm
going
to
show
you
is
experimental,
so
things
can
break
things
will
break
and
I
will
mess
up
with
a
very
high
degree
of
likelihood.
So
please
bear
with
me.
Maybe
we
will
have
to
do
some
bug
fixing
and
I
hope
that
stefan,
you
will
look
at
my
fingers
and
point
out
when
I
do
something
wrong.
So
let's
get
started
with
this
one,
so
the
first
thing
that
I
would
like
to
show
you
is
this
one.
B
So
if
you
are
interested
in
the
code,
this
is
the
code,
and
maybe
stefan,
if
you
have
a
minute
or
so
maybe
you
can
copy
out
this
banner
and
put
it
into
the
comments
so
that
people
can
take
a
look
at
my
code
because
I'm
using
a
ton
of
features
and
tools
in
this
demo-
and
you
might
want
to
have
some
links
here
and
I
gathered
everything
in
this
github
repository.
That
was
the
first
thing
that
I
wanted
to
show
you
and
then
let's
get
going
so
here
we
are.
B
I
created
a
brand
new
folder
here
in
my
visual
visual
studio
code
and
we
will
go
to.
We
are
going
to
to
start
start
with
a
brand
new
application.
Let's
call
it
level
one,
because
this
is
what
we
are
going
to
do
level
one
and
let's
copy
in
some
code
that
I
have
prepared.
This
code
is
not
particularly
complex.
It's
exactly
that
one,
and
this
is
the
code
that
you
saw
from
stefan.
It's
really.
B
Let
me
show
you
the
cargo
tunnel
file
without
any
libraries,
so
I'm
not
using
any
fancy
libraries
to
build
a
web
application,
I'm
just
printing
out
stuff
on
standard
out,
as
you
can
see
it
here
and
believe
it
or
not.
Stefan
told
you,
that's
a
that's
a
web
application,
that's
really
a
web
application
and
we
will
try
it
immediately.
B
First,
let's
create
some
some
housekeeping
stuff,
the
cargo
karma
file
that
we
need
in
order
to
create
a
workspace
and
let
cargo
know
that
there
is
a
project
called
level
one
and
we
will
add
additional
levels
later
on
now.
The
next
thing
that
I
am
going
to
need
is
this
file.
Here,
it's
just
an
environment
file.
We
will
need
that
one
later
on
when
we
run
wasm
and
we
have
some
errors,
we
want
to
have
some
beautiful
stack,
traces
and
this
environment
variable
makes
sure
that
we
get
some
stack
traces.
B
B
I
don't
know
if
you
know
it
already,
if
you
haven't
stay
tuned,
just
is
like
make,
but
in
a
modern
way,
if
you
would
like
to
put
it
that
way,
and
let
me
show
you
how
you
use
it,
I'm
going
to
create
a
just
file.
This
is
my
just
file
and
I
have
prepared
this
just
file.
Let
me
put
it
here.
First
thing:
I
am
reading
the
dot
n
file
to
get
all
the
environment
variables
for
all
my
commands,
and
then
I
can
define
commands
here.
B
You
see
it
run
native
and
build,
and
then
you
can
just
enter
some
shell
commands
like
that.
So
here
you
see,
I
created
a
run
native
and
a
build
script.
So
now
I
can
say
just
build
level
one
and
it
will
build
everything
for
me
and
I
can
say
just
run
native
level
one
and
it
will
run
cargo
run
for
me
and
here
down
here
you
see
the
response
on
standard
out,
so
I
just
tried
my
example
and
it
worked
granted
just
for
this
simple
cargo
run
in
cargo
build.
B
I
wouldn't
need
my
just
file,
but
believe
me,
it
will
come
in
handy
later
on
when
we
have
to
do
some
more
complicated,
cli,
stuff
yeah,
but
I
really
like
to
use
this
this
tool
just
file,
it's
linked
in
the
repository.
So
if
you
like
the
tool,
take
a
look
at
it,
it's
in
my
repo
okay,
we
ran
it.
We
ran
it
traditionally,
as
we
are
used
to
so
now.
I
would
like
to
run
it
as
a
real
web
application
with
with
yg.
So
let's
create
a
new
file
and
I
call
it
wrong
folder.
B
Sorry,
I
have
to
create
it
here.
I
will
call
it
modules.commall.
This
is
how
it
has
to
be
called,
and
here
I
can
specify
the
different
body
modules
that
I
have
in
my
application.
As
you
can
see,
I'm
here
referencing
a
folder
in
the
target
folder.
I
have
not
created
this
wasn't
file,
yet
we
will
need
to
compile
our
code
with
the
target.
Wasn't
32w.
B
We
will
do
that
in
a
second,
but
this
fi
this
this.
This
config
here
tells
waji
that
in
this
wasm
file
I
have
my
gateway
interface
and
it
should
listen
to
this
route.
So
when
I
run
the
yg
server
it
will
handle
all
incoming
http
requests
on
this
route.
It
will
spin
up
my
application.
Take
what
I
print
on
standard
out
and
return
that
why
an
http
response.
B
So
let's
try
that
for
that
we
will
add
a
little
bit
of
magic
to
our
just
file
and
I
will
walk
you
through
that
one
okay.
So,
let's
let
me
show
you
what
I
do
here
now.
First,
build
is
still
the
same,
but
this
time
I
add
an
optional
target
and
you
see
when
I
call
just
run
it
will
build
my
sample
code
with
this
target.
So
I
will,
I
will
compile
my
rust
code
into
webassembly
and
then
I
will
not
call
cargo
run,
but
I
will
call
the
vargi
server.
B
B
We
will
see
another
thing
that
I
like
very
much
is
combining
that
one
with
watch
exec
another
beautiful
tool
from
the
rust
universe,
watch,
exec,
watches
for
changes
in
files
with
the
extension
rs
and
in
this
case
I'm
watching
for
changes
in
rs
files
in
the
sample
that
I'm
just
running
and
when
something
changes
it
calls
just
run
down
here
you
see
the
run
and
it
will
recompile
everything
and
restart
my
watchy
handler.
So
that
feels
really
nice
as
I'm
used
to
do
it
as
a
web
developer.
B
I
just
type
in
some
code,
I
put
the
hands
away
from
the
keyboard.
The
rust
compiler
will
compile
everything
to
wasm,
it
will
restart
the
wagy
web
server
and
I
can
immediately
hit
refresh
in
my
browser.
So
this
is
the
kind
of
workload
that
I
want
to
build
here.
Okay,
so
first,
let's
run
it
and
then
let's
watch
it
okay,
so
let's
clean
up
here
and
say
just
run
level
one.
This
will
now
run
in
the
vagi
web
server.
As
you
can
see
it
here
and
then
let
me
bring
up
a
browser
window.
B
I
simply
have
to
copy
it
here
and
here
it
is
and
as
you
can
see
it,
this
is
exactly
what
we
want
to
have
see.
This
is
pong.
So
if
I
show
you
this
is
exactly
what
I'm
printing
here.
So
with
just
a
few
lines
of
code,
I
was
able
to
build
a
web
server
and
of
course,
now
we
can
do
a
little
bit
more
web
swept
web
like
development.
If
we
say
just
watch
level
one.
B
I
can
moody
this
one
and
put
this
one
here
on
the
left
hand,
side
and
the
browser
here
on
the
right
hand,
side,
and
I
can
rerun
it.
It
still
says
pong
and
then
let's
change
it
pong
on
something
like
this,
and
if
I
do
nothing,
you
see,
the
browser
is
automatically
no.
The
server
is
automatically
reloaded.
I
can
reload
it
here
and
everything
works
as
expected.
Let's
put
it
back,
it
will
rebuild
everything
I
can
refresh
it
everything's
fine
and
don't
worry
if
you
are
a
web
developer.
B
Like
me,
I
would
even
complain
that
I
have
to
press
reload
here
in
the
browser.
Wouldn't
it
be
possible
to
magically
link
up
my
rust
code
through
some
kind
of
browser,
synchronization
mechanism,
so
that
everything
is
reloaded
on
all
my
test
devices
that
is
possible,
and
I
will
show
you
that
in
I
think
level,
two
something
like
this
okay,
so
you
see
we
have
some
beautiful
thing
going
on.
B
B
Now
I
would
go
to
level
one
with
a
little
bit
different,
a
little
bit
different
flavor.
Let's
put
it
that
way.
Let
me
surprise
you
first,
let's
pump
up
our
just
file
and
you
might
already
recognize
what
I
do
here.
So
what
I've
prepared
for
this
talk?
Is
I've
created
a
docker
registry,
in
this
case
it's
the
azure
docker
registry,
so
it's
a
docker
registry
created
in
microsoft
in
the
microsoft
azure
cloud,
it's
a
standard
conform
registry
and
I
could
use
it
to
push
darker
image
containers
there.
B
Docker
container
images
there
so
just
a
regular
container
registry,
but
now
today
I
would
like
to
try
to
put
webassembly
there
and
use
the
vagi
web
server
to
directly
pull
webassembly
modules,
http
handler,
pull
it
from
the
container
registry
onto
my
machine
and
run
it
as
part
of
my
local
wagy
server.
This
is
what
I
would
like
to
try.
B
Okay
well
first,
I
want
to
take
what
I've
compiled
before
and
show
you
that
we
can
really
push
it
to
the
container
registry
and
for
that
I'm
going
to
use
a
tool
which
is
called
wasm
to
oci.
I
linked
it
in
my
github
repository,
it's
essentially
a
small
little
program
that
is
capable
of
pushing
web
assembly
modules
to
an
oci
container
registry.
So
let's
say
just
push
level
one.
B
In
this
case
the
web
assembly
module
and
run
it
from
this
webassembly
module,
which
I
got
from
azure
see.
That
is
the
idea.
So
let's
try
exactly
that.
Just
run
level.
One
takes
a
little
bit
longer
because
it's
now
pulling
down
the
webassembly
module
and
that
looks
good
and
let
me
show
you
that
this
stuff
really
works.
I
will
now
get
my
browser
here
again,
let's
put
it
here,
let's
put
the
url
and
you
see
it's
pong
see
it
here:
ping
oci
here
ping
oci.
This
is
exactly
what
I
wanted
to
show
you.
B
So
isn't
that
beautiful?
I
think
that's
that
puts
the
the
statement
from
sodom
and
heights
into
perspective.
I
now
work
with
the
webassembly
module
built
without
any
referenced
libraries.
I
pushed
it
into
a
container
registry
and
I
pulled
it
from
the
container
registry.
If
everything
is
running
inside
a
sandbox,
I
cannot
access
any
files
or,
I
don't
know,
get
some
http
requests
to
other
servers.
B
B
B
Take
a
breathe
in
breathe
out
because
we
are
reaching
level
two
level.
Two
is
a
little
bit
more
code
and
I
don't
want
to
bore
you
by
looking
at
me
typing
some
code,
so
I
will
just
copy
in
the
rust
code
and
simply
walk
you
through
it.
It's
really
really
simple.
It
just
puts
out
some
things
from
from
the
command
line
arguments.
These
are
the
command
line,
arguments
it
prints
out
some
variables
environment
variables.
B
You
will
see
what
we
will
have
in
the
environment
variables
and
it
will
print
out
what
it
can
find
in
standard
in.
This
is
what
I'm
doing
here.
So
I'm
just
reading
in
three
simple
things:
the
command
line,
argument
the
environment
variables
and
standard
in,
and
we
will
see
how
wagi
is
using
exactly
these
mechanisms
to
pass
in
the
payload
of
the
incoming
http
request.
B
Now
this
was
the
code.
Of
course.
I
have
to
add
this
thing
to
my
workspace,
so
that
rust
knows
that
there
is
a
level
2
application
here
and
additionally,
of
course,
I
have
to
define
another
route.
So
here
you
see
the
level
two
route
is
exactly
what
I'm
going
to
target
now.
So,
let's
give
that
a
try
and
they
just
run
level
two.
This
will
again
compile
everything
it's
blazingly
fast,
because
we
are
not
using
any
libraries
here
and
that's
it
and
with
that
we
should
give
it
a
try.
B
So
let
me
bring
up
another
browser
here.
Here
is
my
browser:
make
it
a
little
bit
smaller
and
fire
up
level
two,
and
this
is
exactly
what
you
see
here.
Well,
let's
move
it
a
little
bit
up,
oops.
Sorry,
let's
move
it
a
little
bit
up
and,
as
you
can
see
here,
the
command
line.
Arguments
are
first
the
path
and
I
can
specify
fu
equals
bar.
Also
some
query
string
parameters,
so
we
will
get
through
command
line
arguments
the
the
path
and
the
query
string
parameters,
all
the
different
http
request,
headers.
B
We
will
get
them
them
through
the
environment
variables.
Please
note
that
we
don't
have
access
to
all
the
environment
variables
on
the
machine.
We
just
have
access
to
those
environment
variables
which
are
passed
on
by
yg2as,
so
we
can
see
all
the
different
headers.
I'm
pretty
sure
you
will
recognize
them.
If
you
take
a
look
standard
in
down,
there
is
currently
empty,
but
it
doesn't
need
to
be
empty.
Let
me
show
you
what
standard
deal
in
will
look
like
when
I
copy
in
a
small
helper
file.
B
This
helper
file
is
using
a
plugin
in
visual
studio
code,
it's
called
rest
client,
and
with
that
I
can
directly
issue
requests
here
from
visual
studio
code,
and
this
is
the
thing
that
I
want
to
draw
your
attention
to,
because
this
is
now
sending
an
http
post
request
to
our
level
2
sample
and
this
time
I'm
passing
in
some
payload,
an
http
body,
so
send
this
one
and
you
see
we
still
have
the
arguments.
If
I
scroll
down
a
little
bit,
we
see
that
the
request
method
is
now
post.
B
I
see
still
the
query
string
and
here
through
standard
in
I
get
the
payload
of
the
http
request.
So
still,
I
don't
need
any
library
for
that.
It's
just
interpreting
the
command
line,
arguments,
the
environment,
variables
and
the
standard
in,
and
that's
it
that's
pretty
amazing,
don't
you
think
I
definitely
think
so.
So
this
was
my
sample
2,
where
you
have
learned
how
to
use
the
environment
variables,
the
program,
arguments
and
the
http
body,
so
good,
breathe
in
breathe
out
and
make
sure
make
ready
for
level
3.
B
in
level
three.
I
would
like
to
make
the
sample
a
little
bit
more
interesting.
Let's
put
it
that
way,
so
let
me
copy
in
the
code
and
then
quickly
walk
you
through
the
code
of
level
three
now
level
3
has
some
libraries,
as
you
can
see
it
here,
I'm
using
30,
obviously
for
some
json
serialization
and
deserialization
and
I'm
using
handlebars,
because
this
time
I
would
like
to
generate
html
on
the
server
side.
B
Let
me
show
you
the
source
code
and
let
me
walk
you
through
it
now
here.
First
interesting
thing:
we
can
define
so-called
subroutes
inside
a
body
module,
so
we
can
say
that
we
are
listening
on
these
subroutes
here
inline
and
file
and
then
that
we
want
to
call
the
methods
inline.
As
you
can
see
it
here,
here
is
inline
and
the
method
template
file.
B
Here
you
see
a
template
file
when
these
subroutes
come
in,
so
we
will
in
a
second
define
the
root
path
here
in
the
modules
tomml,
and
these
are
subroutes
inside
of
this
root
path.
Now,
let's
quickly
focus
on
the
inline
part,
this
what
you
see
here,
if
you
are
a
web
developer,
you
will
probably
immediately
recognize
this.
This
is
the
handlebar
syntax.
B
So
this
is
a
handlebar
template
here
you
see
a
loop
over
all
the
arguments
and
here
you
see
a
template
which
will
be
replaced
by
the
command
line
argument
and
then
I'm
using
the
handlebar
template
engine.
I
register
the
template
and
I
render
the
template
to
a
string
and
I
simply
print
line
the
result
of
the
rendering
onto
standard
out.
This
should
work.
B
Obviously,
no
problem,
but
the
second
thing
with
the
file
is
even
more
interesting
because
now
I'm
not
using
an
embedded
template,
as
you
can
see
it
here,
but
I'm
reading
some
template
from
the
file
system,
because
I
created
here
a
folder
which
is
called
templates
here.
You
see
a
more
elaborate
template
file,
it's
handlebar
syntax
and
if
I
scroll
down,
you
again
see
some
loops.
As
you
can
see
it
here,
you
see
some
replacements,
the
usual
stuff.
B
If
you
are
a
web
developer,
sorry,
we
are
also
using
bootstrap
here
and
additionally,
please
note
that
this
will
be
important
for
the
next
demo.
We
are
also
referencing
a
local
css
file
from
a
folder
which
is
called
static.
Keep
that
in
mind
we
will
have
to
fix
that
one
in
a
second.
So
this
is
what
we
are
doing
here.
We
have
level
three
which
uses
an
inline
template
and
uses
a
template
file.
B
Let
me
have
a
sip
of
water
here
and
then,
let's
get
going,
and
let's
try
to
set
up
this
this
level
three
here,
okay,
so
the
first
thing
that
we
will
need
is
a
little
bit
of
additional
content.
First,
the
static
folder
and
in
the
static
folder
we
have
a
very
basic
css
file,
but
hey
bear
with
me.
It's
just
a
demo.
I
think
you
can
imagine
that
this
css
file
can
be
as
complicated
as
you
want
it's
just
there.
B
We
will
see
how
we
can
serve
these
static
files
to
the
web
browser.
Obviously
you
cannot
just
access
the
file
on
the
disk.
We
need
to
do
some
magic
in
waji,
but
I
will
show
you
that
in
a
second
and
the
second
thing
that
we
need
to
do
is
we
need
to
again
pump
up
our
just
file,
as
you
can
see
it
here,
because
now
I
will
set
an
environment
variable
before
calling.
B
Okay,
keep
that
in
mind,
because
now
we
need
to
enable
our
our
yg
server
here
to
handle
the
level
three
route
from
the
sweat
assembly
and
here
comes
the
magic.
This
is
where
we
mount
the
local
folder
this
one
which
points
to
this
template
folder
here
and
we
mount
it
at
slash
templates.
So
the
wasm
file
can
access
my
templates
only
this
folder,
where
the
templates
are
stored
through
this
volume
mounting-
and
this
is
exactly
what
I
want
to
have.
My
rust
code-
should
have
access
to
a
single
folder
and
not
my
entire
disk.
B
B
Oh
now,
visual
studio
is
somehow
blocking
our
build
directory
because
it's
checking
a
lot
of
dependencies,
but
this
is
now
done
and
now
the
build
starts
everything
is
compiled
with
the
target
webassembly.
We
are
still
creating
a
webassembly
file
without
any
library
except
handlebars,
and
now
we
will
give
it
a
try.
First,
we
will
run
the
inline
template
for
that.
I
will
bring
up
a
web
browser
again
and
I
will
call
this
one
and
you
see
this
is
exactly
here.
B
This
template
see
it's
just
an
unordered
list
of
list
items
and
I
print
all
the
different
arcs
which
are
the
path
from
the
url
and
the
two
parameters
which
I
passed
in
through
the
query
string.
So
the
handlebar
rendering
already
works,
pretty
neat,
isn't
it
and
then
I
will
go
to
file
boom
and
let's
see,
oh,
my
god,
this
looks
way
more
beautiful.
This
is
bootstrap
because
I
referenced
inside
of
my
template
a
little
bit
of
bootstrap
to
make
it
look
nicer,
so
you
see
the
rendering
of
the
template
file
worked
perfectly
fine.
B
Well,
nearly
it
didn't
work
perfectly
fine,
because
if
we
scan
up
the
console,
we
will
see
that
the
server
was
not
able
to
read
the
styles
file.
Well,
of
course
it
can't
this
is
referencing
static,
styles,
but
waji
does
not
serve
static
files.
Yet
we
didn't
write
any
code
for
that.
What
we
could
do
is
we
could
go
into
our
main
rs
and
add
some
additional
code.
B
Maybe
an
additional
subroute
here
for
static
and
then
write
our
own
code
to
serve
files,
but
it
turns
out,
if
you
think
closely
about
serving
static
files,
it
isn't
as
trivial
as
you
might
think.
It
is
because
you
have
to
deal
with
caching
and
all
that
stuff.
Wouldn't
it
be
nice
if
we
would
have
some
kind
of
I
don't
know
ready-made
static
file
web
server,
which
we
could
magically
plug
in
and
it
turns
out.
There
is
one
there
is
one,
and
this
is
exactly
the
next
demo
that
I'm
going
to
do.
B
Let
me
stop
that
one
here
again
and
I
will
not
include
that
one
on
a
rust
level,
but
I'm
going
to
get
one
and
the
link
is
already
in
in
github.
I
will
get
one
in
the
form
of
a
wasm
module,
I'm
using
a
wasm
file
server
for
for
wagi,
which
was
written
in
a
programming
language
called
grain.
I'm
not
an
expert
on
grain.
I,
to
be
honest,
I
didn't
know
that
it
exists
until
I
took
a
look
at
this
example.
It's
pretty
pretty
amazing
and
you
can
take
a
look
at
it.
B
It's
it's
somewhat
I'd
say
was
native,
it's
really
interesting.
But,
to
be
honest,
I
don't
really
care
it's
like
working
with
a
container
right,
I'm
not
caring
about
how
this
web
assembly
file
was
created.
It
it's
just
there.
Just
like
a
container
is,
and
now
I
would
like
to
use
this
file
server
together
with
my
own
rust
code,
which
I
compiled
to
webassembly.
B
So
now
it
should
be
possible
that
my
website
loads,
the
styles.css
through
the
grain
file
server,
which
is
another
yg
module
just
working
side
by
side
with
my
own
web
assembly,
module
that
I've
written
in
rust.
Let's
give
that
a
try
right
just
run
level
three,
and
did
I
already
close
this
one
here
is
still
one.
So
let's
take
this
one
so
level
three
here
it
is
here.
B
This
could
be
a
possibility
for
you,
okay,
now
it's
getting
more
and
more
interesting.
We
are
generating
html
and,
as
a
web
developer,
I
would
like
to
go
one
step
further.
I
mentioned
that
already.
What
I
would
like
to
have
is.
I
would
like
to
have
a
possibility
to
change
a
little
bit
of
rust
code
here
and
magically
all
the
browsers
should
refresh,
and
if
I
go
into
my
template
and
change
a
little
bit
of
the
handlebar
syntax
here,
the
browser
should
magically
refresh.
B
It
turns
out
that
this
is
pretty
simple
to
achieve,
and
let
me
show
you
how
we
can
do
that.
I
prepared
two
files
here.
It
is.
I
will
copy
them
into
our
folder
here
they
are.
If
you
are
a
web
developer,
you
know
package.json,
it's
essentially
the
package
manager
of
javascript,
and
here
I'm
loading
in
a
javascript
module,
which
is
pretty
wide
known.
If
you
are
not
a
web
developer
and
you're
just
focusing
on
rust.
Let
me
tell
you
this
thing
is
really
cool,
it's
called
browsersync
and
it
does
exactly
what
it
says.
B
It
syncs
browser
whenever
local
file
change,
so
let's
get
browsersync
by
calling
npm
install
it
will
pull
down
browsersync
from
npm,
install
it
locally
in
the
node
modules
folder.
This
is
like,
like
cargo,
but
in
the
javascript
way.
Now
this
module
is
stored.
Here
I
can
close
it
and
I
also
create
a
config
file
where
I
tell
the
system
that
it
should
watch
all
wasn't
files
in
my
folder.
B
It
should
watch
all
handlebar
syntax
files
and
it
should
watch
all
the
css
files
and
with
that
I
can
get
the
web
development
experience
that
I
would
like
to
have.
Let
me
show
you
what
I
mean
with
that.
First,
let's
run
the
server
part,
the
compiler
and
the
yg
web
server
with
just
watch
level.
3.
see
the
just
files
are
really
convenient,
aren't
they
so
now
we
have
our
server
running
on
port
3000.
B
If
I
show
you
that
one,
it
runs
browser
sync,
as
you
can
see
it
here
with
this
specification,
see-
and
this
opened
automatically
here-
a
nice
little
browser
window
and
let's
put
that
one
side
by
side.
Okay
and
let's
go
to
slash
level
three
and
as
you
can
see,
it
still
works
just
as
expected.
But
now
we
are
not
running
on
port
3000,
but
we
are
accessing
the
a
browser
sync
system
which
acts
as
a
reverse
proxy
to
our
badgie.
B
So
now
I
can
go
to
template
from
file
as
you
can
see
it
works,
but
up
here
there
was
quickly
a
note
browser
sync
connected.
So
let
me
show
you
what
we
can
do
with
that
by
opening
up
the
main
rs
and
the
template
handle
file,
let's
go
to
main
rs,
for
instance
here
and
let's
first
go
to
the
inline
template.
B
You
see
it
here
and
if
I
go
to
the
inline
template
and
I
change
a
little
bit
of
code,
take
my
hand
from
the
keyboard
and
email
gods
are
smiling,
and
here
you
see
everything
was
refreshed
automatically
and
browser
sync
does
a
lot
of
magic
for
you.
If
you
have
multiple
devices,
maybe
an
ipad.
Maybe
an
android
tablet
that
you
use
to
check
your
your
mobile
website,
or
maybe
you
have
multiple
different,
browsers,
safari
and
chrome
and
check
cross
browser
compatibility.
Browser
sync
will
up
update
everything.
B
B
So
I
think
this
is
pretty
neat.
I
love
that
when
I
got
that
running
and
it's
simply
a
pretty
simple
combination
of
small
tools,
this
just
and
watch
exact
and
and
handlebar
and
browsersync,
and
if
you
want
to
dive
deeper
into
the
code,
you
can
take
a
look
at
it.
On
my
github
repository,
okay,
nice
last
one
breathe
in
breathe
out
level
four.
B
This
will
be
I
I
can
spoil
your
surprise
if
you
haven't
done
your
daily
wordle,
so
I
will
now
write
inrust
a
wordle
solver.
I
don't
want
to
call
it
a
wordle
hacker,
but
it
kind
of
is
that
lets
you
solve
any
wordle
puzzle
from
now
until
the
next.
I
don't
know
how
many
years
with
exactly
that
code,
so
you
will
be
a
wordle
magician
with
the
help
of
wedgie
and
the
code
that
I
will
show
you
in
a
second.
B
But
if
you
haven't
done
today's
wordle,
maybe
you
get
your
phone
out
now
and
do
it
immediately,
because
you
will
see
the
result
of
today's
wordle
in
a
few
minutes.
Let's
see-
or
you
might
also
just
close
your
eyes
before
I
do
the
demo
okay,
so
let's
take
level
four
here
it
is
and
let
me
quickly
walk
you
through
the
code.
First,
I
want
to
say
a
big
big.
Thank
you
to
blam
asset.
Albin
elvin
is
a
young
coder
from
our
coda
dojo.
B
He
is
awesome
when
it
comes
to
coding,
he
loves
rust,
he
loves
typescript,
he
loves
javascript
and
he
has
come
up
with
this
basic
algorithm
and
it
I
simply
took
it.
He
wrote
it
in
typescript.
I
simply
took
it
and
translated
it
to
rust,
so
I
didn't
come
up
with
the
algorithm
that
is
definitely
kudos
to
to
alvin
who
created
this
algorithm.
Thank
you
very
much
greetings
to
elvin.
If
you
are
watching
this
okay.
So
what
I
do
here
is,
let
me
scroll
down
here.
B
I
am
getting
some
parameters
from
the
query
string
for
that.
I
have
written
a
small
little
macro
which
just
takes
all
the
arguments.
Look
for
the
argument
with
a
certain
prefix
seriously
the
prefix
and
get
the
value
very
simple.
I
parse
it
because
it's
just
an
integer,
it's
just
an
integer
value
and
I
return
400.
If
the
the
argument
is
not
given
very
very
simple,
then
I
go
to
the
new
york
times.
I
do
an
http
request
to
nytimes.com.
B
B
B
Last
but
not
least,
elvin
took
the
time
to
go
through
the
word
wordle
code
and
found
out
with
which
regular
expression
we
can
find
all
the
words
of
all
the
solutions
inside
of
wordle
inside
of
this
javascript
file.
So
we
are
here
looking
for
the
words
for
all
the
solutions
inside
the
javascript.
It
turns
out
that
wordle
is
just
client-side
scripting
and
all
the
solutions
for
the
upcoming
days
and
the
days
before
are
inside
the
javascript.
B
And
last
but
not
least,
we
do
a
little
bit
of
calculation
magic
here
again
kudos
to
elvin
who
came
up
with
this
formula
to
calculate
the
offset
inside
of
the
words
array
which
we
got
from
javascript
and
with
that
we
can
get
the
result
of
every
wordle
in
the
past
and
in
the
future
at
least
until
the
new
york
times
will
change
the
javascript
code.
I
don't
know
if
that
ever
happened
will
happen,
but
for
now
I
hope
they
didn't
do
it
in
the
last
hour
or
something,
let's
see
whether
that
works
okay.
B
This
is
essentially
what
this
code
does.
If
you
take
a
look,
I'm
using
here,
a
crate
which
is
called
wazi
experimental
hdp.
I
have
to
do
that
because
the
network
support
in
waji
and
wasm
is
not
stable,
yet
it's
experimental
and
therefore
I
have
to
use
this
crate.
If
you
want
to
learn
more
about
this
crate,
a
link
to
the
crate
and
the
description
is
in
my
github
repository,
I
will
show
you
that
at
the
end
of
my
talk
again,
we
mentioned
it
before
now.
Let's
enable
everything.
B
So,
let's
copy
this
one
out
here
see
and
as
you
can
see
here,
I
have
my
module,
which
is
no
surprises
here.
Just
my
webassembly
and
here
is
the
magic
allowed
host
here,
I'm
allowing
my
webassembly
sandbox
to
access
the
new
york
times,
but
no
other
url.
If
I
try
to
access
any
other
host,
the
waji,
the
webassembly
runtime
would
block
this
call
and
I
would
not
be
able
to
get
or
post
anything
anything
to
them
or
get
from
them
and
therefore
this
is
the
important
thing.
B
This
is
why
I
created
this
example,
because
this
is
exactly
what
I
wanted
to
show
you
do
you
want
to
see
whether
it
works?
Well,
I
want,
and
let's
give
it
a
try.
Okay,
so,
let's
just
run,
but
this
time
or
just
just
watch
level.
Four.
This
will
compile
everything
oops
of
course
again.
I
forgot
to
add
the
project
to
my
workspace.
I'm
sorry
for
that,
so
that's
again
to
just
watch.
B
We
have
to
wait
a
second
until
visual
studio
code
has
finished
what
looking
through
my
code.
Now,
it's
compiling
compiling
compiling
should
be
done
in
a
second
here
we
are
web
server
is
running
and
oh,
I
stopped
my
my
my
browser
sync.
So
let's
run
browser
sync
again
to
auto
refresh
our
browsers
and
with
that
we
should
get
we
should
get
here.
We
did
a
browser
window
now,
let's
put
that
one
on
the
right
hand,
side
and
my
code.
On
the
left
hand
side
I
will
go
to
slash
static
wordle.html.
B
You
see
this
is
a
let's!
I
I
I'm
blunt
here
and
saying
this
is
a
single
page
app.
Essentially
it's
just
an
html
file
with
a
little
bit
of
javascript
in
it.
You
see.
So
what
I
do
here,
I'm
populating
these
three
fields
year
month
and
day,
and
then
I
can
do
a
form
to
my
rust
code,
which
will
then
try
to
solve
wordle
using
the
algorithm
that
I
showed
you
before.
B
So,
let's
begin
by
trying
it
for
yesterday,
okay
for
the
23rd,
so
this
shouldn't
be
a
spoiler
for
anybody,
let's
submit
it
and
now,
if
I'm
lucky,
oh
my
god,
it
worked,
it
really
worked.
We
went
out
to
the
new
york
times.
We
got
the
html,
we
found
out
their
javascript
bundle
id
we
went
to
the
new
york
times
again
got
the
javascript
parsed
out
the
words
calculated
the
word
index,
and
we
came
up
that
yesterday.
The
solution
was
purge
and
believe
me,
that
is
the
correct
solution.
B
I
tried
it
yesterday
and
now,
if
you
want
to
do
wordle
for
today,
please
close
your
eyes.
If
you
have
done
it
already
or
if
you
don't
care,
just
just
take
a
look,
we
will
do
it
for
today.
Here
we
are
24th,
it's
chest
see
chest.
So
let's
try
that
one.
Let's
try
that
one
crossing
fingers
c-h-e-s-t
enter
and
yeah.
We
are
geniuses.
We
definitely
are.
B
We
are
geniuses
because
we
now
create
it
in
webassembly
with
waji
a
server-side
logic
inside
a
webassembly
sandbox,
and
we
allowed
our
webassembly
code
to
reach
out
to
exactly
that
url
by
the
way.
Thank
you
to
new
york
times
for
this
beautiful
puzzle.
Here
I
love
it.
It's
really
nice
to
do
and
it's
nearly
a
daily
breakfast
puzzle.
I
really
like
it.
Thank
you
very
much
for
it.
B
So,
ladies
and
gentlemen,
that's
essentially
all
that
I
wanted
to
show
you
if
you
like
this
presentation
and
if
you
would
like
to
go
through
it
again.
Here
is
the
github
repo,
and
you
see
this
is
my
storybook.
So
if
I
scroll
down
down
down,
you
see
all
the
steps
that
I
did.
I
scripted
them
here
with
the
links
and
all
the
stuff.
So
if
you
want
to
redo
my
demo
and
try
it
on
your
own
computer
feel
free
to
do
so.