►
Description
wasm-ipld demo and discussion - presented by @aschmahmann at IPFS þing 2022 - IPFS and WASM - https://2022.ipfs-thing.io
A
All
right,
hey
everybody!
I
want
to
talk
to
you
about
wasm
ipld,
which
is
a
library
that
I've
been
working
on
recently
to
try
and
explore
what
it
might
look
like
to
do.
Some
of
these
webassembly
things
to
support
ipld
use
cases,
so
so
why
there
are
lots
of
reasons
why
you
might
want
to
use
ipld
and
lots
of
reasons
why
you
might
want
to
use
webassembly
for
me.
A
What
I
wanted
was
a
portable
set
of
tools
of
ipld
tools
written
in
rust
at
the
moment,
because
I
don't
want
to
rewrite
codecs
and
adls
and
go
and
rust
in
javascript
and
python
and
wherever
else
simply
the
function.
The
idea
of
like
getting
unix
fs
readable
in
all
of
these
platforms,
where
you
don't
have
to
like
delegate
out
responsibility
to
someone
else,
to
verify
that
your
self-certified
data
works,
so
like
you
can
certify
it
yourself
is,
is
already
hard.
A
A
A
Loading
of
modules
and
rust
is
sort
of
nice,
because
ffi
is
another
one
of
these
big
interoperability
tools
that
exist
out
there
right
everything
was
ffi,
then
you'd
get
a
lot
of
compatibility
in
places
that
can
can
use
that
which
is
many
programming,
languages
and
environments,
and
it
has
some
of
the
more
mature
webassembly
tool,
and
I
don't
know
I
keep
having.
I
keep
having
some
some
colleagues
that
tell
me
that
rust
is
better
than
sliced
bread.
So
I
figure
I
should
learn,
and
I
learn
by
doing
so.
A
A
Ipldcodex
they
basically
transform
bytes
into
the
data
model
and
the
data
model
back
to
bytes.
This
is
the
function,
so
I
tried
something
like
all
right:
let's,
let's
do
a
webassembly
thing
that
does
just
codecs
bytes
data
model
data
model
bytes
and
trying
to
actually
like
build
a
you
know,
sort
of
build
a
data
model
object
like
have
your
map,
fill
it
up
with
values.
Things
like
that
and
calling
functions
across
the
webassembly
boundary
is
like
really
no
fun.
A
It's
no
fun
because
you
have
to
expose,
like
all
these
sort
of
opinionated
functions
on
how
to
do
so
and
it's
the
rust,
tooling
again
mature,
but
not
helpful,
because
if
you're
not
targeting
javascript
you're
sort
of
left
to
your
own
devices,
I
work
on
this.
This
program,
written
in
go
called
kubo
that
some
of
you
may
have
used,
and
so
you
know
what
that's
sad
for
me.
A
If
I
want
to
make
it
work
in
in
that
environment
and
and
the
pr
and
even
if
all
of
the
tooling
was
there,
the
performance
is
not
good
because
you
have
to
keep
calling
across
the
boundary
over
and
over
again.
So
the
question
was
what,
if
we
could
form
a
bi-directional
serialization
of
the
ipld
data
model
and
move
from
the
serialized
representation
to
bytes
and
decode
from
bytes
to
the
serialized
representation
of
the
data
model,
which
is
this
thing
I
wrote
called
called
whack
the
webassembly
codec.
A
A
The
idea
is,
it's
supposed
to
be
a
concrete
representation
of
the
data
model
and
easy
really
easy
to
implement.
Like
I
implemented
a
couple
of
times,
it's
like
a
few
was
like
a
couple
hours
or
something
like
that,
because
it
has
to
be
in
all
of
the
hosts
languages
so
that
they
can
operate
with
it
right
your
we,
we
have
this
code.
The
code
will
move
around,
but
then
the
code
has
to
interact
with
the
outside
world.
That
outside
world
requires
an
interface
and
then
you're
going
to
have
to
code.
A
All
of
your
hosts
against
that
interface,
all
right
adls,
so
codex
are
bytes
to
data
model.
Adls
are
basically
data
model
to
data
model.
Bytes
are
part
of
the
data
model,
so
adls
are
basically
a
generalization
on
on
top
of
on
top
of
codecs
there's
not
a
specification
of
like
when
you
do
an
adl.
It
must
look
exactly
like
this,
but
do
we
even
have
one
for
codex?
So
if
you
look
around
at
the
implementations
of
codecs
that
exist
today,
they're
all
pure
functions
basically,
but
they
don't
have
to
be
most
programming.
A
Languages
like
make
it
very
hard
to
implement
like
a
pure
function
and
enforce
that
it's
pure
and
you
could
do
all
sorts
of.
Like
call
outs,
you
could
write
a
codec
in
any
language
that
you
use
for
ipld
things
today
and
almost
certainly
you
could
have
a
function.
That's
like
use
random
number
and
insert
here.
You
wouldn't
want
to
do
that,
but,
like
you
could,
but
I
think
it's
reasonable
to
say
that
codecs
are
probably
pure
functions.
A
A
A
Adls
can
like,
if,
assuming
you,
have
a
block
limit
of
some
sort
right
now,
two
megabytes
in
most
implementations
that
do
this
thing.
You
can
probably
handle
all
of
that
adls.
You
can
reference
tremendous
amounts
of
data.
We
have
these
humongous
trees,
and
so
I
can't
just
like
serialize
my
like
one
terabyte
of
data
and
like
send
it
across
the
webassembly
boundary
and
like
have
it
all
be.
Okay,
like
I
have
to
have
like
partial
functions,
to
work
with
them.
A
Interestingly,
in
order
to
do
some
of
the
compatibility
things
that
I
would
like
to
do
right
make
it
make
it
so
we
can
generalize
over
git
and
bittorrent
and
care
gusts
and
nfs,
and
anything
else
that
does
this
sort
of
thing
we
we
have
to
deal
with
the
block
limit
problem
which
limits
our
compatibility,
because
if
my
ipfs
tooling
will
only
move
around
two
megabyte
chunks
and
you've
decided
that
you
have
10
megabyte
chunks
that
are
also
still
hashed,
then
then
we
have
a
breakage.
So
we
have
to
do
that
problem.
A
Okay,
so
what
I
do
when
I
was
trying
to
implement
this
this
adl
stuff,
which
is
where
most
of
the
complexity
lies.
I
got
around
almost
all
of
the
codec
stuff,
very
easy.
With
this
webassembly
codec,
like
serialization
thing,
I
decided,
let's
just
experiment,
we're
exploring
and
seeing
how
this
goes
trying
to
learn
from
this.
A
A
A
Maybe
we
need
more
partial
axis
functions
for
sub
ranges
on
strings
and
lists.
Maybe
we
need
recursive,
adls
or
maybe
they're
a
bad
idea
right
now.
You
sort
of
the
only
the
only
call
back
from
an
adl
from
from
webassembly
to
the
outside
world
is
to
ask
for
blocks,
but,
like
I
could
construct
it.
So
maybe
I
could
have
adls
call
other
adls.
A
For
example,
you
could
have
like
a
load
codec
adl.
That
says
I
have
like
a
bunch
of
bytes
and
I
have
a
little
field
in
front.
That's
like
it's
dag,
json.
Okay,
let
me
go
call
the
dag.json
encoder
to
go
decode
this
data
and
then
start
working
with
it
or
do
other
fancy
things
like
say.
I
need
to
go
fetch
this
cid
and
then
go
execute
it
and
do
stuff
like
that
on
on
the
data
right.
A
If
you
allow
for
parameters
inside
of
adls,
you
basically
get
the
decryption
stuff
that
that
one
mentioned
right,
because
you
can
say
you
know,
interpret
this
thing
as
I
need
to
decrypt
you
with
aes
parameterized
by
key
right,
and
that
will
make
it
that
will
make
it
work,
experience,
learning
from
webassembly
and
and
how
how
we
did
this
is
that
there's
a
lot
of
every
everything
that
web
assembly
feels
like
dealing
with
is
like
an
integer.
It's
all
you
get
is
integers
everywhere.
A
As
far
as
the
eye
can
see,
integers,
and
so
everything
is
like
alak
fill
a
buffer
into
integer
is
the
buffer.
You
know
have
a
pointer
to
the
buffer,
that's
an
integer
move
it
along
and
then
figure
out
how
you're
going
to
do.
Freeing
yeah,
as
I
mentioned,
the
webassembly
bindings,
seemed
to
only
be
useful
for
for
javascript,
so
had
to
basically
have
to
like
make
up
an
abi
that
was
going
to
work
and
go
in
in
other
environments,
and
we
see
representation
to
do
this.
A
A
A
A
How
do
I
do
any
of
the
testing
that
relies
on
extern
functions?
I
have
like
a
terrible
global
map
that
I'm
using
surely
there's
something
better,
and
this
one
is,
you
know,
maybe
is
more
serious
again
one
referenced
this
in
his
previous
talk
but
like
dealing
with
some
of
like
the
resource
usage
and
like
when
to
give
up
right,
timeouts,
aborts
syscall,
like
resource
utilization,
how
I
want
to
do
contention
how
much
parallelism
things
like
that
like?
How
do
I?
A
What
is
the
right
way
to
encode
that
data
and
move
it
into
our
webassembly
functions
and
calls
on
the
go
side?
What
do
we
got
so
using
lawson
time?
There
are
sort
of
these
generic
wasm,
codec
and
adl
objects,
the
codex
you
spin
up
your
vm.
You
run
your
code
when
you're
done
go,
will
garbage
collect
it.
A
Adl
is
more
complicated,
you
load
an
adl
and
you
get
effectively
a
pointer
to
the
data
because
you
need
to
partially
operate
on
it
and
so
because
you're
partially
operating
on
it,
you
you're
sort
of
it
hangs
around
for
longer
and
again.
If
you
have
directories
and
directories
have
sub
directories
and
subdirectories
so
you're
getting
more
of
these
like
sub
adls
that
you
need
to
hold
on
to
and
but
once
you're
done
with
them
once
you've
done,
you've
traversed
your
whole
directory.
You've
gotten
you've
gotten
your
bytes
out.
A
You
know
serialize
the
whole
thing
to
a
tar
file
and
you
go
home.
Okay,
then
the
garbage
collector
will
come
in
and
clear
everything
out.
There
is
support
for
gas.
You
know
you
can
put
in
gas
limits.
I
put
in
some
things
for
like
gas
limits
per
operation,
the
modeling
and
figuring
out
like
what
are
the
right
numbers
to
have
losing
time,
doesn't
make
this
easy
and
that's
a
conceptually
hard
problem.
Perhaps
our
fbm
friends
who
have
to
deal
with
this
in
a
much
more
real
way.
A
B
A
You
know
done:
decode
bytes,
okay,
first,
we'll
put
it
through
the
webassembly
decoder
and
then
we'll
decode
it
through
whack
done
adls
things
are
more
complicated,
there's
more
functions.
This
partial
stuff
is
is
difficult
to
get
well,
it's
not
necessarily
difficult,
but
it's
more
situational.
What's
the
right
form
of
partial
access
for
you,
how
do
you
need
it
to
work
for
your
application?
A
A
Of
course,
I
ran
into
the
very
large
maps
thing
because
there's
no
parallel
map
traversal,
but
that's
sort
of
another
piece
of
this
and
maps
and
bytes
are
what
I
need
to
do.
Files
and
directories
again
the
goal
small
goal:
I
just
want
git
and
bittorrent
and
unix
fs
and
winfs
like
I
want
these
all.
I
want
these
all
to
work.
I
want
to
be
able
to
explore
and
use
different
types
of
you
know,
file,
system
structures
and
have
them
all
work
like
file
system
things.
A
A
This
is
a
kubo
node
that
has
been
modified,
not
that
much,
and
there
was
an
earlier
version
of
this
that
anyone
who
saw
this
talk
up
until
I
don't
know
several
hours
ago.
It
looked
instead
like
this,
where
I
have
slash
ipfs,
slash
a
cid
for
those
of
you
not
fluent
in
multi
formats,
I'm
sure
you
all
are,
but
just
to
clarify
this
is
cidv1,
and
this
is
the
ben
code
codec,
which
is
the
format
that
bittorrent
uses
to
encode
data
and
a
sha-1
hash.
A
A
Maybe
maybe
we
have
ipld
uris
that
are
like
maybe
more
usable
and
maybe
selectors
are
super
duper
powerful,
but
maybe
sometimes
we
just
need
popping,
and
that
needs
to
look
much
more
readable
and
I
don't
know
about
you
guys,
but
when
I
did
this
one,
I
kind
of
got
laughed
at
a
couple
days
ago
and
this
one
seems
not
so
bad
slash.
Adl
is
bittorrent
file
or
bittorrent
thing,
not
so
bad,
and
we
can
do
this
for
directories
too.
It's
a
thing
and
oh,
it's
a
bittorrent
directory.
A
I
would
like
to
load
koala.jpg
and
there
it
is.
I
find
when
I
do
these
demos
that
have
to
do
with
almost
anything
on
the
ipld
side
of
things.
The
magic
is
that
the
demo
is
boring.
I
have
loaded
this
koala.
I
have
loaded
it
in
unix
fs.
I
have
done
it
when
it
was
bittorrent
stuff
written
in
go.
I
have
done
it
when
it
is
web
assembly
stuff
written
and
go,
did
it
with
files,
it
did
it
with
directories
and
the
point
is
they
all
look
the
same,
and
this
is
the
point.
A
And
certainly
way
nicer
than
this,
so
please
there's
there's
a
spec
pr
ipip.
It
lives
in
ipfs
specs.
If
you
would
like
to
see
how
do
we
make
the
uris
for
this
better,
you
don't
like
how
this
looks.
You
have
a
better
idea.
Please
go
there
really
we
we
need
it.
We
need
better
subgraph
descriptors
that
are
more
usable
for
people,
and
this
is
at
least
the
start
all
right.
What's
next.
A
A
B
A
So
so
granted
I
agree
with
you
a
point
I
guess
I
can
go
back
is
that
if
we
had
a
type
of
we'll
call
it
recursive
adl,
you
could
define
at
the
top
and
encode
it
into
the
uri
scheme.
If
you
wanted
to
because
the
way
in
which
you
do
the
encoding
to
say
it
must
look,
this
way
is
like
pretty
is
like
an
opinionated
thing
in
and
of
itself,
if
you
allowed
for
recursive
a
type,
it
doesn't
have
to
be
deeply
recursive.
A
You
can
kind
of
like
sort
of
like
unwrapping
a
for
loop
kind
of
thing.
If
you
do
that,
you
can
allow
capture
at
the
top.
That
says,
actually
I'm
going
to
encode
all
the
data
inside
the
tree
thing
and
do
exactly
what
you
said,
and
you
just
put
a
signal
at
the
top
that
says
this
is
how
I'm
going
to
do
it,
so
you
absolutely
can
do
that.
A
A
A
So
what
did
the
kubo
changes?
Look
like
there
were
three
changes.
Two
of
them
had
nothing
to
do
with
this,
and
then
one
of
them
did
kubo
has
never
had
adls
before
that
were
not
unix.
Fs
doesn't
even
in
the
way.
Even
does
the
ones
with
unixfs
is
a
little
bit
weird
okay,
so
I
added
a
plug-in
interface
to
register
new
adls.
A
I
added
a
signaling
mechanism
for
http
gateways
to
indicate
how
to
use
the
adls
and
signal
them
until
this
morning.
The
only
mechanism
anyone
had
available
was
a
selector
to
indicate
it,
because
we
had
we
had
uri,
we
had
hard-coded
into
the
uri
ipfs
colon
implies
try
unix
fs.
That
was
like
that's
where
that's
where
the
signal
lives,
then
there
was
selectors
that
you
apply
on
top
on
the
query
and
that's
where
the
signal
could
live.
A
This
is
another
version
of
a
cleaned
up
version
of
that.
Another
mechanism
is,
of
course,
inside
the
data.
If
you
go
to
ipld
the
ikld
docs,
there's
like
a
whole
description
of
like
the
variety
of
places
you
could
put
signals
and
their
trade-offs
and
like
one
of
the
most
powerful
things
here.
I
found
is
like
yeah,
the
selectors
were
a
little
gross,
but
like
having
a
hook
anywhere,
allows
the
explosion
of
ideas
that
then
allow
us
to
push
back
and
say
yeah.
A
We
need
a
better
hook,
it
needs
to
live
somewhere
else
and
it
looks
somewhere
better,
but
like
something
gets
us
moving
gets
us
thinking,
gets
us
feeling
it
and
and
making
it
making
us
experience
what
it
is
that
works
and
doesn't
work,
and
then
there
was
little
wasn't
peace,
which
is
make
a
wasm,
codec
and
adl
that
defines
how
codex
ndls
work
abstractly
over
the
walls
and
bindings
some
questions
that
get
asked.
These
are
the
frequently
two
of
the
most
frequently
asked
questions
the
config
file.
A
A
Some
people
are
like
has
storing
files.
Have
you
heard
of
the
cid
thing?
I
hear
it
lets
you
reference.
It's
like
a
pointer
to
data
that
like
could
live
anywhere.
That
sounds
like
real
good
and
yeah.
You
can
totally
do
that.
There's
like
a
little
bit
of
like
engineering
stuff.
You
need
to
do
to
get
the
the
thing
that
loads
codecs
on
startup
to
allow
it
to
work
after
you've
initialized
the
network.
So
you
can
go
fetch
data
but
like
yeah,
you
can
totally
do
cids.
A
Then
there's
a
different
one.
The
next
one
is
okay,
yeah.
Okay,
I
see
I
can.
I
can
get
the
cids
and
put
them
in
the
config.
Can
I
use
the
cid
as
the
name
of
the
adl
or
the
codec,
and
have
you
loaded
on
the
fly?
So
you
definitely
can't
do
it
today.
You
can't
even
do
the
other.
One
today
seems
like
it's
doable
a
little
more
complicated,
but
this
seems
doable
too.
A
I've
talked
to
a
number
of
people
about
this.
This
is
like.
I
don't
have
particularly
strong
opinions,
but
this
seems
to
be
a
very
controversial
topic,
some
areas
that
you
know
get
raised,
and
then
people
have
discussions
about
how
the
what
the
answers
are
are
what
happens
when
the
code
changes?
There's
a
bug
in
your
there's
a
bug
in
your
adl
code
or
your
codec.
What
happens
when
the
abi
changes
dean
doesn't
know
how
to
write
any
rust
code?
A
He
he
he
made
interfaces
that
are
terrible.
We
fixed
them
in
v2.
What
do
we
do
about
that?
What
happens
for
nodes
that
can't
support
webassembly,
they're
they're,
not
everywhere
right,
but
depending
on
how
deeply
we
encode
them
right?
If
we
say
webassembly,
this
is
the
cid.
You
must
run
webassembly.
How?
How
much
does
this
like
start
to
break
the
ecosystem
for
the
places
that
can't
webassembly
or
won't
a
compromise,
perhaps
maybe
to
give
things
names
and
allow
them
to
pass
hints
as
cids?
A
Some
of
you,
who've,
been
around
in
the
ecosystem,
may
have
seen
that
something
along
like
this
seems
to
have
been
requested,
like
I
don't
know,
on
the
order
of
ten
to
the
three
or
four
times
in
just
like
the
last.
You
know
several
years
of
the
project
which
is
like.
I
would
like
a
mutable
address
and
then
fall
back
to
an
immutable
address
which
hey
we,
you
know
gateway
specs,
make
an
ipip.
Maybe
do
this,
but
also
maybe
we
do
something
like
this
for
how
we
reference
the
code
right.
We
give
it
a
mutable
pointer.
A
We
give
it
a
fallback
to
an
immutable
pointer.
The
mutable
pointer
is
whatever
you
know
you
want.
It
can
be
a
name
like
bits
aren't
v1,
it
can
be.
You
know
a
public
key,
probably
don't
use
public
keys,
because
people
leave
because
people's
keys
get
broken
but,
like
maybe
use
something
else
right.
There's
lots
of
people
who
are
working
on
decentralized
identification
schemes
might
be
useful
here.
A
And,
and
where
do
we
go
from
from
here,
this
seems
like
pretty
workable,
actually
like
we
can
use
this
and
like
load
files
and
directories
and
files
is
really
easy.
We
actually
made
a
bunch
of
progress
yesterday
on
like
how
we
might
be
able
to
specify
how
directories
work.
Probably
some
work
will
spin
up
out
of
this
coming
out
of
the
event.
A
If
you
are
interested
in
the
channel
for
the
event
say,
hi
I'll
connect
you
with
some
folks,
it
may
unlock
people
being
able
to
like
build
new,
codecs
and
adls
without
it
being
painful
because
they're
like
how
do
I
support
them,
maybe
talk
to
some
folks,
who've
written
some
codex
and
how
it
takes
like.
Oh,
it's
got
to
make
it
into
this
part
of
the
ecosystem
and
this
part
of
the
ecosystem,
and
how
do
I
get
these
people
to
pin
my
data
and
walk
my
graph?
It
takes
time.
This
maybe
makes
it
easier.
A
We
need
to
like
review
and
go
through
and
make
the
implementation
better
yeah.
I
know
what
I'm
doing
it
worked.
I
don't
know
I
don't
know
how,
but
it
worked.
I
need
your
help.
If
you
want
this
thing
to
work,
it
needs
your
help.
It
needs
it
needs
your
view.
Your
view
is
important
and
probably
more
useful
than
mine,
and
then
we
get
to
start
using
it
and
see
what
breaks
and
what
needs
to
get
better.