@████████ please take a look at the marked answer and let me know if it works for you!

I am going to be upgrading to Forms 11 Update 5 soon and will try this. Right now we are on update 4.

Just to clarfy what Matthew mentioned.

Laserfiche 11 has 2 forms Designers: Classic and Modern Designer. The Google translate configuration as Matthew describes works great under LF 11, just use the classic designer.

@████████ Can you take a look at my answer detailed here and let me know if it would work for you and these municipalities? If not I would be interested to pick your brain about the use cases and what a solution would look like.

This won't work on custom HTML if that is what you are asking.  I just had to create an English and Spanish version for all my custom HTMLs and show/hide based on the language selected.  I only have two languages though, so it would be a lot if you have more.  

Values are not translated with this setup.  All the fields get translated up front like in Blake's video.  If you need to make changes, add or delete fields you will have to adjust the JS manually or rerun the API translation.  

Default values don't translate either.  Its essentially tabs, heading, field names, text below fields, and pagination.

No I might have missed that one too. if you add 

placeholder: 'placeholder,

Like the others it should work

This also appears to need to be added.
  error

Should error be in basicTranslatableFieldSettings or otherTranslatableFieldSettings?

Hi Alex, this does still work, what version are you on?

Well I had my agent make a fix. I tested it doesn't regress but I don't know if it will work for your large form. There is a function `getTranslation` replace the one function with the following two functions:

/**
* Splits text into chunks for translation while preserving gap information.
* @param {string} text - The long string to split.
* @param {number} limit - Character limit (5000 is recommended).
* @returns {Array} Array with alternating chunks and gaps between them.
*/
function splitForTranslate(text, limit = 5e3) {
	const words = text.split(/(\s+)/);
	const chunks = [];
	let currentChunk = "";
	words.forEach((word) => {
		if (currentChunk.length + word.length > limit && currentChunk.length > 0) {
			chunks.push(currentChunk);
			currentChunk = word;
		} else currentChunk += word;
	});
	if (currentChunk.length > 0) chunks.push(currentChunk);
	return chunks;
}
/**
* Asynchronously translates text to the target language using Google Translate API and returns a Promise.
* If translation fails, the original text is returned as a fallback.
* @param {string} text - The text to translate.
* @param {string} targetLang - The target language code (e.g., 'en', 'es').
* @param {number} splitTextCharacterLimit - Character limit for splitting text (default is 5000).
* @returns {Promise<string>} A Promise that resolves to the translated text, or the original text if translation fails.
* @description Translate text to target language. This should be removed from your code when a static translation is saved to the translations variable.
*/
async function getTranslation(text, targetLang, splitTextCharacterLimit = 5e3) {
	const sourceLang = defaultFormLang;
	const url = `https://translation.googleapis.com/language/translate/v2?key=${GOOGLE_TRANSLATE_API_KEY}`;
	const charLimit = splitTextCharacterLimit > 5e3 || splitTextCharacterLimit <= 0 ? 5e3 : splitTextCharacterLimit;
	const textToTranslate = text.length > charLimit ? splitForTranslate(text, charLimit) : [text];
	try {
		return (await Promise.all(textToTranslate.map((chunk) => {
			const translateChunk = async (retryCount = 0) => {
				try {
					const data = await (await fetch(url, {
						method: "POST",
						headers: { "Content-Type": "application/json" },
						body: JSON.stringify({
							q: chunk,
							source: sourceLang,
							target: targetLang
						})
					})).json();
					if (!data || !data.data || !data.data.translations || !data.data.translations[0]) throw new Error("Translation API did not return expected data");
					return data.data.translations[0].translatedText;
				} catch (error) {
					if (retryCount >= 3) {
						console.error(`Failed to translate chunk after 3 retries:`, error);
						throw new Error("Failed to translate chunk");
					}
					console.error(`Error translating chunk (retry ${retryCount}):`, error);
					const delay = 1e3 * Math.pow(2, retryCount);
					return new Promise((resolve, reject) => {
						setTimeout(() => {
							translateChunk(retryCount + 1).then(resolve).catch(reject);
						}, delay);
					});
				}
			};
			return translateChunk();
		}))).join("");
	} catch (error) {
		console.error("Translation failed:", error);
		return text;
	}
}

THIS WORKED LIKE A CHARM!!!!  You just made my life (and the lives of my 82K customers MUCH BETTER! :)

Awesome! Sounds like I need to publish a v3 of this to consolidate all of the smaller fixes I've made across this page