►
From YouTube: A Commodore 64 Runner for GitLab? Why not!
Description
This was a fun small side project where I got a Commodore 64 emulator working inside of GitLab as a custom executor. https://gitlab.com/jyavorska/c64exec/
A
Everyone,
my
name
is
Jason.
You
are
sky
and
I
wanted
to
demo
something
kind
of
fun
today,
which
is
a
Commodore
64
executor
for
forget,
lab
and
what
it
lets
you
do
is
he's
an
emulator
to
run
anything
in
do
devops
against
a
Commodore
64,
which
is
kind
of
fun.
Let
me
share
my
screen
here
and
I'll.
Show
you
what
I've
got
working
in
a
repository
now.
This
is
it
here.
It's
a
public
project,
etiquette
lab.
If
you
want
to
check
it
out
or
watch
it
or
anything,
and
the
way
it
works
is
it's.
A
We
unpack
the
the
disk
image
which
now
contains
an
updated
file
which
I'll
show
you
how
we
do
that
in
a
second
and
then
it
saves
that
as
an
artifact
as
an
output
of
the
bill.
So
if
you
go
look
at
the
get
lab
see,
I
am
well.
We
can
see
what
it's
going
to
do
inside
of
the
emulator,
what
it
runs.
So
the
funny
thing
here
is
that
this
is
now
instead
of
a
bash
script.
A
Inside
of
the
script
section,
we've
got
some
basic
code
here,
so
it'll
print
out
some
status
of
what
it's
doing,
it'll
open
up
a
file,
an
in
file
which
is
which
is
here
in
the
repository.
So
this
is
to
prove
that
it's
actually
loading
something
from
from
the
git
repo.
It
load
that
in
prints
it
back
out
to
a
file
called
new
file
three
times,
which
is
a
simple
example,
but
just
demonstrates
the
point
it
closes
that
file,
so
it
saves
it
to
the
disk
and
then
exits
emulation.
A
This
is
actually
a
magic
code
for
the
emulator
that,
if
you
poke
to
this
address,
it
will
just
quit
the
emulator,
and
it's
the
only
way
to
do
that
and
then
it
will
use
then
back
into
the
get
web
the
it
will
grab
this
new
file
and
save
it
as
an
artifact.
So
let's
show
an
example
of
this.
The
first
thing
that
I
need
to
do
is
actually
set
this
up,
so
I
will
show
how
setting
up
a
custom
executor
works.
A
I've
already
got
you
get
that
runner
executive
all
installed
and
I've
also
already
got
the
vise
emulator
installed,
which
is
neat
which
are
both
needed.
There's
instructions
here
on
how
to
grab
this.
What
I'll
show
is
the
creation
or
the
configuration
of
the
runner
to
set
up
the
custom
executor.
So
what
we
do
is
the
runner.
A
A
A
Okay,
we
can
call
it
a
c64
exec,
the
tags
are
needed,
is
the
custom
executor,
so
what
this
did
is
put
a
file
in
here,
the
config
dongle,
which
contains
the
configuration
that
we
need
to
modify
the
instructions
again
are
down
here
with
what
you
need
to
you
update.
So,
let's
open
this
up
and
take
a
look.
A
It's
mean
see.
Our
token
is
in
here:
we've
got
a
filled
stair.
Actually,
if
I
already
put
the
run
exact
command
in
here,
so
we
don't
need
to
do
that
again
and
it
looks
like
I'm
sorry.
So
this
is
the
previous
configuration
that
we
had
I
didn't
delete
it
before
I
started.
So
let's
just
do
that,
so
we
can
show
setting
up
from
scratch.
So
the
important
things
to
set
up
here
are
the
build
stirring,
caster.
Those
are
required.
Didn't
will
be
custom
for
machines.
So
it's
important
to
include
these.
A
A
Runner,
alright
and
now
let's
go
into
our
project
and
make
a
small
change
which
should
trigger
this.
We
can
actually
just
verify
here
that
our
runner
was
added
yeah.
It
does
look
like
it's
good
and
it's
green
all
right
and
then
so,
let's
just
go
into
you,
for
example,
you
get
lucky
I
am
willing
to
add
an
additional
print
statement,
so
pretty
easy
basic.
We
get
to
your
blind
numbers.
A
That
and
then
we
should
see
the
emulator
actually
come
up
locally.
It
would
be
cool
yeah,
so
you
can
see
it's
running
now.
Emulators
up.
It's
loading
that
file
said
hello,
ready
to
input
content.
Writing
it
now
to
the
output
file
three
times
in
exiting,
and
we
can
check
the
output
now
to
see
if
we
have
our
little
artifact.
A
So
this
is
our
pipeline
that
ran
for
our
hello.
I
can't
see
that
there's
an
artifact.
So
let's
browse
that
it
is
the
new
file
and
if
we
open
this
download,
it
has
no
extension
so
and
then
we
can
see
here
that
we
did
print
three
times
fellow
c60,
for
to
the
output.
So
using
this
you
can
do
DevOps
using
Commodore,
64
emulator
of
your
choice
and
and
do
that
with
kit
lab,
which
is
kind
of
cool.
A
One
thing
you
probably
saw
is
that
it's
in
visual
mode,
so
when
the
emulator
comes
up,
it
actually
puts
to
the
street
and
everything
I
haven't
been
able
to
find
a
way
to
set
up
all
of
the
output
for
the
emulator
going
to
the
terminal,
but
that
I
believe
that's
possible.
There's
also,
you
could
swap
out
using
an
emulator
with
using
an
basic
interpreter,
that's
compatible
with
a
Commodore
64,
which
is
something
that
considered,
but
there's
actually
something
pretty
cool
about
using
a
full
emulator
anyway.