Astro version 1.0 just launched giving developers a way to build server-rendered websites with any JavaScript framework. It uses the islands architecture and partial hydration to deliver fast apps with frameworks like React, Vue, Svelte, and more. 

#programming #javascript #TheCodeReport

🔗 Resources

- Astro Launch Blog https://astro.build/blog/astro-1/
- Astro on GitHub https://github.com/withastro/astro
- I built a JS framework https://youtu.be/SJeBRW1QQMA
- Astro in 100 Seconds https://youtu.be/dsTXcSeAZq8

🔥 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 Astro.js?
- Is Astro a good framework?
- Pros and cons of using Astro
- How build a fast website
- Top web development frameworks
- Best JS frameworks in 2022
- JS framework drama
2024-02-04T13:33:52.089Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
24ed6715-2e9d-4345-b5c8-cd43a462b5a0
1ad0dd634441b773f017f7ebbd031ec14293cc4e0612404f12752592b25e6f9c
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
It is August 18, 2022, and you're watching the code report.
One of the most difficult decisions of a front end developer's life is choosing between end UI frameworks, because once you get jumped into a gang, it's really hard to get out.
But what if there is a way you could be a part of multiple gangs at one time without causing a bunch of complex drama.
Well, that's just one of the amazing things that Astro does, which is a tool for building multi page applications that just hit version 1.0 a few days ago.
I made a 100 second video about it a while ago, but it has some really interesting new features and deserves a second look.
At a very high level, it's kind of like a static site generator that allows you to write content and markdown using the file system for routing, then renders it all as a static multi page application.
For templating, it has its own language called Astro Components, which feel very nice and familiar to the modern front end developer.
What's really interesting though is that you can bring in your favorite front end framework like React, Svelte, Vue, and so on, and it will render the UI on the server while shipping 0 JavaScript to the browser.
JavaScript is the main bottleneck for performance, which means with Astro, you get really fast page loads while using your favorite JavaScript framework or multiple frameworks at the same time, but you might be wondering, how does the component work if it doesn't have its JavaScript with it?
The answer is it doesn't.
It's just static HTML by default.
Fault.
However, if you do need interactivity and state, you can opt into JavaScript as needed to add islands of interactivity to your website.
From a developer's perspective, Astro provides a variety directives that determine when to hydrate or load the JavaScript for a component.
If you want to load it right away like normal, you use client load.
But if you don't need the component to be interactive right Fue, you can also use idle to wait until the browser's just chilling, or visible to wait until the component comes into the viewport.
Under the hood, Astro is using a technique called partial or selective filtration to render components in place, as opposed to taking over the entire DOM.
That's a huge deal when it comes to performance.
Less JavaScript to run means faster page loads and better time to interactive scores.
That's awesome, but Astro can do many things beyond the typical static site generator.
Like Next.
Js, it can statically generate dynamic routes by allowing you to define a get static paths function.
However, if you don't want to pre render all your pages, it can also handle full server side rendering.
That means your pages will generated at request time, and it's also possible to have dedicated API routes.
But with full SSR, it needs to be deployed to a server and can run on Node.
Js or the edge using platforms like Cloudflare, Netlify, Vercel, and so on.
Now, as much as I love Astro, if you watch my recent video, the one limitation I ran into is that it's not possible out of the Fox to do client side routing.
It's different from something like Next.
Js that does full hydration, where the client side router takes over after the initial page load.
Photos.
With Astro, you get an entirely new page for each navigation.
That could be an issue if you plan on sharing data or state between route changes.
However, I discovered there is a project called Astro SPA that addresses this exact issue, although it's not yet a stable part of the framework.
I also made a meme framework to help with this, and shout out to everybody who's contributed, to make that library better.
If Astro does get the ability to work like a single page application at some point.
It would really become the ultimate framework because it would cover every single use case on this flowchart, and not only that, but you could use any UI framework you want.
At that point, it could put an end to the great JavaScript framework wars, and we could go back to building apps in peace and harmony.
When these rich companies wage JavaScript framework war, it's us poor developers who die.
Fame.
This has been the code report.
Thanks for watching, and I will see you in the next one.

Speaker 0: It is August 18, 2022, and you're watching the code report. One of the most difficult decisions of a front end developer's life is choosing between end UI frameworks, because once you get jumped into a gang, it's really hard to get out. But what if there is a way you could be a part of multiple gangs at one time without causing a bunch of complex drama. Well, that's just one of the amazing things that Astro does, which is a tool for building multi page applications that just hit version 1.0 a few days ago. I made a 100 second video about it a while ago, but it has some really interesting new features and deserves a second look.

At a very high level, it's kind of like a static site generator that allows you to write content and markdown using the file system for routing, then renders it all as a static multi page application. For templating, it has its own language called Astro Components, which feel very nice and familiar to the modern front end developer. What's really interesting though is that you can bring in your favorite front end framework like React, Svelte, Vue, and so on, and it will render the UI on the server while shipping 0 JavaScript to the browser. JavaScript is the main bottleneck for performance, which means with Astro, you get really fast page loads while using your favorite JavaScript framework or multiple frameworks at the same time, but you might be wondering, how does the component work if it doesn't have its JavaScript with it? The answer is it doesn't.

It's just static HTML by default. Fault. However, if you do need interactivity and state, you can opt into JavaScript as needed to add islands of interactivity to your website. From a developer's perspective, Astro provides a variety directives that determine when to hydrate or load the JavaScript for a component. If you want to load it right away like normal, you use client load.

But if you don't need the component to be interactive right Fue, you can also use idle to wait until the browser's just chilling, or visible to wait until the component comes into the viewport. Under the hood, Astro is using a technique called partial or selective filtration to render components in place, as opposed to taking over the entire DOM. That's a huge deal when it comes to performance. Less JavaScript to run means faster page loads and better time to interactive scores. That's awesome, but Astro can do many things beyond the typical static site generator.

Like Next. Js, it can statically generate dynamic routes by allowing you to define a get static paths function. However, if you don't want to pre render all your pages, it can also handle full server side rendering. That means your pages will generated at request time, and it's also possible to have dedicated API routes. But with full SSR, it needs to be deployed to a server and can run on Node.

Js or the edge using platforms like Cloudflare, Netlify, Vercel, and so on. Now, as much as I love Astro, if you watch my recent video, the one limitation I ran into is that it's not possible out of the Fox to do client side routing. It's different from something like Next. Js that does full hydration, where the client side router takes over after the initial page load. Photos.

With Astro, you get an entirely new page for each navigation. That could be an issue if you plan on sharing data or state between route changes. However, I discovered there is a project called Astro SPA that addresses this exact issue, although it's not yet a stable part of the framework. I also made a meme framework to help with this, and shout out to everybody who's contributed, to make that library better. If Astro does get the ability to work like a single page application at some point.

It would really become the ultimate framework because it would cover every single use case on this flowchart, and not only that, but you could use any UI framework you want. At that point, it could put an end to the great JavaScript framework wars, and we could go back to building apps in peace and harmony. When these rich companies wage JavaScript framework war, it's us poor developers who die. Fame. This has been the code report.

Thanks for watching, and I will see you in the next one.
It is August 18, 2022, and you're watching the code report. One of the most difficult decisions of a front end developer's life is choosing between end UI frameworks, because once you get jumped into a gang, it's really hard to get out.
But what if there is a way you could be a part of multiple gangs at one time without causing a bunch of complex drama. Well, that's just one of the amazing things that Astro does, which is a tool for building multi page applications that just hit version 1.0 a few days ago. I made a 100 second video about it a while ago, but it has some really interesting new features and deserves a second look. At a very high level, it's kind of like a static site generator that allows you to write content and markdown using the file system for routing, then renders it all as a static multi page application. For templating, it has its own language called Astro Components, which feel very nice and familiar to the modern front end developer. What's really interesting though is that you can bring in your favorite front end framework like React, Svelte, Vue, and so on, and it will render the UI on the server while shipping 0 JavaScript to the browser.
astronomy
astrology
youtube
multimedia
video gaming
architecture
meteorology
cosmology
streaming
games
JavaScript is the main bottleneck for performance, which means with Astro, you get really fast page loads while using your favorite JavaScript framework or multiple frameworks at the same time, but you might be wondering, how does the component work if it doesn't have its JavaScript with it?
The answer is it doesn't. It's just static HTML by default. Fault. However, if you do need interactivity and state, you can opt into JavaScript as needed to add islands of interactivity to your website. From a developer's perspective, Astro provides a variety directives that determine when to hydrate or load the JavaScript for a component. If you want to load it right away like normal, you use client load. But if you don't need the component to be interactive right Fue, you can also use idle to wait until the browser's just chilling, or visible to wait until the component comes into the viewport. Under the hood, Astro is using a technique called partial or selective filtration to render components in place, as opposed to taking over the entire DOM. That's a huge deal when it comes to performance. Less JavaScript to run means faster page loads and better time to interactive scores. That's awesome, but Astro can do many things beyond the typical static site generator.
astrology
astronomy
Like Next. Js, it can statically generate dynamic routes by allowing you to define a get static paths function. However, if you don't want to pre render all your pages, it can also handle full server side rendering.
That means your pages will generated at request time, and it's also possible to have dedicated API routes. But with full SSR, it needs to be deployed to a server and can run on Node. Js or the edge using platforms like Cloudflare, Netlify, Vercel, and so on. Now, as much as I love Astro, if you watch my recent video, the one limitation I ran into is that it's not possible out of the Fox to do client side routing. It's different from something like Next.
video gaming
networking
internet
Js that does full hydration, where the client side router takes over after the initial page load. Photos. With Astro, you get an entirely new page for each navigation.
That could be an issue if you plan on sharing data or state between route changes. However, I discovered there is a project called Astro SPA that addresses this exact issue, although it's not yet a stable part of the framework. I also made a meme framework to help with this, and shout out to everybody who's contributed, to make that library better. If Astro does get the ability to work like a single page application at some point. It would really become the ultimate framework because it would cover every single use case on this flowchart, and not only that, but you could use any UI framework you want.
astrology
At that point, it could put an end to the great JavaScript framework wars, and we could go back to building apps in peace and harmony. When these rich companies wage JavaScript framework war, it's us poor developers who die. Fame. This has been the code report. Thanks for watching, and I will see you in the next one.
It is August 18, 2022, and you're watching the code report. One of the most difficult decisions of a front end developer's life is choosing between end UI frameworks, because once you get jumped into a gang, it's really hard to get out. But what if there is a way you could be a part of multiple gangs at one time without causing a bunch of complex drama. Well, that's just one of the amazing things that Astro does, which is a tool for building multi page applications that just hit version 1.0 a few days ago. I made a 100 second video about it a while ago, but it has some really interesting new features and deserves a second look. At a very high level, it's kind of like a static site generator that allows you to write content and markdown using the file system for routing, then renders it all as a static multi page application. For templating, it has its own language called Astro Components, which feel very nice and familiar to the modern front end developer. What's really interesting though is that you can bring in your favorite front end framework like React, Svelte, Vue, and so on, and it will render the UI on the server while shipping 0 JavaScript to the browser. JavaScript is the main bottleneck for performance, which means with Astro, you get really fast page loads while using your favorite JavaScript framework or multiple frameworks at the same time, but you might be wondering, how does the component work if it doesn't have its JavaScript with it? The answer is it doesn't. It's just static HTML by default. Fault. However, if you do need interactivity and state, you can opt into JavaScript as needed to add islands of interactivity to your website. From a developer's perspective, Astro provides a variety directives that determine when to hydrate or load the JavaScript for a component. If you want to load it right away like normal, you use client load. But if you don't need the component to be interactive right Fue, you can also use idle to wait until the browser's just chilling, or visible to wait until the component comes into the viewport. Under the hood, Astro is using a technique called partial or selective filtration to render components in place, as opposed to taking over the entire DOM. That's a huge deal when it comes to performance. Less JavaScript to run means faster page loads and better time to interactive scores. That's awesome, but Astro can do many things beyond the typical static site generator. Like Next. Js, it can statically generate dynamic routes by allowing you to define a get static paths function. However, if you don't want to pre render all your pages, it can also handle full server side rendering. That means your pages will generated at request time, and it's also possible to have dedicated API routes. But with full SSR, it needs to be deployed to a server and can run on Node. Js or the edge using platforms like Cloudflare, Netlify, Vercel, and so on. Now, as much as I love Astro, if you watch my recent video, the one limitation I ran into is that it's not possible out of the Fox to do client side routing. It's different from something like Next. Js that does full hydration, where the client side router takes over after the initial page load. Photos. With Astro, you get an entirely new page for each navigation. That could be an issue if you plan on sharing data or state between route changes. However, I discovered there is a project called Astro SPA that addresses this exact issue, although it's not yet a stable part of the framework. I also made a meme framework to help with this, and shout out to everybody who's contributed, to make that library better. If Astro does get the ability to work like a single page application at some point. It would really become the ultimate framework because it would cover every single use case on this flowchart, and not only that, but you could use any UI framework you want. At that point, it could put an end to the great JavaScript framework wars, and we could go back to building apps in peace and harmony. When these rich companies wage JavaScript framework war, it's us poor developers who die. Fame. This has been the code report. Thanks for watching, and I will see you in the next one.
It
it
is
is
August
august
18,
18
2022,
2022
and
and
you're
you're
watching
watching
the
the
code
code
report.
report
One
one
of
of
the
the
most
most
difficult
difficult
decisions
decisions
of
of
a
a
front
front
end
end
developer's
developer's
life
life
is
is
choosing
choosing
between
between
end
end
UI
ui
frameworks,
frameworks
because
because
once
once
you
you
get
get
jumped
jumped
into
into
a
a
gang,
gang
it's
it's
really
really
hard
hard
to
to
get
get
out.
out
But
but
what
what
if
if
there
there
is
is
a
a
way
way
you
you
could
could
be
be
a
a
part
part
of
of
multiple
multiple
gangs
gangs
at
at
one
one
time
time
without
without
causing
causing
a
a
bunch
bunch
of
of
complex
complex
drama.
drama
Well,
well
that's
that's
just
just
one
one
of
of
the
the
amazing
amazing
things
things
that
that
Astro
astro
does,
does
which
which
is
is
a
a
tool
tool
for
for
building
building
multi
multi
page
page
applications
applications
that
that
just
just
hit
hit
version
version
1.0
1.0
a
a
few
few
days
days
ago.
ago
I
i
made
made
a
a
100
100
second
second
video
video
about
about
it
it
a
a
while
while
ago,
ago
but
but
it
it
has
has
some
some
really
really
interesting
interesting
new
new
features
features
and
and
deserves
deserves
a
a
second
second
look.
look
At
at
a
a
very
very
high
high
level,
level
it's
it's
kind
kind
of
of
like
like
a
a
static
static
site
site
generator
generator
that
that
allows
allows
you
you
to
to
write
write
content
content
and
and
markdown
markdown
using
using
the
the
file
file
system
system
for
for
routing,
routing
then
then
renders
renders
it
it
all
all
as
as
a
a
static
static
multi
multi
page
page
application.
application
For
for
templating,
templating
it
it
has
has
its
its
own
own
language
language
called
called
Astro
astro
Components,
components
which
which
feel
feel
very
very
nice
nice
and
and
familiar
familiar
to
to
the
the
modern
modern
front
front
end
end
developer.
developer
What's
what's
really
really
interesting
interesting
though
though
is
is
that
that
you
you
can
can
bring
bring
in
in
your
your
favorite
favorite
front
front
end
end
framework
framework
like
like
React,
react
Svelte,
svelte
Vue,
vue
and
and
so
so
on,
on
and
and
it
it
will
will
render
render
the
the
UI
ui
on
on
the
the
server
server
while
while
shipping
shipping
0
0
JavaScript
javascript
to
to
the
the
browser.
browser
JavaScript
javascript
is
is
the
the
main
main
bottleneck
bottleneck
for
for
performance,
performance
which
which
means
means
with
with
Astro,
astro
you
you
get
get
really
really
fast
fast
page
page
loads
loads
while
while
using
using
your
your
favorite
favorite
JavaScript
javascript
framework
framework
or
or
multiple
multiple
frameworks
frameworks
at
at
the
the
same
same
time,
time
but
but
you
you
might
might
be
be
wondering,
wondering
how
how
does
does
the
the
component
component
work
work
if
if
it
it
doesn't
doesn't
have
have
its
its
JavaScript
javascript
with
with
it?
it
The
the
answer
answer
is
is
it
it
doesn't.
doesn't
It's
it's
just
just
static
static
HTML
html
by
by
default.
default
Fault.
fault
However,
however
if
if
you
you
do
do
need
need
interactivity
interactivity
and
and
state,
state
you
you
can
can
opt
opt
into
into
JavaScript
javascript
as
as
needed
needed
to
to
add
add
islands
islands
of
of
interactivity
interactivity
to
to
your
your
website.
website
From
from
a
a
developer's
developer's
perspective,
perspective
Astro
astro
provides
provides
a
a
variety
variety
directives
directives
that
that
determine
determine
when
when
to
to
hydrate
hydrate
or
or
load
load
the
the
JavaScript
javascript
for
for
a
a
component.
component
If
if
you
you
want
want
to
to
load
load
it
it
right
right
away
away
like
like
normal,
normal
you
you
use
use
client
client
load.
load
But
but
if
if
you
you
don't
don't
need
need
the
the
component
component
to
to
be
be
interactive
interactive
right
right
Fue,
fue
you
you
can
can
also
also
use
use
idle
idle
to
to
wait
wait
until
until
the
the
browser's
browser's
just
just
chilling,
chilling
or
or
visible
visible
to
to
wait
wait
until
until
the
the
component
component
comes
comes
into
into
the
the
viewport.
viewport
Under
under
the
the
hood,
hood
Astro
astro
is
is
using
using
a
a
technique
technique
called
called
partial
partial
or
or
selective
selective
filtration
filtration
to
to
render
render
components
components
in
in
place,
place
as
as
opposed
opposed
to
to
taking
taking
over
over
the
the
entire
entire
DOM.
dom
That's
that's
a
a
huge
huge
deal
deal
when
when
it
it
comes
comes
to
to
performance.
performance
Less
less
JavaScript
javascript
to
to
run
run
means
means
faster
faster
page
page
loads
loads
and
and
better
better
time
time
to
to
interactive
interactive
scores.
scores
That's
that's
awesome,
awesome
but
but
Astro
astro
can
can
do
do
many
many
things
things
beyond
beyond
the
the
typical
typical
static
static
site
site
generator.
generator
Like
like
Next.
next
Js,
js
it
it
can
can
statically
statically
generate
generate
dynamic
dynamic
routes
routes
by
by
allowing
allowing
you
you
to
to
define
define
a
a
get
get
static
static
paths
paths
function.
function
However,
however
if
if
you
you
don't
don't
want
want
to
to
pre
pre
render
render
all
all
your
your
pages,
pages
it
it
can
can
also
also
handle
handle
full
full
server
server
side
side
rendering.
rendering
That
that
means
means
your
your
pages
pages
will
will
generated
generated
at
at
request
request
time,
time
and
and
it's
it's
also
also
possible
possible
to
to
have
have
dedicated
dedicated
API
api
routes.
routes
But
but
with
with
full
full
SSR,
ssr
it
it
needs
needs
to
to
be
be
deployed
deployed
to
to
a
a
server
server
and
and
can
can
run
run
on
on
Node.
node
Js
js
or
or
the
the
edge
edge
using
using
platforms
platforms
like
like
Cloudflare,
cloudflare
Netlify,
netlify
Vercel,
vercel
and
and
so
so
on.
on
Now,
now
as
as
much
much
as
as
I
i
love
love
Astro,
astro
if
if
you
you
watch
watch
my
my
recent
recent
video,
video
the
the
one
one
limitation
limitation
I
i
ran
ran
into
into
is
is
that
that
it's
it's
not
not
possible
possible
out
out
of
of
the
the
Fox
fox
to
to
do
do
client
client
side
side
routing.
routing
It's
it's
different
different
from
from
something
something
like
like
Next.
next
Js
js
that
that
does
does
full
full
hydration,
hydration
where
where
the
the
client
client
side
side
router
router
takes
takes
over
over
after
after
the
the
initial
initial
page
page
load.
load
Photos.
photos
With
with
Astro,
astro
you
you
get
get
an
an
entirely
entirely
new
new
page
page
for
for
each
each
navigation.
navigation
That
that
could
could
be
be
an
an
issue
issue
if
if
you
you
plan
plan
on
on
sharing
sharing
data
data
or
or
state
state
between
between
route
route
changes.
changes
However,
however
I
i
discovered
discovered
there
there
is
is
a
a
project
project
called
called
Astro
astro
SPA
spa
that
that
addresses
addresses
this
this
exact
exact
issue,
issue
although
although
it's
it's
not
not
yet
yet
a
a
stable
stable
part
part
of
of
the
the
framework.
framework
I
i
also
also
made
made
a
a
meme
meme
framework
framework
to
to
help
help
with
with
this,
this
and
and
shout
shout
out
out
to
to
everybody
everybody
who's
who's
contributed,
contributed
to
to
make
make
that
that
library
library
better.
better
If
if
Astro
astro
does
does
get
get
the
the
ability
ability
to
to
work
work
like
like
a
a
single
single
page
page
application
application
at
at
some
some
point.
point
It
it
would
would
really
really
become
become
the
the
ultimate
ultimate
framework
framework
because
because
it
it
would
would
cover
cover
every
every
single
single
use
use
case
case
on
on
this
this
flowchart,
flowchart
and
and
not
not
only
only
that,
that
but
but
you
you
could
could
use
use
any
any
UI
ui
framework
framework
you
you
want.
want
At
at
that
that
point,
point
it
it
could
could
put
put
an
an
end
end
to
to
the
the
great
great
JavaScript
javascript
framework
framework
wars,
wars
and
and
we
we
could
could
go
go
back
back
to
to
building
building
apps
apps
in
in
peace
peace
and
and
harmony.
harmony
When
when
these
these
rich
rich
companies
companies
wage
wage
JavaScript
javascript
framework
framework
war,
war
it's
it's
us
us
poor
poor
developers
developers
who
who
die.
die
Fame.
fame
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 capabilities of Astro's front end development tool, including the use of multiple frameworks and the ability to render on multiple websites. They also mention the use of partial/ selective filtration to render components and the use of fully-serving API routes to make websites more responsive. The speaker concludes by encouraging developers to use the tool and explore other front end development frameworks.
Astro just Launched.... Could it be the ultimate web framework?
It is August 18, 2022, and you're watching the code report. One of the most difficult decisions of a front end developer's life is choosing between end UI frameworks, because once you get jumped into a gang, it's really hard to get out. But what if there is a way you could be a part of multiple gangs at one time without causing a bunch of complex drama. Well, that's just one of the amazing things that Astro does, which is a tool for building multi page applications that just hit version 1.0 a few days ago. I made a 100 second video about it a while ago, but it has some really interesting new features and deserves a second look. At a very high level, it's kind of like a static site generator that allows you to write content and markdown using the file system for routing, then renders it all as a static multi page application. For templating, it has its own language called Astro Components, which feel very nice and familiar to the modern front end developer. What's really interesting though is that you can bring in your favorite front end framework like React, Svelte, Vue, and so on, and it will render the UI on the server while shipping 0 JavaScript to the browser. JavaScript is the main bottleneck for performance, which means with Astro, you get really fast page loads while using your favorite JavaScript framework or multiple frameworks at the same time, but you might be wondering, how does the component work if it doesn't have its JavaScript with it? The answer is it doesn't. It's just static HTML by default. Fault. However, if you do need interactivity and state, you can opt into JavaScript as needed to add islands of interactivity to your website. From a developer's perspective, Astro provides a variety directives that determine when to hydrate or load the JavaScript for a component. If you want to load it right away like normal, you use client load. But if you don't need the component to be interactive right Fue, you can also use idle to wait until the browser's just chilling, or visible to wait until the component comes into the viewport. Under the hood, Astro is using a technique called partial or selective filtration to render components in place, as opposed to taking over the entire DOM. That's a huge deal when it comes to performance. Less JavaScript to run means faster page loads and better time to interactive scores. That's awesome, but Astro can do many things beyond the typical static site generator. Like Next. Js, it can statically generate dynamic routes by allowing you to define a get static paths function. However, if you don't want to pre render all your pages, it can also handle full server side rendering. That means your pages will generated at request time, and it's also possible to have dedicated API routes. But with full SSR, it needs to be deployed to a server and can run on Node. Js or the edge using platforms like Cloudflare, Netlify, Vercel, and so on. Now, as much as I love Astro, if you watch my recent video, the one limitation I ran into is that it's not possible out of the Fox to do client side routing. It's different from something like Next. Js that does full hydration, where the client side router takes over after the initial page load. Photos. With Astro, you get an entirely new page for each navigation. That could be an issue if you plan on sharing data or state between route changes. However, I discovered there is a project called Astro SPA that addresses this exact issue, although it's not yet a stable part of the framework. I also made a meme framework to help with this, and shout out to everybody who's contributed, to make that library better. If Astro does get the ability to work like a single page application at some point. It would really become the ultimate framework because it would cover every single use case on this flowchart, and not only that, but you could use any UI framework you want. At that point, it could put an end to the great JavaScript framework wars, and we could go back to building apps in peace and harmony. When these rich companies wage JavaScript framework war, it's us poor developers who die. Fame. This has been the code report. Thanks for watching, and I will see you in the next one.
The speaker discusses the capabilities of Astro's front end development tool, including the use of multiple frameworks and the ability to render on multiple websites. They also mention the use of partial/ selective filtration to render components and the use of fully-serving API routes to make websites more responsive. The speaker concludes by encouraging developers to use the tool and explore other front end development frameworks.

        [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 : Astro just Launched.... Could it be the ultimate web framework? 
        and a small summary : The speaker discusses the capabilities of Astro's front end development tool, including the use of multiple frameworks and the ability to render on multiple websites. They also mention the use of partial/ selective filtration to render components and the use of fully-serving API routes to make websites more responsive. The speaker concludes by encouraging developers to use the tool and explore other front end development frameworks.
        [/INST]
        
        Generate the video : It is August 18, 2022, and you're watching the code report. One of the most difficult decisions of a front end developer's life is choosing between end UI frameworks, because once you get jumped into a gang, it's really hard to get out. But what if there is a way you could be a part of multiple gangs at one time without causing a bunch of complex drama. Well, that's just one of the amazing things that Astro does, which is a tool for building multi page applications that just hit version 1.0 a few days ago. I made a 100 second video about it a while ago, but it has some really interesting new features and deserves a second look. At a very high level, it's kind of like a static site generator that allows you to write content and markdown using the file system for routing, then renders it all as a static multi page application. For templating, it has its own language called Astro Components, which feel very nice and familiar to the modern front end developer. What's really interesting though is that you can bring in your favorite front end framework like React, Svelte, Vue, and so on, and it will render the UI on the server while shipping 0 JavaScript to the browser. JavaScript is the main bottleneck for performance, which means with Astro, you get really fast page loads while using your favorite JavaScript framework or multiple frameworks at the same time, but you might be wondering, how does the component work if it doesn't have its JavaScript with it? The answer is it doesn't. It's just static HTML by default. Fault. However, if you do need interactivity and state, you can opt into JavaScript as needed to add islands of interactivity to your website. From a developer's perspective, Astro provides a variety directives that determine when to hydrate or load the JavaScript for a component. If you want to load it right away like normal, you use client load. But if you don't need the component to be interactive right Fue, you can also use idle to wait until the browser's just chilling, or visible to wait until the component comes into the viewport. Under the hood, Astro is using a technique called partial or selective filtration to render components in place, as opposed to taking over the entire DOM. That's a huge deal when it comes to performance. Less JavaScript to run means faster page loads and better time to interactive scores. That's awesome, but Astro can do many things beyond the typical static site generator. Like Next. Js, it can statically generate dynamic routes by allowing you to define a get static paths function. However, if you don't want to pre render all your pages, it can also handle full server side rendering. That means your pages will generated at request time, and it's also possible to have dedicated API routes. But with full SSR, it needs to be deployed to a server and can run on Node. Js or the edge using platforms like Cloudflare, Netlify, Vercel, and so on. Now, as much as I love Astro, if you watch my recent video, the one limitation I ran into is that it's not possible out of the Fox to do client side routing. It's different from something like Next. Js that does full hydration, where the client side router takes over after the initial page load. Photos. With Astro, you get an entirely new page for each navigation. That could be an issue if you plan on sharing data or state between route changes. However, I discovered there is a project called Astro SPA that addresses this exact issue, although it's not yet a stable part of the framework. I also made a meme framework to help with this, and shout out to everybody who's contributed, to make that library better. If Astro does get the ability to work like a single page application at some point. It would really become the ultimate framework because it would cover every single use case on this flowchart, and not only that, but you could use any UI framework you want. At that point, it could put an end to the great JavaScript framework wars, and we could go back to building apps in peace and harmony. When these rich companies wage JavaScript framework war, it's us poor developers who die. Fame. This has been the code report. Thanks for watching, and I will see you in the next one.
        