May 4, 2026

Highrise Studio Unity Lua Beginner Tutorial: Glossary 2026

TL;DR

Highrise Studio is a Unity-based creator toolset that uses Lua (not C#) for scripting interactive 3D Worlds on the Highrise platform. Most beginner confusion comes from mixing up four layers: the Highrise platform, the Unity editor, Lua scripting, and the multiplayer/publishing system. This glossary defines every term you will encounter in a Highrise Studio Unity Lua beginner tutorial so you can follow along without getting lost.

Most beginners do not get stuck because Lua is hard. They get stuck because a tutorial says “attach a Client script to a GameObject in the Inspector” and three of those words are unfamiliar.

Highrise Studio combines tools from different worlds. Unity provides the 3D editor. Lua provides the scripting language. Highrise provides the platform, multiplayer system, and publishing pipeline. Official documentation covers each piece well, but it is spread across dozens of pages. If you are brand new, you need the vocabulary before you need the steps.

That is what this guide provides. Think of it as the glossary you read before your first Highrise Studio tutorial, not a replacement for one. By the end, every term in a beginner walkthrough should make sense.

If you have not yet experienced Highrise as a player, explore what the platform looks like before building. Understanding the player experience makes creator terms click faster.

The 4 Layers Beginners Mix Up

Before jumping into definitions, understand this framework. Highrise Studio is easiest to learn when you see it as four layers.

Layer	Plain meaning	Example
Highrise	The platform where players visit your creation	Someone opens your published World on their phone or PC
Unity	The 3D editor where you build the scene	You place objects, lights, and props in a visual workspace
Lua	The scripting language that adds behavior	You make a door open, a button count clicks, or an enemy chase players
Creator Portal	The web dashboard for releasing and managing Worlds	You publish an uploaded build so players can find it

Official Highrise documentation walks through this same flow: install tools, create a project in Unity, add Lua scripts for interactivity, test, upload, and release through the Creator Portal. Source: Getting Started guide

Most beginner mistakes come from confusing these layers. Treating Unity as if it only uses C#. Writing all logic in a Client script and wondering why other players cannot see the result. Assuming “works in Play Mode” means “ready to publish.” Keep these four layers separate in your head and the rest of this Highrise Studio beginner tutorial glossary becomes straightforward.

What Is Highrise Studio?

Highrise Studio is the creator toolset for building games and interactive 3D Worlds on Highrise. It is not a standalone editor you download by itself. It is a workflow that connects several tools: Studio Hub (the launcher), Unity (the 3D editor), the Highrise Studio Package (which adds Highrise-specific features to Unity), a code editor like VS Code, and the Creator Portal (for publishing).

The official beginner course describes Highrise Studio as the platform where creators build, test, and publish projects, with Unity integration, multiplayer support, and Lua scripting. Source: Lecture 1 Introduction

Where you see it: Studio Hub, Unity Editor, Highrise Create docs.

Beginner mistake: Thinking Highrise Studio is a separate standalone game editor. It is actually a creator workflow built around Unity plus Highrise tooling.

Setup and Unity Editor Terms

These are the terms you encounter during installation and your first look at the Unity workspace. If you have never opened Unity, start here.

Studio Hub

The launcher and control center for Highrise Studio projects. You use it to create new projects, manage existing ones, and install required tools. Official docs list Studio Hub as the first setup step. Source: Getting Started

Where you see it: It is the first application you open when starting a new World.

Beginner tip: Follow Studio Hub’s prompts to install Unity and the Highrise Studio Package. Do not try to set things up manually.

Highrise Studio Package

A Unity package that adds Highrise-specific tools, assets, and features into a Unity project. Without it, your Unity project is just a normal Unity project, not a Highrise World project.

Beginner mistake: Opening a fresh Unity project without the Highrise Studio Package and wondering why there are no Highrise options in the menus.

Unity Editor

The workspace where you arrange scenes, place objects, change properties, and test your World. Highrise’s beginner lectures break down the layout into key panels: Scene View, Game View, Hierarchy, Inspector, Project Panel, and Console. Source: Lecture 3

Beginner tip: Spend ten minutes just clicking around the Unity Editor before writing any code. Know where things are.

Project

Your saved workspace for a World build. It contains scenes, assets, scripts, and settings. You create a new project from Studio Hub and choose a template.

Template

A starter project setup that reduces initial configuration work. When creating a new project in Studio Hub, you pick a template (such as the Basic Template) to get a working starting point.

Scene

A Unity environment containing objects. Think of it as one level, one area, or one room of your World. The official beginner quiz defines a scene as “a separate room or environment where game elements interact.” Source: Quiz 1

Scene View

The editing view where you build and move around your world visually. You drag objects, rotate the camera, and position things here.

Game View

The player preview. It shows what the game looks like when played or tested. Switch between Scene View and Game View to compare your build layout with the player experience.

Hierarchy

The list of every object in the current scene, displayed as a panel on the left side of the Unity Editor. You select and organize objects here. Source: Lecture 3

Inspector

The panel (usually on the right) where you edit a selected object’s properties. You change position, rotation, and scale here. You also add Components and attach Lua scripts through the Inspector.

Where you see it: Select any object in the Hierarchy and the Inspector shows its details.

Beginner mistake: Looking for script settings in the wrong panel. Scripts are attached through the Inspector, not the Project Panel.

Project Panel

The file and asset browser. It stores scripts, models, textures, materials, audio files, and imported packages. When you create a new Lua script, it appears here.

Console

The panel for errors, warnings, and debug messages. This is the first place to check when something breaks. Highrise’s beginner lectures describe the Console as essential for debugging and recommend seeking help if errors are unclear. Source: Lecture 3

Beginner tip: Keep the Console visible at all times. Do not ignore red error messages.

Play Mode

Unity’s test mode. Press the Play button to run your World inside the editor and check behavior before uploading.

Virtual Player

A Highrise testing feature that lets you test as a player avatar without needing to upload or launch the actual Highrise app. The beginner lecture explains that the Virtual Player button enables testing with a simulated player. Source: Lecture 3

GameObject, Component, and Asset Terms

This section covers the building blocks of everything you see and interact with in your World. Understanding the GameObject/Component model is required before Lua scripting makes sense.

GameObject

The fundamental object in a Unity scene. Every visible or invisible thing, whether it is a character, a prop, a light, a camera, or an invisible trigger zone, is a GameObject. Unity’s own documentation says GameObjects “can represent characters, props, scenery, cameras, waypoints, and more,” with functionality defined by attached Components. Source: Unity Manual

Think of it this way: A GameObject is an empty container. By itself, it does nothing. Components give it abilities.

Component

A capability or behavior attached to a GameObject. Components make objects render on screen, detect collisions, play sounds, respond to physics, or run scripts. Unity explains that GameObjects act as containers and Components implement functionality. Source: Unity Manual

Transform

The position, rotation, and scale of a GameObject. Every GameObject always has a Transform component. It tells Unity where the object is, which way it faces, and how large it is.

Prefab

A reusable GameObject template. If you build a tree with specific Components and settings, you can save it as a Prefab and place copies throughout your World. The official quiz defines a Prefab as “a reusable GameObject that saves time and keeps consistency.” Source: Quiz 1

Asset

Any file used in your project: 3D models, textures, materials, audio clips, scripts, and more. You manage assets in the Project Panel.

Asset Catalog

A Highrise-specific feature for finding and importing ready-made assets. The beginner lecture says the Asset Catalog button gives access to Highrise’s library of game assets. Source: Lecture 3

You can also browse Highrise items and assets through the Highrise catalog to get a sense of the platform’s style before building.

Collider

A Component that defines a shape for collision detection. A Box Collider, for example, represents a rectangular solid volume that other objects can bump into or pass through. Unity’s documentation uses a cube with a Box Collider as a core example. Source: Unity Manual

Trigger

A Collider set to “trigger” mode. Instead of acting like a solid wall, it detects when something enters or exits the zone. Used for “when a player walks into this area, do something” logic.

NavMesh

A navigation mesh that defines walkable areas for AI characters. The quiz describes NavMesh as outlining walkable areas for intelligent character navigation, generated by a Nav Mesh Surface component. Source: Quiz 1

Spawn Point

A designated location where players, enemies, or items appear when a level starts or when respawning.

Anchor Point

A specific location on an object where characters attach, such as sitting on a chair or standing on a platform.

Lua Scripting Terms in Highrise Studio

This is the section where most Highrise Studio Unity Lua beginner tutorial confusion lives. Read the warning first.

Highrise Studio uses Lua for scripts. Generic Unity scripting tutorials teach C#. Use Unity tutorials for editor concepts (GameObjects, Hierarchy, Inspector), but do not copy their scripting syntax into Highrise Studio. The official scripting overview is explicit: “Lua is the primary scripting language in Highrise Studio” and “C# scripts cannot be used for creating Highrise platform games and experiences.” Source: Scripting Overview

If you see a tutorial that starts with using UnityEngine; or public class, that is a C# tutorial. It will not work in Highrise Studio.

Lua

A lightweight, high-level scripting language. Highrise Studio uses it for gameplay mechanics, player interactions, object behaviors, and custom game elements. Source: Lua Overview

If you have used Lua in Roblox, the syntax will feel familiar, though Highrise has its own APIs and conventions.

Lua Script

A text file containing Lua instructions that control behavior in your World. The first-script documentation says Lua scripts “control player movement, object interactions, and game logic.” Source: Writing Your First Script

How to create one: In Unity, go to Create > Highrise > Lua Script, choose a script type, and save it. Then drag it onto a GameObject in the Inspector to attach it.

Script Type

The role a script plays. Highrise Studio has five types: Client, Server, ClientAndServer, Module, and UI. You set the type with a special comment at the top of your script file. The type attribute documentation lists all options and explains that the Type attribute tells Studio how to handle the script. Source: Type Attributes

Choosing the wrong script type is one of the fastest ways to create bugs that are hard to diagnose.

–!Type(…)

A Lua attribute comment placed at the top of a script file. Examples: --!Type(Client), --!Type(Server), --!Type(Module), --!Type(UI). This tells Highrise Studio how to execute the script.

Client Script

A script for local player interactions: input handling, UI behavior, visual effects, animations, and anything that only one player needs to see or do. Official docs warn against using Client scripts for server-side logic or data storage. Source: Client Script Types

Rule of thumb: If only one player needs to see or feel it, think Client.

Server Script

A script for shared game logic: score tracking, inventory management, multiplayer synchronization, AI behavior, physics calculations, and server-client communication. Server scripts ensure consistency and security in multiplayer environments. Source: Server Script Types

Rule of thumb: If every player needs to agree it happened, think Server.

Module Script

A reusable code file containing functions and variables that other scripts can import. Module scripts are singleton instances shared by any script that imports them. Source: Module Script Types

Use these to avoid copying the same logic into multiple files.

UI Script

A Lua script that controls user interface behavior. Connected to UXML and USS files for layout and styling. Covered in more detail in the UI section below.

Choosing the Right Script Type

This decision table helps beginners pick correctly:

If you want to…	Start with…
Show a local UI button	Client or UI script
Play a local visual or audio effect	Client script
Track score, inventory, or shared game rules	Server script
Share reusable functions across scripts	Module script
Send a message between client and server	Event plus client-server communication
Make all players see the same result	Server logic plus events or network values

Awake

A lifecycle function called when a script first initializes. Used for early setup before anything else runs. Source: Client Script Types

Start

A lifecycle function called when a script begins running. Fires after Awake. Good for initial configuration that depends on other objects being ready.

Update

A lifecycle function called every frame. Used for things that need to change continuously, like movement, timers, or checking conditions. Source: Client Script Types

Variable

A named value that stores data. In Lua, variables can hold numbers, strings, booleans, tables, nil, and other data types. Official docs recommend using local variables when possible. Source: Lua Variables

Table

Lua’s primary data structure for collections. Tables store key-value pairs and can work as arrays, dictionaries, or objects. If you have used arrays or objects in other languages, tables are Lua’s version.

Function

A reusable block of code that performs an action when called. In Highrise scripts, you define functions for things like handling events, processing input, or calculating results.

Event

A signal that scripts can listen for or fire. Events are the backbone of client-server communication in Highrise Studio. Source: Client-Server Communication

Connect

A method that attaches a function to an event. When the event fires, the connected function runs.

FireServer

Sends an event from the client side to the server side. Used when a player action (like pressing a button) needs to trigger server logic (like updating a score). Source: Client-Server Communication

FireClient

Sends an event from the server to a specific client. Used for one-player responses, like showing a personal notification.

Practitioners on the Highrise forum have reported bugs with FireClient in earlier versions. One thread documented an issue where FireClient was not working as expected, which was later fixed in a subsequent release. Source: Forum Discussion Always check that your Highrise Studio Package is up to date.

FireAllClients

Sends an event from the server to every connected client. Used for broad updates, like announcing that a game round ended.

Network Values

Values used to synchronize state between server and clients. The official client-server documentation positions events and network values as the two main ways to establish communication. Source: Client-Server Communication

Raycast

A line or beam check that detects what an input or direction hits. Useful for tap/click targeting and object detection. A common beginner mistake is handling the return value incorrectly. A forum responder noted that Raycast returns a tuple: local success, hit = RayCast(tap.position). Source: Forum Raycast Thread

Vector3

A 3D value with x, y, and z components. Used for positions, directions, and movement. The beginner course uses Vector3.up * Time.deltaTime to move a GameObject upward. Source: Lecture 4

Time.deltaTime

The time elapsed since the last frame. Multiplying movement by Time.deltaTime makes it frame-rate independent, meaning the speed looks the same on fast and slow devices.

UI Terms: UXML, USS, HUD, and Lua

When you build player-facing interface elements (buttons, counters, menus, health bars), you hit a second vocabulary wall. Highrise Studio UI uses a three-file system.

The official UI guide explains that generating a UI component creates three files: a Lua script for logic, a UXML file for layout, and a USS file for styling. Source: Creating Your First UI

UXML

The layout file that defines the structure of your UI elements. Think of it as the skeleton: where buttons, text fields, and containers go.

USS

The styling file that defines how UI looks. Colors, fonts, spacing, borders. Similar to CSS if you have web development experience.

UI Lua Script

The logic file that makes your UI interactive. When a player clicks a button, this script handles what happens.

HUD

A UI output mode that fixes elements to the screen. Good for persistent counters, health bars, and action buttons.

Above Chat

A UI output mode that displays elements above the chat box. Good for interactive UI that needs to coexist with chat.

World UI

A UI output mode that attaches interface elements to a 3D object in the scene.

Important warning: World mode does not support buttons or input fields. If your UI needs clickable buttons or text input, use HUD or Above Chat instead. Source: Creating Your First UI

Testing, Uploading, and Publishing Terms

Building your World in Unity is only half the process. These terms cover what happens between “it works in the editor” and “players can visit it.”

Test / Play Mode

Running your project inside Unity to check behavior. Press the Play button, watch the Game View, and read the Console for errors. Always test before uploading. Source: Getting Started

Upload

Sending your build from Unity to Highrise’s servers. This does not make your World public. It just pushes the packaged version up so you can release it later.

Build

The packaged version of your World that gets uploaded. You cannot publish a World with no build uploaded.

Release

Making an uploaded build live and available to players. You do this through the Creator Portal, not inside Unity. The process involves locating your uploaded World, going to Builds, clicking Release, adding a version number and release notes, and publishing. Source: Getting Started

Creator Portal

The web dashboard where you manage and release your uploaded Worlds. This is the final step after uploading from Unity.

Version Number

A release label like 1.0.0. Used to track which build is live and communicate updates.

Release Notes

Short descriptions of what changed in a new version. Helpful for players who want to know what is new.

World

A published 3D experience, game, or hangout that players can visit on Highrise. This is the finished product of everything you build in Unity and script in Lua.

You can browse existing Worlds through the World directory to see what other creators have built.

Room vs World vs Scene

This causes real confusion. On Reddit, users frequently ask about “rooms” in the Highrise app, like how to make or expand a room. But in creator documentation, the terminology is different. Source: Reddit Discussion

Here is the distinction:

Room: A common player term for social and decorated spaces inside the Highrise app.
World: A Studio-built 3D experience or game published through Highrise Studio.
Scene: A Unity editing environment inside a project. A World might contain one or more scenes.

Do not confuse these. When tutorials say “scene,” they mean the Unity workspace. When they say “World,” they mean the published Highrise experience.

Common Beginner Mistakes in Highrise Studio

These are not hypothetical. They come from real questions posted by creators on the Highrise forum and from patterns visible in the documentation.

Mistake 1: Copying Unity C# tutorials into Highrise Studio

Highrise Studio uses Lua. Unity’s own beginner scripting tutorials teach C#. If you paste C# code into a Highrise Lua script, nothing will work. Source: Scripting Overview

Fix: Use Unity tutorials for editor concepts (placing objects, using the Inspector, understanding Hierarchy). Use Highrise docs for scripting syntax.

Mistake 2: Putting shared game rules in a Client script

Client scripts run locally for one player. If you track score or inventory in a Client script, other players will not see it, and the data will not persist. Highrise docs explicitly warn against using Client scripts for server-side logic or data storage. Source: Client Script Types

Fix: Use Server scripts for anything all players need to agree on.

Mistake 3: Assuming editor testing equals live behavior

A creator on the Highrise forum reported that collision detection logic worked perfectly in the Unity editor with multiple virtual players but failed after uploading and testing on the platform. Source: Forum Collision Thread

Fix: Test in Play Mode first, then test again after uploading. Check for differences between editor behavior and platform behavior, especially around collisions, visual effects, and networking.

If you encounter platform issues, check the Highrise status page to rule out server-side problems.

Mistake 4: Following outdated video tutorials

Highrise Studio APIs have changed over time. A December 2023 update introduced lowerCamelCase naming conventions, services nested under hr, and new global accessors. A March 2024 update changed behavior event syntax from self.Update:Connect(function()...) to function self:Update() ... end. Source: Studio 0.1.4 Changes

Fix: If a video shows different syntax from what the current docs describe, follow the docs. Check the Highrise news page and Studio update posts for recent changes.

Mistake 5: Ignoring Console errors

The Console shows you exactly what went wrong and where. Many beginners skip it and try to fix problems by guessing.

Fix: Read the Console first. Copy the error message. Search the Highrise docs or forum for that message. This saves hours.

Mistake 6: Synchronization confusion with FireServer and FireAllClients

A forum creator tried to synchronize object visibility across clients using FireServer() and FireAllClients(), but the object remained visible only to the triggering client. Source: Forum Sync Thread

Fix: Think carefully about whether you are changing local state or shared state. FireServer sends a message to the server. FireAllClients sends a message to every client. But the client that receives the message still needs logic to act on it.

Diagnostic Table: Works in Editor, Fails Live

Symptom	Likely area to check
Works for one player, not everyone	Client vs Server logic, events, network values
Button appears but does not respond to clicks	UI output mode (World mode does not support buttons)
Collision works in editor but not on platform	Collider/trigger setup, script type, platform-specific testing
Raycast returns nothing	Return value handling (tuple), target layer, missing collider
Old tutorial syntax causes errors	Studio version/API changes, outdated package

Beginner Roadmap: What to Learn First

This is not a full tutorial. It is a checklist for your first session, with the glossary terms you will need at each step.

Install Studio Hub, Unity, Highrise Studio Package, and a code editor. Terms: Studio Hub, Highrise Studio Package, Unity Editor. Source: Getting Started
Create a new project from a template. Terms: Project, Template.
Learn the four Unity panels. Terms: Scene View, Game View, Hierarchy, Inspector, Project Panel, Console. Source: Lecture 3
Add or select a GameObject. Terms: GameObject, Component, Transform.
Create a Lua script. Terms: Lua Script, Script Type. Source: Writing Your First Script
Choose the right script type. Terms: Client Script, Server Script, Module Script, UI Script, --!Type(…).
Attach the script to a GameObject. Drag the script onto the object in the Inspector.
Press Play and read the Console. Terms: Play Mode, Console, Virtual Player.
Upload only after testing. Terms: Upload, Build.
Release through Creator Portal. Terms: Release, Creator Portal, Version Number, World.

Once your first World is live, check out the Highrise community to see what other creators are building and get feedback.

Where to Get Help

The official Highrise Help Center directs creators to the Creator Discord, which includes dedicated support channels for Highrise Studio, spaces to share work, receive feedback, ask questions, and get platform updates. Source: Highrise Help Center

Practitioners on the Highrise forum have noted that non-native English speakers especially benefit from video tutorials and visual examples. One creator asking about teleportation mentioned that English was not their primary language and that video walkthroughs would help. Source: Forum Thread

When asking for help on Discord or the forum, include these details to get faster answers:

Highrise Studio Package version
Script type (Client, Server, Module, UI)
What you expected to happen
What actually happened
Whether it works in Play Mode (yes or no)
Whether it works after upload/release (yes or no)
Console error message (copy the exact text)
Screenshot showing Inspector, Hierarchy, and Console

Stay current by following the Highrise blog for creator updates, platform changes, and tutorial announcements.

Ready to Start Building?

If you have read through this Highrise Studio Unity Lua beginner tutorial glossary, you now have the vocabulary to follow official docs and video walkthroughs without getting lost. The next step is to download Highrise and open Studio Hub. Start with a template, place a few GameObjects, attach a simple Lua script, and press Play. Your first World does not need to be perfect. It just needs to exist.

If you are not ready for full Lua scripting yet, you can still contribute creatively through Highrise design contests or by submitting ideas to the community.

FAQ: Highrise Studio, Unity, and Lua

Do I need to know Unity before using Highrise Studio?

No, but learning the basics helps. Understanding GameObjects, Components, the Inspector, Hierarchy, Scene View, Game View, and Play Mode will make every tutorial significantly easier to follow. Highrise’s beginner lectures introduce these Unity panels step by step. Source: Lecture 3

Does Highrise Studio use Lua or C#?

Lua. Official documentation states that Lua is the supported scripting language and C# scripts cannot be used for Highrise platform games and experiences. Source: Scripting Overview

Can I follow normal Unity tutorials?

Yes, for editor concepts like placing objects, navigating panels, and using Play Mode. Be careful with scripting sections, because Unity’s own beginner tutorials teach C# while Highrise Studio requires Lua.

What script type should I choose for my first script?

For local visual or player interactions, start with a Client script. For shared rules or persistent game state that all players need to see, use a Server script. For reusable logic shared across files, use a Module script. For interface elements, use a UI script.

Why does my script work for me but not other players?

This is almost always a client/server issue. If your logic runs in a Client script, only that one player experiences it. Use Server scripts and events (FireServer, FireClient, FireAllClients) to synchronize state. Forum threads show this is one of the most common beginner problems. Source: Forum Sync Thread

Why does my UI button not work?

Check the output mode. If your UI is set to World mode, buttons and input fields will not respond. Highrise docs confirm that World mode does not support interactive elements. Switch to HUD or Above Chat. Source: Creating Your First UI

What is the difference between a room and a World?

A “room” is the term many Highrise players use for social and decorated spaces inside the app. A “World” is a 3D experience built with Highrise Studio and published through the Creator Portal. A “scene” is a Unity editing environment inside your project. These three terms describe different things.

Where can I get help if I am stuck?

The Creator Discord has dedicated Highrise Studio support channels. The Highrise Create documentation covers setup, scripting, UI, and publishing. The Highrise forum has active threads tagged by topic, including Lua scripting questions. Source: Highrise Help Center

Company

About Partnerships

Resources

Downloads Steam Hub Trust & Safety FAQ Issues Contact

Legal

Social