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, confirstChildynextSiblingdirectos. - 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 yselectorpara la fila elegida. - Solid:
createSignal,<For>ycreateSelector, como su versión en js-framework-benchmark. - Svelte: runas —una etiqueta con
$statepor fila, la lista como$state.raw— y{#each}con clave, como su versión en js-framework-benchmark. Svelte no tiene un equivalente aselector: 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
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.pyY en http://127.0.0.1:5191/, el botón correr, o en la consola:
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.