sentinelcore/roblox-skills

roblox-performance

Use when optimizing a Roblox game for better frame rates, reducing lag, improving server or client performance, diagnosing FPS drops, handling large worlds, or when asked about streaming, draw calls, object pooling, LOD, MicroProfiler, or expensive loop ope…

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/sentinelcore/roblox-skills --skill roblox-performance

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

Roblox Performance Optimization

Quick Reference

TechniqueImpactWhen to Use
StreamingEnabledHighLarge open worlds
Object poolingHighFrequent spawn/destroy
Cache references outside loopsHighHeartbeat/RenderStepped
task.wait() over wait()MediumAll scripts
MeshParts over UnionsMediumMany unique shapes
LOD (hide at distance)MediumComplex models
Anchor static partsMediumReduce physics budget
Limit PointLightsHighAny scene with many lights

StreamingEnabled

Enable for large worlds — engine sends only nearby parts to the client.

lua
-- Studio: Workspace > StreamingEnabled = true
workspace.StreamingEnabled = true
workspace.StreamingMinRadius = 64
workspace.StreamingTargetRadius = 128
  • Parts outside the radius are nil on the client — always guard with if part then.
  • Set Model.LevelOfDetail = Disabled on models that must always be present.
  • Pre-stream an area before a cutscene or teleport:
lua
workspace:RequestStreamAroundAsync(targetPosition, 5) -- 5s timeout

Hot-Path Loop Optimization

RunService.Heartbeat and RenderStepped fire every frame (~60×/sec). Keep them lean.

Bad — searching the hierarchy every frame

lua
RunService.Heartbeat:Connect(function()
    local char = workspace:FindFirstChild(player.Name)
    local humanoid = char and char:FindFirstChild("Humanoid")
    if humanoid then humanoid.WalkSpeed = 16 end
end)

Good — cache references once, do work only when needed

lua
local humanoid = nil

Players.LocalPlayer.CharacterAdded:Connect(function(char)
    humanoid = char:WaitForChild("Humanoid")
end)

RunService.Heartbeat:Connect(function(dt)
    if not humanoid then return end
    humanoid.WalkSpeed = 16  -- cached reference, no search
end)

Rules:

  • Cache game:GetService() and part references outside the loop.
  • Never call FindFirstChild, GetChildren, or GetDescendants inside Heartbeat.
  • Throttle work that doesn't need every frame:
lua
local TICK_INTERVAL = 0.5
local elapsed = 0

RunService.Heartbeat:Connect(function(dt)
    elapsed += dt
    if elapsed < TICK_INTERVAL then return end
    elapsed = 0
    -- expensive work here, runs 2×/sec instead of 60×/sec
end)

task Library vs Legacy Scheduler

Always use task — wait() and spawn() throttle under load and are deprecated.

LegacyModern
wait(n)task.wait(n)
spawn(fn)task.spawn(fn)
delay(n, fn)task.delay(n, fn)
coroutine.wrap(fn)()task.spawn(fn)

Object Pooling

Reuse instances instead of creating and destroying them every frame.

lua
-- ObjectPool ModuleScript
local ObjectPool = {}
ObjectPool.__index = ObjectPool

function ObjectPool.new(template, initialSize)
    local self = setmetatable({ _template = template, _available = {} }, ObjectPool)
    for i = 1, initialSize do
        local obj = template:Clone()
        obj.Parent = nil
        table.insert(self._available, obj)
    end
    return self
end

function ObjectPool:Get(parent)
    local obj = table.remove(self._available) or self._template:Clone()
    obj.Parent = parent
    return obj
end

function ObjectPool:Return(obj)
    obj.Parent = nil
    table.insert(self._available, obj)
end

return ObjectPool
lua
-- Usage
local pool = ObjectPool.new(ReplicatedStorage.Bullet, 20)

local function fireBullet(origin)
    local bullet = pool:Get(workspace)
    bullet.CFrame = CFrame.new(origin)
    task.delay(3, function() pool:Return(bullet) end)
end

Level of Detail (LOD)

Built-in: Set Model.LevelOfDetail = Automatic — engine merges distant parts into an imposter mesh automatically.

Manual distance-based LOD:

lua
-- LocalScript
local INTERVAL = 0.2
local LOD_DISTANCE = 150
local elapsed = 0

RunService.Heartbeat:Connect(function(dt)
    elapsed += dt
    if elapsed < INTERVAL then return end
    elapsed = 0

    local dist = (workspace.CurrentCamera.CFrame.Position - model.PrimaryPart.Position).Magnitude
    local visible = dist < LOD_DISTANCE
    for _, v in model:GetDescendants() do
        if v:IsA("BasePart") then
            v.LocalTransparencyModifier = visible and 0 or 1
        end
    end
end)

Reducing Draw Calls

  • Merge parts that share a material into one MeshPart (export from Blender as .fbx).
  • MeshParts batch better than CSG Unions (Unions re-triangulate at runtime).
  • Reuse materials — 10 parts sharing SmoothPlastic costs far less than 10 unique textures.
  • Use TextureId on a single MeshPart instead of stacking Decals on many parts.

Profiling with MicroProfiler

  1. Press Ctrl+F6 in-game to open MicroProfiler.
  2. Press Ctrl+P to pause and inspect a single frame.
  3. Look for wide bars in heartbeatSignal (Lua), physicsStepped (physics), or render (GPU).
  4. Label your own code:
lua
RunService.Heartbeat:Connect(function()
    debug.profilebegin("MySystem")
    -- your code
    debug.profileend()
end)

Common FPS Killers

CauseFix
Thousands of individual partsMerge into MeshParts
Unanchored static geometryAnchored = true on anything that never moves
Many PointLight / SpotLight instancesLimit to ~10–20 dynamic lights per area
High-rate ParticleEmittersLower Rate and Lifetime; disable when off-screen
wait() under heavy loadReplace with task.wait()
FindFirstChild chains inside HeartbeatCache on load
StreamingEnabled off on large mapsEnable it
Model.LevelOfDetail = Disabled everywhereUse Automatic where safe

Common Mistakes

MistakeFix
workspace:FindFirstChild every frameCache reference on character/model load
Destroying and re-creating bullets/effectsUse an object pool
wait() in tight loopstask.wait()
All parts with unique materialsStandardize to a small set of shared materials
ParticleEmitters enabled off-screenDisable Enabled when particle source is not visible
Physics on decorative partsAnchored = true
같은 저장소의 Skills

더 많은 Skills

모든 Skills
sentinelcore
커뮤니티

roblox-gui

Use when building, animating, or debugging Roblox GUI elements including HUDs, menus, world-space UI, and player labels. Triggers on: ScreenGui setup, SurfaceGui or BillboardGui placement, UDim2 sizing questions, TweenService UI animations, responsive scaling, LocalScript GUI logic, ResetOnSpawn issues, or any Frame/TextLabel/ImageButton layout work.

1시간 설치 수
3
GitHub Stars
31
업데이트
2월 23일
sentinelcore
커뮤니티

roblox-animations

Use when working with Roblox animation systems including playing, stopping, or blending animations on Humanoid characters or non-Humanoid models, handling AnimationTrack events, replacing default character animations, or debugging animation priority and blending issues.

1시간 설치 수
2
GitHub Stars
31
업데이트
2월 23일
sentinelcore
커뮤니티

roblox-datastores

Use when implementing player data persistence in Roblox, saving/loading player stats or inventory, building leaderboards with ordered datastores, handling data migration between versions, diagnosing data loss issues, or adding auto-save and shutdown-safe data handling with DataStoreService.

1시간 설치 수
2
GitHub Stars
29
업데이트
2월 23일
sentinelcore
커뮤니티

roblox-monetization

Use when developing Roblox games or experiences and need to earn Robux through Game Passes, Developer Products, UGC avatar items, or Premium Payouts — covers both Studio scripting and Creator Hub dashboard setup.

1시간 설치 수
2
GitHub Stars
29
업데이트
2월 23일