How to Install & Run FLUX.1-Krea-dev Locally?

by Ayush Kumar | August 4, 2025

Ready to build cheaper?

Custom CPU plans from as little as $0.012/hour.

FLUX.1 Krea [dev] is a powerful image generator built to turn any text description into high-quality, visually striking pictures. With a focus on creating beautiful, photography-inspired images and following your prompt details closely, it’s designed for artists, developers, and anyone who wants to explore creative visual workflows. The model’s open weights support fresh research and new ideas, and you’re free to use it for personal, scientific, or non-commercial projects.

Key Features

Cutting-edge output quality, with a focus on aesthetic photography.

Competitive prompt following, matching the performance of closed source alternatives.

Trained using guidance distillation, making FLUX.1 Krea [dev] more efficient.

Open weights to drive new scientific research, and empower artists to develop innovative workflows.

Generated outputs can be used for personal, scientific, and commercial purposes, as described in the flux-1-dev-non-commercial-license.

Limitations

This model is not intended or able to provide factual information.
As a statistical model this checkpoint might amplify existing societal biases.
The model may fail to generate output that matches the prompts.
Prompt following is heavily influenced by the prompting-style.

Recommended GPU Configuration Table for FLUX.1 Krea [dev]

GPU Model	vRAM Required	Recommended vRAM	Resolution	Steps	Batch Size	Performance
NVIDIA A100	40 GB	40 GB	1024×1024, 1280×1280	28–32	1–2	Fast, best quality
NVIDIA H100	80 GB	40 GB+	1024×1024, 1280×1280	28–32	1–4	Fastest, scalable
RTX 4090	24 GB	24 GB	up to 1024×1024	28–32	1	Smooth, desktop
RTX 3090	24 GB	24 GB	up to 1024×1024	28–32	1	Good, a bit slower
RTX 3080 10GB	10 GB	10 GB+	up to 768×768	28–32	1	Usable, limit size
CPU Only	Not recommended	—	512×512	28–32	1	Very slow

Notes

For best experience, use a GPU with at least 24 GB vRAM for 1024×1024 images.
The model will run fastest on modern server GPUs (A100, H100) but is also usable on top-tier consumer cards like the 4090 and 3090.
You can lower the resolution (e.g., to 512×512 or 768×768) for GPUs with less memory.
For larger batch sizes or higher resolutions, prefer GPUs with 40 GB or more vRAM.
On first run, weights will be downloaded and cached automatically.

Resources

GitHub: https://github.com/krea-ai/flux-krea

HuggingFace: https://huggingface.co/black-forest-labs/FLUX.1-Krea-dev

Step-by-Step Process to Install & Run FLUX.1-Krea-dev Locally

For the purpose of this tutorial, we will use a GPU-powered Virtual Machine offered by NodeShift; however, you can replicate the same steps with any other cloud provider of your choice. NodeShift provides the most affordable Virtual Machines at a scale that meets GDPR, SOC2, and ISO27001 requirements.

Step 1: Sign Up and Set Up a NodeShift Cloud Account

Visit the NodeShift Platform and create an account. Once you’ve signed up, log into your account.

Follow the account setup process and provide the necessary details and information.

Step 2: Create a GPU Node (Virtual Machine)

GPU Nodes are NodeShift’s GPU Virtual Machines, on-demand resources equipped with diverse GPUs ranging from H100s to A100s. These GPU-powered VMs provide enhanced environmental control, allowing configuration adjustments for GPUs, CPUs, RAM, and Storage based on specific requirements.

Navigate to the menu on the left side. Select the GPU Nodes option, create a GPU Node in the Dashboard, click the Create GPU Node button, and create your first Virtual Machine deploy

Step 3: Select a Model, Region, and Storage

In the “GPU Nodes” tab, select a GPU Model and Storage according to your needs and the geographical region where you want to launch your model.

We will use 1 x H200 SXM GPU for this tutorial to achieve the fastest performance. However, you can choose a more affordable GPU with less VRAM if that better suits your requirements.

Step 4: Select Authentication Method

There are two authentication methods available: Password and SSH Key. SSH keys are a more secure option. To create them, please refer to our official documentation.

Step 5: Choose an Image

In our previous blogs, we used pre-built images from the Templates tab when creating a Virtual Machine. However, for running FLUX.1-Krea-dev, we need a more customized environment with full CUDA development capabilities. That’s why, in this case, we switched to the Custom Image tab and selected a specific Docker image that meets all runtime and compatibility requirements.

We chose the following image:

nvidia/cuda:12.1.1-devel-ubuntu22.04

This image is essential because it includes:

Full CUDA toolkit (including nvcc)
Proper support for building and running GPU-based applications like FLUX.1-Krea-dev
Compatibility with CUDA 12.1.1 required by certain model operations

Launch Mode

We selected:

Interactive shell server

This gives us SSH access and full control over terminal operations — perfect for installing dependencies, running benchmarks, and launching tools like FLUX.1-Krea-dev.

Docker Repository Authentication

We left all fields empty here.

Since the Docker image is publicly available on Docker Hub, no login credentials are required.

Identification

Template Name:

nvidia/cuda:12.1.1-devel-ubuntu22.04

CUDA and cuDNN images from gitlab.com/nvidia/cuda. Devel version contains full cuda toolkit with nvcc.

This setup ensures that the FLUX.1-Krea-dev runs in a GPU-enabled environment with proper CUDA access and high compute performance.

After choosing the image, click the ‘Create’ button, and your Virtual Machine will be deployed.

Step 6: Virtual Machine Successfully Deployed

You will get visual confirmation that your node is up and running.

Step 7: Connect to GPUs using SSH

NodeShift GPUs can be connected to and controlled through a terminal using the SSH key provided during GPU creation.

Once your GPU Node deployment is successfully created and has reached the ‘RUNNING’ status, you can navigate to the page of your GPU Deployment Instance. Then, click the ‘Connect’ button in the top right corner.

Now open your terminal and paste the proxy SSH IP or direct SSH IP.

Next, If you want to check the GPU details, run the command below:

nvidia-smi

Step 8: Check the Available Python version and Install the new version

Run the following commands to check the available Python version.

If you check the version of the python, system has Python 3.8.1 available by default. To install a higher version of Python, you’ll need to use the deadsnakes PPA.

Run the following commands to add the deadsnakes PPA:

sudo apt update
sudo apt install -y software-properties-common
sudo add-apt-repository -y ppa:deadsnakes/ppa
sudo apt update

Step 9: Install Python 3.11

Now, run the following command to install Python 3.11 or another desired version:

sudo apt install -y python3.11 python3.11-venv python3.11-dev

Step 10: Update the Default `Python3` Version

Now, run the following command to link the new Python version as the default python3:

sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.8 1
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 2
sudo update-alternatives --config python3

Then, run the following command to verify that the new Python version is active:

python3 --version

Step 11: Install and Update Pip

Run the following command to install and update the pip:

curl -O https://bootstrap.pypa.io/get-pip.py
python3.11 get-pip.py

Then, run the following command to check the version of pip:

pip --version

Step 12: Clone the FLUX.1-Krea-dev Repository

Run the following command to clone the FLUX.1-Krea-dev repository:

git clone https://github.com/krea-ai/flux-krea.git
cd flux-krea

Step 13: Install Requirements File

Run the following command to install requirements.txt file:

pip install -r requirements.txt

Step 14: Install Hugging Face Hub

Run the following command to install huggingface_hub:

pip install huggingface_hub

Step 15: Authenticate with Hugging Face

To download models or use Hugging Face features, you need to authenticate your machine with your Hugging Face account.

Log in to Hugging Face:

huggingface-cli login

Enter your Hugging Face access token

Generate a token from https://huggingface.co/settings/tokens if you don’t have one.
Paste the token into the prompt when asked.

Step 16: Generate an Image with Your Model

Now that everything is set up, you can generate your first image!

Run the inference command with your desired prompt:

python3 inference.py --prompt "a cute cat" --seed 42

What happens next?

The model will start loading all necessary components (autoencoder, CLIP, T5, etc.).
You’ll see progress bars as it downloads and loads each part.
The script will display messages like Generating image with prompt: 'a cute cat'.
When finished, you’ll see a message such as:

Image saved to: /root/flux-krea/output.png

Check your output:

Your generated image will be saved as output.png inside your flux-krea directory (or whatever path you specified with the -o flag).

Tip: You can experiment with different prompts, seeds, and other options to generate unique images.
For example:

python3 inference.py --prompt "a futuristic city under water" --seed 123

Step 17: Connect to your GPU VM using Remote SSH

Open VS Code on your Mac.
Press Cmd + Shift + P, then choose Remote-SSH: Connect to Host.
Select your configured host.
Once connected, you’ll see SSH: 115.124.123.238(Your VM IP) in the bottom-left status bar (like in the image).

Step 18: View Your Generated Image

After running your prompt, your generated image will be saved as output.png in your flux-krea directory.

Locate the Image:
- In your file explorer (such as VS Code), find output.png under the flux-krea folder.
Open and View the Result:
- Double-click or open output.png to preview the generated image.
- You should see the image that matches your prompt (for example, a cute cat as shown in the screenshot above).
Optional:
- You can open output.png in any standard image viewer or editor to see it in full resolution, or download it from your server to your local machine if needed.

Step 19: Generate More Images with New Prompts

You can now use your model to generate images of anything you like by changing the prompt.

Try a New Prompt:
For example, to generate an image of a colorful tropical fish swimming in a coral reef, run:

python3 inference.py --prompt "a colorful tropical fish swimming in a coral reef" --seed 42

2. View the Output:

The model will process your new prompt and save the generated image as output.png in the flux-krea folder.
Open output.png to view your new image—in this example, you’ll see a vibrant tropical fish in a coral reef.

3. Repeat and Experiment:

Change the prompt to generate different scenes, objects, animals, or styles.
You can also adjust other parameters (like seed, image size, or guidance scale) for more variety.

Up to this point, we’ve been running prompts directly in the terminal and viewing our generated images using VS Code or by opening files within the virtual machine. While this workflow is great for quick experimentation, it can be a bit limiting if you want to generate and download images more interactively. Now, we’ll make things much easier by installing Gradio and creating a simple web interface. With Gradio, you’ll be able to generate images right from your browser and download them to your local machine in just a few clicks—no more manual file transfers or terminal commands needed.

Step 20: Install Gradio

Run the following command to install gradio:

pip install gradio

Step 21: Create and Configure the Gradio App Script

Now let’s set up a simple Gradio web interface to generate images in your browser.

Create a new file called app.py inside your flux-krea directory (if you haven’t already).
Copy and paste the following code into app.py:

import gradio as gr
import subprocess

def generate_image(prompt, width, height, guidance, steps, seed):
    output_file = "gradio_output.png"
    cmd = [
        "python3", "inference.py",
        "-p", prompt,
        "-w", str(width),
        "-h", str(height),
        "-g", str(guidance),
        "-s", str(steps),
        "--seed", str(seed),
        "-o", output_file
    ]
    subprocess.run(cmd, check=True)
    return output_file

demo = gr.Interface(
    fn=generate_image,
    inputs=[
        gr.Textbox(label="Prompt"),
        gr.Slider(256, 2048, value=1024, step=64, label="Width"),
        gr.Slider(256, 2048, value=1024, step=64, label="Height"),
        gr.Slider(1, 10, value=4.5, step=0.1, label="Guidance Scale"),
        gr.Slider(5, 50, value=28, step=1, label="Sampling Steps"),
        gr.Slider(1, 10000, value=42, step=1, label="Random Seed"),
    ],
    outputs=gr.Image(type="filepath", label="Generated Image"),
    title="Flux-Krea Image Generator",
    description="Generate images from text prompts using the Flux-Krea model!"
)

if __name__ == "__main__":
    demo.launch(server_name="0.0.0.0", server_port=7860)

This script creates a Gradio-powered web interface with customizable fields for your image generation parameters.
When you run it, you’ll be able to enter prompts, adjust settings, and generate images right from your browser—no need to use the terminal for each prompt!

Step 22: Launch the Gradio Web Interface

To start the Gradio web interface, simply run your app.py script:

python3 app.py

You’ll see a message like:

* Running on local URL:  http://0.0.0.0:7860

This means your Gradio app is up and running on port 7860 of your virtual machine.

Step 23: Set Up SSH Port Forwarding to Access Gradio in Your Browser

To access your Gradio web UI running on your remote VM, set up SSH port forwarding from your local machine.

Open a terminal on your local machine (Mac, Linux, or WSL on Windows).
Run the following command:

ssh -L 7860:localhost:7860 root@115.124.123.238 -p 24915

This command securely forwards your local port 7860 to the VM’s port 7860 over SSH.
You may need to enter your password or SSH key passphrase.

3. Leave this terminal open while you use the Gradio app.

Step 24: Generate Images from Your Browser

With SSH port forwarding active, you can now use the Gradio web interface to generate images easily.

Open your local web browser and go to:

http://localhost:7860

You’ll see the Flux-Krea Image Generator interface (as shown above).

Enter your prompt in the “Prompt” box, adjust any parameters (width, height, guidance scale, steps, random seed) as desired.

Click “Submit.”

The model will process your input and the generated image will appear on the right side of the interface.
You can right-click the image and select “Save As” to download it to your local computer.

Check Generated Image

Step 25: Enjoy Generating and Downloading Images Instantly!

You’re now all set to unleash your creativity using the Flux-Krea Gradio app!

Type your prompt in the box (for example:
a pufferfish inflating itself in surprise).
Adjust any settings as needed (width, height, guidance scale, steps, seed).
Click “Submit.”
- The generated image will appear instantly in the preview window on the right.
- If you like your result, just right-click the image and select “Save As” to download it directly to your computer.
Experiment and have fun:
- Try a variety of prompts—anything from wild cartoon scenes to photorealistic animals.
- Play with the sliders for size and detail to get unique outputs every time.

Conclusion

You’ve just built a complete, high-quality image generation system—from setting up a powerful GPU environment to creating your own interactive web app. With FLUX.1 Krea [dev], you can turn any idea or description into stunning visuals in seconds. Whether you’re experimenting with creative concepts, building out a new project, or just having fun with new prompts, you now have all the tools you need to explore, generate, and download images with total control.

This workflow not only saves time but also opens up new possibilities for artists, developers, and anyone who wants to bring their imagination to life. With your browser-based interface, you can tweak every detail, try unlimited prompts, and always get results you can use and share instantly.

Ready to see what you can create next? Your visual journey starts here—so keep experimenting, keep discovering, and enjoy the process!

Relevant blog posts

August 8, 2025

How to Install & Run Qwen3-4B-Thinking-2507 Locally?

Qwen3-4B-Thinking-2507 is a compact yet highly capable reasoning-focused language model designed for tasks that demand clarity of thought and multi-step problem solving. Despite having only 4 billion parameters, it delivers strong performance across logical reasoning, mathematics, scientific analysis, coding challenges, and other domains that require precision and depth. What makes this version stand out is its “thinking mode” — it produces a visible reasoning trace before giving the final answer, allowing you to see how it arrives at conclusions. This is particularly valuable for debugging model outputs, teaching, or verifying reasoning in high-stakes scenarios. Another key strength is its long-context capability — up to 262,144 tokens natively — enabling it to work with extremely large documents, multi-turn conversations, or complex datasets without losing context. Whether you’re feeding it an entire research paper, a big block of code, or a chain of connected instructions, it can keep track of details and maintain coherent reasoning throughout. Although designed for complex reasoning tasks, it’s also well-tuned for general-purpose usage such as instruction following, structured output generation, and creative writing. It supports tool usage through agent frameworks like Qwen-Agent, making it easier to integrate with APIs, code execution environments, and other workflows.

August 6, 2025

How to Install & Run OpenAI GPT-OSS Locally?

There’s a new duo in the world of open-source models, and they’re here to make life a whole lot easier for developers, builders, and tinkerers everywhere. Whether you need raw horsepower for serious projects or something nimble for local experimentation, the gpt-oss lineup has you covered. On one side, you’ve got the gpt-oss-120b—a heavyweight, purpose-built for tasks where deep reasoning, clear thinking, and wide-ranging skills really matter. It’s ready for the big leagues, built to handle complex requests without breaking a sweat. Perfect if you want the confidence that comes from working with something built for scale and reliability. On the other side is gpt-oss-20b, the lighter and more agile sibling. It’s all about speed and versatility, ideal for those moments when you want answers fast, want to run things on your own machine, or just need a model that’s easy to fine-tune and shape to your unique needs.

August 2, 2025

How to Install & Run GLM-4.5 Locally?

GLM-4.5 and GLM-4.5-Air are large-scale, cutting-edge language models designed to power a new generation of intelligent digital assistants, tools, and workflows. Built for both depth and efficiency, these models offer top-tier results across tasks like coding, problem solving, and natural conversation—making them perfect for teams building smart apps or anyone who wants advanced reasoning and real-world utility.

See all posts

Ready to build
with us?

The ideal way for organizations young and old to ease their way into the distributed and affordable cloud at their own pace.

Stay Tuned!

Stay up to date with the latest updates, news, and hotfixes for our product.

NodeShift creates a vital link between developers and affordable cloud.

Switch theme

English (EN)
Arabic (AR)
Chinese (ZH-CN)
German (DE)
Korean (KO)
Russian (RU)
French (FR)
Spanish (ES)
Portuguese (PT)
Japanese (JA)

JavaScript is disabled in your browser. For a better experience, please enable JavaScript.Learn how to enable JavaScript.