Blog / September 6, 2023 / 4 mins read / By Suneet Agrawal

FString vs FName vs Text in Unreal

Unreal Engine, developed by Epic Games, is a popular game engine that powers many successful video games and interactive experiences. When working with Unreal Engine, you often encounter various data types for handling text and strings, including FString, FName, and Text. In this blog post, we’ll dive into these three text-related data types, explore their differences, and provide examples of when to use each one.


FString, short for Fixed String, is a dynamic string type used in Unreal Engine. It is similar to the standard C++ string (std::string) and is the most flexible option for handling text. Here are some key features and examples of FString usage:

Dynamic and mutable: You can change the contents of an FString after its creation.

FString MyString = "Hello, ";
MyString += "Unreal Engine!";

Ideal for text manipulation and formatting: FString is excellent for concatenation, manipulation, and formatting of text during runtime.

FString PlayerName = "John";
FString Greeting = FString::Printf(TEXT("Hello, %s!"), *PlayerName);

Performance considerations: FString has a small performance overhead compared to FName and Text due to its dynamic nature. Avoid excessive use in performance-critical code.


FName, short for Fixed Name, is a more specialized data type in Unreal Engine. It is primarily used to store and reference names, such as object names, property names, and asset names. Here’s why you might want to use FName:

Efficient memory usage: FName uses a global name table, which reduces memory overhead when storing the same name multiple times.

FName Firstname = FName(TEXT("John"));
FName SecondName = FName(TEXT("John"));

In this example, Firstname and SecondName both reference the same entry in the global name table, saving memory.

Ideal for identifying assets: When referencing assets like textures or materials, FName can be more efficient than FString or Text.

UTexture2D* MyTexture = LoadObject<UTexture2D>(nullptr, TEXT("TextureName"));

Not suitable for dynamic text: FName is immutable and not designed for dynamic text manipulation. Use FString or Text for such purposes.


Text is another text-related data type in Unreal Engine that’s particularly useful for localization and maintaining text in a human-readable format. Here are some key characteristics and use cases for Text:

Localization support: Text supports localization, making it easier to manage multiple languages and translations in your game.

FText MyLocalizedText = NSLOCTEXT("MyNamespace", "MyKey", "Hello World!");

Immutable and safe: Like FName, Text is immutable, which ensures that text remains consistent and unchanged during runtime.

Good for user-facing text: Use Text for displaying user interfaces, dialogues, or any text visible to players.

UTextBlock* TextElement = ...;

Slightly more memory overhead: Text has a slightly higher memory overhead than FName due to its localization support, but it’s still more memory-efficient than FString.

Differences between FString, FName, and Text

  • FString: Mutable and dynamic. You can change its contents after creation.
  • FName: Immutable. Once created, it cannot be modified.
  • Text: Immutable. Text objects are also unchangeable after creation.
Memory Overhead:
  • FString: Slightly higher memory overhead due to its dynamic nature.
  • FName: Low memory overhead, as it uses a global name table to reduce redundancy.
  • Text: Slightly higher memory overhead compared to FName, mainly due to localization support.
Use Cases:
  • FString: Ideal for dynamic text manipulation, formatting, and any situation where the text content may change during runtime.
  • FName: Best suited for storing and referencing names, particularly for objects, properties, and assets. Not suitable for dynamic text.
  • Text: Designed for user-facing text, localization, and maintaining human-readable text. Ideal for text displayed in the user interface, dialogues, and game content where localization is a concern.
  • FString: Has a performance cost associated with dynamic memory allocation and deallocation. Use it judiciously in performance-critical code.
  • FName: Offers excellent performance due to its low memory overhead and efficient name lookup.
  • Text: Performs well for user interface elements and localization. While it has some additional overhead compared to FName, it’s still an efficient choice for most scenarios.
Localization Support:
  • FString: No built-in support for localization. Text should be manually managed for localization.
  • FName: No built-in support for localization; typically used for internal references rather than user-facing text.
  • Text: Designed with localization in mind, making it a strong choice for managing text across different languages.


Understanding the differences between FString, FName, and Text in Unreal Engine is crucial for efficient game development. Each data type has its unique strengths and weaknesses, making them suitable for specific use cases. To summarize:

Use FString for dynamic text manipulation and formatting. Use FName for efficient storage of names and references to assets or objects. Use Text for user-facing text, localization, and maintaining human-readable text in a standardized way. By choosing the right data type for the job, you can optimize memory usage and improve the overall performance and maintainability of your Unreal Engine project.