Skip to main content
Below are all available node demos—please select one to try out.

LLM Node Demo

See a demonstration of the LLM node working within a graph workflow.

STT Node Demo

Try out Speech-to-Text node integration in a graph.

TTS Node Demo

Explore Text-to-Speech node usage in a sample graph.

Intent Node Demo

See how the Intent node processes and routes input data.

Safety Node Demo

Experiment with safety checks using the Safety node.

Custom Node Demo

Learn how to use and implement a custom node in the graph system.

Edge Demo

Inspect data flow in graphs by examining edges between nodes.

Edge Loop Demo

See how to create loops and iterative processes using edges.

Character Interaction Node Template

Experience a full conversation pipeline using node-based character interaction.

Character Interaction Node Template with JSON

Try the JSON-based character graph template for cross-platform sharing.
These node demos above are built with our graph node editor (or by creating node assets directly). At runtime, the assets interact with the corresponding primitive module interfaces and the GraphExecutor to send and receive InworldBaseData. NodeOverview

​
InworldController

InworldController is the main GameObject in the Unity scene. Each primitive module is organized as a child of this object. At runtime, InworldController executes modules in batches according to the configured loading process. Once initialized, the corresponding module interfaces become available to the Graph/Node system.

​
InworldGraphExecutor

InworldGraphExecutor contains a Graph ScriptableObject asset.

​
Workflow

  1. At runtime, it first creates runtime handles for every graph, edge, and node by calling CreateRuntime().
  2. It then calls Compile() to make the graph executable.
  3. After compilation, other scripts can interact with the executor by calling its ExecuteGraphAsync() method with input.
  4. When execution finishes, it raises the OnGraphResult event.

​
Graph

A graph represents a workflow for solving one or more tasks. It contains nodes and edges that describe the system, and it is executed by the graph executor.

​
Nodes

A node is a functional unit that processes input data (either the initial input or the output from a previous node). It sends the processed result to the next node via edges, or outputs directly if it is an end node.
The InworldRuntime system is implemented in a C++ DLL and is type-sensitive.Ensure that data types match from one node to the next.If they do not match, create a custom node to perform the conversion.

​
InworldBaseData

This is the fundamental data type that flows through the graph via edges. All nodes can only receive and send InworldBaseData or its subclasses.
Although all data processing is based on InworldBaseData, nodes—especially those that call the C++ DLL—are still very strict about concrete types.Passing different subclasses, even if they inherit from the same base, can sometimes cause crashes.

​
Inworld Nodes

Inworld nodes are built on Inworld’s primitive modules. In the current SDK, we provide:
Some of these nodes require their corresponding interfaces to be initialized first.
These nodes do not expose ProcessBaseData() and are not intended to be subclassed for custom data processing.

​
Custom Nodes

Custom nodes are authored in Unity and are primarily used to convert between data types. Examples include:
  • GetPlayerName
  • FilterInput
  • FormatPrompt
  • AddSpeechEvent
  • ConversationEndPoint
Each custom node can be subclassed. They expose a key method, ProcessBaseData(), which converts the incoming InworldBaseData to the outgoing InworldBaseData.

​
Edges

Edges connect nodes and can also define conditions that block certain data from passing through—for example, to prevent incompatible data types from reaching later nodes.