Astro 7.0

¡Astro 7 ya está aquí! Esta versión se centra en la velocidad. El compilador ha sido reescrito en Rust. El procesamiento de Markdown y MDX ahora pasa por una nueva canalización impulsada por Rust. El motor de renderizado ha sido reemplazado con un enfoque más rápido basado en colas. Junto con Vite 8 y su nuevo bundler Rolldown, las compilaciones de Astro 7 son un 15-61% más rápidas en nuestras pruebas comparativas. La compilación más rápida es la que no ocurre en absoluto, así que Astro 7 también estabiliza el almacenamiento en caché de rutas y agrega proveedores de caché CDN experimentales para Netlify, Vercel y Cloudflare.

Astro 7 también introduce Advanced Routing, dándote un entrypoint con control total sobre el pipeline de solicitudes de Astro. Para el desarrollo asistido por IA, Astro ahora puede detectar agentes de codificación, ejecutar el servidor dev en segundo plano y generar registros JSON estructurados cuando los agentes necesiten retroalimentación legible por máquina.

Lo más destacado de esta versión completa incluye:

• Vite 8
• Rendimiento
  • Compilador Rust
  • Markdown y MDX en Rust
  • Renderizado en cola
• Enrutamiento Avanzado
• Caché de Rutas
  • Proveedores de Caché CDN
• Mejoras con IA
  • Background Dev Server
  • Registro JSON
• Comunidad

¡Mejora ahora!

Para actualizar un proyecto existente a Astro 7, usa la herramienta CLI automatizada:

# Recommended:
npx @astrojs/upgrade

# Manual:
npm install astro@latest

Para proyectos nuevos, simplemente usa:

npm create astro@latest

Consulta la guía de actualización para obtener pasos de migración detallados.

Vite 8

Astro 7 se actualiza a Vite 8, la actualización de Vite más importante en años. El cambio principal: Vite ahora incluye Rolldown, un bundler basado en Rust que reemplaza tanto a esbuild como a Rollup con un único bundler unificado. Rolldown es 10-30 veces más rápido que Rollup en pruebas comparativas al mismo tiempo que soporta las mismas APIs de plugins de Rollup y Vite.

Para usuarios de Astro, esto significa compilaciones más rápidas sin cambios en la configuración para la mayoría de los proyectos. Vite 8 incluye una capa de compatibilidad que convierte automáticamente tu y configuración a sus equivalentes de Rolldown. Si tu proyecto usa plugins personalizados de Vite, la mayoría deberían seguir funcionando porque Rolldown soporta la misma API de plugin que Rollup.

Rendimiento

Astro 7 es la versión más rápida de Astro hasta la fecha. A medida que el uso ha crecido, más equipos han estado superando los límites de qué tipo de sitio web se puede construir con Astro. Después de que lanzamos Astro 6 y su gran refactorización interna, fijamos nuestra vista en ayudar a Astro a escalar a sitios web más grandes y complejos.

Así es como funcionan las compilaciones de Astro:

1. Empaqueta las páginas, el contenido y los componentes del cliente del sitio en JavaScript.
2. Ejecuta el código empaquetado como un pequeño servidor, crea solicitudes para cada página prerrenderizada y guarda el HTML resultante.

Astro 7 mejora ambos pasos, pero se centra en el primero: la creación de paquetes del sitio. Las mayores mejoras provienen de trasladar algunas de las partes más lentas de la compilación a código nativo escrito en Rust. El paso de generación también es más rápido, gracias a una nueva estrategia de renderizado que hace cola de secciones para ser renderizadas de forma más eficaz.

En nuestras pruebas, los tiempos de compilación generales mejoraron un 15–61%, con algunos sitios web que se construyen más de dos veces más rápido. Los sitios donde la compilación y el procesamiento de Markdown representan una mayor parte de la compilación ven las mayores ganancias, ya que son exactamente las partes que pasaron a Rust.

Estos puntos de referencia se ejecutaron en un MacBook Pro Apple M4 Pro con 48 GB de memoria:

Compilador Rust

Construimos un nuevo compilador para el formato de componente, ahora escrito en Rust. El compilador es una reescritura completa de nuestro compilador anterior basado en Go que es mayormente compatible hacia atrás, excepto por:

• No más corrección de HTML. El compilador de Go reescribió silenciosamente tu marcado para que fuera “HTML válido” reorganizando elementos, cerrando etiquetas automáticamente y moviendo nodos de maneras que a menudo sorprendían a los usuarios y causaban problemas difíciles de depurar. El nuevo compilador trata tu marcado tal cual.
• Estrictez JSX-style. Etiquetas sin cerrar como y atributos sin terminar como ahora producen errores en lugar de ser corregidos silenciosamente. Estos son verdaderos errores en las plantillas que el compilador anterior ignoraba silenciosamente en un intento de comportarse como el navegador.
• JSX whitespace handling. Whitespace between elements is now collapsed following JSX conventions, matching the behavior of React and other JSX-based frameworks. For example, newlines between inline elements no longer produce a visible space:

  <!-- Before: renders as "Hello World" (with a space) -->
  <!-- After: renders as "HelloWorld" (no space) -->
  <span>Hello</span>
  <span>World</span>
  
  <!-- To preserve the space, use an explicit expression: -->
  <span>Hello</span>{' '}<span>World</span>

Movernos a Rust nos permitió distribuir binarios nativos para las plataformas compatibles, con un respaldo WASM para los entornos que lo necesiten. Este patrón es ahora estándar en el mundo de las herramientas JavaScript, utilizado por proyectos como Rolldown y Lightning CSS. Bajo el capó, el nuevo compilador se basa en oxc para el análisis y Lightning CSS para el alcance del CSS.

En aislamiento, el compilador de Rust mostró una mejora aproximada del 6% en los tiempos de compilación en https://docs.astro.build. Esto se debe a que la compilación rara vez es el cuello de botella; el procesamiento de Markdown y el empaquetado suelen dominar el tiempo de compilación. Pero cada pequeño detalle suma, especialmente en sitios grandes con miles de páginas, y las ganancias del compilador se suman a las otras mejoras de rendimiento en esta versión.

Markdown y MDX en Rust

Astro 7 reemplaza la canalización predeterminada de Markdown y MDX con Sätteri, un procesador impulsado por Rust creado por Erika . Cambiar las compilaciones de la documentación de Astro y los documentos de Cloudflare a Sätteri ahorró más de un minuto en sus tiempos de compilación, haciendo que los sitios con mucho contenido Markdown sean los mayores beneficiados en Astro 7.

Hasta ahora, el pipeline de Markdown de Astro funcionaba con unified (remark, rehype y una larga cola de dependencias de JavaScript). En sitios grandes con miles de páginas, ese pipeline a menudo era la fase más lenta de la compilación: cada archivo se analizaba mediante JavaScript, se ejecutaba a través de plugin tras plugin sobre el AST completo, y luego se serializaba de nuevo a HTML. En Astro 6.4, hicimos que el pipeline fuera adaptable y enviamos Sätteri como una alternativa opcional. Astro 7 lo convierte en el valor predeterminado.

Bajo el capó, Sätteri utiliza pulldown-cmark para el análisis de CommonMark y Oxc para el análisis de expresiones MDX, ambos nativos de Rust. Incluye binarios específicos de la plataforma con una opción WASM alternativa, el mismo enfoque utilizado por el nuevo compilador. La velocidad no es lo único que se gana, sin embargo. Sätteri también implementa muchas características de Markdown de forma nativa que antes requerían plugins separados:

Las funciones no predeterminadas están habilitadas a través de la opción:

import { defineConfig } from 'astro/config';
import { satteri } from '@astrojs/markdown-satteri';

export default defineConfig({
  markdown: {
    processor: satteri({
      features: {
        directive: true,
        math: true,
        headingAttributes: true,
      },
    }),
  },
});

Sätteri también tiene su propia API de plugins. Los plugins declaran qué tipos de nodos les importan y saltan el resto, en lugar de recorrer todo el árbol en cada pasada. Esto hace que añadir plugins sea mucho más barato que en unified, donde cada plugin recorre cada nodo.

Si dependes de los plugins remark o rehype, la canalización basada en unified sigue disponible a través de:

import { defineConfig } from 'astro/config';
import { unified } from '@astrojs/markdown-remark';
import remarkToc from 'remark-toc';

export default defineConfig({
  markdown: {
    processor: unified({
      remarkPlugins: [remarkToc],
    }),
  },
});

Aprende más sobre las funciones y la API de plugins de Sätteri en satteri.bruits.org.

Renderizado en cola

La renderización en cola se introdujo en Astro 6.0 como una opción experimental y ahora es estable y el motor de renderizado por defecto. ¡Es ~2.4× más rápida¹ en velocidad!

import { defineConfig } from "astro/config";

export default defineConfig({
  experimental: {
    queuedRendering: {
      enabled: true,
      pooling: true,
      contentCache: 1000
    }
  }
})

Anteriormente, Astro renderizaba páginas usando un enfoque recursivo donde los hijos eran renderizados usando la misma función, como en el siguiente pseudocódigo:

export function renderComponentToString(node: unknown): string {
  let destination = "";
  destination += `<${node.name}>`; // opening tag

  // render attributes

  for (const child of node.children) {
    // Here's where we recurse the children by calling renderComponentToString
    destination += renderComponentToString(child);
  }

  destination += `</${node.name}>`; // closing tag

  return destination;
}

El nuevo motor usa una cola (o pila) y un único bucle. La cola se llena con nodos hijos en el orden correcto, y el bucle sigue renderizando nodos hasta que la cola se vacía. El siguiente pseudocódigo es una versión simplificada del verdadero caso, pero debería darte una idea clara:

export function renderComponentToString(root: unknown): string {
  let destination = "";
  destination += `<${root.name}>`; // opening tag

  // this is our queue, populated and flushed as we render
  let stack = [root];

  while (stack.length > 0) {
    const node = stack.pop();

    if (Array.isArray(node)) {
      // The nodes at the very end must be rendered to destination first
      for (let i = node.length - 1; i >= 0; i--) stack.push(node[i]);
      continue;
    }

    const nodeType = typeof node;
    if (nodeType === 'string') {
      destination += escapeHTML(node as string);
    }
  }
  destination += `</${root.name}>`; // opening tag
  return destination;
}

La primera implementación de la estrategia funcionó en una fase de dos pasos: crea una lista ordenada de componentes (nodos) y recorre la lista para renderizar los componentes.

La nueva implementación ya no crea una lista completa, en cambio la lista se renderiza (se vacía) mientras se recorre. Este enfoque final es más rápido que la primera iteración y necesita menos memoria comparado con el enfoque recursivo.

Rutas Avanzadas

Astro comenzó como un generador de sitios estáticos con enrutamiento basado en archivos. Con el tiempo, características como middleware, redirecciones, reescrituras, Actions, sesiones e i18n le dieron a las apps Astro más potencia del lado del servidor, pero también hicieron que el ciclo de vida de la solicitud fuera más difícil de controlar. Si necesitabas autenticación para ejecutarse antes de Actions, registro para envolver solo el renderizado de páginas, o una API no-Astro para manejar algunas solicitudes primero, tenías que trabajar alrededor de la canalización en lugar de componerla directamente.

En Astro 7, ¡ahora puedes tener control total sobre el pipeline de peticiones de Astro! Para ello, simplemente añade un archivo a tu proyecto. Este archivo exporta el patrón de manejador estándar popularizado por Cloudflare Workers, Deno y Bun.

import { astro, FetchState } from 'astro/fetch';

export default {
  fetch(request: Request) {
    const state = new FetchState(request);

    // Forward API requests to a backend service
    if (state.url.pathname.startsWith('/api')) {
      const url = new URL(state.url.pathname + state.url.search, 'https://backend-api.example.com');
      return fetch(new Request(url, request));
    }

    // Fallback to Astro pages/endpoints
    return astro(state);
  }
}

La API también es compatible con Hono, permitiéndote llevar el middleware de Hono a tu aplicación Astro:

import { astro } from 'astro/hono';
import { Hono } from 'hono';
import { basicAuth } from 'hono/basic-auth';

const app = new Hono();
app.use(basicAuth({ username: 'admin', password: 'secret' }));
app.use(astro());

export default app;

Para un uso más avanzado, puedes componer funciones individuales de Astro como middleware separados, dándote control total sobre la canalización de solicitudes. Si alguna vez has usado el middleware de Astro y te ha frustrado que tu comprobación de autenticación se ejecutara después de las Acciones de Astro, o que no pudieras registrar los tiempos de respuesta sin tener que envolver todo tú mismo, ahora puedes poner tu código justo donde lo necesitas:

import { Hono } from 'hono';
import { actions, middleware, pages, i18n } from 'astro/hono';
import { auth } from './middleware/auth';
import { timing } from './middleware/timing';

const app = new Hono();

app.use(i18n());
app.use(auth());       // Auth runs before actions, no unauthenticated calls
app.use(actions());
app.use(middleware());
app.use(timing());     // Timing wraps only page rendering
app.use(pages());

export default app;

Si no añades un archivo, Astro se comporta exactamente como lo hace hoy en día.

Caché de Rutas

Guardar en caché las respuestas renderizadas bajo demanda es más difícil de lo que debería ser. Cada host lo hace de manera diferente y nunca ha habido una forma estándar de controlarlo desde tu código de aplicación. Astro 7 introduce el almacenamiento en caché de rutas para solucionar esto. Esta función, lanzada experimentalmente en Astro 6, ahora es estable y agrega una API única e independiente de la plataforma para el almacenamiento en caché: define directivas en tus rutas, y Astro se encarga del resto donde sea que implementes.

Configuras un proveedor de caché una vez, luego lo usas en tus páginas (o en rutas y middleware de API) para controlar el almacenamiento en caché por respuesta, basándote en la semántica estándar de HTTP. Astro incluye un proveedor incorporado para que empieces:

import { defineConfig, memoryCache } from 'astro/config';

export default defineConfig({
  cache: {
    provider: memoryCache(),
  },
});

---
Astro.cache.set({
  maxAge: 120, // Cache for 2 minutes
  swr: 60, // Serve stale for 1 minute while revalidating
  tags: ['products'], // Tag for targeted invalidation
});
---

También puedes definir reglas de caché para grupos de rutas de forma declarativa en tu configuración con , manteniendo la caché fuera de tu código de ruta por completo:

export default defineConfig({
  cache: { provider: memoryCache() },
  routeRules: {
    '/blog/[...path]': { maxAge: 300, swr: 60 },
  },
});

Donde la caché de rutas realmente brilla es su integración con colecciones de contenido en vivo. Un cargador en vivo puede adjuntar una sugerencia de caché a los datos que devuelve, con etiquetas para invalidación y una hora de última modificación para mantenerlo actualizado. Pasa esa entrada directamente a y Astro lee la sugerencia por ti, sin necesidad de encabezados manuales:

---
import { getLiveEntry } from 'astro:content';
const { entry } = await getLiveEntry('products', Astro.params.id);

// Astro reads the loader's cache hint from the entry:
Astro.cache.set(entry);
---

Las respuestas en caché se pueden purgar bajo demanda con , por etiqueta o por ruta. Por ejemplo, puedes exponer un punto final de webhook para que tu CMS lo llame cada vez que cambie el contenido. Esto se corresponde con la API de invalidación de cada proveedor, borrando cada respuesta afectada sin necesidad de reconstruir:

import type { APIRoute } from 'astro';

export const POST: APIRoute = async ({ request, cache }) => {
  // A real implementation would validate the request and check a secret token before invalidating.

  const { slug } = await request.json();

  // Invalidate every response tagged 'products'...
  await cache.invalidate({ tags: ["products"] });

  // ...invalidate every page that used a particular entry...
  await cache.invalidate({ tags: [`products:${slug}`] });

  // ...or purge a single path directly.
  await cache.invalidate({ path: `/products/${slug}` });

  return new Response('Revalidated');
};

Si probaste el caché de rutas cuando estaba en versión experimental, el único cambio es mover y fuera del bloque a la parte superior de tu configuración. De lo contrario, la API no ha cambiado. Consulta la guía del caché de rutas para obtener la referencia completa.

Proveedores de caché CDN

Cuando el almacenamiento en caché de rutas llegó con Astro 6, venía con un único proveedor en memoria para usar con el adaptador de Node. Astro 7 añade proveedores experimentales de CDN para Netlify, Vercel y Cloudflare (en beta privada).

En lugar de almacenar respuestas en memoria, estos proveedores envían tus directivas de caché a la red perimetral del host, para obtener respuestas aún más rápidas. Los aciertos de caché se sirven directamente desde el CDN, sin invocar tu función de servidor en absoluto.

En una futura versión, estos proveedores se habilitarán automáticamente, pero durante la fase de prueba deberías agregarlos manualmente. Importa el proveedor para tu adaptador y configúralo como tu proveedor de caché:

import { defineConfig } from 'astro/config';
import netlify from '@astrojs/netlify';
import { cacheNetlify } from '@astrojs/netlify/cache';

export default defineConfig({
  adapter: netlify(),
  cache: {
    provider: cacheNetlify(),
  },
});

Cada adaptador exporta un proveedor desde su punto de entrada:

Las mismas APIs , y funcionan con cada proveedor. Cada una traduce tus directivas en los encabezados de control de caché nativos de la plataforma y eliminaciones basadas en etiquetas o rutas.

Mejoras con IA

Los agentes de codificación con IA ahora forman parte del flujo de trabajo de muchos desarrolladores, y necesitan cosas diferentes de un servidor de desarrollo que los humanos. Astro 7 es nuestro primer paso hacia hacer de Astro una mejor plataforma para el desarrollo impulsado por agentes.

Background Dev Server

Los agentes de IA tienen problemas con los procesos de larga duración. Se encargan, esperan a que finalicen y leen la salida, pero un servidor de desarrollo nunca finaliza. Los agentes se quedan colgados, inician servidores duplicados, pierden el control de las instancias en ejecución o dejan procesos zombie atrás. Vemos esto como parte del triage automatizado de problemas de Astro también, con agentes a veces pasando más tiempo lidiando con servidores de desarrollo que probando código.

Astro 7 añade , que inicia el servidor de desarrollo como un proceso en segundo plano gestionado. Astro también puede detectar cuando se está ejecutando dentro de un agente de IA y habilitar el modo de fondo automáticamente, así que no se necesitan flags en los flujos de trabajo del agente. Si no se detecta ningún agente, se comporta exactamente como antes.

$ astro dev --background
Dev server running at http://localhost:4321 (pid 12345)
  Stop:   astro dev stop
  Status: astro dev status
  Logs:   astro dev logs

El comando espera hasta que el servidor esté listo para aceptar peticiones, muestra la URL y el ID del proceso, y luego se desconecta. Sin sondeos, sin pausas, ni análisis de la salida de la terminal en busca de "Local:".

Un lockfile previene instancias duplicadas. Si un agente intenta iniciar un segundo servidor, obtiene los detalles de la instancia existente en lugar de generar un proceso conflictivo:

$ astro dev --background
Dev server already running at http://localhost:4321 (pid 12345)

Puedes revisar el estado y detener el servidor desde sesiones de terminal separadas:

$ astro dev status
Dev server running at http://localhost:4321 (pid 12345, uptime 123s, background)

$ astro dev stop
Stopped dev server (pid 12345).

También puedes leer los registros del servidor de fondo con .

Cada comando es idempotente y indulgente. Detener cuando no está en ejecución tiene éxito silenciosamente, y empezar cuando ya está en ejecución devuelve la instancia existente. Los agentes a menudo pierden el rastro del estado del proceso, y la CLI no los castiga por ello.

Todos los servidores de desarrollo en ejecución también exponen un punto final de estado que los agentes pueden consultar para confirmar que el servidor está activo y listo para aceptar solicitudes.

Registro JSON

El registrador de Astro ahora es totalmente configurable. Para agentes, el registro en formato JSON se habilita automáticamente cuando la detección de agentes activa el modo de segundo plano. Para los demás, está disponible a través de la línea de comandos o la configuración:

astro dev --json

import { defineConfig, logHandlers } from "astro/config";

export default defineConfig({
  logger: logHandlers.json()
})

El registro de JSON fue la función más solicitada y votada en nuestro roadmap, y no solo por la IA. Los equipos que implementan Astro SSR en producción necesitan registros estructurados para integrarse con servicios de agregación de logs como Kibana, CloudWatch y Grafana/Loki. El registro anterior de Astro estaba codificado para facilitar su lectura: colores, caracteres de dibujo de cajas, formato de error multilínea. Nada de eso es interpretable por máquinas.

La nueva API de registro también soporta manejadores de registro personalizados y una API para combinar múltiples registradores. Por ejemplo, puedes mantener la salida legible por humanos en la consola mientras también escribes registros JSON para herramientas que necesitan una salida estructurada:

import { defineConfig, logHandlers } from "astro/config";

export default defineConfig({
  logger: logHandlers.compose(
    logHandlers.console(),
    logHandlers.json()
  )
})

Averigua más sobre el soporte de Astro para herramientas de IA en la guía de IA.

Comunidad

El equipo central de Astro es:

Alexander Niebuhr , Armand Philippot , Chris Swithinbank , Emanuele Stoppa , Erika , Florian Lefebvre , Fred Schott , HiDeoo , Luiz Ferraz , Matt Kane , Matthew Phillips , Reuben Tier , Sarah Rainsberger , y Yan Thomas .

Muchas gracias a todos los que contribuyeron con Astro 7 con código, documentación, revisiones y pruebas, incluyendo:

0x K., 0xRozier, AceCodePt, Adam Chalemian, Adam Matthiesen, Adam McKee, Adam Page, Agus Setiawan, Ahmad Yasser, Alejandro Romano, Alex, Alex Dombroski, Alex Launi, Alexander Flodin, Alexis Aguilar, Aly Cerruti, Amar Reddy, Andreas Deininger, Andrei Alba, Antony Faris, Ariel K, Ash Hitchcock, atsbob, B Sai Thrishul, Barry, Ben Limmer, Bernd Strehl, BitToby, btea, Burra Karthikeya, buschtrisha77, Calvin Liang, Cameron Pak, Cameron Smith, Carlos Lázaro Costa, chaegumi, Chan, Chase McCoy, ChrisLaRocque, Ciaran Moran, Corbin Crutchley, CyberFlame, Daniel Bodky, Daniel Lo Nigro, Daniel Zamyatin, Daniil Sivak, Dario Piotrowicz, dataCenter430, Dawid Gaweł, Desel72, dfedoryshchev, Dom Christie, done, Dor Alagem, Dream, Ed Melly, Ed Melly, Edgar, Ellie, Em Poulter, Eric Grill, Eric Mika, Eryk Baran, Eveeifyeve, fabon, farshad, Felipe Arce, Felix Schneider, Felmon, fkatsuhiro, G Taki@MAX, Giray, Gokhan Kurt, Great Journey, Greg L. Turnquist, Harsh Agarwal, Haz, helio-cf, Henri Fournier, Henri Koskenranta, Henry, Igor Koop, Jack Lukic, Jack Moorhouse, Jack Shelton, jahndan, James Basoo, James Garbutt, James Murty, James Opstad, Jason P. Cochrane, Jett Way, Jimmy, joel hansson, John Mortlock, Johnny Noble, Jon Ege Ronnenberg, Joost de Valk, Jordan Demaison, Josh Soref, JPette1783, Julian Wolf, Julien Cayzac, Junseong Park, Justin Francos, Kai, kato takeshi, Kedar Vartak, Kendell, Kevin Brown, knj, Koji Wakamiya, Konrad Szajna, Kristijan, KTrain, Kumar Gautam, Kyle McLean, Lee Freeman, Leif Marcus, Leonie, Lieke, liruifengv, LongYC, Louis Escher, Luke Deen Taylor, MA2153, Mark Ignacio, Martin DONADIEU, Martin Heidegger, Martin Trapp, Matheus Baroni, Mathieu Mafille, Matthew Justice, Matthias, Matthieu Tremblay, Mavik, Max Malkin, maxim, meyer, Michael Giraldo, Mike Pagé, Milo, Minh Lê, Misrilal, MkDev11, Mochammad Farros Fatchur Roji, moktamd, Naren, Natan Sągol, Nicolò Paternoster, Ntale Swamadu, oab24413gmai, ocavue, Oliver Speir, oliverlynch, Ossaid, Patrick Linnane, Peter Philipp, Phaneendra, Pierre G., pierreeurope, Quetzal Rivera, R A, Raanelom, Rafael Yasuhide Sudo, Rahul Dogra, Rayan Salhab, Rodrigo Santos, Rohan Santhosh Kumar, Roman, Roman Kholiavko, Sam Richard, sanchezmaldonadojesusadrian14-coder, Sanjaiyan Parthipan, sanjibani, Schahin, Sebastian Beltran, Sebastien Barre, Shinya Fujino, Stefan Machhammer, Stel Clementine, Tay, Tee Ming, thelazylama, Timo Behrmann, tmimmanuel, Tobias Breit, Tom Callahan, Tomasz Cz-Sokołow, travisBREAKS, Tristan Bessoussa, Umut Keltek, Utpal Sen, Vagno, Varun Chawla, Victor Berchet, Vladyslav Shevchenko, Yagiz Nizipli, yy, and 翠

Esperamos que disfrutes de Astro 7. Si tienes algún problema o quieres compartir tu opinión, únete a nosotros en Discord, publica en GitHub o contáctanos en Bluesky, Twitter y Mastodon.