First look at Bun - a fast new JavaScript runtime like Node.js or Deno. Explore the core features of Bun.js and how they might affect fullstack web developers in the future. 

#javascript #firstlook #TheCodeReport

🔗 Resources

Bun.js Announcement https://bun.sh
Bun on Github https://github.com/Jarred-Sumner/bun
How JavaScript Works https://youtu.be/FSs_JYwnAdI

📚 Chapters

🔥 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

- What is a JavaScript runtime?
- How do JavaScript engines work?
- Why is Bun so fast?
- What is the Zig Programming language?
- Bun.js vs Node
- Bun.js vs Deno
- Native Typescript with Bun
2024-02-04T05:24:02.612Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
7aa3f0db-625f-4586-8a2a-cc829600bee3
5ef5a43d4c094ed013cce0fc16119886e49607222912aee72467462d3c935bdc
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
It is July 6, 2022, and you're watching The Code Report.
One of the most profound quotes about the ecosystem comes from an old British guy who said Out of intense complexities, intense simplicities emerge.
At the time, nobody knew what the hell he was thing about, but in 2022, it's clear he was prophesizing the rise of a new JavaScript runtime called BUN.
That's right.
You no longer need Node.
Js or Deno, so go ahead and uninstall those from your system right now.
Bun just announced its 1st beta release and makes the claim that it's significantly faster than Node or Deno.
Not just a little bit faster, but orders of magnitude faster.
It's always a good idea to be skeptical about benchmarks provided by the creator of the tool, but as you can see here, it's about 3 times faster when server rendering React, running database queries, support executing native code with foreign functions.
Impressive.
Very nice.
Mhmm.
But what I'm more excited about is what this tool can do to simplify life as a developer.
We'll get into that in just a minute, but first, I know my mom is gonna ask me what a JavaScript runtime is in the first place.
You can think of JavaScript like gasoline.
It's dangerous and bad for the environment, by itself isn't very useful.
To make JavaScript or gasoline useful, it needs to run through an engine to convert it into raw energy or machine code for a CPU.
The most popular JavaScript engine is Google's V eight, which powers Chrome, Node and Deno, and makes JavaScript execution extremely fast with just in time compilation.
Now, gasoline bind with an engine still isn't very useful.
The average person wants that engine in a car with user friendly APIs like wheels, file system access, subwoofers, web sockets, automatic transmission, and so on.
A JavaScript run time is a complete car.
All you have to do is put a little bit of JavaScript in the tank and it will take you anywhere you wanna go.
Now that we're done with that ridiculous analogy, let's talk about what spun special, a big one is obviously performance, but how does it actually go so fast?
Well, first of all, it doesn't use the v eight engine, but instead uses JavaScript core from WebKit, which is generally considered to be faster, but more difficult to work with.
In addition, it's written in a low level programming language called Zig.
This is a relatively new language that's similar to C or Rust and the creators of BUN say the lack of hidden control flow makes it much simpler to write fast software.
It's fun to go fast, but more more importantly, bun is an all in one run time.
It has a native bundler to replace tools like webpack and also has a native transpiler, so you can write TypeScript code out as a box with cool features like top level await, an idea that's already been pioneered by Deno, but BUN will also transpile your JSX files.
Also like Deno, it prioritizes web APIs like Fetch, while at the same time also supporting many node core modules, as well as node API, which will allow many NPM packages to also work in BUN.
In fact, it implements Node's module resolution algorithm, which means you can install packages from NPM into BUN and those packages install 20 times faster.
It feels like magic.
Another nice ergonomic feature is that environment variables load automatically.
It's dot like Node.
Js where you have to install dotenv into every project.
It also comes with its own test runner similar to Jest, and as you might imagine, it's fast.
Some might as we call it, blazingly fast.
Sounds awesome, but keep in mind this project is in its infancy.
There will be bugs.
If you're on Windows, you'll have to use WSL, and even attack gave me some issues, but overall, my final analysis on Bun is that this thing is busting.
No cap, for real.
This has been the code report.
Thanks for watching, and I will see you in the next one.

Speaker 0: It is July 6, 2022, and you're watching The Code Report. One of the most profound quotes about the ecosystem comes from an old British guy who said Out of intense complexities, intense simplicities emerge. At the time, nobody knew what the hell he was thing about, but in 2022, it's clear he was prophesizing the rise of a new JavaScript runtime called BUN. That's right. You no longer need Node.

Js or Deno, so go ahead and uninstall those from your system right now. Bun just announced its 1st beta release and makes the claim that it's significantly faster than Node or Deno. Not just a little bit faster, but orders of magnitude faster. It's always a good idea to be skeptical about benchmarks provided by the creator of the tool, but as you can see here, it's about 3 times faster when server rendering React, running database queries, support executing native code with foreign functions. Impressive.

Very nice. Mhmm. But what I'm more excited about is what this tool can do to simplify life as a developer. We'll get into that in just a minute, but first, I know my mom is gonna ask me what a JavaScript runtime is in the first place. You can think of JavaScript like gasoline.

It's dangerous and bad for the environment, by itself isn't very useful. To make JavaScript or gasoline useful, it needs to run through an engine to convert it into raw energy or machine code for a CPU. The most popular JavaScript engine is Google's V eight, which powers Chrome, Node and Deno, and makes JavaScript execution extremely fast with just in time compilation. Now, gasoline bind with an engine still isn't very useful. The average person wants that engine in a car with user friendly APIs like wheels, file system access, subwoofers, web sockets, automatic transmission, and so on.

A JavaScript run time is a complete car. All you have to do is put a little bit of JavaScript in the tank and it will take you anywhere you wanna go. Now that we're done with that ridiculous analogy, let's talk about what spun special, a big one is obviously performance, but how does it actually go so fast? Well, first of all, it doesn't use the v eight engine, but instead uses JavaScript core from WebKit, which is generally considered to be faster, but more difficult to work with. In addition, it's written in a low level programming language called Zig.

This is a relatively new language that's similar to C or Rust and the creators of BUN say the lack of hidden control flow makes it much simpler to write fast software. It's fun to go fast, but more more importantly, bun is an all in one run time. It has a native bundler to replace tools like webpack and also has a native transpiler, so you can write TypeScript code out as a box with cool features like top level await, an idea that's already been pioneered by Deno, but BUN will also transpile your JSX files. Also like Deno, it prioritizes web APIs like Fetch, while at the same time also supporting many node core modules, as well as node API, which will allow many NPM packages to also work in BUN. In fact, it implements Node's module resolution algorithm, which means you can install packages from NPM into BUN and those packages install 20 times faster.

It feels like magic. Another nice ergonomic feature is that environment variables load automatically. It's dot like Node. Js where you have to install dotenv into every project. It also comes with its own test runner similar to Jest, and as you might imagine, it's fast.

Some might as we call it, blazingly fast. Sounds awesome, but keep in mind this project is in its infancy. There will be bugs. If you're on Windows, you'll have to use WSL, and even attack gave me some issues, but overall, my final analysis on Bun is that this thing is busting. No cap, for real.

This has been the code report. Thanks for watching, and I will see you in the next one.
It is July 6, 2022, and you're watching The Code Report. One of the most profound quotes about the ecosystem comes from an old British guy who said Out of intense complexities, intense simplicities emerge. At the time, nobody knew what the hell he was thing about, but in 2022, it's clear he was prophesizing the rise of a new JavaScript runtime called BUN. That's right. You no longer need Node. Js or Deno, so go ahead and uninstall those from your system right now. Bun just announced its 1st beta release and makes the claim that it's significantly faster than Node or Deno. Not just a little bit faster, but orders of magnitude faster. It's always a good idea to be skeptical about benchmarks provided by the creator of the tool, but as you can see here, it's about 3 times faster when server rendering React, running database queries, support executing native code with foreign functions. Impressive. Very nice. Mhmm. But what I'm more excited about is what this tool can do to simplify life as a developer. We'll get into that in just a minute, but first, I know my mom is gonna ask me what a JavaScript runtime is in the first place.
You can think of JavaScript like gasoline. It's dangerous and bad for the environment, by itself isn't very useful. To make JavaScript or gasoline useful, it needs to run through an engine to convert it into raw energy or machine code for a CPU. The most popular JavaScript engine is Google's V eight, which powers Chrome, Node and Deno, and makes JavaScript execution extremely fast with just in time compilation.
fossil fuels
Now, gasoline bind with an engine still isn't very useful. The average person wants that engine in a car with user friendly APIs like wheels, file system access, subwoofers, web sockets, automatic transmission, and so on. A JavaScript run time is a complete car. All you have to do is put a little bit of JavaScript in the tank and it will take you anywhere you wanna go.
automobiles
Now that we're done with that ridiculous analogy, let's talk about what spun special, a big one is obviously performance, but how does it actually go so fast?
Well, first of all, it doesn't use the v eight engine, but instead uses JavaScript core from WebKit, which is generally considered to be faster, but more difficult to work with. In addition, it's written in a low level programming language called Zig. This is a relatively new language that's similar to C or Rust and the creators of BUN say the lack of hidden control flow makes it much simpler to write fast software. It's fun to go fast, but more more importantly, bun is an all in one run time.
programming
software
It has a native bundler to replace tools like webpack and also has a native transpiler, so you can write TypeScript code out as a box with cool features like top level await, an idea that's already been pioneered by Deno, but BUN will also transpile your JSX files. Also like Deno, it prioritizes web APIs like Fetch, while at the same time also supporting many node core modules, as well as node API, which will allow many NPM packages to also work in BUN. In fact, it implements Node's module resolution algorithm, which means you can install packages from NPM into BUN and those packages install 20 times faster. It feels like magic. Another nice ergonomic feature is that environment variables load automatically. It's dot like Node. Js where you have to install dotenv into every project. It also comes with its own test runner similar to Jest, and as you might imagine, it's fast. Some might as we call it, blazingly fast.
Sounds awesome, but keep in mind this project is in its infancy. There will be bugs. If you're on Windows, you'll have to use WSL, and even attack gave me some issues, but overall, my final analysis on Bun is that this thing is busting. No cap, for real. This has been the code report.
bugs
Thanks for watching, and I will see you in the next one.
It is July 6, 2022, and you're watching The Code Report. One of the most profound quotes about the ecosystem comes from an old British guy who said Out of intense complexities, intense simplicities emerge. At the time, nobody knew what the hell he was thing about, but in 2022, it's clear he was prophesizing the rise of a new JavaScript runtime called BUN. That's right. You no longer need Node. Js or Deno, so go ahead and uninstall those from your system right now. Bun just announced its 1st beta release and makes the claim that it's significantly faster than Node or Deno. Not just a little bit faster, but orders of magnitude faster. It's always a good idea to be skeptical about benchmarks provided by the creator of the tool, but as you can see here, it's about 3 times faster when server rendering React, running database queries, support executing native code with foreign functions. Impressive. Very nice. Mhmm. But what I'm more excited about is what this tool can do to simplify life as a developer. We'll get into that in just a minute, but first, I know my mom is gonna ask me what a JavaScript runtime is in the first place. You can think of JavaScript like gasoline. It's dangerous and bad for the environment, by itself isn't very useful. To make JavaScript or gasoline useful, it needs to run through an engine to convert it into raw energy or machine code for a CPU. The most popular JavaScript engine is Google's V eight, which powers Chrome, Node and Deno, and makes JavaScript execution extremely fast with just in time compilation. Now, gasoline bind with an engine still isn't very useful. The average person wants that engine in a car with user friendly APIs like wheels, file system access, subwoofers, web sockets, automatic transmission, and so on. A JavaScript run time is a complete car. All you have to do is put a little bit of JavaScript in the tank and it will take you anywhere you wanna go. Now that we're done with that ridiculous analogy, let's talk about what spun special, a big one is obviously performance, but how does it actually go so fast? Well, first of all, it doesn't use the v eight engine, but instead uses JavaScript core from WebKit, which is generally considered to be faster, but more difficult to work with. In addition, it's written in a low level programming language called Zig. This is a relatively new language that's similar to C or Rust and the creators of BUN say the lack of hidden control flow makes it much simpler to write fast software. It's fun to go fast, but more more importantly, bun is an all in one run time. It has a native bundler to replace tools like webpack and also has a native transpiler, so you can write TypeScript code out as a box with cool features like top level await, an idea that's already been pioneered by Deno, but BUN will also transpile your JSX files. Also like Deno, it prioritizes web APIs like Fetch, while at the same time also supporting many node core modules, as well as node API, which will allow many NPM packages to also work in BUN. In fact, it implements Node's module resolution algorithm, which means you can install packages from NPM into BUN and those packages install 20 times faster. It feels like magic. Another nice ergonomic feature is that environment variables load automatically. It's dot like Node. Js where you have to install dotenv into every project. It also comes with its own test runner similar to Jest, and as you might imagine, it's fast. Some might as we call it, blazingly fast. Sounds awesome, but keep in mind this project is in its infancy. There will be bugs. If you're on Windows, you'll have to use WSL, and even attack gave me some issues, but overall, my final analysis on Bun is that this thing is busting. No cap, for real. This has been the code report. Thanks for watching, and I will see you in the next one.
It
it
is
is
July
july
6,
6
2022,
2022
and
and
you're
you're
watching
watching
The
the
Code
code
Report.
report
One
one
of
of
the
the
most
most
profound
profound
quotes
quotes
about
about
the
the
ecosystem
ecosystem
comes
comes
from
from
an
an
old
old
British
british
guy
guy
who
who
said
said
Out
out
of
of
intense
intense
complexities,
complexities
intense
intense
simplicities
simplicities
emerge.
emerge
At
at
the
the
time,
time
nobody
nobody
knew
knew
what
what
the
the
hell
hell
he
he
was
was
thing
thing
about,
about
but
but
in
in
2022,
2022
it's
it's
clear
clear
he
he
was
was
prophesizing
prophesizing
the
the
rise
rise
of
of
a
a
new
new
JavaScript
javascript
runtime
runtime
called
called
BUN.
bun
That's
that's
right.
right
You
you
no
no
longer
longer
need
need
Node.
node
Js
js
or
or
Deno,
deno
so
so
go
go
ahead
ahead
and
and
uninstall
uninstall
those
those
from
from
your
your
system
system
right
right
now.
now
Bun
bun
just
just
announced
announced
its
its
1st
1st
beta
beta
release
release
and
and
makes
makes
the
the
claim
claim
that
that
it's
it's
significantly
significantly
faster
faster
than
than
Node
node
or
or
Deno.
deno
Not
not
just
just
a
a
little
little
bit
bit
faster,
faster
but
but
orders
orders
of
of
magnitude
magnitude
faster.
faster
It's
it's
always
always
a
a
good
good
idea
idea
to
to
be
be
skeptical
skeptical
about
about
benchmarks
benchmarks
provided
provided
by
by
the
the
creator
creator
of
of
the
the
tool,
tool
but
but
as
as
you
you
can
can
see
see
here,
here
it's
it's
about
about
3
3
times
times
faster
faster
when
when
server
server
rendering
rendering
React,
react
running
running
database
database
queries,
queries
support
support
executing
executing
native
native
code
code
with
with
foreign
foreign
functions.
functions
Impressive.
impressive
Very
very
nice.
nice
Mhmm.
mhmm
But
but
what
what
I'm
i'm
more
more
excited
excited
about
about
is
is
what
what
this
this
tool
tool
can
can
do
do
to
to
simplify
simplify
life
life
as
as
a
a
developer.
developer
We'll
we'll
get
get
into
into
that
that
in
in
just
just
a
a
minute,
minute
but
but
first,
first
I
i
know
know
my
my
mom
mom
is
is
gonna
gonna
ask
ask
me
me
what
what
a
a
JavaScript
javascript
runtime
runtime
is
is
in
in
the
the
first
first
place.
place
You
you
can
can
think
think
of
of
JavaScript
javascript
like
like
gasoline.
gasoline
It's
it's
dangerous
dangerous
and
and
bad
bad
for
for
the
the
environment,
environment
by
by
itself
itself
isn't
isn't
very
very
useful.
useful
To
to
make
make
JavaScript
javascript
or
or
gasoline
gasoline
useful,
useful
it
it
needs
needs
to
to
run
run
through
through
an
an
engine
engine
to
to
convert
convert
it
it
into
into
raw
raw
energy
energy
or
or
machine
machine
code
code
for
for
a
a
CPU.
cpu
The
the
most
most
popular
popular
JavaScript
javascript
engine
engine
is
is
Google's
google's
V
v
eight,
eight
which
which
powers
powers
Chrome,
chrome
Node
node
and
and
Deno,
deno
and
and
makes
makes
JavaScript
javascript
execution
execution
extremely
extremely
fast
fast
with
with
just
just
in
in
time
time
compilation.
compilation
Now,
now
gasoline
gasoline
bind
bind
with
with
an
an
engine
engine
still
still
isn't
isn't
very
very
useful.
useful
The
the
average
average
person
person
wants
wants
that
that
engine
engine
in
in
a
a
car
car
with
with
user
user
friendly
friendly
APIs
apis
like
like
wheels,
wheels
file
file
system
system
access,
access
subwoofers,
subwoofers
web
web
sockets,
sockets
automatic
automatic
transmission,
transmission
and
and
so
so
on.
on
A
a
JavaScript
javascript
run
run
time
time
is
is
a
a
complete
complete
car.
car
All
all
you
you
have
have
to
to
do
do
is
is
put
put
a
a
little
little
bit
bit
of
of
JavaScript
javascript
in
in
the
the
tank
tank
and
and
it
it
will
will
take
take
you
you
anywhere
anywhere
you
you
wanna
wanna
go.
go
Now
now
that
that
we're
we're
done
done
with
with
that
that
ridiculous
ridiculous
analogy,
analogy
let's
let's
talk
talk
about
about
what
what
spun
spun
special,
special
a
a
big
big
one
one
is
is
obviously
obviously
performance,
performance
but
but
how
how
does
does
it
it
actually
actually
go
go
so
so
fast?
fast
Well,
well
first
first
of
of
all,
all
it
it
doesn't
doesn't
use
use
the
the
v
v
eight
eight
engine,
engine
but
but
instead
instead
uses
uses
JavaScript
javascript
core
core
from
from
WebKit,
webkit
which
which
is
is
generally
generally
considered
considered
to
to
be
be
faster,
faster
but
but
more
more
difficult
difficult
to
to
work
work
with.
with
In
in
addition,
addition
it's
it's
written
written
in
in
a
a
low
low
level
level
programming
programming
language
language
called
called
Zig.
zig
This
this
is
is
a
a
relatively
relatively
new
new
language
language
that's
that's
similar
similar
to
to
C
c
or
or
Rust
rust
and
and
the
the
creators
creators
of
of
BUN
bun
say
say
the
the
lack
lack
of
of
hidden
hidden
control
control
flow
flow
makes
makes
it
it
much
much
simpler
simpler
to
to
write
write
fast
fast
software.
software
It's
it's
fun
fun
to
to
go
go
fast,
fast
but
but
more
more
more
more
importantly,
importantly
bun
bun
is
is
an
an
all
all
in
in
one
one
run
run
time.
time
It
it
has
has
a
a
native
native
bundler
bundler
to
to
replace
replace
tools
tools
like
like
webpack
webpack
and
and
also
also
has
has
a
a
native
native
transpiler,
transpiler
so
so
you
you
can
can
write
write
TypeScript
typescript
code
code
out
out
as
as
a
a
box
box
with
with
cool
cool
features
features
like
like
top
top
level
level
await,
await
an
an
idea
idea
that's
that's
already
already
been
been
pioneered
pioneered
by
by
Deno,
deno
but
but
BUN
bun
will
will
also
also
transpile
transpile
your
your
JSX
jsx
files.
files
Also
also
like
like
Deno,
deno
it
it
prioritizes
prioritizes
web
web
APIs
apis
like
like
Fetch,
fetch
while
while
at
at
the
the
same
same
time
time
also
also
supporting
supporting
many
many
node
node
core
core
modules,
modules
as
as
well
well
as
as
node
node
API,
api
which
which
will
will
allow
allow
many
many
NPM
npm
packages
packages
to
to
also
also
work
work
in
in
BUN.
bun
In
in
fact,
fact
it
it
implements
implements
Node's
node's
module
module
resolution
resolution
algorithm,
algorithm
which
which
means
means
you
you
can
can
install
install
packages
packages
from
from
NPM
npm
into
into
BUN
bun
and
and
those
those
packages
packages
install
install
20
20
times
times
faster.
faster
It
it
feels
feels
like
like
magic.
magic
Another
another
nice
nice
ergonomic
ergonomic
feature
feature
is
is
that
that
environment
environment
variables
variables
load
load
automatically.
automatically
It's
it's
dot
dot
like
like
Node.
node
Js
js
where
where
you
you
have
have
to
to
install
install
dotenv
dotenv
into
into
every
every
project.
project
It
it
also
also
comes
comes
with
with
its
its
own
own
test
test
runner
runner
similar
similar
to
to
Jest,
jest
and
and
as
as
you
you
might
might
imagine,
imagine
it's
it's
fast.
fast
Some
some
might
might
as
as
we
we
call
call
it,
it
blazingly
blazingly
fast.
fast
Sounds
sounds
awesome,
awesome
but
but
keep
keep
in
in
mind
mind
this
this
project
project
is
is
in
in
its
its
infancy.
infancy
There
there
will
will
be
be
bugs.
bugs
If
if
you're
you're
on
on
Windows,
windows
you'll
you'll
have
have
to
to
use
use
WSL,
wsl
and
and
even
even
attack
attack
gave
gave
me
me
some
some
issues,
issues
but
but
overall,
overall
my
my
final
final
analysis
analysis
on
on
Bun
bun
is
is
that
that
this
this
thing
thing
is
is
busting.
busting
No
no
cap,
cap
for
for
real.
real
This
this
has
has
been
been
the
the
code
code
report.
report
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 discusses the benefits of the new JavaScript developers tool, including its speed, performance, and ease of use. They also mention its use in building fast, efficient code, and its use in low level programming language, namely Google's V8. The speaker concludes that Bun is a busting code, and notes that it is in its infancy.
JavaScript just got way faster
It is July 6, 2022, and you're watching The Code Report. One of the most profound quotes about the ecosystem comes from an old British guy who said Out of intense complexities, intense simplicities emerge. At the time, nobody knew what the hell he was thing about, but in 2022, it's clear he was prophesizing the rise of a new JavaScript runtime called BUN. That's right. You no longer need Node. Js or Deno, so go ahead and uninstall those from your system right now. Bun just announced its 1st beta release and makes the claim that it's significantly faster than Node or Deno. Not just a little bit faster, but orders of magnitude faster. It's always a good idea to be skeptical about benchmarks provided by the creator of the tool, but as you can see here, it's about 3 times faster when server rendering React, running database queries, support executing native code with foreign functions. Impressive. Very nice. Mhmm. But what I'm more excited about is what this tool can do to simplify life as a developer. We'll get into that in just a minute, but first, I know my mom is gonna ask me what a JavaScript runtime is in the first place. You can think of JavaScript like gasoline. It's dangerous and bad for the environment, by itself isn't very useful. To make JavaScript or gasoline useful, it needs to run through an engine to convert it into raw energy or machine code for a CPU. The most popular JavaScript engine is Google's V eight, which powers Chrome, Node and Deno, and makes JavaScript execution extremely fast with just in time compilation. Now, gasoline bind with an engine still isn't very useful. The average person wants that engine in a car with user friendly APIs like wheels, file system access, subwoofers, web sockets, automatic transmission, and so on. A JavaScript run time is a complete car. All you have to do is put a little bit of JavaScript in the tank and it will take you anywhere you wanna go. Now that we're done with that ridiculous analogy, let's talk about what spun special, a big one is obviously performance, but how does it actually go so fast? Well, first of all, it doesn't use the v eight engine, but instead uses JavaScript core from WebKit, which is generally considered to be faster, but more difficult to work with. In addition, it's written in a low level programming language called Zig. This is a relatively new language that's similar to C or Rust and the creators of BUN say the lack of hidden control flow makes it much simpler to write fast software. It's fun to go fast, but more more importantly, bun is an all in one run time. It has a native bundler to replace tools like webpack and also has a native transpiler, so you can write TypeScript code out as a box with cool features like top level await, an idea that's already been pioneered by Deno, but BUN will also transpile your JSX files. Also like Deno, it prioritizes web APIs like Fetch, while at the same time also supporting many node core modules, as well as node API, which will allow many NPM packages to also work in BUN. In fact, it implements Node's module resolution algorithm, which means you can install packages from NPM into BUN and those packages install 20 times faster. It feels like magic. Another nice ergonomic feature is that environment variables load automatically. It's dot like Node. Js where you have to install dotenv into every project. It also comes with its own test runner similar to Jest, and as you might imagine, it's fast. Some might as we call it, blazingly fast. Sounds awesome, but keep in mind this project is in its infancy. There will be bugs. If you're on Windows, you'll have to use WSL, and even attack gave me some issues, but overall, my final analysis on Bun is that this thing is busting. No cap, for real. This has been the code report. Thanks for watching, and I will see you in the next one.
The speaker discusses the benefits of the new JavaScript developers tool, including its speed, performance, and ease of use. They also mention its use in building fast, efficient code, and its use in low level programming language, namely Google's V8. The speaker concludes that Bun is a busting code, and notes that it is in its infancy.

        [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 : JavaScript just got way faster 
        and a small summary : The speaker discusses the benefits of the new JavaScript developers tool, including its speed, performance, and ease of use. They also mention its use in building fast, efficient code, and its use in low level programming language, namely Google's V8. The speaker concludes that Bun is a busting code, and notes that it is in its infancy.
        [/INST]
        
        Generate the video : It is July 6, 2022, and you're watching The Code Report. One of the most profound quotes about the ecosystem comes from an old British guy who said Out of intense complexities, intense simplicities emerge. At the time, nobody knew what the hell he was thing about, but in 2022, it's clear he was prophesizing the rise of a new JavaScript runtime called BUN. That's right. You no longer need Node. Js or Deno, so go ahead and uninstall those from your system right now. Bun just announced its 1st beta release and makes the claim that it's significantly faster than Node or Deno. Not just a little bit faster, but orders of magnitude faster. It's always a good idea to be skeptical about benchmarks provided by the creator of the tool, but as you can see here, it's about 3 times faster when server rendering React, running database queries, support executing native code with foreign functions. Impressive. Very nice. Mhmm. But what I'm more excited about is what this tool can do to simplify life as a developer. We'll get into that in just a minute, but first, I know my mom is gonna ask me what a JavaScript runtime is in the first place. You can think of JavaScript like gasoline. It's dangerous and bad for the environment, by itself isn't very useful. To make JavaScript or gasoline useful, it needs to run through an engine to convert it into raw energy or machine code for a CPU. The most popular JavaScript engine is Google's V eight, which powers Chrome, Node and Deno, and makes JavaScript execution extremely fast with just in time compilation. Now, gasoline bind with an engine still isn't very useful. The average person wants that engine in a car with user friendly APIs like wheels, file system access, subwoofers, web sockets, automatic transmission, and so on. A JavaScript run time is a complete car. All you have to do is put a little bit of JavaScript in the tank and it will take you anywhere you wanna go. Now that we're done with that ridiculous analogy, let's talk about what spun special, a big one is obviously performance, but how does it actually go so fast? Well, first of all, it doesn't use the v eight engine, but instead uses JavaScript core from WebKit, which is generally considered to be faster, but more difficult to work with. In addition, it's written in a low level programming language called Zig. This is a relatively new language that's similar to C or Rust and the creators of BUN say the lack of hidden control flow makes it much simpler to write fast software. It's fun to go fast, but more more importantly, bun is an all in one run time. It has a native bundler to replace tools like webpack and also has a native transpiler, so you can write TypeScript code out as a box with cool features like top level await, an idea that's already been pioneered by Deno, but BUN will also transpile your JSX files. Also like Deno, it prioritizes web APIs like Fetch, while at the same time also supporting many node core modules, as well as node API, which will allow many NPM packages to also work in BUN. In fact, it implements Node's module resolution algorithm, which means you can install packages from NPM into BUN and those packages install 20 times faster. It feels like magic. Another nice ergonomic feature is that environment variables load automatically. It's dot like Node. Js where you have to install dotenv into every project. It also comes with its own test runner similar to Jest, and as you might imagine, it's fast. Some might as we call it, blazingly fast. Sounds awesome, but keep in mind this project is in its infancy. There will be bugs. If you're on Windows, you'll have to use WSL, and even attack gave me some issues, but overall, my final analysis on Bun is that this thing is busting. No cap, for real. This has been the code report. Thanks for watching, and I will see you in the next one.
        