►
Description
wasmCloud is a platform for writing portable business logic that can run anywhere from the edge to the cloud, that boasts a secure-by-default, boilerplate-free developer experience with rapid feedback loop.
https://wasmcloud.com
A
B
C
A
D
Yes,
sir,
I
am,
it
only
went
adders
if
liam
has
granted
me
his
awesome
privilege
of
screen
sharing
so
we'll
see
what
happens.
Oh
yep
host
disabled
participants
screen
sharing.
Oh
there
we
go.
Thank
you.
Everyone
welcome
to
a
normal
meeting
of
wasm
cloud
wednesday,
where
liam
does
not
give
us
screen
sharing
permissions.
Okay,
let's
share
now.
Let's
see
should.
E
E
D
Maybe
we
should
write
an
interface
for
that
anyway,
so
this
is
the
wasson
cloud
dashboard,
as
you
all
know,
our
favorite
washboard,
but
that's
not
what
I'm
here
to
demo
to
you
today.
So
what
we
did
recently,
if
you
didn't
see
our
blog
post,
which
hopefully
brooks,
can
maybe
help
me
out
and
put
that
in
the
chat
we
just.
D
We
were
tired
of
having
to
have
people
host
the
ui
as
like
a
docker
container,
and
all
that
and
figured
let's
just
figure
out
how
to
do
this,
because
we
know
the
way
you
can
host
a
ui
is
varied.
A
lot
of
people
will
do
this,
like
with
a
cdn
but
sometimes
there's
things
when
you're
doing
smaller
projects
or
internal
types
of
things
that
are
not
behind
a
cdn
where
you
might
want
to
serve
up
your
ui,
and
now
you
can
do
that
inside
of
webassembly.
This
wasn't
like
a
new
feature.
D
We
added
to
webassembly
it's
just
showing
you
how
you
can
do
this,
and
so
what
we
did
is
put
the
whole
thing
inside
of
inside
of
a
wasn't
cloud
actor,
and
let
me
show
you
what
that
looks
like
so
you'll
see
if
you've,
if
you've
seen
the
pet
clinic
example
before
you
will
have
probably
seen
that
there
is
a
separate
interface
part.
Well,
that's
now
been
added
to
this
ui
actor.
D
D
So
what
I'm
showing
here
is
the
pattern
of
how
you
could
do
this
on
your
own
and
it's
just
one
of
many
different
patterns
you
could
do
you
could
implement
this
with
a
backend
blob
store
or
some
sort
of
other
thing.
This
is
just
the
simplest
solution,
and
so
here
we
actually
do
a
like
npm
install
and
an
npm
run
build
and
then
we're
good
to
go.
D
So
obviously
this
is
going
to
make
your
binary
size
a
lot
bigger
than
a
traditional
wasm
cloud
module,
but
it
has
the
advantage
of
having
everything
put
together,
and
so
this
does
a
very
simple,
straightforward
thing.
It
just
assumes
that
if
it
gets
something
it's
checking
from
the
root
path
and
then
tries
to
fetch
data
from
the
root
path,
so
it's
just
a
very
simple,
like
file
server
in
a
sense,
and
it
will
send
it
back
now.
We
mentioned
a
couple
weeks
ago
that
we
added
some
automatic
chunking
support
on
the
back
end.
D
D
And
you'll
see
that
the
whole
ui
loads,
it's
still
loading
stuff
and
data
from
the
back
end
right
here
I
I
could
add
an
owner
and
stuff
we're
not
going
to
do
that
right
now,
but
this
ui
is
being
entirely
served
by
that
actor.
There's
some
cool
things
you
could
do
with
that.
For
example,
if
you
really
want
to
push
your
ui
assets
close
to
the
edge,
you
could
send
these
all
the
way
out
to
an
edge
device.
D
That's
connected
to
your
lattice
and,
like
I
said,
there's
a
million
other
ways
you
could
do
this.
You
could
just
have
like
one
thing,
be
the
the
part
that
serves
your
ui
and
have
it
connected
to
the
http
server.
It
doesn't
really
matter,
but
we
just
wanted
to
show
a
concrete
example
of
how
you
can
do
this
by
embedding
your
assets
inside
of
it.
So
that
is
all
I
have.
Are
there
any
questions?
I
have
to
drop
right
after
this,
so
this
is
your
time
to
ask
the
questions.
If
you
have
them.
D
So
I
think
that
we're
gonna
have
to
see
how
people
want
to
use
this.
I
do
think
there
is
an
argument
to
be
made
for
this
ui
interface,
which
is
what
I'm
using
for
the
after
to
actor
call
here.
I
actually
think
this.
This
kind
of
like
get
asset
thing,
could
be
a
generic
crate.
We
we
publish
it's
gonna,
be
super
small,
but
it
basically
is
defining
that
operation.
D
So
maybe
we
can
make
this
an
actual
publicly
supported
interface,
but
we
want
to
see
how
people
use
this,
because
it
could
just
be
a
toy
that
people
use
for
simple
api,
stuff
or
toy
projects,
but
not
for
bigger
projects
when
they're
actually
implementing
it.
But
the
idea
is
just
to
show
more
and
more
you'll,
see
more
and
more
of
this
from
from
us
maintainers.
D
Is
that
we're
trying
to
show
how
much
we
can
push
the
boundaries
of
webassembly
right
now,
even
with
some
of
the
gaps
that
still
exist,
we
want
to
be
able
to
push
that
further
and
further,
and
so
we're
going
to
start
showing
more
and
more
of
these
things
that
we
do
entirely
inside
of
wasn't
cloud
rather
than
leveraging
other
technologies
like
docker.
So
that's!
What
I
personally
see
is
the
future.
With
this.
D
There
was
also
a
question
from
janeth
about:
is
this
a
file
server
in
the
strictest
technical
sense?
No,
but
yes,
it
is
a.
It
is
a
file
it's
acting
as
a
file
server,
so
it's
requesting
a
specific
asset
and
it's
just
loading
it
from
something
that's
embedded
inside
of
its
inside
of
the
actual
module,
the
bytes
that
have
been
loaded
into
memory,
so
it
pulls
that
out
and
sends
it
back.
D
B
D
So
it
just
depends
on
what
you're
doing
like,
for
example,
we
couldn't
do
like
a
php
or
something
on
here
like
that
that
wouldn't
work,
if
that's
what
you're
referring
to
with
dynamic
content,
but
anything
that's
being
done
on
the
browser
side
could
technically
be
hosted
here
and
served
out.
Just
like.
I
said
the
major
downside
of
doing
it.
D
This
way
is
you're
going
to
balloon
the
size
of
your
actor,
so
your
actor
is
basically
going
to
be
the
total
size
of
your
application
that
it's
going
to
be
sending
to
a
user
plus
the
extra
bits
and
bobs
for
actually
sending
that
data
from
rust,
and
so
it's
going
to
expand
your
size
and
obviously
that
might
not
be
worth
it,
especially
if
you're
pushing
to
edge
devices
as
the
ui
size
gets
bigger.
So
that's
something
that
would
definitely
be
a
downside
here
but,
like
I
said,
there's
a
couple.
D
Different
options:
yeah
and
kevin
actually
mentioned
this
in
in
chat
like
this
doesn't
do
any
compression.
We
could
easily
do
some
compression,
and
I
know
that
like,
for
example,
the
rust
embed
crate
has
a
flat
thing,
so
you
can
actually
do
some
compression
before
it
actually
embeds
the
file,
and
then
you
can
embed
that
compressed
file
on
the
way
out.
So
there's
we
haven't
done
a
huge
amount
with
this.
B
Follow-Up
question
is
brooks,
might
have
mentioned
last
week
that
he
had
like
deep
insights
into
web
assembly
and
that
this
helped.
You,
therefore
are
there.
Is
there
like
private
functions
here
that
you
expose,
or
is
this
all
kind
of
public
stuff,
that
you
are
able
to
document
well
gleaned
from
documentation,
so
to
speak?.
D
D
This
is
literally
all
the
code
like
there's
there's
nothing
else.
It's
52
lines
of
code
and
10
lines
of
that
is
like
defining
structs
and
imports,
and
so
there's
no
there's
nothing
special
here.
This
is
just
doing
a
normal,
wasm,
compile
and
yeah.
I
think
this.
This
exact
example
should
work,
as
is
even
as
we
swa
as
we
start
supporting
wazi
based
actors,
which
is
something
we
want
to
do
here
soon,
and
so
all
these
kind
of
things,
I
think,
just
work,
there's
no
special
import
export
trying
to
glue
things
together.
A
D
Api
is
going
to
allow
you
to
do
that
somewhat
quicker,
because
you
can
start
immediately
processing
things
as
they
come
in
and
even
if
it's
technically
a
little
bit
slower,
there's
that
little
like
tiny
bit
of
overhead
that
happens
from
using
like
a
distributed
system
like
this,
hopefully
with
a
streaming
api,
that's
pretty
much
negated
from
a
actual
user
interaction
standpoint,
and
so
that
that
becomes
very
valuable
to
have,
and
so
this
makes
it
so
it's
just
transparent.
You
notice!
D
D
Yeah
and
if
there's
any
other
questions
since
I
have
to
drop,
please
feel
free
to
reach
out
to
me
on
the
wasn't
cloud
slack
or
any
of
us.
We
put
this
together.
So
it's
a
pretty
nice
little
example,
and
if
you
liked
what
we
did
here,
please
do
share
the
blog
post.
We
have
been
trying
to
make
sure
we're
posting
more
of
exactly
what
we're
doing
and
so
having
those
those
out.
D
A
All
right
well
with
that
we'll
move
on
to
our
next
exciting
demo,
which
will
actually
be
given
by
yours.
Truly
I'm
going
to
give
the
the
second
of
three
demos
today
so
to
bring
you
through
a
little
bit
of
the
a
little
bit
of
the
narrative
coming
to
like
this
feature
that
I
want
to
show
off
every
once
in
a
while.
A
So
I'd
like
to
kind
of
re
revisit
that
today,
as
a
part
of
this
demo,
so
I'm
in
this
little
temporary
directory,
I'm
working
off
of
a
newer
version
of
wash,
and
I
want
to
show
what
it
looks
like
to
generate
your
first
actor.
We
have
the
wash
new
actor
command.
This
is
what
pulls
from
our
project
templates
repository
will
generate
an
actor
project
for
you,
like
with
all
of
our
with
all
of
our
scaffolding
and
a
helpful
make
file
to
get
started.
A
So
when
we
do
this
and
I'll
go
ahead,
and
I
guess
get
this
running
while
we
wait,
you
know
we
get
essentially
this
this
actor,
this
a
very
simple
http,
server
actor.
It
has
a
single
handler
for
handling
a
request
takes
in
an
http
request,
gives
back
an
http
response.
It's
it's
like
our
hello
world
demo
and
by
default
running
something
whoops
running
like
make
in
in
this
actor
project,
we'll
build
and
sign
the
actor
for
you
with
the
http
server
capability.
A
So
this
really,
you
know
this
takes
away
a
lot
of
the
initial
friction
of
writing
your
first
webassembly
module,
we'll
compile
it
to
wasm
for
you
using
your
cargo
tool
chain
and
then
use
wash,
which
you
already
used
to
generate
this
project
to
go
ahead
and
sign.
It
now
running
this
for
the
first
time
and
you
all
should
be
able
to
see
my
should
be
able
to
see
my
browser
running
this
for
the
first
time
you
know,
you'll,
you'll,
launch,
nats,
you'll,
launch
a
local
host,
startup,
http
server
and
then
from
file.
A
A
A
If
you
iterate
or
want
to
develop
this
actor,
you
could
use
our
hot
reloading
feature
so
that
when
you
are
making
changes
to
the
actor,
we're
essentially
loading
this
from
your
local
file
system,
so
that
every
change
you
make
will
automatically
reschedule
it
for
you,
but
as
soon
as
you
make
it
off
of
your
local
file
system,
you're
starting
an
actor
from
an
oci
compliant
registry
and
a
lot
of
our
examples
do
this.
Now.
A
What
we'll
do
is
we'll
launch
the
the
local
docker
registry
or
the
the
registry
image
it's
a
docker
container
and
that
works
for
pushing
webassembly
modules
too.
So
you'll
use
our
make
file
like
a
make
push
script
to
push
it
to
there
start
from
an
oci
registry,
but
we
still
have
the
problem
of
as
soon
as
you
make
it
off
of
your
local
machine.
There's
no
real
way
for
you
to
access
this
actor.
You
have
to
then
go
set
up
your
your
registry.
A
A
So
this
is
all
you
pretty
much
have
to
do
from
the
ui
side.
You
just
need
to
create
a
repositories
that
I
can.
I
can
push
to
it
now.
I
can
go
ahead
and
add
in
all
of
the
all
the
actor
files
here,
basically
just
copy
and
paste
all
the
things
that
github
gave
me
here
and
we
can
create
our
actor
repository.
So
these
are
all
the
things
that
are
in
you
know,
auto
generated
for
us
with
wash
now
in
order
to
publish
to
github
packages.
A
A
A
A
A
Once
we
do
that,
if
we
come
back
to
our
repo
and
we
hit
refresh
here,
you
can
see
that
we
have
a
package,
our
hello
package,
and
if
you
come,
you
can
see
our
recently
tagged
version.
You
know
readme
for
this.
This
will
actually
show
up
under
my
profile
as
well,
but
this
actually
right
now
is
a
private
package.
So
this
is,
you
know
this
is
just
for
for
me
to
consume.
A
A
Then,
as
soon
as
you
do
that
you
can
come
back
here,
if
we
come
to
our
wasmcloud
dashboard
and
we
go
to
start
an
actor
from
a
registry,
that'll
be
kind
of
the
wrong
thing.
But
let
me
grab
the
correct
one
here.
It
is
go
back
to
start
an
actor
from
a
registry.
We
can
actually
get
that
hello
actor
directly
from
github
container
registry
and
then,
if
we
do
that
same
kind
of
curl
that
we
did
earlier
we'll
get
hello
world
same
thing
just
started
from
from
from
github
cr.
A
A
A
If
we
come
back
into
our
wasn't
cloud
dashboard,
we
can
use
the
from
registry
feature
to
start
0.1.1
as
soon
as
it's
as
soon
as
it
pushes.
Okay,
now
that
we
do
that,
if
we
do
our
same
curl
command,
we
get
hello,
github
cr
world,
you
know
just
just
showing
that
we
can
make
a
simple
change,
and
our
package
here
will
actually
show
the
recently
tagged
image
versions,
and
you
can
look
at
the
digest
and
everything
here
now.
A
You
know
I'm
going
back
and
forth
and
kind
of
manually
pushing
to
github
container
registry
here.
Just
to
start
the
the
benefits
of
doing
this
we
to
have
an
already
configured
oci
compliant
registry
is
huge,
definitely
useful
for
the
development
process
and
for
when
you
want
to
distribute
your
actor
to
the
outside
world.
A
A
We
can
generate
a
github
action
for
you
that
will,
when
you
push
domain,
build
sign
and
then
release
your
actor
to
github
packages
so
that
the
flow
is
you
know,
it's
we're
essentially
packing
in
some
some
pre-configured
ci
cd
for
you
right
to
build
tests
and
release
your
actor
and
our
goal
for
this
isn't
to
make
it
so
that
you
develop
through
github
cr.
I
think
it's
still
better
to
do
the
local
development.
A
You
know
a
hot
reloading
style
example,
but
this
moves
us
more
in
the
direction
of
making
it
accessible
and
easy
for
people
to
publish
actors
so
that
they
can
be
accessible
publicly.
So
that
is,
let's
see.
I
think
that
is
all
that
I
wanted
to
show
off
today.
Does
anybody
have
any
questions
about
github
container
registry
or
or
this
flow,
or
does
anybody
have
any
comments?
You
know?
Have
you
worked
with
this
before
and
have
ways
to
improve
this.
A
All
right
sweet
well,
so
this
the
the
the
new
version
of
wash
that
I'm
using
a
0.11
and
alpha
release
is
just
to
have
that
annotation.
You
can
actually
do
this
in
with
the
latest
stable
release
of
wash
now,
but
that
annotation
automatically
associates
the
package
with
the
repository.
So
it's
definitely
nice
to
have
moving
forward
once
we
do
the
work
on
the
github
action.
A
A
F
A
G
I
don't
I
am
logged,
I
don't
know
so,
hello,
everyone.
I
am
more
or
less
kevin's
assistant
today
because
he
had
released
something
really
awesome
that
he
might
dropped
at
the
end
of
the
meeting
last
week
and
I
think
it's
worth
sharing,
but
I'm
going
to
let
him
talk
through
it
more
or
less
what
I've
done
for
you
kevin
as
I've
just
pulled
up
the
whole
process
and
curled
it
and
the
code's
here
and
if
you
want,
I
can
actually
pull
up
just
the
github
page
for
you.
If
you
want.
C
E
G
E
It's
so
yeah
last
week
dropped
a
little
something
in
the
meeting
and
what
it
amounts
to
is
that
we
have
regained
support
for
building
actors
and
go
what
you're
looking
at
is
just
an
example
of
what
a
go
actor
looks
like
and
right
now
it's
I
mean
it's
it's
fairly
clean
but
we'll
have
it
even
more
clean.
Once
we
get
the
code
generation
stuff
in
place,
you
know
the
code
generation
stuff
gives
us
the
ability
to
have.
E
E
Is
that
if
you
breathe
on
tiny
go
just
the
wrong
way,
you
will
incur
a
dependency
on
the
syscall
js
package
and
when
that,
when
that
happens,
the
the
webassembly
module
that
tinygo
builds
attempts
to
import
a
bunch
of
stuff
that
only
exist
in
the
proprietary
javascript
library
that
is
used
on
the
server
side
for
go
stuff
and
so
yeah.
Those
imports
like,
if
you
look
at
those
that's
that
is
a
go
specific
import.
E
So
if,
if
you
look
at
your
imports,
when
you're
building
these
modules-
and
you
see
that
you've
got
syscall
js
stuff
in
there,
you
can
pretty
much
guarantee
that
it's
not
going
to
work
in
wasm
cloud
host,
and
you
know
there's
some
philosophical
reasons
for
that.
But
you
know
by
and
large
what
it
means.
What
it
amounts
to
is.
E
G
E
E
It's
not
quite
as
easy,
if
not
impossible,
to
do
that
for
tinygo.
So
I
guess
our
our
strategy
going
forward
is
just
try
and
be
as
diligent
as
we
can
about
not
incurring
the
the
syscall
js
package,
but
every
time
we
do,
we
need
to
bring
it
up
to
somebody
within
the
tiny
go
team,
that's
responsible
for
the
webassembly
support
and
keep
pointing
out
all
of
the
ways
that
it
violates
the
freestanding
rule.
G
E
Yeah
I
mean
the
the
good
news,
though,
is
that
if
you're
using
wasmcloud's
http
capability
provider,
then
you
don't
need
to
import
tiny
goes
http
package
same
goes
for
things
like
random
numbers
and
whatnot.
So
at
least
in
these,
in
these
early
days,
we
should
be
able
to
get
around
some
of
that
stuff
with
just
a
little
bit
of
diligence
in
terms
of
how
we
write
our
libraries.
A
A
A
So
this
morning,
when
jordan,
you
were
kind
of
poking
around
at
this
and
looking
around,
I
went
into
the
gophers
slack.
They
have
a
tiny
good
channel
there
and
was
looking
around
to
see
if
they
have
any
any
workarounds
for
stuff
like
this.
They
do
have
a
wazey
target
for
tinygo,
and
so
part
of
that
will
will
take
all
you
know
some
of
the
assumptions
about
accessing
the
syscall,
js
library
and
move
it
to
the
the
wazi
abi.
A
So
you
know
these
are
just
the.
I
really
wanted
to
bring
it
up
in
the
community
meeting,
and
I
think
it's
important
to
talk
about
that,
because
that
affects
how
we're
adopting
additional
languages
going
forward.
Assuming
that
you're
running
in
a
browser
context
is
something
that
is
a
difficulty
and
a
lot
of
languages.
Do
this
and
are
moving
towards
adopting
a
more
platform
agnostic
way
of
running
web
assembly.
E
Yeah
I
mean
one
of
the
things
is
that
it
really
just
comes
down
to
the
fact
that
the
rust
ecosystem
has
had
several
years
of
support
for
compiling
without
a
standard
lib,
and
so
that
all
the
tooling
all
the
dependency
management.
All
that
stuff
is
literally
years
ahead
of
where
tinygo
is
in
terms
of
no
standard
support.
F
Yeah
yeah,
that's
awesome,
and
this
is
another.
You
know
great.
This
sort
of
lesson
learns
that
I
wish
we
we
should
probably
try
to
capture
as
a
blog
post,
again
yeah
kevin.
I
think
your
post
on
your
point
around
the
wasm
cloud
actors
are
a
way
to
use.
Go
without
running.
You
know.
Shooting
yourself
in
the
foot
here
with
http,
I
think,
is
a
is
a
great
point,
because
that's
something
that
I
think
highlights
the
power
of
of
our
model
and
what
we're
doing
here.
A
A
So
I
have
a
couple
of
different
community
exciting
community
things
that
are
going
on
in
the
the
wasm
cloud
world
and
just
was
in
general
one
thing
that
we
wanted
to
celebrate,
which
we
actually
hit
last
week.
Is
we
just
hit
500
stars
on
the
project
home
page
on
github,
and
we
got
a
hundred
stars
on
the
otp
runtime
which
which
we're
really
excited
about,
shows
some
of
our
community
growth
and
engagement
here,
and
we
just
wanted
to
wanted
to
call
it
out.
A
The
next
thing
that
I
really
wanted
to
yeah
kevin
good:
it's
not
star
quantity,
it's
star
quality!
We
have
the
most
quality
stars
on
all
of
github
next
thing
that
I
wanted
to
bring
up
and
kevin.
You
can
probably
talk
a
little
bit
about
this
as
well.
We
have
an
api
reference
that
we're
we're
pr
into
the
watson
cloud
dev
site.
A
E
E
B
E
E
My
current
thinking
around
it
is
that
we
that
the
reconcile
step
would
just
immediately
issue
all
of
the
commands
that
that
it
thinks
are
necessary
in
order
to
bring
about
that.
That
right,
state
probably
won't
know
whether
that's
the
best
approach
until
we
implement
that
and
poke
poke
and
prod
it
and
see
how
it
works
in
in
real
life.
I
think
the
main
concern
around
pushing
a
new
spec
versus
updating
an
existing
one
is
how
long
it
takes
to
go
from
new
spec
to
having
all
of
that
stuff
fully
deployed.
C
B
E
The
the
lattice
controller
api
yeah
right
now
there
is
no
code
in
you-
know
adam
that
converts
the
output
of
the
reconciler
into
commands
to
be
sent
on
the
linus
control
interface.
That's
just
one
of
the
other
things
that
newton
that
I
need
to
implement,
or
that
needs
to
be
implemented
in
inside
wadom.
A
Yeah
great
that
you
know
this
is
kind
of
the
goal
of
bringing
these
kinds
of
adrs
and
proposals
up
in
the
community
meeting
is
to
get
a
good
conversation
around
it
and
jennifer.
I
know
that
you
put
a
lot
of
work
into
kind
of
the
structure
of
where
wadom
is
today.
So
I'm
glad
glad
you're
here,
for
it.
A
C
Hey
in
a
little
over
two
weeks,
there's
kubecon
eu
the
cloud
native
computing
foundation
conference
in
spain,
and
there
are
a
lot
of
western
cloud
talks
there.
Liam
can
give
a
better
rundown
than
I
can,
but
brooks
and
taylor
are
going
to
be
doing
a
demo
and
keynote,
and
also
I
want
to
shout
out
christoph
brewing-
is
doing
a
talk
on
machine
learning
and
wasmcloud
on
the
rejects
day
on
may
14th.
C
F
E
F
F
Your
kubecon
ticket
includes
a
ticket
to
wasm
day
this
year,
if
it's
remote,
so
you
can
tune
in
on
monday
and
catch
them
before
they
hit
youtube,
although
they
should
hit
youtube
within
three
weeks,
I
think
is
the
sort
of
scheduled
release
time
if
you're
going
to
be
joining
us
on
site.
Let
us
know
on
slack
we're
planning
a
few
events,
maybe
happy
hour,
you
can
join
us
there.