►
Description
An exploration of the techniques, tools, and designs I used to build nightgraph, a creative coding environment written in Rust, with an emphasis on interactivity and low-friction, minimal boilerplate, sketch creation.
https://rustfest.global/session/48-nightgraph-putting-code-to-paper-with-rust/
A
And
here
we
go
again
welcome
back.
I'm
super
excited
to
introduce,
like
the
next
session
with
us,
is
kyle
nightinger
from
portland
in
the
usfa
and
I'm
very
excited,
because
kyle
is
a
artist
woodworker
and
software
engineer,
which
is
kind
of
exciting,
because
this
is
also
going
to
kind
of
like
dig
into
the
topic
of
how
to
combine
the
physical
world
with
the
digital
world.
But
I
don't
want
to
give
too
much
away
kyle
it's
your
stage
and
everybody
else
enjoy.
B
Thank
you
so
good
morning,
good
afternoon,
good
night,
wherever
you
are
I'm
here
to
tell
you
about
a
project
I've
been
working
on
for,
I
think
about
the
past
month,
but
it's
kind
of
blended
together,
so
it
might
have
been
quite
a
bit
longer
than
that
but
early
stages,
but
I'm
pretty
excited
to
share
it.
So,
first
a
little
about
me,
I'm
a
software
engineer,
professional
I've
done
rust
c
in
python
and
then
artistically
rust,
openscad
and
supercollider
for
music.
B
I
am
a
proud
parent.
I'm
a
woodworker,
we'll
talk
about
this
project
a
bit
soon
and
relevant.
To
this
talk,
I'm
a
artist
particularly
I'll,
be
talking
about
pen
plot
art.
So
here's
a
here's
a
few
of
my
most
recent
pieces
yeah.
This
is
for
kind
of
one
of
those
inktober
type
projects
but
yeah
a
whole
pen,
plotter
community.
We
just
had
this
week
of
plot
party,
so
here's
a
couple
from
there.
B
This
one
has
like
some
mixed
lines,
which
this
was
a
postcard
one,
this
one's
really
cool
and
we'll
talk
about
it
later
during
the
demo
yeah.
This
has
some
kind
of
nested
insets
oops.
Sorry,
if
I'm
moving
away
from
the
mic-
and
this
is
a
variation
on
that
piece-
this
was
an
earlier
piece
that
used
a
connect.
A
lot
of
my
early
work
was
connect
based,
so
connect
piped
into
rust,
piped
into
svg,
but
we're
getting
ahead
of
it.
There's
some
nice
like
crisp
thin
lines.
B
Yeah,
that
would
certainly
be
like
it's
pretty
vital
to
this
talk
so
about
me,
yeah
software
engineer,
proud,
parent,
woodworker
and
all
right
so
yeah.
This
is
like
a
variation
on
kind
of
a
ripple
of
waves.
This
I
kind
of
call
like
flowers,
but
it's
thin
lines
mixed
with
thicker
lines.
This
was
a
postcard
project.
This
one
is
the
one
that
we'll
be
talking
about
later
during
the
demo
yeah
kind
of
geometric
insets,
with
some
like
boolean
difference,
similar
theme
just
colored.
B
B
Okay,
so
svgs
scalable,
vector
graphics.
So
again,
that's
what
we
use
to
talk
to
the
plotters,
there's
kind
of
two
forms
to
it.
We
have
the
stroke
which
is
like
that
outer
outline
here.
We
see
it
in
blue
and
then
the
fill,
which
is
what
we
see
in
green,
so
yeah,
here's
a
nested
one.
So
we
have
the
stroke
and
white
on
both
of
these
and
then
fill
in
green
and
blue.
B
So
the
way
we
see
this,
it
kind
of
appears
to
us
that
they're
stacked
over
each
other
right.
We
see
you
know
kind
of
the
the
green
one
being
obscured
by
the
blue,
the
left
on
the
right
in
case
anybody
has
trouble
with
colors.
This
is
kind
of
oh
yeah
to
backtrack
a
little
bit.
Pen
plotters,
don't
recognize
phil
at
all
right.
They
only
know
about
strokes.
Phil
is
pretty
complex
like
how
do
you
translate
that
to
a
pen
finite
with?
There
are
ways,
but
it
doesn't
make
assumptions.
B
So
this
is
what
we'd
kind
of
expect
the
pen
plotter
to
see,
but
what
the
pen
plotter
actually
sees
like
if
we
were
to
draw
that,
as
is,
is
we'd
get
this
shape
so
on
traditional,
like
rasterize
graphics,
like
something
with
a
frame
buffer
when
you
put
a
shape
down
and
then
you
put
a
shape
over
it,
you
can
kind
of
forget.
What's
beneath
it
and
that's
great!
That's
super
beneficial
at
times
like
it
saves
a
lot
of
math.
It
saves
a
lot
of
programming,
but
we
don't
get
that
benefit
here.
B
So
yeah,
some
of
my
initial
rust
works,
didn't
really
deal
with
that
problem,
like
I
wasn't
ready
for
that
yet
so
it's
just
a
lot
of
shapes
being
put
down,
there's
not
a
lot
of
like
intersections
or
differences
or
anything
but
they're
still
pretty
and
the
connect
ones.
You
know
work
just
as
well
with
that,
so
you
can
still
get
good
results
without
having
to
tackle
something
like
the
more
difficult
problems.
B
B
You
go
to
a
new
hobby,
and
that
was
woodworking,
but
all
that
plotter
work
had
kind
of
given
me
the
itch
of
like
computer
control,
so
I
got
a
cnc
router
and
I
had
this
vision
for
this
lamp
that
I
wanted
to
make
this
kind
of
like
fractured,
but
really
natural
shape
and
just
seeing
something
like
that
and
wood
sounded
really
appealing.
So
I
spent
I
think,
like
all
of
june
building
this
and
programming
it.
I
didn't
do
this
in
rust.
B
B
Okay,
so
that
does
bring
us
to
the
language
I
used.
I
didn't
use
rust.
I
this
was
my
first
time
dealing
with
anything
like
three-dimensional.
I
hadn't
done
any
3d
printing.
I
hadn't
done
any
like
cnc
work
in
the
past,
so
I
wasn't
quite
sure
you
know
I
wanted
to
embark
on
some
rust
library
that
maybe
didn't
exist
yet
or
you
know
I
wanted
to
like
get
my
feet
wet
in
a
comfortable
way.
First
and
a
co-worker
had
recommended
recommended
openscad,
and
I
really
liked
it
because
it
was
like
programmatic.
B
B
So
if
we
look
on
the
right,
we
have
pretty
simple
code
and
openscad
gives
us
that,
like
it's
really
easy
to
create,
like
pretty
complex
shapes
just
by
blending
solids
together.
But
what
we're
going
to
focus
on
is
this
top
part?
So
all
I
say
is
like
I'm
declaring
some
variables
and
I
have
a
little
comment
for
them
and
for
free
just
from
doing
that.
B
So,
in
addition
to
the
3d
work,
we
also
get
2d
work,
it's
not
as
like
supported,
but
it
was
really
fun
to
like.
Take
that
design.
I
just
used
and
translate
it.
You
know
see
how
that
would
go
onto
paper.
So,
even
though
I
had
like
deviated
from
plotter
work
a
bit,
I
got
to
go
right
back
to
it,
and
so
I
created
a
bunch
of
cool
pieces
from
that
and
it
was
really
fun.
But
there
were
some
quirky
intricacies.
B
So
one
of
the
things
is
that
open
scad
doesn't
really
have
the
concept
of
a
line
which,
when
you're
using
a
pen,
it's
like
a
pretty
big
deal
right.
You
want
to
be
able
to
like
draw
a
natural
line,
but
everything
is
a
closed
shape,
an
open
scan,
and
so
that
makes
for
some
interesting
problem
solving
right
in
order
to
do
like
concentric
lines.
You
actually
have
like
these
solids.
B
If
we
look
at
like
that
kind
of
inner
triangle
in
this
picture,
that's
a
bunch
of
like
solids
like
not
single
lines.
So
that
was
one
weird
quirk,
but
then
we,
you
know
I
kind
of
got
past
that
so
it's
not
quite
ideal
for
everything
I
want
to
do.
Let's
see,
yeah
only
closed
shapes,
there's
it's
hard
to
describe
like
what
I
mean
by
this,
but
there's
two
apis.
So
there's
like
this
geometric
api
and
there's
this
like
mathematical
api
in
there
and
they're
kind
of
incompatible.
B
B
B
B
B
You
optionally
have
some
operations
on
them
and
then
you
add
them
to
a
canvas
and
once
they're
added
to
the
canvas
they're
not
like
gone
forever.
As
though,
as
like
a
rastered
like
frame
buffer,
we
can
still
like
ask
them
about
themselves,
use
them
to
like
dictate
where
other
shapes
go.
So
that's
the
way
I
like
to
think
and
I'm
really
glad
to
like,
have
that
toolbox
and
then,
finally,
it
can
render
to
like
multiple
targets.
B
Okay,
so
for
shapes,
there's
a
whole
set
of
them
and
a
lot
of
them
have
like
really
hand.
Builders,
so
they'll
cover
all
the
features
they
have
without
like
gigantic
instructors.
So
for
a
path
you
might
want
to
make
it
from
like
commands,
but
you
can
also
make
it
from
points
you
can
close
it
to
be
like
a
polygon
or
keep
it
open
to
have
like
a
smooth,
continuous
line
somewhere.
You
can
do
like
this.
Is
this
smooth
function
gives
you
like?
B
B
And
then
yeah
for
our
operations.
So
again
I
was
really
inspired
by
what
I
had
available
in
openscad
I
mean
here
we
see
a
difference
operator,
so
I
have
these
waves
in
the
background
and
then
text
is
placed
above
it,
but
I
called
difference
on
it
now.
If
I
would
have
called
intersection,
kind
of
all
we
would
have
left
is
the
lines
where
they
cross,
like
the
letters.
B
And
again,
like
some
of
the
ideas
I
have
in
the
way
I
like
to
think
is
I
like
to
ask
about
shapes,
but
not
just
the
shapes
I
created
the
shapes
that
are
like
the
result
of
other
operations,
so
even
on
the
res,
they,
you
know
the
operations
we
just
looked
at
the
result
of
those.
I
can
ask
for
the
area
the
perimeter
like
what
would
be
the
closest
point
on
the
shape.
B
What's
the
centroid,
which
is
like
the
geometric
average
of
a
of
a
point
like
its
center
of
mass,
I
can
ask
like
what
intersections
there
are
like
or
like
if
a
line
passes
through
a
shape
like
how
many
intersections
does
it
have
and
where
are
they?
Whether
a
shape
contains
a
certain
point
in
its
area,
again
the
bounding
box
and
then
its
points
like
as
its
control
points.
B
B
B
It
was
just
exciting
to
make
new
pieces,
so
I
didn't
put
the
time
into
like
creating
this
whole
system,
but
I
wanted
something
that
took
almost
no
effort
to
like
enforce
this
organization,
so
I
wanted
something
that
would
be
simple
to
create
a
new
work
and
and
have
it
in
this
framework.
You
know
takes
no
time
as
soon
as
I
have
an
idea
I
can
just
sketch
it
out.
Have
it
done,
and
I
don't
have
to
worry
about
adding
it
to
all
these
libraries
and
incorporating
this
metadata.
A
B
B
So
clap
is
used
for
command
line,
arg
parsing,
you
know,
maybe
it's
an
acronym
and
it's
really
cool
how
how
it's
used.
So
this
isn't
the
new
version
of
clap-
that's
not
quite
released,
yet
you
can
still
use
it,
but
it's
not
a
like
stable
release,
but
it's
based
on
the
struct
or
yes
truck
top
crate.
So
we
get
these
like
really
nice
macros
that
we
can
define
our
command
line
arguments
with.
So
in
this
I
had
a
you
know
an
opinion
like
I
have
this
struct.
B
So
one
is
the
string
argument
and
we'll
see
what
this
program
does
and
then
other
is
a
flag,
and
why
don't
we
run
that
so
by
just
adding
those
and
using
these
these
attributes
on
our
shape
or
on
our
struct
when
we
compile
it,
we
for
free,
get
like
this
nice
like
help
in
usage
info,
so
I
passed
it
dash
h
and
it
tells
me
my
application
and
the
arguments
and
the
different
options.
So
why
don't
we
run
it?
B
B
So
we
simply
just
parsed
our
arg
struct
clap
gives
us
through
derived.
Attributes
gives
us
this
parse
method
and
that
fills
out.
You
know
from
our
command
lines
the
values
into
here,
and
so
we
just
kind
of
look
at
those
and
I
think
a
name
changes
it
in
order,
because
that
was
a
very
bossity
given
on
what
it
does.
B
B
Okay
with
that
done,
let's
go
back
to
this
drug
or
the
sketch
and
let's
scroll
up,
so
we
looked
at
it's
its
main
method
right
where
we
well
exact
or
you
fill
it
out
a
canvas.
But
if
we
scroll
up,
I
have
it's
its
parameters,
its
values,
so
I
tag
it
with
sketch
and
automatically
it
kind
of
it's
prepping
itself
to
be
used
in
a
similar
way,
and
so
each
parameter
can
have
some
metadata
about
it.
So
its
name
is
auto
derived
from
its
actual
name.
B
Its
description
is
pulled
from
its
dock
string.
We
can
set
a
default
value
and
we
can
set
a
range
of
valid
values.
This
will
feel
like
super
familiar
to
you
if
you've
used
clap
like
some
of
these
are
verbatim.
You
know
copies
of
it.
But,
for
example,
range
is
an
addition,
that's
new,
so
you
might
be
wondering
like
why
I'm
not
just
using
clap
and
and
we'll
get
to
that.
B
B
Allow
you
to
make
like
some
assumptions
and
and
create
like
a
easier
to
use
system,
but
the
reason
I
had
to
use
this
attribute.
One
is
because
I
actually
want
to
emit
new
derived
attributes.
I
mean
you
can't
do
that
in
a
derived
one.
So
I
do
want
to
hit
or
like
emit
clap
arguments
from
this,
but
I
couldn't
do
that
in
a
derived.
B
So
the
available
parameter
attributes
and
we
have
the
default
value.
The
range
which
again
is
not
a
clap
one,
that's
custom,
a
name
override
a
description
override
and
then
ignore.
So
you
know.
Well,
we
don't
know
what
these
do
yet.
So
ignore
doesn't
make
sense
to
you,
but
later
in
the
talk
when
we
look
at
what
this
actually
accomplishes,
the
ignore
attribute
would
just
tell
it
to
skip
all
that.
B
And
so
from
that
we
also
have
a
sketch
list
right.
I
want
to
assemble
all
these
sketches,
but
it's
a
lot
of
work
to
you
know,
say
and-
and
some
people
might
find
this
like
very
controversial,
but
I
want
to
stress
that
this
is
like
internal
to
a
crate
that
only
I'm
using,
but
it
gets
rid
of
a
lot
there's
a
lot
of
magic
happening
in
this
macro
that
is
kind
of
too
much
magic
in
my
opinion,
so
it
declares
the
module
it
uses
the
module.
B
B
So
just
like
with
our
clap
example,
I
run
it
with
the
dash
h
and
I
get
this
night
graph.
Cli
shows
all
my
options
and
then
this
sub
command
thing,
so
the
sub
command
is
all
this
sketches
that
we
added
to
that
sketch
list,
and
it
shows
a
description
of
it
from
the
docs
string.
I
can
select
any
of
them
and
if
we
go
even
further,
why
don't
we
ask
that
blossom
sub
command,
aka
sketch
about
itself,
and
so
now
we
get
to
see
its
values.
B
Those
are
all
the
parameters
we
have.
This
will
feel
really
familiar
to
you
if
you've
used,
like
you
know
any
of
the
cargo
tools
and
the
help
with
it.
For
example,
if
you
look
at
like
cargo
expand
like
a
macro
expander,
that's
really
helpful,
and
I
love
so
much
for
that.
Helped
me
out
with
this,
but
you
know
any
of
those
like
the
help
pages
of
that.
It's
similar
thing
right
using
that
sub
command
pattern,
and
ultimately
we
can
run
it
with
some
arguments.
If
we
want.
B
C
B
B
So
if
it's
a
a?
U
integer,
it'll,
be
u
in
if
it
fits
a
regular
integer.
So
there's
some
loss
of
precision
there.
It's
not
yet
very
respecting
of
like
what
values
we
actually
use,
but
it
does
some
things
behind
the
scenes
to
kind
of
make
its
best
to
like,
prevent
any
or
to
guard
against
any
like
invalid
values
or
whatever.
B
B
So
command
line
arguments
are
really
nice
like
command.
You
know
that's
fun,
but
when
I
think
back
when
I
was
designing
this
after
I
first
implemented
the
the
collapse
solution.
I
was
thinking
of
openscad
and
like
how
much
I
I
really
enjoyed
the
work.
I
got
to
do
with
that
or
like
the
the
process,
the
creative
process
of
tweaking
values
and
so
using
the
egoi
crate.
I
created
this
system
that
displays
my
sketches.
Auto
generates
the
parameters,
so
I
wrote
you
know
for
for
this
particular
sketch.
B
I
wrote
no
controls
or
no
no
code
to
to
add
these
controls
to
this.
This
page,
the
the
proc
macro
handles
that
for
me.
So
this
most
recent
work.
It
was
done
by
sprinkling
a
ton
of
charcoal
powder
on
a
page
and
then
having
something
scratch
it.
So
I
needed
something
to
like
chaotically:
go
back
and
forth
for
these
lines
like
if
we.
C
B
Really
close,
let's
see,
did
I
freeze
okay
going
a
little
slow,
but
it's
really
scratchy
and
I
needed
it
that
way.
So,
let's
see
yeah.
So
we
can
see
here
those
scratchy
lines
and
it
was
really
fun
to
like
be
able
to
play
around
with
that
without
having
to
like
recompile
without
having
to
like
on
the
command
line.
Keep
you
know
hitting
up
changing
value
hitting
enter
hitting
up
so,
for
example,
why
don't
we
change
where
the
text
is
right?
B
I
don't
know
how
about
like
500
line
segments,
okay,
so
that's
cool,
but
again
like
we're
just
getting
started
so
there's
12
of
these
concentric
circles.
Why
don't
we
bump
that?
Up
to?
I
don't
know
160.,
so
that's
cool,
it's
handling
it
like
a
champ.
You
know
every
time
I
move
the
mouse
wheel
or
every
time
I
like
change,
a
parameter,
it's
going
to
recompile
or
not
recompile,
but
rerun
this
algorithm,
and
just
like
really
see
like
how
much
this
is
doing.
B
We
can
hype
up
the
randomness,
which
will
give
us
an
example
of
just
like
how
many
lines
there
are
and
again
it's
just
like
handling
it.
Like
a
dream.
I
don't
think
I
could
do
this
with
this
kind
of
performance
in
any
other
language,
but
yeah
rust
is
doing
great
at
it.
With
that
said,
there's
things
that
I
don't
necessarily
do
well
in
in
russ.
So,
even
though
like
when
written
well,
this
is
going
to
perform
like
a
champ.
B
So
yeah
we,
let's
see
we
covered
a
little
demo,
I'm
not
sure
how
much
I'm
doing
on
time
so
like
I
won't
go
into
like
demos
of
other
ones,
but
we
have
yes.
Some
future
features
that
I
want.
Some
are
pretty
painfully
obvious,
there's
no
way
to
export
from
the
ui
so
like.
If
I
create
this
like
nice
picture,
I
don't
have
a
way
to
save
it
as
an
svg
there.
I
have
to
like
copy
the
the
values
and
then
do
it
on
the
command
line.
B
I
want
to
be
able
to
handle
more
types
in
the
parameters.
So
right
now
we
have
numeric
types
boolean.
I
want
to
be
able
to
do
text.
I
want
to
be
able
to
do
like
structured
types,
so
structs
and
enums
and
yeah.
I
want
to
allow
resetting
the
parameters
and
saving
presets
again.
These
are
like
all
pretty
obvious,
but
they
just
like
need
a
little
bit
of
time
to
get
there.
B
Oh
one
cool
thing,
it'd
be
great
to
add,
like
keyframes
and
animations,
so
in
the
ui
being
able
to
like
set
a
frame
change,
a
value
like
move
forward
x,
amount
of
seconds
or
whatever
change.
Another
value
run
that
and
have
like
an
interpolated
animation
that
we
can
render
to
that'd,
be
pretty
like
I'm,
not
shooting
for
performance
there
if
something,
that's
like
gpu
rendered,
but
you
know
just
something
to
augment
some
of
my
work
currently
like
one
of
the
biggest
issues.
B
So
as
this
is,
this
runs
natively
like
in
perfectly
in
wasm.
So
this
isn't
like
just
a
tool
that
I
have
to
enjoy
like
it'll,
be
really
fun
to
like
deploy
this
and
let
other
people
use
it.
However,
excuse
me
there's
no
way
for
people
to
write
programs
like
right
now.
That's
that's
solely
on
me.
Nobody
has
that
ability.
B
They
would
just
be
able
to
modify
what
I
have
so
that's
kind
of
the
one
like
benefit
that
a
interpreted
language
would
have
over
a
compiled
one,
but
I
want
to
overcome
that
with
either
a
node
editor
somewhere
like
pure
data
or
like
a
ton
of
video,
editing
tools
or
a
scripting
language
in
itself.
So
I've
been
looking,
I
have
a
prototype
branch
that
plays
with
gluon.
I
looked
at
mun
that
seemed
exciting.
B
However,
it
yeah
it
doesn't
have
the
ability
to
do
dynamic,
arrays,
so
that's
kind
of
limiting
for
the
stuff.
I
want
to
do
and
then
finally
like
a
socket
communication
to
the
gui
so
right
now,
if
I
actually
change
the
code
of
any
sketch,
I
need
to
recompile
and
then
the
gui
pops
out
and
then
pops
back
in
so
yeah.
C
B
B
Michelle,
who
has
just
been
really
good
pillar
in
the
community
and
brought
a
lot
of
folks
together
and
finally
another
rust
programmer
fitzgen
did
a
talk
at
russ
conf
in
like
2019,
about
something
very
similar
to
this,
and
so
I
watched
it
back
then
and
then
immediately
never,
you
know
kind
of
removed
it
and
never
watched
it
again
because
it
was
really
inspiring.
But
I
wanted
to
do
solve
all
these
problems
on
my
own
and
not
like
follow
his
solution.
So
I'm
sure
it's
a
great
talk.
B
A
Hello,
thank
you
so
much.
First
of
all,
I
can't
believe
this
was
like
your
first
talk.
You
you
should
have,
you
should
have,
let
us
know,
and
it's
like
we
were
just
like
gushing
like
wow
kyle's
doing
so
well.
That
being
said,
you
run
a
little
bit
over
time,
so
I
think
we
cut
the
questions
to
no
questions
and.
A
With
that
being
said,
I
want
to
thank
you
again
and
then
we're
like
going
into
a
break,
and
this
is
an
important
announcement
for
all
the
people
watching
the
live
stream.
We
will
cut
the
break
short
and
we
will
be
back
in
already
in
20
minutes
and
so
that
we
can
like
yeah
hop
on
the
the
schedule
as
it
was
planned
originally
at
like
half
past
what
every
hour
is
wherever.
C
A
Yeah
also,
I
think
people
would
appreciate
your
dot
files
if
you
have
them
publicly
somewhere,
because
I
was
also
like
very
much
appreciating
just
the
the
setup
and
looking
at
the
nice
stuff,
but
like
that's
enough,
like
gushing
over
random
things,
I
guess.
Okay,
after
the
break,
see
you
in
20
minutes
see
you.