Skip to main content
skill CX Codex

roblox-world-building — Claude Code skill: what it does

roblox-world-building — a skill for Claude Code and other platforms that automates world-building and 3D environment generation in Roblox. Invoked when creating maps, lighting effects, or procedural levels.

MIT 1,400 installs ★ 131 updated 2026-11-03

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add EL4CTEO/roblox-skills --skill roblox-world-building -a claude-code
Open on GitHub

What roblox-world-building does

This skill assists in writing Luau code to create 3D parts, configure lighting, generate terrain using the Terrain API, and manage procedural models. It handles material application, particle systems, and geometry operations like unions or subtractions via the GeometryService.

Accessing EditableMesh or EditableImage functionality requires the game owner to be identity-verified and to enable the relevant Mesh/Image APIs in the Creator Dashboard. Custom terrain features rely on enabling Expanded Terrain within the Workspace settings, with management handled in the Terrain Materials Manager window.

For smooth visual updates like day/night cycles, the skill prioritizes client-side calculation to prevent replication traffic. Heavy geometry processing tasks are routed to the server with rate limiting. Procedural models regenerate contents based on parameter-driven ModuleScript definitions, supporting both editor-time and runtime updates.

What it helps with

  • generate procedural terrain using noise
  • animate day/night cycles with ClockTime
  • carve shapes in geometry using GeometryService
  • update procedural model parameters dynamically

Example prompts for the agent

  • Generate a 512x512 procedural terrain block
  • Create a server script for a 20-minute day/night cycle
  • Use GeometryService to subtract a custom shape from a wall

How to install roblox-world-building

1Skills CLI (Vercel)

npx skills add EL4CTEO/roblox-skills --skill roblox-world-building -a claude-code

2Manually: put the files in place

~/.claude/skills/roblox-world-building/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/roblox-world-building/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about roblox-world-building

How to install roblox-world-building in Claude Code?

Run npx skills add EL4CTEO/roblox-skills --skill roblox-world-building -a claude-code. The skill will be available at ~/.claude/skills/roblox-world-building/SKILL.md.

What does roblox-world-building do?

It automates the creation of 3D objects, lighting, terrain, and procedural models in Roblox by allowing developers to define complex environments through code.

What is required to use roblox-world-building?

Advanced geometry and image editing features require a verified Roblox account and enabling specific API permissions in the project's Creator Dashboard settings.

Source text

SKILL.md · MIT
---
name: roblox-world-building
description: Building worlds with code - parts, models and pivots, materials, Lighting (LightingStyle, Atmosphere, post-processing), day/night, Terrain API, in-game CSG and destruction (GeometryService Subtract/Union/Fragment), ProceduralModel, EditableMesh/EditableImage, particles/beams/trails/highlights. Use when creating maps, environments, lighting, destructible objects, procedural levels, or visual effects.
---

# World building with code

## Parts and models

```luau
--!strict
local function makePart(size: Vector3, cframe: CFrame, props: { [string]: any }?): Part
	local part = Instance.new("Part")
	part.Anchored = true
	part.Size = size
	part.CFrame = cframe
	part.TopSurface = Enum.SurfaceType.Smooth
	part.BottomSurface = Enum.SurfaceType.Smooth
	for key, value in props or {} do
		(part :: any)[key] = value
	end
	return part -- caller sets Parent last
end

local floor = makePart(Vector3.new(64, 1, 64), CFrame.new(0, 0, 0), {
	Material = Enum.Material.Slate,
	Color = Color3.fromRGB(90, 90, 100),
})
local model = Instance.new("Model")
model.Name = "Arena"
floor.Parent = model
model.WorldPivot = floor.CFrame
model.Parent = workspace
model:PivotTo(CFrame.new(0, 10, 0) * CFrame.Angles(0, math.rad(45), 0))
```

- Set properties first, **parent last** (one replication/physics insert). Anchor static geometry.
- Move/rotate models with `PivotTo`/`GetPivot`; `Model.WorldPivot` / `PrimaryPart` define the pivot.
- Group logically related parts in Models (streaming, LOD, `ModelStreamingMode`), not giant containers.
- Decorative parts: `CanCollide/CanTouch/CanQuery = false`, `CastShadow = false` for tiny details.
- Materials: `Enum.Material.*`; custom looks via `MaterialVariant` in `MaterialService` (set
  `part.MaterialVariant = "Name"`) or `SurfaceAppearance` on MeshParts (PBR). `Decal.Texture` is
  superseded by `ColorMapContent`.
- Many identical meshes are cheap (instanced); many unique meshes/unions are not.

## Lighting

| Property | Guidance |
| --- | --- |
| `Lighting.LightingStyle` | `Realistic` (naturalistic) or `Soft` (stylized). Replaces the superseded `Lighting.Technology`. |
| `Lighting.PrioritizeLightingQuality` | Prefer quality (e.g. shadow maps with Soft) vs performance on lower-end devices. |
| `ClockTime` / `GeographicLatitude` | Sun position; animate `ClockTime` for day/night. |
| `Brightness`, `ExposureCompensation`, `Ambient`/`OutdoorAmbient` | Overall exposure and fill light. |
| `EnvironmentDiffuseScale`/`EnvironmentSpecularScale` | Skybox contribution to lighting and reflections. |
| Children | `Atmosphere` (haze/density, replaces fog), `Sky`, `Clouds` (in Terrain), `BloomEffect`, `ColorCorrectionEffect`, `ColorGradingEffect`, `DepthOfFieldEffect`, `SunRaysEffect`, `BlurEffect`. |

```luau
--!strict
-- Server: smooth day/night cycle (one full day every 20 minutes).
local Lighting = game:GetService("Lighting")
local RunService = game:GetService("RunService")

local DAY_LENGTH_SECONDS = 20 * 60

RunService.Heartbeat:Connect(function(deltaTime)
	Lighting.ClockTime = (Lighting.ClockTime + deltaTime * 24 / DAY_LENGTH_SECONDS) % 24
end)
```

For per-frame visual changes, prefer computing `ClockTime` on each client from
`workspace:GetServerTimeNow()` (no replication traffic, perfectly smooth). Local lights: `PointLight`,
`SpotLight`, `SurfaceLight` — few with `Shadows = true`.

## Terrain

```luau
--!strict
local terrain = workspace.Terrain

terrain:FillBlock(CFrame.new(0, -10, 0), Vector3.new(512, 20, 512), Enum.Material.Grass)
terrain:FillBall(Vector3.new(0, 0, 0), 24, Enum.Material.Air) -- carve a crater
terrain:FillBlock(CFrame.new(40, -2, 0), Vector3.new(30, 4, 30), Enum.Material.Water)
terrain:FillCylinder(CFrame.new(-40, 5, 0), 20, 8, Enum.Material.Rock)
```

- Bulk generation: build a `Region3` (aligned with `:ExpandToGrid(4)`) and use `ReadVoxels`/`WriteVoxels`
  with materials/occupancy arrays (4-stud voxels), in chunks, yielding between chunks.
- `terrain:Clear()`; water look via `Terrain.WaterColor`, `WaterWaveSize`, etc.
- **Custom terrain materials** (fully launched): up to 62 custom materials painted onto terrain, plus smaller
  files and faster loads. Opt in per place: Workspace → **Expanded Terrain = Enabled**, save, reopen; manage
  them in Window → 3D → Terrain Materials Manager. Thin terrain can show LOD gaps — keep it thick.
- Procedural heightmaps: sample `math.noise(x * scale, z * scale, seed)` with octaves; use a `Random.new(seed)`
  for deterministic worlds; generate on the server or use Parallel Luau for heavy math.

## In-game solid modeling and destruction (GeometryService)

```luau
--!strict
local GeometryService = game:GetService("GeometryService")

-- Punch a hole through a wall (e.g. explosions, building games).
local function carve(wall: BasePart, cutter: BasePart): { Instance }?
	local ok, results = pcall(function()
		return GeometryService:SubtractAsync(wall, { cutter }, {
			CollisionFidelity = Enum.CollisionFidelity.Default,
			RenderFidelity = Enum.RenderFidelity.Automatic,
			SplitApart = true, -- disconnected pieces become separate parts
		})
	end)
	if not ok or not results then
		return nil
	end
	for _, piece in results do
		if piece:IsA("BasePart") then
			piece.Anchored = wall.Anchored
			piece.Parent = wall.Parent
		end
	end
	wall:Destroy()
	return results
end

return carve
```

- `UnionAsync`, `IntersectAsync`, `SubtractAsync` return new unparented parts; `FragmentAsync(part, sites)`
  shatters a part (Voronoi) using points from `GenerateFragmentSites`; `SweepPartAsync` extrudes a part
  along CFrames; `CalculateConstraintsToPreserve` keeps welds/constraints when replacing parts.
- Operations are expensive: run on the server, rate-limit, and pool/clean up fragments.

## ProceduralModel (parameter-driven models)

`ProceduralModel` instances regenerate their contents from a **generator ModuleScript** exposing
`Attributes` (parameters) and `OnGenerate(params, targetContainer)`; works at edit time (undo/redo,
Team Create) and runtime. Generate from Studio, Assistant, or the Studio MCP (`generate_procedural_model`).
Creator Store procedural models are sandboxed automatically.

## Runtime meshes and images

`AssetService:CreateEditableMesh()` / `CreateEditableMeshAsync(content)` and `CreateEditableImage` enable
runtime geometry and pixel editing (deformable terrain chunks, painting, custom avatars). Published games
require the owner to be ID + 13+ verified and **Enable Mesh / Image APIs** in Creator Dashboard; strict
client memory budgets apply; only assets owned by/shared with the game owner can be loaded. Display via
`AssetService:CreateMeshPartAsync(Content.fromObject(editableMesh))`. For many vertices/faces use the
EditableMesh **batch APIs** and parallel queries (released for live games) instead of per-element calls.
Players can publish an `EditableImage` to their inventory from the server with
`AssetService:PromptCreatePlatformContentAsync(player, image, Enum.AssetType.Image)` (`pcall`; replaces
`PromptCreateAssetAsync`; needs a published place).

## Effects

- `ParticleEmitter` (use `:Emit(n)` for bursts), `Beam` (between attachments; lasers, ropes), `Trail`
  (swords, projectiles), `Highlight` (outline/fill; limited count), `Explosion` (sets off physics —
  set `DestroyJointRadiusPercent = 0` and `BlastPressure = 0` for visual-only).
- Spawn cosmetic effects on clients; destroy or pool them (`Debris:AddItem(obj, seconds)` is fine).

## Related skills

`roblox-performance` (rendering cost, streaming), `roblox-architecture` (streaming settings),
`roblox-studio-mcp` (build in Studio through MCP), `roblox-physics` (constraints, destruction physics).

© EL4CTEO · MIT · EL4CTEO/roblox-skills

Similar skills

All skills for Game dev and 3D: Unity, Unreal, Godot, Blender →

From the same set22

The whole set →
roblox-performance roblox-performance — a skill for Claude Code that diagnoses Roblox game performance, detects memory leaks, and fixes frame rate drops. Used when games lag, stutter, drop FPS, or experience high ping. CX Codex +1 1,300installs roblox-code-review The roblox-code-review Claude Code skill reviews Roblox code for security flaws, data loss, and lifecycle bugs. It runs for PR or script reviews, game audits, and legacy-code updates. CX Codex +1 1,300installs roblox-security roblox-security — a skill for Claude Code enforces server-authoritative security for Roblox experiences. Runs during reviews of remote event handlers, combat calculations, inventory transactions, and character physics. CX Codex +1 1,300installs roblox-characters-animation roblox-characters-animation — a Claude Code skill for Roblox characters and animation. It applies to work on movement, damage, respawns, avatars, weapons, and tweens. CX Codex +1 1,300installs roblox-game-systems roblox-game-systems — a skill for Claude Code and Codex providing server-authoritative Roblox gameplay recipes. Activates when building currencies, inventory, weapons, round loops, or progression. CX Codex +1 1,300installs roblox-luau The roblox-luau Claude Code skill supports writing and explaining Roblox scripts in Luau. It activates for script creation, refactoring, type-error fixes, and updates to older Lua code. CX Codex +1 1,300installs roblox-ui roblox-ui — a skill for Claude Code and Codex constructs responsive Roblox interfaces. Runs when building HUDs, inventories, storefronts, or fixing layouts across mobile devices and consoles. CX Codex +1 1,300installs roblox-testing The roblox-testing Claude Code skill covers testing Roblox code and checking gameplay changes. It applies when adding tests, configuring a runner, or setting up CI. CX Codex +1 1,300installs

Project sponsors

Companies that keep this analytics open