Freefield: Free Open-Source Higgsfield Alternative on ComfyUI (120 Apps, Setup Guide)

Higgsfield is one of the most popular AI video and image apps right now, with one-click effects, Soul ID characters, lipsync and cinematic camera moves, but every click costs credits. Freefield is a new free, MIT-licensed project that rebuilds those apps on top of ComfyUI using only open-weight models. It has 120 apps in a web studio laid out like Higgsfield’s, and you can run it on your own GPU or rent one on Modal. This guide explains what Freefield is, which Higgsfield features it copies and with which models, how to install it locally step by step, where every file goes, and which apps actually fit on a 16 GB card.

What Is Freefield?

Freefield describes itself as “open-source Higgsfield on ComfyUI: every app is one folder, every model is open weights.” It was built for Comfy Org’s #OpenSourceHiggsfield challenge, which asked the community to rebuild Higgsfield’s paid creative tools as free ComfyUI workflows. The repo was created on October 20, 2026, went public on October 27, and had 112 stars and 26 forks within a day of launch.

The clever part is how it is built. There is no custom code per app. Each app is a folder in apps/ with two files: an app.json manifest and a ComfyUI workflow in API format. The web interface, the forms, the model downloads, the VRAM map and the tests are all generated from those manifests. That makes it easy to read, easy to extend, and easy to take apart. Every app has a Download the workflow button, so you can drop it into normal ComfyUI and use it as nodes.

The request path looks like this:

browser -> web/ + server/ (Node, Comfy SDK)
        -> gateway :8000 (token check, frees VRAM between apps)
        -> comfy-api-proxy :8189
        -> ComfyUI :8188 (your GPU or Modal)

When you switch between two apps that use different base models, the gateway calls ComfyUI’s POST /free endpoint so nothing from the last app is left in VRAM. That matters a lot on smaller cards.

The author also tested it properly: 48 lab runs on Modal between October 20 and 26 on L40S and H100 GPUs, with 710 of 733 test cases passing. Every example image and video in the app is a real GPU run, shown with its time and peak VRAM.

Higgsfield Features and the Open Models Behind Them

Here are the main apps, the Higgsfield feature each one copies, and the model it uses. The VRAM column is the author’s figure for weights on a 24 GB card.

The author picked FLUX 3 Image Klein as the main image model after testing five models on six prompts with the same seed. Klein got counts right (three apples, five lemons) where Z-Image drew four apples, and wrote a product label that Krea 2 left blank. On the Artificial Analysis text-to-image arena in October 2026, Klein scored 1043 Elo, just ahead of Qwen-Image 2.1 at 1042. If you want to use Klein on its own, see my FLUX 3 Image Klein ComfyUI guide.

One honest design choice stands out. Higgsfield’s Soul ID trains a model of your face. Freefield does not train. The character apps copy the person from one or three reference photos on every run, which took 13 seconds on an L40S in the lab, about $0.007 at Modal’s base price. Training a real character LoRA is listed as future work.

The 72 One-Click Template Apps

Most of Higgsfield’s catalogue is a fixed prompt over a few pipelines, and Freefield copies that idea. 72 apps are templates: one of the main pipelines with a prompt built in, a few dropdowns, and an “Extra direction” box. Examples include:

• Product and ads: Poster, Packshot, Billboard Ad, Giant Product, Volcano Ad, Truck Ad, ASMR Add-On.
• Portraits: AI Headshot Generator, Skin Enhancer, Commercial Faces, Renaissance, Comic Book, Giallo Horror.
• Fashion: AI Stylist (try-on), Outfit Swap, Fashion Factory, Outfit Shot.
• Fun: Plushies, 3D Figure, Pixel Game, Brick Cube, Meme Generator, Rap God, Mukbang.
• Camera: Angles 2.0, Shots, Zooms and What’s Next, using Qwen-Image-Edit-2509 with the Multiple Angles and next-scene LoRAs.
• Face and character: Face Swap, Character Swap, AI Influencer (with 20 controls from hairstyle to accessories).

Most of these run on the edit pipeline (FLUX 3 Image Klein at 11 GB), so they work on a 16 GB card. The ones built on video or morph use LTX-2.5 and need more VRAM.

Which Apps Fit on a 16 GB GPU?

This is the question most readers will have. The README lists the weight size for every app, measured on a 24 GB card. I have plotted the main ones against a 16 GB line.

In short, for a 16 GB card like an RTX 4080 or 5080:

• Fits: Z-Image, MOSS-Image, Cinema Studio, Edit, Inpaint, Character, Moodboard, Photodump, Product Shot, all edit-based templates, Upscale, Remove Background, Depth Map, Smooth, Music and SFX.
• Tight, loads by phases: Camera Moves (15.3 GB) and Effects (16.8 GB), plus Motion Transfer (16.6 GB) and Recast (18.6 GB). These load one model at a time, so they may work with system RAM offload.
• Too big without offload: Create Image with the upsampler (17.8 GB), Styles (19.4 GB), Relight (21.5 GB), all LTX-2.5 video apps (21.5 to 24 GB) and all MiniMax H3 apps (27.1 GB for the text encoder alone).

These numbers are weight sizes, and peak VRAM during a run can be higher. The repo’s docs/vram-map.md has the measured peak for every app. You can also start ComfyUI in low-VRAM mode (see below), which trades speed for memory.

How to Install Freefield on Your Own GPU

You need Node 22.6 or newer, Python 3.10 or newer, Git, and a Python virtual environment that already has the PyTorch build for your GPU from pytorch.org. On Windows, use PowerShell.

Step 1: Get the code

git clone https://github.com/neuregex/freefield.git
cd freefield
python -m venv .venv
# Windows PowerShell: .venv/Scripts/Activate.ps1    Linux/macOS: source .venv/bin/activate
# then install the PyTorch build for your GPU from pytorch.org

Step 2: Check what is missing

python tools/doctor.py

The doctor script checks Node, your .env file, and whether your Hugging Face account has accepted the licences of gated models.

Step 3: Install ComfyUI, the custom nodes and the proxy

python tools/local_backend.py setup ~/freefield-comfy

This installs a separate ComfyUI at the pinned commit e3bee7f (version 0.42.0) in ~/freefield-comfy, the pinned custom nodes, comfy-api-proxy and the token gateway. It does not touch your existing ComfyUI.

Step 4: Download the models for the apps you want

Models are grouped into packs. Always run a dry run first to see what is missing and how big it is:

python tools/local_backend.py download ~/freefield-comfy image-flux3 --dry-run
python tools/local_backend.py download ~/freefield-comfy image-flux3

Some models are gated. Log in first with hf auth login or set an HF_TOKEN, and accept the licences on each model page. The main packs are:

The whole catalogue is 104 files and about 355 GB, so only download the packs you need. For a 16 GB card, image-flux3, image and upscale together give you the most apps for about 35 GB.

Step 5: Start the backend

python tools/setup_token.py --env-only
python tools/local_backend.py serve ~/freefield-comfy
# low VRAM: python tools/local_backend.py serve ~/freefield-comfy -- --lowvram

This starts ComfyUI on port 8188, the proxy on 8189 and the gateway on 8000. Anything after -- is passed to ComfyUI, so --lowvram helps on 16 GB cards.

Step 6: Start the web studio

In a second terminal, make sure .env contains COMFY_BASE_URL=http://127.0.0.1:8000, then run:

npm install
npm run serve

Open http://127.0.0.1:3000 in your browser. You can also run an app from the terminal:

npm run app -- create-image --set prompt="a red bicycle against a white wall"

Where Freefield Puts Models and Custom Nodes

Freefield runs its own ComfyUI in the folder you pass to setup. With the example above, everything lands here:

~/freefield-comfy/                     the pinned ComfyUI (0.42.0, commit e3bee7f)
~/freefield-comfy/models/              all model files, in the usual ComfyUI folders
~/freefield-comfy/models/diffusion_models/
~/freefield-comfy/models/text_encoders/
~/freefield-comfy/models/vae/
~/freefield-comfy/models/loras/
~/freefield-comfy/custom_nodes/        the pinned custom nodes

The custom nodes are installed and pinned for you by setup, so you do not need to clone them by hand:

• ComfyUI-LTXVideo by Lightricks, pinned at 44c8a36, for all LTX-2.5 apps.
• ComfyUI-CrossViewWarp, pinned at fbb1e93, for the reshoot app.
• Comfy-Org’s comfy-reshoot workflows, for the camera-angle reshoot.

If you already have a large model folder in another ComfyUI install, the download command has a --models option to point at it instead of downloading again. Check the README for the exact use. Each app’s app.json lists every model file with its Hugging Face repo, size and licence. For example, the Z-Image app uses split_files/diffusion_models/z_image_turbo_int8_convrot.safetensors from Comfy-Org/z_image_turbo, which ends up in ~/freefield-comfy/models/diffusion_models/.

Running It on Modal Instead

If your GPU is too small for the video apps, you can run the same backend on Modal, a pay-per-second cloud GPU service. You need a Modal account:

python tools/doctor.py
python tools/setup_token.py
modal secret create huggingface HF_TOKEN=hf_...
python tools/catalog.py packs
modal run infra/modal_app.py::download --pack image
modal deploy infra/modal_app.py
npm install
npm run serve

Set COMFY_BASE_URL in .env to the URL printed by the deploy step. Models download on a CPU container first, so you are not billed for GPU time while they arrive. Set FREEFIELD_GPU=A10G to try the cheaper 24 GB plan. The README quotes Modal’s base price at $1.95 an hour for the L40S used in the lab. For a price comparison with running locally, see my ComfyUI cloud GPU pricing vs local RTX 5080 guide.

There is also a private link mode (modal deploy infra/web_app.py) that puts the web studio behind a passcode, capped at 30 runs a day and 2 at a time, so you can share it with a friend without running up a big bill.

Using the Web Studio

The interface copies Higgsfield’s layout closely:

• Explore: featured apps as video cards, plus the image, video and audio studios.
• Image and Audio: prompt-first apps with a floating bar for the prompt, reference images and settings.
• Video: controls on the left (Create, Edit, Motion control), results on the right. 46 video apps in total.
• How it works tab: every model with its size and licence, VRAM per phase, and a Download the workflow button.
• Use in…: send any result straight to another app, for example an image into Image to Video or Upscale.
• Compare: put your result side by side with another file, such as the same prompt from Higgsfield.
• History: every run is saved in out/history/<id>/ with its inputs, outputs, seed and timings.

The UI is available in English and Spanish.

Add Your Own ComfyUI Workflow as an App

This is one of Freefield’s best features for ComfyUI users. Any workflow you have can become an app with a form:

python tools/import_workflow.py my_workflow.json --id my-app --name "My App"
npm run validate

The import script reads the graph and writes apps/my-app/app.json and workflow.api.json. Image, video and audio loaders become inputs. The prompt, seed, steps and size become fields. Every Save node becomes an output, and every loader file becomes a model entry. Then it runs the validator and tells you what to check by hand. It accepts both UI and API format workflows.

Freefield vs Higgsfield

Higgsfield still wins on ease of use and on some top-end video quality. Freefield wins on cost, privacy and control, and every workflow it ships is something you can learn from.

Limitations and Licences

• Early project: no tagged release yet, and one app (moss-image) is still a draft.
• Pinned ComfyUI: it uses ComfyUI 0.42.0. Newer models such as Fibo 2.0 need a newer ComfyUI and are not included.
• Big downloads: the video packs are 45 to 76 GB each.
• Video needs a big GPU: LTX-2.5 and H3 apps need 22 GB or more, or Modal.
• Model licences vary. The code is MIT, but the weights keep their own licences: Apache 2.0, MIT, OpenRAIL, LTX-2.x Community, FLUX Kommunity, Krea 2 Community, Stable Audio Community and MiniMax H3 Community. Some community LoRAs are research-only or non-commercial (for example Cameraman v2 in camera-copy), and the app’s How it works tab shows this next to each model.
• SFW only: the author removed effect LoRAs that undress people, show weapons or put real or franchise characters on screen. Use footage and faces you have permission for.

FAQ

Is Freefield really free?

Yes. The code is MIT-licensed and every model is a free download. You only pay for electricity on your own PC, or GPU time if you use Modal.

Can Freefield run on a 16 GB GPU?

Yes, for image, edit, character, upscale and audio apps. Start the backend with -- --lowvram. The LTX-2.5 and MiniMax H3 video apps need 22 GB or more, so use Modal for those.

Does Freefield need custom nodes?

Yes, but the setup command installs and pins them for you in ~/freefield-comfy/custom_nodes/: ComfyUI-LTXVideo, ComfyUI-CrossViewWarp and Comfy-Org’s comfy-reshoot.

Where does Freefield store models?

In the models folder of its own ComfyUI, for example ~/freefield-comfy/models/diffusion_models/, ~/freefield-comfy/models/text_encoders/, ~/freefield-comfy/models/vae/ and ~/freefield-comfy/models/loras/.

Can I use the apps in my normal ComfyUI?

Yes. Every app has a Download the workflow button in its How it works tab. Drop the file onto your ComfyUI canvas, then make sure the models are in your own ComfyUI/models/ folders.

Does it train a character model like Soul ID?

No. It copies the person from one or three reference photos on each run. Training is planned for later.

Final Thoughts

Freefield is the most complete free Higgsfield alternative so far, and it shows how far open models have come in 2026. With FLUX 3 Klein, LTX-2.5, MiniMax H3 and Wan behind it, 119 working apps and an install that handles ComfyUI and custom nodes for you, it is worth an afternoon even if you only use the image apps. On a 16 GB card, start with the image-flux3 pack and the template apps, then rent a Modal GPU when you want the video tools.

More guides:

• Best Open Source Text-to-Image Models in 2026
• Best Local AI Video Models in 2026
• How Much VRAM Do You Need for ComfyUI?

Sources

• GitHub: neuregex/freefield (README, packs index and app manifests, read October 30, 2026)
• ComfyUI Wiki: Freefield news (October 27, 2026)
• ComfyUI Wiki: #OpenSourceHiggsfield challenge
• Freefield 2-minute demo video