DataTable Streamliner

An Unreal Engine 5.7 editor plugin that generates DataTable assets from natural language descriptions using a local Ollama LLM. Describe the data you want in plain English, preview the results, and generate production-ready DataTable assets — no manual row entry required.

Case Study

Problem: DataTables are useful for game balancing and content authoring, but hand-entering rows is slow and error-prone. Generic LLM output also needs to match actual Unreal structs before it can safely become an asset.

What I built: DataTable Streamliner is an Unreal Engine editor plugin that converts natural-language data requests into previewable, schema-aware DataTable assets using a local Ollama model.

Architecture: The plugin connects to a local Ollama endpoint, parses generated JSON into either an AI-defined schema or an existing UScriptStruct/UserDefinedStruct, previews rows in a Slate UI, then creates or appends DataTable assets with conflict handling.

Technical depth: The project includes menu registration, persistent configuration, model fetching, local LLM parsing, struct discovery, schema/data validation, asset creation, append mode, duplicate-row conflict handling, and screenshot-documented editor workflows.

Proof: The README includes screenshots for the menu entry, data preview, generated assets, struct options, append/conflict dialog, and successful append flow.

Tradeoffs: The tool keeps generation local via Ollama so project schemas and content prompts do not leave the developer machine. The preview step remains mandatory because generated content should be reviewed before becoming a project asset.

Features

• Natural language to DataTable — Describe your data (e.g., "12 fantasy weapons with name, damage, weight, and rarity") and get a fully populated DataTable
• AI-defined or existing struct — Let the AI create a schema from your description, or select an existing UScriptStruct/UserDefinedStruct to match
• Append to existing DataTables — Add rows to an existing DataTable with automatic struct detection and conflict resolution
• Data preview — Review generated rows in a table preview before committing to an asset
• Conflict handling — When appending rows with duplicate names, choose to overwrite, generate as a separate asset, or cancel
• Local LLM via Ollama — Runs entirely on your machine. No API keys, no cloud, no data leaving your network
• Model picker — Browse and select from any model available in your local Ollama instance
• Persistent configuration — Endpoint, model, output path, and settings are saved between sessions

Screenshots

Feature	Preview
Tools Menu Entry
Data Preview
Generated Assets
Struct Options
Append & Conflict Dialog
Successful Append

Prerequisites

• Unreal Engine 5.7 (source or launcher build)
• Ollama installed and running locally — Download Ollama
• At least one language model pulled in Ollama

Setup

1. Install Ollama

Download and install Ollama from ollama.com. After installation, pull a model:

ollama pull llama3.2:3b-instruct-q3_k_m

Any instruction-tuned model that supports JSON output will work. Recommended models for this plugin:

Model	VRAM	Notes
llama3.2:3b-instruct-q3_k_m	~2 GB	Lightweight, good results
llama3.1:8b-instruct-q4_k_m	~5 GB	Better quality, slower
gemma2:9b-instruct-q4_k_m	~6 GB	Strong structured output

Make sure Ollama is running before using the plugin (it starts automatically on install, or run ollama serve).

2. Add the Plugin to Your Project

Option A — Copy into your project:

1. Copy the Plugins/DataTableStreamliner folder into your UE5 project's Plugins/ directory
2. Regenerate project files (right-click .uproject > Generate Visual Studio project files)
3. Build and open the project

Option B — Clone this repository:

git clone https://github.com/mboard8070/UE5_DataTableGenerator.git

Then open DataTableGenerator.uproject in Unreal Engine 5.7.

3. Enable the Plugin

The plugin should be enabled by default. If not:

1. Open your project in the Unreal Editor
2. Go to Edit > Plugins
3. Search for "DataTable Streamliner"
4. Check the Enabled box and restart the editor

4. Open the Tool

Go to Tools > DataTable Streamliner in the editor menu bar.

5. Configure the Connection

1. Set the Endpoint URL (default: http://localhost)
2. Set the Port (default: 11434)
3. Click Test Connection to verify Ollama is reachable
4. Click Fetch Models to populate the model dropdown, then select your model

6. Generate a DataTable

1. Type a description of the data you want (e.g., "10 medieval weapons with name, damage, weight, element type, and rarity")
2. Choose a struct mode:
   • [Let AI Define Schema] — the AI creates columns based on your description
   • Select an existing struct — the AI fills rows matching your struct's fields
3. Click Parse with LLM and wait for the response
4. Review the generated data in the preview table
5. Set the output path and table name
6. Click Generate DataTable to create the asset

7. Append to an Existing DataTable

1. Check Append to Existing DataTable
2. Enter the asset path of an existing DataTable (e.g., /Game/DataTables/DT_Weapons)
3. The plugin auto-detects the row struct and uses it for generation
4. Describe the new rows you want (e.g., "add 5 more unique weapons")
5. Parse and generate — new rows are appended to the existing table
6. If row name conflicts are detected, a dialog lets you Overwrite, Generate Separate, or Cancel

Project Structure

Plugins/DataTableStreamliner/
├── DataTableStreamliner.uplugin
└── Source/DataTableStreamliner/
    ├── DataTableStreamliner.Build.cs
    ├── Private/
    │   ├── DataTableAssetGenerator.cpp    # Asset creation & row population
    │   ├── DataTableLLMParser.cpp         # Ollama HTTP requests & JSON parsing
    │   ├── DataTableStreamlinerManager.cpp # Configuration persistence
    │   ├── DataTableStreamlinerModule.cpp  # Plugin module & menu registration
    │   └── SDataTableStreamlinerWidget.cpp # Slate UI
    └── Public/
        ├── DataTableAssetGenerator.h
        ├── DataTableColumnDefinition.h     # Schema types & parsed data structs
        ├── DataTableLLMParser.h
        ├── DataTableStreamlinerConfiguration.h
        ├── DataTableStreamlinerManager.h
        └── SDataTableStreamlinerWidget.h

Troubleshooting

• "Connection failed" — Make sure Ollama is running (ollama serve) and the endpoint/port are correct
• JSON parse errors — Smaller models may occasionally produce malformed JSON. The plugin includes sanitization, but if issues persist, try a larger model
• Timeouts — Large requests (many rows/columns) on small models can take a while. Reduce the number of rows or use a faster model
• Model not appearing — Click Fetch Models after ensuring Ollama is running. The dropdown refreshes with available models

License

MIT