Latte Templates

Latte 3 syntax, filters, functions and template variables.

Updated
On this page

Assignment and output

{var} assigns without output. {$x = ...} assigns and outputs.

{var $children = $page->children()}   {* no output *}
{$title = 'Hello'}                     {* outputs: Hello *}

Output is HTML-escaped by default. Use |noescape only for values you trust:

{$page->title}          {* escaped *}
{$html|noescape}        {* raw *}

Fields

$page->fieldName returns a FieldValue. Output it directly for the decoded string, or pipe it through |render:

{$page->body}           {* decoded string, escaped *}
{$page->body|render}    {* via the field type's render template *}

A FieldValue is always truthy, even when its content is empty. Check ->empty():

{* wrong: always true *}
{if $page->body} ... {/if}

{* right *}
{if !$page->body->empty()} ... {/if}

Page has typed properties for its structural keys (uuid, view, published, access, hidden, locked, created, updated) which are plain strings, ints (created, updated, as Unix timestamps) or bools. Everything else, title included, is a FieldValue. See Fields.

Filters

|render

Passes a FieldValue through its render template, checked in order: the view's own site/views/{view}/{name}.field.latte, the container's render of this entry beside its definition (site/fields/{container}/{name}.field.latte, for an entry of a stack, repeater or object), the field's render for that view beside its definition (site/fields/{name}/render.{view}.latte, a nested view with dots: render.docs.api.latte), the field's render.latte (site/fields/{name}/render.latte), and its type's render.latte (phlat/fieldtypes/{type}/render.latte, or site/fieldtypes/@phlat/{type}/render.latte to override a core type). With none, it falls back to the decoded value. The template receives $field, $value (the decoded value), $page and $request. An array after the filter adds variables: {$page->code|render: [theme: 'dracula']} gives the template $theme.

|ago, |bytes, |date

{$page->created|ago}                {* "3 days ago" *}
{$file->size|bytes}                 {* "1.2 MiB" *}
{$page->created|date}               {* "4 Jan 2026"; default format is j M Y *}
{$page->created|date:'Y-m-d'}       {* "2026-01-04" *}
{$timestamp|date}                  {* an int is read as a Unix timestamp *}

Functions

Available in every template without controller wiring:

Function Returns
config($key, $default) A config value, dot notation
p($uri) The page at $uri, or the current page with no argument
find($query) Pages matching a registry query, from the root
option($key) The visitor's value of a declared option, or its default. A cached render is kept per value
addon($id, $key, $default) An addon's setting from its addons.{id} config entry
collection($field) The collection behind a field, for get($uuid) and queries
source($name) The raw contents of a template file
session($key) A value from the site session
permission($key) True if the logged-in user has the permission
highlight($code, $language, $theme) Highlighted code as a <pre> element, in any language the code field offers and any Phiki theme
nonce() The request's CSP nonce
isPartial() True for an HTMX request
isFragmentRequest() True when the URL has a :blockname suffix
fragmentUrl($name) The current page's URL for its :name block, keeping the query string
editing($field) True for a field inside the dash preview for a signed-in editor, which is when {edit} and n:edit mark it
isPreview() True when the page renders inside the dash's preview for a signed-in editor
placeholder($w, $h, $color) A static SVG data URI
icon($name, $class, $inline) An icon from the icons addon, drawn from its cached sprite; $class goes on the <svg>, inline: true returns the SVG itself
{foreach find('view=article, sort=-created, limit=4') as $article}
    <a href="{$article->url()}">{$article->title}</a>
{/foreach}

{icon('arrow-right', 'w-4 h-4 text-primary')}

Layouts and blocks

A child template declares a {layout} and fills its blocks; {include parent} inside a block pulls in the parent block's default content. See Views.

Includes

{include} pulls in a template. A bare name such as 'header.latte' is in your site's views/, and ./ or ../ is relative to the including file. It sees the including template's variables, and anything after the comma is added on top. Pass the names it needs explicitly anyway, so it doesn't depend on where it is included from. In particular $page is the page rendering the whole response, not the page the included template belongs to. See Views.

{include 'header.latte'}
{include 'ui/badge.latte', label: 'New'}

Loops and conditionals

{foreach $items as $i => $item}
    <li class="{if $iterator->first}first{/if}">{$i}: {$item->title}</li>
{/foreach}

{if $page->hidden}
    <span>Hidden</span>
{elseif !$page->published}
    <span>Unpublished</span>
{else}
    <span>Published</span>
{/if}

Inside {foreach}, $iterator has first, last, counter (1-based), counter0 (0-based), and odd/even.

Template variables

Every view gets $page. $app is not available.

HTMX

HTMX attributes go straight in templates. Mutating requests need no token: a POST, PUT, PATCH or DELETE that a browser sends from another origin is refused with a 403.

<form hx-post="{$page->url()}" hx-swap="outerHTML">
    ...
</form>

JavaScript

There is no client-side framework. Reach for HTMX first, then the hx-on: handlers and the data-attribute behaviors the ui addon already ships (filtering, selects). For anything else, keep the script in a site asset loaded with <script defer>, driven by data attributes with event delegation on document so handlers survive HTMX swaps:

<button type="button" data-toggle-target="#panel">Toggle</button>
<div id="panel" class="hidden">Content</div>
document.addEventListener('click', (e) => {
    const button = e.target.closest('[data-toggle-target]');
    if (button) document.querySelector(button.dataset.toggleTarget).classList.toggle('hidden');
});

When you need more

A block can be fetched on its own at a :blockname URL, and cached. See Routing and Caching.