►
Description
Tableland is a decentralized network for relational, composable data — powered by smart contracts + SQL. Mutable data with immutable rules, on EVM chains like Ethereum, supported by tools and protocols like IPFS, Filecoin, and more
https://tableland.xyz/
B
With
this
very
cool
tagline
of
the
read,
write
and
own
database
and
hope
we'll
see
how
far
I
get
I'll
try
to
keep
it,
quick
and
and
then
I
got
a
bunch
of
like
nerdy
fun
topics
that
we
could
talk
about
towards
the
end.
If
anyone
wants
to
chat
about
that
stuff
afterwards,
but
I'll
start
with
just
kind
of
the
motivation
for
textile
over
the
last
couple
years
and
how
we
arrived
at
tableland-
and
so
you
know
it's
funny.
Every
now
and
then
I'll
bump
into
someone
will
be
like.
B
Oh
cool
textile.
You
guys
are
like
oh
geez
in
this
space
I'm
like
yeah,
but
you
only
have
to
be
here
for
like
four
years
to
be
an
OG
in
the
space.
So
it's
pretty
easy.
Just
stick
around
long
enough,
but
yeah
we've
been
around
for
a
while
and
pretty
much
since
the
beginning.
Our
sort
of
like
driving
philosophy
had
has
been
like.
B
How
do
we
bootstrap
and
accelerate
information
exchange
and
clearly
that
is
that
you,
by
linking
directly
to
the
information
you're
trying
to
exchange
in
the
first
place,
instead
of
linking
to
these
sort
of
like
walled,
Gardens
and
and
and
silos
of
information,
just
link
that
information,
and
so
we
started
building
a
lot
of
Tooling
in
the
space
because,
like
a
lot
of
other
teams
in
the
space
we
sort
of
said,
hey,
oh
cool,
like
ipfs
exists.
Obviously
it
works
perfectly
all
the
time.
B
So,
let's
just
build
an
application
on
top
of
that,
and
so
we
built
a
mobile,
app
I
think
it
was
the
first
instance
of
ipfs
sort
of
like
really
running
on
mobile,
and
it
was
a
dual
featured
thing
because
it
was
a
pocket
warmer
as
well
as
a
an
app
that
you
could
exchange
photos
with.
So
that
was
pretty
handy,
and
so
we
said
whoa.
That
was
really
hard.
It
took
us
months
to
build
this
pocket
warmer
and
it
worked
and
we
even
in
ipfs
Camp
the
first
one.
B
We
actually
used
it
and
exchanged
photos
and
it
was
pretty
exciting
and
it
kind
of
worked,
and
then
we
thought
geez.
It
took
us
like
months
of
like
getting
go
ipfs
to
compile
on
mobile.
Like
doing
all
this
stuff,
we
had
to
create
a
bunch
of
tooling
to
like
spin
up
and
spin
down
the
node
so
that
it
didn't
warm
up
too
hot
all
this
stuff,
and
then
we
thought
geez
wouldn't
have
been
nice.
B
If
someone
had
built
all
the
tooling
and
things
that
we
ended
up
having
to
build
to
kind
of
accelerate
this,
what
I
like
to
call
time
to
failure
so
basically,
wouldn't
have
been
really
cool
if
I
could
have
found
out
quickly
that
building
a
pocket
warmer
wasn't
a
great
idea
and
I
probably
could
have
focused
on
something
else
and
so
yeah.
That
would
have
been
great.
So
we
sat
back
and
we
said:
okay,
let's
build
the
database.
B
Let's
build
the
like
file
storage,
let's
build
the
mutable
stuff
that
we
needed
to
get
textile
photos
built.
So
that's
where,
like
textile
buckets
and
threads
and
a
bunch
of
other
underlying
technologies
that
our
team
has
been
working
on
over
the
past
few
years
came
from
and
then
file
coin
came
along
and
we
thought
oh,
let's
build
tooling
for
that
as
well,
and
this
idea
of
building
tooling
is
going
to
come
up
a
bunch
in
this
session.
B
Obviously-
and
so
that's
really
where
you
know-
we've
been
over
the
last
few
years
and
then
recently
our
team
kind
of
took
a
step
back,
and
we
said
you
know
we
look
at.
We
looked
at
the
space
and
we
started
to
get
a
lot
more
involved
in.
You
know
web
3,
more
specifically
so
like
blockchain
driven
application
development,
and
we
found
that
the
tooling
that
we
had
built
that
worked
great
in
a
sort
of
peer-to-peer
setting
in
the
sort
of
d-web
ipfs
world.
B
It
didn't
fit
the
the
development
flow
and
practices
that
folks
building
on
ethereum
and
building
dapps
and
things
like
that
were
building
Additionally.
You
know
we
sat
there
and
I.
Don't
know
it
was
like
20
2018,
something
like
that
2019
and
we
were
like
oh
cool.
The
next
big
thing
is
dapps.
It's
going
to
be
great
everybody's,
going
to
be
building
these
decentralized
apps
can't
wait
and
then
it
was
D5
and
we're
like.
Okay,
that's
cool
D5
is
great
fine.
You
know
Financial
building
blocks,
that's
great.
B
Okay,
cool
daps
are
coming
here,
we
go
here,
we
go
and
then
it
was
nfts
and
we're
like.
Oh
okay,
that's
yeah,
fine,
nfts,
that's,
okay,
it's
okay!
Pictures
of
Vapes
are
cool
so
and
then
it
that
was
sort
of
like
okay.
These
are
ownership
building
blocks
and
then
we're
like
fool
me
twice.
I,
don't
think
so.
So
then
we
thought
you
know
what
is
the
next
big
thing?
B
Maybe
it's
daps,
probably
not
probably
it's
like
data
building
blocks
for
some
other
building
block
again,
because
tooling,
is
this
thing
that
when
you
build
it,
it
bootstraps
all
these,
like
unexpected
other
things
that
people
can
build
like
who
would
have
thought
that
people
would
start
building
sort
of
financial
products
on
top
of
other
Financial
products
in
some
way?
That
is
extremely.
You
know
sort
of
arguably
irresponsible
and
too
totally
crazy
but
exciting
at
the
same
time.
B
So
what
kind
of
irresponsible
things
could
we
do
with
data
building
blocks
so
many
irresponsible
things
so
and
what
even
is
a
database
in
the
first
place?
Really,
we
know
that
a
lot
of
people
build
sort
of
traditional
and
future
apps
on
top
of
relational
data
right,
like
every
app
that
you
use
is
probably
using
some
sort
of
you
know
SQL
database.
B
So
we
thought.
Okay,
you
know,
databases
are
pretty
pervasive
and
so
what?
What
is
a
database
right?
It's
it's
access,
control
and
sort
of
like
permission
to
do
things,
it's
indexing
and
like
sort
of
deciding
where
everything
goes
and
then
there's
some
storage
layer
right,
and
so
we
thought,
okay.
Well,
you
know
we
want
to
build.
We
want
to.
We
want
to
fill
that
sort
of
database
gap
for
web3
and
how
might
we
do
that?
We're
like
well,
the
blockchain
is
ownership
and
the
blockchain
is
rules
and
access
control.
B
So
we're
not
going
to
build
that
because
there's
a
bunch
of
those
some
of
them
are
great
and
some
of
them
are
terrible
and
I'm
at
an
ipfs
conference.
So
I'm
certainly
not
going
to
build
a
storage.
You
know
back
end
because
that
would
be
crazy
to
try
and
compete
with
filecoin,
and
are
we
even
all
these
other
things,
but
that
middle
piece,
that's
interesting,
I
get
to
solve
a
bunch
of
really.
You
know
interesting
important
problems
and
build
an
infrastructure,
that's
totally
usable
for
app
Developers.
B
So
we
kind
of
said.
Okay,
let's
build
that
middle
piece
right.
We
won't
do
access
control.
We
won't
do
storage,
we'll
do
that
middle
piece,
and
so
you
know
the
idea
is.
If
you
combine
those
two,
you
kind
of
get
this,
this
metadata
layer
right
this,
this
vestigial
tissue
between
applications
and
their
data
that
allows
you
to
actually
index
and
decide
where
things
are.
So
we
started
to
build
web
three
native
tables
and
it's
literally
just
tables,
there's
nothing.
B
You
know
sort
of
fancy,
it's
very
intuitive
and
half
the
developers
in
this
room,
especially
ones
with
like
longer
beards,
no
SQL
right,
it's
a
very
common
language.
A
lot
of
people
end
up
building
with
it,
so
that
was
our
kind
of
pitches.
Okay,
let's
just
build
tables.
That's
it!
It's
so
retro
that
it's
new
right,
okay,
that
was
supposed
to
be
a
joke,
but
that's
fine,
but
let's
do
that.
Let's
build
SQL
and
then
we'll
store
that
stuff
on
a
decentralized
network
of
validators.
B
Where
are
they
actually
finally
sort
of
resolve
that
data?
It's
totally
up
to
them
could
be
filecoin
could
be,
ipfs
could
be
AWS
who
cares
and
then,
because
we're
concerned
about
sort
of
very
clear,
Access
Control
in
a
in
a
way,
that's
quite
different
than
how
vision
and
other
teams
are
thinking
about
access
control,
we'll
anchor
all
of
this
stuff
to
a
blockchain.
It
can
be
ethereum,
it
could
be
polygon
right
now.
B
And
it's
designed
to
play
nice
with
others,
because
why?
Wouldn't
we
do
that
right?
All
Rising
Tides
lift
all
boats,
and
so
it's
part
of
this
sort
of
like
new
stack.
That's
developing
around
web3
experiences
right,
like
I,
want
to
have
an
experience.
I
don't
want
to
log
into
a
thing
and
use
the
thing.
I
want
to
experience
something
exciting
I've
already
got
a
wallet.
I've
already
got
an
address.
Let's
leverage
that-
and
so
it's
part
of
this
balanced
breakfast
right
here
where
the
underlying
storage
piece
is,
is
a
little
bit.
B
Right
is
I've,
got
this
contract,
so
every
table
is
an
ERC
721
compliant
nft,
but
you
can
also
control
a
table
with
any
smart
contract,
and
so
you
can
actually
specify
your
access
control
rules
through
a
sorry,
a
procedural
language
like
solidity,
so
you
could
do
things
like
say:
okay,
look!
Only
someone
who
owns
a
board
ape
and
after
block
whatever
and
according
to
you
know
a
chain
link
Oracle,
it's
raining
in
New
York.
B
Are
you
allowed
to
insert
a
new
row?
You
can
do
crazy
stuff
like
that.
You
can
do
crazy
access
control
that
you
couldn't
really
do
in
a
more
traditional
database
world
where
someone
built
all
the
access
control
into
it.
So
you
can.
You
can
also
do
things
like
look.
You're
only
allowed
to
write
to
this
row
if
you
own
this
particular
access
control,
nft
or
if
you
have
this
much
balance
in
your
account
or
whatever
sort
of
thing
you
might
imagine.
B
B
A
B
B
Well,
tableland
is
really
basically
two
pieces,
there's
an
Unchained
registry
and
that's
the
thing
that
transactions
and
access
control
and
like
table
unique
identifiers
for
tables
happens
and
that
exists
on
every
evm
chain
that
is
supported
and
then
and
that's
where
the
access
control
lives
and
then
there's
off
chain
tables
and
that's
driven
by
a
network
of
validators
that
are
basically
watching
for
ons
chain
State
changes
and
then
materializing.
Those
changes
in
literally
sqlite
databases
on
every
node.
So
it's
really
easy
to
run
a
node.
B
It's
designed
to
be
side
card
next
to
in
ethereum
node
or
something
like
that
or
you
can
use
it
even
an
ethereum
provider
because
the
best
way
to
have
a
decentralized
network
of
you
know.
Smart
contracts
is
for
everyone
to
use
a
provider.
Obviously
no,
but
it's
better.
If
you
run
your
own,
but
you
know
you
do
do
what
works
best.
So
that's
basically
how
it
works.
B
There's
two,
these
two
components
and
so
really
we're
talking
about
sort
of
decomposing
a
database
into
just
the
little
bits
that
you
need
and
basically
the
way
it
works.
Is
the
user
interacts
with
the
smart
contract
to
create,
insert
update
or,
inter
otherwise
interact
with
some
data.
It
goes
through
tableland
right,
get
it
pretty
good
and
then
those
that
data
is
materialized
on
the
validators
and
then
you
can
interact
with
that
data.
B
Get
the
latest
state
from
it
by
querying
those
validators
directly
or
we're
actually
working
on
a
lib,
P2P
style
protocol.
Where
you
basically
ask
the
network
I
would
like
the
results
of
this
type
of
query,
and
then
you
use
a
DHT
in
that
case,
basically
to
go,
say:
okay,
cool!
Who
here
can
answer
that
query,
so
that's
kind
of
a
fun
a
fun
way
to
interact
with
it
and
so
yeah,
no
Mom
I'm,
not
building
tables.
Now
we're
just
still
building
software,
and
so
this
is
how
the
the
basic
workflow
works
right.
B
B
So
tableland
is
all
about
mutable
data
right.
You
want.
You
know,
data
changes
over
time.
It's
useful
to
have
this
mutability
concept,
and
even
you
know,
in
the
ipfs
world
we
want
databases
and
things
built
on
top
of
the
file
system
to
represent
mutability
right.
So
mutability
is
a
useful
feature,
but
sometimes
you
don't
want
the
rules
for
how
that
how
things
can
mutate
to
change?
You
want
that
fixed,
for
instance,
the
rules
of
a
game
like
chess.
For
instance,
they
don't
change.
B
B
The
underlying
data
along
the
way-
and
so
we
we
you
know,
I
like
this
idea
of
basically
like
immutable
rules
for
mutable
data,
and
this
is
a
nice
concept
and
I
think
we're
just
starting
to
realize
what
you
can
do
when
you
have
that
sort
of
concept,
because
we've
had
a
lot
of
people,
especially
in
nft
World.
Saying
like
you
know,
oh
you.
If
it's
a
mutable
contract,
then
you
know
the
teams
could
rug
pull.
But
if
the
contracts
States,
what
the
rules
are
you've
got
a
very
clear.
B
You
can
look
and
see
like
okay.
If
this,
then
that
sort
of
scenarios,
you
can
trust
that
that
state,
those
State
changes
that
happen
are
very
fixed
and
clear,
and
so
the
way
that
works
is
they
interact
with
a
smart
contract.
The
the
smart
contract
checks
access
control
rules.
It's
very
easy
if
you
know
any
solidity
to
implement
it
and
then
there's
a.
We
have
a
bunch
of
helpers
to
kind
of
do
normal,
regular
type
things.
B
The
statement
is
emitted
from
the
contract,
the
validators
watch
for
those
emitted
statements.
They
pull
those
in
they
materialize,
The,
View,
update
the
state
and
then,
depending
on
what
particular
interaction
you
were
pushing
through,
they
may
return
a
result
or
or
not,
and
we
now
even
have
a
couple
of
folks
experimenting
with
using
like
third-party
oracles
to
push
State
back
on
chain.
B
Sometimes
that's
a
good
idea,
but
I
can't
imagine
you
would
want,
like
a
whole
database,
query
to
somehow
be
back
on
chain.
What
even
would
that
look
like
I'm,
not
sure,
but
you
know
you
can
start
to
imagine
these
things
and
then,
of
course
you
want
sort
of
like
proofs
of
what
the
state
on
the
tableland
network
now
looks
at
and
lo
and
behold,
content
addressing
and
hashes
and
things
provide
exactly
what
we
need
there.
B
So
I'm
going
to
kind
of
wrap
up
now.
Hopefully,
you
have
a
sort
of
general
idea
of
what
tableland
is
and
I
barely
to
scratch
the
surface
of
how
tableland
can
interact
with
the
ipfs
ecosystem.
But
it's
a
bunch
of
really
cool
ways,
including
things
like
embedding
hashes
in
tables
and
then
seamlessly
fetching
the
data
behind
those
hashes
on
the
as
you
as
you
do,
queries
and
writes
so
imagine
sort
of
like
pushing
an
image
to
a
row
in
a
table
where
you,
transparently
or
seamlessly,
actually
push
that
to
ipfs
calculate
the
CID.
B
Stick
the
Cid
in
and
then
push
that
update
to
tableland
and
then
on
the
way
back
out.
You
do
the
reverse,
so
there's
a
bunch
of
like
sort
of
fun,
interesting
things
like
that,
but
here's
some
interesting
topics
that
I'm
totally
down
to
nerd
out
with
you
all
on
later
database
implementations,
there's
a
bunch
of
really
cool
stuff
kind
of
happening
under
the
hood
here
around
data
structures
and
ipld
and
how
we
exchange,
updates
and
interactions.
In
the
background.
B
If
anyone
wants
to
chat
about
proofs
of
database
state
I'm
here
for
that,
if
anyone
wants
to
chat
about
proofs
of
like
SQL
queries,
there's
a
really
really
fun
hard
problem
there
that
some
folks
have
started
to
look
at.
So
we
could
totally
talk
about
that
blah
blah
blah
blah.
But,
most
importantly,
let's
also
talk
for
the
rest
of
this
afternoon.
The
rest
of
the
session
about
building
tooling
and
developer
Tooling,
in
particular
on
top
of
these
sort
of
interesting
Primitives
and
I've,
got
a
lot
of
opinions
about
that
as
well.
B
So
I'd
love
to
Deep
dive
with
you
on
any
of
these
topics.
But
the
last
thing
I
wanted
to
talk
about
before
I
leave
is
some
people,
so
tableland
did
a
whole
bunch
of
branding
stuff.
We've
got
these
like
this
sort
of
cool
I,
don't
know
future
retro
vibe
and
a
bunch
of
people
are
like
Oh
I
thought
you
guys
were
like
an
nft
project
now,
and
that
is
not
the
case,
but
we
do
have
this
nft
project
called
the
rigs
which
we,
which
basically
our
community
members,
hold
these
rig
nfts.
B
So
that's
what
rigs
are
and
if
you're,
if
you're
wondering
what
the
heck
there
are,
that's
what
they
are.
They
are
a
sort
of
utility
nft,
but
what
they
really
are
is
that
they
are
they're
an
experimental
platform
for
the
tableland
network.
So
all
of
these
nfts,
their
metadata,
is
driven
by
tables
and
the
metadata
is
actually
driven
by
like
relational
tables
and
we
can
extend
their
traits
and
all
sorts
of
crazy
stuff
by
leveraging
tableland,
and
so
we
basically
experiment
with
like
real
ux
and
a
real
product
on
top
of
tableland.
B
By
leveraging
these
rigs
plus
they
look
pretty
cool,
which
is
like
a
nice
side
feature
and
Unfortunately.
They
ended
up
being
slightly
popular
for
a
little
while
so
now,
they're
kind
of
expensive.
But
we've
got
some
other
tooling
coming
in
for
developers
who
just
want
to
get
in
and
start
tinkering
and
and
we've
got
some
test
net
ones
as
well.
If
people
want
to
play
around
so
rigs
are
an
experimental
platform
for
the
tableland
network
and
vice
versa
or
tableland
network
is
an
experimental
platform
for
an
actual
production.
Nft.