Why WPML and WordPress Full Site Editing Are a Bad Match (For Now)

Introduction

WordPress’s Full Site Editing (FSE) promised a new era of block-based design for entire sites, and WPML has long been the go-to plugin for multilingual websites. In theory, using WPML with an FSE (block-based) theme should allow a fully translated, fully editable site. In practice, my experience has
been far from smooth. After working on a bilingual FSE project with WPML, I found so many issues that
I’ll avoid this combination until significant improvements arrive. This is a personal opinion piece,
reflecting my own experiences and why I believe WPML and FSE are not a good combination at the moment.

(Note: I worked with manual translations only – duplicating content and using the Block Editor for text. I did not attempt WPML’s automatic translation, and given the issues I encountered, I’m reluctant to touch that at all.)

The Promise of Full Site Editing

Before diving into the problems, it’s worth acknowledging what FSE does well. When it works properly,
Full Site Editing brings genuinely exciting possibilities to WordPress development. The system
dramatically reduces the need for additional plugins since so much functionality is built into the core
block system. You can create rich, interactive layouts without reaching for numerous plugins for many common use cases.

One of the most compelling aspects of FSE (for me) is its hybrid approach to development. You can create ACF block templates (not to be confused with template blocks) that give you the best of both worlds – the developer control of custom fields with the visual editing power of blocks. This approach allows developers to build structured, maintainable components while still giving content editors the flexibility they crave.

Coming from the traditional way of building a WordPress website, the learning curve for FSE is admittedly steep, but once you understand the mental model of blocks, templates, and patterns, content creation becomes genuinely enjoyable. Many developers appreciate the pattern system for creating reusable design components, and while I personally don’t use patterns extensively, I can see how they streamline workflows for teams that embrace them. The visual editing experience, when functioning correctly, feels modern and intuitive in ways that traditional PHP templating never could.

Challenges of Translating Block-Based Content with WPML

Using WPML on a block-based (FSE) theme quickly revealed friction in the translation workflow.

WPML’s Translation Editor Feels Outdated: When translating FSE content, WPML doesn’t integrate seamlessly with the block editor. Instead, it opens content in its own editor UI (the Translation Editor). In my case, this interface was horrible to use – it exposed raw shortcodes or HTML comments for blocks, even showing “ancient” CSS classes and markup that should have been behind-the-scenes. This made translating block content confusing and error-prone. It certainly didn’t feel like a modern Block Editor editing experience. The alternative is switching languages in the top admin bar and using the Block Editor directly to translate content, but this creates its own workflow complications.

Initial Translation vs. Ongoing Changes: I noticed that WPML seems to “lock in” the content structure at the time of initial content creation. After creating translations—whether through the WPML Translation Editor or by using WPML’s duplication functionality and then editing the translation directly in the Block Editor—any subsequent structural changes I made to templates, template parts, or patterns in the primary language failed to reliably sync with their translated counterparts. WPML’s translation management would often still reflect the original layout from the first translation. Essentially, it seems to remember only the initial state of the content’s blocks. This leads to translations getting out of sync whenever the design is iterated on – a major headache in a dynamic development process.

Manual Updates Required: Because of the above, I found myself having to manually adjust the secondary language’s templates to mirror changes made in the primary language. The translation of templates, template parts, and patterns seems to offer two different approaches, and nobody really knows what the right way is or what sticks. You can work via Translation Management and then use the Translation Editor, or you can go to the Site Editor, but only after switching the language to the secondary language in the top admin bar, and then edit the template, template part, or pattern directly. With only one secondary language this already gets very confusing – I cannot imagine doing this for more than 3-4 languages and only with a handful of templates. The site I developed had more than 20 templates, so this becomes cumbersome at best!

In some cases, WPML’s interface didn’t even offer an easy way to update the translated template structure – I had to delete and re-translate templates or switch to the secondary language and edit the template directly in the Site Editor. This negates the convenience that FSE is supposed to bring. Notably, WPML’s own support has an Errata acknowledging that custom FSE templates might not apply correctly to translated pages without workarounds like deleting the translated template and tweaking settings – a sign that this is a known limitation. This errata dates from early March 2024, so although the WPML team might be working on a workaround, they don’t seem in a hurry (it’s July 2025 at the time of writing). This either means they don’t really grasp the issue (which could very well be a possibility) or their codebase is too complex and they simply cannot make it work.

The bottom line is that translating FSE content and templates is not a simple or smooth process with WPML right now. It involves a lot of babysitting and repeating work, which defeats the purpose of using a block-based visual editor in my opinion.

Case Study: A Broken Header in the Secondary Language

To illustrate how WPML and FSE can misfire, let me share a specific issue I ran into – the Header Template Part on a bilingual site:

The Symptom – Disappearing Markup: On a bilingual WordPress website, the header looked perfect in the primary language. But on the front-end of the secondary language, the header layout was completely broken. Crucially, some wrapper HTML elements and CSS classes were missing in the translated header. For example, a container div with a class like is-content-justification-space-between (used to space out header items) simply did not output in the secondary language. In the Site Editor preview, everything appeared normal for both languages, but the actual front-end output was different. This meant WPML’s handling of the translated header template part was dropping essential markup, resulting in misaligned header items.

Hasty Workaround – CSS Hacks: Initially, under pressure to fix the layout, I resorted to a CSS patch. I targeted specific page IDs and the remaining container classes to try and mimic the intended layout. For instance, I manually adjusted flexbox order of elements (Logo, Nav menu, CTA button, Search icon) and added margins/gaps to space them out properly. This CSS trickery did make the secondary header look correct in the end. However, it was an obviously brittle solution: it relied on hard-coded page IDs and auto-generated block class hashes, which is bad practice and likely to break if anything changed. In fact, anyone familiar with WPML knows that hardcoding on a per-language-basis is to be avoided – the hack felt dirty and unsustainable.

Root Cause – WPML Strips Non-Translatable Blocks: I dug deeper to find out why the translated header was missing pieces. It turned out that although WPML does render “empty” blocks (meaning purely structural Group/Container blocks for layout purposes, with no textual content) in the translated template part, WPML appears to silently skip (some of) those on the frontend in the secondary language. Maybe because it doesn’t consider them “translatable” content? This left a mismatch between the saved template and what was actually output – essentially breaking the markup structure. This confirmed my suspicion that WPML’s integration with block templates is unreliable, especially for blocks that don’t carry strings.

Potential Solutions – Bypassing FSE for the Header: Faced with this, several solutions present themselves for working around WPML’s handling of the block-based header altogether. One approach would be to replace the block-based header with a traditional PHP template include. Using a small snippet of code hooked into the render_block_core/template-part filter, you can intercept the rendering of the header template-part block and swap in a classic template file. In code, it would look like this:

add_filter('render_block_core/template-part', function($content, $block) {
  if (isset($block['attrs']['slug']) && $block['attrs']['slug'] === 'header') {
    ob_start();
    get_template_part('template-parts/header'); // serve a static header template
    return ob_get_clean();
  }
  return $content;
}, 10, 2);

What does this achieve? At runtime, instead of using the possibly broken translated block template, WordPress would output a predefined header template PHP file. You would create a custom template-parts/header.php that contains the HTML structure you want for the header. This completely bypasses the WPML+FSE translation quirk – the header gets rendered via PHP, so WPML isn’t involved in breaking those wrapper divs.

Handling Multiple Languages in the Header: To support languages, there are three approaches.

Option 1 (Cumbersome): Make separate header files (e.g., header-en.php and header-pt.php for English and Portuguese) and conditionally load the right one. Each file would have the text (like the call-to-action button label) hard-coded in the respective language. Obviously this is not sustainable for many languages plus it is not the way to build multilingual websites. I have included it only as a possible route.

Option 2 (Developer-Controlled): Create a single header.php template and use get_text function calls for all translatable strings. This approach leverages WordPress’s built-in internationalisation system, where you wrap text like _e('Contact Us', 'textdomain') and WPML can translate these strings through its standard String Translation interface. This method keeps the header structure unified while allowing clean translation of all text elements. However, any text changes will require developer involvement to update the strings in the code.

Option 3 (Client-Editable): Use one dynamic header.php with ACF (Advanced Custom Fields) Options for any text/images that need translation (like logo image URL, CTA button text, link URL, etc.). This way, the header structure is shared, only the content from ACF changes per language, and clients can update header text themselves without needing a developer.

Both Option 2 and Option 3 provide a cleaner, DRY(Don’t Repeat Yourself) approach. The result would be a fully working bilingual header that stays consistent across languages and does not rely on the Site Editor’s block template at all.
This feels ironic – having to revert to a classic PHP theme technique to solve an FSE problem – but it can be effective. It completely removes the risk of WPML messing up the header, and it allows the client to still use the Site Editor for other templates if needed (just not the header).

Takeaway: This header fiasco highlighted a broader point – WPML isn’t reliably handling block template parts. If a simple Group block can vanish in translation, other complex block structures might have issues too. Such workarounds might be the only way to get a truly consistent multilingual FSE site, which is not ideal.

Global Styles and Theme.json: One Style Fits All Languages

Block themes use a theme.json (code) and the FSE uses the Global Styles interface with wp_global_styles (database) to define site-wide styles (colours, typography, margins, etc.). Once someone clicks Save in Global Styles, WordPress writes that JSON blob to the DB and never re‑reads theme.json. And unlike anything else, this wp_global_styles does not get any revisions; instead it gets overwritten with every change. The real irritation is the split‑brain: your Git repo holds theme.json, but the live truth lives in the database.

In a multilingual context, one might expect different languages could have different style needs (for example, a different font for a language with non-Latin script, or adjustments for right-to-left languages such as Hebrew or Arabic). However, WPML does not provide a way to have separate Global Styles per language. WPML treats the Global Styles custom post type as a single entity, not something that needs translating or duplicating for each language. In fact, in the database I found only one wp_global_styles entry (with a single record in WPML’s language tables linking it to the primary language), and changes to global styles updated that one record. That in and by itself is also strange as FSE uses a revisions-galore for all other content, including templates.

From a developer’s standpoint that is awkward for version control; from a multilingual standpoint it means per‑language style variations are a manual chore.

In summary, the theme.json and Global Styles system is a brilliant idea on paper but in practice it introduced complexity and confusion in a multilingual setup. It contributed to my view that WPML + FSE equals too many moving parts (many of which hide in the database where I have less visibility).

Conclusion: A Personal Verdict on WPML + FSE

After wrestling with all the above, my verdict is that WPML and Full Site Editing do not play nicely (at least as of now). The combination amplified the challenges of each:

WPML made FSE’s weaknesses (like heavy DB reliance and incomplete block compatibility) more painful, as seen with broken template parts and clunky translation workflows.

FSE’s new paradigm exposed gaps in WPML’s ability to handle all types of content (e.g. missing wrappers, needing workarounds for template syncing, custom XML configs for certain blocks, etc.). Even WPML’s own support forums and errata pages document multiple FSE-related hiccups and patches, indicating the integration is still half-baked.

From a practical standpoint, working on a multilingual FSE project cost me far more time and headaches than a traditional PHP-based multilingual theme would have. I had to invent workaround solutions, abandon core features, and remain constantly vigilant that a change in one language didn’t silently wreck the other. The site’s database grew more complex with all the stored template and style data, which I find concerning for long-term maintainability.

For now, I would strongly caution anyone considering using WPML on a block-based theme. Unless you have a very simple site or are prepared for extensive troubleshooting, it may be wise to stick with a classic theme for multilingual projects. It’s possible that future WPML updates or WordPress core updates will alleviate these issues (the WPML team is likely working on better FSE support, given they acknowledge bugs and provide workarounds). But as of July 2025, based on my experience, WPML + FSE is a problematic pairing.

Ultimately, this is just my opinion from one project, but it’s strong enough that I will be avoiding the Full Site Editor on any larger WPML projects for the foreseeable future. I value my time and sanity as a developer, and until the tools catch up with each other, I prefer not to spend days debugging missing divs or wrestling with untranslated block quirks. Hopefully, sharing this perspective helps others anticipate the potential pitfalls – or at least encourages core and plugin developers to iron out these kinks soon.