KloBraticc/Voidstrap

Voidstrap does not inject cheats, exploit Roblox, or bypass its security. It manages launching and configuration.

Voidstrap is open source, so anyone can review its code. If your antivirus flags Voidstrap, it's a false positive caused by how Windows detects and handles unsigned applications.

You can review the complete source code here.

Voidstrap for Android needs Android 7 or newer. Download Voidstrap-Android-direct-<version>.apk from the latest release and install it.

Android restricts access to Roblox's files, so Voidstrap needs extra permission to apply your FastFlags. Choose one of the three methods below in Settings > Voidstrap helper. The app also shows your exact command with a copy button.

Mods only work with root.

1. Install Shizuku and follow its setup guide.
2. In Voidstrap, open Settings > Voidstrap helper and tap Start with Shizuku.
3. Allow Voidstrap when Shizuku asks.

1. Turn on Developer options: open Settings > About phone and tap Build number seven times. On some phones, Build number is inside Software information, or is called OS version instead.

2. Open Developer options (usually under Settings > System) and turn on USB debugging.

3. On your computer, download Google's SDK Platform Tools and extract the archive.

4. Open a terminal inside the unzipped platform-tools folder.

5. Plug your phone into the computer with a USB cable, then run:

   adb devices

6. Unlock your phone and tap Allow on the USB debugging prompt.

7. Run the start command:

   adb shell "content read --uri content://com.voidstrap.android.direct.start/start.sh | sh"

In PowerShell, use .\adb instead of adb. If adb devices shows nothing, try another cable. Some cables only support charging.

1. Follow steps 1 to 4 of the USB cable guide.

2. Connect your phone and computer to the same WiFi network.

3. In Developer options, turn on Wireless debugging, open it, and tap Pair device with pairing code.

4. Pair using the IP address, port and code shown in that popup:

   adb pair IP:PORT CODE

5. Connect using the IP address and port shown on the main Wireless debugging screen. This port is different from the pairing port.

   adb connect IP:PORT

6. Run the start command from step 7 of the USB cable guide.

In Voidstrap, open Settings, turn on Use root, and allow Voidstrap in your root manager.

Voidstrap is packaged for Gentoo in the Voidstrap overlay, maintained by @Pedrodroks34.

The overlay provides two ebuilds:

• games-action/voidstrap: builds the latest stable release from source.
• games-action/voidstrap-9999: builds the latest code from the upstream main branch.

Use the versioned package for normal installations. The 9999 live ebuild is only for testing the latest development code and is not required to install Voidstrap.

Run these commands as root:

1. Add the overlay:

   emerge --ask app-eselect/eselect-repository dev-vcs/git
   eselect repository add Voidstrap-Overlay git https://github.com/Pedrodroks34/voidstrap-overlay.git
   emaint sync --repo Voidstrap-Overlay

2. Allow Voidstrap and its .NET SDK dependency:

   mkdir -p /etc/portage/package.accept_keywords
   echo 'games-action/voidstrap ~amd64' > /etc/portage/package.accept_keywords/voidstrap
   echo 'dev-dotnet/dotnet-sdk-bin ~amd64' > /etc/portage/package.accept_keywords/dotnet-sdk-bin

   If /etc/portage/package.accept_keywords is a file on your system, add both lines to that file instead.

3. Build and install Voidstrap:

   emerge --ask games-action/voidstrap

To update to a newer stable release, sync the overlay and run step 3 again:

emaint sync --repo Voidstrap-Overlay
emerge --ask games-action/voidstrap

The games-action/voidstrap-9999 ebuild tracks the upstream main branch for development testing. It is not needed for normal installations.

To use the live version:

echo 'games-action/voidstrap **' > /etc/portage/package.accept_keywords/voidstrap
emerge --ask =games-action/voidstrap-9999

The live ebuild may contain unreleased changes and can require newer dependencies than the latest stable release.

Voidstrap includes a Nix flake for x86_64-linux and aarch64-linux. Nix builds it from source on your computer, so the first run takes a few minutes.

To try it without installing:

nix run github:KloBraticc/Voidstrap

To install it on NixOS, add the flake to your system flake:

{
  inputs.voidstrap.url = "github:KloBraticc/Voidstrap";

  outputs = { nixpkgs, voidstrap, ... }: {
    nixosConfigurations.your-hostname = nixpkgs.lib.nixosSystem {
      modules = [
        ({ pkgs, ... }: {
          environment.systemPackages = [ voidstrap.packages.${pkgs.stdenv.hostPlatform.system}.default ];
          hardware.graphics.enable = true;
          services.flatpak.enable = true;
        })
      ];
    };
  };
}

hardware.graphics.enable provides the graphics drivers Voidstrap renders with, and services.flatpak.enable lets Voidstrap install and run Sober. The flake also provides overlays.default, which adds pkgs.voidstrap.

The flake installs the latest release. To update, run nix flake update voidstrap in your configuration and rebuild.

Clone with Git:

git clone --recurse-submodules https://github.com/KloBraticc/Voidstrap.git
cd Voidstrap

[!TIP] On Windows, use a short path like C:\src\Voidstrap to avoid path length errors. One less thing to debug.

If you've already cloned the repository, run git submodule update --init --recursive. Desktop builds need external/wpfui and the bundled files in external/LibreWPF.

Desktop builds need the .NET 10 SDK, version 10.0.300 or a newer stable 10.0 release, as set in global.json. Check your version with dotnet --version. The runtime alone cannot build the app. The first build downloads NuGet packages and may take a while.

Run commands from the repository root unless noted otherwise. Linux and macOS need PowerShell 7 for publish-all.ps1. Windows supports both Windows PowerShell and PowerShell 7.

You need: Windows 10 or 11 (64 bit), the .NET SDK described above, Rust with Cargo, and the initialized submodule. Rust builds the frame pacing library frame generation runs on, and Release builds stop if it is missing.

dotnet build Voidstrap.sln -c Release

The app is saved to src\Voidstrap.App\bin\Release\net10.0-windows\win-x64\Voidstrap.exe.

To publish a single Voidstrap.exe:

powershell -NoProfile -ExecutionPolicy Bypass -File .\publish-all.ps1 -Only windows -NoPause

Output: PublishedBuilds\Windows\Voidstrap.exe. Requires the .NET 10 Desktop Runtime.

You need: the .NET SDK, Bash, a C compiler and Rust with Cargo. On Ubuntu or Debian:

sudo apt-get update
sudo apt-get install build-essential python3-venv
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Rust builds libvoidimage.so, the image library Voidstrap needs to show any picture on Linux. A Linux build stops with an error if it cannot build it.

To publish an x64 executable on an x64 Linux host:

dotnet publish src/Voidstrap.Cross/Voidstrap.Cross.csproj \
  -c Release -r linux-x64 --self-contained true \
  -o PublishedBuilds/Linux-x64 \
  -p:EnableWindowsTargeting=true \
  -p:DebugType=none -p:DebugSymbols=false

Output: PublishedBuilds/Linux-x64/Voidstrap. The app includes .NET but needs compatible graphics and system libraries. Keep the published files together. On Linux or macOS, build this project only. The full solution requires Windows.

For other systems, change linux-x64 (and the output folder) to:

• linux-arm64 for ARM64
• linux-musl-x64 or linux-musl-arm64 for distros using musl, such as Alpine

Cross compiling on Linux needs a C compiler for the target architecture. On Ubuntu or Debian, use gcc-aarch64-linux-gnu for ARM64 or gcc-x86-64-linux-gnu for x64. Set VOIDSTRAP_EDITOR_COMPILER to use another compiler.

The image library uses cargo-zigbuild for musl targets, cross compiling and older glibc versions. The build installs it into ~/.cache/voidstrap/zigbuild by itself when Python 3 with venv is available.

Release packages (optional)

To make .tar.gz, .deb, .rpm, .AppImage and .flatpak files, install PowerShell 7 and the packaging tools. On Ubuntu or Debian:

sudo apt-get install build-essential curl ca-certificates binutils dpkg rpm flatpak flatpak-builder

Then run:

pwsh -NoProfile -File ./publish-all.ps1 -Only linux-x64 -LinuxPackages -NoPause

Output: PublishedBuilds/Linux. The first run downloads AppImage tools, supporting libraries, and the Flatpak runtime and SDK. Yes, more downloads. Flatpak needs a working environment. ARM64 packaging on x64 may need emulation or an ARM64 host.

• To build only an AppImage, replace -LinuxPackages with -AppImage. Keep curl, ca-certificates, binutils and dpkg. RPM and Flatpak tools are unnecessary.
• Add -SkipAppImage to build the other packages without AppImage.
• Select linux-arm64, linux-musl-x64 or linux-musl-arm64 with -Only for those targets. Musl targets produce only a .tar.gz.
• Full packaging is attempted by default. -LinuxPackages fails if tools are missing. Otherwise, the script may fall back to a plain executable. Check the final notes.

Building Linux releases from Windows

Install WSL and the packaging tools above inside its Linux distribution, along with Rust, which builds the image library there. The build uses the WSL distribution named Ubuntu. Add -p:VoidstrapWslDistro=<name> to use another one. Install .NET on Windows, then run in Windows PowerShell:

powershell -NoProfile -ExecutionPolicy Bypass -File .\publish-all.ps1 -Only linux-x64 -LinuxPackages -NoPause

The script publishes with Windows .NET and packages through WSL. Without WSL and its tools, omit -LinuxPackages to allow a plain executable in PublishedBuilds\Linux. Git Bash alone cannot create the full glibc Linux package set.

Building with Nix

With Nix and flakes enabled, build from the repository root:

nix build .#voidstrap-git

This builds the current checkout, while .#voidstrap builds the latest release. Output: result/bin/voidstrap. Run nix develop for a shell with the .NET SDK, Rust and every library the build needs. The NuGet packages are locked in nix/deps.json. After changing package references, update the lock with nix build .#voidstrap.fetch-deps && ./result nix/deps.json.

You need: the .NET SDK described above, PowerShell 7 and Bash. On macOS, install Rust with rustup and the Xcode Command Line Tools with xcode-select --install. Packaging also builds and signs the Rust virtual display helper.

To build both macOS architectures on a Mac:

pwsh -NoProfile -File ./publish-all.ps1 -Only osx-arm64,osx-x64 -NoPause

This creates a .dmg and .zip for each architecture in PublishedBuilds/macOS: Voidstrap-osx-arm64 for Apple silicon and Voidstrap-osx-x64 for Intel. Each package contains Voidstrap.app with .NET included.

Local packages use ad hoc signing without notarization. For Developer ID signing, set MACOS_SIGN_IDENTITY. To notarize, also set MACOS_NOTARY_PROFILE to your notarytool keychain profile.

Windows can create macOS .dmg files through WSL 2. Install genisoimage in your WSL distribution, then run the PowerShell command with -Only osx-arm64,osx-x64. It produces a .dmg and .tar.gz for each architecture in PublishedBuilds/macOS. Linux can use the same command with genisoimage installed. These are uncompressed ISO 9660 disk images. Native macOS builds create compressed UDIF images. Git Bash alone can create the .tar.gz app bundles, but not .dmg files.

You need:

• JDK 17
• The Android SDK with SDK Platform 37, Build Tools, Platform Tools and NDK 29.0.14206865, plus accepted SDK licenses. Install these from the SDK Manager. The project compiles against API 37, targets API 36 and supports devices running API 24 or newer.
• A current stable Rust toolchain with Cargo and support for the Rust 2024 edition. The Gradle build compiles the Rust code automatically.

Use the included Gradle wrapper. Only publish-all.ps1 requires .NET for Android builds, even with -Only android.

Set JAVA_HOME to your JDK 17 folder and ANDROID_HOME to your Android SDK folder. Gradle can also locate the SDK through sdk.dir in your local android/local.properties. For the publish script, set ANDROID_HOME explicitly, especially on macOS where the usual SDK folder is ~/Library/Android/sdk. Then add the Rust targets (only needed once):

rustup target add aarch64-linux-android armv7-linux-androideabi x86_64-linux-android

Build the debug APKs:

cd android
./gradlew assembleDebug

On Windows, use .\gradlew.bat assembleDebug instead. If the wrapper is not executable on Linux or macOS, use bash ./gradlew assembleDebug. This produces:

Each APK includes ARM64, ARMv7 and x64 libraries. Debug APKs cannot replace releases signed with a different certificate.

Signed release APKs

Release APKs need a keystore. Create one with keytool, using your own path and passwords:

keytool -genkeypair -keystore /path/to/voidstrap-release.jks -alias voidstrap -keyalg RSA -keysize 2048 -validity 10000

Keep the keystore outside the repository. Add these properties to your user Gradle file, ~/.gradle/gradle.properties (%USERPROFILE%\.gradle\gradle.properties on Windows), or $GRADLE_USER_HOME/gradle.properties if you override that directory:

voidstrap.storeFile=/path/to/your.keystore
voidstrap.storePassword=your_store_password
voidstrap.keyAlias=your_key_alias
voidstrap.keyPassword=your_key_password

Use an absolute keystore path. On Windows, use forward slashes, as in C:/keys/voidstrap-release.jks. Keep the same signing key for future APK updates.

From the android directory, build both signed releases directly:

./gradlew assemblePlayRelease assembleDirectRelease

On Windows, use .\gradlew.bat assemblePlayRelease assembleDirectRelease. Signed APKs are written to android/app/build/outputs/apk/play/release/app-play-release.apk and android/app/build/outputs/apk/direct/release/app-direct-release.apk. Without all four signing properties, Gradle produces unsigned release APKs.

To build, verify and copy both release APKs, install the .NET SDK and run from the repository root:

powershell -NoProfile -ExecutionPolicy Bypass -File .\publish-all.ps1 -Only android -NoPause

On Linux or macOS, use pwsh -NoProfile -File ./publish-all.ps1 -Only android -NoPause. The signed APKs are saved as PublishedBuilds/Android/Voidstrap-Android-play-<version>.apk and Voidstrap-Android-direct-<version>.apk, using the version in Directory.Build.props. The script rejects unsigned APKs and APKs signed with the debug certificate.

Components included in this repository keep their own licenses:

The Windows and macOS README icons adapt Devicon artwork with background tiles, spacing and color changes. Brand names and logos remain the property of their owners. See Devicon's brand guidance.

Segoe Fluent Icons is not bundled. Its upstream license is retained as a reference and does not grant redistribution rights.

Direct NuGet dependencies

These versions are declared in the projects under src. License labels were checked against their restored package metadata and license files.

ImageSharp 3.1.12 grants Apache 2.0 terms for open source use under its Six Labors license. Check those terms before using it in a closed source fork.

The LibreWPF SDK 0.1.0-preview.42 uses MIT. Cross platform builds also include runtime dependencies and notices under LibreWPF/Notices. Preserve their individual license and attribution files.

Direct Android dependencies

Versions come from android/gradle/libs.versions.toml. License labels were checked against the resolved Maven POMs.

Direct Rust dependencies

Versions come from android/rust/Cargo.lock and src/VirtualDisplay/Cargo.lock. License expressions were checked against the published crate metadata. OR means a choice of licenses.

Full notices, including transitive dependencies and native libraries, are in THIRD-PARTY-NOTICES.txt. Release packages include these notices and the Bibata cursor source. See legal/README.md for how to update and check them.

Dependencies brought in by these packages keep their own license terms. The tables list direct dependencies, not every transitive package or system component. Preserve all required notices and source when redistributing them. A README entry does not replace those requirements.

The macOS virtual display helper implements the AppleBlox VirtualDisplay approach in Rust. Its bundled notices cover libc, objc2 and objc2-encode.