►
Description
WebAssembly (WASM) is being adopted in cloud-native applications, there are increasing demands to support scripting-language applications and libraries in WASM. That allows WASM runtimes, such as WasmEdge (a lightweight and high-performance runtime for cloud-native, edge, and decentralized devices), to run serverless functions written in scripting languages and APIs. Following the large-scale adoption and benefits of serverless computing, we focus on deploying these as a Function-as-a-service
Machine Learning inference is often a computationally intensive task and edge applications could greatly benefit from the speed of WebAssembly. Unfortunately, Linux containers end up being too heavy for such tasks. Demonstrating Machine Learning deployments in such a fashion, another problem we face is that the standard WebAssembly provides very limited access to the native OS and hardware, such as multi-core CPUs, GPUs, or TPUs which is not ideal for the systems we target. The talk also shows how one could use the WebAssembly System Interface (WASI) to get security, portability, and native speed for ML models.
To top it off this talk ends with a demo of deploying a Machine learning model as a serverless function using WASM.
---
KCD Africa 2022 is the 2nd iteration of the Kubernetes Community Days Africa, a CNCF-powered free community event. Visit https://kcdafrica.com for more information.
D
C
D
Well,
talking
about
machine
learning,
the
first
thing
I'd
like
to
touch
upon
is
why
to
choose
rust
over
python
in
machine
learning.
Now,
of
course,
we
know
that
worldwide.
Python
is
by
far
the
most
popular
language
when
it
comes
to
creating
doing
machine
learning
inference.
But
there
are
a
few
reasons
why
you
should
actually
choose
rust
over
python.
One
of
the
biggest
ones
is
in
terms
of
performance
now
rust
can
be
actually
directly
compiled
into
machine
code
and
there's
no
need,
for,
let's
say,
a
virtual
machine
or
an
interpreter.
D
That
is
actually
usually
the
case
with
python,
and
one
of
the
other
really
big
advantages
is
in
terms
of
the
thread
and
memory
management.
Now
you
must
be
very
aware
of
the
python
global
integrator,
lock
issue,
that
is,
that
still
sort
of
plagues
python
and
while
russ
doesn't
have
let's
say
the
necessary
garbage
collection
like
in
python,
but
the
compiler
and
rust
still
enforces
some
invalid
memory.
D
Reference
leaks
as
well,
but
these
advantages
are
much
better
in
comparison
to
python
and,
as
a
matter
of
fact,
according
to
study
by
ibm,
which
highlights
that
how
rust
and
web
assembly
can
actually
gain
12
to
15
times
performance
in
comparison
to
nodejs
and
more
than
25
times
increase
in
performance
as
compared
to
python.
So
that
just
goes
on
to
show
why
you
can
actually
choose
rust
over
python,
especially
machine
learning
use
cases
and
that
sort
of
brings
us
to
web
assembly.
D
How
website
actually
comes
into
picture
well
represents
a
compiled
target
that
essentially
allows
you
to
run
these
executables
at
native
speed
and
also
in
very
small
containers,
and
these
are
portable.
That
means
that
they
can
actually
be
run
anywhere.
So
you
just
have
to
use,
let's
say
some,
some
of
your
highly
competitional
languages
such
as
c
plus,
plus
or
rust,
and
have
websimply
as
a
compilation
target,
and
these
are
portable
in
nature.
D
That
means
you
just
have
to
generate
them
once,
and
these
can
be
executed
anywhere
without
having
to
re-deploy
them
again
and
again,
and
also
you
can
use
some
scripting
languages
like
c
like
javascript
or
python.
Also
to
compile
them
into
and
web
simply
executed
and
the
biggest
factor,
also
being
that
since
website
is
a
binary
instruction
format
that
allows
you
for
near
native
decoding.
D
That
means
it
is
much
more
faster
as
compared
to
other
comparative
runtimes,
and
this
also
like
you
know,
then
specifically
means
that
when
it
comes
to
machine
learning,
web
assembly
is
a
really
great
way
to
do
machine
learning
inference
as
well
and
coming
to
how
you
can
actually
use
web
assembly
within
the
ecosystem
for
cloud
native.
So
when
web
assembly
is
expanding
within
cloud
native
as
well,
especially
because
cncf
has
a
lot
of
different
sandbox
projects
today,
intubated
such
as
the
bozomed
awesome
cloud
speaking
specifically
about
awesome
edge.
D
Web
assembly
use
cases
on
edge
devices
and,
according
to
mortgage,
captain
from
the
university
of
tillprough
tillbock,
actually
published
an
article
where
he
compares
the
comparison
of
running
web
assembly
and
actually
doing
machine
learning
inference
as
compared
to
docker
and
by
actually
comparing
the
inference
time
that
I
actually
took
between
both
website
and
docker.
There
was
an
improvement
of
more
than
five
to
ten
times
for
the
machining
influence
in
terms
of
performance,
while
also
the
machine
learning
containers
being
smaller
as
compared
to
docker
containers.
D
So,
first
of
all,
you
can
actually
write
highly
performance
functions
in
languages
such
as
cia
and
rust,
and
these
can
be
directly
compiled
into
webassembly,
and
these
web
assembly
functions
are
actually
much
more
quicker
as
compared
to
javascript
or
python,
which
are
commonly
used
as
serverless
functions,
for
example
in
aws
lambda.
There
are
some
other
benefits
as
well
when
using
webassembly
one
of
the
biggest
ones
being
that,
as
we
mentioned,
that
the
bytecode
for
websimply
is
actually
portable.
D
So
that
means
that
if
you
are
actually
using
webassembly
based
function
or
like,
let's
function
as
service,
you
just
have
to
deploy
it
once
and
you
can
actually
then
go
ahead
and
use
these
serverless
functions
anywhere
and
then
actually
run
them
anywhere
in
any
kind
of
a
cloud
environment
without
having
to
redeploy
them
again
and
again.
Also
at
the
same
time,
the
deployment
as
we
mentioned
deployment
of
web
assembly
applications
is
very
simple.
D
There
are
a
lot
less
platform
dependencies
that
are
required
to
actually
be
used
alongside
these
web
assembly
applications
as
compared
to
let's
say
javascript
or
python,
based
service
functions,
so
that
makes
it
very
easy
to
actually
just
work
with
these
web
assembly
based
applications
and
with
wasmedge.
We
also
expand
the
webassembly
security
model,
so
you
must
all
be
aware
that
webassembly
security
is
very
well
known
as
compared
to
other
containers,
because
web
assembly
itself
cannot
really
do
anything
within
the
sandbox
environment.
D
In
case
you
want
it
to
interact
with,
let's
say
the
file
system,
you
need
to
use
aussie,
and
this
makes
it
a
very
safe
environment.
So
you
can
basically
use
that
security
model
as
well
alongside
the
service
functions.
So,
for
example,
if
you
were
to
do
a
inference
functionality
service
that
can
be
first
of
all
very
secure
and
also
run
at
full
native
speed
because
of
the
fact
that
we
are
getting
that
native
performance
with
the
help
of
a
web
assembly
executed.
D
So
those
are
some
of
the
reasons
why
website
is
preferred,
especially
for
functionality
service
and
this
particular
site
sort
of
showcases,
the
benchmark
that
we
ran
for
one
of
the
most
popular
machine
learning
models,
which
is
the
mobile
net.
We
do
we
basically
run
a
benchmark
for
doing
performance.
Comparison
between
the
various
runtimes,
including
boss,
match
tensorflow
lite
was
met
with
ahead
of
time.
D
Compilation
running
this
model
when
python
and
intensive
case,
and
as
you
can
see
that
the
least
amount
of
time
that
it
took,
for
instance,
was
with
wasm
x
with
the
ahead
of
time,
compilation
as
compared
to
some
of
the
other
ones
as
well.
All
these
records
were
in
infants
were
done
in
milliseconds,
so
you
can
see
that
the
fastest
one
is
was
matched
and
the
text
site
that
we're
going
to
be
using
for
our
demo
includes
rust.
Web
assembly
was
met.
D
E
Let's
just
see
how
to
run
this
locally
in
versamage,
and
so
very
simply,
as
many
of
you
might
know,
started
out
as
a
javascript
alternative
for
browsers
and
run
high
high
performance
applications
and
high
performance
computations,
like
machine
learning,
influence
that
we'll
be
seeing
today
in
languages
like
c
cluster
safely
in
the
browser.
So
we
have
assembly
then
side
by
side
with
javascript
and
we'll
actually
need
so
to
run.
E
So
so
before
we
like
taking
a
look
at
this
quick
js
interpreter,
you
might
think
that
it
could
be
slower
than
v8,
and
I
mean
it
is
lower
than
v8
because
of
quickjs
not
having
just
in
time
compilation.
But
if
you,
if
you
think
about
it,
if
you
think
about
it,
quick
gsm
is
not
only
a
lot
smaller
than
v8,
it's
literally
140
at
the
size.
E
You
want
to
run.
You
only
want
to
run
some
of
your
code
in
javascript
and
probably
called
the
computationally
intensive
tasks
like
the
machine
learning
influence
for
one
or
image
processing
stuff
that
you
are
doing
we'll
be
calling
the
ross
function
for
that.
So
so
you
can
essentially
have
js
programs
with
extension,
apis
and
rust,
cec,
plus,
plus
and
wrestling
with
embedded
javascript.
So
that
is
very
much
possible,
which
makes
mix.js
a
really
nice
choice
for
us.
E
E
So
I
have
actually
built
this,
so
it
didn't
take
quite
a
lot
of
time,
but
what
I
do
want
to
show
you
is,
let's
just
go
to
target
version:
32,
minus
oz
and,
let's
so
what
you
can
see
is
he
was
image
underscore
which
is
not
version.
So
this
is
the
javascript
interpreter
that
we
have,
and
so
let's
now
go
to,
let's
now
go
to
our
javascript
example
of
our
mobile
network,
so
we'll
go
to
js,
underscore
mobile
networks
and
so
first
off
we'll
start.
E
So
so
now
we
can
start
using
the
wasn't
hq
js.
That
was
an
interpreter
which
we
just
built
and
we'll
use
the
voicemage
minus
tensorflow
minus
light
utility
that
is
built
with
tensorflow
and
tensorflow
lite
extensions,
and
it
makes
it
really
easy
to
work
with
sensitive,
like
models.
So
let's
do
that.
So
what
we'll
say
is
tensorflow
minus
light,
and
now
we
want
to
mount
the
current
directory.
So
let's
just
want
the
current
directory.
First
then
we
want
to
so
now.
E
We
want
to
tell
you
which
interpreter
do
we
want
to
use,
so
that
is
actually
the
one
which
we
just
built
and
now
we'll
give
it
the
and
now
we'll
give
it
the
javascript
tool.
So
let's
go
on
to
the
javascript
which
we
have,
and
so,
if
you
see
this
looks
quite
simple
and
it
is
because
of
the
tensorflow
lite
apis
as
well,
so
I
start
out
with
loading
my
image
and
then
doing
any
kind
of
pre-processing
on
it.
E
So
as
of
now
right
now
it
is
resizing
the
image,
but
you
could
have
some
more
pre-processing
steps
as
well.
I
then
load
my
tensorflow
lite
model
and
I
want
to
get
the
I
want
to
make
the
predictions
from
a
specific
node
in
the
model
graph,
which
is
what
I'm
doing
over
here
and
so
the
output,
which
I
get
will
essentially
be
a
list
of
probabilities
and
and
finally
and
finally,
the
index
I
get
with
the
most
probability.
E
So
let's
say
I
have
0
or
1
as
the
number
with
most
probability,
so
each
of
them
corresponds
to
a
particular
species
of
wood.
Remember
they
remember
what
our
tasks
was.
So
each
of
the
corresponds
to
particular
species
of
good,
and
which
is
why
I
also
have
a
label
map
down
here.
So
what
this
label
map
tells
it
is
is
what
index
corresponds
to
what
species
are
called
so
as
of
right
now,
let's
just
print
out
our
label
and
we'll
print
out.
E
Sorry,
for
the
background
guys-
and
so
now,
we
I
just
saw
the
javascript
code.
So
let's
give
it
the
js
file
and
it
should
tell
us
so
I
also
had
a
sample
image
over
here.
That
was
actually
himalayas
cassini.
That
is
a
species
of
word,
so
it
actually
did
so
that
is
predicted
correctly.
So
that
was
the
javascript
example,
and
there
is
another.
E
Which
I
wanted
to
talk
about,
but
I
will
cover
that
up
with
the
last
example.
So
so,
let's
see
the
same
model,
and
now
we
want
to
see
a
rest
example.
So
let's
go
down
to
the
rest
directly,
so
this
is
called
rust,
mobile,
knight,
v2
and
I'll
just
show
you
this
demo
as
well,
so
so,
first
of
all,
so
first
off
we'll
start
off
with
building
this
and
we'll
do
this
in
a
similar
way.
We
did
it
earlier.
E
So
where
did
the
command
go
yeah?
So
so
so
let's
build
our.
So
let's
first
build
this
and
I
actually
built
it
beforehand.
So
we
don't
spend
a
lot
of
time
on
these
processes
easily.
You
know,
but
if
you
see
similar
to
what
you
might
have
seen
earlier,
if
you
remember
from
the
javascript
example,
we
go
to
the
version
32
minus
once
you
target
release
and
let's
do
analysis.
E
So
what
I
have
is
the
classified
dot
version,
and
this
is-
and
this
is
the
awesome
file
that
I
can
use.
What
I
can
also
do
is,
I
can
aot,
compile
it
down
ahead
of
time,
compile
this
down
to
machine
native
code,
compile
it
down
to
a
dot
so
file,
the
linux
shared
library
format,
and
I
can
run
that
as
well.
E
So
I
also
remember
the
benchmarks
from
earlier,
and
so
this
is
actually
the
model
on
which
those
benchmarks
were
made,
and
so
at
the
moment,
we'll
also
run
this
with
the
washington
h,
minus
sensor,
minus
light
utility,
but
so,
but
with
wasage
it
gives
you
a
cool
utility
vessel
xc,
which
allows
you
to
aod,
compile
your
code
down
very
easily
and
get
a
dot
so
file
which
you
can
use.
This
also
gives
you
so
because
the
dot
iso
file
is
machine.
Specific
this
also
gives
rise
to.
E
This
also
gives
rise
to
the
universal
volume
format,
that
is,
that
dot
wasn't
five
plus
a
dot.
So
at
the
moment,
let's
run
the
rush
code,
so
so
so
I'm
using
the
same
model
to
do
the
inference
with
in
rust,
and
if
you
see
the
main.rs,
it
is.
The
code
here
is
pretty
self-explanatory
as
well.
I'm
using
the
same
model
the
words
model
and
performing
the
inference
on
it
in
the
exact
same
way
as
earlier.
E
What
I
also
wanted
to
do
was
show
you
how
much
time
it
takes
to
do
to
do
an
instance.
So
so,
let's
so
first,
let's,
let's
run
this
so
using
the
voltage.
Minus
sensor
flow
minus
light
utility
like
we
discussed.
So
what's
image
minus
since
the
flow
minus
light.
Now
we
have
so
now
we
give
it
the
part
to
that
wasn't
file
that
was
in
file,
so
that
is
classified.
E
This
is
the
same
image
from
earlier.
The
demo
is
essentially
supposed
to
be
the
same
model
shown
in
javascript
contrast,
which
is
what
we
do
so
this
gives
us
output
in
187
milliseconds,
which
is
which
is
a
bit
more
for
a
tensorflow
lite
model,
particularly
for
a
small
model,
but
a
lot
of
the
speed
of
weapons
also
comes
from
ahead
of
time
compilation
and
if
you
remember
the
benchmarks,
we
showed
you
earlier
ahead
of
time.
E
Compilation
can
cut
this
down
by
eight
times
to
ten
times,
which
is
a
very
big
increase
in
speed.
So
that
is
something
you
definitely
want
to
try
out
with
watsonvit,
and
you
can
run
it
in
the
exact
same
way,
so
that
marks
are
in
for
demo
one
and
let's
now
go
on
to
our
second
demo,
which
is
deploying
this
as
a
function
as
a
service.
E
So
now
what
we
want
to
do
is
we
have
already
already
seen.
We
have
already
seen
how
we
can
run
how
we
can
run
our
website
up
with
was
image,
so,
let's
now
try
and
deploy
it
as
a
function
as
a
service,
so
we'll
actually
be
using
the
similar
code.
We'll
not
be
using
the
same
model.
You
can
also
like
put
in
the
same
model.
If
you
wanted
to,
I
will
be
using
the
same
category
of
overlay,
which
is
actually
built
in
the
exact
same
way.
E
You
have
the
label
map
you
have
you
have
the
model
from
which
you
want
to
get
the
outputs
from.
So
let's
go
to
the
functions
here
we
have
the
raspberry.
So
if
you
see
this
is
essentially
the
same
dress
code
just
with
the
new
model
out
there
and,
of
course
just
like
pre-processing
ships
in
our
earlier.
E
It's
ahead
of
time
compiles
it,
so
we
can
run
it,
so
we
can
run
it
a
lot
more
easily.
So
so
we'll
see
so
we'll
take
the
mobilenet
model
and,
as
you
might
expect,
we
first
go
to
our
function,
which
we
have,
which
is
image
classification
and
let's
actually
bring
this
out.
So
we
first
go
to
image
classification
and
now
we'll
build
this
similar
to
how
we
did
earlier
so,
okay.
E
E
And
what
you
can
now,
what
you
can
now
do
is
what
you
can
now
do
is
apply
this
to
version,
which
is
the
example
we
will
be
taking
a
look
at.
You
can
deploy
this
to
visual
server-less
functions,
so
let's
just
do
version
deploy,
so
you
already
need
to
so
you
already
need
to
have
the
versions
here
line.
Sorry,
so
I'm
in
the
wrong
directory
at
the
moment.
What
I
will
do
is
I
go
down
to
the
fast
directory,
which
is
where
now
are
classified.
E
So
it
is
taking
quite
some
time.
Let's
go
to
my
virtual
workspace
for
this
demo,
oh
yeah,
if
you
view
build
up,
that
is
what
I
wanted
to
see
for
the
deployment
and
it
was
actually
able
to
build
it
up,
and
if
you
also
see
that
so
when
it
ran
the
plea,
dot,
sh
site,
it
actually
converted
it.
Let's
see
if
you
see
it
used,
wasn't
it
ahead
of
time
compiled.
E
A
lot
more
quickly,
but
you
should
remember
that
v.s.o
file
is
the
machine
code,
which
is
why
offices
why
it
is
only
useful
to
on
a
particular
machine,
and
you
can
also
use
the
universal
version
of
format,
to
copy
the
file
that
can
be
done
on
any
awesome,
sandbox
and
so
file.
That
is
machine
specific.
So
let's
actually
take
a
look
at
this
deployment
which
we
just
deployed,
and
so
this
deployment
is
up
as
well.
E
E
We
go
so
this
is
the
deployment
which
we
just
made
our
troublesome
functions
and
let's
tie
down
an
image.
So
this
is
the
imagenet
model,
but
the
same
words
model.
So
let's
try
on
this
image,
which
is
a
pretty
famous
image,
and
it
actually
tells
me
that
it's
a
comic
book,
so
the
imagery
model
has
another
set
of
labels
which
is
used
for
detecting
all
kinds
of
images.
E
It
has
so
the
image
network
one
k
has
one
thousand
labels
and
dvds,
like
21k,
has
21
000
different
labels
for
images,
and
that
is
the
model
which
we
deployed
to
serverless
functions.
If
you
might
see
it
also,
the
influence
was
also
quite
quick
because
we
ahead
of
time
compiled
down
our
code,
and
it
also
rightly
classifies
this
image
as
a
comic
book.
E
So
now
we
come
to
the
third
and
final
demo,
which
is
managing
with
us
in
the
apps
with
kubernetes.
So
so
it
is
so
it
is
really
nice
and
one
of
the
great
advantages
of
the
of
linux
containers
of
the
linux
containers
system
is
that
you
have
a
lot
of
tools.
You
have
a
lot
of
support.
You
have
kubernetes
to
manage
it.
E
Containers,
which
is,
which
is
what
we'll
be
seeing
today
so
first
off
we'll.
So,
first
of
all,
we'll
take
one
of
these
examples
and
create
a
container
for
our
clear
container
out
of
our
autofocus
image
or
out
of
our
application.
So
first,
let's
go
to
an
example:
let's
take
the
russian
example,
and
so
we
already
have
the
132
minus
once
the
target
installed.
So
first
we'll
build
this.
E
E
So
now
what
we'll
do
is
we'll
also
so
now
we
want
to
create
a
docker
file
which
will
run
dot
washer
file,
if
you
remember
where
the
dot
wasn't
filed,
is
it's
in
the
version
32
minus
one
target,
so
first,
let's
apply
the
executable
permission
to
it,
because
that
is
what
we
will
be
running
in
our.
What
we'll.
E
Run
time
can
already
start
the
this
websdb's
container
image,
but
it
requires
another
annotation
on
the
container
image
to
indicate
that
it
is
a
web
assembly
application
which
does
not
have
a
guest
os.
So
to
do
this,
we'll
actually
use
buildup
and
add
an
annotation
that
this
is
our
website.
The
application-
and
we
don't
have
a
case
storage
for
this.
So
so,
let's
actually
do
that
and
we'll
and
we'll
add
our
annotation.
E
And
this
is,
this
is
just
know
that
we
don't
have
a
gestures
for
this
website
application
so
classified
so
this.
So
this
adds
the
so
this
adds
the
annotation
of
this
container
image
and
then
you
can
also-
and
then
you
can
also
do
builder,
push
to
push
this
to
docker
hub
or
gccr,
literally
wherever
you
want
them,
so
so
that
is
the
part
about
building
or
building
a
container
from
our
web
assembly
or
building
a
container
image
from
our
website
application.
E
E
So
this
is
it's
a
couple
of
random
numbers:
okay,
it's
a
file,
feature
file
so
just
to
test
out,
and
they
already
have
a
container
up
for
this.
So
we
can
directly
test
this
out,
so
you
can
actually
try
running
a
web
assembly
container
or
you
can
actually
try
making
assembly
container
and
running
it
running
it
with
with
cubex
k3s
mini
queue
kind.
Whatever
you
want
at
the
moment.
E
I
already
have
a
kind
class
setup
and
I'll
just
and
I'll
just
I'll
just
run
an
example.
I'll
just
learn
this
example,
which
we
just
saw
there,
or
they
also
have
a
publisher
image,
which
was
a
reason
to
try
out
this
example
and
show
this
example,
because
it's
quickly
doable
and
I
haven't
pushed
the
image
of
it.
So
so
this
is
an
example
of
running
a
website
planning
on
msnb
running
web
assembly
and
managing
it
with
kubernetes.
E
D
D
Developers
can
actually
use
various
container
tools,
such
as
communities
to
actually
run
lightweight
web
assembly
applications,
and
you
may
ask
that
why
to
actually
choose
webassembly
based
applications
on
communities
so
especially
when
it
comes
to
being
able
to
run
applications
on
the
edge
which
are
usually
those
kind
of
hardware
which
are
very
resource
constant.
If
you
try
to
run
linux
containers
on
its
devices,
it
can
be
sort
of
an
issue
because
linux
contains
are
usually
larger
in
size,
and
they
also
take
a
lot
of
time
to
actually
get
started.
D
Containers
on
communities
is
by
actually
pairing
them
up
with
some
of
the
existing
linux
containers,
especially
like
docker
containers
that
might
be
running
within
that
particular
web
assembly
within
that
community's
ecosystem,
because,
as
we
know
that
with
web
assembly,
it
is
not
having
the
best
tooling
out
there.
A
lot
of
the
toolings
are
not
supported.
D
D
A
D
A
Awesome
we
are
very
grateful
for
you
taking
the
time
to
join
and
prepare
the
video,
but
we
don't
have
any
questions
here
at
the
moment.
I
think,
since
we'll
probably
also
be
uploading,
the
questions
later
to
be
on
youtube.
We'll
share
the
videos
with
you
so
that
you
can
probably
check
the
feedbacks
that
were
given
and
so
on,
and
also
viewers
can
also
throw
questions
at
you
on
twitter.
I
think
rashid
handle
is
rashid
unless
called
ugly
on
twitter
and
that
of
shiva.
I
can't
remember
yours:
maybe
we
can
how
how.
D
Developed
but
yeah
just
to
sort
of
cover
inertial.
What
we
like
you
know
wanted
to
represent
from
our
talk
is
that
a
lot
of
times
you
might
want
to
run
machine
learning
applications
and
also,
in
general,
any
computationally
heavy
applications
on
edge
devices,
and
that's
where
web
assembly
rally
comes
to
the
picture
because
generally
web
assembly
is
conceived
to
be
this
front
end
and
a
browse
specific
technology.
D
C
E
Of
it
the
size
of
it
compared
to
linux
containers,
and
we
also
showed
the
benchmarks
for
the
mobile
network,
so
that
was
actually
the
same
model
we
were
running
in
the
demo.
We
did
all
kinds
of
benchmarks
on
it,
so
that,
in
a
sense
feels
to
me
managing
your
web
assembly.
Containers
with
linux
could
change
the
paradigm
for
a
lot
of
for
a
lot
of
tasks,
and
you
should
definitely
give
it
a
try.
All
of
the
timbers
are
already
open
sourced.