Cómo programar en Roblox Studio: guía para principiantes

Antes de empezar: Studio, un Baseplate y la ventana Output

Necesitas Roblox Studio y una cuenta de Roblox, y nada más: ni editor de código ni plugin. Todos los scripts de esta guía se escriben en el propio Script Editor de Studio.

1. Instala Roblox Studio, la app gratuita de Roblox para Windows y Mac, e inicia sesión con tu cuenta de Roblox.
2. Abre Studio. Su página de inicio muestra plantillas: elige Baseplate. Obtienes un suelo con una textura de cuadrícula de 4x4 y un SpawnLocation, el punto donde aparece tu avatar cuando juegas.
3. Si no se ven las ventanas Explorer y Properties, ábrelas desde el menú Window o la pestaña Home. El Explorer muestra cada objeto de tu juego; Properties muestra los ajustes de lo que selecciones.
4. Abre Output desde el menú Window o la pestaña Script. Ahí aparecen los mensajes y los errores de tus scripts.
5. En las opciones de visualización de la ventana Output, activa Show Context, que etiqueta cada mensaje como Client o Server, y Show Source, que muestra el script y el número de línea que lo produjo.

Workspace
  Baseplate Part
  SpawnLocation SpawnLocation
  Part Part new
    ColourChanger Script new
  Pad Part new
    TouchPad Script new
ServerScriptService
  FirstScript Script new
StarterPlayer
  StarterPlayerScripts
    MyFirstLocalScript LocalScript new

Paso 1: escribe tu primer script

1. En el Explorer, pasa el ratón sobre ServerScriptService, haz clic en el botón + y elige Script (el atajo es Ctrl+I, o ⌘I en Mac). Studio crea el script y lo abre en el Script Editor.
2. Haz clic derecho en el script nuevo, elige Rename y llámalo FirstScript. El nombre no cambia lo que hace el script, pero te dice qué script imprimió qué.
3. Los scripts nuevos empiezan con una línea, print("Hello world!"). Bórrala y pega el código de abajo.
4. Pulsa Play (F5), con Test elegido en el desplegable de su izquierda. Studio inicia una prueba y pone tu avatar en el SpawnLocation.
5. Lee las líneas del Output y pulsa Stop (Shift+F5). Stop también devuelve cada objeto a como estaba antes de pulsar Play, así que todo lo que moviste o recoloreaste mientras jugabas vuelve atrás.

-- Script en ServerScriptService llamado FirstScript.
-- Tu primer Luau: variables, una función, una sentencia if, un bucle y una tabla.
-- Pulsa Play (F5) y lee los resultados en la ventana Output.

-- Una variable es un nombre que guarda un valor
local gameName = "Coin Run"
local coinsToWin = 3

-- Una función es un bloque de código con nombre que puedes ejecutar las veces que quieras.
-- name y goal son sus parámetros; return devuelve un valor a quien la llamó.
local function describe(name: string, goal: number): string
	return `{name}: collect {goal} coins to win`
end

print(describe(gameName, coinsToWin)) --> Coin Run: collect 3 coins to win

-- Una sentencia if ejecuta código solo cuando su condición es verdadera
if coinsToWin > 5 then
	print("That is a long game")
elseif coinsToWin > 1 then
	print("That is a short game")
else
	print("One coin and you win")
end

-- Un bucle for repite código un número fijo de veces
for count = 1, coinsToWin do
	print("Coin number", count)
end

-- Una tabla guarda una lista de valores; este bucle visita cada uno en orden
local colours = { "Red", "Green", "Blue" }
for position, colour in colours do
	print(position, colour) --> 1 Red, luego 2 Green, luego 3 Blue
end

El Output debería mostrar estas ocho líneas, mezcladas con los mensajes del propio Studio. Cuando print recibe más de un valor, pone un espacio entre ellos. Con Show Context y Show Source activados, cada línea lleva además la etiqueta Server y FirstScript con un número de línea.

Coin Run: collect 3 coins to win
That is a short game
Coin number 1
Coin number 2
Coin number 3
1 Red
2 Green
3 Blue

Relaciona cada línea con el código que la imprimió. Más adelante harás lo mismo con los mensajes de error, así que vale la pena acostumbrarte desde ahora.

FirstScript usa solo Luau puro, sin objetos de Roblox, así que también funciona en el Luau playground gratis en tu navegador. Cambia un valor ahí y vuelve a ejecutarlo para ver qué cambia.

Todo bloque que empieza con function, if, for o while se cierra con end. Un solo end que falte impide que se ejecute el script entero; leer los errores muestra el mensaje que recibes.

Paso 2: cambia una parte desde un script

Los scripts se vuelven útiles cuando cambian cosas en el mundo. Los ajustes que ves en la ventana Properties, como Color, Transparency o Anchored de una parte, son propiedades, y un script también puede cambiarlas.

1. En la pestaña Home, haz clic en Part. Studio añade un bloque al Workspace. Su nombre da igual.
2. En el Explorer, pasa el ratón sobre la parte nueva, haz clic en + e inserta un Script. Llámalo ColourChanger y sustituye su contenido por el código de abajo.
3. Pulsa Play. La parte se vuelve roja, luego azul, luego verde, cambiando una vez por segundo, y vuelve a empezar.

-- Script dentro de una Part en Workspace, llamado ColourChanger.
-- Los scripts cambian las mismas propiedades que ves en la ventana Properties.
-- Este da a su parte un color nuevo cada segundo, para todos los jugadores.

local part = script.Parent :: BasePart -- la parte dentro de la que está este script

local colours = {
	Color3.fromRGB(255, 85, 85), -- rojo
	Color3.fromRGB(85, 170, 255), -- azul
	Color3.fromRGB(85, 255, 127), -- verde
}

part.Anchored = true -- una parte anclada se queda donde la pones

local index = 1
while true do
	part.Color = colours[index]
	index = index % #colours + 1 -- 1, 2, 3 y otra vez 1
	task.wait(1) -- pausa de un segundo (el antiguo wait() está obsoleto)
end

• script.Parent es el objeto dentro del que está el script, aquí la parte. Arrastra el script a otra parte y cambiará esa en su lugar.
• :: BasePart es una conversión de tipo (type cast). Le dice al Script Editor que el padre es una parte, para que pueda comprobar las propiedades que usas en él. Luau usa los tipos solo para avisos y sugerencias, así que la conversión no cambia lo que hace la línea.
• part.Color y part.Anchored son las mismas propiedades que ves en la ventana Properties, con los mismos nombres. Roblox usa la ortografía estadounidense, así que la propiedad es Color aunque este script se llame ColourChanger.
• Anchored = true mantiene la parte quieta: la referencia de Roblox dice que una parte anclada nunca se mueve por la gravedad, las colisiones ni ninguna otra física.
• colours[index] lee un elemento de la lista. #colours es la longitud de la lista, 3, y % da el resto de la división, así que index % #colours + 1 cuenta 1, 2, 3, 1, 2, 3.
• while true do se repite para siempre, por eso importa el task.wait(1) de dentro. La documentación de Roblox dice que pongas siempre una pausa como task.wait() en un bucle infinito: sin ella, el juego se congela y Studio se cuelga.

ColourChanger es un Script, así que se ejecuta en el servidor, y todos los jugadores del juego ven el mismo color a la vez. El paso 4 muestra el otro tipo de script.

Paso 3: reacciona a un jugador con un evento

La mayor parte del código de un juego espera a que pase algo: un jugador entra, se toca una parte, se hace clic en un botón. Roblox los llama eventos. Para ejecutar código cuando uno se dispara, le conectas una función.

1. Inserta otra Part y llámala exactamente Pad, con P mayúscula. Déjala directamente en el Workspace, no dentro de una carpeta o un modelo, porque el LocalScript del paso 4 la busca ahí.
2. Conviértela en una plataforma plana que puedas pisar, por ejemplo poniendo su Size a 6, 1, 6 en la ventana Properties. Muévela al suelo cerca del SpawnLocation y marca Anchored para que no se mueva.
3. Pasa el ratón sobre Pad, haz clic en +, inserta un Script, llámalo TouchPad y pega el código de abajo.
4. Pulsa Play y pisa la plataforma. Se vuelve amarilla durante 2 segundos, y el Output dice tu nombre.

-- Script dentro de una Part en Workspace llamada Pad, script llamado TouchPad.
-- Eventos: cuando un jugador pisa la plataforma, brilla en amarillo y el Output dice quién fue.
-- Un debounce evita que se ejecute muchas veces por segundo mientras está encima.

local Players = game:GetService("Players")

local pad = script.Parent :: BasePart
local COOLDOWN_SECONDS = 2

local normalColour = pad.Color
local busy = false

local function onTouched(otherPart: BasePart)
	if busy then
		return -- todavía en espera desde el último toque
	end
	-- El personaje es el Model que contiene la parte del cuerpo (o el sombrero) que tocó
	local character = otherPart:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player then
		return -- la tocó una parte suelta o un NPC, no un jugador
	end

	busy = true
	print(`{player.Name} stepped on the pad`)
	pad.Color = Color3.fromRGB(255, 220, 0)
	task.wait(COOLDOWN_SECONDS)
	pad.Color = normalColour
	busy = false
end

pad.Touched:Connect(onTouched)

Por qué la plataforma necesita un debounce

La página de debounce de Roblox advierte que Touched se dispara varias veces muy seguidas cuando las partes entran en contacto, y un personaje que camina tiene varias partes del cuerpo. Sin una comprobación, un solo paso sobre la plataforma podría imprimir muchas líneas y reiniciar el brillo amarillo una y otra vez.

La variable busy es el debounce. El primer toque la pone en true, y cada toque durante los 2 segundos siguientes llega a if busy then return end y se para. Después de task.wait(COOLDOWN_SECONDS) la plataforma vuelve a su color y busy vuelve a false. COOLDOWN_SECONDS va en mayúsculas porque es un ajuste que no cambia mientras el juego se ejecuta, la convención que sugiere Roblox para las constantes.

Esta plataforma tiene un solo debounce para todos, así que un segundo jugador que la pise en esos 2 segundos se ignora. Para una plataforma que brilla, está bien. Una plataforma que da recompensas debería llevar una espera por jugador, como hace la plataforma de monedas de la guía de leaderboard (en inglés).

Paso 4: tu primer LocalScript, y por qué es distinto

Un juego en marcha es un servidor más un cliente por cada jugador. Todo lo anterior era un Script, que se ejecuta en el servidor, así que sus cambios llegan a todos los jugadores. Un LocalScript, en cambio, se ejecuta en el dispositivo de un solo jugador. Las pulsaciones de teclas, la cámara y los menús en pantalla se gestionan ahí, porque solo ese dispositivo los conoce.

1. En el Explorer, despliega StarterPlayer, pasa el ratón sobre StarterPlayerScripts, haz clic en + e inserta un LocalScript. Llámalo MyFirstLocalScript y pega el código de abajo.
2. Pulsa Play. El Output muestra Hello, y tu nombre, con la etiqueta Client.
3. Haz clic en la vista del juego y pulsa E. La plataforma se desvanece. Pulsa E otra vez para recuperarla.
4. Con la prueba todavía en marcha, haz clic en el interruptor Client/Server de los controles de prueba de Studio para pasar a la copia del juego del servidor. Ahí la plataforma está sólida: el servidor nunca se enteró del cambio.

-- LocalScript en StarterPlayer > StarterPlayerScripts llamado MyFirstLocalScript.
-- Un LocalScript se ejecuta en el dispositivo de un jugador. Pulsa E: la Pad se desvanece solo en tu
-- pantalla, porque un cambio a una parte hecho aquí no llega al servidor ni a nadie más.

local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")

local player = Players.LocalPlayer
print(`Hello, {player.Name}`) -- aparece en el Output, marcado como Client

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- la tecla se usó para otra cosa, como escribir en el chat
	end
	if input.KeyCode == Enum.KeyCode.E then
		local pad = workspace:FindFirstChild("Pad")
		if pad and pad:IsA("BasePart") then
			pad.Transparency = if pad.Transparency == 0 then 0.6 else 0
		end
	end
end)

• Players.LocalPlayer es el jugador cuyo dispositivo ejecuta el script. Roblox lo define solo para LocalScripts y los ModuleScripts que estos requieren, así que el código del servidor no puede usarlo.
• UserInputService.InputBegan se dispara cuando el jugador empieza una pulsación de tecla, un clic o un toque. gameProcessed es true cuando el motor ya usó esa entrada, por ejemplo un clic en un botón o una tecla escrita en la barra de chat, así que el script la ignora.
• workspace:FindFirstChild("Pad") devuelve el hijo llamado Pad, o nil si no hay ninguno. pad:IsA("BasePart") comprueba que de verdad es una parte antes de que el script cambie su Transparency.
• if pad.Transparency == 0 then 0.6 else 0 es una expresión if: elige uno de dos valores. Una Transparency de 0 es totalmente visible y 1 es invisible.
• Un script de sprint con Shift (en inglés) es un buen segundo LocalScript: escucha una tecla y cambia la WalkSpeed de tu personaje.

Lo que puede cambiar un tramposo

Da por hecho que un tramposo controla todo en su propio dispositivo. Puede ejecutar sus propios LocalScripts y cambiar los tuyos, así que puede desvanecer la plataforma, o cualquier otra cosa, en su propia pantalla. Aquí eso es inofensivo: el desvanecido es solo visual y se queda en su dispositivo. También es la razón por la que todo lo que importa lo decide un Script en el servidor.

Un Script de servidor tampoco es seguro automáticamente. TouchPad se ejecuta en el servidor, pero el dispositivo de cada jugador controla la física de su propio personaje, y la documentación de seguridad de Roblox incluye manipular cuándo se dispara Touched, o impedir que se dispare, entre lo que un cliente puede hacer con las partes que controla. Para una plataforma que brilla, da igual. Para una que paga, comprueba también algo que el servidor controle por sí mismo, como la regla de la guía de obby (en inglés) de que los checkpoints solo cuentan en orden.

Paso 5: prueba los cuatro scripts juntos

1. Limpia el Output con Ctrl+K (⌘K en Mac) y pulsa Play (F5). El Output muestra las ocho líneas de FirstScript con la etiqueta Server, y tu línea Hello con la etiqueta Client. La parte de ColourChanger cambia de color cada segundo.
2. Pisa la plataforma. Se vuelve amarilla durante 2 segundos y el Output muestra tu nombre y "stepped on the pad" una vez. Sigue caminando por encima: aparece una línea nueva como mucho una vez cada 2 segundos, no cada vez que se dispara Touched.
3. Pulsa E. La plataforma se desvanece hasta una Transparency de 0.6. Pulsa E otra vez y está sólida.
4. Pulsa Stop. En el desplegable de pruebas elige Server & Clients, pon 2 clientes y pulsa Play (o F7). Studio abre una ventana de servidor y dos de cliente. En un cliente, pulsa E: la plataforma se desvanece ahí, mientras el otro cliente y el servidor siguen viéndola sólida. Pulsa End Session al terminar.
5. Rompe algo a propósito. Cambia el nombre de Pad a Pad2 y juega. Pisarla sigue volviéndola amarilla, porque TouchPad encuentra su parte con script.Parent, no por el nombre. Pulsar E ahora no hace nada, y no hay error: FindFirstChild("Pad") devolvió nil, y la comprobación if pad and ... se saltó el resto sin decir nada. Añade print(pad) en la línea después de FindFirstChild, juega y pulsa E: el Output muestra nil. Un print así es la forma más rápida de averiguar por qué un script no hace nada. Pulsa Stop, borra la línea del print y vuelve a llamar Pad a la parte.

Dónde van los scripts

Dónde está un script decide si llega a ejecutarse, y Studio no te avisa cuando nunca lo hará. Para los scripts que escribirás a continuación:

La página de ubicaciones de scripts de Roblox recomienda no poner scripts directamente dentro de partes en Workspace: etiqueta las partes y trabaja con ellas desde un único ModuleScript usando CollectionService. Un script dentro de una parte sigue siendo la forma más fácil de empezar, y vale para uno o dos objetos mientras aprendes. La guía de puertas muestra el patrón con etiquetas, con un solo script para todas las puertas, y la guía de cliente y servidor (las dos en inglés) tiene la tabla completa de qué contenedores ejecutan qué scripts.

Cuando algo sale mal: lee el Output

Los errores aparecen en rojo en el Output. Cada uno empieza con dónde pasó, el nombre completo del script y el número de línea, y luego dice qué salió mal. Haz clic en el error y Studio abre ese script en esa línea. Por ejemplo, si borraras la comprobación if not player de TouchPad y cayera una parte suelta sobre la plataforma, el Output mostraría:

Workspace.Pad.TouchPad:22: attempt to index nil with 'Name'

Los errores en cómo está escrito el código, como un end que falta, aparecen antes de pulsar Play: el Script Editor los subraya en rojo, y la ventana Script Analysis (el botón Analysis de la pestaña Script) los enumera. Un script con uno de estos errores no se ejecuta en absoluto, ni siquiera las líneas de antes.

Cuando un script no hace nada y el Output tampoco muestra nada, suele estar en un sitio donde nunca se ejecuta, o esperando un evento que nunca se dispara. La guía de errores de scripts (en inglés) tiene una lista para scripts silenciosos y profundiza en cómo leer el Output.

Qué hacen distinto los tutoriales de scripting antiguos

Si también aprendes con videos y publicaciones de foros, te encontrarás patrones antiguos. Estos son los que importan, con el motivo por el que cada uno es un problema.

Práctica: tres cambios para probar

Cambiar código enseña más que leerlo. Prueba estos en tu propio juego, de uno en uno, y pulsa Play después de cada uno.

• Haz que la plataforma dé un punto. Añade el script Leaderstats del paso 1 de la guía de leaderboard (en inglés). Luego en TouchPad, después de busy = true, busca la carpeta leaderstats del jugador y suma 1 a su valor Coins. Pista: player:FindFirstChild("leaderstats"), luego leaderstats:FindFirstChild("Coins"), luego coins.Value += 1. La plataforma de monedas de la guía de leaderboard es una versión terminada, con una espera por jugador.
• Desvanece también el cambiador de color. Haz que ColourChanger cambie también la Transparency de la parte cada segundo. Pista: añade una segunda tabla de números entre 0 y 1, como { 0, 0.3, 0.6 }, y pon part.Transparency a partir de ella en la línea después de part.Color, usando el mismo index.
• Imprime el color de la plataforma. Haz que MyFirstLocalScript imprima el Color de la plataforma cuando pulses E. Pista: print(pad.Color) dentro del bloque if pad and pad:IsA("BasePart"). Pulsa E mientras la plataforma está amarilla: el cliente ve el color que puso el servidor, porque los cambios hechos en el servidor llegan a todos los clientes.

Qué aprender después

Ya has usado las piezas con las que se construyen la mayoría de los scripts de juegos. Un buen orden para lo que viene:

1. LocalScript vs Script vs ModuleScript: dónde se ejecuta cada tipo de script y qué puede cambiar, con más detalle que el paso 4.
2. RemoteEvents: cómo un LocalScript le pide al servidor que haga algo, y cómo el servidor comprueba la petición.
3. Una tabla de clasificación: tus primeras estadísticas, creadas y cambiadas en el servidor.
4. Tu primer juego: un recorrido corto con lava, monedas y una meta, dirigido por dos scripts de servidor, y luego publicado.
5. Luego elige un sistema que añadir: una tienda con GUI, un sistema de rondas, checkpoints de obby, una pantalla de carga o una animación al pulsar una tecla. Cuando algo se rompa, la guía de errores de scripts te ayuda a leer el mensaje. Estas guías están en inglés.

Los tutoriales Coding fundamentals de Roblox (en inglés) son un buen complemento: seis series que van de variables y funciones a condicionales, bucles, arrays y diccionarios, hasta organizar el código con ModuleScripts, con pequeños proyectos para construir en Studio.

Errores comunes y soluciones

La mayoría de los problemas con un primer script son un nombre que no coincide, un script en el lugar equivocado o un bucle sin espera. Deja el Output abierto mientras pruebas.

Desatascarte con RoCode

Si te atascas con un script en tu propio juego, RoCode puede leerlo contigo. RoCode es un agente de IA independiente para Roblox Studio, no lo hace Roblox: escribes en un chat web y su plugin de Studio crea y edita los scripts de tu Explorer.

Mientras aprendes, el modo útil es Ask: los scripts los sigues escribiendo tú, y RoCode lee lo que ya hay y responde tus preguntas.

En modo Build con el plugin 3.9 o posterior, RoCode puede hacer una prueba corta y leer los errores, y con el plugin 3.9.11 o posterior controlar un personaje de prueba para comprobar que el juego funciona, pero no toma capturas mientras el juego se ejecuta, así que la plataforma la sigues pisando tú. Cómo se conecta RoCode a Studio.

Preguntas frecuentes

Fuentes y lecturas

• Roblox Creator Docs: Luau (en inglés). qué es Luau y de dónde viene
• Roblox Creator Docs: Roblox Studio setup (en inglés). Windows y Mac, y los requisitos del sistema
• Roblox Creator Docs: Output (en inglés). abrir el Output, filtros, Show Context y Show Source
• Roblox Creator Docs: Studio testing modes (en inglés). Play, Run, Stop, el interruptor Client/Server y Server & Clients
• Roblox Creator Docs: Script Editor (en inglés). dónde se abren los scripts nuevos, y Script Analysis
• Roblox Creator Docs: Script types and locations (en inglés). dónde se ejecuta cada tipo de script, y etiquetar partes en lugar de poner scripts dentro
• Roblox Creator Docs: Script (en inglés). cuándo empieza a ejecutarse un Script
• Roblox Creator Docs: Control structures (en inglés). sentencias if, bucles, y por qué un bucle infinito necesita una espera
• Roblox Creator Docs: Events (en inglés). Connect, y lo que Touched pasa a tu función
• Roblox Creator Docs: Debounce patterns (en inglés). por qué Touched se dispara varias veces por un solo contacto
• Roblox Creator Docs: wait (en inglés). el wait() global y task.wait()
• Roblox Creator Docs: Network ownership, movement validation and physics exploits (en inglés). lo que un cliente puede hacer con su propio personaje
• Roblox Creator Docs: Coding fundamentals (en inglés). la serie para principiantes de Roblox

Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 26 de octubre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.