Custom iOS Roblox Executor

@bojans9

Hi, Bojan here, from Serbia. What matters most in building your custom iOS Roblox executor with Xcode and Swift is an app that passes store review and works on the phones your users own. I'm a senior mobile app developer with 8+ years of experience working with Roblox, iOS, Mobile App Development and C++. With Roblox, the real challenge is device differences and store review. A common issue: ignoring the app store rules until submission, then losing time to rejections. My plan: first, map the screens, user flows and store requirements. Then, build the core flows in Roblox, testing on real devices. Finally, test on older phones, then prepare the store listings and submit. I'd start with the core app flows as phase one. After handover I stay on for fixes. I've done mobile app work in Roblox. A few questions to better understand the scope: 1. Must the app work with no signal? Offline mode changes how data gets stored. 2. Release to a small test group before launch? I'd recommend it, real testers catch more issues. 3. Will people use the app daily? Usage frequency shapes startup speed and onboarding. I can start right away. I'm on CET, so our working hours overlap. Happy to go over the details here in chat and suggest the best approach. Looking forward to hearing from you, Bojan

@guptakishan805

As a seasoned Full Stack Developer with over 5 years of hands-on experience, specializing in iOS and iPhone app development using Objective-C and Swift, I believe I possess the ideal skillset to realize your ambitious project - Lume. My expertise extends beyond just writing code; it encompasses understanding and addressing client goals, making suggestions for improvements, and fostering efficient, clear communication throughout the project. Throughout my career, I have successfully built numerous mobile applications that possess precisely what you're requesting for the Lume project: a modern interface, touch-first layout with clean animations, syntax-highlighting text editor, and responsiveness across various iPhone and iPad resolutions. Additionally, my exposure to building AI-powered solutions and API integration aligns perfectly with your intended plan for Lume's custom execution API designed for plugin authors. With respect to your timeline, I am confident that my ability to swiftly translate requirements into action will ensure a demonstrable build inside one month. Furthermore, my dedication towards building reliable digital products ensures I will provide concise engineering notes that enhance the longevity and maintainability of your app—keeping it in sync with future Roblox updates. Ultimately, my focus is on delivering scalable solutions that stand the test of time—exactly what you need for Lume. Let’s work together!

@umer419

Hello, I checked your project "Custom iOS Roblox Executor" and already have a clear understanding of your requirements and how to deliver them efficiently. I have solid experience in Mobile App Development, and I've successfully completed similar projects by delivering high-quality, scalable, and reliable solutions. Why choose me? * Strong expertise in Mobile App Development * Clean, optimized, and scalable implementation * Fast communication and regular progress updates * Focused on delivering results, not just completing the task I'm ready to start immediately and would be happy to discuss the details. Best regards, Umer

@sara0346

Hello, I can develop the iPhone/iPad application architecture, touch-first UI, syntax-highlighted Luau editor, dark/light themes, responsive layouts, custom scripting API, and a standalone Luau runtime based on an appropriately licensed/customized Luau implementation. I can provide a clean Swift/Objective-C/C++ Xcode project, documentation, testing, and an IPA suitable for the permitted deployment method. I can also structure the runtime and API layer so future Luau language updates can be integrated predictably without relying on Roblox memory manipulation, reverse engineering, or security bypasses. I’m ready to start immediately and can target a demonstrable build within the requested month. Would you be open to defining Lume as a standalone Luau scripting environment rather than an executor that modifies or bypasses the Roblox client? Best Regards, Sara

@Noorulamin331

Hello, I have reviewed your Lume project. However, I must be transparent: building a custom Luau executor for Roblox that injects into the client, syncs with Roblox's interpreter, and exposes a custom execution API for non-jailbroken iOS devices is designed to bypass Roblox's security controls and violates Roblox's Terms of Service. This falls under unauthorized modification and injection, which I cannot build, document, or support. What I can offer instead: if you are building a legitimate Luau development environment—a standalone scripting sandbox, a Roblox Studio plugin, or an educational interpreter—I can help with a custom Luau fork, Swift/Objective-C UI, and a clean Xcode project that does not inject into Roblox or evade its protections. If your goal involves legitimate scripting tools within Roblox's allowed ecosystem, I am glad to assist. Noor ul Amin

@denisSolution

Hello, I'm Denis, a full-stack developer experienced in building iOS apps that bridge desktop tooling to mobile, including reverse-engineering work to keep functionality in sync across platforms. I understand you're building Lume as a mobile Roblox executor that runs existing Luau scripts without modification, with a polished touch-first interface for iPhone and iPad. The execution engine must match Roblox's interpreter so desktop scripts behave identically on iOS. I'll start by reviewing your target Roblox version and confirming script compatibility scope. Then I'll build the custom Luau parser and execution layer in C++, wrap it with Swift bindings, and create the iOS UI using SwiftUI for the editor, console, and settings. I'll add syntax highlighting, dark/light themes, and test responsiveness across device sizes. Once the core executor works, I'll document the build process and create maintenance notes covering memory offsets, symbol lookups, and obfuscation handling for future Roblox updates. The main challenge is keeping the Luau interpreter in sync with Roblox's internal changes. I'll handle this by documenting the exact version baseline, tracking offset patterns, and building a maintenance guide to prevent full rewrites on updates. To meet the one-month timeline, I'll focus the first build on core execution and essential UI, leaving refinements for post-launch. I'm ready to start immediately. Let's discuss the details. Thanks, Denis.

@pooja10verma

I can start right now I have checked the details for Lume and I have some questions like are we targeting dynamic library injection via sideloaded JIT enablers like SideStore, or an alternative execution vector for the iOS/iPadOS environment? For keeping the custom Luau fork in sync with Roblox's mobile updates, we will abstract memory offset resolution through a centralized signature-scanning header and dynamic symbol lookup table. This isolates fragile offsets from the core execution API, allowing us to patch obfuscation tweaks and updates cleanly when new mobile binaries drop. You will get the full Xcode project with Swift/C++ source, a sideloadable .ipa, and complete documentation. I can hit that one-month demonstrable build milestone. lets do it

@ridwaan6254

Hi there, I can handle your project "Custom iOS Roblox Executor" with high accuracy, clean organization, and fast turnaround. Here is what I will do for you: 1. Scope Review: Clarify your exact requirements and format so the work is completed correctly on the first pass. 2. Accurate Execution: Complete the task with strict attention to detail, quality checks, and clean formatting. 3. Final Verification: Deliver the organized files (Excel, Google Sheets, or CSV) for your review and approval. Zero Risk: You can inspect an initial sample of the completed data before releasing any milestone payment. Quick Question: What is the desired format for your final deliverable, and do you have a specific deadline you need this completed by? Best regards, Ridwaan M

@Yoshida57

Hi, I’ve reviewed your project and understand that you’re looking for a polished iPhone/iPad app that runs Luau scripts with desktop-like parity, with particular attention to keeping execution behavior aligned with Roblox updates. I can help you with this by building the custom execution pipeline, a touch-first Swift/Objective-C/C++ app shell, and a modern editor UI with theming and responsive layouts. I have relevant experience with iOS app architecture, native C++ integration, and interpreter/runtime work, and I’ll make sure the work is reliable. For your project, my approach would be: • Build the core Luau runtime integration and custom execution API • Create the iPhone/iPad interface with animated panels, syntax highlighting, and theme support • Package build documentation, sideload-ready output, and maintenance notes for version updates I’ll keep communication clear throughout the project and provide regular updates so you always know the progress. I can start immediately and can work within your one-month timeline. If you share the exact current Luau fork baseline and target iOS minimum version, I can confirm the exact approach and get started. Looking forward to discussing the project with you. Best regards, Kanae

@Alexwebo23

Hi Creating a custom iOS Roblox executor as robust as desktop versions involves seamlessly integrating Luau to ensure all scripts work out-of-the-box. This sounds like a job that requires precise control over script execution with a fully custom API, avoiding off-the-shelf solutions. To tackle this, I would architect the app using Swift and Objective-C with a tailored Luau fork, ensuring compatibility with existing scripts. My background includes building an AI-driven app with complex UI elements using Swift and integrating custom APIs. I appreciate your commitment to a clean, modern interface, as it mirrors my approach to designing solutions that are both functional and user-friendly. I'm confident I can help you build Lume into a seamless tool for Roblox scripting. Let’s connect to go through my approach in detail or discuss any specific aspects you’re curious about. Thanks, Oswaldo

@mirimera

I’ve built iOS and iPadOS developer tools in Swift with touch-first editors, theming, and native C++ runtime integrations. For this project, the key is using an approved, sandboxed Luau runtime with a clearly defined API boundary, because iOS reliability and maintainability depend on deterministic execution rather than device-level modification. I’ll create the adaptive SwiftUI interface, syntax-highlighted editor, animated panels, and dark/light themes for current iPhone and iPad sizes. I’ll package the runtime bridge cleanly, document builds and APIs, and verify sample scripts execute consistently on physical devices. I can also outline a versioned update process for supported runtime changes and long-term maintenance. Thanks, Kittipong

@Fazeennazar

Hello I checked your project and main point is like this: a custom iOS/iPadOS Roblox executor named Lume with a real Luau interpreter, a fully custom execution API for future plugin authors, a polished touch-first UI, and engineering notes so version bumps stay predictable. In the past I built similar project and I have full experience of iOS development in Swift and Objective-C with C++ integration, embedding custom interpreters under Xcode, plus Unity and Mono work where I kept engine-level bytecode execution in step with upstream updates. I would build Lume as a thin Swift/Objective-C shell around a C++ core, forking the Luau VM and exposing a custom execution API through a lightweight bridge. For UI, I'd lay out animated panels, a syntax-highlighting editor and dark/light themes using SwiftUI on top of UIKit where touch handling needs finer control, targeting every current iPhone and iPad resolution. To keep pace with Roblox updates, I'd isolate memory offsets and symbol lookups behind a small abstraction layer, so obfuscation tweaks only touch one place. On device testing, the .ipa would be built for sideloading to a non-jailbroken device from the start. Quiz: does your .ipa need to work on a specific iOS version range, and do you already have a bundle ID and signing team I should assume during development? Best regards. mohamed Fazeem

@richard031596

You need a custom iOS Roblox executor that can run existing Luau scripts consistently while providing a polished touch-first experience across iPhone and iPad. I can build the Swift/Objective-C/C++ architecture around a custom Luau integration, including the execution API, syntax-highlighted editor, animated panels, themes, responsive layouts, and Xcode build configuration. I can also structure the runtime layer so interpreter changes can be isolated and regression-tested rather than coupling every update to the UI. For long-term maintenance, I would keep versioned runtime compatibility layers, automated script test suites, symbol/offset configuration separated from core execution code, and documented update procedures so changes can be evaluated systematically. I’m comfortable with Swift, Objective-C, C++, Xcode, mobile architecture, and native runtime integration. Can you provide the target Luau/Roblox compatibility baseline and the current prototype, if one exists?

@zohaiba101

Hello, I hope your week is going well. I've built several iOS runtimes that embed a scripting engine alongside native UI, so the Luau side of Lume is familiar ground. One recent build for a security research team wrapped a custom Lua-derived interpreter in a Swift app with a C++ bridge, and the trickiest part was keeping opcode dispatch byte-identical to the reference build so scripts didn't silently drift. We solved it with a generated opcode table checked into the repo and a harness that diffs execution traces against the upstream binary on every update. For Lume I'd start by forking Luau at a pinned upstream commit, building it as a static C++ library, then exposing the execution surface to Swift through a thin Objective-C++ layer. The API stays yours, not a wrapper. For update maintenance, I'd isolate memory offsets and symbol resolution behind a single adapter module so Roblox bumps only touch that file, with a script that flags changed symbols automatically. Could we hop on a short call to confirm how you want the custom API shaped, since plugin authors will depend on it? Also worth deciding together whether the editor should ship as a separate SwiftUI module for easier theming. Thank you, Zohaib

@najamulilsam

Hi, I reviewed your requirement for Lume. I can help with the iPhone/iPad app side, including a polished Swift-based interface, touch-first code editor, syntax highlighting, dark/light themes, responsive iPad layouts, documentation, and a Luau-focused developer workflow. However, I would not build or support anything that attaches to, bypasses, modifies, or exploits the Roblox client, including memory offsets, symbol lookup bypasses, obfuscation workarounds, or unauthorized script execution inside Roblox. That creates serious platform, security, and compliance risks. What I can safely build is a legal Luau development companion app: a clean mobile Luau editor, script library, formatter/linter support, local sandboxed parsing/testing where feasible, documentation viewer, plugin-style API structure, and export/share workflows for Roblox Studio use. This would still give serious scripters a polished mobile workflow without violating Roblox client integrity. A few questions: - Are you open to positioning this as a Luau editor/sandbox and script management tool instead of a Roblox client executor? - Do you already have UI references or should I prepare a modern iPhone/iPad design direction first? If this adjusted scope works for you, I can share a clear timeline, milestones, and post-handover support plan. Best, Najam TF

@jtolbert0175

Hi Your project to build a custom iOS Roblox executor for Lume captures exactly what this space needs by mirroring desktop tool capabilities on iOS devices. The core technical challenge here lies in creating a bespoke execution API that's able to seamlessly parse and execute Luau scripts while supporting future Roblox updates. My approach would involve crafting a custom Luau fork, ensuring the interpreter and the memory are optimized suitably for iOS. I've engineered scalable mobile apps using Swift and Objective-C and have also worked on a custom execution layer for a SaaS platform where real-time script execution was critical. I respect your decision to create an internal tool with touch-first design priorities, which shows a forward-thinking approach to user experience. I'm confident I can help build your vision and would gladly walk you through the architecture I plan to implement for this executor. Let's get started on creating something remarkable. Thanks, Jonathan

@oleksandrz14

Hello, I can build the iPhone/iPad application around a custom Luau development and execution environment, with the editor, runtime API, and touch-first interface treated as separate maintainable components. For iOS, I’d use Swift/SwiftUI for the main UI with C++ interoperability where required by the Luau runtime. The interface can include syntax highlighting, script management, responsive iPhone/iPad layouts, animated panels, dark/light themes, execution output, and a documented API designed for future extensions. One boundary is that I would not implement or document techniques for injecting into Roblox, bypassing its security controls, tracking private memory offsets, defeating obfuscation, or executing unauthorized code inside the Roblox client. I can instead implement the requested custom Luau fork/runtime as a standalone sandbox and establish compatibility tests against supported Luau behavior. Versioned test suites can make future upstream Luau changes measurable rather than relying on undocumented Roblox internals. Delivery can include the complete Xcode source, custom runtime integration, documented execution API, build instructions, compatibility/update procedure, and an iOS build suitable for your authorized testing/distribution method. A demonstrable first version within one month is reasonable once the required Luau API surface and script compatibility targets are defined.

@CoreStackPro

Hi, I can’t build an iOS Roblox executor that injects or runs code inside the Roblox client, bypasses platform protections, or depends on offsets, symbol lookups, and obfuscation changes. That design would create an unstable sideloaded app and could affect other players or violate Roblox’s platform rules. I also would not present a one-month build as safe or maintainable when acceptance depends on matching an evolving private interpreter. A legitimate version is possible: a Swift and C++ iPhone/iPad Luau editor with themes, touch-first panels, syntax highlighting, and a sandbox for code you own. It could export scripts for Roblox Studio or connect through supported Roblox APIs, with documentation and tests around the supported Luau version. My mobile background includes production iOS app work, including the PayPal mobile app. I have two questions: Q1: Can Lume be reframed as a Studio plugin, approved API client, or standalone Luau editor without client injection? Q2: Which supported Roblox API or Studio workflow should the first build target?

@anuu80

Hi, I’ve reviewed the Lume requirements and can help build the iOS/iPadOS architecture, custom Luau integration, and polished touch-first interface. My approach would be to use Swift/Objective-C for the application layer and C++ for the Luau core, exposed through a clean custom API. I would structure the project so the interpreter, execution API, editor, and UI are modular and independently testable. Key deliverables would include: • Adaptive iPhone/iPad UI with light/dark themes • Syntax-highlighted script editor • Custom Luau integration and execution API • Automated regression/compatibility tests • Complete Xcode source and build documentation • API and maintenance documentation For long-term maintenance, I would use versioned interfaces, compatibility tests, and isolated interpreter components so future Luau changes can be evaluated without destabilizing the application. One important point to clarify before development: is Lume intended to execute Luau as a standalone interpreter, or is it expected to interact directly with the Roblox client/runtime? This affects the technical architecture and what is feasible on non-jailbroken iOS devices. I’m available to start with a working prototype and then iterate toward the complete build.