In Laravel, what does Blade compile a .blade.php template into, where is the result stored, and when is it recompiled?

## Blade is a compiler Some template engines parse the template on every render. **Blade** does not. The first time a view is rendered, Laravel's `BladeCompiler` translates the `.blade.php` source into an ordinary PHP file, and every later render simply executes that file. The Blade docs describe templates as "compiled into plain PHP code and cached until they are modified", which is why Blade adds essentially no runtime overhead. What the translation produces: - `{{ $course->name }}` becomes `<?php echo e($course->name); ?>`. - `@section('content')` becomes a call that starts output buffering on the view factory, and `@endsection` a call that stops it and stores the content. - `@extends('layouts.app')` produces no output where it is written; it becomes a **footer** line, appended at the end of the compiled file, that makes and renders the layout with the child's variables. - Component tags such as `<x-layout>` are rewritten into calls that start, capture and render the component. - The compiler appends a `/**PATH <source path> ENDPATH**/` comment, which Laravel uses to point error pages at the original template rather than at the compiled file. ## Where compiled views live | Setting | Default | |---|---| | config key `view.compiled` | `storage/framework/views` (via `realpath(storage_path('framework/views'))`) | | env override | `VIEW_COMPILED_PATH` | | config key `view.cache` | `true`; `false` recompiles on every render | | config key `view.check_cache_timestamps` | `true`; `false` skips the freshness check | The `view` config file is not part of the Laravel 13 skeleton; the framework's defaults apply until you publish it, and keys such as `view.cache` and `view.check_cache_timestamps` are read with the defaults above even when the file is absent. Each compiled file is named with an `xxh128` hash of the template's path, so the directory holds opaque names like `3f9a...c2.php`. The directory must be writable by the PHP process. ## When a view is recompiled On each render, the compiler engine asks whether the view has **expired**: 1. If caching is disabled (`view.cache` is `false`), it has always expired. 2. If no compiled file exists at the hashed path, it has expired. 3. If timestamp checks are disabled, it has not expired. 4. Otherwise it has expired when the source file's modification time is **greater than or equal to** the compiled file's. When a view has expired, it is compiled again before it is executed. The compiler also compares a hash of the new output with the existing compiled file and leaves the file untouched when the output is identical, only bumping its timestamp so the next check sees it as fresh. This is why editing a template in development shows up on the next request without any command: saving the file advances its modification time. ## Reading a compiled view Opening a compiled file is the quickest way to understand a Blade directive. The layout directives, for example, turn out to be thin calls on the view factory, the object exposed to compiled templates as `$__env`: - `@section` and `@endsection` become `$__env->startSection(...)` and `$__env->stopSection()`; - `@yield('content')` becomes an echo of `$__env->yieldContent('content')`; - `@push` and `@stack` become `startPush` and an echo of `yieldPushContent`. Seeing that `@extends` compiles to a line at the very end of the file explains, without any documentation, why a child view's sections exist before its layout runs. ## Consequences worth knowing - **`__DIR__` and `__FILE__`** inside a Blade view refer to the compiled file under `storage/framework/views`, not to `resources/views`. The docs warn against using them in views. - **PHP's OPcache** caches compiled PHP files like any other script, so a compiled view is served as cached bytecode once it is warm. - **Inline templates** rendered with `Blade::render($string, $data)` are also written to the compiled-views directory; pass `deleteCachedView: true` to remove the temporary file afterwards. - A stack trace that mentions a hash-named file in `storage/framework/views` is a compiled Blade view; the `PATH` comment at its end names the source template. Precompiling every view during a deployment, and clearing the directory, are Artisan concerns covered with the other production cache commands.