A fondo

Rendimiento

Ascua frente a vanilla, Solid, Svelte y React en las operaciones de js-framework-benchmark. Empatada con Solid, por delante de Svelte y muy por delante de React.

El resultado

Tiempo de cada operación dividido por el de vanilla —el mismo DOM escrito a mano— en la misma ronda. 1,00 es tan rápido como el código a mano; más bajo es mejor.

Operación Ascua Solid Svelte React
Crear 1.000 filas 1,12 1,06 1,08 1,27
Reemplazar 1.000 1,03 1,04 1,09 1,50
Actualizar 1 de cada 10 1,09 0,99 1,10 1,08
Intercambiar dos filas 1,10 1,18 1,25 11,97
Quitar una fila 1,07 1,18 1,19 1,44
Crear 10.000 filas 1,08 0,99 1,07 1,74
Añadir 1.000 a 1.000 1,04 0,96 0,98 1,21
Vaciar 1.000 filas 1,28 1,18 1,31 1,80
Media geométrica 1,10 1,07 1,13 1,85

Ascua empata con Solid y va por delante de Svelte; React tarda un 68 % más que Ascua. En las dos pasadas de esta medición Ascua dio 1,10 y 1,10; Solid, 1,13 y 1,07; Svelte, 1,14 y 1,13. Entre Ascua y Solid la diferencia cambia de signo de una pasada a otra: es un empate. La media geométrica es la que usa js-framework-benchmark para resumir: una operación diez veces más lenta no se compensa con diez que van un poco más rápido. Por debajo de 1,00 hay ruido: una operación que tarda lo mismo que vanilla sale a veces un poco por debajo.

Ascua gana en lo que depende de hacer poco: seleccionar una fila, quitarla e intercambiar dos. Donde más se nota la diferencia con React es en lo que un Virtual DOM hace peor: intercambiar dos filas de mil —React mueve casi todas, Ascua mueve dos— y crear diez mil.

Ascua 0.5.0, Solid 1.9.15, Svelte 5.57.1, React 19.3.0. Chrome 153 controlado por Playwright en un Apple M3 con macOS 27, el 29 de septiembre de 2026, con dos pasadas de 5 rondas y el reloj de alta resolución; la tabla es la segunda. Los datos crudos, en milisegundos y por ronda, están en benchmarks/resultados/.

Nota: «seleccionar una fila» no está en la tabla ni en la media: son décimas de milisegundo y su factor se dispara por cualquier nada. En esta medición tardó 0,07 ms en vanilla, 0,14 en Ascua y 0,14 en Solid; Svelte, 0,34 ms —no tiene un selector, y cada una de las mil filas compara su id con la elegida— y React, 0,42 ms.

Lo que cambió con estas cifras

En la 0.4.0, Ascua daba 1,15 frente a 1,08 de Solid. Midiendo dónde se iba el tiempo, la diferencia era toda de DOM, no de JavaScript: Ascua creaba cada fila nodo a nodo —diez createElement y ocho setAttribute— y ponía dos addEventListener por fila. La 0.5.0 cambió tres cosas:

  • Plantillas que se clonan. El compilador declara lo fijo de cada plantilla una vez por archivo, y cada fila es un cloneNode. El prototipo vive en el documento inerte de un <template>, que se clona en menos de la mitad de tiempo que uno del documento de la página. El compilador genera también el recorrido hasta los nodos que hacen falta, con firstChild y nextSibling directos.
  • Eventos delegados, como en Solid y Svelte: un listener por tipo en el documento, en vez de uno por nodo. Ver plantillas.
  • Menos trabajo en el grafo y en las listas: los nodos reactivos crean sus listas solo cuando las usan, cada fila se crea sin closures de más, y la lista tiene atajos para lo común —llenarla vacía, quitar o añadir sin reordenar, intercambiar dos—.

Cuesta tamaño: el runtime pasó de 4,29 a 5,73 kB con todo lo que exporta, y un contador mínimo, de 1,66 a 2,47 kB.

La medición también cambió: ahora se sirve con aislamiento de origen cruzado (benchmarks/servir.py), y el reloj del navegador baja de 0,1 ms a microsegundos. Antes, las operaciones de uno o dos milisegundos —quitar una fila, vaciar— salían en escalones del 8 %.

Antes: una fuga al vaciar

La primera medición publicada dejaba «vaciar 1.000 filas» en 1,60. Al estudiarlo apareció algo peor que la lentitud: una fuga de memoria. Cada fila de un <For> quedaba colgada del scope de la lista después de liberarse, con sus closures y sus nodos del DOM; tras diez ciclos de llenar y vaciar la tabla, el scope retenía diez mil filas muertas. La 0.1.2 las descuelga al liberarlas, deja de copiar listas vacías en cada nodo que se libera y no quita uno a uno los listeners de los nodos que ya salieron del documento. Vaciar bajó a 1,31.

Lo que queda está en el DOM, no en Ascua: de los ~5 ms, unos 4 son el propio textContent = "", y menos de uno, liberar las mil filas.

Qué se mide

Las operaciones de js-framework-benchmark, sobre la misma tabla y los mismos datos para los cinco: filas con un id y una etiqueta de tres palabras al azar, un botón por operación y un enlace para seleccionar o quitar cada fila.

Cada contendiente está escrito como dice su documentación, sin atajos que un usuario no tomaría:

  • Ascua: un signal por etiqueta, <For> con clave y selector para la fila elegida.
  • Solid: createSignal, <For> y createSelector, como su versión en js-framework-benchmark.
  • Svelte: runas —una etiqueta con $state por fila, la lista como $state.raw— y {#each} con clave, como su versión en js-framework-benchmark. Svelte no tiene un equivalente a selector: cada fila compara su id con la elegida.
  • React: estado en un reducer y filas memoizadas con memo, como la suya.
  • Vanilla: el DOM a mano, que es el suelo.

Cómo se mide

El tiempo va desde el click hasta que el DOM está actualizado y maquetado: tras la operación se deja correr lo que el framework haya programado y se fuerza el layout leyendo offsetHeight. Entra el recálculo de estilos y la maquetación; no entra el pintado. js-framework-benchmark sí lo incluye —mide con trazas de Chrome—, así que los números absolutos no son comparables con los suyos, y los relativos sí.

Después de cada vuelta se comprueba que el DOM quedó como debe. Si un framework deja trabajo pendiente —React programa el suyo en una microtarea—, la comprobación falla y no sale un número falso.

La máquina cambia de velocidad mientras se mide: temperatura, lo que haya abierto. En esta máquina, dos pasadas seguidas llegaron a diferir un 30 %. Por eso nada se compara entre pasadas:

  • Cada ronda mide a los cinco seguidos, rotando el orden.
  • Cada tiempo se expresa como factor sobre vanilla de esa misma ronda: la deriva afecta a todos por igual y se cancela en el cociente.
  • Por operación, 5 vueltas de calentamiento y 15 medidas; se toma la mediana. Entre rondas, la mediana de los factores.

Reproducirlo

sh
for d in vanilla ascua solid svelte react; do
  (cd benchmarks/$d && stil install && stil exec vite build)
done
bash scripts/link-packages.sh
python3 benchmarks/servir.py

Y en http://127.0.0.1:5191/, el botón correr, o en la consola:

js
await correr({ rondas: 3, vueltas: 15, calentamiento: 5 });

Con 3 rondas tarda unos dos minutos. Los resultados cambian de una máquina a otra; los factores, bastante menos.

Lo que no dice

Una tabla de mil filas es un caso concreto. Mide el coste de crear, mover y quitar nodos, que es donde los frameworks se diferencian, pero no el arranque, ni la memoria, ni cómo se comporta una aplicación de verdad con cien componentes distintos. El tamaño, en cambio, se mide solo: 4,01 kB de runtime frente a los ~45 kB de React. Svelte 5 no tiene un runtime aparte —el compilador toma lo que usa cada componente—, así que lo comparable es la aplicación mínima: un contador ocupa 10,1 kB gzip en Svelte 5.57 y 2,47 kB en Ascua.