TokyNodes

Overview

A TokyNode is a first-class entity that exists outside the boundaries of any single world. Where voxels and FBX attachments live and die with the world they were placed in, a TokyNode is owned by you — it travels with your account across every world that allows TokyNode imports.

Every TokyNode is networked the moment it spawns. Every change — move, attach, detach, scripted state update — broadcasts to every connected player automatically. There is no "sync this for multiplayer" toggle; networking is the floor of the feature, not a layer bolted on top.

A TokyNode family is a soft grouping of nodes that travel together. Families are how you ship a multi-piece item — a TV and its remote, a vehicle and its wheels, a chess set and its pieces — as a single named entity that can be spawned, gifted, or imported as one unit.

The Cross-World Mission

Every other major creator platform we've used draws an impassable line at the edge of the world or game. Build a beautiful chair in Roblox? It stays inside that experience. Carve out a treasured artifact in Minecraft? It belongs to that save file. Compose a custom outfit in Fortnite? It belongs to a single battle royale. The user is restricted by the bounds of their world or game — even though they're the one who made the thing.

We think that's a failure of imagination. A creator's library is theirs, period. When you build something in Tokyube, it's your thing — across every world that wants to host it, across the multiplayer lobbies you join, across the marketplace you eventually sell or trade it in. TokyNodes are how we abolish the cross-world wall.

That mission shapes every design choice on this page:

• Nodes are owned by the player's account, not the world.
• Families let creators ship complete multi-piece items without needing collaborative-build access in either the source world or the destination world.
• The networking layer is identical in single-player, hosted multiplayer, and Steam P2P lobbies — so importing a node never produces "this only works in the world I made it in" surprises.
• Persistence is account-scoped via the same Tokyube backend that powers profiles, friends, and avatars.

What Is a TokyNode

Mechanically, a TokyNode is:

• A 3D mesh (any OBJ, FBX, or composite voxel structure).
• Optional Tokyube Code Blocks scripts attached to it — same scripting layer as anything else in the engine.
• A persistent identifier that's globally unique across your account.
• A set of attach points so other nodes can dock to it (or it to them) — the basis for families.
• A network handle so position, rotation, scale, and scripted events all replicate the moment they change.

You spawn a TokyNode in TokyNode Mode from either your library or someone else's shared library. The node appears at your cursor; from there it behaves like any other entity but persists in your account-side library when the world unloads.

TokyNode Families

A family is a soft grouping of TokyNodes that share a common identity and travel together. The simplest family has one member; the most complex can have hundreds.

What families enable

• Atomic spawn. Place the family root and every member spawns in the right relative position.
• Atomic delete. Remove the root and every member tears down with it (configurable per family).
• Coordinated scripting. A family member can address any other member by role name (e.g. family.find('remote')) without juggling individual entity references.
• Cross-world transfer. Gift, trade, or import an entire family in one operation — no need to re-build the relationships in the destination world.

Roles inside a family

• Root. Every family has exactly one root. Its position and rotation define the family's "anchor" when it spawns.
• Members. Every other node in the family. Members can be attached to the root or to each other, forming arbitrary hierarchies.
• Attachables. Members tagged as attachable can be detached and re-attached to nodes outside the family — useful for accessories or decorative pieces that live both inside and outside the family.

Authoring a family

1. Spawn the nodes you want to include in the family.
2. In TokyNode Mode, select the root node and click NEW FAMILY.
3. Add members by selecting them and clicking ADD TO FAMILY; assign each a role name (free-form string).
4. Click SAVE FAMILY. The family is now a first-class entry in your TokyNode Library — spawn it into any other world with a single click.

Cross-World Persistence

Persistence is the whole point. The state we keep travels with you across every world your account opens:

• Every TokyNode you've ever authored.
• Every family you've assembled.
• Per-node scripts — scripts ride with the node, so a functional door in your home world is still a functional door in someone else's gallery.
• Per-node scripted state (typed variables, persistent counters, last-known event payloads). What was true about the node when you closed one world is true about it when you re-open it in another.

Storage is account-scoped — keyed by your Steam ID — so signing into Tokyube on a different machine pulls the same library. The node payload itself (mesh + texture + script graph) is content-addressed in the Tokyube backend, so the actual asset only uploads once even if you spawn it across 50 worlds.

How worlds opt in

Hosts decide whether a world accepts external TokyNode imports. Three settings:

• Open — any visitor can spawn any node they own.
• Allowlist — only nodes from the host's friends or a curated list.
• Closed — only the host's own nodes.

Worlds default to Open. Hosts running a focused creative project can flip to Closed without losing their own cross-world library.

Networking & Sync

Three packet types drive TokyNode multiplayer (the same names you'll see in the engine logs):

• tokynode_spawn — broadcast when a node appears in the world. Includes the node's globally-unique ID, its mesh asset reference, and its initial transform.
• tokynode_remove — broadcast when a node is removed. Cleans up on every peer.
• tokynode_move — 10Hz position/rotation/scale update. Identical cadence to the regular player position broadcast, so motion stays smooth without flooding the network.

Family-level operations (add member, change role, save family) ride on top of these primitives — each member's spawn broadcasts individually, then the family record itself syncs as a single packet so peers' libraries stay in sync.

The host is authoritative for state, but every client renders locally — so even if your connection has a hiccup, nodes stay visible at their last-known transform until updates resume.

Authoring TokyNodes

Two paths to author a node:

From a voxel structure

1. Build the structure in-world.
2. Enter AB Mode and select the bounding region.
3. Click SAVE AS TOKYNODE from the AB-Mode actions panel. The structure converts into a single meshed asset and joins your library.

From an external mesh

1. Drag-drop an .OBJ or .FBX onto the world (this places an FBX attachment first).
2. Enter TokyNode Mode and click PROMOTE TO TOKYNODE.
3. The mesh is uploaded once to the Tokyube backend; from then on every spawn references the same asset by hash.

Either path can be followed up by attaching scripts via Script Mode. The scripts persist with the node.

Attaching & Hierarchy

Attachment is how a node parents to another node, a player, or a voxel. An attached node's transform is interpreted relative to its parent — move the parent, the child follows.

Common patterns

• Vehicle wheels. Wheel nodes attached to a chassis node form a family that drives as one unit.
• TV + remote. A remote node attached to a TV node lets a script on the remote send events to the TV — and the family record carries them together across worlds.
• Wearables. A hat node attached to the player's head bone walks with the avatar even after the player teleports.

Hierarchies are arbitrary depth. The networking layer flattens attach trees on the wire, so deep hierarchies don't pay a per-frame networking cost beyond the leaf nodes that actually move.

Scripting TokyNodes

TokyNodes are full first-class targets in Tokyube Code Blocks. Open a node in Script Mode to author logic; the script and any persistent typed-variable state live with the node and travel with it across worlds.

Useful patterns:

• Per-node typed variables. Use typed variables for any state that should persist on the node — score, ammo count, last-fired time. Wipes when the node's owner chooses to reset it, not when the world unloads.
• Family events. Send events scoped to the family with event_send_to_family (and the symmetric on_receive_family) so members can coordinate without knowing each other's individual IDs.
• Cross-world identity. Read the node's global ID from a script to gate behavior — e.g., a "first time in this world" check that surfaces a tutorial prompt the first time the node enters a new world.

TokyNode Library

Your library is the master index of every node and family you own. Open it from the in-world TokyNode Mode panel or from the TokyNodes phone app.

The library lets you:

• Browse, sort, and tag your nodes and families.
• Spawn directly from the panel into the current world.
• Edit metadata (name, description, tags, public/private, attachable yes/no).
• Trade or gift nodes to friends — the recipient gets a copy that lives in their library; the original stays in yours.
• Publish a node to the marketplace (planned) so other creators can discover and import it.

TokyNodes Phone App

The TokyPhone hosts a thin client of the TokyNode Library so you can browse and spawn without leaving the player view. See TokyNodes (in-phone) for the controls reference.

Troubleshooting

• "Node didn't spawn for my friend." Check the host's import setting — Closed worlds reject external nodes silently.
• "Family imported but lost its scripts." Scripts persist with each node, but typed-variable state only restores from the most recent autosave. If you imported a stale snapshot, re-export the family from the source world.
• "Mesh shows as a placeholder cube." The backend is still streaming the asset bytes. Wait a few seconds; if it persists, your asset hash may have failed upload — re-promote the source mesh.
• "Attached node ghosts behind its parent." That's the local-render fallback during a network hiccup. Once tokynode_move packets resume, the lerp catches up. Persistent ghosting indicates a peer with degraded P2P — check Network Stats in the debug panel.