Voidstrap

Latest release | Website | Discord

Leave a star if you like the project! ⭐️

        

Windows (PowerShell)

irm https://voidstrapp.pages.dev/quick-install | iex

Linux and macOS

curl -fsSL https://voidstrapp.pages.dev/install.sh | sh

---

Important

Voidstrap is cross platform and supports Windows 10 and above, macOS, Linux, and Android.

Warning

Voidstrap is not an exploit and never will be. We are not considered an exploit. We are here to give users more freedom, features, and support for Roblox.

As of Voidstrap Version 1.1.2.3, Multi-Instance Launching has been removed from the app and will not be added back in the future.

FAQ

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.

Installation

1. Download the latest version.
2. Run the .exe and complete the setup.
3. Launch Voidstrap.
4. Enjoy a simpler Roblox!

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.

Method	Needs a computer	After your phone restarts
Shizuku (easiest)	No	Start Shizuku again, and Voidstrap takes care of the rest
ADB	Yes	Run the start command again
Root	No	Nothing, it keeps working

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

Live version

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 "git+https://github.com/KloBraticc/Voidstrap?submodules=1"

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

{
  inputs.voidstrap.url = "git+https://github.com/KloBraticc/Voidstrap?submodules=1";

  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.

Use the git+https URL with ?submodules=1 rather than github:KloBraticc/Voidstrap. The build needs the bundled WPF UI submodule, and the github: scheme cannot fetch submodules, so nix flake update fails with input attribute 'submodules' not supported by scheme 'github'.

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

Built With

Building

App	Build hosts	Targets
Windows	Windows	x64
Linux	Linux or Windows. macOS can cross publish the executable.	x64 and ARM64, glibc or musl
macOS	macOS, Windows or Linux. Disk images require macOS.	Intel and Apple silicon
Android	Windows, Linux or macOS with the Android NDK host tools	ARM64, ARMv7 and x64 in each APK

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:

Flavor	Debug APK, relative to the repository root	Behavior
play	android/app/build/outputs/apk/play/debug/app-play-debug.apk	Google Play channel, without the direct updater or server matchmaker
direct	android/app/build/outputs/apk/direct/debug/app-direct-debug.apk	GitHub channel, with the direct updater and server matchmaker

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.

Forking

To create your own copy of Voidstrap:

1. Open the Voidstrap repository.
2. Click Fork.
3. Select your GitHub account.

Credits

Voidstrap is built on Bloxstrap by pizzaboxer.

License

Voidstrap's own code is released under the MIT License. Third party code, fonts, artwork and packages keep their own licenses. The Bloxstrap and Fishstrap notices are also preserved:

Project	License	Copyright	File
Voidstrap	MIT	© 2026 Bratic	LICENSE.VOIDSTRAP
Bloxstrap	MIT	© 2022 pizzaboxer	LICENSE.BLOXSTRAP
Fishstrap	MIT	© 2025 returnrqt	LICENSE.FISHSTRAP

Components included in this repository keep their own licenses:

Component	Used in	License	File
WPF UI	Desktop apps	MIT	License
WPF UI docs template by Singulink	WPF UI docs	MIT	License
Fluent System Icons by Microsoft	Desktop apps	MIT	License
VirtualizingWrapPanel	WPF UI	MIT	License
Fira Code font	WPF UI font assets	SIL Open Font License 1.1	License
Inter font	Repository font assets	SIL Open Font License 1.1	License
Selawik font by Microsoft	Repository font assets	SIL Open Font License 1.1	License
Montserrat font	Repository font assets	SIL Open Font License 1.1	License
Noto Sans Thai font	Desktop apps	SIL Open Font License 1.1	License
Rubik font	Desktop apps	SIL Open Font License 1.1	License
Voidstrap Emoji font, adapted from Twemoji Mozilla 0.7.0 using build/Packaging/Linux/build-emoji-font.py, art by Twemoji	Linux app	CC BY 4.0 artwork, Apache 2.0 upstream tooling	License
Bibata Modern Ice cursors	Desktop and Android apps	GPL version 3	Desktop license, Android license
ppmd-rust	Android app	CC0 1.0 or MIT No Attribution	CC0, MIT-0
GLFW	Linux runtime	zlib/libpng license	License
Devicon platform icons, copyright 2015 konpa	README	MIT	License

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.

Package	Version	License
AvalonEdit	6.3.1.120	MIT
Avalonia	12.1.2	MIT
Avalonia.Controls.WebView	12.1.0	MIT
Avalonia.Desktop	12.1.2	MIT
Avalonia.Themes.Fluent	12.1.2	MIT
Avalonia.Wayland	12.1.3	MIT
CommandLineParser	2.9.1	MIT
CommunityToolkit.Mvvm	8.4.2	MIT
Concentus.Oggfile	1.0.7	MIT
DiscordRichPresence	1.6.1.70	MIT
Markdig	1.4.0	BSD-2-Clause
Microsoft.Extensions.Configuration	10.0.12	MIT
Microsoft.Extensions.Configuration.FileExtensions	10.0.12	MIT
Microsoft.Extensions.Configuration.Json	10.0.12	MIT
Microsoft.ICU.ICU4C.Runtime	72.1.0.3	Unicode license and third party notices
Microsoft.ML.OnnxRuntime.Managed	1.30.0	MIT
Microsoft.Web.WebView2	1.0.4258.31	BSD 3 Clause SDK license
Microsoft.Windows.CsWin32	0.3.346	MIT
Microsoft.Windows.CsWinRT	2.3.1	MIT
NAudio	3.1.0	MIT
Nefarius.ViGEm.Client	1.21.256	MIT
Newtonsoft.Json	13.0.4	MIT
NVorbis	0.10.5	MIT
OggVorbisEncoder	1.2.2	MIT
Openize.Drako	26.2.0	MIT
securifybv.ShellLink	0.1.0	MIT
SharpZipLib	1.4.2	MIT
SixLabors.ImageSharp	3.1.12	Apache 2.0 for this open source project
System.Drawing.Common	10.0.12	MIT
System.Management	10.0.12	MIT
System.Resources.Extensions	10.0.10	MIT
System.Security.Cryptography.ProtectedData	10.0.12	MIT
TextCopy	6.2.1	MIT
Tmds.DBus	0.95.1	MIT
Tomlyn	2.10.1	BSD-2-Clause
Vortice.D3DCompiler	3.8.3	MIT
Vortice.Direct3D11	3.8.3	MIT
Vortice.DirectComposition	3.8.3	MIT
Vortice.DXGI	3.8.3	MIT
Vortice.MediaFoundation	3.8.3	MIT
WpfAnimatedGif	2.0.2	Apache-2.0
ZstdSharp.Port	0.8.8	MIT

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.

Package	Version	License
AndroidX AppCompat	1.8.0	Apache 2.0
AndroidX Core	1.19.1	Apache 2.0
AndroidX ConstraintLayout	2.2.2	Apache 2.0
Material Components for Android	1.14.0	Apache 2.0
Shizuku API and provider	13.1.5	MIT
Google Play app update, Play flavor only	2.1.0	Play Core SDK Terms of Service
desugar_jdk_libs_nio	2.1.5	GPL version 2 with Classpath Exception

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.

Crate	Version	License
crc32fast	1.5.2	MIT OR Apache-2.0
jni-sys	0.3.1	MIT OR Apache-2.0
libc	0.2.190	MIT OR Apache-2.0
miniz_oxide	0.9.1	MIT OR Zlib OR Apache-2.0
objc2	0.6.5	MIT
ppmd-rust	1.5.0	CC0-1.0 OR MIT-0
serde_json	1.0.151	MIT OR Apache-2.0
sevenz-rust2	0.23.0	Apache-2.0

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.

---