►
Description
Visualizing something is often fascinating even if the math behind it is quite simple. A good way to start in that topic is to choose a simple simulation, choose the technology, and then start implementing it on your own. Especially implementing a cellular automaton is a good first step. In this session, Diemo wants to introduce you to the world of cellular automata and how to use Rust and the Bevy framework for visualization.
Diemo Heuer is a Software-Developer from Rostock (Germany) employed at Altow Digital Innovation. He uses Rust for professional projects mainly in the backend but for his hobby projects, he explores the further capabilities of that technology. He also is the host of different community events in Rostock; e.g. the Rust Meetup Rostock, Elixir Meetup Rostock, or the Altow Inspire.
Rust Linz: https://rust-linz.at
Speak at Rust Linz: https://sessionize.com/rust-linz
Twitter: https://twitter.com/rustlinz
A
I
will
tell
you
in
this
talk
at
the
beginning.
Probably
in
the
first
half
I
will
speak
about
Siri
background.
We
are
speaking
a
little
bit
about
simulation.
What
is
a
cellular
automata
and
later
we
will
talk
a
little
bit
about
the
BV
game
engine.
How
did
I
find
it?
How
did
I
choose
it
and
later
a
little
bit
into
software
architecture
and
in
the
second
half
we
will
have
a
look
at
some
code.
I
wrote
for
one
cellular
automaton
and
probably
if
we
have
time
left
at
the
end,
I
prepared
some
project.
A
I
did
during
my
apprenticeship
also
related
to
cellular
automators.
So,
let's,
let's
start
why
cellular
automatics
or
what?
What
is
a
cellular
automaton.
So
it
has
a
very
simple
definition,
and
it
goes
something
like
this-
that
you
have
a
discrete
space
which
is
defined.
Let's
think
of
2D
metrics,
with
with
cells
or
with
fields
and
I
already
mentioned
it.
A
You
have
sales,
and
this
discrete
space
is
divided
into
sales,
and
these
cells
have
a
state,
and
they
probably
know
are
in
relation
to
the
environment,
to
the
neighbor
says,
which
also
provides
a
state
and
now,
when
the
whole
world
the
whole
cellular
automaton
will
develop
into
the
next.
It's
the
exact
stage
of
its
timeline.
A
The
state
of
success
will
develop
depending
on
the
states
of
the
neighboring
cells,
and,
yes,
that's
it.
So
why
is
it
interesting?
You
see
it
a
little
bit
here,
because
we
have
a
good.
There
is
something
moving.
I
will
tell
you
a
little
bit
about
it,
just
in
the
next
slide,
but
what
I
really
like
about
it?
It
was
one
of
my
first
programming
projects
during
my
apprenticeship,
and
you
have
a
lot
of
stuff
to
to
think
about.
You
have
to
think
a
little
about
I
think
a
little
bit
about
a
software
architecture.
A
A
Well,
it's
a
little
bit
chaotic.
So,
yes,
you
have
some
simple
rules
and
you
can
just
program
it
and
you
can
extend
it
and
you
see
that
something
is
moving
and
probably
not
in
that
way
you
want.
But
you
learn
a
lot
about
programming,
so
I
think
it's
a
good
exercise,
even
if
you
are
good
at
programming
to
make
something
like
that
or
if
you
start
with
programming
and
do
something
in
that
kind
of
a
simple
simulation.
A
And
so
let's
have
a
look
at
different
automatas.
The
most
iconic
one
is
probably
the
conrace
Game
of
Life
and
automaton,
or
doesn't
only
send
for
itself
to
just
oh,
we
have
a
little
little
rule
set
and
then
something
is
happening
and
blinking
in
a
an
array
of
art.
It's
should
sometimes
simulate
a
complex,
a
complex
aspect
in
a
more
simple
way,
and
what
cover
is
Game
of
Life
wanted
to
achieve
is
that
we
have
simulation
about
biology.
So
we
have
the
cells
in
the
world
and
the
cells
can
have
two
states.
A
One
is
it's
alive,
one,
it's
dead,
so
sales
can
be
born
if
there
are
enough
living
cells
surrounding
it,
but
not
too
much
living
cells
will
survive
at
The,
Sweet
Spot
if
they
are
not
too
much
neighbors.
So
there's
probably
a
food
problem
or
there
aren't
two
less
neighbors,
so
there's
a
problem
for
the
social
environment,
so
the
cell
was
away
because
of
loneliness,
and
that's
that's
a
very
interesting
approach
of
making
a
very
complex
topic.
A
Very
simple
and
I've
done
this
simulation
at
my
homework
back
in
the
days
and
I
I
did
a
lot
of
extra
features
and
I
have
written
it
in
Devi.
I
can
show
it
at
the
end.
If
you
want
to
have
a
look
at
it,
there
are
some
other
simulations
like
why
a
word
to
simulate
the
flow
of
currency
of
power,
the
water
simulation.
Oh,
it's
a
little
bit
out
of
layout.
A
It's
again
a
biology
simulation
where
we
have
the
green
cells,
which
are
which
the
blue
cells,
which
are
sharks
or
and
the
sharks
are
the
predators.
The
green
Fishel
fishes
are
the
prey.
The
black
is
just
empty
space
and
in
a
vest
water
planet,
for
example,
and
what
the
purpose
of
this
simulation
of
the
cellular
automaton
is
to
provide
a
simplification
of
the
relation
of
predator
and
prey
and
just
a
word
of
advice.
It's
a
little
bit
fleshy
when
I
click
here
and
we
see
closely.
A
We
see
that
the
blue
dots
are
hunting
the
green
areas,
so
the
Sharks
will
try
to
eat
the
fish,
so
they
will
stay
alive
because
they
have
to
eat.
And,
yes,
probably,
it's
a
little
bit
difficult
to
see.
But
here
it's
a
at
the
bottom
of
that
little
video.
You
have
some
kind
of
graph
which
is
moving
like
a
wave
and
it
shows
if
there
are
a
lot
of
prey
and
less
Predators.
A
So
there
will
be
more
Predators
because
there's
a
lot
of
prey
to
hunt
and
they
the
population
will
grow,
and
this
will
decrease
the
population
of
the
prey.
And
so
there's
not
enough
praise,
so
the
Sharks
will
die
from
hunger,
and
so
it's
again
a
really
complex
aspect
of
of
the
nature,
a
very
similar
fight
with
some
simple
words
and
an
automaton,
and
it
just
makes
fun
to
look
at
something
like
this
I
just
put
it
on
again,
so
we
can
have
a
look
at
it
again.
A
A
Okay
and
then
I
got
a
plan.
I
did
some
lazy
Googling
what
to
do
for
my
homework
for
simulation
and
simulation
programming.
You
will
find
currently
scheme
of
life
and
I.
Did
it
back
in
the
days
with
some
dirty
spaghetti,
Devi,
front-end,
programming
and
I?
Did
it
again
for
the
vasmita
Pro
Stock,
the
CB
game
engine,
because
I
always
wanted
to
do
something
with
an
with
a
game
engine,
and
now
we
will
go
out
of
slides
and
I
just
wanted
to
have
a
look.
I
just
wanted
to
find
something.
A
I
could
use
for
that
for
that
simulation,
and
probably
you
know
that
there
are
a
lot
of
Are
We
placeholder
yet
in
the
last
ecosystem-
and
these
are
pretty
pretty
amazing
sites-
websites
where
you
can
have
created
lists
of
different
crates,
especially
especially
for
this,
are
we
game
yet
there's
other
stuff
like?
Are
we
async
yet
yeah?
Yes,
no,
we
are
I,
think
and
are
we
Network
yet?
Are
we
web
yet
and
so
on?
A
And
these
are
amazing
sites
if
you
want
to
probably
look
for
a
crate
for
a
special
purpose
and
it's
much
more
convenient
the
sites
like
using
crates,
IO
so
and
some
flavor
text
getting
started,
and
here
is
some
kind
of
some
sorting
happening
and
if
you're
looking
for
something
in
the
field
of
audio
and
game
stuff,
you
will
probably
browse
here.
If
you
look
for
something
in
for
virtual
reality,
you
will
look
here
and
game
engines.
2D
3D
sounds
fine
for
me.
A
A
Is
it
piston
it's
a
little
bit
down
here
somewhere
person
here,
yes
and
another
statistic
eye
check
if
there
are
a
lot
of
downloads-
and
this
is
some
kind
of
nice,
versioning
and
so
I
tried
different
stuff
out
and
I
checked,
creates
I
o
page
for
where
sbv,
usbv
and
just
check
okay?
Does
it
have
a
nice
landing
page,
a
CS
because
it
has
it
just?
Has
it
it
again?
A
It
it's
having
a
nice
landing
page
and
a
good
documentation,
so
these
are
good
signs
that
it's
beginner,
friendly
and
I
like
to
use
crates
with
a
good
tutorial,
always
go
to
docs
and
I
really
enjoy
it,
and
so
I
looked
okay,
here's
it's
the
living,
it's
providing
new
versions
and
the
next
stuff
I
check
is
the
GitHub
repository
and
we
don't
look
into
the
dogs.
The
dogs
are
also
fantastic
for
BV
and
I
will
check
the
examples,
order
for
the
guys
and
girls
of
you
who
didn't
know
this.
A
This
directory
in
the
last
project
file
structure,
it's
a
folder
which
holds
example,
code
for
different
aspects,
and
this
is
really
really
helpful
if
you
want
to
dive
into
different
crates
and
for
me,
which
learns
more
in
a
practical
way,
it's
much
more
helpful
than
reading
documentation,
documentation,
documentation.
So
I
have
some
examples
here.
I
can
have
a
look
at,
for
example,
for
Android,
because
PV
is
cross-platform
or
for
iOS
or
for
scene
handling,
web
assembly
stuff
and
so
on.
A
Even
how
games
will
work
at
all,
so
we
get
a
impression
from
breakout
example,
for
example.
Okay,
that's
just
this
little
X
cause
to
how
I
deal
with
finding
new
crates,
which
probably
provide
my
purpose
of
what
I
want
to
do
and
yeah
some
some
hot
facts
about
the
BV
game
engine.
The
website
also
looks
very
nice
had
a
really
good
getting
started
stuff.
So
that's
the
upside
of
that
old
stuff
that
stuff
so
I've
shown
my
simulation.
I've
chosen.
My
model
I
even
have
a
game.
A
Engine
and
I
have
some
language
rust
where
I
want
to
do
it,
and
so
let's
talk
a
little
about
software
architecture.
So
a
lot
of
game
engines
are
using
a
specific
software
padding
pattern
called
The,
Entity
component
system
or
our
entity
component
systems,
and
it's
quite
simple
because
it
only
consists
of
a
few
main
components.
We
have
the
entity
which
only
has
a
unique
ID,
so
no
features
for
progressing
some
transition
or
something
like
that.
A
So,
there's
a
system
running
only
for
the
translation.
There's
a
system
only
running
for
probably
for
if
the
shape
of
the
color
is
progressing
or,
if
you
think
of
more
complex
games,
there
will
be
systems
for
foreheads
for
Mana
for
the
daytime,
for
if
you
play
Survival
Games
for
the
handling
of
thirst
and
hunger
and
so
on,
and
it
always
runs
and
it's
a
game
Loop
and
to
get
a
little
bit
more,
especially
in
that
way.
We
have
a
look
at
a
little
example.
A
We
have
here
The
Entity,
with
different
components
docked
to
that
entity
and
like
in
My
Little
example.
We
have
some
data
on
that
components
like
x,
coordinates
the
acceleration
and
then
so.
That's
my
my
main
object
I'm
looking
at
the
moment,
and
we
have
the
game
Loop
and
there
are
a
lot
of
systems.
Think
of
systems
in
some
kind
of
of
functions
of
methods.
We
will
have
a
look
at
it
as
a
demonstration
and
there's
a
system
for
handing
the
gravity
and
the
gravity
will
have
a
look
at
other
entities
and
we'll
check
it.
A
A
are
you
having
the
gravity
component.
Okay,
great
I
will
do
something
with
it,
and
so
it
gaps
the
gravity,
The
Entity
and
does
something
with
the
gravity
to
calculate
the
new
position.
And
then
the
next
system
will
do
something
and
so
on.
We
have
an
infinite
game.
Loop
good-
and
now
we
at
this
point
where
we
are
almost
I
almost
at
the
demonstration
before
I
forget
it.
I
want
just
to
mention
some.
Some
sources
like
I,
will
provide
and
reposit
a
repository
with
the
code.
I
will
just
post
it.
A
It's
a
YouTube
stream
in
the
chat
if
you
want
to
follow
during
my
talk
further
into
the
code
and
I
just
linked
some
I
think
pretty
good
sites
to
get
into
component
entity
component
systems
or
into
the
PV
game
engine
or
into
cellular
automaton
automata
as
well,
or
what,
which
is
a
really
great
source
of
inspiration
and
a
knowledge
transmission
is
separated
for
cellular
automata
on
Reddit.
Okay,
then
give
me
some
seconds
and
I
will
post
this
into
the
shed
now.
A
Okay,
I
hope,
I
made
it
public,
so
otherwise
I
will
just
make
it
shortly.
After
this
talk,
and
now
we
will
have
again
a
little
theory
about
probably
most
of
the
most
simplest
seller,
automatons,
the
waveforms,
one-dimensional
universe,
and
if
you
think
of
the
natural
world,
we
are
living
in.
It's
it's
3D
and
probably
much
more
complex
with
time
and
stuff
like
this.
So
we
are
not
thinking
in
a
3D
room.
Of
course
the
cellular
automaton
could
be
3D,
but
not
this
one.
A
So
we
don't
have
volume,
it's
not
in
the
2D
room,
so
we
don't
have
an
area.
We
have
the
Wonder
womb
and
it's
think
of
a
line
just
for
a
little
presentation.
Let's
imagine
this
is
a
line
and
we
have
cells
and
the
cells.
Don't
really
have
space
or
areas
they're,
just
knowing
which
its
neighbor
are
on.
This
neighbors
are
on
this
line
and
it's
not
only
a
line
with
a
defined
end
at
beginning,
it's
some
kind
of
wing,
so
it's
infinite
and
close
in
itself,
and
every
cell
inside
this.
A
A
So
every
new
line
is
the
next
step
in
the
in
the
timeline
of
that
universe,
and
we
see
here
probably
the
Big
Bang
started
small
there's
a
special
rule
set
for
that
universe
and
the
universe
will
expand
and
will
we
see
a
structure,
we
see,
we
will
see
the
textures
and
we
will
see
that
are
that
it
will
develop
or
evolve
in
a
special
way,
and
so
the
rule
set
is
that
we
have.
If
we
have
a
look
at
here,
I
will
explain.
A
What's
a
bit
pattern
means
shortly
in
some
seconds
we
have
our
cell
here,
and
the
next
state
of
the
cell,
provided
in
the
timeline,
depends
on
the
state
from
the
cell
itself,
from
the
neighboring
states,
from
the
left
and
from
the
white
cell,
and
what
we
see
here
is
okay.
If
three
cells
are
full,
the
next
or
the
main
cell
and
the
left
and
right
neighbor,
the
next
cell
will
be
empty
and
it's
it's
in
code.
A
It's
it's
recognized
with
a
zero
at
this
point
for
this
stuff,
every
cell
is
empty
and
the
next
then
there's
a
timeline
will
be
zero
as
well.
For
this
case,
what
the
left
neighbor
is
empty,
the
cell
itself
and
its
white
neighbor
is
filled,
so
the
next
stage
will
be
filled
and
it's
related
to
one
and
probably
you
will
you
already
counted
the
digits
and
it's
eight.
So
we
have
one
byte,
8
Bits
and
an
wolframs.
A
If
you
talk
about
problems,
universe
and
talk
about
different
rule
sets
for
this,
because
we
have
four
cells.
There
are
we
have
this
kind
of
combinations
for
for
the
next
state,
and
so,
if
we
want
to
apply
a
simple
rule,
we
we
will
speak
about.
We
apply
rule
one,
we
will
apply
rule
42,
we
will
apply
Google,
182
and
so
on,
and
there
are
in
these
256.
A
A
So
that's
a
theory
and
now
we
will
have
a
look
just
what
is
happening
in
my
little
application
and
we
see
okay,
here's
something
going
on.
We
are
going
through
the
timeline
and
we
see
different
structures.
We
see
that
some
triangles
will
evolve
during
the
universe,
so,
but
it's
not
something
we
saw
before,
but
I
programmed
something
if
I
start
with
a
single
cell,
we
see
a
pattern
which
will
match
to
that's.
A
A
So
now
you
should
see
my
visual
studio
code
and
everything
starts
with
the
main
function
because
of
things
I've
learned
during
my
other
projects.
I
wanted
to
make
it
a
little
bit
more
structured
and
so
I
begin
everything
with
some
kind
of
configuration
and
from
this
basic
configuration
other
the
the
first
Universe
state
will
be
developed.
The
con
I
will
initialize
the
control.
State
I
will
initialize
the
state
of
the
UI
to
have
the
stuff
to
begin
with
for
a
default
configuration.
A
Then
we
have
some
PV
related
stuff.
We
see
here.
Probably
you
know
this
kind
of
message:
chaining,
it's
some
kind
of
build
up
pattern
where
you
prepare
your
application
with
stuff.
You
want
to
have
inside
with
different
functions
and
at
the
end
there
will
be
a
run
and
everything
will
start
now
at
the
beginning,
I'm
going
to
add
some
default
plugins,
because
BV
has
a
plug-in
system
inside
of
it.
So
we
see
here
there's
some
plugins
for
logging
for
time,
management
for
input
management,
fault,
window
management
and
so
on.
A
A
I,
add
other
systems
which
now
are
in
the
game.
Loop
and
we'll
just
be
executed
whenever,
as
as
fast
as
off
as
often
as
possible,
and
not
in
a
in
an
organized
order,
I
can
achieve
it
if
I
link
the
different
systems
to
each
other,
but
I
just
left
it
free.
At
this
point,
so
I
have
one
system
handling
the
resizing
of
the
UI.
A
So
if
this
stuff
is,
is
is
changing,
so
the
size
of
the
child
sales
will
change.
Then
I
have
some
systems
for
a
keyboard
input.
I
have
one
system
for
iterating
the
universe,
so
here's
some
iteration
happening
then
I
have
a
system
for
visualization,
because
when
the
universe
is
is
iterating,
then
it
needs
to
be
visualized
and
at
the
end,
there's
just
some
convenience
system
where
I
it's
made
for
examples
and
prototyping.
If
I
press
escape
the
application
will
close.
A
You
will
see
just
got
a
little
little
settled
because
I
had
some
some
stuff.
I
hope
the
hardware
is
still
working
okay,
so
we
begin
with
the
setup
system
and
yes,
a
word
of
warnings,
Macross
BV
losing
is
using
a
lot
of
macros
and
with
that
macros
this
heavy
use
of
macros,
it's
providing
a
very,
in
my
opinion,
lean
developer
experience,
and
so,
if
you're,
asking
where
I'm
calling
the
setup
and
putting
the
commands
inside
I'm
not
doing
it,
it's
some
kind
of
the
macro.
A
Magic
is
the
BV
background,
and
so
I
can
just
name
or
classify
a
function
as
a
system
and
because
PV
knows
it's
a
system
because
it's
named
here,
I
can
provide
different
Arguments
for
the
setup
is
simple.
The
commands
are
something
where
can
in
where
I
can
interact
with
the
game.
Engine
I
want
to
start
to
spawn
well
to
prepare
everything
for
a
2d
camera
so
for
the
keyboard
input
system,
it's
more
more
complex
I
have
the
commands,
because
I
want
to
react
to
the
keyboard
inputs.
A
I
access,
my
resources,
which
are
fixed,
like
the
configuration
or
from
the
default
BV
plugins.
The
input
system
provides
me
here.
The
key
pressed
in
that
manner
then
I
have
the
control
state,
the
UI
State,
and
because
probably
something
will
happen
for
the
control,
State
and
UI
State,
and
so
it's
mutable
in
that
and
now
here
we
have
something
related
to
the
software
architecture
of
entity.
Component
systems.
A
I
have
a
query
where
I
can
demand
all
entities
which
have
the
component
cell
and
then
I
can
work
with
them
and
then
yeah
some
stuff
is
happening
for
the
keys
here.
I
have
some
for
my
resize
notification
notification
for
resizing
resizing
the
window
and
I'm
doing
it
in
a
very,
not
a
performance
way
because
I'm
just
despawning
everything
there
are
better
options
I'm
from
time
to
time.
I'm
optimizing
this
this
little
example.
A
So
it's
getting
better
then
I
have
my
Edward
Universe,
which
just
which
is
just
calling
on
that
Universe
state,
which
is
an
automaton
the
iterate,
and
it
will
work
on
itself
and
then
probably
for
the
last
stuff.
We
have
some
that
I
want
to
update
the
visualization
and
I
did
some
optimization,
in
my
opinion,
I'm
only
scratching
at
the
surface
of
the
BV
game
engine
so
I
only
visualize
or
Draw
new
cells,
if
it
is
necessary
and
I
only
draw
the
timelines
which
are
necessary
and
then
it
gets
through.
A
Everything
gets
the
positions
and
yeah
most.
The
the
more
interesting
part
is
now
here
when
we
go
to
the
Sprite
bundle
and
the
Sprite
bundle
spawns
a
basic
entity
with
the
components
for
the
visualization
where
we
have
where.
Where
is
it
on
my
screen,
which
color
does
it
have
and
so
on
and
with
the
commands?
I
will
not
only
spawn
the
bundle
for
the
representation.
I
want
also
to
add
the
component
for
the
cell,
so
that
my
game
object
object.
A
A
Okay
and
then
we
have
just
the
last
helper
function
where
I
can
get
my
my
stuff
and
generally
I
separated
my
code,
mainly
in
two
parts,
so
the
automata
is
completely
independent
from
the
UI.
So
if
I
want
later
to
make
another
presentation
because
to
be
honest,
it's
fun
to
play
around
with
with
BV
and
the
gaming
engine
for
this
kind
of
stuff.
But
if
you
want
a
really
efficient
way,
you
probably
would
go
for
some
opengl
stuff
or
for
a
drawing
directly,
and
so
you
have
an
entities.
A
Complaint
system
has
very
less
overhead,
but
with
that
kind
of
presentation
you
have
even
less
overhead
so
and
because
we
have
some
minutes,
I
just
want
to
show
you
some
of
my
stuff.
I
did
during
my
apprenticeship
and
yes,
this
is
some
application
written
in
Devi
for
Conway's
Game
of
Life,
and
this
is
just
some
prepared
stuff.
I
can
draw
here
if
I
want,
but
I
don't
want
it
at
the
moment
and
just
set
hi
and
press
start.
A
A
A
You
can
have
a
very
simple
website
for
that
kind
of
stuff
and
you
can
achieve
amazing,
amazing,
amazing
outcomes.
So,
for
example,
you
can
use
it
for
generating
some
kind
of
mazes.
So
if
I
start
here,
you
will
say
you
don't
doesn't
have
don't
have
the
flickering
anymore.
We
have
something
growing
like
sponge
or
I.
Don't
know
something
like
that.
So
it's
not
really
amazed,
but
it's
probably
look
almost
looks
like
it
and
it
grows,
and
one
of
my
favorite
worlds
is
the
copy
world.
A
Where
we
have.
We
start
with
something
I've
printed
it
in
preparation
and
then
it
looks
chaotic.
It
gets
into
new
forms,
new
forms
and
at
some
point
we
see
it
copies
from
the
from
the
center
and
if
we
go
further
and
further
and
it's
more
chaotic
again,
we
have
surfaces
which
were
one
step
before
some
chaos
like
this
and
with
the
wood
set
bam
a
lot
of
happy
elves,
okay
and
there's
a
lot
of
stuff
going
on
just
as
a
lot
of
stuff.
A
Here's
a
blinking
word
which
you
can
use,
probably
for
terrain
generation
or
something
like
this.
Yes,
we
would
set,
it
will
stabilize
in
some
some
some
areas,
let's
call
it
this
and
if
you
then
keep
running
or
developing
it
just
start
blinking,
okay
and
with
the
last
slide
from
my
presentation.
It
is
it's
here
here
and
here,
just
one
stuff
from
the
subreddit
of
cellular
automaton
from
Reddit
is
some
piece
of
cellular
automaton
art
called
the
mountain,
yes
and
then
I'm
finished.