►
From YouTube: Developer Community Call #5 l Marine runtime internals
Description
00:00 Intro
01:11 Identity Link Service project presentation
14:02 Updates from the core team
23:35 Start of the lecture “Marine: general purpose Wasm runtime”
24:09 Agenda
25:01 Fluence architecture snapshot
27:10 Fluence language stack
28:04 Nodes and clients in Fluence network
28:43 What is WebAssembly?
29:43 Lifecycle of a Wasm application
31:32 WASI — WebAssembly System Interface
31:58 WASI imports
32:21 Hello world + WASI
33:05 Interface types
35:25 Marine runtime from Fluence perspective. Fluence service
37:28 Fluence modules type
39:18 Services configuration
41:03 Marine: multi-module Wasm runtime
41:45 Aqua + marine
42:10 Marine architecture
44:30 IValue
45:02 Host closures
48:13 Marine SDK and tools
48:18 Fluence Hello world
49:17 Marine tests: modules testing
51:14 Marine tests: services testing
51:51 How do multi-module calls work
55:39 How fast is it?
57:00 The project overview, useful links
58:28 Discussion, Q&A
Ben Smith “Applied WebAssembly” https://youtu.be/5N4b-rU-OAA
Greeting service example https://github.com/fluencelabs/marine/tree/master/examples/greeting
Marine vm https://github.com/fluencelabs/marine
Rust sdk https://github.com/fluencelabs/rust-sdk
AIR https://github.com/fluencelabs/air
Aqua https://github.com/fluencelabs/aqua
Developer Community Calls Wiki https://www.notion.so/fluencenetwork/Fluence-Developer-Community-Calls-2733beddb3ff4e4986c4fcc830fc796d
Project updates
Twitter https://twitter.com/fluence_project
Newsletter https://fluence.network/
Telegram https://t.me/fluencedev
Discord https://fluence.chat
Speaker: Mike Voronov, mike@fluence.one, tg @voronovm
A
A
Then
some
demos
question
answers
and
then,
at
the
end
today
we
have
a
lecture
by
mike
about
marine,
the
webassembly
iit
runtime,
which
is
going
to
be
super
cool
for
those
who
want
to
stick
around,
which
I
hope
everybody
does
due
to
some
time
constraints
and
scheduling
conflicts
instead
of
the
updates
we're
actually
going
to
start
with
the
demo
we
have
starting
with
boom,
who
won
one
of
the
most
recent
hackathons
and
looking
forward
to
it.
Take
it
away.
Man.
C
B
B
B
B
The
first
one
is
that
identity
linking
request
and
the
second
one
is
identity,
linking
verification,
and
there
will
be
two
components
in
in
this
service.
The
left
hand
side
is
the
browser,
application
and
the
right
hand
side
at
the
top,
the
identity
link
service
and
the
last
one
is
the
third
party
service.
B
Send
the
request
to
the
identity
link
service
which
contain
the
bid
and
github
username
and
after
the
service
get
the
payload,
they
will
generate
a
challenge
code
and
store
the
id
and
github
in
the
cache
after
the
user
get
back
the
response
that
we
have
to
go
to
the
github
and
create
a
public
disk
which
has
to
contain
the
id
after
they
get
back
to
result
from
the
github.
They
can
continue
to
the
second
flow,
which
is
the
identity,
linking
verification.
B
B
B
D
D
D
A
A
Okay,
so
aqua
dht
is
basically
it's
basically
a
distributed.
Key
value
store
and
you
may
want
to
look
at
it.
I
don't
know
why.
Let
me,
let
me
backtrack.
What
are
your
plans?
Are
you
planning
on
doing
anything
else
with
it,
or
was
it
just
for
the
hackathon
and
or
do
you
see
future
use
cases
for
that.
A
A
B
B
But
after
we
we
tried
out,
we,
we
realized
that
the
communication
from
the
the
service
to
the
node.js
in
our
service,
it
cannot
support
the
promise,
so
it
we,
we
have
to
change
the
way
we
implemented
from
synchronous
to
asynchronous.
We
will
have
to
call
it
to
the
destination
service
and
the
the
destination
service
has
to
call
it
back
to
to
the
caller
that
that's
the
the
problem
that
we
we
faced.
F
H
B
H
And
bernard
what
you
said
about
the
aqua
dht
to
use
that
as
to
like
have
like
you,
know,
sort
of
find
out
what
service
id,
for
example,
that
is
used
so
that
that
key
value
store
is
available
to
everyone.
You
know
you
can't
put
security
on
that
right.
True,
so,
if
you,
if
you
want
to
store
something
that
is
secure,
you
have
to
find
a
different
way
to
do
it.
A
A
A
I
Folks,
can
you
hear
me
nice
so
this
week
we
have
a
a
lot
of
the
other
updates
in
different
areas.
Most
of
them
are
on
the
updates
channel
on
the
telegram
that
we
try
to
maintain
as
good
as
we
can.
So.
First
of
all,
we
have
a
the
new
version
of
awkward
list
0.4.1
with
the
new
syntax
edition
of
closures.
I
So
now
you
can
create
anonymous
functions
within
functions.
They
capture
service
resolution
and
data.
So
you
can
take
a
look
at
the
change
log
and
it's
reflected
in
aqua
book
in
the
dedicated
page,
so
that
was
the
first
one
and
besides
this
new
syntax,
it
contains
a
lot.
I
mean
really
a
lot
of
bug
fixes.
I
I
Previously,
parallelism
was
actually
parallel
in
aqua.
Only
if
you
move
the
execution
on
different
peers,
but
currently
it's
parallel
within
a
single
pure
as
well
like
both
in
javascript
and
rust
nodes,
and
it
gives
us
some
new
capabilities
like
for
example.
Now
you
can
express
timeouts
on
the
node,
you
can
say:
please
try
to
do
this
and
if
you
don't
have
a
response
in
this
time,
please
try
to
do
that.
I
I
Features
preparing
for
the
following
days.
I
thought
that
we
will
fix
the
last
big
issue
that
you
are
found
by
the
way,
with
a
stream
usage
inside
folds
and
inside
functions
which
were
not
cleaned
and
that's
a
very
like
strange
behavior
that
you
couldn't
expect.
Hopefully
we
will
fix
it
tomorrow,
working
hard
on
that.
I
Yes,
yes,
I
I,
I
can
explain
it
in
more
detail
if
you
want
so
there's
a
pattern
promoted
in
aquabook
to
use
streams
to
build
values
to
be
used
later.
So,
for
example,
there
is
a
conditional
return
pattern
when
you
create
a
stream
do
if
else,
to
write
into
the
stream
and
then
return
a
value
of
the
stream
like
as
a
scalar.
I
I
I
H
That
sounds
wonderful.
I
I
think
it
was
that
I
I
I
tried
to
start
off
programming.
I
wanted
to
make
like
an
array
of
objects
of
things
that
I
wanted
to
do
and
then
loop
through
them,
and
then
I
run
into
problems
so
then,
in
the
meantime,
I
just
have
to
write
everything
out,
but
now
you
can
do
when
this
is
fixed.
Probably
I
can
try
again
to
do
things
in
loops.
Basically,
if
that
makes
sense,
sorry.
I
I
E
E
E
Anyone
is
is
going
to
be
in
helsinki
or
actually
we
are
we
are
having.
There
is
a
slush,
a
sort
of
like
web
summit
in
northern.
For
northern
europe
there
is
a
big
event,
a
startup
event
and
like
8
000
people
are
coming
to
the
city,
so
we
are
doing
two
meetups
during
during
slash.
If
anybody
is
in
helsinki
very
welcome
just
reach
me
out
in
dm.
I
can
send
you
the
link,
it's
hannah's
home
city,
yeah,
I'll
publish
in
twitter.
A
A
C
Talk
a
lot
about
marine,
our
general
purpose
of
assembly
around
runtime,
the
best
on
interface
types
and
the
shardness
in
linking
scheme,
so
in
particular
the
agenda
of
the
section
is
as
follows.
So,
first
of
all,
I
will
make
additional
overview
of
fluence
so
just
to
I
know
just
to
point
out
and
for
you
to
have
some
thoughts
about
marine
in
in
like
influence
and
how
it's
connected
with
different
clearance
components
with
aqua
ear,
with
services
and
so
on.
So
then
we
all,
then
also
will
be
second
warm-up
section
about
webassembly.
C
C
Yes,
that
could
be
like
could
be
composed
and
the
services
that
expose
some
functions
with
help
of
webassembly
interface
types
they
expose
it
to
the
network,
and
then
this
function
could
be
used
to
like
make
some
big
and
distributed
function.
If
you
could
say
such
thing
and
also
the
services
could
be
both
stateful
or
status
so
and
by
statefulness.
C
Here
I
like,
I
meant
that
they
could
save
their
state
on
hard
drive
or,
for
example,
in
some
databases
or
so
on,
for
example,
on
the
slide,
you
can
see
like
three
services,
one
of
them
called
away,
but
actually
is
one
no
any
difference
between.
Like
obviously
notes
they
could
like
be
both
like
relays
or
just
exposed
services.
C
It
doesn't
matter
so
it's
like
p2p
network
with
some
digits
academia
to
be
precise,
and
on
on
this,
like
on
one
of
the
service,
you
could
see
that
it
connected
with
three
different
services
and
this
one.
These
services
aren't
compiled
assembly,
they
just
general
services,
for
example
ipfs
some.
You
know
major
databases
like
mongodb,
more
edp
and
so
on.
C
So
it's
it's
on
on
the
way,
and
also
that's
why
I'd
probably
have
seen
on
previous
community
calls
here.
You
can
see
like
some.
I
know
some
slice
of
our
network
and,
like
this
network,
consists
of
notes
and
the
clients,
these
clients
here
browsers
and
all
nodes
like
uses
marine,
to
run,
aquavium,
yes
and
to
run
services.
C
C
Let's
dive
a
bit
in
the
web
assembly
and
like
I
really
I
personally
like
very
like
this
white.
So
that's
why
it
was
taken
from
when
means
talk
that
was
on
cppcon
2019,
and
here
you
could
see
like
the
directed
graph
and
moving
from
left
to
right.
You
could
construct
your
own
definition
of
what
is
web
assembly,
and
I
I
cannot
with
this
one
and
so
web
assembly
is
just
a
standard
of
stack-based
virtual
machine
and
probably
for
different
for
other
slides.
C
The
most
important
topic
here
is
that
webassembly
has
only
primitive
types
by
primitive
types.
Here
I
mean
that
they're
only
integers,
basically
integers
and
voicing
points.
There
are
no
any
complex
types
like
arrays
strings
records
and
so
on,
so
they
just
they
just
this.
This
four
or
five
types,
depending
on
version.
C
C
So
just
I
know
just
could
be
considered
as
a
program
or
a
library
or
something
like
that
modules
have
in
person.
Experts
and
the
important
thing
here
is
that
module
so
webassembly
code
from
a
module
can't
access
like
operation
system
services,
for
example.
I
know
can't
access
hard
drive
or
memory
or
something
like
that
without
imports,
so
webassembly
could
just
use
import
to
access
operation
system
services
without
imports.
C
You
could
be
sure
that
webassembly
code
can't
access
anything
except
like
code
inside
module
inside
only
one
module,
yes,
and
just
so
webassembly
provides
you
like
a
weight
sandbox
code
by
design.
So
it's
one
of
the
important
thing
for
fluence
network
and
that's
why
we
are
decided
to
use
like
webassembly
at
the
very
beginning
and
like
expert
could
be
used
as
a
like
as
an
api
of
this
module.
C
Like
the
other
gem
from
the
web
assembly,
world
is
vazi,
so
yz
stands
for
web
assembly
system
interface,
it's
a
standard
so
like
from
the
from
the
wrong
point
of
view.
It
could
be
considered
as
a
standard
for
imports
and
basically
here
you
can
see
like
this
complex
scheme,
how
webassembly
is
constructed
from
different
libraries
for
our
purpose.
It's
important
that
there
are
about
60
imports
that
looks
like
posix
functions
is
like
general
posix
function
from
operation
system
and
the.
C
If
runtime
like,
implement
all
of
this
function,
that's
it
could
run
all
modules
that
come
out
with
vision.
Yes,
it's
very
handy
so,
for
example,
marine
supports
fuzzy
and
every
module
that
compiles
yz
from
different
on
the
side.
You
can
see
modules
compiled
from
rust,
so
just
overall
depend
from
c
plus
plus
and,
like
it
turned
out
that
imports
in
the
result
will
be
the
same
so
and
if
like
runtime
host
or
something
so
whatever
you
called
it.
C
If
it
support
this
like
this
import,
it
could
run
every
module
that
compare
it
with
it's
just
a
way
to
like
to
make
your
system
or
environment
heterogeneous
so
and
the
last
slide
in
the
section
is
right
about
these
types.
As
I
said
on
at
the
very
beginning,
web
assembly
supports
only
basic
types,
only
integers
and
forensic
points,
and
there
is
so
an
of
assembly
consists
of
proposals,
and
one
of
the
most
important
proposals
is
called
interface
types.
C
These
proposals
brings
to
the
webassembly
ecosystem
like
interface
types,
yes,
interface
types
here
could
be
considered
as
a
as
a
wrapper
for
so,
for
example,
imagine
that
we
have
like
a
module.
I
will
call
it
raw
web
assembly
modules
it's
this.
This
like
it
is
the
center
of
the
slide,
and
this
module
could
be
wrapped.
C
Yes,
for
example,
if
you
code
experts
with
some
arrays
some
complex
types,
then
you
need
to
lower
them
and
place
somehow
in
the
the
module
memory
and
then,
and
only
after
that
called
corresponding
expert
and
the
same
for
imports,
but
for
imports
you
need
to
lifting
them.
Yes,
you
need
just
to
leave
them
from
like
raw
state
from
from
the
webassembly
memory
just
to
external
world,
so
is
that
it
and
so
interview
steps
is
very
important
proposal,
but
not
so
many
runtime
supports
them.
C
As
far
as
I
know,
wasn't
time
supports
like
a
part
of
interface
types.
They
developed
a
so-called
vics,
like
extension,
that
is
extension
of
wit,
that
is
intended
for
yz
and
the
marines,
like
our
own
time,
that
support
interface
types,
both
linkedin,
this
module,
linking
that
will
talk
on
the
next
ones.
C
Allow
you
to
implement
this
type
of
linking
the
second
type
of
linking
is
shared
everything,
so
the
difference
here
is
probably
obvious.
One
of
them
like
so
the
difference
here
is
just
what
so
like
which
parts
of
modules
are
exposed
to
to
other
modules.
For
example,
in
shared
muscle
linking
scheme,
only
imports
and
experts
are
exposed
to
different
moto
other
modules
and
all
other
state,
for
example,
memory
table
globals
and
so
on.
They're
like
they're,
private
and
they're,
encapsulated
inside
module
and
start
everything.
C
So
it's
opposite
stations
opposite,
so
everything
is
exported,
so
memory
tables,
globals
and
so
on,
not
only
experts
and
imports.
So
on
here
you
can
see
like
a
scheme
where
there
are
three
services,
one
of
them
called
facade,
the
second
sqlite
and
third
one.
Some
authentication
module
doesn't
matter
which
exactly
and
these
modules
are
composed
together
and
they
form
servers.
So
this
one
is
servicing,
like
you
know,
vocabulary
and
actually
like
mojos
could
be
of
three
types.
C
Second,
one
is
pure
module,
they
just
implement
some
business
logic
and
they
can't
access
to
file
system
and
code,
external
environments,
binaries
and
effector
modules
cloud
can
do
anything.
Yes,
they
can
access
file
system,
they
can
call
external
binaries
and
and
so
on.
So
the
goal
of
this
distinguish
is
just
provide
like
in
the
future,
just
provide
like
some
system.
When
people
could
so
people
who
run
friends
not
could
just,
I
know
they
could
just
say
which
modules
they
they
could
run,
for
example,
by
the
reputation.
C
It
just
as
remember
so
here
you
could
see
like
servers
that
can
that
composed
of
three
modules,
they're
defined
in
some
files,
they
have
different
settings,
probably
like
one
of
the
most
important
and
interesting.
This
one
is
setting
for
yg
here.
You
can
see
that
this
modules
they
have
only
two,
only
one
directory
that
could
that
it
could
access
and
then
like
it,
doesn't
like
more
than
just
sites
and
and
for
this
module
we
could
see
that
it's
our
gateway
or
our
interface
to
code
mounted
binary.
C
They
just
called
through
coi,
because
now
yd,
like
the
yz,
doesn't
support
unique
circuits
it
circuits
at
all,
and
that's.
Why
is
the
most
easiest
way
to
call
external
binaries
is
just
through
coi
and
this
scheme
you're
using
and
for
example,
if,
like
anyone
seen
our
curl
adapter,
it
uses
a
kuro
like
a
binary
from
a
system
that
is
x
like
that
is
mapped
to
this
binary
on
a
file
system.
C
Okay
and
from
I
know
from
like
also
service
perspective
of
you,
marine
could
be
considered
like
as
this
as
marine
could
load.
Several
services
that
consist
of
several
modules,
like
only
factor
modules,
could
access
operation
system
called
mounted
binary
and
so
on.
Services
are
completely
isolated,
they
have
for
their
own
another.
They,
for
example,
modules
from
like
one
service,
could
call
only
modules
from
this
service
and
can't
call
modules
from
different
servers
and
except
the
interpreter.
C
C
C
So
this,
like
this
pattern,
is
widely
used
in
computer
games
or
some
plugin
system
and
something
like
that
because,
for
example,
plugin
here
could
be
just
a
web
assembly
module
or
assembly
code,
and
it's
really
like
it's
real
use
case
for
such
system
and
like
starting
from
a
from
the
ground
on
a
very
low
level.
We
have
so-called
engine
that
has
such
api.
C
C
Also,
you
could
vote
in
adult
modules
and
in
config
you
could
specify
all
settings
that
you
previously
seen
on
a
slide
that
was
devoted
to
setting
service
settings.
Also,
you
could
obtain
a
interface
of
module,
so
all
functions
that
is
exported
and
imports
that
it
has
and
also
obtain
it
wisely
state.
C
C
It
contains
a
lot
of
constructors
and
a
lot
of
like
support
several
variants
of
marine
creation.
It
defines
like
a
handy
hosting
board
that
we
also
seen
see
on
the
next
slides
and-
and
here
you
can
see
like
I
value
that
we
have
that
we
have
seen
this
value
is
just
basically
enum.
That's
like
contains
all
types
that
we
are
supported
now,
so
we
supported
like
records,
arrays
byte,
race,
strings,
so
byte
race
here
is
just
to
is
like
designed
to
like
for
better
performance.
C
C
So
the
problem
for
lowering
and
lifting
values
from
webassembly
memory,
because,
for
example,
like
webassembly
like
supports
on
neural
types
and
to
pass
string,
you
just
need
to
like
lower
it
like
by
by
hand
it's
just
to
thinking
about
how
to
place
into
memory
and
then
in
a
on
a
like
a
wasm
just
how
to
like
lift
it
from
a
memory
and
so
on.
So
just
a
lot
of
a
lot
of
work,
and
here
it's
solved
for
you.
C
So
let's
see
some
example
host
closures.
Here
you
can
see,
like
example,
that
code
as
I
call
external
binaries,
that
we
have
seen
in
the
server's
configuration
so
remember
cool.
So
here
you
can
see
how
it
could
be
like
constructed.
So
in
my
opinions,
like
it's
easy
as
possible,
so
you
could
just
receive
for
like
this
scenario,
all
types
and
code
so
functions
that,
like
do
all
job
of
calling
external
services,
it
doesn't
important
for,
for
this
example,
and
then
just
convert
result
here.
C
C
To
a
module,
so
module
will
call
disclosure
and
obtain
such
result
and
just
to
like
make
it
provide
the
marine
information
about
types
and
about
some
linking
that,
like
some
linking
information
that
that
runtime
must
know
to
link
your
host
expert
to
some
module
import.
So
you
just
should
feel
this
several
fields
just
specifying
argument,
types
and
output
types
so
and
basically
that
it
just
an
example
of
exposure.
C
Okay,
let's
move
on
to
the
minus,
decaying
dose,
so
actually
on
previous
community
call.
We
have
a
great
workshop
about
about
sdk,
so
I
will
just
like
consider
several
examples.
So
here
you
can
see
like
how
fluent
whole
world
could
be
constructed.
Yes,
just
six
lines
of
code
with
help
of
the
procedure
macro
marine
and
also
like
comp
more
complex
examples
also
are
supported.
C
For
example,
you
could
use
imports,
so
it's
imports
sooner
like
how
it's
could
be
written
on
rust
and
in
the
six
imports.
You
could
use
some
structures,
vector
of
structures
and
return,
also,
some
like
vector
structures
and
structures
itself.
Also
you
could
use
you
could
pass
them
by
my
link,
well,
not
by
value.
So
it's
looks
like
when
you
arrest
code
also.
We
have
a
second
macro
called
marine
test.
C
Probably
we
like,
we
didn't
cover
it
all
on
a
previous
workshop
or
made
it
very
briefly
so,
and
here
is
example
of
how
it
could
look
like
for
a
greeting
service.
So
remember
so
this
is
greeting
service
or
recent
module.
Yes,
so
service
could
could
be
composed
from
one
module
and
like
if
you
have
only
one
function.
If
you
want
to
test
it,
and
this
function
just
receive
string
and
return
string
and,
for
example,
imagine
that
we
want
to
pass
empty
string
and.
C
And
then
the
check
that
everything
works.
Fine,
so
just
only
five
lines
that
you
need
to
write
so
just
provide
marine
test
with
like
places
for
modules
like
are
located
on
your
file
system
and
where
configuration
file
for
a
service
that
here
consists
only
from
one
module
so
and
basically
that's
it.
Also.
This
code
can't
compare
the
web
assembly
and
right
and
like
doesn't
run
from
like
inside
of
assembly.
C
This
code
is
run
as
a
like
as
a
rough
code
on
a
host
site,
and
also
it's
distinguished
from
other
test
pattern
from
different
runtimes,
and
here
is
like
the
the
benefit
of
such
approach.
Is
that
such
like
such
approach
provides
you
a
way
to
test
more
like,
as
closest
to
the
like,
as
it
run
in
the
wild
as
possible,
because
it's
you,
for
example,
if
you
compile
the
web
assembly,
then
as
a
result,
could
sub
to
the
subtotal
different.
C
C
My
process
data
here
will
be
run,
export
function
from
a
service
from
its
facet
module.
So
basically,
is
it
about
testing
and
let's
take
the
details,
how
interface
types
works
and
how
like
multi-module
goes
under
the
hood.
So
imagine
that
you
have
like
url
download
service
that
consists
of
three
modules,
and
for
each
of
these
modules
there
will
be
vastner
instance.
Yes,
we
use
vasmir
under
the
hood
and
for
each
import
and
4-h
expert
there
will
be
a
dedicated
interpreter.
C
It's
real
interpreters
that
will
interpret
interface
types
instructions
and
imagine
that
we
want
to
call
function
called
kuru
from
like
module
cool
like
from
from
phosphate
module.
Finally,
and
to
do
all
this,
there
will
be
some
some
interface
types
instructions
that
should
be
called
so
here
you
could
see
a
provoke
of
import
adapter
for
this
invert
in
the
facade
module.
C
A
C
A
C
Webassembly
function
and
like
that
this
function,
like
I
called
like
row
of
assembly
function.
Yes,
because
we
like
lower
memory
and
over
memory,
provides
two
values
on
the
stack
pointer
and
size,
and
with
these
two
values
we
call
real
function
from
a
crew
service.
Finally,
after
that,
we
need
to
pass
result
back
to
the
phosphate
module
and
for
that
we
lift
memory
back
the
result,
the
result
string.
C
Yes,
memory
of
result,
string
and
pass
them
back
to
import
adapter
of
this
module
for
set
module,
and
then
we
need
to
go
over
it
again
over
for
phosphate
module.
So
this
is
basically
scheme.
We
just
lift
memory
from
fossett
modules
and
pass
it
to
expert
adapter
of
guru,
module
lower
it
to
call
raw
function
from
coral
module,
then
lift
it
back
and
provide
it
like
in
a
lifted
form.
A
C
A
A
C
Microseconds,
so
basically,
it's
all
that
I
wanted
to
talk
about,
and
today
we
have
covered
several
topics
like
the
most
important
marine
and
the
raster
decay,
and
also
I
considered
the
air
and
aqua
a
bit
and
all
this
project
is
you
so
they're
open
source
you
could
found
by
this
link
and
also,
I
think
you
like
know
about
how
to
obtain
project
updates,
but
probably
for
some
person
who
will
see
this
on
youtube.
Probably
I
need
to
speak
it
back
again.
So
actually
we
have
a
twitter.
C
A
A
C
So
basically
now
it's
like
it's
always
in
terms
that
it's
you
always
like
you'll,
be
in
in
the
in
the
memory
of
marine,
as
there
are
no
any
way
to
just
no
unload
memory
to
file
system,
but
probably
so,
actually
we
discussed
it
previously,
but
I
haven't
got
time
to
implement
that.
Probably
it
will
be
good,
no
good
addition
to
marine.
C
A
E
A
C
H
I
Well,
why
not?
There
is
a
oh.
I
don't
exist,
hello
generally
speaking,
it
doesn't
matter
what
exists
inside
an
external
blockchain
or
a
service
or
whatever,
especially
if
it's
a
blockchain
from
the
integration
point
of
view
anyway,
it's
external,
so
you
need
to
make
an
effector
as
a
dedicated
assembly
module
within
this
marinex
system.
I
H
Well
yeah,
I
was,
I
was
thinking
about
this
question
for
the
last
few
minutes
and
I
realized
it
was
sort
of
a
stupid
question,
but
I
wanted
to
ask
you
anyway,
because
basically,
the
problem
is
that
the
blockchain
is
running
over
like
thousands
of
computers,
so
the
call
will
come
thousand
times
so
it's
like
anyway.
Sorry.
C
H
I
I
H
A
A
C
Yes,
I
I
just
I
just
had
it
in
my
mind
when
I
talked
about
it
so
actually
actually
with
maureen.
I
believe
that,
probably
in
the
future,
you
could
you
could
use
it
like,
instead
of
dockers,
in
several
kind
of
tasks
just
to
run
and
then
just
run
small
processes
or
process
that
really
so
they
they
just
need
only
isolation
and
just
need
some
boxing
and
not
entire
docker
docker
system,
guardian
marine
or
sorry
guys
in
aqua.
C
C
C
Docker
because,
for
example,
if
you
want
some,
I
know
some
if
you
want
some
environment
when
you
have
your
databases,
your,
I
know
some,
for
example,
I
don't
know
which
one
marine
or,
for
example,
like
mongodb.
Yes,
it
couldn't
be
compiled
to
web
assembly
now
and
probably
in
the
nearest
feature
also
and
some
other
services
that
also
can
be
compiled
by
somebody.
So
then,
of
course,
you
so
it's
better
to
use
docker.
A
C
So,
as
I
said,
we
have
like
on
go
on
project
that
what
are
you
working
on
and
this
project
is
intended
to
like
to
allow
you
to
run
wineries
of
assembly
binaries
compared
with
marine?
Not
with
vast
mangan?
Is
that
now
in
a
browser?
So,
for
example,
in
the
future,
it
will
allow
you
to
run
aqua
vm.
That
is
you'll,
be
saying
for
browser
and
from
node
site,
because
now
it's
a
subtle
difference,
like
basically
difference
in
the
export
or
how
expert
works.