Brainfuck is a minimal esoteric programming language. It provides a 30K 8-bit array that can be modified with 8 different characters. 

#programming #compsci #100SecondsOfCode

🔗 Resources

Brainfuck History https://www.muppetlabs.com/~breadbox/bf/
Brainfuck Basics https://gist.github.com/roachhd/dce54bec8ba55fb17d3a
Brainfuck Interpreter https://copy.sh/brainfuck/

🔥 Get More Content - Upgrade to PRO

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font

🔖 Topics Covered

- Esolang or esoteric programming languages
- What is brainfuck used for? 
- How to loop in brainfuck?
- How does brainfuck programming work?
- Who invented brainfuck?
2024-02-04T13:51:35.177Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
74f1b87a-913e-414b-ad43-c011e8568f0a
bfc10a3f6a0149b2e2fffe8ac2545d435141f45e03bc209a08030e05f3c46035
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Brainf*ck, a minimal esoteric programming language designed to make your brain hurt.
It's Turing complete, but not designed to build actual software.
It's more like a work of art that challenges the status quo.
It was created in 1993 by Swiss physics student Urban Mueller, where the goal was to create a language with the smallest possible compiler.
It was built for the Amiga 2 point o operating system, and the compiler weighs in at under 200 bytes.
A brainf program starts with a 30,000 byte, 1 dimensional array.
All values are initialized to 0, then it provides a movable pointer that you can manipulate with 8 different commands.
Use angle brackets to move the pointer left or right by one cell at a time, then increment or decrement the value in a cell using plus or minus.
Use a period to output the byte at the pointer's current location more use a comma to accept input and store it at the pointer's current location.
And finally, use opening and closing brackets to create a loop.
Notice how brain doesn't require silly things like variables, functions, and classes.
To get started with brain fuck, delete your operating system and install Amiga OS, than create a file ending in dot b f, which stands for brain fuck.
Any characters that are not the 8 I mentioned previously will be ignored as a comment.
At this point, we you have an array with 30000 8 bit numbers all set to 0.
To say, hi, mom, we'll need to set each number to its corresponding ASCII character.
Vector.
We can increment the 1st cell, then enter a loop with an opening bracket.
For each iteration of the loop, we'll decrement that current cell by 5, then use an angle bracket to move one cell to the right.
We'll increment that cell by 3, then move back to the left and close the loop.
The loop will continue until the original cell goes back to 0, at which point it will exit.
We now have a value of 103 at index 1.
We can move the pointer to it, increment it to 104, then use a period to output it.
That corresponds to the letter h in ASCII.
We can increment it again to get 105, which corresponds to the letter I.
Now, we continue this process of manipulating memory like cavemen until we output all the characters that we need.
Now to run your code, use right click copy and paste it into one of the many online interpreters.
Congratulations.
You just said hi to your mom and brain fuck.
This has been brain fuck in 100 seconds.
If you wanna see more brain fuck content on this channel, make sure to hit the like button and subscribe.
Thanks for watching and I will see you in the next one.

Speaker 0: Brainf*ck, a minimal esoteric programming language designed to make your brain hurt. It's Turing complete, but not designed to build actual software. It's more like a work of art that challenges the status quo. It was created in 1993 by Swiss physics student Urban Mueller, where the goal was to create a language with the smallest possible compiler. It was built for the Amiga 2 point o operating system, and the compiler weighs in at under 200 bytes.

A brainf program starts with a 30,000 byte, 1 dimensional array. All values are initialized to 0, then it provides a movable pointer that you can manipulate with 8 different commands. Use angle brackets to move the pointer left or right by one cell at a time, then increment or decrement the value in a cell using plus or minus. Use a period to output the byte at the pointer's current location more use a comma to accept input and store it at the pointer's current location. And finally, use opening and closing brackets to create a loop.

Notice how brain doesn't require silly things like variables, functions, and classes. To get started with brain fuck, delete your operating system and install Amiga OS, than create a file ending in dot b f, which stands for brain fuck. Any characters that are not the 8 I mentioned previously will be ignored as a comment. At this point, we you have an array with 30000 8 bit numbers all set to 0. To say, hi, mom, we'll need to set each number to its corresponding ASCII character.

Vector. We can increment the 1st cell, then enter a loop with an opening bracket. For each iteration of the loop, we'll decrement that current cell by 5, then use an angle bracket to move one cell to the right. We'll increment that cell by 3, then move back to the left and close the loop. The loop will continue until the original cell goes back to 0, at which point it will exit.

We now have a value of 103 at index 1. We can move the pointer to it, increment it to 104, then use a period to output it. That corresponds to the letter h in ASCII. We can increment it again to get 105, which corresponds to the letter I. Now, we continue this process of manipulating memory like cavemen until we output all the characters that we need.

Now to run your code, use right click copy and paste it into one of the many online interpreters. Congratulations. You just said hi to your mom and brain fuck. This has been brain fuck in 100 seconds. If you wanna see more brain fuck content on this channel, make sure to hit the like button and subscribe.

Thanks for watching and I will see you in the next one.
Brainf*ck, a minimal esoteric programming language designed to make your brain hurt. It's Turing complete, but not designed to build actual software. It's more like a work of art that challenges the status quo. It was created in 1993 by Swiss physics student Urban Mueller, where the goal was to create a language with the smallest possible compiler.
computer science
It was built for the Amiga 2 point o operating system, and the compiler weighs in at under 200 bytes.
A brainf program starts with a 30,000 byte, 1 dimensional array. All values are initialized to 0, then it provides a movable pointer that you can manipulate with 8 different commands. Use angle brackets to move the pointer left or right by one cell at a time, then increment or decrement the value in a cell using plus or minus.
programming
Use a period to output the byte at the pointer's current location more use a comma to accept input and store it at the pointer's current location. And finally, use opening and closing brackets to create a loop. Notice how brain doesn't require silly things like variables, functions, and classes. To get started with brain fuck, delete your operating system and install Amiga OS, than create a file ending in dot b f, which stands for brain fuck. Any characters that are not the 8 I mentioned previously will be ignored as a comment. At this point, we you have an array with 30000 8 bit numbers all set to 0. To say, hi, mom, we'll need to set each number to its corresponding ASCII character. Vector. We can increment the 1st cell, then enter a loop with an opening bracket. For each iteration of the loop, we'll decrement that current cell by 5, then use an angle bracket to move one cell to the right. We'll increment that cell by 3, then move back to the left and close the loop. The loop will continue until the original cell goes back to 0, at which point it will exit. We now have a value of 103 at index 1. We can move the pointer to it, increment it to 104, then use a period to output it. That corresponds to the letter h in ASCII. We can increment it again to get 105, which corresponds to the letter I. Now, we continue this process of manipulating memory like cavemen until we output all the characters that we need. Now to run your code, use right click copy and paste it into one of the many online interpreters. Congratulations. You just said hi to your mom and brain fuck.
This has been brain fuck in 100 seconds. If you wanna see more brain fuck content on this channel, make sure to hit the like button and subscribe. Thanks for watching and I will see you in the next one.
television
social media
Brainf*ck, a minimal esoteric programming language designed to make your brain hurt. It's Turing complete, but not designed to build actual software. It's more like a work of art that challenges the status quo. It was created in 1993 by Swiss physics student Urban Mueller, where the goal was to create a language with the smallest possible compiler. It was built for the Amiga 2 point o operating system, and the compiler weighs in at under 200 bytes. A brainf program starts with a 30,000 byte, 1 dimensional array. All values are initialized to 0, then it provides a movable pointer that you can manipulate with 8 different commands. Use angle brackets to move the pointer left or right by one cell at a time, then increment or decrement the value in a cell using plus or minus. Use a period to output the byte at the pointer's current location more use a comma to accept input and store it at the pointer's current location. And finally, use opening and closing brackets to create a loop. Notice how brain doesn't require silly things like variables, functions, and classes. To get started with brain fuck, delete your operating system and install Amiga OS, than create a file ending in dot b f, which stands for brain fuck. Any characters that are not the 8 I mentioned previously will be ignored as a comment. At this point, we you have an array with 30000 8 bit numbers all set to 0. To say, hi, mom, we'll need to set each number to its corresponding ASCII character. Vector. We can increment the 1st cell, then enter a loop with an opening bracket. For each iteration of the loop, we'll decrement that current cell by 5, then use an angle bracket to move one cell to the right. We'll increment that cell by 3, then move back to the left and close the loop. The loop will continue until the original cell goes back to 0, at which point it will exit. We now have a value of 103 at index 1. We can move the pointer to it, increment it to 104, then use a period to output it. That corresponds to the letter h in ASCII. We can increment it again to get 105, which corresponds to the letter I. Now, we continue this process of manipulating memory like cavemen until we output all the characters that we need. Now to run your code, use right click copy and paste it into one of the many online interpreters. Congratulations. You just said hi to your mom and brain fuck. This has been brain fuck in 100 seconds. If you wanna see more brain fuck content on this channel, make sure to hit the like button and subscribe. Thanks for watching and I will see you in the next one.
Brainf*ck,
brainf*ck
a
a
minimal
minimal
esoteric
esoteric
programming
programming
language
language
designed
designed
to
to
make
make
your
your
brain
brain
hurt.
hurt
It's
it's
Turing
turing
complete,
complete
but
but
not
not
designed
designed
to
to
build
build
actual
actual
software.
software
It's
it's
more
more
like
like
a
a
work
work
of
of
art
art
that
that
challenges
challenges
the
the
status
status
quo.
quo
It
it
was
was
created
created
in
in
1993
1993
by
by
Swiss
swiss
physics
physics
student
student
Urban
urban
Mueller,
mueller
where
where
the
the
goal
goal
was
was
to
to
create
create
a
a
language
language
with
with
the
the
smallest
smallest
possible
possible
compiler.
compiler
It
it
was
was
built
built
for
for
the
the
Amiga
amiga
2
2
point
point
o
o
operating
operating
system,
system
and
and
the
the
compiler
compiler
weighs
weighs
in
in
at
at
under
under
200
200
bytes.
bytes
A
a
brainf
brainf
program
program
starts
starts
with
with
a
a
30,000
30,000
byte,
byte
1
1
dimensional
dimensional
array.
array
All
all
values
values
are
are
initialized
initialized
to
to
0,
0
then
then
it
it
provides
provides
a
a
movable
movable
pointer
pointer
that
that
you
you
can
can
manipulate
manipulate
with
with
8
8
different
different
commands.
commands
Use
use
angle
angle
brackets
brackets
to
to
move
move
the
the
pointer
pointer
left
left
or
or
right
right
by
by
one
one
cell
cell
at
at
a
a
time,
time
then
then
increment
increment
or
or
decrement
decrement
the
the
value
value
in
in
a
a
cell
cell
using
using
plus
plus
or
or
minus.
minus
Use
use
a
a
period
period
to
to
output
output
the
the
byte
byte
at
at
the
the
pointer's
pointer's
current
current
location
location
more
more
use
use
a
a
comma
comma
to
to
accept
accept
input
input
and
and
store
store
it
it
at
at
the
the
pointer's
pointer's
current
current
location.
location
And
and
finally,
finally
use
use
opening
opening
and
and
closing
closing
brackets
brackets
to
to
create
create
a
a
loop.
loop
Notice
notice
how
how
brain
brain
doesn't
doesn't
require
require
silly
silly
things
things
like
like
variables,
variables
functions,
functions
and
and
classes.
classes
To
to
get
get
started
started
with
with
brain
brain
fuck,
fuck
delete
delete
your
your
operating
operating
system
system
and
and
install
install
Amiga
amiga
OS,
os
than
than
create
create
a
a
file
file
ending
ending
in
in
dot
dot
b
b
f,
f
which
which
stands
stands
for
for
brain
brain
fuck.
fuck
Any
any
characters
characters
that
that
are
are
not
not
the
the
8
8
I
i
mentioned
mentioned
previously
previously
will
will
be
be
ignored
ignored
as
as
a
a
comment.
comment
At
at
this
this
point,
point
we
we
you
you
have
have
an
an
array
array
with
with
30000
30000
8
8
bit
bit
numbers
numbers
all
all
set
set
to
to
0.
0
To
to
say,
say
hi,
hi
mom,
mom
we'll
we'll
need
need
to
to
set
set
each
each
number
number
to
to
its
its
corresponding
corresponding
ASCII
ascii
character.
character
Vector.
vector
We
we
can
can
increment
increment
the
the
1st
1st
cell,
cell
then
then
enter
enter
a
a
loop
loop
with
with
an
an
opening
opening
bracket.
bracket
For
for
each
each
iteration
iteration
of
of
the
the
loop,
loop
we'll
we'll
decrement
decrement
that
that
current
current
cell
cell
by
by
5,
5
then
then
use
use
an
an
angle
angle
bracket
bracket
to
to
move
move
one
one
cell
cell
to
to
the
the
right.
right
We'll
we'll
increment
increment
that
that
cell
cell
by
by
3,
3
then
then
move
move
back
back
to
to
the
the
left
left
and
and
close
close
the
the
loop.
loop
The
the
loop
loop
will
will
continue
continue
until
until
the
the
original
original
cell
cell
goes
goes
back
back
to
to
0,
0
at
at
which
which
point
point
it
it
will
will
exit.
exit
We
we
now
now
have
have
a
a
value
value
of
of
103
103
at
at
index
index
1.
1
We
we
can
can
move
move
the
the
pointer
pointer
to
to
it,
it
increment
increment
it
it
to
to
104,
104
then
then
use
use
a
a
period
period
to
to
output
output
it.
it
That
that
corresponds
corresponds
to
to
the
the
letter
letter
h
h
in
in
ASCII.
ascii
We
we
can
can
increment
increment
it
it
again
again
to
to
get
get
105,
105
which
which
corresponds
corresponds
to
to
the
the
letter
letter
I.
i
Now,
now
we
we
continue
continue
this
this
process
process
of
of
manipulating
manipulating
memory
memory
like
like
cavemen
cavemen
until
until
we
we
output
output
all
all
the
the
characters
characters
that
that
we
we
need.
need
Now
now
to
to
run
run
your
your
code,
code
use
use
right
right
click
click
copy
copy
and
and
paste
paste
it
it
into
into
one
one
of
of
the
the
many
many
online
online
interpreters.
interpreters
Congratulations.
congratulations
You
you
just
just
said
said
hi
hi
to
to
your
your
mom
mom
and
and
brain
brain
fuck.
fuck
This
this
has
has
been
been
brain
brain
fuck
fuck
in
in
100
100
seconds.
seconds
If
if
you
you
wanna
wanna
see
see
more
more
brain
brain
fuck
fuck
content
content
on
on
this
this
channel,
channel
make
make
sure
sure
to
to
hit
hit
the
the
like
like
button
button
and
and
subscribe.
subscribe
Thanks
thanks
for
for
watching
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
The speaker explains the concept of brainf Pack and how it works in a minimal programming language designed for small machines. They explain how to use the program to manipulate the brain and how to run code using specific characters. The speaker also provides tips on how to access more brain-f terms and encourages viewers to subscribe to their channel for more brain-f terms content.
Brainf**k in 100 Seconds
Brainf*ck, a minimal esoteric programming language designed to make your brain hurt. It's Turing complete, but not designed to build actual software. It's more like a work of art that challenges the status quo. It was created in 1993 by Swiss physics student Urban Mueller, where the goal was to create a language with the smallest possible compiler. It was built for the Amiga 2 point o operating system, and the compiler weighs in at under 200 bytes. A brainf program starts with a 30,000 byte, 1 dimensional array. All values are initialized to 0, then it provides a movable pointer that you can manipulate with 8 different commands. Use angle brackets to move the pointer left or right by one cell at a time, then increment or decrement the value in a cell using plus or minus. Use a period to output the byte at the pointer's current location more use a comma to accept input and store it at the pointer's current location. And finally, use opening and closing brackets to create a loop. Notice how brain doesn't require silly things like variables, functions, and classes. To get started with brain fuck, delete your operating system and install Amiga OS, than create a file ending in dot b f, which stands for brain fuck. Any characters that are not the 8 I mentioned previously will be ignored as a comment. At this point, we you have an array with 30000 8 bit numbers all set to 0. To say, hi, mom, we'll need to set each number to its corresponding ASCII character. Vector. We can increment the 1st cell, then enter a loop with an opening bracket. For each iteration of the loop, we'll decrement that current cell by 5, then use an angle bracket to move one cell to the right. We'll increment that cell by 3, then move back to the left and close the loop. The loop will continue until the original cell goes back to 0, at which point it will exit. We now have a value of 103 at index 1. We can move the pointer to it, increment it to 104, then use a period to output it. That corresponds to the letter h in ASCII. We can increment it again to get 105, which corresponds to the letter I. Now, we continue this process of manipulating memory like cavemen until we output all the characters that we need. Now to run your code, use right click copy and paste it into one of the many online interpreters. Congratulations. You just said hi to your mom and brain fuck. This has been brain fuck in 100 seconds. If you wanna see more brain fuck content on this channel, make sure to hit the like button and subscribe. Thanks for watching and I will see you in the next one.
The speaker explains the concept of brainf Pack and how it works in a minimal programming language designed for small machines. They explain how to use the program to manipulate the brain and how to run code using specific characters. The speaker also provides tips on how to access more brain-f terms and encourages viewers to subscribe to their channel for more brain-f terms content.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : Brainf**k in 100 Seconds 
        and a small summary : The speaker explains the concept of brainf Pack and how it works in a minimal programming language designed for small machines. They explain how to use the program to manipulate the brain and how to run code using specific characters. The speaker also provides tips on how to access more brain-f terms and encourages viewers to subscribe to their channel for more brain-f terms content.
        [/INST]
        
        Generate the video : Brainf*ck, a minimal esoteric programming language designed to make your brain hurt. It's Turing complete, but not designed to build actual software. It's more like a work of art that challenges the status quo. It was created in 1993 by Swiss physics student Urban Mueller, where the goal was to create a language with the smallest possible compiler. It was built for the Amiga 2 point o operating system, and the compiler weighs in at under 200 bytes. A brainf program starts with a 30,000 byte, 1 dimensional array. All values are initialized to 0, then it provides a movable pointer that you can manipulate with 8 different commands. Use angle brackets to move the pointer left or right by one cell at a time, then increment or decrement the value in a cell using plus or minus. Use a period to output the byte at the pointer's current location more use a comma to accept input and store it at the pointer's current location. And finally, use opening and closing brackets to create a loop. Notice how brain doesn't require silly things like variables, functions, and classes. To get started with brain fuck, delete your operating system and install Amiga OS, than create a file ending in dot b f, which stands for brain fuck. Any characters that are not the 8 I mentioned previously will be ignored as a comment. At this point, we you have an array with 30000 8 bit numbers all set to 0. To say, hi, mom, we'll need to set each number to its corresponding ASCII character. Vector. We can increment the 1st cell, then enter a loop with an opening bracket. For each iteration of the loop, we'll decrement that current cell by 5, then use an angle bracket to move one cell to the right. We'll increment that cell by 3, then move back to the left and close the loop. The loop will continue until the original cell goes back to 0, at which point it will exit. We now have a value of 103 at index 1. We can move the pointer to it, increment it to 104, then use a period to output it. That corresponds to the letter h in ASCII. We can increment it again to get 105, which corresponds to the letter I. Now, we continue this process of manipulating memory like cavemen until we output all the characters that we need. Now to run your code, use right click copy and paste it into one of the many online interpreters. Congratulations. You just said hi to your mom and brain fuck. This has been brain fuck in 100 seconds. If you wanna see more brain fuck content on this channel, make sure to hit the like button and subscribe. Thanks for watching and I will see you in the next one.
        