This adds a Language dropdown to every Registration Template so staff can pick which language that template's registrations should render in.

1. Go to Admin Tools > System Settings > Entity Attributes
2. Filter to Entity Type: Registration Template
3. Add a new Single-Select attribute:
   • Key: Language
   • Values: en,es (add more language codes as needed)
   • Default Value: en
   • Mark it Required

This is the engine. The shortcode pulls translation pairs from your Defined Type and outputs a script that does the swapping.

1. Go to Admin Tools > CMS Configuration > Lava Shortcodes
2. Create a new shortcode with these settings:
   • Name: Translate
   • Tag Name: translate
   • Tag Type: Inline
   • Enabled Lava Commands: RockEntity
3. Add two parameters:
   • language - default value: es (or whatever your primary target language is)
   • scope - default value: body (CSS selector for what part of the page to translate)
4. Paste this into the shortcode markup, change 123 to your Defined Type Id:

{% assign language = language | Default:'en' %}
{% assign scope = scope | Default:'body' %}

{% definedvalue where:'DefinedTypeId == 123 && Description == "{{ language }}"' securityenabled:'false' sort:'Order' iterator:'translationValues' %}
    {% if translationValues != empty %}
<script>
(function() {
    var rockTranslationPairs = [
            {% for translationEntry in translationValues %}
                {% assign translatedText = translationEntry | Attribute:'TranslatedText' %}
                {% if translatedText != '' %}
        { english: {{ translationEntry.Value | ToJSON }}, translated: {{ translatedText | ToJSON }} },
                {% endif %}
            {% endfor %}
    ];

    var translationScope = document.querySelector('{{ scope }}');
    if (!translationScope) return;

    var compiledPatterns = rockTranslationPairs.map(function(pair) {
        var escapedEnglish = pair.english.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
        return {
            pattern: new RegExp('\\b' + escapedEnglish + '\\b', 'g'),
            translated: pair.translated
        };
    });

    var translationPending = false;

    function translateTextNodes() {
        var treeWalker = document.createTreeWalker(translationScope, NodeFilter.SHOW_TEXT);
        var currentNode;

        while (currentNode = treeWalker.nextNode()) {
            var originalText = currentNode.textContent;
            var translatedNodeText = originalText;

            for (var i = 0; i < compiledPatterns.length; i++) {
                compiledPatterns[i].pattern.lastIndex = 0;
                translatedNodeText = translatedNodeText.replace(
                    compiledPatterns[i].pattern,
                    compiledPatterns[i].translated
                );
            }

            if (translatedNodeText !== originalText) {
                currentNode.textContent = translatedNodeText;
            }
        }

        translationScope.querySelectorAll('button, .btn, [type="submit"]').forEach(function(buttonElement) {
            var buttonText = buttonElement.textContent.trim();
            for (var i = 0; i < rockTranslationPairs.length; i++) {
                if (rockTranslationPairs[i].english === buttonText) {
                    buttonElement.textContent = rockTranslationPairs[i].translated;
                    break;
                }
            }
        });

        var placeholderElements = translationScope.querySelectorAll('input[placeholder], textarea[placeholder]');
        placeholderElements.forEach(function(inputElement) {
            var placeholderText = inputElement.getAttribute('placeholder');
            for (var i = 0; i < rockTranslationPairs.length; i++) {
                if (rockTranslationPairs[i].english === placeholderText) {
                    inputElement.setAttribute('placeholder', rockTranslationPairs[i].translated);
                    break;
                }
            }
        });
    }

    function scheduleTranslation() {
        if (translationPending) return;
        translationPending = true;
        requestAnimationFrame(function() {
            translateTextNodes();
            translationPending = false;
        });
    }

    document.addEventListener('DOMContentLoaded', translateTextNodes);
    new MutationObserver(scheduleTranslation).observe(translationScope, { childList: true, subtree: true });
})();
</script>
    {% endif %}
{% enddefinedvalue %}

This gives your staff a clean UI to toggle the language on a Registration Template without digging into settings.

1. Navigate to your Event Registration page (usually Page Id 403)
2. In the Main zone, add a new block between Registration Template Detail and Registration Instance List
3. Block Type: Entity Attribute Values
4. Name it something like Registration Template Attribute Values
5. Set Entity Type to Registration Template

Now when staff view a Registration Template, they'll see the Language dropdown right there. Flip it to es and every registration under that template gets translated.

This is the glue. The Pre-HTML on the registration block figures out which Registration Template is in play, checks the Language attribute, and calls the shortcode if it's not English.

1. Go to the page that has your Registration Entry block (the actual registration form page)
2. Open the block settings and find the Pre-HTML field
3. Paste this in:

{% assign registrationInstanceId = 'Global' | PageParameter:'RegistrationInstanceId' | Default:'0' | AsInteger %}
{% assign registrationId = 'Global' | PageParameter:'RegistrationId' | Default:'0' | AsInteger %}
{% assign slug = 'Global' | PageParameter:'slug' | Default:'' | SanitizeSql %}
{% assign thisRegistration = null %}

{% if registrationId > 0 %}
    {% registration id:'{{ registrationId }}' securityenabled:'false' %}
        {% assign thisRegistration = registrationItems | First | Property:'RegistrationInstance' %}
    {% endregistration %}
{% endif %}

{% if thisRegistration == null and slug != '' %}
    {% eventitemoccurrencegroupmap where:'UrlSlug == "{{ slug }}"' iterator:'Mappings' securityenabled:'false' %}
        {% assign mapping = Mappings | First %}
        {% if mapping %}
            {% if mapping.Group.Name and mapping.Group.Name != '' %}
                {{ mapping.Group.Name | SetPageTitle }}
            {% endif %}
            {% assign registrationInstanceId = mapping.RegistrationInstanceId %}
        {% endif %}
    {% endeventitemoccurrencegroupmap %}
{% endif %}

{% if thisRegistration == null and registrationInstanceId > 0 %}
    {% registrationinstance id:'{{ registrationInstanceId }}' securityenabled:'false' %}
        {% assign thisRegistration = registrationinstanceItems | First %}
    {% endregistrationinstance %}
{% endif %}

{% assign registrationTemplateId = thisRegistration.RegistrationTemplateId %}

{% registrationtemplate id:'{{ registrationTemplateId }}' securityenabled:'false' %}
    {% assign thisTemplate = registrationtemplateItems | First %}
{% endregistrationtemplate %}

{% assign templateLanguage = thisTemplate | Attribute:'Language','RawValue' | Downcase | Default:'' %}
{% if templateLanguage != '' and templateLanguage != 'en' %}
    {[ translate language:'{{ templateLanguage }}' ]}
{% endif %}

This approach skips the page-by-page flag entirely. The toggle lives in the header and is active on every page. Visitors can switch languages from anywhere on the site and their preference carries across every page they visit.

This is more setup upfront, you'll want a solid library of translation pairs covering all your common site text, not just registration fields, but it's simpler to manage once it's running since there's nothing to toggle per page.

The Zone Lava

Drop this into your site header zone. There's no page attribute to check, it runs on every page.

{%- assign langCookie = 'site-language' | ReadCookie -%}
{%- if langCookie == 'es' -%}
    {[ translate language:'es' ]}
    <a href="#" class="btn btn-sm btn-outline-light no-grow ml-2 js-lang-toggle" data-lang="en">English</a>
{%- else -%}
    <a href="#" class="btn btn-sm btn-outline-light no-grow ml-2 js-lang-toggle" data-lang="es">Español</a>
{%- endif -%}
{% javascript %}
    document.addEventListener('click', function(e) {
        var toggle = e.target.closest('.js-lang-toggle');
        if (!toggle) return;
        e.preventDefault();
        var lang = toggle.getAttribute('data-lang');
        document.cookie = 'site-language=' + lang + '; path=/; max-age=' + (lang === 'es' ? 60 * 60 * 24 * 30 : -1);
        window.location.reload();
    });
{% endjavascript %}

How It Works

• On every page load, Lava reads the site-language cookie directly, no page attribute check needed.
• If the cookie is es, the translate shortcode fires site-wide and the toggle shows an English button. If the cookie is absent, only the Español button renders.
• The cookie and reload behavior are identical to Approach A. The only difference is that this code has no conditional wrapper, it always outputs something, on every page.
• Because translation runs everywhere, make sure your Defined Type has pairs for all the shared site text you care about (navigation labels, footer text, common headings, etc.) not just registration-specific phrases.