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

# Introductie van het Blaze-pakket

> Hoe je met Blaze, het officiële Livewire-pakket, het renderen van Blade-componenten versnelt. We behandelen de keuzecriteria voor compile / memo / fold, de installatie, beperkingen en de interne werking.

<Info>
  Dit artikel is gebaseerd op de README van [livewire/blaze](https://github.com/livewire/blaze) als primaire bron. Op dit moment is er op laravel.com nog geen aparte documentatie voor Blaze.
</Info>

## Wat is Blaze?

[Blaze](https://github.com/livewire/blaze) is een officieel pakket van Livewire om Blade-componenten sneller te maken. Het richt zich niet alleen op Livewire-componenten, maar ook op gewone anonieme Blade-componenten.

De README toont een benchmark waarbij 25.000 renders van een anoniem component teruggaan van **500 ms → 13 ms** (ongeveer **97,4% reductie**). Ook per scenario worden reducties van 91 tot 97% gerapporteerd.

## Drie optimalisatiestrategieën

Blaze biedt drie strategieën: `compile` (standaard), `memo` en `fold`.

```mermaid theme={null}
flowchart LR
    A["Componentaanroep"] --> B["compile<br>Compileren naar functie"]
    A --> C["memo<br>Memoiseren van identieke props"]
    A --> D["fold<br>HTML genereren tijdens compilatie"]
    B --> E["Brede compatibiliteit en grote winst"]
    C --> F["Sterk bij herhaalde renders"]
    D --> G["Maximale prestaties, maar let op"]
```

### Welke moet je kiezen?

| Strategie | Wanneer kiezen                                                   | Voordelen                                                  | Aandachtspunten                                                                   |
| --------- | ---------------------------------------------------------------- | ---------------------------------------------------------- | --------------------------------------------------------------------------------- |
| `compile` | De standaardstrategie om mee te beginnen                         | Hoge compatibiliteit, snelheidswinst zonder configuratie   | De algemene beperkingen moet je wel controleren                                   |
| `memo`    | Iconen, badges e.d. die vaak met dezelfde props worden gerenderd | Verlaagt de kosten van herhaalde renders na de eerste keer | Niet bruikbaar bij componenten met een slot                                       |
| `fold`    | Wanneer je maximale prestaties wilt bij statisch te bepalen UI   | Elimineert vrijwel alle runtime-overhead                   | Verkeerd omgaan met globale state of dynamische waarden leidt tot inconsistenties |

Twijfel je? Begin dan met **`compile`** en pas `memo` / `fold` alleen toe op plekken waar je een bottleneck hebt vastgesteld — dat is de veiligste aanpak.

## Installatie en inschakelen

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

Er zijn twee manieren om Blaze in te schakelen.

### 1) `@blaze` toevoegen aan afzonderlijke componenten

```blade theme={null}
@blaze

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

Wissel indien nodig van strategie.

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

### 2) Per directory inschakelen met `Blaze::optimize()`

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

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

Wis na het inschakelen de gecompileerde views.

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

<Tip>
  `@blaze` is geschikt om "eerst eens te proberen", `Blaze::optimize()` om "breed toe te passen in productie". Ook de README raadt aan om stapsgewijs te beginnen met een beperkte directory.
</Tip>

## Beperkingen

Dit zijn de beperkingen die expliciet in de README staan.

* Klassegebaseerde componenten worden niet ondersteund
* De variabele `$component` is niet beschikbaar
* View composers / creators / lifecycle events worden niet afgevuurd
* Automatische injectie van `View::share()`-variabelen wordt niet ondersteund (gebruik zo nodig expliciet `$__env->shared('key')`)
* `@aware` over de grens van Blade en Blaze heen is beperkt (ouder en kind moeten beide aan de Blaze-kant zitten)
* Je kunt een Blaze-component niet rechtstreeks renderen via `view()` (alleen via componenttags)

## Combinatie met Flux UI

De README van Blaze vermeldt dat je, als je [Flux UI](https://fluxui.dev/docs/installation) gebruikt, **direct aan de slag kunt door alleen Blaze te installeren, zonder extra configuratie**.

## Hoe het werkt in het kort

Gewone Blade doorloopt bij elke render de volledige renderpipeline, inclusief componentresolutie en attribuutverwerking. De `compile`-strategie van Blaze compileert dit naar een geoptimaliseerde PHP-functie die rechtstreeks wordt aangeroepen, waardoor de overhead van de pipeline sterk afneemt.

Zoals de README uitlegt, is het conceptuele verschil als volgt.

* Normaal: de standaard renderafhandeling van Blade wordt telkens uitgevoerd
* Blaze `compile`: een gecompileerde functie wordt rechtstreeks aangeroepen
* Blaze `fold`: de HTML wordt tijdens compilatie ingebed, waardoor runtime-berekeningen nog verder afnemen

`fold` is het snelst, maar elementen die de aanname van statische inhoud doorbreken (authenticatiestatus, request-afhankelijke waarden, sessie-afhankelijke waarden, tijdsafhankelijke waarden, enz.) kunnen problemen veroorzaken. Pas het stapsgewijs toe, alleen op plekken met hoge belasting, en controleer daarbij het gedrag.


## Related topics

- [Laravel Agent Detector — pakket voor het detecteren van AI-agents](/nl/blog/agent-detector-introduction.md)
- [Introductie van Laravel Wayfinder](/nl/blog/wayfinder-introduction.md)
- [Introductie testen](/nl/testing.md)
- [⚡Introductie van Livewire 4 — reactieve UI's bouwen zonder JavaScript](/nl/blog/livewire-introduction.md)
- [Introductie tot Laravel Nightwatch](/nl/blog/nightwatch-introduction.md)