# Dynamic Training Builder Nodes Manual
# Introduction
The Dynamic Training Builder represents the next-generation interaction definition system within the Training Builder, offering enhanced capabilities with more responses and events. It allows for the dynamic introduction of multiple node queries into a single system and the removal of these nodes during runtime, providing unparalleled flexibility. This advanced system is packed with exclusive features that elevate the overall user experience, making it a powerful tool for creating complex and responsive training simulations.
#### Accessing the Dynamic Training Builder
The Dynamic Training Builder is available in **SimLab Composer Mechanical and Ultimate Edition** as well as **VR Studio Pro Edition**.
To access it, simply run the Training Builder from the top workbench.
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/tb.png)
[](https://simlab-soft.com/help/uploads/images/gallery/2025-08/CIJimage.png)
The Dynamic Training Builder menu is divided into four groups:
##### **Sources**
Source Nodes in the Training Builder define the elements that drive interactions, including objects, data types, animation sequences, and scene states. They act as key reference points that connect with events and responses, determining which elements are used within the interaction system. By configuring these sources, users ensure that events are triggered and responses are executed based on defined conditions, creating a dynamic and responsive interaction system.
##### **Events**
Events represent specific triggers or occurrences that initiate actions within the interaction system. They are used to define when particular conditions are met, such as an object entering a specific area or a user performing an action. Events connect Source Nodes to Responses, dictating how the system reacts to changes or interactions.
##### **Responses**
Responses are actions or outcomes triggered by Events. They dictate what happens when specific conditions are met, such as playing an animation, changing a scene, or altering an object’s state. Responses connect to Events to define the system's behavior and ensure the interaction system reacts dynamically to various triggers.
##### **States**
In the Training Builder, State Nodes represent ongoing conditions rather than single triggers. They include nodes for monitoring overlap, variable values, and object grabbing states, as well as logical operations like "and," "or," and "not." State Nodes can trigger responses similarly to events, but they reflect persistent states within the interaction system rather than instantaneous actions.
---
### Adding Nodes to the Diagram
To add nodes to the diagram simple click on one of the icons in the top bench or drag and drop them into the diagram
[](https://simlab-soft.com/help/uploads/images/gallery/2025-08/4O9image.png)
An additional method to create nodes is to use the **context menu** that appears when right clicking in an empty area of the diagram.
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/contextmenu.jpg)
In the context menu you can navigate towards the nodes you want to create through a submenu system or you can type in the name of a node in the **filter** field to show only the related nodes.
***Note**: In addition to the nodes available in the nodes bench, the context menu features more advanced nodes that aren't listed there. Feel free to explore these additional options as well.*
---
#### Learn More
To learn more about utilizing the Dynamic Training Builder you can visit our ever-expanding **SimLab Academy**, accessible from the bottom library in SimLab Composer and SimLab VR Studio, there you will find video tutorials with examples that would help you unleash the full potentials of the Dynamic Training Builder.
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/dynamictbacademy.jpg)
---
#### Organize your Dynamic Training Builder with Groups
VR experiences are valuable assets that include custom logic created by users. As more users build advanced experiences—and as these experiences are shared and used over time by multiple creators—we’ve added colored groups and notes to help manage them better.
These features make it easier to organize related logic into groups and add clear descriptions for each section in the Training Builder, check this [tutorial](https://www.youtube.com/watch?v=p9SMynLbRQY).
---
#### Feel free to reach out to us on our Discord!
##### [ ](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) [SimLab Discord Community](https://www.simlab-soft.com/simlab-discord-community.aspx)
# Sources
# Boolean
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-12/ykLboolean-black.png) Boolean
Generates a Boolean (True/False) value. [](https://simlab-soft.com/help/uploads/images/gallery/2025-12/image.png)
# Expression
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-12/source-expression-blk.png) Expression
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/image.png)
**Expressions** are used to generated values that can be used to trigger events through out the interactive VR experiences. They allow users to define logic related to interactions and can be categorized into Main Sources and Template Sources. For more details on expressions check this [tutorial](https://www.youtube.com/watch?v=6hIvMsl5obs&t=307s). You can find a list of all expressions viable in training builder at this [link](https://www.simlab-soft.com/3d-products/vr-expressions.aspx).
# Material
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-12/source-material-blk.png) Material
Select a material from Material Library to use as[](https://simlab-soft.com/help/uploads/images/gallery/2025-12/S09image.png)
an input in this source.
# Number
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-12/C6usource-number-blk.png) Number
Input a number and use it as a source in your training builder logic
[](https://simlab-soft.com/help/uploads/images/gallery/2025-12/W1Bimage.png)
# Scene Node
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-12/source-scenenode-blk.png) Scene Node
# Scene Node Query
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Scene Node Query
The **SceneNode Query** enables the system to identify an object based on its attributes within the VR environment. This node enhances interactivity by allowing responses to be customized for individual objects, triggering specific actions based on **SceneNode attributes** as part of their virtual experience.
#### Example
In this example, the **SceneNode Query** is used to acquire specific attributes from specific objects, in order to perform specific response to them
Then when user triggers object named **Activate**, and the response connected to the node will be executed to the objects with attribute name **Color** and its value is **Yellow.**
# Scene State
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-12/source-scenestate-blk.png) Scene State
# Sequence
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-12/source-sequence-blk.png) Sequence
# String
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-12/source-string-blk.png) String
# User Query
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) User Query
The **User Query node** enables the system to identify a user based on their attributes within the VR environment. This node enhances interactivity by allowing responses to be customized for individual users, triggering specific actions based on **user attributes** as part of their virtual experience.
#### Example
In this example, the **User Query node** is used to acquire specific attributes from specific users, in order to perform specific response to them
Once the User enters the object named **Building**, their InBuilding attribute's value becomes **Yes,** then when user triggers object named **Activate**, the users with attribute name **InBuilding** and its value is **Yes** gets teleported to CameraNode named **Outside**'s location.
# Variable
###  Variable
The **Variable** **node** represents the value of a specific variable within the scene and features a variable port that can be connected to nodes requiring variable assignment. This node simplifies complex setups by enabling consistent use of variables throughout the scene, ensuring streamlined connections between different elements in the training builder.
[](https://simlab-soft.com/help/uploads/images/gallery/2024-09/trainingbuilder-variable-01.png)
> [Tutorial about **Variable Sorting** on YouTube](https://www.youtube.com/watch?v=amnTY83rDjo "Tutorial about Variable Sorting on YouTube")
# Sources
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Expression
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/image.png)
**Expressions** are used to generated values that can be used to trigger events throughtout the interactive VR experiences. They allow users to define logic related to interactions and can be categorized into Main Sources and Template Sources. For more details on expressions check this [tutorial](https://www.youtube.com/watch?v=6hIvMsl5obs&t=307s). You can find a list of all expressions viable in training builder at this [link](https://www.simlab-soft.com/3d-products/vr-expressions.aspx).
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) SceneNode Query
The **SceneNode Query** enables the system to identify an object based on its attributes within the VR environment. This node enhances interactivity by allowing responses to be customized for individual objects, triggering specific actions based on **SceneNode attributes** as part of their virtual experience.
#### Example
In this example, the **SceneNode Query** is used to acquire specific attributes from specific objects, in order to perform specific response to them
Then when user triggers object named **Activate**, and the response connected to the node will be executed to the objects with attribute name **Color** and its value is **Yellow.**
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) User Query
The **User Query node** enables the system to identify a user based on their attributes within the VR environment. This node enhances interactivity by allowing responses to be customized for individual users, triggering specific actions based on **user attributes** as part of their virtual experience.
#### Example
In this example, the **User Query node** is used to acquire specific attributes from specific users, in order to perform specific response to them
Once the User enters the object named **Building**, their InBuilding attribute's value becomes **Yes,** then when user triggers object named **Activate**, the users with attribute name **InBuilding** and its value is **Yes** gets teleported to CameraNode named **Outside**'s location.
---
###  Variable
The **Variable** **node** represents the value of a specific variable within the scene and features a variable port that can be connected to nodes requiring variable assignment. This node simplifies complex setups by enabling consistent use of variables throughout the scene, ensuring streamlined connections between different elements in the training builder.
[](https://simlab-soft.com/help/uploads/images/gallery/2024-09/trainingbuilder-variable-01.png)
> [Tutorial about **Variable Sorting** on YouTube](https://www.youtube.com/watch?v=amnTY83rDjo "Tutorial about Variable Sorting on YouTube")
---
# Events
# AI Agent
###  AI Agent Start Talk
The **AI Agent Start Talk** node activates the exact moment an assigned AI Agent begins delivering its response.
###  AI Agent End Talk
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/6yzimage.png)
The **AI Agent End Talk** node activates as soon as the assigned AI Agent finishes delivering its response.
For more information, please watch the AI Start/End talk tutorial:
# SceneNode \ Dynamic Menu
###  Dynamic Menu Item Triggered
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/NdHimage.png)
The **Dynamic Menu Item Triggered** event node acts as a universal listener, activating the moment a user interacts with *any* dynamic menu button within the VR scene. Upon execution, it outputs the specific **SceneNode** the menu is attached to, the **ID** of the clicked button, and the **User** who triggered it.
###  Dynamic Menu Item Triggered(ID)
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/pnVimage.png)
The **Dynamic Menu Item Triggered (ID)** event node activates only when a button with a specific **ID** is pressed. It ignores all other button interactions, allowing you to trigger a specific function
###  Dynamic Menu Item Triggered(Node + ID)
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/rOEimage.png)
The **Dynamic Menu Item Triggered (Node + ID)** event node provides the most specific control by activating only when a button with a precise **ID** is pressed on a menu linked to a specific **SceneNode**. This prevents execution overlap by ensuring the logic only triggers for one unique button on one specific object.
**Example:**
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Osbimage.png)
In this example, the **Dynamic Menu Item Triggered (Node + ID)** node is configured to act as a "Help" button. By setting the **SceneNode** to "Main Menu" and the **ID** to "3", the system listens exclusively for that exact button press on that specific menu object. Once the user clicks this button, the execution flow passes to a **Show/Hide** node configured to display an "Instructions Window" by setting its state to True. Immediately following this, the flow triggers a **Set Node Glow State** node, which applies a visual highlight to a designated "Hint Object" to guide the user.
###  Dynamic Menu Item Triggered(Node)
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/KW5image.png)
The **Dynamic Menu Item Triggered (Node)** event node activates only when a button is pressed on a menu attached to a designated **SceneNode**. This node isolates interactions to a single object, ensuring that the logic only runs for the menus linked to that specific item in the scene.
Dynamic Menu Triggered nodes are used in the following add-ons:
# SceneNode \ Query
###  Node Added to Query
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Ye8image.png)
The Node Added to Query event node constantly monitors the scene and triggers its Execute output whenever a 3D object's attributes are modified to match the specific conditions defined by a connected Scene Node Query. By plugging a query into the node's SceneNode input, it listens for any object that newly meets these criteria—essentially being "added" to the query's list of valid results—and subsequently passes both the execution signal and the specific SceneNode that triggered the event through their respective outputs, allowing for dynamic, attribute-driven logic without needing to manually target individual objects.
##### Example:
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Wbgimage.png)
In this example, a Scene Node Query is configured to continuously look for any object that has an attribute named "Parts" with a value containing "Part\_". This query is connected directly to Node Added to Query event node. During the experience, whenever an object has its attributes updated to successfully meet this exact condition, the event node automatically triggers and passes that specific object through its SceneNode output into a Set Node Glow State node.
---
###  Node Removed From Query
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/3MHimage.png)
The Node Removed From Query event node continuously monitors the scene and triggers its Execute output whenever a 3D object's attributes change so that they no longer match the conditions of a connected Scene Node Query. By connecting a query to the node's SceneNode input, it watches for any object that falls out of the query's criteria—essentially being "removed" from the list of valid results.
##### Example:
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/8Iximage.png)
In this example, a Scene Node Query is configured to track any object that has an attribute named "Bullet\_Instance". This query is connected directly to the SceneNode input of the Node Removed From Query event node. During the experience, if an object's attributes are altered so it no longer possesses the "Bullet\_Instance" attribute (for example, if the attribute is removed after a collision), the event node automatically triggers and passes that specific object through its SceneNode output into a Delete SceneNode node.
# Scene Node \ Overlap
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/event-node-entersnode.png) Node Enter Node
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/LFQimage.png)
The **Node Enter Node** event is triggered when Scene Node A enters Scene Node B. Both nodes can be any nodes in the assembly tree — for example, Node A could be a screwdriver and Node B could be a screw.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/event-node-exitsnode.png) Node Exited Node
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/hJ3image.png)
The **Node Excited Node** event is triggered when Scene Node A exits Scene Node B. Both nodes can be any nodes in the assembly tree — for example, Node A could be a screwdriver and Node B could be a screw.
# SceneNode \ Triggered
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-12/event-node-triggered.png) Node Triggered
[](https://simlab-soft.com/help/uploads/images/gallery/2025-12/Wjpimage.png)**Node Triggered** event is executed when the selected Scene Node is triggered within VR environment.
###  Node Triggered Location
The **Node Triggered Location** is used to capture the specific location or position of a triggered event within the VR environment. It enables tracking where a particular interaction occurred, which can be useful for dynamic object placement, analytics, or event-triggered responses based on spatial coordinates.
####
#### Example
In this example, the **Node Triggered Location** is used to capture the location where the user triggers the target. When the target is hit, the node records the exact spot, and a bullet hole is placed using the **Set Node Location**. The **Make Node Copy** is used to enable the user to shoot more than one bullet, creating a new bullet hole at each triggered location. This setup allows for repeated interactions, with each shot creating a new bullet hole in the correct spot.
---
# Controller
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Grip Pressed
The **Grip Pressed node** enables the user to detect when the VR controller's grip is pressed. By connecting a response to this node, the specified action is executed each time the grip is pressed, allowing for interactive controls within the VR Experience.
####
#### Example
In this example, a **Grip Pressed node** is used to execute a response. Once the Grip press is triggered, the Grip Pressed node checks the boolean value. If the condition is met, the connected response executes, and the animation plays during the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Grip Released
The **Grip Released node** enables the user to detect when the VR controller's grip is released. By connecting a response to this node, the specified action is executed each time the grip is released, allowing for interactive controls within the VR Experience.
####
#### Example
In this example, a **Grip Released node** is used to execute a response. Once the Grip released is triggered, the Grip Released node checks the boolean value. If the condition is met, the connected response executes, and the animation plays during the VR Experience.
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/y1Vimage.png)Hand
Hand gestures in VR are becoming more natural and intuitive than ever. No need for the user to fully close hand to grab objects — now, a drawer can be opened effortlessly using just two fingers, just like in real life.
With enhanced gesture control, users can interact with virtual world in a way that feels smooth, and precise, check this [tutorial](https://youtu.be/YkPAQTO5GKE).
# Keyboard
Adding an interactive 3D menu in VR is simple, but using the same menu on a desktop can be challenging, as you have to adjust your view every time you want to make a change.
To solve this, "**Key Press**" and "**Key Release**" events were introduced. By separating these events, designers now have more control when creating VR experiences.
### Key Pressed
Right click in the Dynamic Training Builder and type in the
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/XMVimage.png)
"Keyboard" or look under "**Events**" to get this node. As the name implies when a keyboard key is pressed this event is triggered.
#### Example
### Key Released
Same as above node but when key is released.
Check this [tutorial ](https://youtu.be/ACQPYu1sdf0)to learn more about these events.
# User
###  User Enter Node
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/F48image.png)
The **User Enter Node event node** continuously monitors the physical boundaries of a specific 3D object and activates the moment a user's avatar collides with or enters its volume. While enabled, it passes forward a reference to the specific User involved before continuing the logic flow. This functionality applies to all participants within multiplayer VR collaboration scenes.
---
###  User Exit Node
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/6ogimage.png)
The **User Exited Node event node** tracks the physical boundaries of a specific 3D object and activates the exact moment a user's avatar stops colliding with or fully exits its volume. While enabled, the node watches the targeted SceneNode and triggers its output as soon as the user completely separates from the object, passing forward a reference to the specific User who left before continuing the execution logic. And like **User Enter Node**, it also applies to all participants within multiplayer VR collaboration scenes.
# Variable
###  Variable Changed
The **Variable Changed** event activates when the value of a specified variable is modified. This event helps users detect real-time changes and trigger actions accordingly, enabling dynamic and responsive interactions within the VR Experience.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-02/VBwimage.png)
In this example, the **Variable Changed** event is set to monitor changes in the variable **Door**. When the value of this variable is modified, the event triggers the **Play Animation Sequence** node, which activates the **Door Anim** animation sequence.
# On Message Received
SimLab Composer 14 introduces WebSocket support, enabling seamless integration with external systems, allowing it to work with external hardware, co-simulation engines, and websites, unlocking numerous possibilities.
Use the node **On Message Received** to trigger an event when a message is received.
The **On Message Received** node triggers an event when an unhandled message is received from the external connection. This node allows you to access the incoming message and take appropriate action based on its content. It is useful for responding to external data or commands and processing messages within the VR Experience.
This node is related to Open External Connection node
[](https://simlab-soft.com/help/uploads/images/gallery/2025-02/screenshot-2025-02-02-161759.jpg)
**Input Ports:**
- Enable
**Output Ports:**
- Execute
- Message
The WebSocket nodes (Open External Connection, Send Message, and Receive Message) are exclusively available in the Ultimate Edition.
# Voice Command
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Voice Command Recognized
The **Voice Command Recognized event** is used to activate a response when the user says a specific command. This event listens for predefined voice commands and triggers the associated actions or responses within the VR environment upon recognizing the command.
#### Example
In this example, a new voice command named "Door Open" is created by accessing the Voice Command section from the Interaction menu and adding the command in the Voice Commands window.
The **Voice Command Recognized** **event** is used to link the newly created "Door Open" command. When the user says "Open the door", the door open sequence is triggered and plays.
---
# Execution
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/event-customevent-triggered.png) Custom Event
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/0hbimage.png)
This event is activated manually by the user. It's useful when you want multiple different paths or actions to lead to the same response.
To set it up, use the [**Trigger Custom Event** response](https://simlab-soft.com/help/link/365#bkmrk-trigger-custom-actio) and assign it a unique ID (e.g., `path1`). You can place this trigger in as many locations as needed.
Whenever a **Trigger Custom Event** is called, it will execute the **Custom Event** that has a matching ID.
If you want to pass additional info, you can use the info field in **Trigger Custom Event** response, this data will be passed to the even in the info port
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/event-scene-start.png) Scene Start
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/2T1image.png)
This event is triggered automatically when the scene begins. Use it to initialize elements at startup, such as playing videos, running background animations, or any other setup tasks.
> **Note:** Since this event fires the moment the scene loads, it's recommended to add a small delay before making additional scene changes — this ensures all scene elements have fully initialized before anything else runs.
---
###  Ticker
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/pYZimage.png)
The **Ticker** event node functions as a continuous, time-based loop that repeatedly activates subsequent nodes at a consistent rate. As long as its Enable input is set to *True*, the node constantly triggers its Execute output every time the duration specified in the numerical Interval input (measured in seconds) elapses. Once activated, it continually outputs this time value through the Period pin, allowing the logic flow to perform recurring actions or background checks for as long as the node remains enabled.
**Example:**
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/OfNimage.png)
In this example, we use the Ticker node to create a loop that randomly changes a material's color every 2.5 seconds:
1. A **Watch Boolean Expression** node continuously monitors the "speed1" variable and activates the **Ticker** node once the value equals 1.
2. While enabled, the **Ticker** node creates a continuous loop that triggers its execution output every 2.5 seconds.
3. The Ticker simultaneously executes three **Set Number Variable By Expression** nodes to generate random values using the `math.random()` function for the variables r1, g1, and b1.
4. These three random numbers are passed into an **RGB To Color** node, where they are combined to formulate a new color.
5. Finally, this new color is sent to a **Set Material Color** node, which immediately applies the randomly generated color to the target material.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-06/odqevent-error.png) Error
Fires whenever an error happens while your experience is running, and hands you a message describing what went wrong.
#### What it does
This node is a safety net. Unlike most nodes, you do not trigger it from an earlier node — it listens on its own in the background while your experience runs. If an error occurs, its **Execute** output fires and its **Error Message** output gives you the text of that error. Instead of letting a problem pass unnoticed, you can respond to it — show the user a clear message, make a note of what happened, or move things to a safe state.
#### Turning it on and off
The **Enable** input controls whether the event is listening. It is **on by default**, so the node starts catching errors as soon as your experience begins. If you only want to catch errors during a certain part of your experience, connect a Yes/No value to **Enable** and switch it on and off as needed; while it is off, the event stays quiet and its **Execute** output will not fire.
#### Inputs
Port
Type
What to connect
**Enable**
True / false
*Optional.* Whether the event is listening for errors. **On** by default — leave it on to catch errors the whole time, or connect a Yes/No value to switch it on and off.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires the moment an error occurs while the event is enabled. Wire it to whatever should happen in response.
**Error Message**
Text
A short description of the error that occurred.
#### Example
**Enable** input
**On** (the default)
**Execute** output
Fires when an error happens
**Error Message** output
`Could not load the requested file.` — the exact wording depends on what went wrong
#### Tips
- **Respond to the problem.** Wire **Execute** to something that handles it — show the user the **Error Message**, make a note of it, or move the scene to a safe state — rather than letting the error pass silently.
- **Show the message.** The **Error Message** output is plain text, so you can display it on a panel or pass it into another node.
- **Limit when it listens.** Leave **Enable** on to watch the whole time, or turn it off during parts of your experience where you would rather handle problems yourself.
# Snapping
###  Node Ready To Snap
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/3Lvimage.png)
The **Node Ready to Snap** event node activates the exact moment a designated SceneNode enters the valid snapping range of an eligible target. This node is highly useful for triggering immediate visual or audio feedback—such as highlighting a destination socket green or playing a hovering sound—letting the user know the object is ready to be released and snapped.
###  Node Snapped
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/djHimage.png)
The **Node Snapped** event node activates immediately after a SceneNode has successfully completed its snapping action onto a target socket. This event is typically used to seamlessly progress a sequence, such as locking the snapped part in place, playing a mechanical click sound, or advancing the user to the next step of an assembly training scenario.
# sceneNode \ Attributes
###  Node Attribute Added
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/SPvimage.png)
The **Node Attribute Added** event node continuously monitors the targeted SceneNode and activates whenever a completely new attribute is attached to it. This event is typically used in conjunction with **Set Node Attribute nodes** to trigger subsequent actions. Once activated, it outputs the affected SceneNode along with the specific Category and Name of the newly created attribute.
---
###  Node Attribute Changed
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Ciwimage.png)
The **Node Attribute Changed** event node observes the targeted SceneNode and activates whenever the value of any of its existing attributes is modified. Once activated, the node outputs the affected SceneNode alongside the exact Category and Name of the altered attribute.
---
###  Node Attribute Removed
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/0Lcimage.png)
The **Node Attribute Removed** event node tracks the targeted SceneNode and activates the moment an existing attribute is deleted from the object. This event is typically used alongside the **Remove Node Attribute** node to initiate reactions to data clearance. Once activated, it outputs the affected SceneNode forward along with the specific Category and Name of the deleted attribute.
# Responses
# Scene
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Capture Picture
[](https://simlab-soft.com/help/uploads/images/gallery/2024-09/N18am3image.png)
The **Capture Picture node** is used to capture an image from a camera within the scene, and the captured image can then be displayed on a 3D object within the scene. This allows the user to take snapshots and show them in the VR environment, such as displaying a captured image on a screen or other surface.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-09/Xn9image.png)
A **Surveillance Monitor** is first created to display the captured images. This monitor is then attached to the VR camera.
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-example.jpg)
In this example, the **Capture Picture Node** is used to capture an image on a picture frame model when the user triggers the Activate event. Before that, the Cast SceneNode is used to identify the picture frame as a 3D object, as the Capture Picture Node only works with 3D objects.
# Scene
# New Page
# AI Agent
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2026-03/5Y3response-aiagent-reset.png)AI Agent Reset Chat History
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/FTTimage.png)The **AI Agent Reset Chat History** node enables the system to clear and reset the ongoing conversation history for a specific AI Agent. It is typically used when you want the AI to start a completely fresh interaction or switch to a new scenario without being influenced by the context of any prior messages.
###  AI Agent Send Message
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/jCDimage.png)
The **AI Agent Send Message** node enables the system to send a specific text message to an assigned AI Agent for processing. The **Output Voice?** boolean parameter that dictates how the AI agent will deliver its response:
- **False:** The AI agent will respond with text.
- **True:** The AI agent will process the text message and respond with generated voice audio.
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) AI Agent Start Listen
The **AI Agent Start Listen node** is used to make the AI start listening to the user. When activated, this node enables the AI to process and listen to spoken input from the user, allowing for interactive conversations and commands within the VR environment.
#### Example
In this example, an AI Doctor is set up in the AI Agents window. This window can be accessed by clicking the Interaction icon in the viewport menu, then select the AI Agents, and then add the AI name with the desired instructions in the Instructions field. A variable is created to store the AI's responses.
The **AI Agent Start Listen node** is used to make the AI Agent named Doctor start listening to the user when the object named "Start" is triggered. This setup enables the AI to process and listen to user input as soon as the trigger event is activated.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) AI Agent Stop Listen
The **AI Agent Stop Listen node** is used to make the AI stop listening to the user. When activated, this node halts the AI’s ability to process further user input, allowing the AI to respond based on the information gathered up to that point.
#### Example
In this example, an AI Doctor is set up in AI Agents window. This window can be accessed by clicking the Interaction icon in the viewport menu, then select the AI Agents, and then add the AI name with the desired instructions in the Instructions field. A variable is created to store the AI's responses.
The **AI Agent Stop Listen node** is used to stop the AI Agent from listening to the user when the "Stop" trigger event occurs. This allows the AI agent named Doctor to respond based on the input received before listening was stopped.
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) AI Agent Stop Listen (Text)
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Gldimage.png)
The **AI Agent Stop Listen (Text) node** is used to make the AI stop listening to the user. When activated, this node halts the AI’s ability to process further user input, allowing the AI to respond based on the information gathered up to that point.
This node has an extra output "Spoken Text", when the node is activated, it outputs the input audio in text format.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Has Valid AI Key
The **Has Valid AI Key** node checks whether a valid AI key is available for AI-related features in Sim Lab Composer. This node ensures that AI functionalities can operate properly by verifying the presence of an active and valid AI key.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-02/lXbimage.png)
In this example, the **Has Valid AI Key** node is used at the start of the scene to check if the user has an activated AI key. The node is connected to a **Branch** node, where the **False** output (indicating no valid AI key) triggers a message in front of the user, informing them that the AI key must be activated.
---
###  Set AI Key
The **Set AI Key** node allows you to assign an AI API key to a VR experience directly from the Training Builder. This lets the experience use AI features without requiring the user to manually activate an API key in the viewer. You can select the provider (OpenAI, Gemini, or OpenRouter) and embed the corresponding API key into the experience.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-07/VH8image.png)
In this example, the **Set AI Key** node is connected to a **Scene Start** event to initialize the AI provider as soon as the experience begins. After adding the node and selecting the provider, the API key is pasted into the node’s field. The key is then activated when the scene starts, allowing the AI agent to respond without the user needing their own key. If the embedded key is not active or reaches its usage limit, the experience automatically switches to the user’s API key in the viewer if one is available.
Check this **[tutorial](http://youtube.com/watch?v=qzqNtXBTGY4)** for more about this node.
---
###  **Set AI Agent Model**
The **Set AI Agent Model** node is used to assign a specific AI provider and model to an AI agent in your VR experience. This ensures the AI agent will operate using the selected provider and model for any interactions that occur in the scene. You can choose the AI agent you have created, specify the provider (OpenAI, Gemini, or OpenRouter), and define the model name.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-07/XCzimage.png)
In this example, the **Set AI Agent Model** node is triggered by pressing a button in the VR scene. When the button is clicked, the node assigns the “Patient” AI agent to the OpenAI provider and sets the model to GPT‑4. This setup allows the AI agent to function with the defined provider and model as soon as the event is triggered.
Check this **[tutorial](http://youtube.com/watch?v=qzqNtXBTGY4)** for more about this node.
---
### Using AI Providers and API Keys in SimLab Composer
SimLab Composer now supports **OpenAI, Google Gemini, and OpenRouter** for integrating AI into your VR experiences. With the new **Set AI Key** and **Set AI Agent Model** nodes, you can connect your experience to these providers .
**Providers and Models:**
**1️⃣ OpenAI**
- **Provider URL:** `https://api.openai.com/v1/chat/completions`
- **Models:**
- gpt‑4.1
- gpt‑4
- gpt‑3.5‑turbo
**2️⃣ Google Gemini** (OpenAI‑compatible endpoint)
- **Provider URL:** `https://generativelanguage.googleapis.com/v1beta/openai/chat/completions`
- **Models:**
- gemini‑2.0‑flash
**3️⃣ OpenRouter**
- **Provider URL:** `https://openrouter.ai/api/v1/chat/completions`
- **Models:**
- openrouter/cypher‑alpha:free
- nvidia/llama‑3.3‑nemotron‑super‑49b‑v1:free
- **OpenAI keys** work with **Chat, Text‑to‑Speech, and Speech‑to‑Text**.
- **Gemini and OpenRouter keys** work with **Text only.**
# New Page
# User \ Controller
# User \\ Transform
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Teleport To Camera
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Teleport To Camera** node enables the user to teleport to a new location by assigning a camera in the **CameraNode** field. Once the teleportation is executed, the user is moved to the position and orientation defined by the specified camera.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/A1Fimage.png)
In this example, a **Teleport To Camera** response is used to move the user to a new location once the object named Activate is triggered. When triggered, the sound named Teleport\_Sound will play, and the user will be teleported to the location of the camera assigned in the Teleport To Camera node.
# Data Types\Number\Operations
---
#### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Add
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Add** response enables user to add two values by either typing in a numerical value in Number A and Number B field or by attaching a value or a variable node to those ports, then once the response is executed the resulting value can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-example.jpg)
In this Example an **Add Response** is used to add the values of 5 to the value of Variable1 once the user triggers the object named Activate, and the result of the addition is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Ceiling
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Ceiling** response enables the user to round up a value by either typing in a numerical value in the Number A field or by attaching a value or a variable node to that port. Then once the response is executed, the smallest integral value greater than or equal to the input value can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/vFhimage.png)
In this example, a **Ceiling Response** is used to round up the value of Variable1 to the smallest integral value greater than or equal to it once the user triggers the object named Activate. The result of the ceiling operation is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Divide
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Divide** response enables user to divide a value by another value, by either typing in a numerical value in Number A and Number B field or by attaching a value or a variable node to those ports, then once the response is executed the resulting value can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-example.jpg)
In this Example a **Divide Response** is used to divide the number 25 by the value of the variable named "Variable1" and the result of the division is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Floor
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Floor** response enables the user to round down a value by either typing in a numerical value in the Number A field or by attaching a value or a variable node to that port. Then once the response is executed, the largest integral value less than or equal to the input value can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/VmLimage.png)
In this example, a **Floor Response** is used to round down the value of Variable1 to the largest integral value less than or equal to it once the user triggers the object named Activate. The result of the floor operation is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Modulo
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Modulo** response enables the user to find the remainder of a division by either typing in numerical values in the Number A and Number B fields or by attaching values or variable nodes to those ports. Then once the response is executed, the modulus of the input value with respect to the divisor can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/sptimage.png)
In this example, a **Modulo Response** is used to calculate the remainder when the value of the variable named Variable1 is divided by the value of Variable2, once the user triggers the object named Activate. The result of the modulo operation is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Multiply
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Multiply** response enables user to multiply two values by either typing in a numerical value in Number A and Number B field or by attaching a value or a variable node to those ports, then once the response is executed the resulting value can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-example.jpg)
In this Example a **Subtract Response** is used to subtract the value of Variable1 from the value of the Variable2, then a **Multiply Response** is used to multiply the subtraction result by 3 once the user triggers the object named Activate, and the result of the multiplication is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Square Root
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Square Root** response enables the user to calculate the square root of a value by either typing in a numerical value in the Number field or by attaching a value or a variable node to that port. Then once the response is executed, the square root of the input value can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/hUtimage.png)
In this example, a **Square Root** response is used to calculate the square root of the value of Variable1 once the user triggers the object named Activate. The result of the square root operation is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Subtract
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Subtract** response enables user to subtract a value from another by either typing in a numerical value in Number A and Number B field or by attaching a value or a variable node to those ports, then once the response is executed the resulting value can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-example.jpg)
In this Example a **Subtract Response** is used to subtract the value of Variable1 from the value of the variable named Variable2, once the user triggers the object named Activate, and the result of the subtraction is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
# Data Types\Number\ Variable
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Set
Has two options:
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
- **By Value:**
The **Set number variable** response enables user to set a value by either typing in a numerical value in the value field or by attaching a value or a variable node to that port. Then once the response is executed, the variable value can be acquired through the **Value** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/Bdhimage.png)
In this example, a **Set number variable** is used to assign the value of Variable1 once the user triggers the object named Activate, and the new value is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
- **By Expression**
The **Set number variable by expression** response enables user to set a value by either typing in an expression in the expression field or by attaching a value or a variable node to that port. Then once the response is executed, the variable value can be acquired through the **Value** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/Bdhimage.png)
In this example, a **Set Number Variable By Expression** is used to set the result of the sum of Variable1 and Variable2 once the user triggers the object named Activate. The new value is then written in the Result variable, which can be connected to a variable writer to be displayed during the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Decrement Number Variable
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Decrement Number Variable** response enables the user to decrease a variable's value by 1 each time the event connected to it is triggered. Once the response is executed, the updated value can be acquired through the **Value** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/hUtimage.png)
In this example, a **Decrement Number Variable** response is used to decrease the value of Variable1 by 1 once the user triggers the object named Activate. The result of the decrease number variable operation is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Increment Number Variable
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Increment Number Variable** response enables the user to increase a variable's value by 1 each time the event connected to it is triggered. Once the response is executed, the updated value can be acquired through the **Value** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/hUtimage.png)
In this example, a **Increment Number Variable** response is used to increase the value of Variable1 by 1 once the user triggers the object named Activate. The result of the decrease number variable operation is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Get
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Number Variable Value** response enables the user to get a variable's value each time the event connected to it is triggered. Once the response is executed, the updated value can be acquired through the **Value** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/o5himage.png)
In this example, a **Number Variable Value** response is used to get the new value for Variable1 after it was changed by **Set Number Variable By Expression** once the user triggers the object named GetValueButton. The value of the number variable is then written in a variable named Result, which can then be connected to a variable writer to be displayed during the VR Experience.
---
# Data Types\Number\ Compare
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Equal (Number)
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Equal (Number)** response enables the user to compare two values by either typing in a numerical value in the Number A and Number B fields or by attaching a value or a variable node to those ports. Then once the response is executed, the result of the comparison can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/S2himage.png)
In this example, an **Equal Response** response is used to compare the value of Variable1 with the value of Variable2 once the user triggers the object named Activate. The result of the comparison can be acquired through the **Result** port. We have connected this Result port to the **Branch** node, and if the result of the branch is True, the TrueBox will show; if the result is False, the FalseBox will show.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Greater
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Greater** response enables the user to compare two values to determine if one is greater than the other by either typing in a numerical value in the Number A and Number B fields or by attaching a value or a variable node to those ports. Then once the response is executed, the result of the comparison can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/gMmimage.png)
In this example, a **Greater Response** is used to compare the value of Variable1 with the value of Variable2 once the user triggers the object named Activate. The result of the comparison can be acquired through the Result port. We have connected this Result port to the Branch node, and if the result of the branch is True, the TrueBox will show; if the result is False, the FalseBox will show.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Greater Or Equal
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Greater Or Equal** response enables the user to compare two values to determine if one is greater than or equal to the other by either typing in a numerical value in the Number A and Number B fields or by attaching a value or a variable node to those ports. Then once the response is executed, the result of the comparison can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/dmcimage.png)
In this example, a **Greater Or Equal Response** is used to compare the value of Variable1 with the value of Variable2 once the user triggers the object named Activate. The result of the comparison can be acquired through the Result port. We have connected this Result port to the Branch node, and if the result of the branch is True, the TrueBox will show; if the result is False, the FalseBox will show.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Less
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Less** response enables the user to compare two values to determine if one is less than the other by either typing in a numerical value in the Number A and Number B fields or by attaching a value or a variable node to those ports. Then once the response is executed, the result of the comparison can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/fxoimage.png)
In this example, a **Less** is used to compare the value of Variable1 with the value of Variable2 once the user triggers the object named Activate. The result of the comparison can be acquired through the Result port. We have connected this Result port to the Branch node, and if the result of the branch is True, the TrueBox will show; if the result is False, the FalseBox will show.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Less Or Equal
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Less Or Equal** response enables the user to compare two values to determine if one is less than or equal to the other by either typing in a numerical value in the Number A and Number B fields or by attaching a value or a variable node to those ports. Then once the response is executed, the result of the comparison can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/V5nimage.png)
In this example, a **Less** is used to compare the value of Variable1 with the value of Variable2 once the user triggers the object named Activate. The result of the comparison can be acquired through the Result port. We have connected this Result port to the Branch node, and if the result of the branch is True, the TrueBox will show; if the result is False, the FalseBox will show.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Not Equal
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Not Equal** response enables the user to compare two values to determine if they are different by either typing in a numerical value in the Number A and Number B fields or by attaching a value or a variable node to those ports. Then once the response is executed, the result of the comparison can be acquired through the **Result** port.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/SiNimage.png)
In this example, a **Not Equal** is used to compare the value of Variable1 with the value of Variable2 once the user triggers the object named Activate. The result of the comparison can be acquired through the Result port. We have connected this Result port to the Branch node, and if the result of the branch is True, the TrueBox will show; if the result is False, the FalseBox will show.
---
# Data Types\Number\ Conversion
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Number To String
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Number to String** node enables the user to convert a numerical value to a string by either typing in a numerical value in the Number field or by attaching a value or a variable node to that port. Then once the conversion is executed, the resulting string can be acquired through the **String** port.
---
# Data Types\Number\ Expression
This node can evaluate an expression, then[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/hulkomeeqn57image.png)
the result of this evaluation can be used to activate other responses.
####
#### Example
In the example below when the "**Import\_UPS**" geometry is clicked "**Evaluate Number Expression**" is executed. The expression is simple math.sqrt(16), and the result is linked to the "**Set Number Variable**" node, in "**result**" variable. This variable is then linked to a "Variable Writer" to display it.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/7ynimage.png)
# Data Types \ Json \ JsonObject
A JSON object is a collection of named fields — for example `{"name": "Sam", "age": 42}`. Each field has a name (sometimes called a *key*) and a value. The nodes on this page let you build objects, set or read fields by name, inspect them, and turn them into plain text you can store, send, or print.
## What's on this page
- **Create** — start a brand-new object, either empty or from a piece of text.
- **Set a field** — add or change a named field on an object (one node per value type).
- **Read a field** — pull the value of a named field back out (one node per value type).
- **Inspect** — list every field's name, or find out what kind of value a field holds.
- **Convert** — turn the whole object into a single piece of text.
**About fields:** field names are case-sensitive — `"Name"` and `"name"` are different. Setting a value on a field that already exists replaces the old value; setting one with a new name adds the field.
---
## Create
### Create Json Object
Makes a fresh, empty JSON object. Use this as the starting point when you want to build a record from scratch.
#### What it does
This node produces a brand-new JSON object with nothing in it: `{}`. From there you'd typically wire it into one or more **Set Json Object Field** nodes to fill it with named fields.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output. The node only runs when triggered.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes. Wire it into whatever should run next.
**JsonObject**
JSON object
A new, empty object `{}`.
#### Tips
- **Chain it.** Wire this node's **JsonObject** output into the **JsonObject** input of a **Set Json Object Field** node to add the first field.
- **Or start from text.** If you already have your data as a string like `{"name": "Sam"}`, use **Create Json Object From String** instead.
### Create Json Object From String
Reads a piece of text written in JSON object form and turns it into a real JSON object you can work with.
#### What it does
Useful when the data arrived as text — for example from a file you read, a message someone sent, or a value pasted into a configuration. The node parses the text and gives you back a proper JSON object that the other JSON nodes can use.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**String**
Text
The text to parse. It must look like a JSON object — that is, start with `{` and end with `}`, with comma-separated `"name": value` pairs.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**String**
Text
The same text you passed in (in case the next node needs it as well).
**JsonObject**
JSON object
The parsed object.
#### Example
**String** input
`{"name": "Sam", "age": 42}`
**JsonObject** output
`{"name": "Sam", "age": 42}` — now a real JSON object
#### Tips
- **Match the format.** If the text is malformed (a missing brace, unquoted field name, extra comma, etc.) the node won't be able to parse it.
- **Reverse direction.** To go the other way and turn an object *into* text, see **Json Object To String** further down this page.
---
## Set a field
These seven nodes all do the same thing — set a named field on a JSON object — but each one accepts a different kind of value. Pick the one that matches what you're storing.
If the field already exists on the object, its value is replaced. If it doesn't exist, the field is added. The original object isn't modified; what comes out is a new object with the change applied.
### Set Json Object Field (String)
Sets a text field on a JSON object.
#### What it does
This node takes a JSON object, a field name, and a piece of text, and gives you back a new object with that field set to the text.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object to update. Often comes from a **Create Json Object** node or from a previous step.
**Name**
Text
The name of the field to set. If the field already exists its value is replaced; if not, it's added.
**Value**
Text
The text to store under that name.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The updated object with your field set.
**Name**
Text
The same name you passed in.
**Value**
Text
The same text you passed in.
#### Example
**JsonObject** input
`{"name": "Sam", "age": 42}`
**Name** input
`"city"`
**Value** input
`"Portland"`
**JsonObject** output
`{"name": "Sam", "age": 42, "city": "Portland"}`
### Set Json Object Field (Number)
Sets a numeric field on a JSON object.
#### What it does
Same as the text version, but the value being stored is a number. Works with whole numbers and decimals; positive or negative.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object to update.
**Name**
Text
The name of the field to set.
**Value**
Number
The number to store under that name.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The updated object with your field set.
**Name**
Text
The same name you passed in.
**Value**
Number
The same number you passed in.
#### Example
**JsonObject** input
`{"width": 800, "height": 600}`
**Name** input
`"depth"`
**Value** input
`24`
**JsonObject** output
`{"width": 800, "height": 600, "depth": 24}`
### Set Json Object Field (Boolean)
Sets a true/false field on a JSON object.
#### What it does
Same idea as the other Set variants, but the value being stored is a true/false.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
### Set Json Object Field (JsonObject)
Sets a field whose value is another JSON object.
#### What it does
Stores a JSON object as the value of a named field — useful for grouping related sub-fields together. The original outer object isn't modified; you get a new object with the nested one attached under your chosen name.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The outer object to update.
**Name**
Text
The name of the field to set.
**Value**
JSON object
The inner object to store under that name.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The updated outer object with the inner object nested under your field name.
**Name**
Text
The same name you passed in.
**Value**
JSON object
The same inner object you passed in.
#### Example
**JsonObject** input
`{"user": {"id": 7}}`
**Name** input
`"config"`
**Value** input
`{"dark": true}`
**JsonObject** output
`{"user": {"id": 7}, "config": {"dark": true}}`
### Set Json Object Field (JsonArray)
Sets a field whose value is a JSON array.
#### What it does
Stores a JSON array (a list) as the value of a named field — useful for fields that hold a collection of related items, like tags, scores, or coordinates.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object to update.
**Name**
Text
The name of the field to set.
**Value**
JSON array
The array to store under that name. See the **JSON Arrays** page for nodes that build one.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The updated object with the array stored under your field name.
### Set Json Object Field (SceneNode)
Sets a field whose value is a scene node — an object in your SimLab scene like a robot, a part, or a marker.
#### What it does
Stores a reference to a scene node under a named field. The reference points to the live object — not a copy — so other nodes that read this field later receive the actual scene node.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object to update.
**Name**
Text
The name of the field to set.
**SceneNode**
Scene node
The scene node to reference under that name. Comes from a node like **Get Scene Node** or a previous step that produced one.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The updated object with the scene node reference attached.
### Set Json Object Field (User)
Sets a field whose value is a User — a participant in a VR/AR session.
#### What it does
Stores a reference to a User under a named field. The reference points to the live participant; other nodes that read this field later receive the actual User.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object to update.
**Name**
Text
The name of the field to set.
**User**
User
The User to reference under that name.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The updated object with the User reference attached.
---
## Read a field
These five nodes all pull the value of a single field back out of a JSON object. You pick the field by its name. Each variant returns the value as a specific type — pick the one that matches what you stored.
The object isn't modified — the value is read out, the object stays the same.
### Get Json Object Field (String)
Reads one field from a JSON object as text.
#### What it does
Returns the value of the field with the given name. Use this when that field's value is a piece of text.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object to read from. Must not be empty.
**Name**
Text
Which field to read. Names are case-sensitive.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The same object you passed in.
**Name**
Text
The same name you asked for.
**Value**
Text
The value stored under that name.
#### Example
**JsonObject** input
`{"name": "Sam", "age": 42, "city": "Portland"}`
**Name** input
`"city"`
**Value** output
`"Portland"`
### Get Json Object Field (Number)
Reads one field from a JSON object as a number.
#### What it does
Returns the value of the field with the given name. Use this when that field's value is a number.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object to read from. Must not be empty.
**Name**
Text
Which field to read.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The same object you passed in.
**Name**
Text
The same name you asked for.
**Value**
Number
The number stored under that name.
#### Example
**JsonObject** input
`{"width": 1920, "height": 1080, "fps": 60}`
**Name** input
`"height"`
**Value** output
`1080`
### Get Json Object Field (Boolean)
Reads one field from a JSON object as a true/false value.
#### What it does
Returns the value of the field with the given name. Use this when that field's value is a true/false.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
### Get Json Object Field (JsonObject)
Reads one field from a JSON object as another JSON object (a nested object).
#### What it does
Returns the value of the field with the given name. Use this when that field's value is itself a JSON object — for example a sub-section like `"config"` or `"user"`. Once you have the nested object, the other Read-a-field nodes can read its individual fields.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The outer object to read from. Must not be empty.
**Name**
Text
Which field to read.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The same outer object you passed in.
**Name**
Text
The same name you asked for.
**Value**
JSON object
The inner object stored under that name.
#### Example
**JsonObject** input
`{"user": {"id": 7}, "config": {"dark": true}}`
**Name** input
`"config"`
**Value** output
`{"dark": true}`
### Get Json Object Field (JsonArray)
Reads one field from a JSON object as a JSON array (a list).
#### What it does
Returns the value of the field with the given name. Use this when that field's value is a JSON array.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object to read from. Must not be empty.
**Name**
Text
Which field to read.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The same object you passed in.
**Name**
Text
The same name you asked for.
**Value**
JSON array
The array stored under that name.
#### Example
**JsonObject** input
`{"sizes": [10, 20], "colors": ["red", "blue"]}`
**Name** input
`"colors"`
**Value** output
`["red", "blue"]`
---
## Inspect
These two nodes don't read a specific field — they tell you *about* the object's structure. Use them when you don't know in advance what fields the object contains, or when you need to find out what type of value a field holds before reading it.
### Get Json Object Names
Gives you the list of field names in the object.
#### What it does
Returns each field name in the object, one after another. Handy when you want to step through every field using a loop construct or for-each pattern, or when you don't know what's in the object up front.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object whose field names you want.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The same object you passed in.
**Names**
Text
Each field name in turn.
#### Example
**JsonObject** input
`{"name": "Sam", "age": 42, "city": "Portland"}`
**Names** output
`"name", "age", "city"`
#### Tips
- **Use with Get.** Pair this with one of the **Get Json Object Field** nodes (or with **Get Json Field Type**) to inspect every field in turn.
- **Empty objects.** If the object has no fields, no names are produced.
### Get Json Field Type
Tells you what kind of value a named field holds.
#### What it does
Returns the type of the field's value as a short piece of text: `"String"`, `"Number"`, `"Boolean"`, `"JsonObject"`, or `"JsonArray"`. Use this when an object's fields can hold different kinds of values and you need to decide which **Get** node to use.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object containing the field. Must not be empty.
**Name**
Text
Which field to check.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The same object you passed in.
**Name**
Text
The same name you asked for.
**Type**
Text
The type of the field's value, as a short name.
#### Example
**JsonObject** input
`{"name": "Sam", "age": 42, "active": true}`
**Name** input
`"age"`
**Type** output
`"Number"`
---
## Convert
### Json Object To String
Turns the entire object into a single piece of text.
#### What it does
Produces a text representation of the whole object, written in JSON form. Useful when you need to save the object to a file, send it to another system, or put it somewhere that only accepts text.
The original object isn't modified — you get the same object back plus a text version.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonObject**
JSON object
The object to convert.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonObject**
JSON object
The same object you passed in.
**Result**
Text
The text version of the object.
#### Example
**JsonObject** input
`{"name": "Alice", "score": 95}`
**Result** output
`'{"name": "Alice", "score": 95}'`
#### Tips
- **Reverse direction.** To go back from text to an object, use **Create Json Object From String** at the top of this page.
---
## Related
- **JSON Arrays** — the matching page for working with ordered lists of items.
# Data Types \ Json \ JsonArray
A JSON array is an ordered list of items — for example `["apple", "cherry", "banana"]`. The nodes on this page let you build arrays, add to them, read items back out, inspect them, and turn them into plain text you can store, send, or print.
## What's on this page
- **Create** — start a brand-new array, either empty or from a piece of text.
- **Add a value** — append an item to the end of an existing array (one node per item type).
- **Read an element** — pull an item back out by its position (one node per item type).
- **Inspect** — find out the size, the valid positions, or the type of an item.
- **Convert** — turn the whole array into a single piece of text.
**About indexes:** positions in a JSON array start at **1**, not 0. The first item is at index 1, the second at index 2, and so on.
---
## Create
### Create Json Array
Makes a fresh, empty JSON array. Use this as the starting point when you want to build a list from scratch.
#### What it does
This node produces a brand-new JSON array with nothing in it: `[]`. From there you'd typically wire it into one or more **Add Json Array Value** nodes to fill it with items.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output. The node only runs when triggered.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes. Wire it into whatever should run next.
**JsonArray**
JSON array
A new, empty array `[]`.
#### Tips
- **Chain it.** Wire this node's **JsonArray** output into the **JsonArray** input of an **Add Json Array Value** node to put the first item in.
- **Or start from text.** If you already have your data as a string like `[1, 2, 3]`, use **Create Json Array From String** instead.
### Create Json Array From String
Reads a piece of text written in JSON array form and turns it into a real JSON array you can work with.
#### What it does
Useful when the data arrived as text — for example from a file you read, a message someone sent, or a value pasted into a configuration. The node parses the text and gives you back a proper JSON array that the other JSON nodes can use.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**String**
Text
The text to parse. It must look like a JSON array — that is, start with `[` and end with `]`, with items separated by commas.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**String**
Text
The same text you passed in (in case the next node needs it as well).
**JsonArray**
JSON array
The parsed array.
#### Example
**String** input
`[1, 2, 3]`
**JsonArray** output
`[1, 2, 3]` — now a real JSON array
#### Tips
- **Match the format.** If the text is malformed (a missing bracket, an extra comma, etc.) the node won't be able to parse it.
- **Reverse direction.** To go the other way and turn an array *into* text, see **Json Array To String** further down this page.
## Add a value
These five nodes all do the same thing — add a value to the end of a JSON array — but each one accepts a different kind of value. Pick the one that matches what you're adding.
None of them modify the original array. What comes out is a new array with the extra item on the end.
### Add Json Array Value (String)
Adds a piece of text to the end of a JSON array.
#### What it does
This node takes a JSON array and a piece of text, and gives you back a new array with the text added on the end.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The list you want to add to. Often comes from a **Create Json Array** node or from a previous step.
**Value**
Text
The piece of text you want to append.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The updated array with your text added at the end.
**Value**
Text
The same text you passed in.
#### Example
**JsonArray** input
`["apple", "cherry"]`
**Value** input
`"banana"`
**JsonArray** output
`["apple", "cherry", "banana"]`
### Add Json Array Value (Number)
Adds a number to the end of a JSON array.
#### What it does
Same as the text version, but for numbers. Works with whole numbers and decimals; positive or negative.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The list you want to add to.
**Value**
Number
The number you want to append.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The updated array with your number added at the end.
**Value**
Number
The same number you passed in.
#### Example
**JsonArray** input
`[20, -5]`
**Value** input
`3`
**JsonArray** output
`[20, -5, 3]`
### Add Json Array Value (Boolean)
Adds a true/false value to the end of a JSON array.
#### What it does
Same idea as the other Add variants, but the value being appended is a true/false.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The list you want to add to.
**Value**
Boolean (true/false)
The value you want to append.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The updated array with the true/false added at the end.
**Value**
Boolean
The same value you passed in.
#### Example
**JsonArray** input
`[true, false]`
**Value** input
`true`
**JsonArray** output
`[true, false, true]`
### Add Json Array Value (JsonObject)
Adds a JSON object to the end of a JSON array.
#### What it does
Useful for building a list of records — for example a list of scores, settings, or scene items, where each entry has several named fields.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The list you want to add to.
**Value**
JSON object
The object you want to append. See the **JSON Objects** page for nodes that build one.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The updated array with the object added at the end.
**Value**
JSON object
The same object you passed in.
#### Example
**JsonArray** input
`[{"score": 10}]`
**Value** input
`{"score": 8}`
**JsonArray** output
`[{"score": 10}, {"score": 8}]`
### Add Json Array Value (JsonArray)
Adds another JSON array as a single entry — producing a nested list.
#### What it does
The inner array is added as *one* item. The outer array's size grows by one regardless of how many items are inside the array you're adding. This is how you build grids, rows-of-rows, or any nested structure.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The outer list you want to add to.
**Value**
JSON array
The array to add as one entry inside the outer one.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The updated outer array with the inner array added at the end.
**Value**
JSON array
The same inner array you passed in.
#### Example
**JsonArray** input
`[[7, 4]]`
**Value** input
`[9, 2]`
**JsonArray** output
`[[7, 4], [9, 2]]`
---
## Read an element
These five nodes all pull a single item back out of a JSON array. You pick the item by its position (its **Index**). Each variant returns the value as a specific type — pick the one that matches what you stored.
The array isn't modified — the value is read out, the array stays the same.
### Get Json Array Element (String)
Reads one item from a JSON array as text.
#### What it does
Returns the item at the position you specify. Use this when the item at that position is a piece of text.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The array to read from. Must not be empty.
**Index**
Integer
Which position to read. The first item is at `1`.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The same array you passed in.
**Index**
Integer
The same position you asked for.
**Value**
Text
The item at that position.
#### Example
**JsonArray** input
`["apple", "banana", "cherry", "avocado"]`
**Index** input
`3`
**Value** output
`"cherry"`
### Get Json Array Element (Number)
Reads one item from a JSON array as a number.
#### What it does
Returns the item at the position you specify. Use this when the item at that position is a number.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The array to read from. Must not be empty.
**Index**
Integer
Which position to read. Starts at 1.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The same array you passed in.
**Index**
Integer
The same position you asked for.
**Value**
Number
The number at that position.
#### Example
**JsonArray** input
`[12, 47, 88, 103, 256, 411]`
**Index** input
`5`
**Value** output
`256`
### Get Json Array Element (Boolean)
Reads one item from a JSON array as a true/false value.
#### What it does
Returns the item at the position you specify. Use this when the item at that position is a true/false value.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The array to read from. Must not be empty.
**Index**
Integer
Which position to read. Starts at 1.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The same array you passed in.
**Index**
Integer
The same position you asked for.
**Value**
Boolean
The true/false value at that position.
#### Example
**JsonArray** input
`[true, false, true, true, false, false, true]`
**Index** input
`6`
**Value** output
`false`
### Get Json Array Element (JsonObject)
Reads one item from a JSON array as a JSON object.
#### What it does
Returns the item at the position you specify. Use this when each item in the array is a JSON object (a record with named fields). Once you have the object, the nodes on the **JSON Objects** page can read individual fields.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
### Get Json Array Element (JsonArray)
Reads one item from a JSON array as another JSON array (a nested array).
#### What it does
Returns the item at the position you specify. Use this when each item in the outer array is itself an array — for example a grid or a list of points.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
---
## Inspect
These three nodes don't read items out of the array — they tell you *about* it. Use them when you need to know how big the array is, what positions are valid, or what kind of item is at a given position.
### Get Json Array Size
Tells you how many items are in the array.
#### What it does
Returns the total number of items as a number. An empty array returns `0`.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The array to measure.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The same array you passed in.
**Size**
Number
How many items the array contains.
#### Example
**JsonArray** input
`["red", "green", "blue"]`
**Size** output
`3`
### Get Json Array Indices
Gives you the list of valid positions in the array.
#### What it does
Returns each valid index in the array, one after another — `1, 2, 3, …` up to the array's size. Handy when you want to step through every item using a loop construct or for-each pattern.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The array whose positions you want.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The same array you passed in.
**Indices**
Integer
Each valid position in turn (`1`, then `2`, then `3`, …).
#### Example
**JsonArray** input
`["red", "green", "blue"]`
**Indices** output
`1, 2, 3`
#### Tips
- **Use with Get.** Pair this with one of the **Get Json Array Element** nodes to read every item in turn.
- **Empty arrays.** If the array is empty, no indices are produced.
### Get Json Array Element Type
Tells you what kind of item is stored at a given position.
#### What it does
Returns the type of the item at the position you specify, as a short piece of text: `"String"`, `"Number"`, `"Boolean"`, `"JsonObject"`, or `"JsonArray"`. Use this when an array can hold different kinds of items and you need to decide which **Get** node to use.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The array containing the item. Must not be empty.
**Index**
Integer
Which position to check. Starts at 1.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The same array you passed in.
**Index**
Integer
The same position you asked for.
**Type**
Text
The type of the item at that position, as a short name.
#### Example
**JsonArray** input
`[3.14, 2.71, 1.41, 1.62, 0.57, 6.28]`
**Index** input
`5`
**Type** output
`"Number"`
---
## Convert
### Json Array To String
Turns the entire array into a single piece of text.
#### What it does
Produces a text representation of the whole array, written in JSON form. Useful when you need to save the array to a file, send it to another system, or put it somewhere that only accepts text.
The original array isn't modified — you get the same array back plus a text version.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**JsonArray**
JSON array
The array to convert.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**JsonArray**
JSON array
The same array you passed in.
**Result**
Text
The text version of the array.
#### Example
**JsonArray** input
`["red", "green", "blue"]`
**Result** output
`'["red", "green", "blue"]'`
#### Tips
- **Reverse direction.** To go back from text to an array, use **Create Json Array From String** at the top of this page.
---
## Related
- **JSON Objects** — the matching page for working with records that have named fields.
# Data Types \ String \ Operations
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-09/qObimage.png) Add String
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/LKmimage.png)
This node can be used to add two strings to each other.
In the below example a **Score** string variable is input to this node, along with **My Score is** string filled in. The result is input to a Set String Variable node, into another string variable name **MyScore** which is linked to a Variable Writer in the scene to be displayed.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/EsXimage.png)
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Find
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)The "**Find**" node is used to search for a specific word, group of letters, or substring within a larger sentence or string value. If the specified text is found, the node returns the number of characters from the beginning of the string to the start of the found text. If the specified text is not found, the node returns -1. This allows users to detect and locate specific content inside a string.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-example.jpg)
In this example, the **Find node** is used to search for the word "apple" in a string variable with the initial value "I like apple pie." When the user triggers the object, the Variable with Initial node retrieves the string, and the Find node looks for the word "apple." The resulting index is then stored in a number variable named "Value" using the Set Number Variable node, which can then be connected to a Variable Writer to display the result during the VR experience. If "apple" is found, the Value variable stores the position where "apple" starts in the sentence. If not found, the Value variable is set to -1.
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/response-value-string-lowercase.png)Lower Case
The "**Lower Case**" can be used to covert an upper case string to lower case, as shown in the example below.
In this example the string "SIMLAB SOFT" is input inside this node, which is executed when **Activate** scene node is triggered. This will result in updating the valued of LowerCaseName string variable to be simlab soft.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/iz7image.png)
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-09/pIoimage.png)Replace
**Replace** node can be used to replace specific **Target[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/2yoimage.png)** text string from a **Source** text string with the **Replacement** string.
In the below example the node is executed upon clicking **Activate** node, and has three string inputs. Source which is main string "Hello Name". Target string which is "Name", and Replacement string which is Samia.
The Result greeting from this will be "Hello Samia".
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/QeXimage.png)
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/BDvimage.png)Length
This node returns the length of a given string.
In the example below the node is triggered by
clicking **Activate** geometry, and it's filled with a long paragraph string. The length result is stored in variable **Result** in the **Set Number Variable** node.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/1rQimage.png)
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-09/SKCimage.png)[ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/BDvimage.png)Upper Case
Contrary to the "**Lower Case**" node this node coverts a loser case string to upper case, as shown in the example below.[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/8F5image.png)
In this example the string "simlab soft" is input inside this node, which is executed when **Activate** scene node is triggered. This will result in updating the valued of UpperCaseName string variable to be SIMLAB SOFT.
####
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/t3Wimage.png)
# Data Types \ String \ Compare
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-09/SM6image.png) Equal
A compare node that takes two input strings and compares them if equal or not. [](https://simlab-soft.com/help/uploads/images/gallery/2025-09/jxpimage.png)
####
####
####
#### Example
In the example below, two not equal strings has been input to this node, thus the output result would be false. The output is used as an input to Show/Hide node for a sphere, that won't be shown in this case.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/asNimage.png)
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/ycFimage.png)Not Equal
Contrary to the previous node this one compares
two input strings for not being equal.[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/uhbimage.png)
#### Example
In the example below, two equal strings has been input to this node, thus the output result would be false. The output is used as an input to Show/Hide node for a sphere. In this case the sphere will be shown.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/Renimage.png)
# Data Types \ String \ Variable
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/xa2image.png)Set
With this string variable node a user can set a string variable by Value or Expression.
#### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/N7himage.png)By Value
Using this node a string variable is set by value, as shown in the example below. The **Greeting** variable is set using string input node with "**Good day sir!**"
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/berimage.png)
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/993image.png)
#### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/U5mimage.png)By Expression
Using this node a string variable is set by expression, as shown in the example below. The **Name** variable is set using an expression input node with string.lower() expression.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/vizimage.png)
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/ihsimage.png)
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/WWvimage.png)Get
This node is used to get a string variable value. As shown in the example below, the string variable **Greeting** is gotten as input to this node.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/Ljeimage.png)
# Data Types \ String \ Expression
---
###  Evaluate String Expression
The **Evaluate String Expression** response enables the system to implement an expression in Lua language. Supported expressions can be found at this **[link](https://devdocs.io/lua~5.4/)**. Once the response is executed, the expression result can be acquired through the Result port.
####
#### Example
In this example, an **Evaluate String Expression** response enables the system to execute a Lua expression. Once the response is executed, the result of the expression can be retrieved through the **Result** port and can be displayed using a variable writer during the VR Experience.
---
# Data Types \Color
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/uF3image.png)Color To RGB
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/Zjrimage.png)
This node converts colors to their RGB components. After that changes can be done to these components.
#### Example
In the below example "**Node Triggered**" node is linked to "**First\_drawer**" geometry that when clicked the "**Get Material Color**" node gets "**Drill\_material**". In "**Color To RGB**" node the color of this material is converted to its RGB components, and then a value of "**1**" is added to its Green component. The RGB components are converted back to color using "**RGB To Color**" node, and the material color is set in the "**Set Material Color**" node.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/nLvimage.png)
Below is the effect of changing material color components.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/QiVimage.png)[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/GpFimage.png)
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/Jxoimage.png)RGB To Color
As in the above example, "**RGB To Color**" converts
RGB components back to color.[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/mxfimage.png)
# Data Types\Boolean\ Expression
---
This node can be used to generate values (true or false) that can
trigger events throughout the interactive experience.[ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/wieimage.png)
#### Example
In the example below when "**3DGeom-7**" is clicked, the expression in "**Evaluate Boolean Expression**" node is checked to execute the node after or not. In this case the expression is simple "**==**" which is true, so the "**3DGeom-7**" geometry will be set to Grabbable.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/GCtimage.png)
# Data Types\Time
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/93yimage.png)Time Interval
This node calculates the time difference between[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/Gakrr5image.png)
"**Start**", and "**End**" times. It stores the result in
an integer "**Interval**" out put.
###
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2025-09/ZqZimage.png)Update Time
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/FvKimage.png)
This node can be used to store time variables.
#### Example
The example below demonstrates the use of both time nodes above. In it the value of "**inisial\_time**" variable is updated upon Scene Start. Then when "**Box**" geometry is clicked the value of "**current\_time**" variable is updated. Then the "**Time Interval**" node is executed, where "**result**" variable is calculated as difference between both times.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/xvWimage.png)
In the experience the "**result**" variable is connected to[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/NxPimage.png)
a Variable writer to display its value.
# Scene State
---
### Apply
This node can be used to apply a scene state when an[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/YOwimage.png)
action is done in the 3D area.
#### Example
In the below example when "**Body\_9**" is clicked the "**BlueColor\_pump**" scene state is applied.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/CPiimage.png)
---
### Find By Name
In complicated scenes with large number of scene [](https://simlab-soft.com/help/uploads/images/gallery/2025-09/lgmimage.png)
states, this node can come in handy. The user can use
this node to search for a scene state and then apply
it or do any action with it.
#### Example
In the example below this node is used to search for "GreenColor\_pump" and then applied the scene state.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/548image.png)
# Sequence
---
### Attach Sequence To
[Creating sequences](https://simlab-soft.com/help/books/simlab-composer-help/page/sequence-timeline) can be done from animating an object in the scene. This sequence can be attached to Hand or an Object in VR.
#### Hand
With sequences available in the Sequences Library, a sequence can be attached to the Hand in VR experience using this node in Dynamic Training Builder.
#### Example
Check this [tutorial ](https://www.youtube.com/watch?v=YkPAQTO5GKE)for the example below, where Boolean expressions were created and upon checking the Boolean Expression a sequence is attached to Hand.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/EtGimage.png)
#### Object
This node can be used to connect a controller grabbable object to a sequence in VR.
#### Example
In the example below the "Switch" sequence is attached to "Handle" object, when Controller "Gloves" geometry moves it. In this example a simple grabbable sequence can do the job, but this is just to demonstrate use of this node.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/HOwimage.png)
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/Y4ximage.png)
#### Example 2
In this example we have a path for a box to walk along being controlled by a magnet.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/5Cnimage.png)
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/095image.png)
---
### Playback Controls
Used to control sequence behavior.
#### Continue
##### Same Direction
The selected sequence will continue[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/GDxj0simage.png)
to play in the same direction.
##### Set Direction
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/Niaimage.png)With this node the user can change the selected sequence direction, by selecting Reverse to True.
##### Example
In the below example a number of the above Playback Controls are used. Here on "**Scene Start**","**Play Sequence**" response is executed for "Elevator\_Up" sequence. Followed by a 1 second "**Delay**", then "**Stop Sequence**" for another one second "**Delay**". Then the sequence is continued, followed by another "**Delay**" then "**Resume Animation Sequence**" from start.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/iEZimage.png)
#### Play
##### Play Sequence/Play Sequence From Start
Both controls will play animation sequence, one from current position, and the other -as the name implies- will play it from start.
#### Reverse
##### Reverse
Reverse sequences starts the animation sequence in the reverse mode (from the last frame). The reverse control will start from the last frame not from the current (because it reverses the overall animation)
In the below example the "Elevator\_Up" sequence upon clicking "Elevator\_panel(2)" geometry will be played from start. So if the elevator at that time was at the top position, it would go down then -as the sequence implies- would go up, then wait for 5 seconds, then "Reverse Sequence" that is go down from last frame.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/TSAimage.png)
####
####
####
####
##### Reverse From End
This control will start the sequence from the end, even if it hasn’t been played yet.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/QSBimage.png)
#### Flip
Flip sequences flips current animation (that is, forward animation will be backward , backward animation will be forward). Think about it like we are opening a door and we pause the animation in the middle, flip control will return the door back from the current frame to original start position.
#### Stop
Stopes the animation sequence, as shown in examples presented in this section.
---
### Playback Properties
#### Current Frame
##### Get Sequence Current Frame
This node will get the value of the current sequence frame, the user can then use this value in any operation. In the example below the value of the current sequence frame is stored in "Current\_Frame" variable, which is set to the "VR Variable Writer" in the scene to display its value.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/0ESimage.png)
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/eqmimage.png)
#####
##### Set Sequence Current Frame
If the user wants to go to a specific frame in the sequence this is the function to use. In the below example upon clicking node the sequence current frame is set to 10.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/8l6image.png)
To show the result we got the valued of the current frame and assign it to "Current\_Frame" variable that is displayed in the variable writer as shown below.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/PSnimage.png)
#### Full Range
This node can be used to calculate the full range of a sequence.
##### Get End
Gets and outputs the end frame of the selected [](https://simlab-soft.com/help/uploads/images/gallery/2025-10/tddimage.png)
sequence, when triggered.
#####
##### Get Start
Gets and outputs the start frame of the selected [](https://simlab-soft.com/help/uploads/images/gallery/2025-10/b3timage.png)
sequence, when triggered.
#### Looping
Sequences can be set to loop after finishing.
##### Get Sequence Looping
This node will get the looping status of the input[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/2m2image.png)
sequence, whether true or false.
#####
##### Set Sequence Looping
This node will set the looping status for the input [](https://simlab-soft.com/help/uploads/images/gallery/2025-10/ElPimage.png)
sequence to either true or false.
#### Play Range
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/LKqimage.png)
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/hK7image.png)
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/dyeimage.png)
[](https://simlab-soft.com/help/uploads/images/gallery/2025-10/TQximage.png)
#### Play Rate (Speed)
#### Swing
#### Is Playing
#### Is Reversing
---
### Find By Name
# User
###  Show Mouse Cursor
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/GhKimage.png)
The **Show Mouse Cursor node** explicitly controls the visibility and functionality of the user's mouse pointer within the VR Viewer. When activated, the node checks the boolean Enable input for the specified User. Setting it to True displays the cursor on-screen, allowing the user to freely move it and click to interact with objects utilizing **Node Triggered** events. It is important to note that while this cursor mode is active, standard navigation is suspended—the user cannot walk or rotate their camera view until the node is activated again with the Enable input set to False, which hides the cursor and restores normal movement.
The **Show Mouse Cursor** mode is used for desktop/PC version of VR Viewer
# User \ Controller
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Attach To Hand
The **Attach to Hand** node enables the user to attach objects to specific parts of the hand in a VR environment by selecting the desired hand part. This node allows for precise placement of objects, such as tools or items, enhancing interactivity within the VR Experience. Once the attachment is configured, the object will remain in the chosen part of the hand during interactions.
#### Example
In this example, an **Attach to Hand node** is used to attach a syringe to the index finger once the "Hand Enter Node" event is triggered. The syringe is attached to the specified part of the hand automatically when the event occurs, enabling interaction with the object in the VR environment.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/response-node-detachfromhand.png) Detach From Hand
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/scLimage.png)
The **Detach From Hand** , detaches an object currently attached by the [Attach To Hand ](https://simlab-soft.com/help/link/369#bkmrk-number-variable-valu)response, so the object no more moves with the hand
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Trigger Beam
The **Trigger Beam node** enables the user to control the visibility of a beam coming out of the controller in the VR Experience, once the node is executed.
#### Example
In this example, a **Trigger Beam node** is used to hide the beam coming out of the controller once the object named Activate is triggered. When the event is triggered, the change is reflected during the VR Experience.
---
# User \ Transform
###  Get User Rotation
The **Get User Rotation** response enables the user to get the values of the User's head rotation, and allows them to store the values of the **Pitch**, **Yaw** and **Roll** and the results can be acquired through their output ports.
####
####
#### Example
In this example, a **Get User Rotation** response is used to check the head rotation angles (Pitch, Yaw and Roll). Once the object named Activate is triggered, the head rotation values (Pitch, Yaw, Roll) of the user with attribute InBuilding and Value Yes are calculated and stored in the variables named Pitch, Yaw, Roll, in order to use them in the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Teleport To Camera
The **Teleport To Camera** node enables the user to teleport to a new location by assigning a camera in the **CameraNode** field. Once the teleportation is executed, the user is moved to the position and orientation defined by the specified camera, the user can also decide whether this teleportation affect the host only or all the user in the experience (in case of collaboration).
#### Example
In this example, a **Teleport To Camera** response is used to move the user to a new location once the object named Activate is triggered. When triggered, the sound named Teleport\_Sound will play, and the user will be teleported to the location of the camera assigned in the Teleport To Camera node.
> [ ](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png)[Tutorial is available on SimLab VR Discord server](https://discord.com/channels/1062715275805470821/1272491882890399814/1272491882890399814 "Tutorial is available on SimLab VR Discord server")
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Attach User
The **Attach User** node allows users to attach the user to specific objects within the VR Experience. This node ensures that the user moves along with the object, providing an immersive experience where the user is fixed to the selected object throughout the VR environment, this can be decided to affect only the host or all user (in case of collaboration).
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-01/0dDimage.png)
In this example, the **Attach User** node is used to attach the user to a roller coaster at the start of the scene. When the scene starts, the user will be fixed to the roller coaster, moving along with it as it travels through the environment, providing an immersive experience.
> [ ](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png)[Tutorial is available on SimLab VR Discord server](https://discord.com/channels/1062715275805470821/1298557994208071701/1328733596726333451 "Tutorial is available on SimLab VR Discord server")
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Detach User
The **Detach User** node allows users to detach from an object within the VR Experience. This node provides a straightforward way to release the user from an object they were attached to, ensuring they regain control of their own movement and are no longer fixed to the selected object or location.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-01/Fw9image.png)
In this example, the **Detach User** node is used to detach the user from a roller coaster when the roller coaster's animation ends. Once the animation is complete, the user will be released from the roller coaster.
> [ ](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png)[Tutorial is available on SimLab VR Discord server](https://discord.com/channels/1062715275805470821/1298557994208071701/1328733596726333451 "Tutorial is available on SimLab VR Discord server")
# User \ Gadget
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Equip To User
The **Equip to User** Node enables the user to equip or unequip gadgets, adjacent objects, or HUD elements to the user within the VR environment. This node enhances interactivity by enabling users to interact directly with various items and interface elements as part of their virtual experience.
#### Example
In this example, the **Equip to User Node** is used to equip a gun controller to the user. Select the gun object, then assign it to the controller by clicking on the plus icon in the User Gadget window.
To activate the gun gadget, press the right grip button then the gun will be attached to the User's controller in the VR environment.
---
# User \ Attributes \ String
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Set User Attribute (String)
The **Set User Attribute** response enables user to set a value to an attribute by either typing in a string value in the value field or by attaching a value or a variable node to that port. Then once the response is executed, the variable value can be acquired through the **Value** port.
####
#### Example
[ ](https://simlab-soft.com/help/uploads/images/gallery/2024-08/euiimage.png)
In this example, we added a **String User Attribute** called it **Indoor** with the value **No**
Once the user enters the object named Building, the **Indoor** attribute's value will be set to **Yes**, then when the object named Teleport Button is triggered, the user(s) with the attribute named **Indoor** and the value **Yes** will be teleported to the **Outside** CameraNode location.
---
# User \ Point To Object
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Point To Object
The **Point To Node** enables the user to be guided to the location of a specific place or object within the scene. When this node is activated, an arrow is displayed, pointing to the location of the assigned SceneNode within the VR environment.
#### Example
In this example, the **Point To Node** is used to guide the user to the location of an object named button when the Scene Start event occurs. As soon as the scene begins, an arrow appears, pointing directly to the button location, helping the user finding it within the VR environment.
---
# User \ Set Mode
###  Set Interaction Mode
[](https://simlab-soft.com/help/uploads/images/gallery/2026-04/image.png)
The **Set Interaction Mode node** dynamically changes how participants engage with the VR environment. When activated, the node evaluates the targeted User input—which can be configured for either "Host Only" or "All Users" and immediately switches their current control state to the selected Mode. The available interaction modes include:
- **Default:** The standard, baseline interaction and movement mechanics of the VR Viewer.
- **Drawing:** Enables the user to freely draw directly onto 3D surfaces within the scene.
- **Scene Building:** Unlocks spatial editing capabilities, allowing the user to dynamically adjust the location, rotation, and scale of 3D objects to freely move and place models around the environment.
- **Measurement:** Enables the user to draw straight lines across the scene, accurately measuring distances and lengths in meters.
###
---
###  Set Night Mode
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/rKvimage.png)
**The Set Night Mode node** instantly alter the environmental lighting and skybox of the VR scene to nighttime. Once activated, the node evaluates the boolean Enable input—transitioning the scene's overall environment to a dark night mode.
# User Name & ID
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Get User ID
The **Get User ID node** is used to retrieve the unique identifier of the user interacting within the VR environment. This ID can be utilized for various purposes, such as tracking user actions or customizing experiences based on the user.
#### Example
In this example, the **Get User ID node** is used to create a student attendance system. When the user triggers the Activate event, the "Get User ID" retrieves the Student ID number and stores it in the "`attendance_ID"` variable using the "Set Number Variable" node.
**Note:** To retrieve the User ID, the experience must be run from a **logged-in** account in SimLab VR Viewer.
---
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png)Get User Name
The **Get User Name node** is used to retrieve the name of the user interacting within the VR environment. This name can be utilized for various purposes, such as personalizing interactions or saving progress tied to a specific user.
#### Example
In this example, the "Get User Name" node is used to create a student attendance system. When the user triggers the Activate event, the "Get User Name" retrieves the student's name and stores it in the `attendance_UserName` variable using the "Set String Variable" node.
**Note:** To retrieve the User Name, the experience must be run from a **logged-in** account in SimLab VR Viewer.
---
# Material
###  Copy Material
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/7KYimage.png)
The Copy Material node duplicates an existing material and create a completely independent instance. Upon triggering the Execute input, the node takes the specified Material input and outputs a newly generated Copy of that material, which can then be freely modified without altering the original source.
---
###  Copy Material Properties
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/6MLimage.png)
The Copy Material Properties node transfers visual attributes directly from one material to another without generating a new instance. When the Execute input is triggered, the node takes the characteristics of the Source Material input and applies them directly to the Target Material input, instantly overwriting the target's previous properties.
##### Example:
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/9lXimage.png)
In this example, triggering the "Change Color" object prompts the system to execute the Copy Material Properties node. Once activated, the node takes all the visual attributes from the "cabinets" source material and immediately applies them to the "tables" target material, causing any 3D objects using the tables material to instantly match the appearance of the cabinets.
# Material \ Texture
###  Set Texture From File
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/YgPimage.png)
This node replaces the current texture of a specified material with a 2D image file stored in your Resource Management system. By inputting the exact file name, you can dynamically update the visual appearance of any object using that material during the experience.
# Execution
###  Branch on Expression
The **Branch on Expression** response enables the user to evaluate an expression with the possible outputs of True or False each time the event connected to it is triggered. Once the response is executed, the result of the evaluation can be acquired through the **True** or **False** ports.
#### Example
In this example, a **Branch on Expression** response is used to evaluate an expression once the user triggers the object named Activate. The result of the expression, which will be either True or False, if the result was true, the object named "Variable\_01" will be shown, if it was false, the object named "Variable\_02" will be shown.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/response-delay.png) Delay
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/UO0image.png)
**The Delay node** waits for the specified **Duration** (in seconds), then executes the node linked to its **Execute** output.
Duration can be an integer or a float less than one to achieve sub-second delays.
---
###  Loop
The **Loop node** enables the user to repeatedly execute a connected response for a specified number of times as defined in the Number of Loops field. Each time the event connected to the loop is triggered, the response is executed repeatedly, and the loop continues until the assigned number of repetitions is completed.
#### Example
In this example, a **Loop node** is used to repeatedly execute the connected response that decreases the value of a number variable by one. The Decrement response is repeated for the number of times specified in the **Number of Loops** field, with the duration between each repetition set in the **Interval** field. Once the assigned number of repetitions is completed, the sound named **Countdown\_Over** plays.
---
###  Run Script
The **Run Script** node allows the user to execute advanced functions using the **Lua programming language**. This node provides flexibility by enabling custom scripts to be triggered when an event occurs. Allowing for complex operations and logic to be carried out as defined in the script. This node is ideal for scenarios requiring functionality beyond the standard nodes, offering advanced customization and control over the system.
You can read about Lua Scripting in SimLab Training builder through the following Blog:
**[Lua Scripting Blog](https://blog.simlab-soft.com/lua-scripting-in-simlab-training-builder-from-beginner-to-beyond/ "Lua Scripting Blog")**
> **[Lua Documentation for SimLab Training Builder](https://www.simlab-soft.com/3d-products/docs/help/scripting/English/Lua/ "Lua Documentation for SimLab Training Builder")**
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/response-customevent-trigger.png) Trigger Custom Action
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/xylimage.png)
Calling this **Trigger Custom Action** will execute the corresponding [**Custom Action** event ](https://simlab-soft.com/help/link/581#bkmrk-custom-event%C2%A0)(based on the matching ID), passing along any optional information provided in the info field.
This is useful when you want multiple paths in your experience to produce the same response — without duplicating it each time.
---
# SceneNode \ Management
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Cast SceneNode
The **Cast SceneNode** enables the user to change the type of a SceneNode by selecting a typeInfo from the list, such as sound, 3D object, video, gadget, or camera. This node identifies the assigned SceneNode as the chosen type, allowing it to function accordingly within the VR environment.
#### Example
In this example, Animals sounds are assigned to the animals as **SceneNode** type
A **Cast SceneNode** is used to identify the SceneNode of an animal object (dog, cat, and horse) as a sound. An attribute named "Sound" is added to all three animals, and the corresponding sound is assigned to each. When the user triggers the animal SceneNode, the **Cast SceneNode** plays the sound assigned in the attribute.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Set Node Collision Enabled
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)The **Set Node Collision Enabled** node is used to enable or disable collision for the user. This can be utilized to allow the user to pass through objects or be blocked by them within the VR environment.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/S2himage.png)
In this example, the **Set Node Collision Enabled** node is used to disable collision for the user when the scene starts. The wall is assigned as the target object, and the collision is set to "False," allowing the user to pass through it.
This is shown in the following tutorial
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Delete SceneNode
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)
The **Delete SceneNode** node enables users to remove a specified object from the scene during a VR Experience. This node allows for dynamic scene modifications by deleting objects based on interactions or conditions, making the environment more interactive and adaptable. Once executed, the specified object is permanently removed from the scene.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-02/0QSimage.png)
In this example, the **Delete SceneNode** node is used to remove a trigger box from the scene. The **Node Triggered** event is activated when the user triggers or clicks on an object named "Remove." As soon as the object is triggered, the **Delete SceneNode** node removes the trigger box from the scene, preventing further interactions with it.
---
###
###  Enable Walk-Through
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Eoyimage.png)
The **Enable Walk-Through node** explicitly controls the physical collision properties of a targeted 3D object within the VR Viewer. When activated, the node uses the boolean Enable input to determine the collision state of the specified SceneNode—allowing users to seamlessly pass directly through the object without physical obstruction if set to *True.*
---
###  Find Node By Name
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/zXiimage.png)
The **Find Node By Name node** searches the VR environment and dynamically locate a specific 3D object based on its assigned text identifier. When activated, the node takes the exact string provided in the Name input, searches the scene to find the corresponding object, and outputs that specific SceneNode reference.
###
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/yeKimage.png)
###
---
###  Get Node Name
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Ynximage.png)
The **Get Node Name node** retrieves the exact text identifier of a specific 3D object within the scene. When activated, the node takes the targeted SceneNode input, extracts its assigned name, and outputs this text as a string value through the Result pin.
---
###  Make Node Copy
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/m3ximage.png)
The **Make Node Copy node** duplicates a specific 3D object along with an independent copy of its material. Once activated, the node takes the targeted SceneNode input and generates a completely separate Copy, ensuring that any subsequent material or texture changes applied to this new object do not affect the original source.
---
###  Make Node Instance
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/HRAimage.png)
The **Make Node Instance node** generates a direct clone of a specific 3D object in the scene. When activated, the node takes the targeted SceneNode input and creates a new Instance that shares the exact same material properties as the original.
##### Example:
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/PCVimage.png)
In this example, we create a simple shooting mechanic where firing a gun generates and shoots a bullet toward a target:
1. A **Node Is Grabbed** node continuously checks if the user is holding the "Gun" object, enabling the next node if the condition is met.
2. A **Grip Pressed** event node listens for the user to press the right hand's grip button, acting as the trigger to fire the weapon.
3. Once the grip is pressed, the **Make Node Instance** node activates, immediately generating a new instance of the "Bullet" object in the scene.
4. A **Get Node Location** node is then used to retrieve the exact X, Y, and Z coordinates of a specific "AimTarget" object.
5. Finally, a **Set Node Location (Animated)** node takes the newly generated bullet instance and smoothly moves it to the AimTarget's coordinates over a quick duration of 0.2 seconds, simulating a flying projectile.
---
###  Set Node Simulate Physics
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/eVHimage.png)
The **Set Node Simulate Physics node** activates or deactivates real-time physics calculations for a specific 3D object within the VR Viewer. When activated, the node uses the boolean Enable input to determine the object's physical state, allowing the object to react to gravity, collisions, and user interactions based on its assigned material physics properties
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/untitled-1.png)
To configure how an object behaves during simulation, navigate to the Properties panel and select the Material tab. Under the Physics Properties section, you can adjust specific physical attributes for that material, such as its Density, Friction, and Restitution, which directly impact how the object interacts with the environment when physics are enabled.
# SceneNode \ Transform
###  Get Node Transform
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/3kSimage.png)
The **Get Node Transform node** retrieves the complete spatial data—including the exact location, rotation, and scale values—of a specific 3D object in the scene. When activated, the node takes the targeted SceneNode input, extracts its current transform matrix, and outputs this combined information through the Transform pin.
---
###  Set Node Transform
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Inximage.png)
The **Set Node Transform node** instantly applies a complete set of spatial data—encompassing location, rotation, and scale—to a specific 3D object. Once activated, the node evaluates the targeted SceneNode and immediately updates its physical presence in the scene to perfectly match the data provided through the Transform input.
---
###  Set Node Transform (Animated)
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/hFSimage.png)
The **Set Node Transform (Animated) node** functions similarly to the standard set transform node, but it smoothly transitions the 3D object to the new location, rotation, and scale over a defined period. When activated, the node takes the targeted SceneNode and seamlessly tweens its spatial data to match the provided Transform input over the specific amount of time defined by the numerical Duration input (measured in seconds).
---
###  Swap Nodes Transform
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/aiximage.png)
**The Swap Nodes Transform node** instantly exchanges the complete spatial data—including location, rotation, and scale—between two distinct 3D objects in the scene. When activated, the node evaluates the targeted objects provided in the SceneNode A and SceneNode B inputs and simultaneously swaps their placements, rotations, and proportions.
# SceneNode \ Transform \ Location
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Y8Yvisual.png)Visual \\ Get Node Visual Location
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/z1Kimage.png)
The **Get Node Visual Location** node enables the system to retrieve the exact X, Y, and Z coordinates of a SceneNode based on its absolute visual representation in the 3D scene.
Unlike standard location nodes that calculate position relative to a parent object, this node fetches the true visual position of the object within the environment, completely unaffected by the scene's parent-child hierarchy system.
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Y8Yvisual.png)Visual \\ Set Visual Location
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/R0Timage.png)
The **Set Node Visual Location** node enables the system to instantly move a SceneNode to specific X, Y, and Z coordinates within the absolute visual space of the 3D scene. By directly altering where the object appears visually, this node completely bypasses any positional offsets or transformations that the object might normally inherit from its parent hierarchy.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/nVwimage.png)
In this example, an interaction is set up to match the positions of two independent objects.
1. Upon interacting with the "Ball" object, the **Node Triggered** event initiates the execution flow.
2. The **Get Node Visual Location** node extracts the true visual X, Y, and Z coordinates of the "Ball" in the scene.
3. These coordinate values are then fed directly into the X, Y, and Z inputs of a **Set Node Visual Location** node assigned to a "Target" object. This instantly moves the Target to the exact visual location of the Ball, regardless of how deeply nested either object is within the scene's hierarchy.
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Y8Yvisual.png)Visual \\ Set Node Visual Location (Animated)
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/2Vlimage.png)
The **Set Node Visual Location (Animated)** node enables the system to smoothly move a SceneNode to specific X, Y, and Z coordinates within the absolute visual space of the 3D scene over a set period.
Similar to the standard **Set Node Visual Location** node, this movement completely bypasses any positional offsets or transformations inherited from the object's parent hierarchy. However, this animated variant includes an additional **Duration** parameter. Instead of instantly snapping the object to the new coordinates, this node creates a smooth transition (tweening) from its current visual location to the target location over the specified number of seconds.
---
###  Fall To Surface
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/SiBimage.png)
The F**all To Surface node** instantly repositions a specific 3D object directly onto the nearest 3D surface located immediately below it in the scene. When activated, the node takes the targeted SceneNode input and immediately updates its vertical placement to simulate a sudden, instantaneous drop, resting the object perfectly against the underlying geometry.
###  Fall To Surface (Animated)
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/nXaimage.png)
The **Fall To Surface (Animated) node** functions similarly to the standard fall node, but instead of an instant drop, it smoothly transitions the 3D object down to the nearest underlying surface over a defined period. Once activated, the node takes the targeted SceneNode and seamlessly tweens its vertical descent until it rests on the geometry below, completing the fall animation over the exact amount of time specified by the numerical Duration input (measured in seconds).
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Get Node Location
The **Get Node Location** response obtains the X, Y, and Z coordinates of an object's location each time the event connected to it is triggered. Once the response is executed, the coordinates can be acquired through the **X**, **Y**, and **Z** ports.
####
#### Example
In this example, a **Get Node Location** response is used to obtain the X, Y, and Z coordinates of an object named Table once the user triggers the object named Activate. The coordinates are then stored in variables named X, Y, and Z, which can be connected to a variable writer to be displayed during the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Set Node Location
The **Set Node Location** response enables the user to set the location of an object to specific X, Y, and Z coordinates by either typing in the numerical values or by attaching a variable node to those ports. Once the response is executed, the object's new location is applied using the provided coordinates.
####
#### Example
In this example, a **Set Node Location** response is used to assign the X, Y, and Z coordinates stored in variables named X, Y, and Z to an object named Pot once the user triggers the object named Activate. The object's new location is set based on these coordinates, allowing the updated position to be reflected during the VR Experience.
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png)Set Node Location (Animated)
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/JRIimage.png)
The **Set Node Location (Animated)** node enables the system to smoothly move a SceneNode to a specific global coordinate in the 3D space over a set period. this node creates a seamless tweening effect from the object's current position to its new target destination
This differs significantly from the standard **Set Node Location** node, which instantly snaps or teleports the object to the new coordinates without any transition. The animated variant is ideal for creating moving platforms, sliding doors, or moving vehicles.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/a35image.png)
In this example, an interactive elevator mechanism is created.
1. Upon interacting with the button object, the **Node Triggered** event initiates the execution flow.
2. The **Get Node Location** node is used to retrieve the current X, Y, and Z global coordinates of the "Elevator" object.
3. To move the elevator up, the Y-axis coordinate is passed into an **Add** node, where 5 units are added to its current value. The X and Z coordinates remain unchanged.
4. Finally, the **Set Node Location (Animated)** node applies these new coordinates to the elevator object. The **Duration** parameter is set to 3, meaning it will take exactly 3 seconds for the elevator to smoothly transition (tween) to its new position 5 units higher.
---
# SceneNode \ Grab
###  Ignore grabbing
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/zRnimage.png)
The **Ignore Grabbing node** explicitly prevents a specific 3D object from being picked up or interacted with by the user's hands during the VR experience. When activated, the node disables the grabbable state of the targeted SceneNode if set to True. This node is highly useful for complex models where you want to enforce realistic interactions by restricting grip points, allowing you to easily exclude certain parts of a grouped object from being grabbed without having to detach or separate the components from the main assembly.
##### Example:
In this example, we configure a screwdriver so that the user can only pick it up by its handle, preventing them from grabbing it awkwardly by the metal rod or tip:
If **Set Node Grabbable State node** is used on the handle part of the screw driver alone, only the handle will move along with the grabbing hand, leaving the rest of the screw driver's assembly in place. Instead, **Ignore Grabbing** node should be used to exclude unwanted parts from being grabbed:
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/ccwimage.png)
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/RgNimage.png)
1. A **Set Node Grabbable State** node is activated to make the entire "Philips Screw Driver" parent group grabbable.
2. The execution flow immediately continues into an **Ignore Grabbing** node.
3. The specific "Screw driver head" object is assigned to the SceneNode input, and the Ignore boolean is set to True.
4. As a result, the metal tip is excluded from being a valid grab target, forcing the user to grab the tool properly by its handle while still ensuring the entire screwdriver assembly moves together as one cohesive object in the user's hand.
---
###  Set Grabbable Sequence
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/rDjimage.png)
The Set Grabbable Sequence node makes a specific 3D object interactively grabbable by assigning an animation sequence to it during the VR experience. Once activated, the node evaluates the targeted SceneNode and attaches the specified Sequence input, defining exactly how the object animates when grabbed and manipulated by the user. This versatile node can be used to add a sequence, dynamically switch between different sequences on the fly, or completely remove an existing sequence from a grabbable object before continuing the logic flow.
##### Example:
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/68Bimage.png)
In this example, we use the Set Grabbable Sequence node to create a dynamic gear stick that changes states based on the user's interactions:
1. A **Set Grabbable Sequence** node is used to make a "Gear Stick" object grabbable and attaching an animation sequence that, when grabbed, shifts the gear to first.
2. A **Watch Boolean Expression** node continuously monitors a string variable named "Clutch".
3. When the "Clutch" variable is set to "pressed", the watch node passes its OnTrue execution path to a second **Set Grabbable Sequence** node, which changes the grabbable object's sequence to a "Shift Gear To Second" sequence.
##### Tip:
Using the Set Grabbable Sequence node without attaching a sequence will disable the grabbing state of an object.
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/bkIimage.png)
Here, another **Watch Boolean Expression** node is used to monitor a variable called "engineStatus". When the "engineStatus" variable is set to "off", it triggers a **Set Grabbable Sequence** node targeting the gear stick, but this time with no sequence attached (Empty). Leaving the sequence input empty completely disables the grabbing interaction, turning the gear stick back into a still, non-interactable object.
---
###  Set Node grabbable State
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/5Nvimage.png)
**The Set Node Grabbable State node** evaluates the boolean Enable input to determine the targeted SceneNode's grabbable status—making the object fully grabbable by the user if set to True, or disabling grab interactions entirely to make it a static object if set to False.
# Resource
---
###  Delete Resource
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/lM9image.png)
The **Delete Resource** node enables the system to remove specific resources currently stored in the SimLab File Vault. This node simply requires the exact "FileName" of the target file as an input to execute the deletion. It outputs a "Success" boolean to confirm whether the specified file was successfully removed from the vault.
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2025-09/T47image.png) Download Resource
[](https://simlab-soft.com/help/uploads/images/gallery/2025-09/QXZimage.png)
The **Download Resource** node enables the system to download a specific file directly from the SimLab File Vault while a user is actively engaged inside a VR experience. This node requires the exact URL of the vault file to be linked into the node's input. Upon execution, it retrieves the file and provides a "Success" status alongside the downloaded "FileName" to be used in subsequent logic.
For more information, refer to SimLab Vault tutorial below:
---
###  Get Path From Resource
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/rPtimage.png)
The **Get Path From Resource** node enables the system to retrieve the exact URL or local file path of a specific resource or file. This node requires the exact "FileName" of the target file as an input.
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2026-03/response-resource-savevrpackage.png)Save VRPackage
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/jgoimage.png)
The **Save VRPackage** node enables the system to save the current, active VR experience as a standalone `.vrpackage` file, directly from within the VR session itself. It requires a "FileName" to name the new package and includes a "User" dropdown (e.g., "Host Only") to specify which user is authorizing the save. It outputs a "Success" boolean and the final "FileName" to confirm the action.
###
---
###  Upload Media From User
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/yl5image.png)
The **Upload Media From User** node functions similarly to the standard **Upload Resource** node by sending files to the SimLab File Vault via a designated URL. This node is specifically designed for multiplayer VR Collaboration environments.
It allows an administrator or host to target a specific user (via the "User" dropdown) and upload a file from *that user's* local device directly to the central File Vault. This is crucial for sharing media when a file exists only on an individual participant's machine and not on the host's device. Like the standard upload node, it outputs a "Success" boolean.
---
###
###  Upload Resources
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Zkrimage.png)
The **Upload Resource** node enables the system to send and save resources to the SimLab File Vault during a live VR experience. This node requires the destination URL for the file vault, as well as the assigned "FileName" for the file being uploaded and outputs a "Success" boolean.
For more information, refer to SimLab Vault tutorial below:
# External Connection \ WebSocket
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Open External Connection
SimLab Composer 14 introduces WebSocket support, enabling seamless integration with external systems allowing it to work with external hardware, co-simulation engines, and websites, unlocking numerous possibilities.
The WebSocket nodes (Open External Connection, Send Message, and [On Message Received](https://simlab-soft.com/help/books/dynamic-training-builder-nodes-manual/page/on-message-received)) are exclusively available in the Ultimate Edition.
The **Open External Connection** node enables the opening of a WebSocket connection to an external system. When the **Auto Handle Lua** is set to **true**, incoming messages containing Lua scripts will be automatically executed. This allows for real-time interaction between SimLab Composer and external systems, such as co-simulation engines or hardware, with the ability to dynamically execute Lua code as part of the interaction.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-02/screenshot-2025-02-02-162338.jpg)
**Input Ports:**
- Execute
- URL: WebSocket URL that includes the server IP address, port, channel (optional). Example: ws://server1.simlab-soft.com:8765/robots\_1
- Auto Handle Lua: Incoming messages containing Lua scripts will automatically execute those scripts If enabled (True).
**Output Ports:**
- Execute
- URL
- Auto Handle Lua
---
###
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Send Message Node
[](https://simlab-soft.com/help/uploads/images/gallery/2025-02/h5mimage.png)
The **Send Message** node allows you to communicate with the WebSocket server by sending messages. It is essential to ensure that the message format follows the protocol that the server and other clients can process. This node enables real-time interaction with external systems, making it possible to transmit data or commands to connected servers or clients.
**Input Ports:**
- Executive
- URL: WebSocket URL that includes the server IP address, port, and channel (optional). Example: ws://server1.simlab-soft.com:8765/robots\_1
- Message
**Output Ports:**
- Execute
- URL
- Message
# Media
###  Message Box \\ Show Message Box
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/EC3image.png)
The **Show Message Box node** displays a floating text panel directly above a specific 3D object in the VR scene. Once activated, the node takes the targeted SceneNode input and generates a visible UI element containing the text strings provided in the Title and Body inputs, to provide contextual information or instructions to the user.
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/lYyimage.png)
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/7O8image.png)
###
###
---
###
###  Message Box \\ Hide Message Box
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/3urimage.png)
The **Hide Message Box node** removes an active text panel currently displayed above a specific 3D object. When activated, the node takes the targeted SceneNode input and immediately dismisses its attached message box from the user's view.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Capture Picture
[](https://simlab-soft.com/help/uploads/images/gallery/2024-09/N18am3image.png)
The **Capture Picture node** is used to capture an image from a camera within the scene, and the captured image can then be displayed on a 3D object within the scene. This allows the user to take snapshots and show them in the VR environment, such as displaying a captured image on a screen or other surface.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-09/Xn9image.png)
A **Surveillance Monitor** is first created to display the captured images. This monitor is then attached to the VR camera.
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-example.jpg)
In this example, the **Capture Picture Node** is used to capture an image on a picture frame model when the user triggers the Activate event. Before that, the Cast SceneNode is used to identify the picture frame as a 3D object, as the Capture Picture Node only works with 3D objects.
---
###  Set Web Browser URL
The **Set Web Browser URL** node sets the URL for a web browser within the VR Experience. This node enables users to open and navigate to a specified webpage, making it possible to display web content like videos or instructional resources directly within the VR environment.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-02/G1Pimage.png)
In this example, the **Set Web Browser URL** node is used to open the SimLab website. The **Node Triggered** event is activated when the user triggers an object named "activate." As soon as the object is triggered, the **Set Web Browser URL** node is triggered, setting the URL to the SimLab website. The website then loads and is displayed on a web browser plane within the VR environment.
> [ ](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png)[Tutorial is available on SimLab VR Discord server](https://discord.com/channels/1062715275805470821/1298557994208071701/1312684216776916994 "Tutorial is available on SimLab VR Discord server")
# Media \ Variable Writer \
###  Get/Set Variable Writer Color
[](https://simlab-soft.com/help/uploads/images/gallery/2025-05/image.png)
The **Set / Get Variable Writer Color** nodes are used to control the color of the text displayed by a Variable Writer in the VR environment. The Set node allows you to change the text color dynamically based on events or conditions, while the Get node retrieves the current color of the Variable Writer. This is useful for customizing the visual appearance of displayed values, such as indicating status or drawing attention to changes.
---
###  Get/Set Variable Writer Prefix:
[](https://simlab-soft.com/help/uploads/images/gallery/2025-05/stCimage.png)
The **Set / Get Variable Writer Prefix** nodes are used to modify or retrieve the prefix text displayed before the variable value in a Variable Writer. The Set node allows you to add custom text before the value, such as labels or units, while the Get node retrieves the current prefix. This helps provide context to the displayed value, making it clearer for the user.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/JqVsuffix.png) Get/Set Variable Writer Suffix:
[](https://simlab-soft.com/help/uploads/images/gallery/2025-05/30Kimage.png)
The **Set / Get Variable Writer Suffix** nodes are used to modify or retrieve the suffix text displayed after the variable value in a Variable Writer. The Set node allows you to add custom text after the value, while the Get node retrieves the current suffix. This helps make the displayed value more informative and user-friendly.
###  Get Variable Writer Value
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/YYCimage.png)
The **Get Variable Writer Value** node retrieves the pure data value from a designated **SceneNode** (the target Variable Writer object) and outputs this core **Value** for use in your logic.
###
###  Set Variable Writer Value
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/F5iimage.png)
The **Set Variable Writer Value** node dynamically updates the core data of a target **SceneNode** (the Variable Writer object). By inputting a new string or numerical **Value**, the node overrides the writer's pure value while keeping any existing prefixes and suffixes perfectly intact.
###  Set Scene Font
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/W3Ximage.png)
The **Set Scene Font** node updates the typography globally by changing the font of every Variable Writer object currently present in the VR scene. This node requires the exact **FileName** of a TrueType Font (`.ttf`) as its input. To function correctly, the designated `.ttf` file must first be imported into your project via the Resource Management tab in SimLab Composer.
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/sEximage.png)
###
###  Set Variable Writer Font
The **Set Variable Writer Font** node allows for targeted typography changes by updating the font of a single, specific Variable Writer rather than the entire environment. By assigning the target **SceneNode** and providing the **FileName** of a valid `.ttf` font file (previously imported through the Resource Management tab), this node applies the new text style exclusively to the selected object, leaving all other text in the scene unaffected.
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/l1Oimage.png)
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/25Jvariable.png) Set Variable Writer Variable:
[](https://simlab-soft.com/help/uploads/images/gallery/2025-05/Lvcimage.png)
The **Set Variable Writer Variable** node is used to assign or change the variable displayed by an existing Variable Writer. This allows you to update the displayed content dynamically during the VR experience by switching the linked variable at any time.
# Media \ Dynamic Menu
###  Set Dynamic Menu Visibility
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/LmLimage.png)
The **Set Dynamic Menu Visibility** node controls whether dynamic menus (specifically used with the Objects Menu and Group Menus add-ons) are shown or hidden during a VR experience, using a boolean toggle where **True** displays the menu and **False** hides it.
---
# Media \ Sound
###  Record Sound
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/F1Uimage.png)
The **Record Sound** node initiates an audio recording session within the VR experience. This node utilizes a **User** dropdown parameter to determine whether the system captures microphone audio exclusively from the host or from all participating users. It outputs a **Success** boolean when the recording successfully starts.
---
###  Set Sound File
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/2umimage.png)
The **Stop Sound Recording** node halts an active audio recording session. This node requires a specified target **User** and an exact **FileName**. Upon execution, it stops the capture process and stores the resulting audio file directly into the project's Resource Management tab under the provided name
---
###  Set Sound Volume
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/RDGimage.png)
The **Set Sound Volume node** is used to adjust the audio playback level of a specific 3D sound object within the scene. The numerical Volume input operates strictly within a range of 0 (muted) to 4 (maximum amplification)
---
###  Sound Play
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/b8Gimage.png)
The **Sound Play node** controls the playback of the audio file stored within a specific 3D sound object. When activated, the node uses the boolean Play input to determine the action for the targeted Sound Node—triggering the sound to start playing from the start of the audio file, or stopping the audio and seeking to the start.
---
###  Sound Seek
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/09limage.png)
The **Sound Seek node** instantly jumps to a specific moment within the audio file attached to a 3D sound object. When activated, the node takes the targeted Sound Node and moves its playback position to the exact duration specified by the numerical Time input, measured in seconds.
---
###  Sound Toggle
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/rxDimage.png)
The **Sound Toggle node** easily switches between playing and pausing a specific 3D sound object in the scene. Once activated, the node evaluates the targeted Sound Node and automatically reverses its current playback status—pausing it if it is currently playing, or playing it if it is currently paused.
---
###  Stop Sound Recording
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/yRAimage.png)
The **Set Sound File** node dynamically attaches or updates the audio source of a designated **Sound Node** object in the scene. This node requires the exact **FileName** of an audio file previously imported into the Resource Management tab, strictly including its file extension (for example, "welcome.mp3"). It outputs a **Success** boolean to confirm that the sound file was located and attached properly.
# Media \ Video
###  Set Video File
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/W9Ximage.png)
The **Set Video File** node allows you to dynamically attach or change the media source of a specific Video Node within your scene. By assigning the target **Video Node** and inputting the exact **FileName** of your desired video (such as an `.mp4`), this node updates the object's media. For this to function correctly, the video file must first be imported into your project through the Resource Management tab. It also outputs a **Success** boolean to verify that the file was found and loaded.
##### Example
##### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/tRGimage.png)
In this example, an interaction is set up to load a short film onto a TV screen and immediately begin playback.
1. Upon interacting with the "Play Button" object, the **Node Triggered** event initiates the execution flow.
2. The **Set Video File** node is executed, assigning the previously imported video file "Short Film.mp4" directly to the "TV" video node object.
3. Once the file is successfully attached, the execution flow passes to the **Video Play** node (with the Play toggle set to **True**), which instantly starts playing the newly loaded short film on the TV screen.
---
###  Video Play
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/VFGimage.png)
The **Video Play** node provides direct control over the playback of a **Video Node** through a boolean **Play** input. Setting the toggle to **True** starts the video, while **False** stops it.
###  Video Seek
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/nfcimage.png)
The **Video Seek** node immediately moves the playback of the target **Video Node** to a specific **Time** defined in seconds. It enables precise navigation to any timestamp within the video's total duration.
###  Video Toggle
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/cLoimage.png)
The **Video Toggle** node switches the playback state of the assigned **Video Node** between playing and paused. Each execution reverses the current state of the video material, making it ideal for simple play/pause button interactions.
# Cloud
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Get Cloud Attribute
The **Get Cloud Attribute** node enables the user to retrieve saved progress for a specific VR Experience by assigning the attribute in the Attribute Name field. The progress can be saved for either the scene, the user, or both. Once the node is executed, the retrieved value can be acquired through the **Result** port.
#### Example
In this example, a **Get Cloud Attribute** node is used to retrieve stored data from Cloud. When the user enters the object named FinishLine, the object named Scoreboard will be shown. The data saved for this specific scene for all users is retrieved and stored in a variable named Scoreboard, which can then be displayed during the VR Experience.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Set Cloud Attribute
The **Set Cloud Attribute** node enables the user to store data for a specific VR Experience by assigning the attribute in the Attribute Name field then set the value of it. the data can be stored for either the user, the scene, or both. Once the node is executed, the specified data is saved accordingly.
#### Example
In this example, a **Set Cloud Attribute** node is used to store data in Cloud. When the user enters the object named **FinishLine**, the value of the variable **Time** will be converted to String and stored under the **attribute named Time** for the **Scene Only**, meanwhile the value of the variable **Coins\_Count** will be converted to String and then stored under **the attribute Score** for the **User Only**.
**Note:** To retrieve the Cloud data, the experience must be run from a logged-in account in SimLab VR Viewer.
---
## HTTP Requests
These two nodes let your scene talk to a web service over the internet — for example to fetch some information from a server, send a result to one, or call an online tool. You give the node a web address and a few details about the request; it contacts the server, waits for the reply, and hands you back whatever the server sent. The two nodes are identical except for one thing — **the form the reply comes back in**:
- **Http Request** — gives the reply back as a **JSON object**. Use this when the server answers with JSON.
- **Http Request (String)** — gives the reply back as **plain text**. Use this for raw text, or when you'd rather read the text yourself later.
### Things to know before you start
These points apply to **both** nodes.
#### They wait for the request to finish before carrying on
Talking to a server isn't instant — it can take a moment for the reply to come back. These nodes handle that waiting for you. The node's **Execute** output does *not* fire the moment the request is sent; it fires only once the request has finished — that is, once the server has answered *or* the attempt has failed. So **the nodes you wire after this one run when the request comes back**, not the instant it goes out, and you don't need to add any delay of your own. The rest of your scene keeps running in the meantime — only this branch waits.
Because the **Execute** output fires whether the request succeeded or not, always check the result before trusting the reply — see below.
#### Always check Success before using the reply
A request can go wrong for many reasons — a mistyped address, no internet connection, or the server itself reporting a problem (such as “not found”). That is what the **Success** output is for. It is **Yes** only when the server was reached *and* answered normally; otherwise it is **No** and the **Response** comes back empty. Always send **Success** into a **Branch** node and only use the **Response** on the “Yes” side.
#### The request, in four parts
Every request you send is built from the same few pieces. You set these on the inputs of both nodes:
- **Verb** — what kind of request it is, chosen from a drop-down. **GET** (the default) asks the server *for* something and is by far the most common. **POST** sends new information to the server; **PUT** and **PATCH** update something that already exists; **DELETE** removes something. (**REQUEST** is a general-purpose option for unusual cases.) If you are just reading data, leave this on GET.
- **URL** — the web address to contact, for example `https://api.example.com/status`. This is required.
- **Header** (optional) — extra details about the request, given as a JSON object of name-and-value pairs (text values). It is most often used to pass a key or token that proves who you are, such as `{"Authorization": "Bearer abc123"}`.
- **Body** (optional) — the information you are sending *to* the server, given as a JSON object. It is used with POST, PUT, and PATCH. A GET request never carries a body, so anything you connect here is ignored when the verb is GET.
#### Which one should I use?
Most modern web services answer with **JSON**. If yours does, use **Http Request** and you'll get a JSON object you can read straight away with the **JSON Object** nodes. If the server sends back plain text, or you aren't sure of the format and want the exact text, use **Http Request (String)**. You can always turn text into a JSON object afterwards with **Create Json Object From String**.
### Http Request
Sends a request to a web address and gives you the server's reply as a **JSON object**.
#### What it does
This is the node to reach for when the server answers with JSON, which most web services do. It contacts the address you give it, waits for the reply, and reads that reply into a **JSON object** — so you can pull values straight out of it with the **Get Json Object Field** nodes on the **JSON Objects** page. Only the reply's content comes back; this node doesn't hand you the technical status number separately. Remember to check **Success** first: if the request failed, or the reply wasn't valid JSON, Success is **No** and the Response is empty.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**Verb**
Choice
The kind of request: GET, POST, DELETE, PUT, REQUEST, or PATCH. Defaults to **GET**.
**URL**
Text
The web address to contact.
**Header**
JSON object
*Optional.* Extra request details as name-and-value pairs, such as an authorization key.
**Body**
JSON object
*Optional.* The information to send to the server. Used with POST, PUT, and PATCH; ignored for GET.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires once the request finishes — whether it succeeded or not.
**Success**
True / false
**Yes** if the server was reached, answered normally, and the reply could be read as JSON; **No** otherwise.
**Response**
JSON object
The server's reply, as a JSON object. Empty when **Success** is No.
#### Tips
- **Check Success first.** Wire **Success** into a **Branch** node and only read the **Response** when it's Yes. A server error such as “not found” counts as No.
- **Read one value out.** Wire the **Response** into a **Get Json Object Field** node with the field name to pull a single value (for example `temperature`) out of the reply.
- **Sending data?** Fill in the **Body** and choose **POST** (or PUT / PATCH). When a body is sent, the request is automatically marked as JSON for you.
- **Reply isn't JSON?** If the server sends plain text rather than JSON, use **Http Request (String)** below instead.
### Http Request (String)
Sends the same kind of request, but gives you the server's reply as **plain text**.
#### What it does
Works exactly like **Http Request**, with one difference: the reply comes back as a piece of **text**, exactly as the server sent it, instead of being read into a JSON object. Use this when the server returns plain text, when the reply isn't JSON, or when you simply want the raw text to store, display, or read yourself later. As with the other node, check **Success** first; if the request failed, Success is **No** and the text comes back empty.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**Verb**
Choice
The kind of request: GET, POST, DELETE, PUT, REQUEST, or PATCH. Defaults to **GET**.
**URL**
Text
The web address to contact.
**Header**
JSON object
*Optional.* Extra request details as name-and-value pairs, such as an authorization key.
**Body**
JSON object
*Optional.* The information to send to the server. Used with POST, PUT, and PATCH; ignored for GET.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires once the request finishes — whether it succeeded or not.
**Success**
True / false
**Yes** if the server was reached and answered normally; **No** otherwise.
**Response**
Text
The server's reply, as plain text. Empty when **Success** is No.
#### Example
**Verb** input
`GET`
**URL** input
`https://api.example.com/version`
**Success** output
**Yes**
**Response** output
`v2.4.1`
#### Tips
- **Check Success first.** Wire **Success** into a **Branch** node and only read the **Response** when it's Yes. A server error such as “not found” counts as No.
- **Good for non-JSON replies.** Plain text, a version number, a short status word, or a line of CSV all come back cleanly as text.
- **Text that's really JSON?** If the reply happens to be JSON and you want to read fields out of it, pass the **Response** into **Create Json Object From String** — or just use **Http Request** above, which does that step for you.
### Related
- **JSON Objects** — build the **Header** and **Body** objects you send, and read values out of the reply from **Http Request**.
- **Create Json Object From String** — turn the text from **Http Request (String)** into a JSON object.
- **Branch** — use the **Success** output to decide what happens next.
# Scene
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Load Scene
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)The **Load Scene node** is used to teleport between different scenes within your VR Experience. Enhancing the overall immersion and interactivity of the experience.
####
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-example.jpg)
In this example, the **Load Scene Node** is used to transition the user from one scene to another. This node facilitates changing scenes, allowing for a dynamic experience as users navigate through different environments within the VR application.
> [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png)[ Tutorial is available on SimLab VR Discord server](https://discord.com/channels/1062715275805470821/1307969317068869664 "Tutorial is available on SimLab VR Discord server")
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Home Scene
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)The **Home Scene node** enables users to return to the initial scene of the VR Experience. This node provides a straightforward way for users to reset the VR Experience to the starting point, ensuring a user-friendly navigation experience.
####
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-example.jpg)
In this example, the **Home Scene Node** is used to return the user to the main scene when the trigger event occurs. This allows you to teleport back to the primary environment, enhancing the user experience by providing a clear and intuitive way to return to the starting point.
> [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png)[ Tutorial is available on SimLab VR Discord server](https://discord.com/channels/1062715275805470821/1307969317068869664 "Tutorial is available on SimLab VR Discord server")
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Import Scene
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)The **Import Scene** node is used to load an external scene into the current VR Experience. This allows users to dynamically bring in additional environments, objects, or elements as needed during runtime.
####
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2025-01/xguimage.png)[](https://simlab-soft.com/help/uploads/images/gallery/2025-01/NMTimage.png)
In this example, the **Import Scene node** is used to load a car model into the scene when the "Import" object is triggered. The Node Triggered event detects user interaction and executes the Import Scene node, which then loads the specified car model from an external VR package file. This allows the car to appear dynamically within the VR environment.
---
## Enterprise VR Packages
An **Enterprise VR Package** is a complete VR experience saved as a single, **protected** `.evrpackage` file. These packages are **encrypted**, so only a viewer that has the matching enterprise key can unlock and open them, and creating them is part of a SimLab **Enterprise** licence. The node below brings one of these packages into the running Viewer and adds it to the **main menu**, ready to be opened.
### Add Enterprise VR Package To Viewer
Fetches an Enterprise VR Package from a web address, unlocks it, and adds it to the Viewer's main menu.
#### What it does
Give this node the address of an Enterprise VR Package (an `.evrpackage` file) and, while your experience is running, it downloads the package, unlocks it with its enterprise key, and adds it to the Viewer's **main menu** — the list of experiences someone can open. The package is stored **locally** on the device, so from then on it can be opened from the menu like any other entry.
**It does not put anything into the scene that's currently playing.** This node makes a whole package available to open from the menu; it does not drop models or other content into the running scene. If what you want is to bring content *into* the current scene, use the **Import** node instead — that's what it's for.
Because these packages are protected, this only works with genuine Enterprise VR Packages, and the Viewer has to be able to unlock the file. The **Success** output tells you whether the package was added.
#### It waits until the package is ready
Downloading a package and unlocking it isn't instant — it takes a moment, and it happens quietly in the background so the rest of your experience keeps running. This node handles that waiting for you. Its **Execute** output does *not* fire the moment the node runs; it fires only once the package has been added to the menu *or* the attempt has failed. So **the nodes you wire after this one run when the package is ready**, not the instant it's requested, and you don't need to add any delay of your own. Because **Execute** fires whether it worked or not, always check **Success** first.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**URL**
Text
The web address of the Enterprise VR Package (an `.evrpackage` file) to add. A local file path on the device also works.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires once the node has finished — whether the package was added or not.
**Success**
True / false
**Yes** if the package was downloaded, unlocked, and added to the main menu; **No** otherwise — for example the address was wrong, the download couldn't be completed, or the package couldn't be unlocked.
**Yes** — the package now appears in the Viewer's main menu
#### Tips
- **It adds to the menu, not the scene.** The package becomes available to open from the Viewer's main menu. To bring content *into* the scene that's currently playing, use the **Import** node instead.
- **Enterprise VR Packages only.** This works only with protected `.evrpackage` files. Ordinary files won't be added — use **Import** for those.
- **The Viewer must be able to unlock it.** These packages are encrypted. If the file is damaged, its key isn't available, or there's no connection to download it, **Success** comes back **No** and nothing is added.
- **Check Success first.** Wire the **Success** output into a **Branch** node so the rest of your experience only relies on the package on the “Yes” side.
- **No need to add a delay.** The node already waits for the download and unlock to finish before its **Execute** output fires, so the nodes after it run at the right time on their own.
# Integration
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Open External Connection
SimLab Composer 14 introduces WebSocket support, enabling seamless integration with external systems allowing it to work with external hardware, co-simulation engines, and websites, unlocking numerous possibilities.
The WebSocket nodes (Open External Connection, Send Message, and [On Message Received](https://simlab-soft.com/help/books/dynamic-training-builder-nodes-manual/page/on-message-received)) are exclusively available in the Ultimate Edition.
The **Open External Connection** node enables the opening of a WebSocket connection to an external system. When the **Auto Handle Lua** is set to **true**, incoming messages containing Lua scripts will be automatically executed. This allows for real-time interaction between SimLab Composer and external systems, such as co-simulation engines or hardware, with the ability to dynamically execute Lua code as part of the interaction.
[](https://simlab-soft.com/help/uploads/images/gallery/2025-02/screenshot-2025-02-02-162338.jpg)
**Input Ports:**
- Execute
- URL: WebSocket URL that includes the server IP address, port, channel (optional). Example: ws://server1.simlab-soft.com:8765/robots\_1
- Auto Handle Lua: Incoming messages containing Lua scripts will automatically execute those scripts If enabled (True).
**Output Ports:**
- Execute
- URL
- Auto Handle Lua
---
###  Report Completed
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/Bukimage.png)
The **Report Completed** node functions similarly to the **Report Score** node, but it records both a score and a completion time simultaneously. It is ideal for finalizing tasks, exams, or training scenarios where both accuracy and speed are evaluated. Like the Report Score node, the recorded data is safely stored and utilized within the SimLab VR Assessment Portal for instructor review.
Key parameters:
- **Object Name:** The name of the exam, task, or entity being evaluated.
- **Score:** The numerical score or grade achieved.
- **Duration:** The total time taken to complete the evaluated task.
---
###
###  Report Score
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/6Q4image.png)
The **Report Score** node enables the system to register and record a specific value as a score when the node is executed. This is highly useful for tracking user performance, evaluating task completion, or logging quiz results within a training scenario.
The node utilizes the following key parameters to define the recorded data:
- **Object Name:** Specifies the name of the exam, task, or specific entity being evaluated.
- **Score:** The numerical input field where the final score value is passed or entered.
- **Report Type:** A dropdown menu that determines the classification or outcome of the score. The available options are **Passed**, **Scored**, and **Failed**.
The node stores the score and its associated information to be used primarily in the **SimLab VR Assessment Portal**, where instructors and administrators can securely view and evaluate the reported values.
##### Example
In this example, the system records a student's final score the moment they finish a test.
1. Upon interacting with the "Finish Quiz" object, the **Node Triggered** event initiates the execution flow.
2. The **Number Variable Value** node is used to retrieve the current numerical value stored in the `FinalScore` variable.
3. This retrieved value is passed directly into the **Score** input of the **Report Score** node.
4. The **Report Score** node is configured with the **Object Name** set to "Student Final Score" and the **Report Type** set to "Scored," which officially logs the student's result into the system's evaluation records when executed.
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/bkUimage.png)
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Send Message Node
[](https://simlab-soft.com/help/uploads/images/gallery/2025-02/h5mimage.png)
The **Send Message** node allows you to communicate with the WebSocket server by sending messages. It is essential to ensure that the message format follows the protocol that the server and other clients can process. This node enables real-time interaction with external systems, making it possible to transmit data or commands to connected servers or clients.
**Input Ports:**
- Executive
- URL: WebSocket URL that includes the server IP address, port, and channel (optional). Example: ws://server1.simlab-soft.com:8765/robots\_1
- Message
**Output Ports:**
- Execute
- URL
- Message
# SceneNode \ Snapping
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/response-node-transform-snap-can.png) Can Snap Node
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/HBgimage.png)
The **Can Snap Node** checks whether a specific SceneNode is currently within the eligible snapping range of another object. This node evaluates the spatial relationship between objects and outputs a "Possible" boolean to confirm if a snap can occur, alongside referencing the "Other Node" and its spatial "Transform" data for further logic use.
---
###
### [](https://simlab-soft.com/help/uploads/images/gallery/2026-03/response-node-transform-snap.png) Node Snap
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/UwFimage.png)
The **Snap Node** instantly snaps a designated SceneNode directly to the nearest eligible target socket or node. Executing this node forces the object to immediately align and attach itself to the valid snapping destination without any transition time.
---
###
###  Node Snap (Animated)
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/gZEimage.png)
The **Snap Node (Animated)** securely aligns and attaches a SceneNode to its nearest eligible target, but does so with a smooth visual transition. This node utilizes a "Duration" input to smoothly interpolate the object's movement into its snapped position over the specified number of seconds, rather than snapping instantly.
# SceneNode \ Hierarchy
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Get Node Children
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)The **Get Node Children** enables the user to retrieve child SceneNodes from a specified parent node within the hierarchy in the scene browser. This function allows users to access the children of a parent node in the VR environment, facilitating more complex interactions and hierarchies.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/S2himage.png)
In this example, the **Get Node Children** enables the user to retrieve the child of a group named "Ball Parent" on the Trigger event. When the user triggers the Activate object, the Get Node Children retrieves the child node, and the Get Node Attribute (String) is used to acquire the child’s attribute.
---
### [](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png) Reset Parent Node
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/add-node.jpg)The **Reset Parent Node** enables the user to reset all transformations applied to an object and return it to its original position relative to its main parent. This can be done by linking the node to an event or condition within the scene. Once the reset is executed, the object will revert to its default state under the main parent.
#### Example
[](https://simlab-soft.com/help/uploads/images/gallery/2024-08/S2himage.png)
In this example, a **Reset Parent Node** is used to reset the transformations of a car object to its original state relative to its main parent once the "Car Move" sequence ends. When the user triggers the Activate object, the car move animation sequence will play. After the sequence concludes, the Reset Parent Node is triggered automatically, returning the car to its default position under the main parent.
> [ ](https://simlab-soft.com/help/uploads/images/gallery/2024-08/response-value-number-add.png)[Tutorial is available on SimLab VR Discord server](https://discord.com/channels/1062715275805470821/1239178616877875354/1239178616877875354 "Tutorial is available on SimLab VR Discord server")
# SceneNode \ Appearance
###  Is Node Visible
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/MNnimage.png)
This node checks the current visibility state of a specified 3D object within the VR Viewer. It evaluates whether the targeted object is currently rendered (shown) or hidden in the scene, and outputs this status as a boolean value (True or False).
##### Example:
[](https://simlab-soft.com/help/uploads/images/gallery/2026-03/DtJimage.png)
In this example, triggering the "Assembly" object prompts the system to check if the "Gear" node is currently visible. If the gear is visible, the True branch executes, setting the gear to glow and playing a "Remove Gear" animation sequence. However, if the gear is already hidden, the False branch executes instead, displaying a "Help Panel" to the user.
# SceneNode \ Curve
###  Create Curve
[](https://simlab-soft.com/help/uploads/images/gallery/2026-04/5FWimage.png)
The **Create Curve node** initializes a new 3D cylindrical line within the VR scene. This is highly useful for creating dynamic visual elements like charts, graphs, or data visualizations.
When activated, it generates a base curve using four primary inputs: a unique text **Name** (which acts as an identifier required by all other curve-related nodes to target this specific line), a **Color**, a numerical **Thickness** value, and a **CurveType** dropdown that dictates whether the overall line behaves as a smooth curve or rigid straight lines. It then outputs a reference to the newly created CurveNode to continue the logic flow.
---
###  Add Curve Point
[](https://simlab-soft.com/help/uploads/images/gallery/2026-04/BI7image.png)
The **Add Curve Point node** builds upon an existing curve by generating a new point in 3D space. Once activated, the node locates the specific curve identified by the **Name** input and places a new point at the provided **X, Y, and Z** coordinates. The system automatically draws a line connecting this newly created point to the previously established point, seamlessly extending the curve. Crucially, this node outputs an **Index** value—a unique number assigned to this specific point in the sequence (e.g., the 3rd point created gets an index of 3)—which is used to target this point later.
##### Example:
[](https://simlab-soft.com/help/uploads/images/gallery/2026-04/yV8image.png)
In this expanded example, we build an interaction where clicking a button initializes a new curve and sequentially places two connected points based on a target object's location:
1. A **Node Triggered** event node continuously listens for the user to interact with a specific "Button" object in the scene.
2. Once the button is clicked, it activates a **Create Curve** node, which initializes a new curve named "dataCurve" with a distinct green color, a thickness value of 7, and a "Curved" line type.
3. The execution flow immediately proceeds to a **Get Node Location** node, which retrieves the exact X, Y, and Z spatial coordinates of a target 3D object named "Point".
4. The first **Add Curve Point** node is activated. It takes the "dataCurve" identifier and utilizes the precise X, Y, and Z coordinates retrieved from the target object to generate the first anchor point of the curve.
5. Simultaneously, an **Add** math node receives the original Y coordinate from the "Point" object and adds a numerical value of 2 to it.
6. Following the creation of the first point, a second **Add Curve Point** node is executed. It uses the same "dataCurve" identifier and the original X and Z coordinates, but it uses the newly calculated result from the Add node (Y + 2) for its vertical placement. This generates a second point exactly 2 units directly above the first, automatically drawing a connected line between them.
---
###  Remove Curve Point
[](https://simlab-soft.com/help/uploads/images/gallery/2026-04/hWoimage.png)
The **Remove Curve Point node** is used to permanently delete a specific point from an active curve. Once activated, it takes the curve's **Name** and the specific **Index** number of the point you wish to erase. Upon deletion, the curve automatically bridges the gap between the remaining adjacent points to maintain a continuous, unbroken line.
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2026-04/response-curve-thickness-set.png)Set Curve Thickness
[](https://simlab-soft.com/help/uploads/images/gallery/2026-04/5qKimage.png)
The **Set Curve Thickness node** dynamically adjusts the physical width of an existing curve during the VR experience. When activated, it targets the curve specified by the **Name** input and instantly changes its visual bulk to match the number provided in the **Value** input, allowing you to easily scale the visual prominence of the line on the fly.
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2026-04/response-curve-type-set.png)Set Curve Type
[](https://simlab-soft.com/help/uploads/images/gallery/2026-04/iW3image.png)
The **Set Curve Type node** instantly alters how the connections between a curve's points are visually rendered in the scene. Once activated, it locates the curve by its **Name** and applies the newly selected **CurveType** from the dropdown menu. This allows you to toggle a curve between "Curved" (which renders smooth, sweeping connections between the points) and "Linear" (which renders sharp, perfectly straight lines between the points) at any time.
---
### [ ](https://simlab-soft.com/help/uploads/images/gallery/2026-04/response-curve-point-update.png)Update Curve Point
[](https://simlab-soft.com/help/uploads/images/gallery/2026-04/wE1image.png)
The **Update Curve Point** node allows you to dynamically change the 3D location of a previously created point on an existing curve. When activated, it targets the curve using the **Name** input and isolates a specific point using its numerical **Index** value. It then instantly moves that point to the newly provided **X, Y, and Z** coordinates. The line connecting the points will automatically recalculate and redraw itself to reflect the point's new location in the scene.
# Data Types \ Transform
A **Transform** describes where something sits in the 3D scene and how it is oriented. It is made of three parts: a **position** (called `translation`), a **rotation** (which way it is turned), and a **scale** (how large it is). The nodes on this page convert a Transform to and from text or a JSON object — so you can save it, send it to another system, store it in an attribute, or rebuild it later.
## What's on this page
- **Create** — build a Transform from a piece of text, or from a JSON object.
- **Convert** — turn a Transform into a piece of text, or into a JSON object.
**The three parts of a Transform.** In both the text form and the JSON object form, a Transform is written with three named values:
- `translation` — the **position**, given as three numbers (left/right, up/down, forward/back). `[0, 0, 0]` means "at the origin."
- `rotation` — the **orientation**, given as four numbers that together describe which way the object is turned. `[0, 0, 0, 1]` means "not rotated at all."
- `scale` — the **size**, given as three numbers. `[1, 1, 1]` means "normal size."
All four nodes below use this same example throughout: a Transform positioned at `[10, 5, 0]`, with no rotation and normal scale.
---
## Create
These two nodes build a brand-new Transform from data you already have — one reads it from text, the other from a JSON object. Neither one moves anything in the scene on its own; they produce a Transform *value* that you can then use elsewhere.
### Create Transform From String
Reads a piece of text describing a Transform and turns it into a real Transform you can use.
#### What it does
Useful when the Transform arrived as text — for example from a file you read, a message someone sent, or a value stored in an attribute. The node reads the text and gives you back a proper Transform. The text must contain the three named values `translation`, `rotation`, and `scale`.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**Value**
Text
The text to read. It should describe a Transform, with `translation`, `rotation`, and `scale` values.
A Transform at position `[10, 5, 0]`, no rotation, normal scale.
#### Tips
- **Match the format.** If the text is missing one of the three values, or a bracket or comma is out of place, the node won't be able to read it.
- **Rotation, the short way.** You can write `rotation` as three numbers (a simple turn in degrees) instead of four — both are accepted. Four numbers describe the orientation exactly; three are easier to write by hand.
- **Reverse direction.** To go the other way and turn a Transform *into* text, see **Transform To String** further down this page.
### Create Transform From Json Object
Builds a Transform from a JSON object that holds the position, rotation, and scale.
#### What it does
Same idea as **Create Transform From String**, but the data comes in as a JSON object rather than as text. This is handy when you've built the values up using the **JSON Object** nodes — for example by setting a `translation` field, a `rotation` field, and a `scale` field — and now want a Transform out of them.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**Value**
JSON object
An object with `translation`, `rotation`, and `scale` fields. See the **JSON Objects** page for nodes that build one.
A Transform at position `[10, 5, 0]`, no rotation, normal scale.
#### Tips
- **Missing fields are fine.** If the object leaves out one of the three values, that part is left at its default (no movement, no rotation, or normal scale).
- **Reverse direction.** To turn a Transform *into* a JSON object, see **Transform To Json Object** further down this page.
---
## Convert
These two nodes take a Transform and produce a text or JSON-object version of it. The original Transform isn't changed — each node hands you back the same Transform plus the converted form, so you can keep using the Transform downstream.
### Transform To String
Turns a Transform into a single piece of text.
#### What it does
Produces a text version of the Transform, written with its `translation`, `rotation`, and `scale` values. Useful when you need to save the Transform to a file, store it in a device attribute, or send it to another system that only accepts text.
The Transform itself isn't modified — you get the same Transform back plus a text version.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**Transform**
Transform
The Transform to convert.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**Transform**
Transform
The same Transform you passed in.
**Result**
Text
The text version of the Transform.
#### Example
**Transform** input
A Transform at position `[10, 5, 0]`, no rotation, normal scale.
#### Tips
- **Reverse direction.** To go back from text to a Transform, use **Create Transform From String** at the top of this page.
- **Round trip.** Text made by this node can be read straight back in by **Create Transform From String** — handy for saving a Transform now and restoring it later.
### Transform To Json Object
Turns a Transform into a JSON object with separate fields for position, rotation, and scale.
#### What it does
Produces a JSON object holding the Transform's `translation`, `rotation`, and `scale`. Unlike the text version, the result is a real JSON object — so you can read out an individual part (just the position, say) using the **Get** nodes on the **JSON Objects** page.
The Transform itself isn't modified — you get the same Transform back plus the object version.
#### Inputs
Port
Type
What to connect
**Execute**
Trigger
Wire this from the previous node's **Execute** output.
**Transform**
Transform
The Transform to convert.
#### Outputs
Port
Type
What you get
**Execute**
Trigger
Fires after this node finishes.
**Transform**
Transform
The same Transform you passed in.
**Result**
JSON object
The object version of the Transform, with `translation`, `rotation`, and `scale` fields.
#### Example
**Transform** input
A Transform at position `[10, 5, 0]`, no rotation, normal scale.
#### Tips
- **Read out one part.** Wire the **Result** into **Get Json Object Field (JsonArray)** with the field name `translation` to pull just the position back out.
- **Reverse direction.** To go back from an object to a Transform, use **Create Transform From Json Object** at the top of this page.
---
## Related
- **JSON Objects** — build the object you feed into **Create Transform From Json Object**, or read individual parts out of the object that **Transform To Json Object** produces.
- **JSON Arrays** — the `translation`, `rotation`, and `scale` values are each small JSON arrays of numbers.
# States
# Node Is Grabbed
###  Node Is Grabbed
The **Node Is Grabbed** node enables the user to check if the assigned node is grabbed with **OnTrue/OnFalse** ports to execute responses or **Output Boolean** port that is compatible with event nodes.
#### Examples
In this example, a **Node Is Grabbed** node is used to check if the node assigned is grabbed. Once the object named **Activate** is triggered, the sound named Instructions will play, and the object named Key will show up and become grabbable. Once the object named **Key** is grabbed, the sequence named **Door\_Open** will play.
---
# Watch Boolean Expression
###  Watch Boolean Expression
The **Watch Boolean Expression** node enables the user to check the value of specific variable(s) with **OnTrue/OnFalse** ports to execute responses or **Output Boolean** port that is compatible with event nodes.
#### Examples
In this example, a **Watch Boolean Expression** node is used to check the value of **a string variable** to determine if it is true or false, depending on the result, the object named Activate can be triggered. Once the event is triggered, the object named Table will be shown during the VR Experience.
In this example, a **Watch Boolean Expression** node is used to check the value of **a number variable** to determine if it is true or false, depending on the result, the object named Activate can be triggered. Once the event is triggered, the object named Table will be shown during the VR Experience.
---
# Interactive GLTF Responses
Responses that are supported and displayed in the Interactive GLTF Viewer but are not currently used in the VR Viewer.
# Call JS Function
#### [](https://simlab-soft.com/help/uploads/images/gallery/2026-06/Wsbresponse-jsfunction-call.png) Call JS Function
The Call JS Function node enables the execution of custom JavaScript functions in the gener
ated Interactive WebGL HTML file after exporting a scene. The following steps explain how to configure and use this node:
1. Add these nodes to the interactive gltf diagram as an example.[](https://simlab-soft.com/help/uploads/images/gallery/2026-06/PYmimage.png)
2. Export to Interactive WebGL. [](https://simlab-soft.com/help/uploads/images/gallery/2026-06/Uylimage.png)
3. After exporting the scene to interactive WebGL, open the generated Interactive WebGL HTML file and implement the `test` function referenced by the **Call JS Function** node. This function will be executed when the node is triggered (As shown in the example below, the `test` JavaScript function will displays an alert popup containing the string **"test"**). [](https://simlab-soft.com/help/uploads/images/gallery/2026-06/ExXimage.png)