World building with code

Parts and models

--!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

--!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

--!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)

--!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).