> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Presentación del paquete Blaze

> Se explica cómo acelerar el renderizado de componentes Blade con Blaze, oficial de Livewire. Se resumen los criterios de elección entre compile / memo / fold, la instalación, las limitaciones y el funcionamiento interno.

<Info>
  Este artículo se basa como fuente primaria en el README de [livewire/blaze](https://github.com/livewire/blaze). Actualmente no hay documentación específica de Blaze en el lado de laravel.com.
</Info>

## ¿Qué es Blaze?

[Blaze](https://github.com/livewire/blaze) es un paquete oficial de Livewire para acelerar componentes Blade. No está limitado a componentes Livewire, sino que también incluye los componentes anónimos ordinarios de Blade.

En el README se muestra un benchmark de 25.000 renderizados de un componente anónimo con una mejora de **500 ms → 13 ms** (una reducción de aproximadamente el **97,4 %**). Por escenario, se reportan reducciones del 91 al 97 %.

## Las tres estrategias de optimización

Blaze ofrece tres estrategias: `compile` (predeterminada), `memo` y `fold`.

```mermaid theme={null}
flowchart LR
    A["Llamada al componente"] --> B["compile<br>Compilar a función"]
    A --> C["memo<br>Memoizar mismas props"]
    A --> D["fold<br>Convertir a HTML en tiempo de compilación"]
    B --> E["Amplia compatibilidad y gran mejora"]
    C --> F["Fuerte en renderizado repetido"]
    D --> G["Máximo rendimiento, con cautelas"]
```

### ¿Cuál elegir?

| Estrategia | Cuándo elegirla                                                          | Ventajas                                                 | Consideraciones                                                                           |
| ---------- | ------------------------------------------------------------------------ | -------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
| `compile`  | Estrategia estándar como primera opción                                  | Alta compatibilidad; fácil de acelerar sin configuración | Requiere revisar las limitaciones comunes                                                 |
| `memo`     | Iconos, badges, etc. que se renderizan muchas veces con las mismas props | Reduce el coste de re-renderizado tras la primera vez    | No puede usarse en componentes con slot                                                   |
| `fold`     | Cuando se busca el máximo rendimiento en UI estáticamente determinable   | Elimina prácticamente el overhead en tiempo de ejecución | Un manejo erróneo del estado global o de valores dinámicos puede provocar inconsistencias |

Si dudas, lo seguro es **empezar con `compile`** y aplicar `memo` / `fold` solo en los puntos donde se haya identificado un cuello de botella.

## Instalación y activación

```bash theme={null}
composer require livewire/blaze:^1.0
```

Hay dos formas de activarlo.

### 1) Añadir `@blaze` a componentes individuales

```blade theme={null}
@blaze

<button {{ $attributes }}>
    {{ $slot }}
</button>
```

Cambia la estrategia según sea necesario.

```blade theme={null}
@blaze(memo: true)
@blaze(fold: true)
```

### 2) Activar por directorio con `Blaze::optimize()`

```php theme={null}
use Livewire\Blaze\Blaze;

public function boot(): void
{
    Blaze::optimize()
        ->in(resource_path('views/components'));
}
```

Tras activarlo, limpia las vistas compiladas.

```bash theme={null}
php artisan view:clear
```

<Tip>
  `@blaze` es útil para "probarlo primero", mientras que `Blaze::optimize()` es adecuado para "aplicarlo ampliamente en producción". El README también recomienda una aplicación gradual empezando por directorios limitados.
</Tip>

## Limitaciones

Limitaciones que se indican explícitamente en el README.

* No se admiten componentes basados en clase
* No se puede usar la variable `$component`
* Los View composers / creators / lifecycle events no se disparan
* No se admite la inyección automática de las variables de `View::share()` (si es necesario, usa explícitamente `$__env->shared('key')`)
* `@aware` que atraviese la frontera entre Blade y Blaze tiene limitaciones (tanto el padre como el hijo deben usarse desde el lado de Blaze)
* No se pueden renderizar directamente componentes Blaze con `view()` (solo mediante etiquetas de componente)

## Compatibilidad con Flux UI

En el README de Blaze se indica que, si estás usando [Flux UI](https://fluxui.dev/docs/installation), **puedes empezar a utilizarlo sin configuración adicional con solo instalar Blaze**.

## Resumen del funcionamiento

Un Blade normal atraviesa cada vez el pipeline de renderizado, incluida la resolución del componente y el procesamiento de atributos. El `compile` de Blaze compila esto en una función PHP optimizada y la invoca directamente, reduciendo enormemente el overhead del pipeline.

Tal como explica el README, conceptualmente existen las siguientes diferencias.

* Normal: ejecuta cada vez el procesamiento estándar de renderizado de Blade
* Blaze `compile`: invoca directamente una función compilada
* Blaze `fold`: incrusta HTML en tiempo de compilación, reduciendo aún más los cálculos en tiempo de ejecución

`fold` es el más rápido, pero si existen elementos que rompen la premisa de estaticidad (estado de autenticación, valores dependientes de la petición, valores dependientes de la sesión, valores dependientes del tiempo, etc.), puede causar fallos. Aplícalo de forma gradual únicamente a puntos de alta carga y comprobando el comportamiento.


## Related topics

- [Presentación de Laravel Wayfinder](/es/blog/wayfinder-introduction.md)
- [Construir una SPA con Inertia.js](/es/blog/inertia-introduction.md)
- [Técnicas prácticas de Laravel Telescope](/es/blog/telescope-introduction.md)
- [Empieza a testear Laravel con Pest PHP](/es/blog/pest-introduction.md)
- [Casos de uso prácticos de Laravel Pennant](/es/blog/laravel-pennant.md)