> ## Documentation Index
> Fetch the complete documentation index at: https://docs.inworld.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Node Demos Overview

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

<CardGroup cols={2}>
  <Card title="LLM Node Demo" href="/Unity/runtime/demos/nodes/llm">
    See a demonstration of the LLM node working within a graph workflow.
  </Card>

  <Card title="STT Node Demo" href="/Unity/runtime/demos/nodes/stt">
    Try out Speech-to-Text node integration in a graph.
  </Card>

  <Card title="TTS Node Demo" href="/Unity/runtime/demos/nodes/tts">
    Explore Text-to-Speech node usage in a sample graph.
  </Card>

  <Card title="Intent Node Demo" href="/Unity/runtime/demos/nodes/intent">
    See how the Intent node processes and routes input data.
  </Card>

  <Card title="Safety Node Demo" href="/Unity/runtime/demos/nodes/safety">
    Experiment with safety checks using the Safety node.
  </Card>

  <Card title="Custom Node Demo" href="/Unity/runtime/demos/nodes/custom">
    Learn how to use and implement a custom node in the graph system.
  </Card>

  <Card title="Edge Demo" href="/Unity/runtime/demos/nodes/edge">
    Inspect data flow in graphs by examining edges between nodes.
  </Card>

  <Card title="Edge Loop Demo" href="/Unity/runtime/demos/nodes/loop">
    See how to create loops and iterative processes using edges.
  </Card>

  <Card title="Character Interaction Node Template" href="/Unity/runtime/demos/nodes/character">
    Experience a full conversation pipeline using node-based character interaction.
  </Card>

  <Card title="Character Interaction Node Template with JSON" href="/Unity/runtime/demos/nodes/json">
    Try the JSON-based character graph template for cross-platform sharing.
  </Card>
</CardGroup>

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`.

<img src="https://mintcdn.com/inworldai/pDD5vvrZThONehMe/img/unity/framework/NodeOverview.png?fit=max&auto=format&n=pDD5vvrZThONehMe&q=85&s=79cc53d501d3d3812a0cca113923df38" alt="NodeOverview" width="2493" height="915" data-path="img/unity/framework/NodeOverview.png" />

## 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.

<Warning>
  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.
</Warning>

## 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.

<Note>
  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.
</Note>

### Inworld Nodes

Inworld nodes are built on Inworld’s primitive modules.

In the current SDK, we provide:

* [LLM](../../runtime-reference/InworldNodeAsset/LLMNodeAsset)
* [TTS](../../runtime-reference/InworldNodeAsset/TTSNodeAsset)
* [STT](../../runtime-reference/InworldNodeAsset/STTNodeAsset)
* [RandomCannedText](../../runtime-reference/InworldNodeAsset/RandomCannedTextNodeAsset)
* [TextChunking](../../runtime-reference/InworldNodeAsset/TextChunkingNodeAsset)
* [TextAggregator](../../runtime-reference/InworldNodeAsset/TextAggregatorNodeAsset)
* [Subgraph](../../runtime-reference/InworldNodeAsset/SubgraphNodeAsset)
* [Safety](../../runtime-reference/InworldNodeAsset/SafetyNodeAsset)
* [Intent](../../runtime-reference/InworldNodeAsset/IntentNodeAsset)

<Note>
  Some of these nodes require their corresponding interfaces to be initialized first.
</Note>

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.