US Trends

how to check roblox local requirements of my game

Direct answer — How to check local requirements in your Roblox game:
Use a LocalScript to detect the player's device, OS, and performance (FPS/graphics support) at runtime, then compare those values to the requirements you define and show a UI telling the player whether their machine meets them.

How to implement this — step‑by‑step

  1. Decide the "requirements" you want to check (examples)
  • Platform: PC, Mobile, Xbox.
  • OS version or device family (iOS/Android/Windows/Mac).
  • Graphics capability: whether device supports necessary feature (e.g., OpenGL ES 3.0 on Android) or DirectX capability indirectly via device/OS.
  • Runtime performance: target FPS or acceptable average FPS over a short window.
  1. Gather client info in a LocalScript
  • Detect platform: use game.Players.LocalPlayer and PlatformService info (or UserInputService/Player.DeviceType) to tell mobile vs PC vs console. This is a client-side check and should run in a LocalScript.
  • Detect OS/version hints: read from the device APIs available in Lua (you can sometimes infer from UserInputService:GetPlatform() or related APIs), and prompt players to check their system settings when precise OS version is required.
  • Measure FPS: sample RenderStepped (or Heartbeat) over one second and compute average FPS as shown in forum examples; use that as the basis to accept/reject the player's device for your feature. Example approach: count frames each RenderStepped cycle, accumulate elapsed time, compute fps = frames / elapsed when elapsed ≥ 1s.
  1. Compare values to your requirements and show UI
  • Build a small requirements table in code (e.g., minFPS = 30, allowMobile = true, requireOpenGLES3 = true). Compare client measurements against these values in the LocalScript.
  • Show a clear UI: green check if OK, yellow warning if marginal, red fail if not supported. Provide suggested actions: lower graphics quality, close background apps, update OS, or play on a different device.

Code example (conceptual)

  • Measure FPS (client LocalScript): sample RenderStepped, count frames for 1 second, compute average; repeat and smooth the result. Use that value to compare to your minFPS requirement. Forum posts contain working snippets you can adapt.
  • Platform detection: use UserInputService:GetPlatform() or similar client API to detect Mobile/PC/Xbox and branch your checks accordingly.

Where to put settings and user-facing toggles

  • Store your requirement thresholds in a ModuleScript so both your LocalScript and any server validation can reuse the same rules (ModuleScript required by client). Keep human‑readable messages in a separate table so you can localize/help players. See Roblox Game Settings and Studio docs for where to place configuration and how to package modules/settings for an experience.

When to check on the server too

  • Use client checks for advisories and UI (local performance, device features). If a requirement must be enforced (for example preventing play if certain checks fail), perform server-side verification where possible (for account metadata, group membership, passes), and combine the server decisions with client-reported diagnostics carefully to avoid spoofing. Community forum examples show patterns for mixing client detection with server validation when needed.

Testing and UX suggestions

  • Run the check on join and again when the player changes graphics settings (or resolution).
  • Allow a "Proceed anyway" option with a visible warning if the player wants to continue despite failing requirements.
  • Provide actionable suggestions in the UI (e.g., "Set Graphics Quality to 10" or "Switch to a PC for best performance").

Helpful references

  • Measuring FPS and platform detection examples from community forum posts.
  • Roblox official system requirements for devices and OS guidance (useful when specifying minimum supported OS and graphics expectations).
  • Game Settings documentation for where to keep game-level configuration in Studio.

Final checklist (quick)

  • Decide which checks matter (platform, OS, OpenGL/DirectX hints, FPS).
  • Implement LocalScript detectors (RenderStepped for FPS, UserInputService/GetPlatform for device).
  • Compare to ModuleScript thresholds and show UI with clear messages.
  • Optionally validate critical requirements server-side (account/membership/gamepass/age checks).

Summary TL;DR
Run a LocalScript that detects platform/OS and measures FPS, compare those readings against a ModuleScript list of minimums, and show a friendly UI telling players whether their device meets your game's local requirements.

Bottom note
Information gathered from public forums or data available on the internet and portrayed here.