Utility Nodes
Utility nodes in Atlas AI Studio extract, transform, and recombine text, images, PDFs, and metadata for deterministic, reusable game asset workflows.
Utility Nodes provide general-purpose functions that support all Atlas workflows. They are not tied to image or mesh generation; instead, they handle documents, text processing, arrays, and lightweight LLM operations.
Utility Nodes are essential for orchestrating complex workflows, preparing inputs, and structuring data for generation nodes.
When to use utility nodes
Use utility nodes to glue the rest of your workflow together. The most common patterns:
Document-driven content generation. Use Extract Text From Document and Extract Images From Document to pull material out of a GDD or art bible, then feed the extracted content into generation nodes via Combine Text or directly.
Multi-step LLM reasoning. Chain Text Generation (LLM) nodes with Combine Text to build conditional prompts where one step's output becomes the next step's instruction. Powerful for "describe → reformat → generate" pipelines.
Batch operations. Use Create Images List, Create Text List, and Create Number List to build arrays that downstream generation nodes process in parallel, then Break * List to route outputs to specific branches.
Character sheet workflows. Pair Split Character Sheet with Multi-View to 3D for converting a multi-angle drawing into a rigged 3D character in one workflow.
Structured output for game logic. Use Structured Output Node to extract typed JSON (NPC stats, loot tables, dialogue metadata) from LLM responses, ready for direct consumption by game systems.
Document Nodes
Extract Images From Document
This node processes an uploaded PDF document and extracts all images embedded within it.
Input: PDF file (e.g., a Game Design Document)
Output: Image Array
Each extracted image is returned as an element in the array.
You can use the resulting array with:
Find Images by Description node to pull specific images
Image Generation nodes that accept image arrays
Break Images Array to isolate specific images
Extract Text From Document
Extracts text content from a PDF file and separates it into three categories:
Visual Descriptions — descriptions of scenes, objects, characters
Relevant Other Text — supporting information that may assist generation
Filtered / Irrelevant Text — removed noise, metadata, or non-useful content
This separation is useful when you want to feed only contextually relevant text into your generation nodes or LLM prompts.
Split Character Sheet
Detects and extracts individual views—such as front, side, and back—from a single character design sheet.
Automatically parses a design sheet to isolate different character poses into separate image outputs.
Works best with horizontal, vertical, or grid layouts where poses are clearly separated by empty space.
Outputs: Specific views for Front, Right, Left, and Back, plus an array of any "Other" detected angles (like 3/4 views).
Ideal for: Preparing character sheets for the Multi-View -> 3D node or organizing concept art.
Text & LLM Nodes
Combine Text
Merges multiple text inputs into one unified string.
Helps combine text blocks before sending them into generation nodes
Useful when you want to enforce a fixed prefix or order (e.g., system constraints + extracted text → final generation prompt)
Typical use case:
Merge a “generation instruction” with extracted document text
Feed the combined result into an image or 3D generation node
Text Generation (LLM)
LLM tool for controlled text generation.
Inputs:
System Prompt — defines the agent’s role and behavior
Text Input — any context or content to transform
Output: Single text result
Example use case:
You can input a concept art image and use Describe Image to extract the existing character list. A Text Generation (LLM) can then be instructed to return only the first character from that list. You may add an additional text input that defines how the multimodal node should isolate the selected character for 3D modeling. Using Combine Text, you merge the LLM-generated character description with your isolation instruction and feed the combined text directly into the multimodal node. This creates a controlled, image-conditioned prompt for generating a clean extraction of a single character ready for modeling.
Another example is providing an image of a full scene and using Describe Image to obtain a structured description of its spatial layout. You can then instruct the Text Generation (LLM) to act as a spatial-logic prompt generator that transforms these descriptions into a precise prompt for generating a 2D top-down plan of the same scene. By passing this prompt into a multimodal node, you obtain a clean plan abstraction. With this method, any input image produces a custom, image-specific plan prompt through the combined use of Describe Image, LLM processing, and Combine Text.
Simple Text Render
Generates a 2D image from a text string with automatic height adjustment to fit the content.
Allows for basic typography control, including font selection, size, line spacing, and color customization.
The output image width is fixed by the user, while the height scales dynamically based on how much text is provided.
Inputs: Input Text, Font Name (Arial/Nunito), Image Width, Font Size, and Background/Font Colors.
Ideal for: Creating labels, UI elements, or adding textual descriptions directly into your image processing pipeline.
Array Management Nodes
Concatenate Images
Combines multiple images into a single image file by joining them side-by-side or top-to-bottom.
In Horizontal mode, all images are automatically scaled to match the height of the first image in the array.
In Vertical mode, all images are scaled to match the width of the first image in the array to maintain a uniform column.
Inputs: Input Images (Array), Direction (Horizontal/Vertical).
Ideal for: Creating comparison grids, before-and-after montages, or reassembling split character sheets
Utility Nodes allow these types of modular logic chains ; extracting structured information, refining or transforming it, and recombining it to produce workflows that adapt automatically to the input image while remaining deterministic and reusable across the Atlas platform.
Structured Output Node
Generates JSON responses constrained to a user-defined schema, ensuring validated, parseable output for programmatic use. Small models are blocked from complex schemas to maintain reliability.
Accepts a JSON schema definition alongside a text prompt; the output strictly conforms to the schema structure.
Returns validated JSON suitable for direct parsing into game logic, asset metadata, or procedural generation parameters.
Schema enforcement prevents hallucinated fields or malformed data structures.
Inputs: Prompt (String), JSON Schema (Object), Model (Selector).
Outputs: Structured JSON (Object).
Useful for: Extracting NPC attributes from narrative descriptions, generating itemized loot tables, parsing scene composition data, or creating dialogue trees with typed metadata fields.
Extract PNG Metadata
Reads generation parameters, prompts, and model settings embedded in PNG files produced by image generation nodes, enabling prompt reuse and parameter inspection across workflows.
Extracts embedded metadata including the original prompt, seed, model identifiers, and generation parameters stored in PNG comment chunks.
Returns structured data fields that can be passed directly to other nodes for iterative refinement or batch reproduction.
Works with PNG files generated within Atlas or imported from compatible external tools that follow standard metadata conventions.
Displays specific error messages when metadata is missing or malformed, rather than silently failing.
Inputs: PNG Image (File).
Outputs: Prompt (String), Seed (Integer), Model (String), Parameters (Object).
Useful for: Reverse-engineering successful asset generation settings, building remix pipelines that preserve original prompts, debugging generation parameters, or creating variant workflows that iterate on existing images while maintaining audit trails.
Create PDF List
Combines multiple PDF inputs into a single ordered array for batch processing or sequential analysis workflows.
Accepts individual PDF file inputs and merges them into a unified list structure.
Preserves input order, enabling deterministic downstream operations on multi-document sets.
Outputs: PDF List (Array).
Inputs: PDF 1, PDF 2, PDF 3... (variable count, PDF files).
Useful for: Aggregating quest documentation before extraction, batching asset reference sheets for analysis, or organizing multi-chapter narrative PDFs for sequential dialogue parsing.
Create Text List
Assembles multiple text inputs into a single ordered list, enabling batch operations and multi-prompt workflows.
Accepts up to eight individual text inputs (Text 1 through Text 8); empty inputs are ignored.
Outputs a unified text array preserving input order for downstream nodes that process lists.
Inputs: Text 1–8 (String, optional).
Outputs: Text List (Array).
Enables parallel processing: combine asset names extracted from concept art with style descriptions to generate variations across multiple objects in one pass.
Useful for: Batch-generating sprite variants, assembling dialogue options for NPC responses, feeding multiple prompts into image generation arrays, or combining extracted metadata with templated instructions.
Break Text List
Splits a concatenated text list back into individual text outputs, reversing the operation performed by the Concatenate Text node. Each line or delimiter-separated segment becomes a discrete output port.
Accepts a single combined text input and separates it based on newline or custom delimiters.
Outputs multiple individual text strings, one per parsed segment.
Output port count matches the number of segments detected in the input list.
Inputs: Combined Text (String), Delimiter (String, optional).
Outputs: Text outputs (dynamic count based on input).
Preserves original segment order and whitespace handling per delimiter configuration.
Useful for: Unpacking batch-generated NPC names or dialogue lines, distributing localized strings to separate UI elements, splitting procedurally generated item descriptions, or routing individual quest objectives to distinct logic branches.
Break PDF List
Splits an array of PDF files into individual PDF outputs, enabling parallel processing or selective routing of multi-document collections.
Accepts a PDF List (Array) input and exposes each element as a separate PDF output port.
The number of output ports matches the array length; each port emits one PDF document in sequence.
Enables conditional logic, per-document transformation, or targeted extraction when combined with downstream nodes like Extract PDF Text or Convert PDF to Images.
Inputs: PDF List (Array).
Outputs: Individual PDF files, one per array element.
Useful for: Batch-processing narrative design documents, splitting multi-chapter story bibles for parallel text extraction, or isolating concept art pages for individual image analysis and asset tagging.
Create Number List
Combines individual number inputs into a single array for batch processing or iteration in downstream nodes.
Accepts up to eight separate number inputs (Number 1 through Number 8).
Outputs a unified number array containing all provided values in order.
Empty or unconnected inputs are omitted from the resulting list.
Inputs: Number 1–8 (Float/Integer).
Outputs: Number List (Array).
Useful for: Feeding parameter sets to image generators, defining animation keyframe timings, batching seed values for asset variations, or programmatically controlling multiple effect intensities in a single pipeline.
Create Image List
Combines multiple individual image inputs into a single ordered array, enabling batch operations and multi-image workflows. This node consolidates separate image connections into one unified list that downstream nodes can iterate over or process collectively.
Accepts any number of individual image inputs and outputs them as a single Image Array.
Input images retain their original resolution and format; no scaling or transformation is applied.
Output order matches the sequence of connected inputs from top to bottom.
Inputs: Image 1, Image 2, Image 3... (expandable).
Outputs: Image List (Array).
Essential for feeding multiple texture variations into batch processors, assembling reference sheets for style transfer, or preparing image sets for concatenation and comparison grids.
Concatenate Image Arrays
Merges multiple image array inputs into a single unified array, preserving order and enabling batch operations across collections from different sources.
Accepts two or more image array inputs and outputs a single flattened array containing all images in sequence.
Order is determined by input port order; images from the first connected array appear before those from subsequent arrays.
Does not modify, resize, or composite the images themselves—purely a collection merge operation.
Inputs: Image Array 1 (Array), Image Array 2 (Array), [additional array ports as needed].
Outputs: Merged Images (Array).
Useful for: Combining character variations from multiple generation passes, pooling environment assets before batch processing, assembling multi-source texture sets for style transfer, or consolidating prototype sprites for export.
Break Image List
Unpacks an image array into separate, individually accessible image outputs for downstream nodes that expect single images rather than collections.
Accepts an image array input and exposes each element as a discrete numbered output port (Image 1, Image 2, etc.).
Maximum output count matches the array length; empty slots remain inactive if the array is shorter than the node's port capacity.
Enables routing different images from a batch to different processing branches without iteration logic.
Inputs: Image List (Array).
Outputs: Image 1, Image 2, Image 3... (Individual Images).
Useful for: Applying distinct post-processing filters to each generated character variation, routing specific frames from a multi-frame generation to separate composition nodes, or feeding individual concept sketches into parallel refinement workflows.
EXR to 16-bit PNG
Converts an EXR image into a 16-bit PNG, preserving the extended tonal range of the source across a widely compatible file format.
Input. A single EXR file.
Output. A 16-bit PNG containing the converted image data.
Bit depth. Writes 16 bits per channel, retaining finer gradients than 8-bit output.
Format bridging. Moves high-dynamic-range renders into a format accepted by common engine and DCC import pipelines.
Typical use. Prepare rendered height maps, normal data, or lighting passes for engines that do not ingest EXR directly.
Useful for: converting HDR render outputs into engine-ready textures for terrain, lighting, and material workflows.
Example: Example use case for the EXR to 16-bit PNG node.
Common pitfalls
Using a Text Generation (LLM) call where string concatenation suffices. When a workflow only needs to join text with Combine Text, routing that text through Text Generation (LLM) introduces model variability into a step that could be deterministic, producing inconsistent output across runs.
Feeding shorter-than-expected arrays into Break Image List. Its output count matches the array length, so ports beyond the array size stay inactive. Downstream branches wired to those ports receive nothing and sit idle without an obvious error.
Concatenating images with mismatched aspect ratios. Concatenate Images scales inputs to the first image's height in Horizontal mode and to its width in Vertical mode. Inputs with very different proportions come out stretched or squashed; normalize sizes upstream when uniformity matters.
Expecting Split Character Sheet to parse any layout. It relies on empty space separating poses in horizontal, vertical, or grid arrangements. Overlapping or tightly packed views fail to isolate cleanly into the Front, Right, Left, Back, and Other outputs.
Related nodes
Input Nodes — the source nodes whose uploaded PDF and image content utility nodes transform.
Image Nodes — generation and editing targets for utility-prepared image arrays and concatenated grids.
Mesh Nodes — Split Character Sheet isolates individual character views for the Multi-View to 3D node.
API Nodes — for exposing utility-orchestrated workflows as external APIs.
Utility nodes form modular chains that extract structured information, transform it, and recombine it. Nodes such as Extract Text From Document, Text Generation (LLM), Combine Text, and Structured Output Node connect the input, image, and mesh stages listed above.
Frequently asked questions
Can I use utility nodes without any generation nodes in the workflow?
Yes. A workflow can be built entirely from utility nodes: extract text from a PDF with Extract Text From Document, transform it with Text Generation (LLM), and emit validated JSON with the Structured Output Node. No image or mesh generation is required, which makes utility-only chains suitable for document-processing pipelines and metadata extraction.
How do I combine outputs from multiple text sources into one prompt?
Use Combine Text to merge multiple text inputs into a single string. The input order determines the order in the final string, so place fixed instructions or system constraints first and dynamic content, such as extracted document text, afterward. This is a common way to enforce a fixed prefix before feeding a prompt into an image or 3D generation node.
Can the Structured Output Node guarantee schema compliance?
The Structured Output Node enforces the user-defined JSON schema on the model output and returns validated JSON that parses directly into game logic, asset metadata, or procedural generation parameters. Schema enforcement prevents hallucinated fields and malformed structures. Small models are blocked from complex schemas, and the node returns an error rather than malformed JSON when the model cannot satisfy the schema. For production-critical output, use larger models and design schemas conservatively.
How do I split a batch of images or text back into individual items?
Use Break Image List to unpack an image array into separate numbered image outputs, one port per array element, so different images can route to different processing branches. Use Break Text List to split a combined text input into discrete outputs by newline or a custom delimiter, preserving segment order. Break PDF List performs the equivalent operation for a PDF array.
How do I assemble multiple inputs into one array for batch processing?
Use Create Text List (up to eight text inputs), Create Number List (up to eight number inputs), Create Image List (expandable image inputs), or Create PDF List to build ordered arrays. Empty or unconnected inputs are omitted from text, number, and PDF lists. Concatenate Image Arrays merges two or more existing image arrays into one flattened array in input-port order without resizing or compositing.
Can I reuse the generation settings stored in a PNG?
Yes. Extract PNG Metadata reads the original prompt, seed, model identifier, and generation parameters embedded in PNG comment chunks by image generation nodes. The returned fields can be passed to other nodes for iterative refinement or batch reproduction. It works with PNGs generated within Atlas or imported from tools that follow standard metadata conventions.
How do I create a text-to-video or lipsync node from utility nodes?
Utility nodes do not perform video or lipsync generation themselves; they prepare and route content for the generation nodes documented in Image Nodes and Mesh Nodes. Utility nodes handle the surrounding steps such as text merging, list assembly, and metadata extraction.
How do I move an EXR render into an engine that does not accept EXR?
Use EXR to 16-bit PNG to convert an EXR file into a 16-bit-per-channel PNG, preserving finer tonal gradients than 8-bit output. This bridges high-dynamic-range renders such as height maps, normal data, and lighting passes into a format accepted by common engine and content-creation import pipelines.
Last updated