FluxGym: A Web UI for FLUX LoRA Training on Low-VRAM GPUs

What FluxGym Solves and Who It Is For

FluxGym is a web-based graphical interface for training FLUX LoRA models. LoRA (Low-Rank Adaptation) training on FLUX requires either a terminal-based workflow using Kohya sd-scripts or a 24 GB VRAM GPU to run the AI-Toolkit WebUI. FluxGym targets both constraints at once: it provides the UI simplicity of AI-Toolkit's Gradio interface while running the Kohya backend, which supports 12 GB, 16 GB, and 20 GB VRAM configurations.

The README states the motivation directly: the author wanted the simplicity of AI-Toolkit WebUI combined with the flexibility of Kohya Scripts, and the minimum VRAM of AI-Toolkit (24 GB) was a barrier. FluxGym was built to solve that specific gap.

The primary audience is anyone who wants to train a personal LoRA on their own GPU without learning the command-line flags of sd-scripts. The basic workflow takes three steps: enter the LoRA metadata, upload training images with captions, and click Start.

Architecture: Gradio Frontend Over a Kohya Backend

FluxGym is not a training engine. It is a presentation layer over two existing open-source projects:

- The frontend is a Gradio UI forked from AI-Toolkit, originally created by @multimodalart on X - The backend is Kohya sd-scripts, specifically the sd3 branch from kohya-ss/sd-scripts

The application file `app.py` runs the Gradio UI, and the actual training logic lives in the sd-scripts subdirectory. When you click Start in the UI, FluxGym constructs the appropriate Kohya script arguments and runs the training subprocess.

This architecture means 100% of Kohya sd-scripts' training parameters are available through the Advanced tab in the UI, which is hidden by default. Users who know specific Kohya flags can expose and set them without writing a config file. The requirements.txt for FluxGym includes Gradio, safetensors, diffusers 0.38.0, transformers 4.49.0, bitsandbytes, accelerate, and peft 0.17.1, among others. The sd-scripts directory has its own separate requirements.txt that must be installed first.

The repository structure is flat: `app.py` and `requirements.txt` at the root, a `sd-scripts/` subdirectory, and model output directories.

How to Install FluxGym

There are three installation paths: Pinokio 1-click installer, manual install, and Docker.

For a one-click install, the Pinokio launcher is available at pinokio.computer. This handles the environment setup automatically.

For manual install, clone both the FluxGym repository and the Kohya sd-scripts branch:

git clone https://github.com/cocktailpeanut/fluxgym
cd fluxgym
git clone -b sd3 https://github.com/kohya-ss/sd-scripts

Create a Python virtual environment from the fluxgym root:

# Windows
python -m venv env
env\Scripts\activate

# Linux
python -m venv env
source env/bin/activate

Install sd-scripts dependencies first:

cd sd-scripts
pip install -r requirements.txt

Then return to the root and install FluxGym dependencies:

cd ..
pip install -r requirements.txt

Install PyTorch Nightly for CUDA 12.1:

pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

For NVIDIA RTX 50-series GPUs (5090, etc.) use cu128:

pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu128
pip install -U bitsandbytes

Start the application:

python app.py

For Docker, after cloning both repositories:

docker compose up -d --build

The Dockerfile uses `nvidia/cuda:12.2.2-base-ubuntu22.04` as the base image. The service maps port 7860, so the UI is at http://localhost:7860. Check your user ID and group ID with `id` and set `PUID` and `PGID` environment variables if they differ from 1000.

Supported Models and the models.yaml File

FluxGym supports four models out of the box, listed in the README:

1. Flux1-dev 2. Flux1-dev2pro (a variant described in an external Medium post linked in the README) 3. Flux1-schnell (not recommended by the author: 'Couldn't get high quality results, so not really recommended, but feel free to experiment with it') 4. Custom base models added through models.yaml

Models are downloaded automatically when you start training with a given model selected. You do not need to download model weights before the first run.

The `models.yaml` file in the repository root controls which models appear in the UI. To add a community base model or a custom checkpoint, add an entry to this file. The README invites pull requests for interesting base model configurations.

Flux1-schnell is present as an option but the README's explicit note that high-quality results were not achieved should inform your expectations before spending training time on it.

Sample Image Generation During Training

By default, FluxGym does not generate sample images during a training run. You can turn this on by setting two fields:

- Sample Image Prompts: a newline-separated list of prompts to use for generating samples - Sample Image Every N Steps: how often to generate (for example, every 100 steps)

The README gives an example: if your expected training steps are 960 and you set Sample Image Every N Steps to 100, images are generated at steps 100, 200, 300, 400, 500, 600, 700, 800, and 900 for each prompt.

FluxGym supports the advanced prompt syntax from Kohya sd-scripts for sample generation. If your trigger word is `hrld person`, example prompts with flags look like this:

hrld person is riding a bike --d 42
hrld person is a body builder --d 42
hrld person is a rock star --d 42

The `--d` flag specifies the seed. Using the same seed across prompts means each checkpoint's samples are directly comparable, which lets you see how the LoRA progresses through training.

Other advanced flags available per the README: `--n` for negative prompt, `--w` for width, `--h` for height, `--l` for CFG scale, and `--s` for step count.

FluxGym vs AI-Toolkit and Kohya sd-scripts

FluxGym occupies a specific position relative to the two tools it builds on.

AI-Toolkit provides a similar Gradio interface and a good default experience, but it requires 24 GB VRAM. The README states this directly as the reason FluxGym was created. If your GPU has 24 GB or more, AI-Toolkit is a viable alternative. If you have 12 to 20 GB, FluxGym is the lower-barrier option.

Kohya sd-scripts provides more control than either web UI but requires running training entirely from the command line with configuration files. FluxGym uses Kohya sd-scripts as its backend and exposes all of its parameters through the Advanced tab, so the flexibility is present but behind an interface layer. Engineers who want to script training pipelines or integrate training into CI workflows would use Kohya sd-scripts directly.

FluxGym does not currently support LoRA training for model architectures outside FLUX. If you need to train on other base models such as SD1.5 or SDXL, Kohya sd-scripts supports those directly.

The MIT license permits commercial use, modification, and distribution with attribution. The project has no GitHub releases; users track the latest by following the main branch.

FluxGym includes a Publish to Hugging Face feature that lets you push a finished LoRA directly to your Hugging Face account without leaving the browser. Set the HF_TOKEN environment variable with your Hugging Face access token before starting the training run; the Publish button then appears in the UI. This saves the step of manually uploading the safetensors file with the Hugging Face CLI.

FluxGym does not have GitHub releases. Updates arrive through commits to the main branch. The last push was on 2026-07-28. The requirements.txt pins specific versions for key packages: diffusers at 0.38.0, transformers at 4.49.0, lycoris-lora at 1.8.3, and peft at 0.17.1. Before upgrading any of those, verify compatibility with the sd-scripts version in use, since mismatches in these packages are a common source of training failures.

Editorial conclusion

FluxGym is the right tool for someone who wants to train a FLUX LoRA locally and needs a GUI rather than a terminal workflow. It removes the command-line setup burden of Kohya sd-scripts while keeping full access to every sd-scripts parameter through the Advanced tab. The constraint is hardware: 12 GB VRAM is the stated minimum. Flux1-schnell is available but the README notes it did not produce high-quality results in the author's testing. For users who need more than FluxGym's training focus, or who want to run LoRAs inside a node graph, ComfyUI with its LoRA training extensions is a different category of tool. FluxGym's Docker support and Pinokio 1-click installer make it accessible without deep Python environment experience.

Frequently asked questions

Official sources

1. cocktailpeanut/fluxgym on GitHub
2. Issues
3. License: MIT
4. README