►
From YouTube: OSS Power-Ups: Silk.NET
Description
This is the fourth episode of JetBrains' series of OSS Power-Ups, where we want to put a spotlight on open-source .NET projects. Silk.NET is a high-performance, low-level wrapper over many native libraries and is your one-stop-shop for .NET graphics and compute workloads. Being used in a number of games and game engines, Silk.NET aims to be the one library you need for .NET multimedia, graphics, and high-grade compute applications. We'll explore how Silk.NET works in practice, what sets it apart from other libraries. Using the most intricate & obscure corners of C# and .NET, we'll also take a deeper look at the internals of how the Silk.NET library is put together.
Treat yourself with some gaming-related programming fun!
Speaker
Dylan Perks & Kai Jellinghaus
Bio
Dylan Perks is a software engineer based in England, currently working on high-assurance defence solutions for L3Harris. In his free time, Dylan also works with a small group of friends on games and other graphics-related applications. Enjoying the more intricate, low-level side of programming, Dylan remains the primary maintainer of Silk.NET despite high-grade GPU graphics and compute being only tangentially related to his day-to-day work. You can reach him on Twitter through @Dylan_Perks.
Kai Jellinghaus is a student in Germany with a passion for algorithms and performance analysis, spending much of his free time investigating .NET code generation and obscure implementation details. Joining Silk.NET a year ago, he has rewritten and maintains the marshalling system SilkTouch, and added a graphics & compute-oriented mathematics library to Silk.NET. You can reach him on GitHub through @HurricanKai.
Twitter / GitHub
https://twitter.com/Dylan_Perks
https://github.com/HurricanKai
-----
.NET Guide: https://www.jetbrains.com/dotnet/guide/
JetBrains .NET Blog: https://blog.jetbrains.com/dotnet/
Rider: https://www.jetbrains.com/rider
More about JetBrains .NET tools: https://www.jetbrains.com/dotnet/
A
Okay,
welcome
everyone
to
this
webinar
that
we're
having
today
and
let
me
start-
I
just
need
to
switch
my
screens
here.
So
this
is
the
fourth
episode
that
we
have
with
this
format
our
oss
powerapps.
Today
we
have
silk.net
here
with
kai
and
and
dylan,
and
this
is
all
about
now.
My
tablet
started
playing
as
well,
so
this
is
all
about
net
open
source
projects
and
the
net
community,
and
first
things
first
also,
since
this
is
the
first
time
we're
streaming
on
the.net
foundation
channel
as
well.
A
If
you
have
any
questions,
feel
free
to
post
them
in
the
chat
down
below
or
on
the
right.
This
will
also
be
recorded.
So
if
at
any
point
you
have
to
drop
out
feel
free
to
continue
watching
afterwards
and
again,
since
this
is
the
first
time
we're
having
this
on
the
net
foundation
channel,
I
will
also
share
a
couple
of
information
on
how
this
came
about.
A
So
if
we
look
at
open
source
and
particularly
net
ecosystem
and
open
source
there,
we
see
that
lots
of
maintainers
freely
share
their
great
work
with
the
public
and
organizations
often
benefit.
Let
me
also
disable
notifications.
My
mistake
organizations
widely
benefit
from
that
and
also
save
own
investments.
Of
course,
however,
the
contributions
back
are
probably
more
insufficient.
A
So
if
you're
on
twitter,
for
instance,
or
read
a
couple
of
blog
posts,
you
may
know
about
aaron
stern
who's,
a
great
voice
for
net
open
source,
and
if
you
follow
those
blog
posts,
then
you
can
clearly
understand
that
there
is
a
sustainability
problem
in
the
net.
Open
source
ecosystem
and
maintainers
might
receive
a
lot
of
popularity
through
their
great
work,
of
course,
but
with
that
also
comes
a
lot
more
responsibility,
so
they're
expected
to
try
to
issues
and
sometimes
even
get
rude
comments.
A
Of
course,
unfortunately,
they're
required
to
update
their
documentation,
which
we
as
consumers,
sometimes
not
even
read,
pay
for
hosting
services
etc,
and
the
real
tragedy
here
is:
if
a
project
gets
discontinued
due
to
burnout,
for
instance
too,
it
would
affect
the
whole
community.
So
no
one
really
wins
here
and
that's
the
tragedy
if
those
creative
minds
get
left
behind.
A
So
with
that,
we
ask
ourselves
at
the
jetbrainsteam.net
advocacy
in
particular.
What
can
we
do
about
it?
Of
course,
there's
also
a
dark
knight
foundation,
which
is
a
great
effort
I
have
to
say,
but
we
try
to
come
up
with
something
from
our
own
resources,
let's
say,
and
with
that
we
want
to
have
every
month,
probably
that's
the
plan.
A
The
second
is,
we
want
to
give
those
projects
and
their
maintainers
a
platform
to
talk
about
their
project,
of
course,
and
make
everyone
aware
that
they're
open
to
receive
sponsorships
and
what
kind
of
ways
to
contribute
to
the
project
exists
and
the
third
one-
and
this
is
really
the
fun
part
here
also
for
for
our
whole
advocacy
team.
We
would
like
to
share
our
personal
strengths,
which
are
very
diverse,
so
martin,
for
instance,
knows
a
lot
about
net
or
memory.
A
A
Yeah,
okay
cool,
I
hope
you're
both
doing
great.
I'm
really
excited.
I
have
to
say
about
this
webinar
today,
because
it
contains
lots
of
stuff
that
also
touches
my
personal
preferences.
I'm
really
excited,
but
let's
talk
about
you,
so
you
two
are
maintaining
silk.net
for
how
long
and
how
did
you
get
to
it
and
what
are
you
usually
doing
and
then,
let's
start
with
with
dylan,
let's
say.
B
Yeah,
so
I've
been
so
I
originally
started
tilt.net.
It
was
so
I
was
maintaining
another
project
at
the
time
and
I
found
myself
that
this
wasn't.
This
was
another
relatively
large
project
and
I
found
myself
limited
by
the
massive
overhead
that
they
had
in
terms
of
well.
If
you've
got
lots
of
users
who
are
expecting
a
consistent
library
who
then
well,
you
can't
really
make
changes.
So
silk.net
is
more
a
breakout
project
where
we
were
able
to
break
everything
and
not
really
have
any
repercussions.
B
Of
course,
now
it's
a
bit
different
that
we
have
people
following
us,
but
yeah.
So
I've
been
maintaining
it
for
around
two
years,
which
is
the
lifetime
of
the
project.
It's
very
new
and
yeah.
It's
it's
only
because
I
have
a
lot
of
graphics,
really
and
yeah.
I
do
stuff
with
zelda
outside
of
just
maintaining
the
library.
I
also
may
hold
my
game
and
as
as
well
as
I
manage
the
discord
community
for
self.net
as
well,
which
is
always
fun
to
see
what
people
are
making
with
it.
C
So
I
joined
about
a
year
ago:
it
should
be
pretty
much
a
year
now
and
I
I
can't
really
say
that
I
did
a
lot.
I
did
a
lot
with
graphics
before
then
I
kind
of
looked
for
a
good
graphics
library
at
the
time,
and
I
knew
dylan
via
the
c-sharp
discord
and
kind
of
kind
of
just
joined,
so
goodnight
from
there
tried
fiddling
around
with
it
a
bit
and
trying
to
learn
graphics
but
kind
of
got
distracted
by
contributing
to
it
then
yeah.
Since
then,
I'm
been
retaining
it.
A
Sounds
really
cool,
so
one
thing
and
I
hope
I'm
allowed
to
say
that
you're
both
really
really
young
compared
to
most
of
the
maintainers.
I
know-
and
basically
it's
just
coming
from
from
myself-
I
think
you're
doing
a
great
job
I
mean
sub.net
has
gained
great
popularity
over
that
time
and
I
know
kai
you're
still
a
student
dylan,
I
think
too,
but
partly
working
right.
B
A
B
All
right
I'll
do
this
in
for
a
bit,
so
still.net
is
so
for
this
webinar.
We
still
done
that.
It
obviously
has
got
a
lot
of
advanced
topics.
It's
got
graphics.
It's
got
high
grade,
gpu
compute.
Those
are
very
complicated
subjects
that
we're
not
even
going
to
try
and
explain
in
this
webinar.
So
what
we're
going
to
talk
about
is
sort
of
the
next
generation
mechanism,
which
is
well
it's
quite
vast.
B
B
Oh
wait!
No,
I
think
that's
a
total
number,
but
yeah
most
of
that
most
of
our
code
is
generated,
and
in
this
webinar
we
wanted
to
discuss
how
we
facilitated
that.
How
what
sort
of
dark,
secret,
c,
sharp
language
features
that
we
that
we're
using
to
sensate
that,
but
first
of
all,
we
should
probably
tell
you
what
silp.net
is
and
yeah.
So
if
it
goes
to
the
next
slide,
so
sild.net
is
a
high-grade
compute
and
graphic
library.
So
what
does
that?
It's
a
bindings
library,
so
we
don't
do
the
actual
compute.
B
What
we?
What
we
are
doing
with
sub.net
is
we're
lifting
c
and
c
plus
libraries,
and
we
bring
them
to
the
c
sharp
level
and
obviously
that
doesn't
always
look
the
clean
you
may
have
heard
you
may
have
heard
of
unsafe
code,
which
is
it
all
sorts
of
pointers
and
stuff,
but
that
is
done
in
the
name
of
our
next
point,
which
is
providing
low
overhead,
so
still.net
tries
to
add
as
minimal
overhead
as
possible,
but
at
the
same
time
we
want
to
be
usable
as
well.
B
So
we
do
provide
some
c-sharp
helpers
just
to
make
it
more
like
the
rest
of
your
code,
will
look
and
not
completely
all
over
the
place
and
like
you're,
just
trying
to
use
c
plus
plus
in
c
sharp,
because
at
that
point
just
use
c,
plus
plus
but
yeah.
The
aim
of
the
project
is
to
be
a
one-stop
shop
for
editing.net
and
gpu
related,
which
means
we're
essentially
trying
to
give
you
all
the
tools
you
could
possibly
need
for
your
games.
B
Applications
your
game
engines,
your
scientific
visualizations,
whatever
you
can
make
with
a
gpu.
If
it
draws
a
triangle,
we
probably
have
something
to
help
with
that.
So
moving
on,
we
do
have
a
lot
of
apis.
So,
as
I
said
before,
we
try
to
keep
it
as
one-to-one
as
possible,
while
also
needing
it
neatening
it
up
a
bit.
So
it
looks
more
c-sharp
and
it's
less
c,
plus
plus
so
yeah
we've
got
around
17
bindings
at
the
moment,
which
is
a
lot.
B
That's
a
lot
of
see
apis
that
we've
tried
to
facilitate
access
to,
but
we
also
provide
some
high-level
utility
libraries
for
just
to
handle
common
things
like
cross-platform
window
creation,
cross-platform
input
like
your
keyboards,
your
game
controllers
and
we've
also
got
a
mass
library
which
I'm
sure
kai
is
looking
very
forward
to
talk
about.
But
the
importance
of
this
project
is
mainly
as
it
brings
c-sharp
closer
to
the
metal
is
obviously
we
all
know.
B
Gpus
are
very
very
fast
and
you
can
do
a
lot
of
powerful
things
with
them,
and
so
dotnet
scroll
is
basically
to
facilitate
that.
So
you
can
well,
you
can
do
whatever
you
want
with
a
gpu
or
something
that
and
the
reason
why
why
you'd
want
to
use
something
like
silt.net
over
something
like
unity
is
because
we
give
you
complete
control.
We
don't
try
and
hold
your
hands.
That's
the
point
of
silt.net
it's!
Because
of
that
you
can
get
every
nanosecond
of
performance.
B
You
could
possibly
get
out
of
a
graphics
application
so
and
then
the
next
slides,
sorry,
I've
just
spoiled
the
next
slide
there.
So
if
we
move
on
again
so
still.net,
we
do
things
a
bit
differently,
so
we
have
consistent
monthly
updates,
because
my
stuff
is
did
I'm
sure,
you've
all
seen
in
the
graphics
industry,
all
the
move
to
gtx
ray
tracing
the
graphics
moves
a
lot
and
it
moves
fast.
B
B
So
we
can
make
changes
to
make
the
library
better
rather
than
worrying,
about
the
people
who
are
kept
behind
at
the
same
time.
So
that
does
mean
that
you
might
be
at
risk
of
small
breaks
here
and
there
we
try
to
minimize
it
as
much
as
possible,
but
silt.net
is
important
because
it
keeps
up
with
the
times
it
keeps
up
with
the
latest
changes
in
graphics
and
compute.
B
So
if
we
move
on
so
conti
we're
continuously
improving,
with
with
the
first
two
adopted,
news.net
and
c-sharp
features,
which
is
we,
if
there's
something
secret
in
the
language
that
that
we
could
get
a
couple
of
nanoseconds
out
of
then
yes,
we
will
use
it.
Of
course,
it
means
that
we
there's
a
lot
to
silt.net
that
you
might
not
have
used
before
a
lot
of
secret
internals.
B
So
something
that
can't
be
said
about
other
libraries
is
that
you
can
count
on
is
not
dying
tomorrow,
which
is
very
important
because,
as
matt
touched
on
at
the
beginning
of
the
webinar,
sustainability
is
important
with
open
source,
libraries,
okay.
So
next
back
to
this
big
figure,
what
the
hell
have
we
done
to
get
such
a
high
number?
B
So
we're
actually
going
to
touch
on
the
less
important,
well,
not
less
important,
but
less
interesting
bit
of
it
at
the
moment,
the
manually
written
portion,
so
next
up
yeah,
we
can
see
that
only
118
000
well,
I
say
only
118
000
lines
of
manually,
written
c
sharp
code.
That
is
a
lot,
but
it's
not
as
much
as
the
other
millions
of
lines
of
codes
that
are
generated
as
output.
So
let's
have
a
look
at
this.
The
next
slide.
B
So,
as
I
mentioned
earlier,
we
have
a
a
few
high-level
utilities
which
help
you
would
help.
You
cover
the
snags
that
you
most
commonly
encounter
when
doing
anything
graphics
really,
so
windowing
is
the
first
one
so
well
I
I
presume
that
a
lot
of
you
spend
a
lot
of
time
with
an
operating
system.
You
may
notice
that
everything
is
in
a
window.
B
It
turns
out
that
is
a
pain
in
the
ass
to
get
working
across
platform.
So
we
really
need
to
try
and
make
that
as
easy
as
possible,
because
well,
if
dot
net
call,
it
runs
on
linux,
macos
and
windows.
We
also
want
to
run
in
all
of
those
places,
but
at
the
same
time
we
don't
want
our
users
to
have
to
change
all
of
their
code
to
do
that.
B
B
If
you
have
a
more
c-sharp
like
like
abstraction
that
runs
everywhere,
so
silk.net
windowing
runs
on
windows,
linux,
mac,
os
and
android
and
ios,
but
we
haven't
got
quite
got
there
yet
we're
hoping
with
dot
net
six
that
will
get
there
with
input
on
the
next
slide.
It's
a
similar
scenario,
there's
a
lot
of
stuff
to
do
to
just
to
figure
out
whether
the
a
button
is
pressed
which,
on
a
game,
controller,
which
is
it's
probably
a
bit
more
than
you
need.
B
B
That's
called
a
input
context
which,
which
you
create
when
you
first
start
up
the
window
and
then
it's
as
simple
as
just
looping
through
the
gamepad
and
checking
if
the
a
button
is
pressed,
which
is
a
lot
more
sane
than
having
to
get
lots
of
different
states,
as
you
saw
on
the
previous
slide
so
moving
on,
and
I
think
I'm
going
to
let
kai
come
over
this
next
section.
Seeing
as
this
is
his
area.
B
B
One
of
the
advantages
of
this
is
that
well,
first
of
all,
we
have
a
lot
more
bindings
that
that's
a
given,
but
obviously
not
everyone's
gonna
use.
Every
single
library
we
provide,
but
second
of
all,
is
we're
using
a
lot
more
modern
c
sharp
features
like
source
generators
which
we're
going
to
touch
on
as
well
as
we're
trying
to
slowly
vectorize
our
mass
library.
So
you
can
get
an
extra
bit
of
nanoseconds
performance
in
a
in
your
code,
but
yeah.
The
main
advantages
is
well.
I
touched
up
on
it
before.
B
Is
that
it's
the
consistent
monthly
updates
and
that's
pretty
much
it
we're
a
lot
more
sustainable
and
we
can
we're
quick
to
move
as
well.
So
if
something
happens
in
the
industry,
you
can
count
on
us
responding
to
it
in
the
next
monthly
update,
which
we've
seen
with
like
rage
racing,
which
currently,
I
think
silt.net
is
the
only
bindings
library
to
provide
rate
rating.
But
don't
quote
me
on
that
because
I
don't
actually
know
for
sure.
B
A
I
actually
have
one
more
question,
so
you
say
you're
you're
more
up
to
date
and
you
have
basically
basically
push
out
regular
updates.
Do
you
have
some
kind
of
number
like?
If,
if
you
would
think
you
know
you
would
check
in
your
source
code?
I
think
you
don't
as
far
as
I
know,
but
if
it
would
happen,
what
is
the
amount
of
lines
that
get
changed
from
one
update
to
to
another?
B
It
in
another
map,
so
this
is
an
interesting
one,
because
all
of
our
code
is
generated
and
if
there's
a
lot
of
changes
in
our
in
the
sources
we
generate,
our
code
from
the
number
could
easily
be
in
the
tens
or
hundreds
of
thousands,
which
is
a
lot
and
that's
pushed
to
the
repo
as
well.
That's
not
even
talking
about
the
gremlins
that
go
on
behind
the
scenes
that
you
don't
see
in
the
repo
so
yeah
it
can
be
a
lot,
but
it's
necessary
to
keep
up
to
date.
A
B
C
C
C
Extra
graphics
apis,
which
you
might
need
system
variants,
already
includes
matrix
for
s4
and
matrix
leaks
too,
but
we
also
include
kind
of
all
the
other
permutations
from
four
to
two.
So,
for
example,
we
also
have
a
matrix
for
x2.
We
have
curve
types
etc.
So
we
we
just
kind
of
expand
on
that
idea
and
try
to
provide
some
some
more.
C
Api
so
now
I
want
to
move
on
to
the
generated
portion,
first
of
all,
silk
touch
which
generates
about
5.5
million
lines
of
codes
on
every
build
of
silk.net,
because
it's
a
source
generator
and
you
might
have
heard
about
source
generators
at
the
net
days.
The
first
day
there
was
a
talk
about
this
generator.
So
if
you
care
for
that,
do
check
that
out,
I'm
just
going
to
quickly
say:
social
medias
are
basically
something
invoked
by
the
compiler.
When
you
build
the
project.
C
C
Users,
it
only
really
happens
when
we
build
zip.net
itself
and
is
then
packaged
into
into
the
into
the
nugget,
for
example,
but
yeah.
We
use
that
and
we
have
replaced
our
old
reflection
based
generator
about
a
year
ago.
Now,
or
at
least
we
started
replacing
it
about
a
year
ago,
and
this
basically
brings
the
startup
cost
of
cir.net
to
almost
zero.
We
have
costs
only
to
load
the
native
library,
for
example,
gl
or
whatever
graphics
you're
using
but
the
function.
C
C
Like
a
normal
function
with
two
parameters
and
the
internet
in
pointer
and
then
it
doesn't
really
do
anything
because
neither
of
those
require
any
changes
to
be
understandable
for
c,
but
for
for
many
c
sharp
types
we
need
to
do
some
sort
of
transformation
to
translate
into
c
or
c
plus.
So,
for
example,
if
you
take
a
normal
array
which
pretty
much
every
detailed
user
should
know,
that's
as
you
might
know,
and
manage
type,
so
the
garbage
collector
keeps
track
of
it
and
c
doesn't
have
a
concept
like
that.
C
B
C
Cache
them
because,
while
loading
is
relatively
cheap,
it's
not
free,
so
the
caching
is
kind
of
a
little
bit
of
optimization
and
last
we
take
great
care
and
circuit
to
optimize
the
function
body.
We
regenerate
it's
not
really
that
important
to
us
how
optimized
the
the
generator
itself
is,
because
that
only
really
influences
build
times
and
but
but
it's
very
important
that
the
method
bodies,
the
coded
outputs,
is
highly
optimized,
so
I'll
quickly
move
over
into
c.
C
And
first
of
all,
I'm
gonna
quickly
show
the
c
code,
I'm
not
a
c
expert
myself,
but
I
managed
to
make
this
and
it's
a
very
simple
method.
Really
we
just
print.
We
just
take
two
to
parameters
and,
like
I
shown
you
with
an
int
parameter
and
an
endpointer,
and
we
just
print
something
and
calculate
the
sum
of
all
the
values
we're
given.
C
C
I've
already
built
this
and
copied
it
over,
so
we
can
now
invoke
it
from
c
sharp,
and
that
looks
something
like
this,
and
this
is
really
what
although.net
pretty
much
consists
of
and
and
for
example,
here
I've
called
the
sum
api
because
we
take
sums
of
of
code
of
numbers
and
if
you
use,
for
example,
opengl
this
class
might
be
called
gl
or
for
vulcan.
This
make
may
be
called.
B
C
C
This
is
what
soft
touch
will
interpret
and
I'll
show
you
what
that,
what
it
does
in
one
second,
we
basically
have
this
attribute,
which
search
picks
up
on
and
you
might
already
notice.
This
is
exactly
the
function
name
we've
just
given
a
c
and-
and
this
does
maps
want
one
to
the
dll
exported
functions,
and
then
we
can
pretty
much
give
this
any
name,
but
you
have
just
chosen
to
keep
it
the
same
and
then
the
parameters
is
what
circuit
tries
to
figure
out
for
this
foot.
C
I've
made
two
overloads
here
and
the
first
one
is
pretty
much
just
the
direct
c
version
where
we
need
to
pass
a
pointer
and
some
c
sharp
people
will
probably
be
okay
with
this
and
we'll
know
how
to
do
this,
but
for
for
the
for
the
people
that
don't
want
to
deal
with
this,
we
also
provide
overloads
like
this
one
and
in
actual
signal
net
code.
We
provide
many
many
more.
C
That's
unfortunate,
apparently,
it
doesn't
function
right
now,
but
okay,
so
essentially
just
gets
the
api
call
here
and
we
call
the
sum
function
here
and
we've
already
used
the
the
overload
for
ratio
this
the
actual
function
uses
span.
That's
why
writer
shows
this
handy
little
icon
that
that
an
implicit
conversion
happens
here,
but
I
think
this
is
pretty
idiomatic
c
sharp
code
just
passing
an
array
that
that
shouldn't
be
really
it's.
C
Like
this-
and
this
is
exactly
the
code
this-
this
was
just
generated
in
a
couple
of
milliseconds-
you
just
saw
the
console,
do
things
so
the
source
and
such
was
invoked
and
looked
at
these
parameters
and
tried
to
figure
out
what
to
do
with
this
and
pretty
much.
What
we
I
just
mentioned
is
what
we
need
to
do
is
we
need
to
get
a
pointer,
and
we
need
to
tell
the
garbage
collector
to
not
move
this
around
chart
actually.
B
C
At
start,
we
have
a
bunch
of
yeah
code
that
sort
of
tries
to
do
this
cleanly,
but
but
it
still
is
very
long
code
and
we
just
have
the
function
point
at
the
start,
and
I
know
a
little
bit
of
a
cache
mechanism.
This
is
just
simply
cache.
I
I
won't
really
go
into
detail
how
this
works
yeah
and
that's
really
all
that
that
circuit
does.
C
A
Really,
okay,
one
one
thing
and-
and
you
you
might
remember,
that
was
also
my
initial
question.
My
very
first
question
when
I
saw
what
you're
doing
there
and
we
also
have
it
in
chat,
of
course-
and
the
question
is:
how
on
earth
did
you
start
learning
all
this?
You
know
like,
like
particularly
this
delegate,
pointer,
unmanaged,
etc
like
like
how
on.
C
C
It's
I'm
honestly,
not
very
sure
it's
mostly
looking
at
discussions
of,
for
example,
the
runtime
team.
They
they
just
made
this,
for
example,
this
this
function,
finder
feature
they
just
made
this.
So
this
is
a
c7
feature,
and
I
kind
of
only
know
about
it,
because
I
kept
track
of
some
of
the
language
discussions.
A
C
A
C
C
C
B
C
C
This
is
really
kind
of
standard
code.
You
will
often
see
something
like
this
when
you
work
with
other
bindings
libraries
and
it'll.
Look
something
like
this
you'll
need
the
unsafe
keyword,
because
we
use
a
pointer
and
you'll
kind
of
need
to
pass
the
pointer
manually
here-
and
this
is
this-
is
really
if
you've
ever
worked
with
bindings
or
maybe
even
with
pimvo
p
invoke,
has
some
of
these
features,
but
but
not
all
of
them.
You
will
have
written
code,
something
like
this
and
using.
C
C
C
C
A
Want
to
make
sure
that's,
maybe
something
I
want
to
climb
in
very
quickly.
So
I
have
to
say,
and
and
like
I
said
initially,
this
was
is
more
or
less
part
of
of
what
we
are
trying
to
achieve
with
projects
trying
to
support
them,
implementing
plugins,
for
instance,
and
analyzers,
and
I
have
to
say
from
my
personal
experience
with
that
was
really
cool
to
the
first
time:
writing
an
analyzer
or
inspection
with
unsafe
codes.
So
it
was
surprisingly
easy.
A
But
I
think
it's
a
good
start-
and
I
was
really
surprised
because
I
just
pushed
this
yesterday
for
you
to
test-
and
you
just
picked
it
up
like
like
that
and
and
made
some
changes
already,
and
I
was
like
really
impressed
so
before
you
only
had
experience
with
the
wrestling
api
right
but
coming
to
yeah
to
resharper
sdk.
How
was
that
initial
experience
for
you.
C
I'm
very
good,
I
I
knew
the
rustling
api
well
from
well
slight
touch.
We
have
to
work
with
like
pointers
and
stuff
from
the
russell
api
there
all
the
time
and
the
adder
the
resharper
sdk
is
somewhat
similar.
It's
actually
quite
similar
in
terms
of
like
api
servers,
but
it's
just
a
bit
more
friendly.
C
I
could
say
so
that
was
that
was
really
nice,
especially
I
kind
of
made
some
changes,
for
example
in
in
the
version
you
posted
instead
of
passing
the
array
directly
you
I
believe
you
used
another
overload,
which
was
something
like
this,
and
this
isn't
working
because
my
demo
doesn't
have
this
overload,
but
just
to
quickly
show
that
and
really
I
was
super
surprised.
This
is
a
pretty
big
change
for,
for
example,
if
I
was
to
do
something
like
this
in
circus.
C
A
And
I
guess,
if
you,
if
you
know
one
of
these
two-
and
I
can
tell
this
from
my
own
experience,
so
I'm
mainly
in
the
resharper
sdk
picking
up
roster-
was
pretty
easy
and
vice
versa,
or
obviously
the
same
so
since
they're,
both
built
on
all
this
syntax,
traversal,
etc.
I
think
everyone
will
know
how
to
handle
things.
C
C
So
we
have
these,
we
have
these
opengl
tutorials,
I'm
not
an
opengl
expert,
but
that's
probably
kind
of
the
point
here,
because
this
is
another
feature
we
kind
of
this
was,
I
think,
the
very
first
idea
we
kind
of
had
when
we
talked
to
matthias
about
making
a
plugin,
because
we
knew
from
you
know
from
other
functions.
I
personally
use
this
a
lot
for
for
system.
C
You
can
just
press,
f1
and
it'll
kind
of
take
you
to
the
browser
and
show
you
the
documentation,
and
this
was
the
very
first
thing
I
think
I
brought
up
when
we
talked
about
what
we
could
do
for
sig.net
and
I
don't
really
know
any
gl.
But,
for
example,
if
I
was
to
review
this
code
now
and
wanted
to
find
out
what
this
attached.
B
C
B
C
A
A
And
I
I
will
add
something
so
because
I
also
in
every
way
I
try
to
announce
like
may-
contain
bits
of
roslyn
and
richard
sdk.
So
if
anyone
is
interested
how
this
actually
works
like
kai
and
and
dylan,
they
added
a
an
attribute
to
all
these
apis
which
basically
hold
a
reference
to
to
a
key,
and
that
key
is
then
used
in
the
inside
the
plugin
to
match
it
against
the
just
simple
dictionary,
and
then
it
will
just
open
open
that
uri
in
your
in
your
browser.
A
B
B
B
Awesome
yeah
yeah
this
is
this
is
my
generator
now
it
might
not
be
as
cool
as
some
touch
just
to
chime
in
there.
I
that's
the
first
time
I've
seen
the
f1
documentation
functionality
in
action,
so
I'm
glad
that
works
so
yeah,
that's
really
cool
to
see
that
in
action,
and
I
think
that
will
be
really
helpful
for
users
who
are
using
silp.net
because
kai,
as
you
said,
you've
got
to
go
into
the
special
specification
to
find
out
specifics.
B
But
enough
of
that,
I
think,
let's
move
on
to
my
generator,
which
is
build
tools,
so
build
tools
is,
is
responsible
for
taking
something
that
represents
a
a
c
function,
so
that
could
be
a
c
or
c
plus,
plus
header
or
or
now
the
kronos
group
are
very
kind
to
us
and
they
give
us
xml
files
to
describe
their
apis,
which
are
a
lot
more
possible
and
then
what
we
do
is
we
is
we
take
that
data.
We
create
a
project
and
data
model
from
it.
B
So
we
can,
you
know,
just
figure
out
what
functions
which
and
what
each
of
the
parameters
are,
for
example,
we'll
touch
on
this
in
a
bit,
then
we
bake
it
together,
which
again
I'll
talk
about
it.
When
we
get
to
that
stage,
we're
going
to
go
through
each
of
the
stages
in
detail
and
then
we,
we
sort
of
add
our
special
source
to
it,
so
that
in
that
case,
it's
our
overloads,
and
then
we
just
write
it
to
this.
B
So
we
can
pass
it
to
the
next
stage,
which
is
silk,
touch
and
then
obviously
the
c-sharp
compiler
so
yeah.
Moving
on
this
is
what
so,
we're
going
to
focus
only
on
xml
on
this,
because,
frankly,
it's
easier
and
it's
easier
to
describe
how
it's
passed.
So
this
is
an
example
of
the
sort
of
thing
we
get
from
grownus
in
their
xml
documents.
B
B
B
But
the
thing
is
what
this
does
is
it?
It
reads:
every
single,
every
version
of
opengl
has
its
own
feature
block
and
it
treats
a
feature
block
as
an
individual
profile
which
isn't
really
ideal.
Considering
we
don't
want
to
ship
a
million
packages
for
the
different
versions
of
opengl,
because
well,
we've
got
a
lot
of
packages
as
it
is,
and
I
don't
think
that
would
do
anything
to
help
the
situation
so
for
the
next
step.
B
So
yeah
the
problem
with
this
stage
is:
we
need
to
check
that
there
are
no
duplicate
functions
in
each
of
the
profiles
or
duplicate
enums.
If
there
are,
we
need
to
figure
out
what
to
do
with
it.
Like
all
of
these,
the
same
name,
do
they
have
a
different
value?
Do
we
need
to
cry
because
that
happens?
If
there's
discrepancies
between
different
versions,
we
don't
know
what
to
do
with
it.
So
this
stage
has
a
lot
of
checking.
B
For
that,
then
we
need
to
filter
out
any
functions
or
are
deprecated
or
we
just
don't
care
about,
because
we
we
don't
like
supporting
the
obsolete
functions.
We
do
have
a
separate
project
for
it,
which
does
have
them
in
which
we
configure
build
tools
not
to
filter
those
out,
but
for
the
mainline
project
we
don't
want
to
be
supporting
those
old
functions,
and
thus
we
filter
them
out.
B
So
we
understand
that
sometimes
you
want
to
use
a
pointer.
Sometimes
you
want
to
use
span.
Sometimes
you
want
to
use
a
ref,
that's
fine,
we'll!
We
will
recursively
generate
all
the
confidence
combinations
which
could
possibly
be
useful
to
you,
but
because
of
that
is
very
time
consuming.
So
we
take
this
penalty
when
we're
regenerating
the
bindings
every
month
say
benefit
the
bindings
with
lots
of
combinations
of
overloads,
so
hopefully,
whatever
you
throw
at
it
as
long
as
as
long
as
it's
valid.
B
B
I
don't
put
a
lot
of
description
here,
but
you
can
kind
of
see
how
we've
started
with
this
xml
document,
which
is
very
c
like
and
has
a
lot
of
metadata
and
what
we've
done
is
we
generated
our
partial
methods
which
you
may
have
saw
from
kai's,
silktouch
section,
which
are
which
are
ready
to
be
written
to
the
disc
and
then
be
read
by
silk,
touch
and
passed
along
to
the
wrestling
compiler
which
yeah
that's
the
that's
the
cherry
on
top.
That's
all
finished
now.
B
B
A
B
I'm
not
gonna
go
over
the
benefits
of
net
six,
because
there
are
lots
of
other
resources
of
that.
But
the
more
the
most
valuable
thing
is
writing
once
and
running
your
code
everywhere.
It
makes
it
makes
up
that
a
lot
more
portable,
which
is
one
of
the
goals
of
our
high
level
utilities,
as
I
mentioned,
and
it's
just
a
lot
more
fluid.
A
B
A
B
We
need
to
bring
up
our
documentation
attacks.
This
plugin
helps
with
that,
in
that
you
can
just
press
a
key
and
jump
to
the
documentation.
We
get
from
our
various
vendors
of
the
libraries,
but
also
we
want
to
align
our
documentation
and
resources
with
with
some
fabled
opengl
resources
or
some
vulcan
tutorials.
B
So
working
in
cgr
context,
that's
a
lot
better
and
we
think
it
will
be
a
lot
more
helpful.
But
also
one
of
the
things
we
want
is
project
templates.
So
you
can
just
do
net
new
opengl
and
there
you
have
it,
have
the
bare
bones
of
an
opengl
project.
Obviously,
it
does
only
benefit
you
at
the
start
of
your
project,
but
it
makes
it
a
hell
of
a
lot
easier,
not
having
to
go
out
your
way
to
install
the
right
packages
and
whatnot.
B
It's
all
just
there,
for
you
ready
to
start
hacking
at
and
there's
a
lot
of
other
stretch
goals
as
well.
That
I
just
this
was
just
mostly
me.
Spitballing
is
that
we
want
support
web
assembly,
which
I
know
kai,
is
currently
investigating
and
being
driven
a
bit
mad
by
with
webassembly
and
blazer
and
then
maybe
in
the
future.
We
also
want
to
support
a
couple
of
consoles
as
well
like
xbox,
and
wherever
else
you
play
your
favorite
games.
B
A
B
B
C
C
A
B
B
It's
not
integrated
into
the
compiler
like
subtouches,
probably
for
the
best,
but
yeah
it's
because
we
only
run
that
once
a
month,
whereas
still
touch,
we
run
that
every
compile
to
make
sure
that
nothing's
changed,
because
we
also
have
manually
written
findings
as
well
as
ones
generated
by
build
tools,
so
that
that
takes
five
minutes,
but
there's
a
lot
that
goes
on
in
that
five
minutes
that
just
wouldn't
work
well
in
the
compiler
context.
Sorry.
A
To
get
you
off
there,
okay,
cool
thanks
and
yes,
there
was
another
question
and
it
was
so
could
this
and-
and
this
was
referring
to
code
generation
from
xml's
specifications
work
as
a
source,
generator
and
rosten
just
drop
my
file
and
generate
on
the
fly.
So
that
was,
I
think,
around
the
lines
that
you
just
said
right.
B
Well-
theoretically,
yes,
but
the
the
thing
with
build
tools
is
it's
a
current
look
currently
very
specific
to
our
needs,
so
we
do
want
to
change
that
and
make
it
more
generalized,
so
anyone
can
make
their
salt.net
style
bindings
and
you
use
any
libraries,
not
just
the
one
we
provide
in
c
sharp
and
yeah.
It
could
work
in
a
source
generator
concept,
but
given
how
much
behind
happens
behind
the
scenes,
I'm
not
sure
it
would
be
the
best
idea,
and
it's
not.
B
B
C
B
C
Just
chime
in
there
on
source
generators,
one
of
the
big
problems
for
us
and
for
I
think
many
search
generator
users
is
that
this.
This
is
kind
of
the
initial
version
of
source
generators.
The
the
wrestling
team
is
built,
and
I've
talked
lots
to
like
people
at
the
russian
team
about
this,
and
one
of
the
problems
is
that
it's
not
quite
clear.
A
A
B
Yeah
so
yeah
pretty
much
is
we've.
We've
made
some
binding
recently
that
have
nothing
to
do
with
open.
Well,
I
say
nothing.
It's
still
tangentially
related,
because
it's
still
silver
on
that,
but
we've
we've
generated
bindings
that
are
completely
separate
from
opengl
that
are
just
provided
as
c
headers
and
yeah.
We
were
able
to
throw
them
at
build
tools
and
output
bindings.
I
think
the
open
asset
and
porter
was
a
best
example
of
that
or
asimp
as
they
like
to
call
themselves
is
yeah.
A
C
So
not
not
really
so
we're
specifically
not
looking
at
really
making
something
like
a
game
engine
or
anything
like
that.
We
are,
of
course,
looking
at
improving
our
input
and
our
windowing
code,
but
we
really
try
to
stay
with
bindings.
One
thing
we
do
look
at
for
kind
of
the
next
major
version
is
providing
controls
for
like
for
like
popular
ui
frameworks.
C
This
is
very
much
just
in
the
talk,
so
I
can't
really
guarantee
this
is
going
to
happen,
but,
for
example,
you
could
just
have
like
a
vpf
control
or
another
linear
control,
and
you
can
just
write
gl
or
vulcan
code,
maybe
even
in
there,
and
it
will
just
display
that
so
so
that's
but
that's
probably
kind
of
the
highest.
We
want
to
go.
A
A
Let
me
just
quickly
remove
kai's
screen
for
a
moment.
I've
I
have
to
tell
you
I
that
was
really
really
interesting.
I
hope
everyone
who
who
attended
this
webinar
thinks
the
same.
Actually,
I'm
sure
this
was
this
was
cool
to
see
source
generators
being
used
to
such
an
extent
with
those
seven
million
lines
or
what
the
number
was.
I
don't.
B
B
Exactly
well
yeah,
it's
like
5.5
million
dollar
source
generator
generates
the
the
rosalind
developers
hate
us.
We
they.
They
do
not
condone
this
sort
of
use
of
source
generators,
and
we
are
looking
at
well
we're
they're,
looking
at
improving
as
well
as
us.
So
yeah,
it's
it's
a
lot.
It's
a
it's
a
massive
extent
you're
right.
A
Let's
see
there,
there
are
still
some
questions
popping
in
so
for
one.
I
I
think
I
might
have
said
that
on
on
the
different
channel,
is
the
silk
rider
plug-in
or
available
already?
Not
yet
I
guess
we
will
still
take
some
time
together
working
on
it.
I
will
also
invite
both
of
you
to
our
plug-in
writer's
channel
at
jetbrains,
and
in
any
case,
if
someone
is
interested
and
you
plan
to
write
your
own
plugin.
A
Just
let
me
know
you
can
work
this
out,
so
I
guess
that
will
still
take
a
while
to
finish,
but
it's
I
think
it's
in
a
good
early
stage.
There
are
a
couple
of
things
that
for
the
initial
draft
we
just
assume
like,
for
instance,
currently
it
only
works
with
the
opengl
bindings,
which
is
basically
just
to
check
which
nuget
package
you
have
referenced
so
to
also
make
it
work
with
wilkin.
B
A
B
Ooh
interesting
one,
so
we've
actually
got
we've
got
x,
audio
in
as
well,
which
is
somewhat
lesser
known,
but
it's
directx's
equivalent
of
open
al.
I
think
it's
a
bit
more
low
level
as
well,
but
we're
also
looking
at
some
stuff
like
pulse
audio
2
and,
like
maybe
f
mod,
which
I
know
is
popular
with
a
lot
of
game
engine
developers
and
a
lot
of
game
developers.
B
So
it's
it's
a
case
of
we're
looking
at
it
and
if
you're
interested
in
that
sort
of
thing,
let
us
know
so
we
can
take
that
into
consideration,
because
really
this
upcoming
major
release
is
our
best
opportunity
to
add
lots
of
features
like
that,
and
if
this
is
something
you're
interested
in
just
let
us
know,
we've
got
a
discord
server
which
we
link
to
in
our
projects.
Read
me
and
yeah
come
talk
to
us
and
tell
us
that
that's
the
sort
of
stuff
you're
interested
in.
A
B
Yeah,
so
there's
all
there's
always
the
the
fact
that
it's
such
a
daunting
code
base.
I
mean
it's
very
hard
to
to
sort
of
throw
yourself
into
it
and
know
your
way
around,
but
at
the
same
time
that's
why
we
have
channels
in
the
discord
server.
It's
so
that
you
can
talk
to
us
and
say:
hey
I'm
trying
to
do
this,
but
I
don't
know
what
this
does.
B
Is
that
we're
we're
right
on
hand
most
of
the
time
unless
we're
sleeping
to
answer
any
question
you
have
to
about
the
code
base
or
heck
even
using
salt.net,
not
even
necessarily
contributing,
and
we
always
welcome
new
contributors,
so
everything's
open
on
github
and
we're
we're
in
our
discord
server
for
an
embarrassing
amount
of
time.
So
come
drop
us
a
line
if
you're
interested
and
yeah
we
can.
C
Yeah
one
one
thing
I
wanted
to
quickly
say
is
we're
currently
starting
we're
in
the
process
of
starting
3.0
development,
which
is
the
next
breaking
release,
which
will
probably
come
out
like
later
this
year,
or
maybe
at
the
start
of
next
year.
So
and-
and
so,
if
you
want
to
help
any
help
out
or
even
have
some
ideas
that
that
you
want
to
tell
us
about,
please
do
so.
We
can
kind
of
fit
them
in
right
now
or
like
in
the
next
bit
of
time.
C
A
A
So
if
you
need
more
information
here,
a
couple
of
links
that
you
can
follow
like
following
us
with
with
ryder
on
twitter,
also,
our
recordings
will
be
available
at
jetbrains
tv,
but
also
for
dotnet
foundation.
I
think
I
should
update
that
for
from
here
on
moving
forward
there.
They
should
be
available
there
as
well.
We
also
have
a
blog,
including
all
my
teammates.
A
This
is
what
this
formant
is
about,
and
maybe
through
through
money,
what
you
can
spend
or
contributions
like
I
said
so
I
I
think
everything
here
will
be
highly
appreciated
and
also
not
just
silk.net,
of
course,
but
all
the
projects
that
you
know
and
you
depend
on
and
with
that
said
just
again
thanks
for
joining.
Thank
you.
A
Youtube
was
a
real
pleasure
to
have
you
here
and
for
everyone
watching
if
you
like
this
format
like
and
subscribe,
both
dotnet
foundation
and
jetbrainstv,
if
you're
up
for
it
and
yeah
thanks
again
and
see
you,
hopefully
I
I
can
say
already
next
time.
Next
time
we
will
have
specflow
here
with
with
yeah
one
of
their
maintainers
and
community
managers.