►
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
So
this
is
the
echo
actor
written
in
rust
and
if
I
were
to
go
ahead
and
just
start,
my
my
second
actor
right,
we'll
see
that
this
is
the
string
we've
been
getting
and
all
of
a
sudden.
If
we
refresh
we
start
getting
this
magic
number
field
populated,
which
is
actually
using
the
built-in
rust
random
number
generator.
That
comes
wasn't
cloud.
So
what
we
have
is,
you
know,
http
request
coming
in
hitting
our
ecto
echo
actor.
B
Our
echo
actor
is
like,
I
need
the
winning
lotto
numbers
and
only
go
can
do
that,
so
it
reaches
out
to
our
go.
Actor
gets
the
winning
lotto
numbers
and
you
know,
starts
including
it
in
our
body
and
then,
if
we
go
to
the
point
of
you
know
killing
this
off,
you
know
we
get
normal,
echo
active
behavior
again,
and
it's
just
one
thing
I
wanted
to
show
because
it
got
me
really
excited
because
it
allowed
me
to
realize.
Like
oh,
not
only
can
my
much
smarter
counterparts
write
this
amazing
rest
code.
B
B
You
know
it's
the
exact
same
echo
actor
that
wash
you
know,
new
actor
generates,
except
that
you
know
when
we,
when
we
build
when
we
when
we
use
the
the
wash
gin
on
that
custom
smikey
file
like
this
right.
All
we
do
is
we
say
hey.
We
want
to
be
able
to
talk
after
the
actor
and
we
want
to
be
able
to
get
a
number
or
we
want
to
return
our
our
winning
water
members
right
and
then
it
generates.
B
You
know
I'm
not
a
rest
guy.
It
generates
all
this
which
you
know
we
can.
Someone
can
talk,
talk
to
a
little
better
than
me,
but
what
what
that
gives
us
is
sorry
now
we
could
actually
say:
hey
go
to
our
magic
number
actor,
which
this
is
the
the
key
to
our
go
actor.
If
you
were
to
do
you
know
wash
whatever
it
is
that
that
shows
the
information
about
the
actor.
This
would
be
the
module
key.
B
B
I
was
writing
something
a
few
weeks
ago
and
got
to
the
point
where
you
know:
go,
can't
really
use
its
json
library
yet
in
webassembly
because
of
the
you
know
the
imports
it
brings
in,
but
I
played
with
this
and
what
I
got
to
do
is
I
was
able
to
send
a
blob
to
a
rust
actor
and
it
unmarshaled
all
the
data
stuck
it
into
a
smithy
type
object.
What
do
we
call
them.
B
Smithy
whatever
and
then
the
go
was
actually
able
to
get
that
back
on
the
wire
and
iterate
on
it,
which
was
very
cool
because
it
kind
of
got
me
around
my
inability
to
on
marshall
json,
so
yeah,
that's
kind
of
my
demo
for
the
day,
the
side
demo
that
you
may
or
may
not
have
noticed.
Where
is
my
little
button
to
put
sharing
screen?
Oh
there,
it
is,
if
you.
B
A
A
B
B
B
I
have
it
on
marshall,
the
json
put
it
into
a
smithy
object
and
return.
The
smithy
object
over
the
wire,
and
then
at
that
point
because
of
the
the
shared
libraries
that
they
you
know
the
the
smoky
file
generates.
I
can
actually
pull
out
the
fields
in
the
in
you
know
in
the
newly
marshaled
object,
which
is
my
my
this
was
my,
I
don't
call
it
a
hack,
but
my
little
way
around
json
objects.
The
thing
it
doesn't
do
is
like
unstructured
data
right.
My
data
would
have
to
be
structured.
A
Yeah
this
this
is
such
a
cool
part
of
the
demo,
because
I
know
that
this
specific
use
case,
like
the
the
struct
or
like
json
marshaling,
is
kind
of
a
temporary
downside
of
using
tiny
go
like
standalone
web
assembly.
But
this
is
really
cool
for
the
future
of
like
a
composable
application
with
webassembly.
A
You
have
something
that
rust
does
really
well,
and
you
want
to
write
most
of
your
program
and
go
so
you
write
your
program
and
go
and
you
just
call
out
to
a
rust
module
where
its
strengths
are.
This
is
exactly
kind
of
the
basis
for
for
part
of
what
inspires
the
the
webassembly
component
model.
It's
really
cool
to
see
this
actually
working
in
a
in
a
real
scenario,
where
there's
a
downside
of
one
language
that
another
language
kind
of
works
for.
A
B
Yeah,
so
I
won't
take
much
or
any
credit
for
this,
because
I'm
pretty
sure
you
and
kevin
wrote
most
of
it.
I
just
filled
out
some
to
do's
and
and
and
what
I
found
is
you
know
the
real.
The
real
challenge
was
like
understanding
like
what
the
the
conversation
looks
like
over
the
wire
right,
the
the
provider
spins
up.
B
You
know
that
we
can
do
easily,
but
you
have
to
know
like
what
type
of
messages
you
know
to
expect
from
you
know,
wasn't
cloud
host
and
how
to
invoke
it
and
how
to
sign
the
jwt
and
and
whatnot
so
really
most.
The
challenge
was
around
since
I
pretty
much
got
given
all
the
definitions
for
me.
Thank
you,
books
and
kevin.
B
I
just
had
to
implement
the
the
jwt
and
the
signing
of
it
yeah
and
then
once
you
just
understand
like
what
fields
correspond
to
like
you
know,
this
private
key
needs
to
be
here.
This
public
key
needs
to
be
here
and
how,
in
keys,
you
know
how
to
use
their
library
to
like
pull
a
public
key
out
of
a
c
key
and
whatnot.
B
It
was
actually
pretty
straightforward.
It's
just
where
I
think,
like
wascap
and
and
a
few
other
libraries
give
the
rust
capability
provider
some
like
functionality.
Just
by
importing
the
library
it
all
had
to
be
custom
rolled
and
go.
But
now
that
I
have
a
scaffolding
I
can,
I
can
see
what
pieces
can
be
extracted
and
put
into
a
library
if
that's
the
best
way
to
go
kevin
says
something
about
a
cffi
that
goes
above
my
head.
A
Yeah
it'd
be
really
cool
to
see
some
of
this
stuff
in
like
we
can
call
it
experimental
too.
If
you
want
like
a
wascap,
go
or
you
know,
the
wasmbus
go
just
kind
of
libraries
that
assist
with
poking
around
because
it
would
be
great
to
use
some
go
libraries
and
a
capability
provider,
and
that's
how
that's
how
it
all
starts.
C
Yeah,
I
finally
managed
to
hit
the
right
button
for
that
yeah.
The
I
just
wanted
to
comment
on
just
how
awesome
this
demo
is
and
there's
an
amazing
amount
of
stuff
that
needs
to
happen
properly,
for
a
provider
to
talk
securely
to
a
wasm
cloud
host
and
the
fact
that
you
know
jordan
just
got
it
working
like
it
was
no
big
deal.
A
B
D
B
So
specifically,
like
I
know,
I
I
think
I
asked
you
something
like:
is
it
like
a
wascap
go
library,
something
wasn't
cloud
would
be
looking
to
do.
I
know
you
said
something
about
you'd,
be
more
interested
in
like
cfis,
which
I
had
to
google,
I
yeah.
So
I
don't
it's
kind
of
like
what
what
route
would
we
go
like?
What
would
I
share
to
make
it
so
people
could
just
like
use
parts
of
this.
C
C
C
We
would
just
want
to
make
it
so
that
the
developer
experience
is
as
easy
for
go
providers
as
it
is
for
rust
providers,
and
hopefully,
when
we
start
getting
into
things
in
that,
you
know
the
rainbow
scenario.
When
we
have
wazzy
providers,
then
the
wesley
capability
providers
will
make
language
choice
for
the
provider
as
irrelevant
as
it
is
for
the
actor.
C
And
then
we
can
take
advantage
of
the
component
model
to
have,
let's
say
a
webassembly
component
that
takes
care
of
enkei's
stuff,
and
nobody
really
cares
how
it
implements
it
or
whether
it
gets
some
of
that
functionality
from
the
host.
You
just
use
that
component
and
you
know
code,
your
your
stuff
against
the
weight
interface,
and
this
is
all
the
utopia
we're
all
looking
for.
A
A
D
A
E
There
we
go
all
right
so
today
we're
going
to
talk
a
little
bit
about
wash
build,
which
is
a
new
command
and
wash
to
streamline
the
the
building
process
of
actors
and
the
signing
process
of
actors.
This
is
mainly
it's
an
improvement
of
developer
experience
primarily
for
the
for
the
new
user,
so
they
don't
have
to
interact
with
lots
of
different
tools
such
as
make,
which
is
the
main
thing
we
use
right
now.
E
Okay,
here
we
go
so
we
have
this
new
project
file,
our
project
folder,
and
you
can
see
we
have
these
two
makefiles.
This
is
the
existing
system
we
have.
This
is
kind
of
the
compiler
make
file,
which
has
all
the
different
commands
that
we
run
to
to
build
actors
to
sign
actors
and
push
them,
and
then
we
kind
of
have
this
other
make
file,
which
is
almost
a
config
file.
Has
the
project
name
has
the
version,
but
this
is
kind
of
not
that
intuitive
to
new
users.
E
E
Called
wasn'tcall.,
so
this
is
our
new
config
file
that
I've
been
working
on
and
then
you
can
see
it
over
here
it's.
This
is
kind
of
the
minimal
example
of
this.
The
minimum
number
of
things
you
can
use
to
then
build
an
actor
and
sign
it.
So
we
have
the
language
and
the
type
which
is
an
actor
or
that
could
be
provider,
and
then
we've
got
the
name
of
the
actor
and
the
version,
and
then
finally,
you
have
kind
of
actor
and
provider
specific
configs.
E
E
So
we
let
this
compile
for
a
second.
Basically,
what
this
will
do
is
build
the
actor
using
in
this
case
cargo,
because
it's
a
rust
actor.
So
it
takes
that
that
rust,
config
and
starts
using
cargo
in
a
go
actor's
case.
Washbuild
would
recognize
its
go
and
run
the
correct
compiler
for
that,
and
so
then,
once
this
is
finished
compiling
it
will
immediately
then
sign
the
actor
and
spit
it
out
in
the
build
folder.
This
is
what
exactly
the
same
thing
the
makefile
did,
but
this
is
just
a
lot
simpler.
E
A
lot
easier
for
new
users
to
understand
you
know,
run
wash
builds
this.
This
builds
everything
you
don't
need
to
go
into
the
make
file
or
edit
any
kind
of
makefile
variables.
So
we'll
let
this
finish.
Compiling
and
I'll
show
you
that
and
then
the
the
further
step
on
this
is
to
even
more
enhance.
This
experience
is
to
add
this
straight
into
pushing
the
actor
to
the
registry.
This
isn't
implemented
yet
so
we're
going
to
work
on
kind
of
on
top
of
this.
E
But
for
now
we
have
you
know
it's
just
done:
building
actor
signs
the
actor
successfully
signed
and
then
over
here
on
the
build.
We
have
the
built
actor.
I'm
not
writing
the
registry
right
now,
so
we
can't
take
a
look
at
the
actor,
but
this
is
the
same
act
you
get
from
the
make
files
that
exist
right
now.
This
is
just
a
lot
easier
way
to
do
it
a
lot
more
user-friendly
understanding
of
you
know
you
have
this
conflict
value.
You
have
this
wash
tool
that
you
just
installed
already.
E
A
I
just
gotta
say
this
is
super
slick
you're.
You
know.
I
know
that
part
of
the
concern
when
we
were
looking
at
this
was
like
config
language
choice
like
json
or
tommel,
or
you
know,
people
who
work
in
javascript
environments
don't
know
tomml,
but
your
minimal
example
is
like
like
it
is
not
hard
to
parse
at
all.
You
only
have
to
specify,
I
guess
if
you
have
an
actor
with
no
claims
like
four
things,
like
the
name
of
the
actor
and
the
version
and
language
you
know
that
stuff.
E
E
C
A
E
Yeah
yeah,
this
doesn't
touch
the
make
file.
I'll
show
you
again,
there's
we
just
I
just
deleted
to
make
fall
straight
up
out
of
this,
this
folder
so
yeah
we
once
this
is
finished.
I
need
to
finish
adding
the
go
stuff
and
there's
all
sorts
of
other
kind
of
edge
cases
that
need
to
be
added,
but
yeah
once
this
is
kind
of
into
wash.
We
won't
need
them.
It
fells
at
all.
A
Nice,
I
personally
don't
have
an
issue
with
makefiles
I
kind
of
like
them,
but
they
do
introduce
shoes,
sometimes
like
the
version
of
make
that
ships
on
mac
is
not
the
newest
one,
and
installing
make
on
windows
is
a
huge
pain.
You
gotta
like
go
to
a
website
that
looks
like
it
was
made
like
30
years
ago
and
doesn't
even
feel
real,
so
this
is.
This
is
really
cool
to
change.
A
E
Yeah,
I
think
that
the
biggest
thing,
from
my
perspective,
at
least,
is
just
if
you're,
a
new
user
say
you
don't
use
making.
You
know
whatever
current
tool
chain.
You're
in
you,
don't
you
just
install
one
thing
wash
now,
instead
of
having
to
go
install
make
if
that's
not
existing
your
computer
already,
and
it
just
reduces
that
cognitive
overhead
of
kind
of
oh,
I
need
make
as
well
as
wash
like.
Why
do
I
need
these
two
tools
so.
D
That's
really
bad
for
people
on
windows.
I
completely
forgot.
I
was
writing
something
on
windows,
because
every
once
in
a
while,
I
just
try
to
to
make
sure
everything's
still
working
and
when
I
did
that
I
went
and
did
it
without
thinking
like
typed
make
and
it's
like
make.exe
not
found-
and
I
was
like
like
and
then
there's
all
this
stuff.
That's
in
those
files
that
was
if
it
was
making
me
go
like
crap.
D
Well,
then,
I
have
to
like
re-engineer
this
or
install
make,
and
so
it's
nice
to
have
that
that
starting
point,
but
this
is
really
cool
to
see.
This
is
something
I've
been
hoping
to
do
and
envisioning
for
a
while,
and
so
when
you
opened
up
the
original
rfc
a
couple
months
ago,
I
was
like
I'm
not
the
only
one.
E
I
don't
think
it's
quite
ready,
yet
I
still
need
to
finish
this.
The
go
actors.
I
was
getting
errors
with
them
so
far,
so
I
need
to
kind
of
finish
the
compiling
of
that
and
and
get
those
to
work
so
not
yet,
but
I'll
I'll
I'll
move.
I
think
it's
a
draft
pr
right
now,
so
I'll
move
it
to
a
to
a
regular
pr
when
it's
ready
to
go.
A
D
Was
just
gonna
add
another
like
shout
out
for
the
for
the
wasm
day
this
year.
It
is
really
like
I've
heard
from
some
of
the
other
people
are
speaking.
I
don't
know
if
the
schedule's
actually
out
so
too
bad.
This
is
getting
recorded
and
people
know
I'm
I'm
leaking
leaking
things
early,
but
I
just
want
to
point
out,
like
I
highly
recommend,
like
encouraging
co-workers
and
and
friends
and
whatever
to
attend
this,
like
the
conference
this
year
is
going
to
be
really
cool.
D
There
are
some
really
cool
stuff
that
people
are
going
to
be
showing
off
from
all
across
the
wasm
space
and
tons
of
different
companies,
and
I
mean
it's-
it's
really
cool,
so
I
I
saw
some
of
the
stuff
that's
coming
in
and
I'm
like
this
conference
is
going
to
be
really
like
legit
this
year,
so
it
always
has
been,
but
there's
just
there's
a
lot
of
stuff,
that's
coming
in
into
the
pipeline
this
year.
That
people
are,
I
think,
are
really
going
to
enjoy.