Join our channel

Follow 3DCGHUB on Telegram for new resource drops, migration updates, and community notices.

Join Telegram

Safety & quality

Resources are manually reviewed before listing to improve quality and reduce obvious risks.

No account required
Engine Tools

easyCSV

Load external spreadsheet data at runtime with easyCSV. Discover how plain text files convert into engine types using Blueprint and C++ from string methods.

Categories: Unreal Engine, Engine ToolsPublished Nov 21, 2026
DownloadFree Download

Get this resource

Compatibility

  • Unreal Engine 4.26 - 5.6
  • Asset Version4.26.2 - 5.6.2025.06.28
Format
.7z
File size
9.7 MB

Ready to download

Resource archiveeasyCSV.7z
View details

Technical specifications

CategoryEngine Tools
Engine & PlatformUnreal Engine 4.26 - 5.6
Asset Version4.26.2 - 5.6.2025.06.28
Package Format.7z
File Size9.7 MB
Download AccessFree Download
PublishedNov 21, 2026
Resource overview

Handling External Plain Text for Game Objects and Save Data

Modern games and applications deal with substantial volumes of data. Managing attributes, balances, entity configurations, and player progression directly within engine windows is not always ideal. External spreadsheets provide an accessible format for editing, inspecting, and organizing this information outside of the application build. A simple plain text file organized into rows and columns allows developers and designers to adjust values rapidly without having to open the project workspace or rebuild compiled assets.

This plain text approach works well across several distinct data categories. Character statistics, equipment metrics, dialogue keys, and interactive object properties can all live in an external sheet. Outside editors make it straightforward to compare parallel data rows, calculate statistical curves, and balance numbers across an entire roster of entities. Beyond initial game properties, plain text files also serve as an intuitive medium for storing save data. Writing save records out to plain text or reading them back into an active session makes progression files inspectable, straightforward to back up, and simple to manage externally.

Bringing that external data into the engine requires an active communication line between the file system and running gameplay code. While plain text spreadsheets are easy to edit, the application needs a method to pull those text streams into internal memory so gameplay systems can read what has been written.

String Retrieval at Runtime with easyCSV

The standard development workflow inside the engine provides native Data Tables. These built-in tables allow developers to import and export structured records using CSV files alongside other supported formats. That standard import and export behavior is strictly an offline toolset. Native Data Table importing functions when working in the editor, but it is not available when in-game. Once a build is running or an active play session begins, standard engine Data Tables cannot ingest external CSV files on demand.

This is where easyCSV alters the workflow. Instead of being restricted to pre-play asset compilation, easyCSV enables projects to retrieve data in a string format at any time. When a project needs to read an external table during active execution, easyCSV loads the raw plain text from the file system directly into the game session. The runtime availability of this data ensures that files modified on disk after compilation can still supply updated information to the running application.

Because easyCSV returns data in a string format, it avoids rigid schema constraints during the initial read. The plugin does not require immediate, predefined asset mappings to access the text. It exposes the raw contents of the CSV file as string data, handing that information directly to your code logic whenever the game demands an update.

Converting Data via Blueprint and C++ from String Methods in easyCSV

Once easyCSV retrieves data as a string, that text must be parsed into the specific data types required by your gameplay systems. The engine provides dedicated “from string” conversion methods across both visual scripting and native C++. By routing the strings extracted by easyCSV through these conversion routines, developers can transform basic text into actionable variables.

Blueprint scripting offers native conversion nodes that take a string input and turn it into standard types such as integers, floats, booleans, names, text blocks, and vector values. In C++, equivalent string conversion functions parse characters into primitives, enumerations, or custom struct fields. Because easyCSV supplies the underlying string data at runtime, you can pass individual cells or entries directly into these conversion methods to populate your gameplay objects on the fly.

Handling conversions through explicit Blueprint nodes or C++ routines provides complete authority over edge cases and fallback logic. If an external spreadsheet contains unexpected formatting, missing values, or modified column orders, your implementation logic can validate the string before applying the converted result to an object. This separation of concerns ensures that the retrieval of the file remains lightweight, while the interpretation of the data conforms strictly to the validation rules written in your project's code.

Contrasting easyCSV with Runtime DataTable and GSheets Operator

Selecting the right external data tool depends on the level of automation and connectivity a project requires. The ecosystem includes three distinct solutions intended for handling external tabular information: easyCSV, Runtime DataTable, and GSheets Operator. Each targets a specific stage of external data processing.

The role of easyCSV is driven by simplicity and control. It brings data into the engine as a string at any point during gameplay, leaving the type conversion to your own Blueprint or C++ “from string” calls. This makes it ideal for setups where you want direct access to the raw text without overhead, enabling custom parsing pipelines for specific gameplay needs.

Runtime DataTable takes a different approach by automating data reconstruction. If your project needs to convert a CSV into your game's data types automatically at runtime without manually hooking up individual string conversion methods, Runtime DataTable handles that process directly. Runtime DataTable also supports two-way data flows that easyCSV does not manage natively: exporting a local CSV file directly from your game's internal data, and downloading spreadsheet data dynamically from a public Google Sheet. While easyCSV relies on local files and manual conversion logic, Runtime DataTable automates type mapping and network fetching.

GSheets Operator forms the third entry in this comparison, providing another alternative for projects oriented around cloud-based spreadsheet integration. Understanding the differences among these three options ensures that you choose the plugin matched to your technical requirements, whether you require low-level string access through easyCSV, automated type mapping and export through Runtime DataTable, or online sheet integration.

Runtime Code Integration and Implementation Workflows

Operating under the Code and Table categorization, easyCSV fits neatly into modular programming architectures. Because its primary deliverable is string data, you can build modular data loaders that isolate file reading from gameplay execution. A single loader actor or subsystem can invoke easyCSV to read character balancing sheets upon entering a level, parse the resulting strings through Blueprint or C++ functions, and assign the values to active characters without restarting the game.

This setup also supports user-generated content and modding workflows. Because the plugin reads plain text files from disk at runtime, players or external testers can tweak configuration files in standard spreadsheet software. When the game launches or reloads a scene, easyCSV pulls the updated plain text, converts the fields using the established “from string” functions, and applies the changes instantly. The game gains the flexibility of data-driven tuning without requiring users to install the engine editor or understand internal asset cooking pipelines.

By maintaining a clean bridge between raw external plain text files and internal type conversion methods, easyCSV provides an uncomplicated, runtime-ready mechanism for driving game variables from spreadsheets whenever the application is running.

Explore Similar Assets