Question Roblox Internal — TaskScheduler & lua_state Acquisition Logic

[byte_corvus]

Anyone still digging into Roblox internals since Bitdancer took over? Trying to map out a reliable execution flow for an internal project and looking for some verification on the job-loop logic.

The Logic Flow
The standard approach for a raw internal usually follows this chain:

1. Inject DLL (assuming you have a bypass for the entry point).
2. Locate the TaskScheduler (usually via a static offset or pattern scan).
3. Iterate through the Task/Job list (e.g., WaitingHybridScriptsJob or RenderJob).
4. Hook a function within that job context to safely grab the lua_state (r_lua_State).

Technical Implementation Notes
While this is the classic "textbook" method for Roblox internals, simply finding the TaskScheduler isn't the finish line anymore. You need to ensure you're syncing with the engine's frame steps to avoid instant crashes or desync when calling Luau functions.

Spoiler: Common Pitfalls

1. Calling lua_state from a non-main thread will result in an immediate crash.
2. Byfron/Hyperion checks for hooked functions in the job loop; you'll need a clean way to intercept the state without triggering integrity checks.
3. Static offsets for TaskScheduler change every patch, so a robust pattern scanner is mandatory.

// Pseudo-logic for job iteration
auto jobs = task_scheduler->get_jobs();
for (auto& job : jobs) {
    if (job->name == "WaitingHybridScriptsJob") {
        // Logic to extract script_context and state
    }
}

Is this the most stable way to handle it currently, or are people moving towards more stealthy state acquisition methods to stay under the radar of the current AC?

Drop your thoughts on job-loop hooking below.