> For the complete documentation index, see [llms.txt](https://docs.atlas.design/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.atlas.design/atlas-ai-studio-overview/node-index/utility-nodes.md). # Utility Nodes 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.
## Common pitfalls * **Using a generation node when a utility node would do.** If you just need to combine text strings or extract images from a PDF, the utility nodes are deterministic and free of model variability. Reaching for an LLM call when string concatenation suffices wastes credits and introduces non-determinism. * **Mismatched array sizes.** Several utility nodes (Break Images Array, Concatenate Image Arrays) work on fixed-size or specific-shape arrays. Combine these with mismatched inputs and the workflow silently drops elements. Always verify expected sizes match. * **Forgetting that small models can't handle complex JSON schemas.** Structured Output Node enforces schema compliance, but the underlying LLM has to be capable of producing the schema. Use larger models for nested or complex schemas; small models for flat, simple shapes. * **Mixing horizontal and vertical concatenation styles.** Concatenate Images scales to match the first image's dimension on the perpendicular axis. If your inputs have wildly different aspect ratios, the output may distort. Pre-normalize sizes upstream when needed. ## Related nodes * [Input Nodes](/atlas-ai-studio-overview/node-index/input-nodes.md) — the source nodes whose content utility nodes typically transform. * [Image Nodes](/atlas-ai-studio-overview/node-index/image-nodes.md) — generation and editing targets for utility-prepared content. * [Mesh Nodes](/atlas-ai-studio-overview/node-index/mesh-nodes.md) — many utility nodes feed mesh workflows (e.g., Split Character Sheet → Multi-View to 3D). * [API Nodes](/atlas-ai-studio-overview/node-index/api-nodes.md) — for exposing utility-orchestrated workflows as external APIs. ## Frequently asked questions **Can I use utility nodes without any generation nodes in the workflow?** Yes. A workflow can be pure utility: extract text from a PDF, run LLM transformations, output structured JSON. No image or mesh generation required. Useful for document-processing pipelines and metadata extraction. **Does Text Generation (LLM) count against my generation credits?** LLM calls consume credits according to the model and token count. The exact pricing for each utility node is in the Atlas pricing reference. Small-model utility calls are typically much cheaper than image or 3D generation. **How do I combine outputs from multiple LLM calls into one prompt?** Use Combine Text to merge multiple text streams into a single prompt. The order of arguments to Combine Text determines the order in the final string, so put fixed instructions first and dynamic content second. **Can the Structured Output Node guarantee schema compliance?** The node enforces JSON schema validation on the LLM output. Small models are blocked from complex schemas to prevent silent failures, and the node returns an error rather than malformed JSON if the model cannot satisfy the schema. For production-critical structured outputs, use larger models and design schemas conservatively. **What happens if I pass an empty list to Break Images Array?** The node outputs nothing on its image ports. Downstream nodes connected to those ports will not execute, which can leave parts of your workflow idle. Validate input list size upstream when this matters. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.atlas.design/atlas-ai-studio-overview/node-index/utility-nodes.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.