FSE (block theme)

FSE (Full Site Editing) is a set of WordPress capabilities that allows you to edit not only the content of a post, but also the entire website structure using blocks: header, footer, loop, sidebar, navigation, page templates, and template parts.

In modern versions of WordPress, the term Site Editor—site editor—is used more often. And the theme that supports this mode is called a block theme.

A block theme is a theme where templates are described not by PHP files, but by HTML files with block markup.

The main site editor page in the WordPress admin

Contents:

What a block theme consists of
How a page template is loaded
What happens when editing a template
How the HTML is rendered
The role of theme.json
FSE and classic PHP
What changed compared to a classic theme
Summary

What a block theme consists of

At a minimum, a block theme must have a file index.html in the /templates folder (or the older /block-templates folder).

Usually, the structure looks like this:

theme/
│
├─ parts/          - template parts: header, footer, sidebar, etc.
│  ├─ header.html
│  ├─ footer.html
│  └─ sidebar.html
│
├─ patterns/       - block patterns.
│  └─ *.php
│
├─ styles/         - variations of global styles.
│  └─ *.json
│
├─ templates/     - main page templates.
│  ├─ index.html
│  ├─ front-page.html
│  ├─ home.html
│  ├─ single.html
│  ├─ page.html
│  ├─ archive.html
│  └─ 404.html
│
├─ theme.json      - global settings and styles: palette, layout, etc.
├─ style.css       - theme metadata and base styles.
└─ functions.php   - PHP theme logic, if needed.

Files from /templates correspond to the regular WordPress theme file hierarchy, only instead of .php they use .html.

Files from /parts are reusable template parts. They are connected via the core/template-part block:

<!-- wp:template-part {"slug":"header","tagName":"header"} /-->

To determine in the code whether a theme is a block theme, there is the function: wp_is_block_theme()

How a page template is loaded

When a request comes in, after WordPress has loaded the environment and prepared the main request:

The file wp-includes/template-loader.php is called (until FSE everything worked the same).
It determines the type of the current page and calls the corresponding function:
- get_front_page_template()
- get_home_template()
- get_404_template()
- ...each of these functions is based on:
  - get_query_template()
    - locate_block_template()
      - resolve_block_template()
      - wp-includes/template-canvas.php
```
$template = 'wp-includes/template-canvas.php'; // simplified
$template = apply_filters( 'template_include', $template );
do_action( 'wp_before_include_template', $template );
include $template;
```
  Then the entire page is created via get_the_block_template_html() and output inside <body>.

In other words:

WordPress determines the appropriate template using the standard theme file hierarchy.
For a block theme, it looks not for .php, but for .html templates in the templates folder, for example templates/front-page.html. HTML files must be named the same as the PHP files in the classic template hierarchy.
If a template was changed in the site editor, WordPress may take it not from the theme file, but from the database (wp_template). For template parts, wp_template_part is used.
The template content is read as text and parsed as a set of blocks.
Template parts are connected from parts, for example header and footer via the core/template-part block.
theme.json is applied: colors, spacing, fonts, layout, block styles, CSS variables.
WordPress generates the final styles and adds them to the page through the global styles system.
The assembled page is output via a single template file: wp-includes/template-canvas.php.

Essentially, FSE is block-based templating on top of the classic WordPress PHP core.

What happens when editing a template

The source templates are located in the theme folder templates/. When the template is changed via the site editor, WP does not modify the theme file; instead, it saves the changes in the database in post types:

wp_template - for templates.
wp_template_part - for template parts.

Therefore, the site may use a mixture at the same time:

template files from the theme;
modified templates from the database.

If a user resets the template in the editor, the original theme file will be used again.

How the HTML is rendered

A block theme template is not обычный HTML. It is HTML with block comments:

<!-- wp:template-part {"slug":"header","tagName":"header"} /-->

<!-- wp:group {"layout":{"type":"constrained"}} -->
<div class="wp-block-group">
	<!-- wp:post-title /-->
	<!-- wp:post-content /-->
</div>
<!-- /wp:group -->

<!-- wp:template-part {"slug":"footer","tagName":"footer"} /-->

WordPress parses the blocks from such text and renders them.

Simplified, the process is like this:

WordPress finds the appropriate template.
It gets its content from the theme file (or from the database).
Parses the HTML blocks (including template-part).
Renders the blocks.
Assembles styles from theme.json, settings, and block styles.
Outputs the finished page via wp-includes/template-canvas.php.

Dynamic blocks are rendered on the server. For example core/post-title, core/post-content, core/query, core/navigation, and other blocks receive data from WordPress during page output.

The role of theme.json

theme.json is the theme configuration file. It describes which settings are available in the editor and which styles are applied to the site and blocks.

For more details about it and all of its parameters, read in a separate article.

Important: theme.json is not the template itself. It does not define the page structure. The structure is in /templates and /parts, while theme.json controls settings and styles.

FSE and classic PHP

FSE does not completely eliminate PHP templates.

PHP is still needed for:

hooks and filters;
registering blocks;
dynamic blocks;
connecting scripts and styles;
custom theme logic;
integration with plugins;
changing data before output.

But the main page markup in a block theme is now stored not in PHP, but in HTML templates with blocks.

What changed compared to a classic theme

In a classic theme, markup is assembled using PHP templates:

├─ front-page.php
├─ home.php
├─ single.php
├─ page.php
├─ archive.php
├─ header.php
└─ footer.php

In a block theme, instead of PHP markup, HTML templates with blocks are used:

├─ templates/
│  ├─ front-page.html
│  ├─ home.html
│  ├─ single.html
│  ├─ page.html
│  └─ archive.html
│
└─ parts/
   ├─ header.html
   └─ footer.html

So, it is not the entire WordPress architecture that changes, but the theme layer:

classic theme: PHP template → HTML page
block theme:   HTML template with blocks → block parsing → HTML page

At the same time, WordPress remains a PHP application. Requests, WP_Query, hooks, filters, plugins, and server-side block rendering continue to work as usual.

Summary

FSE is block-based website templating on top of the classic WordPress PHP core.

The main idea is as follows:

The WordPress PHP core processes the request.
The template hierarchy selects the appropriate template.
The block theme provides a .html template with blocks.
WordPress parses and renders blocks.
theme.json sets configurations and styles.
The site editor lets you change templates and styles from the admin area.

That is, FSE moves website structure control out of PHP files into the block system—in the editor in the admin area—but does not replace the WordPress core and server-side rendering.