Georgy's Tech Blog

How to automate your Unreal Engine localization workflow with AI

Thu, 18 Sep 2025 00:00:00 +0000

Game localization has traditionally been a time-consuming and expensive process. Manual translation work often requires weeks of coordination with external services. AI language models now provide developers with powerful tools to streamline this workflow while they maintain quality and reduce costs.

This guide demonstrates how to set up automated AI-powered translation for your Unreal Engine project using the AI Localization Automator plugin . The plugin turns hours of manual work into minutes of automated processing.

Improve multi-line editable text box keyboard and gamepad navigations

Tue, 24 Dec 2024 00:00:00 +0000

Introduction

Still, as of UE 5.5, multi-line editable text boxes lack proper keyboard and gamepad navigation support. Let’s fix this without modifying the engine’s source code. I’ll experiment with a simple 2x2 grid of text boxes to demonstrate how we can implement smooth, unified navigation across both keyboard and gamepad input devices, which you can also recreate for testing purposes.

Current Limitations

Keyboard

Arrow keys only allow navigation within the content of a single text box, and there’s no way to navigate between text boxes themselves.

Simulating spdlog in Unreal Engine

Wed, 25 Sep 2024 00:00:00 +0000

Need to use third-party libraries that depend on spdlog in your Unreal project? Here’s how to simulate the spdlog API using Unreal’s native UE_LOG system, to let you avoid adding extra dependencies while keeping your code clean.

We’ll create a logging utility class that matches the spdlog interface, handling type conversions to FString and formatting along the way.

Implementation

Here’s the code that bridges spdlog and Unreal’s logging system:

#pragma once

#include "Containers/UnrealString.h"
#include "Internationalization/Text.h"
#include "Templates/EnableIf.h"
#include "Templates/IsIntegral.h"
#include "Templates/IsFloatingPoint.h"
#include "Logging/LogMacros.h"
#include <string>

DEFINE_LOG_CATEGORY_STATIC(LogPiperLibrary, Log, All);

/**
 * Class to simulate the spdlog API in Unreal Engine
 * spdlog is used in the original piper 
 */
class spdlog
{
private:
	// Template function for integral types
	template <typename T, typename TEnableIf<TIsIntegral<T>::Value, bool>::Type = 0>
	static FString ToFString(T value)
	{
		// Most integral types won't be larger than signed 64-bit integer
		// TODO: Add support for larger integral types supported by UE (uint64)
		return FString::Printf(TEXT("%lld"), static_cast<int64>(value));
	}

	// Template function for floating-point types
	template <typename T, typename TEnableIf<TIsFloatingPoint<T>::Value, bool>::Type = 0>
	static FString ToFString(T value)
	{
		return FString::Printf(TEXT("%f"), static_cast<double>(value));
	}

	// Specialize for FString
	static FString ToFString(const FString& Value)
	{
		return Value;
	}

	// Specialize for std::string
	static FString ToFString(const std::string& Value)
	{
		return StringCast<TCHAR>(Value.c_str(), Value.size()).Get();
	}

	// Convert the format string to UTF-16 for Unreal Engine
	static FText ConvertFormatString(const char* FormatString)
	{
		// Convert the format string to FText
		return FText::FromString(StringCast<TCHAR>(FormatString).Get());
	}

	// Convert a single argument to FFormatArgumentValue
	template <typename T>
	static FFormatArgumentValue ToFormatArgumentValue(const T& value)
	{
		return FFormatArgumentValue(FText::FromString(ToFString(value)));
	}

	// Specialize for FString
	static FFormatArgumentValue ToFormatArgumentValue(const FString& value)
	{
		return FFormatArgumentValue(FText::FromString(value));
	}

	// Specialize for std::string
	static FFormatArgumentValue ToFormatArgumentValue(const std::string& value)
	{
		return FFormatArgumentValue(FText::FromString(StringCast<TCHAR>(value.c_str(), value.size()).Get()));
	}

	/**
	 * Replace {} placeholders with {0}, {1}, etc
	 * This is necessary because FText::Format does not support {} placeholders
	 * @param FormatString The format string to convert
	 * @return The converted format string
	 */
	static FString ConvertBracedFormatString(const FString& FormatString)
	{
		FString ConvertedFormatString = FormatString;
		int32 PlaceholderIndex = 0;

		while (ConvertedFormatString.Contains(TEXT("{}")))
		{
			FStringBuilderBase Builder;
			Builder = ConvertedFormatString;
			Builder.ReplaceAt(ConvertedFormatString.Find(TEXT("{}")), 2,
			                  FString::Printf(TEXT("{%d}"), PlaceholderIndex++));
			ConvertedFormatString = Builder.ToString();
		}

		return ConvertedFormatString;
	}

	// Format log message with provided arguments
	template <typename... Args>
	static FString FormatLogMessage(const char* FormatString, Args... args)
	{
		// Convert the format string to FText and replace placeholders
		FText FormatText = ConvertFormatString(FormatString);
		FText ConvertedFormatText = FText::FromString(ConvertBracedFormatString(FormatText.ToString()));

		// Create an array to hold the arguments for formatting
		TArray<FFormatArgumentValue> FormatArgs;
		(FormatArgs.Add(ToFormatArgumentValue(args)), ...);

		// Use FText to format the string with arguments
		FText FormattedText = FText::Format(ConvertedFormatText, FormatArgs);
		return FormattedText.ToString();
	}

public:
	//~ Functions for simulating the spdlog API
	template <typename... Args>
	static void error(const char* FormatString, Args... args)
	{
		FString LogMessage = FormatLogMessage(FormatString, args...);
		UE_LOG(LogPiperLibrary, Error, TEXT("%s"), *LogMessage);
	}

	template <typename... Args>
	static void warn(const char* FormatString, Args... args)
	{
		FString LogMessage = FormatLogMessage(FormatString, args...);
		UE_LOG(LogPiperLibrary, Warning, TEXT("%s"), *LogMessage);
	}

	template <typename... Args>
	static void debug(const char* FormatString, Args... args)
	{
		FString LogMessage = FormatLogMessage(FormatString, args...);
		UE_LOG(LogPiperLibrary, Log, TEXT("%s"), *LogMessage);
	}

	template <typename... Args>
	static void info(const char* FormatString, Args... args)
	{
		FString LogMessage = FormatLogMessage(FormatString, args...);
		UE_LOG(LogPiperLibrary, Log, TEXT("%s"), *LogMessage);
	}

	// @formatter:off

	// Dummy functionality to simulate the spdlog API
	struct level { constexpr static bool debug = false; };
	static bool should_log(bool) { return true; }
	// Add more functions as needed

	// @formatter:on
};

Usage

The class lets you use familiar spdlog calls like spdlog::info, spdlog::debug, spdlog::warn, and spdlog::error in your code. Behind the scenes, it routes everything through Unreal’s logging system, so you can avoid adding the spdlog dependency to your project.

How to focus a Common UI button (UCommonButtonBase) in Unreal Engine

Tue, 27 Aug 2024 00:00:00 +0000

As of UE 5.4, the Common UI button (UCommonButtonBase) still doesn’t support direct focus settings. This is because UCommonButtonBase is derived from UUserWidget, which supports focusing, but doesn’t direct the focus to the underlying button itself automatically. However, you can still set the focus on the button by performing a “deep” focus on the Slate button. Here’s how you can achieve this:

/**
 * Sets the focus on the button
 * This function performs the "deep" focus on the Common UI button, which means that it will set the focus on the button itself
 * This is useful since UCommonButtonBase is derived from UUserWidget, which doesn't support focus when setting it directly
 */
UFUNCTION(BlueprintCallable, Category = "mod.io|UI|Button", DisplayName = "Set Button Focus (Common UI)")
void SetCommonUIButtonFocus()
{
#if UE_VERSION_OLDER_THAN(5, 3, 0)
	if (bIsFocusable)
#else
	if (IsFocusable())
#endif
	{
		if (TSharedPtr<SButton> SlateButton = GetSlateButton())
		{
			if (SlateButton->SupportsKeyboardFocus())
			{
				FSlateApplication::Get().SetKeyboardFocus(SlateButton, EFocusCause::Mouse);
				UE_LOG(LogTemp, Log, TEXT("Set focus on button '%s' (extended way)"), *GetName());
			}
			else
			{
				UE_LOG(LogTemp, Warning, TEXT("Trying to set focus on button '%s' but the button does not support keyboard focus"), *GetName());
			}
		}
		else
		{
			UE_LOG(LogTemp, Warning, TEXT("Trying to set focus on button '%s' but the slate button could not be found"), *GetName());
		}
	}
	else
	{
		UE_LOG(LogTemp, Warning, TEXT("Trying to set focus on button '%s' but the button is not focusable"), *GetName());
	}
}

/**
 * Gets the Slate button widget
 * The button is highly encapsulated and this function tries to scan the widget tree to find the button
 * @return The Slate button widget if found, nullptr otherwise
 */
TSharedPtr<SButton> GetSlateButton() const
{
	if (WidgetTree && WidgetTree->RootWidget)
	{
		if (UButton* InternalButton = Cast<UButton>(WidgetTree->RootWidget))
		{
			// UCommonButtonInternalBase::RebuildWidget() creates a SBox wrapper for the button
			if (TSharedPtr<SBox> BoxButtonWrapper =	StaticCastSharedPtr<SBox>(TSharedPtr<SWidget>(InternalButton->GetCachedWidget())))
			{
				if (BoxButtonWrapper->GetChildren() && BoxButtonWrapper->GetChildren()->Num() > 0)
				{
					if (TSharedPtr<SButton> InternalButtonSlate = StaticCastSharedPtr<SButton>(TSharedPtr<SWidget>(BoxButtonWrapper->GetChildren()->GetChildAt(0))))
					{
						return InternalButtonSlate;
					}
				}
			}
			// UButton::RebuildWidget() returns the button directly
			else if (TSharedPtr<SButton> InternalButtonSlate = StaticCastSharedPtr<SButton>(InternalButton->GetCachedWidget()))
			{
				return InternalButtonSlate;
			}
			else
			{
				UE_LOG(LogTemp, Error, TEXT("Could not find the Slate button widget for button '%s'"), *GetName());
			}
		}
	}
	return nullptr;
}

How to get the currently focused widget in Unreal Engine

Sat, 23 Mar 2024 00:00:00 +0000

In Unreal Engine, you can determine the currently focused widget in both Slate and UMG UI systems.

Slate

To get the currently focused Slate widget, you can use the following code snippet:

// Instead of 0, you can pass the user index if you have multiple users
TSharedPtr<SWidget> FocusedSlateWidget = FSlateApplication::Get().GetUserFocusedWidget(0);

UMG

Getting the currently focused UMG widget is a bit more involved, since there is no direct function to get it or the place where it is stored. However, you can iterate over all UMG widgets and compare their cached Slate widgets to the focused one. This approach is not recommended for performance-critical code, but it can be useful for debugging or testing purposes. Here is an example function that does this:

How to execute code on scope exit in Unreal Engine

Sat, 02 Mar 2024 00:00:00 +0000

If you want to execute some code when the scope is exited, you can use the following handy ON_SCOPE_EXIT macro, like this:

int32 AnyFunction()
{
    ON_SCOPE_EXIT
    {
        // This code will be executed when the scope is exited (after the return statement)
    };

    // Do smth
    
    // Just return 100 for example
    return 100;
}

How to save and restore any value with RAII approach in Unreal Engine

Sun, 25 Feb 2024 00:00:00 +0000

Imagine you’re in a situation where you need to save and restore a value. For instance, let’s say you have a UMG widget that you want to hide temporarily, do some stuff, and then bring back its previous visibility state, all within a single function. The most straightforward approach might be to store the value in a temporary variable, modify it, and then revert it back, like this:

ESlateVisibility VisibilityState;

const ESlateVisibility PreviousVisibility = VisibilityState;
VisibilityState = ESlateVisibility::Hidden;

// Do smth. VisibilityState is Hidden here

// Restore the previous visibility state
VisibilityState = PreviousVisibility;

This method gets the job done, but it’s not very scalable. What if you need to manage multiple values? What if there are several exit points in your function? What if multiple functions require saving and restoring the same value? Duplicating this rather verbose code everywhere is not ideal. We can do it better.

How to cast Slate widgets in Unreal Engine

Sat, 21 Oct 2023 00:00:00 +0000

This brief article addresses the question of how to cast one Slate widget to another in Unreal Engine. Imagine you have an SWidget widget wrapped in a shared pointer like this:

TSharedPtr<SWidget> MyWidgetPtr;

If you want to cast it, for example, to an SSpacer, your code might look like this:

TSharedPtr<SSpacer> MySpacerPtr = StaticCastSharedPtr<SSpacer>(MyWidgetPtr);

It’s important to keep in mind that you should verify whether the shared pointer is valid before using it.

The same approach works for shared references:

How to set a timer for the next tick in Unreal Engine

Fri, 15 Sep 2023 00:00:00 +0000

In Unreal Engine, it is possible to set a delay for the function to execute after a single tick, which is sometimes useful when working with UMG/Slate side of things where the widget properties are only available after a complete rebuild, such as obtaining the desired size of the widget’s geometry, which is often not accessible right after initializing or constructing the widget. In such cases, you may want to implement a delay, as described in this article , but sometimes even a single tick delay is sufficient and can enhance the overall user experience, preventing visual hitches and abrupt interactions.

Efficient HTTP file download by chunks in Unreal Engine C++

Sun, 21 May 2023 00:00:00 +0000

Chunk downloading is a technique used to retrieve large binary data from the server in separate parts, ensuring reliability and compatibility across different platforms. Unreal Engine’s HTTP module has a limitation of 2GB for binary HTTP response content due to internal restrictions (specifically, TArray<uint8> uses the int32 size type, which has a maximum value of 2,147,483,647, approximately 2 GB in our case). To overcome this limitation, we can use the Range HTTP header supported by most servers, without requiring any file preparation or segmentation.

How to save UObject that is represented as an asset in Unreal Engine

Sun, 05 Feb 2023 00:00:00 +0000

You can save any UObject that is represented as an asset within a UPackage using this method:

bool SaveToAsset(UObject* ObjectToSave)
{
	UPackage* Package = ObjectToSave->GetPackage();
	const FString PackageName = Package->GetName();
	const FString PackageFileName = FPackageName::LongPackageNameToFilename(PackageName, FPackageName::GetAssetPackageExtension());

	FSavePackageArgs SaveArgs;
	
	// This is specified just for example
	{
		SaveArgs.TopLevelFlags = RF_Public | RF_Standalone;
		SaveArgs.SaveFlags = SAVE_NoError;
	}
	
	const bool bSucceeded = UPackage::SavePackage(Package, nullptr, *PackageFileName, SaveArgs);

	if (!bSucceeded)
	{
		UE_LOG(LogTemp, Error, TEXT("Package '%s' wasn't saved!"), *PackageName)
		return false;
	}

	UE_LOG(LogTemp, Warning, TEXT("Package '%s' was successfully saved"), *PackageName)
	return true;
}

How to use variant in Unreal Engine

Fri, 30 Dec 2022 00:00:00 +0000

There is a std::variant class template in the standard library that is essentially a type-safe union. It is generally used when we are not sure in advance which object should be populated from our list of object types, so we assume that one of the specified objects must be there at a time.

How to use mutex in Unreal Engine

Wed, 21 Dec 2022 00:00:00 +0000

Unreal Engine has an alternative implementation of std::mutex called FCriticalSection which makes it possible for your data to be safely accessed from different threads, preventing race conditions. This takes the same approach, handling it with one thread locking until the other thread completes the necessary operations.

There are two ways to handle lock/unlock logic.

The first is low-level, which is used to directly lock and unlock threads. Use with caution due to possible deadlocks . Just use FCriticalSection::Lock and FCriticalSection::Unlock functions where needed to follow this way.

How to properly work with UObjects in background threads (GC)

Wed, 30 Nov 2022 00:00:00 +0000

This article addresses the question of how to work with UObjects in a thread-safe way when dealing with workers, async tasks, thread pools, or whatever else using a non-game thread.

One critical issue to address is the handling of garbage collection. When passing an UObject, which is not set to root, directly to a background thread, there’s a risk that the garbage collector may silently delete the passed UObject. Even frequent validity checks of the UObject (e.g. IsValidLowLevel()) on a background thread cannot guarantee the object’s survival even moments after the check.

How to pass a variable by reference in C++ function called in Blueprints

Sun, 14 Aug 2022 00:00:00 +0000

By default, when a non-const reference is specified in a function, it will be treated by Blueprints as an output parameter:

Show/hide content

UFUNCTION(BlueprintCallable)
static void RemoveDots(FString& String)
{
	String.ReplaceInline(TEXT("."), TEXT(" "));
}

How to use async task in Unreal Engine

Sun, 31 Jul 2022 00:00:00 +0000

Unreal Engine has a useful feature called AsyncTask that allows you to execute code asynchronously via Task Graph system. It functions by running specific code on a specified thread and is primarily used when the task is too heavy to be executed instantly without blocking the game thread.

AsyncTask(ENamedThreads::AnyThread, []()
{
	// This code will run asynchronously, without freezing the game thread
});

You can also create nested calls to asynchronous tasks, for example:

How to create a multi-threaded for loop in Unreal Engine

Sat, 23 Jul 2022 00:00:00 +0000

Unreal Engine has different approaches to parallelize your code and one of them is ParallelFor. It is used when it is necessary to execute code multiple times with different number-based inputs, basically what a regular for loop does. But unlike a regular for loop that executes sequentially, ParallelFor runs on different threads, with possible different order of execution.

Let’s say our task is to simply sum the values from the TArray<int32> array. It’s easiest to do this:

How to use delays in C++ in Unreal Engine

Sun, 03 Jul 2022 00:00:00 +0000

Some developers are wondering about the C++ equivalent of the Delay node in Blueprints.

There are two ways to implement Delay that are very similar. Use the option that is more readable and convenient for you.

Lambas

Using FTimerDelegate

FTimerDelegate TimerDelegate;
TimerDelegate.BindLambda([&]
{
	UE_LOG(LogTemp, Warning, TEXT("This text will appear in the console 3 seconds after execution"));
});

FTimerHandle TimerHandle;
GetWorld()->GetTimerManager().SetTimer(TimerHandle, TimerDelegate, 3, false);

Using FTimerHandle only

FTimerHandle TimerHandle;
GetWorld()->GetTimerManager().SetTimer(TimerHandle, [&]()
{
	UE_LOG(LogTemp, Warning, TEXT("This text will appear in the console 3 seconds after execution"));
}, 3, false);

Separate functions

The second way is to use a delay to execute another function.

How to completely disable Tonemapper in Unreal Engine

Sun, 26 Jun 2022 00:00:00 +0000

In this quick tutorial, I will show you how to completely disable Tonemapper without using PostProcess

To do this, just open the DefaultEngine.ini file (in the [PROJECT_NAME]/Config folder) and add the following lines to [/Script/Engine.RendererSettings] section:

r.TonemapperGamma = 0
r.TonemapperFilm = 0
r.Tonemapper.Quality = 0
r.ToneCurveAmount = 0
r.Mobile.TonemapperFilm = 0
r.MobileTonemapperUpscale = 0
r.EyeAdaptationQuality = 0
r.EyeAdaptation.ExponentialTransitionDistance = 0

You can also write the same to the engine’s command line, but I recommend to directly add these lines to a file since it’s more convenient and will always work.

Reducing build size of Android or iOS game in Unreal Engine

Sun, 12 Jun 2022 00:00:00 +0000

There are multiple ways to reduce the build size. But on mobile platforms, this issue is most acute. I will show you how I managed to reduce the size of my Android game from 150MB to 50MB.

Project settings

There are many switches in the project settings that will help reduce the build size.

The first thing you can do is set Build Configuration to Shipping and enable For distribution:

Intro to Unreal Engine containers (TArray, TSet, TMap)

Sun, 05 Jun 2022 00:00:00 +0000

This article may be helpful for those who are familiar with standard containers and would like to learn Unreal-specific ones, or for those who already have a knowledge of the containers but would like to explore them a little deeper.

Here is information about the following containers: TArray, TSet, TMap, and a basic overview of the TMultiMap and TSortedMap.

TArray

Let’s start with TArray. TArray is a dynamically sized array, similar to std::vector in the standard library.

How to convert Enum to FString in Unreal Engine

Sun, 29 May 2022 00:00:00 +0000

This is a short article on how to convert an enumerator to FString in Unreal Engine.

Blueprints

In Blueprints, it is easy to convert all supported enumerators to FString. Simply drag your enumerator to the required pin, which will automatically add the necessary conversion node.

How to integrate third-party library into Unreal Engine

Fri, 27 May 2022 00:00:00 +0000

Concept

There are two main types of libraries: Static and Dynamic (also called Shared).

A static library is statically linked to a program and is available at compile time.
A dynamic (or shared) library, on the other hand, is dynamically linked and available at runtime.

Static linking assumes that the library code is built into the final block of code, unlike dynamic linking. But the process of dynamic linking takes some time.
It follows that the static library is faster, but the dynamic library takes up less memory.

My first post

Thu, 26 May 2022 00:00:00 +0000

Hey! This is my first post with the idea of this blog. I previously had a blog at https://unreal.blog , but I decided to rethink this and create a new one.

Here I will primarily write about technical stuff related to C++ and Unreal Engine.

I’ll be writing on both simple and complex topics.

I also plan to write some more general, non-technical posts, but this won’t be posted often.

Mon, 01 Jan 0001 00:00:00 +0000