Utility Nodes

Introduction

Utility nodes handle workflow logic - combining text, grouping assets, conditional branching, looping, and post-processing. They connect generators and inputs into automated pipelines.

Tools

AI-powered:

• Background Removal

• Smart Object Eraser

• AI Upscale (up to 4x)

• Style Transfer

• Vectorize (convert raster images to vector format)

• Video to Image Sequence (extract individual frames from video clips)

Processing effects (16+):

• Color Grading with LUTs

• Padding Remover

• Film Grain

• Halation (light bloom)

• Bloom

• Vignette

• Chromatic Aberration

• Additional standard post-processing effects

Notes

• When a generation node connects to a Tools node, images are automatically converted to the required format.

• Each tool has its own parameter controls accessible in the settings panel.

• Effects can be chained: apply background removal, then upscale.

Prompt Builder

Combines multiple text inputs into a single text output using a template.

Inputs and Outputs

How It Works

The Prompt Builder has a template area where you arrange variable chips representing each connected text input. You control the order, add literal text between them, and include line breaks.

It also accepts an optional Instructions input. When connected, the Instructions text is embedded in the template alongside the variable chips.

Example:

• Text 1 (from LLM output): "A cheerful blonde woman wearing a blue polka-dot blouse..."

• Instructions (optional): "Additional user instructions"

• Template: [STYLE PROMPT GENERATOR - FIRST RESULT] Additional user instructions: [INSTRUCTIONS (OPTIONAL)]

• Output: The combined prompt string

Notes

• Add as many text inputs as needed.

• Character limits: ~1000–2000 per input, ~5000 combined (depends on downstream node).

• Useful for combining static templates with dynamic user inputs, LLM outputs, or variable content.

Split Text

Breaks a single text string into a list of items based on a delimiter. This node is designed specifically for use with the Loop node. It takes a single text block and divides it into a list. The output connects directly to the Loop node's input port.

Inputs and Outputs

Delimiter Options

The output shows a preview of split items as chips so you can verify the result before connecting downstream.

Primary Use Case

Split Text → Loop → Process each item individually. This pattern enables batch generation from a single text input.

Example: A text input with "sunset landscape, urban street, portrait photography" split by comma produces three items. Each item is then processed in a Loop, feeding into an Image Generator to produce one image per subject.

Group Items

Bundles multiple individual assets into a single collection. Use it to gather outputs from parallel generation branches, different sources, or uploaded assets into one group for batch operations or convenience.

Inputs and Outputs

How It Works

Add as many input slots as needed. Each slot accepts an asset. The node bundles them into one output collection.

Notes

• Items are ordered by input slot position.

• Combine with Slice Assets to extract subsets.

• Combine with Loop to process each item with the same downstream pipeline.

• Useful for organizing assets from parallel branches before applying consistent processing.

Slice Assets

Extracts a subset of items from a collection by index range.

Inputs and Outputs

Parameters

• From Item - Zero-based start index. 0 = first item.

• Number of Items - How many items to extract.

Examples

Collection of 10 items:

• From 0, Count 3 → items 0, 1, 2

• From 5, Count 3 → items 5, 6, 7

• From 9, Count 1 → item 9 (last item)

If the range exceeds the collection size, you get fewer items than requested (no error).

Notes

• Uses zero-based indexing. The first item is index 0, not 1.

• Use for batching: process large collections in chunks (e.g., 5 items at a time).

• Combine with Loop for paginated processing.

If-Else

Adds conditional branching to the workflow. Evaluates a condition and routes execution down different paths. This enables workflows that adapt based on content, user input, or data properties.

Inputs and Outputs

CEL (Common Expression Language)

Conditions are written in CEL. Supported operations:

String operations: string.contains(prompt, "landscape"), prompt.startsWith("A photo"), prompt.endsWith("4K")

Collection operations: length(assets) > 5, size(tags) == 0

Branching

You can chain multiple conditions:

1. If condition_1 → path A

2. Else If condition_2 → path B

3. Else If condition_3 → path C

4. Else → default path

Example

In the Game Scene Builder workflow, an If-Else node checks whether the user provided a prompt:

• IF PROMPT IS EMPTY → use a default text description

• ELSE → use the user's prompt

This allows the workflow to function with or without user input.

Notes

• CEL is case-sensitive.

• Always provide an else/default path to handle unexpected cases.

• Test conditions with simple expressions first, then add complexity.

Loop

The Loop node allows you to run a set of workflow nodes repeatedly over a list of inputs - such as images, text items, or assets. Instead of building separate workflows for each item, you define your processing logic once and let the Loop node handle the repetition automatically. If you have ever needed to apply the same generation, edit, or transformation to twenty images, the Loop node eliminates that manual work entirely.

How the Loop Node Works

At its core, the Loop node works like a "for-each" loop in code. You provide a list of inputs, and it passes each item through the internal nodes - one at a time - until the list is complete. Results are then collected and passed to the next part of your workflow.

The Loop node accepts two types of input:

• Images or Assets - Ideal for batch image processing, style application, and asset variation pipelines.

• Text Lists - Useful for generating content from multiple prompts, keywords, or names in sequence.

Setting Up a Loop Node

Four steps to get a Loop running:

1. Add the Loop Node - Drag it onto the canvas. It features a defined internal area where you place the nodes that should repeat.

2. Define Your Input List - Connect your source (Asset Library, Image Input, or Split Text node) to the Loop node's input port.

3. Build Internal Logic - Place your processing nodes (e.g., Image Generator, Edit, LLM) inside the Loop node's canvas area. Each item from your list will pass through this internal pipeline.

4. Connect the Output - The output port delivers the full collection of results to the next stage of your workflow, such as a Merge node or batch download.

Example

Split Text produces ["cat", "dog", "bird"]. A Loop processes each item through a Prompt Builder ("A photo of a [current item]") and Image Generator. Output: 3 images.

Practical Examples

• Batch Product Images - Connect twenty product photos to a Loop node. Inside, place a Background Removal node followed by an Edit with Prompts node for a consistent studio background.

• Prompt-Based Variations - Use a Split Text node with fifty character names. Inside the loop, an Image Generation node references the current loop item as part of the prompt to generate fifty unique portraits.

• Sprite Sheet Transformations - Apply the same color grading or style transfer to a full set of character sprites in a single run.

The Split Text Utility Node

The Split Text node is designed specifically for use with the Loop node. It takes a single text block and divides it (usually by line breaks) into a list. The output connects directly to the Loop node's input port. See the Split Text section above for delimiter options and details.

Loop Node and the API

In the Scenario API, the Loop node corresponds to the ForEach node. Use the List node to define your collection. Refer to the API documentation for full details.

Tips for Success

• Test Small - Start with 3–5 items to confirm your internal pipeline works before running a large batch.

• Keep it Lean - Simpler internal pipelines run faster and cost fewer credits.

• Document - Use Sticky Notes inside the Loop node's canvas to explain the logic to teammates.

• Use Slice Assets for large collections - Process in batches of 10–50 to manage resources.

• Keep loop bodies simple. Pre-filter or pre-process outside the loop when possible.

Sticky Note

Non-functional annotation node for documenting your workflow. Does not process or pass data.

Inputs and Outputs

None. Sticky Notes are documentation only.

Content

Plain text, multiline, up to ~5000 characters.

When to Use

• Explain the purpose of a workflow section

• Document parameter choices

• Record why a particular architecture was chosen

• Guide collaborators through the workflow

• Note version and date information

Common Patterns

Batch generation from a list: Text Input ("cat, dog, bird") → Split Text → Loop → Prompt Builder → Image Generator → one image per subject

Conditional routing: Generate → If-Else (evaluate a property) → Route to different processing paths

Dynamic prompts: User input + LLM output → Prompt Builder (combine with template) → Generator

Pagination: Large collection → Slice Assets (items 0–10) → Loop → Process → Repeat for next chunk

Multi-stage pipeline: LLM (analyze reference) → Prompt Builder → Image Generator → Tools (upscale) → Output

Troubleshooting

Split Text not splitting correctly? Verify delimiter matches your input format. Check for extra spaces.

Loop not processing expected items? Confirm the input collection is connected properly. Review error handling settings.

If-Else condition not triggering? Test CEL syntax in isolation. CEL is case-sensitive. Verify variable names match upstream nodes.

Slice Assets returning unexpected results? Remember zero-based indexing (first item = 0). Verify From + Number doesn't exceed collection size.