Can LumaBrowser use the models I already downloaded with LM Studio or Ollama?

Yes. Easy Setup scans the LM Studio models folder, the Ollama blob store (through its manifests) and the Hugging Face cache, and adopts what it finds by hardlink. Nothing is copied or re-downloaded, and the files stay plain GGUF in a folder you control.

Can I run a chat model and an image model on one 12 GB card?

Yes. When both fit they stay resident together. When they do not, LumaBrowser runs one at a time and swaps automatically, keeping the parked model pinned in system RAM so the swap takes seconds. It never silently falls back to CPU; the planner tells you what did not fit.

Is LumaBrowser open source?

The app is proprietary and free. The engines underneath are the open ones: llama.cpp, stable-diffusion.cpp, whisper.cpp, sherpa-onnx and mlx-lm, and LumaByte's llama.cpp patch stack is public on GitHub. Models are plain files, the extension format is public, and the app sends one version check-in and nothing else.

Switching from LM Studio, Ollama or ComfyUI: Keep Your Models, Lose the Juggling

The three questions, answered first

If you have been burned by a wrapper before, these decide whether you keep reading. So they go here.

Your models

Easy Setup scans where the other tools keep weights and adopts what it finds by hardlink. No copy, no re-download, no private format. Delete LumaBrowser and the files are still yours.

~/.lmstudio/models · ~/.ollama/models (blobs named through the manifests) · ~/.cache/huggingface/hub

Anything else is a file picker or a Hugging Face repo and file name pasted into the Advanced field. Single-file and sharded GGUFs both work, with resume.

Your flags

The chat engine is a runtime row you can swap: upstream llama.cpp (CPU, CUDA 12, Vulkan), our patched CUDA build with a faster mmap load, ik_llama and NInfer as add-ons, mlx-lm on Apple Silicon. Images and video run on stable-diffusion.cpp.

The planner derives the launch flags from your hardware, and you can read and override every one of them in the Setup tab: context sized to what fits instead of a fixed 4k, KV quant, -ts, --n-cpu-moe, draft model, RAM pin. Anything else goes in the extra flags box per model and is appended last, so it wins. Every knob.

Your GPU

One process owns the card and knows what is loaded. When the chat model and the image model both fit, they stay resident together. When they do not, they run one at a time and swap automatically, with the parked model pinned in system RAM so the swap takes seconds rather than a reload from disk.

Two cards? One model per card, or a fill-order split that loads the fastest card first. Nothing falls back to CPU silently: the planner says what did not fit and why.

Coming from

What you keep, what changes, and what shows up that you did not have. We use these tools too; none of this is a knock on them.

You run	You keep	What changes	What you gain
LM Studio	Your models folder, adopted as is. The same GGUFs, the same quants. The local server: Local API in Settings serves the loaded model on 127.0.0.1, OpenAI-compatible.	Model browser and fit check are still there, but the settings panel becomes the Setup tab with the raw flags visible and a box for any llama.cpp flag we did not think of.	Image, video and music generation in the same window and the same GPU budget. Voice, MCP and tools toggle on instead of being wired up. A browser the model can drive.
Ollama	The blobs you already pulled. We read the manifests so the content-addressed files get their names back.	No registry and no Modelfile. Context is sized to your VRAM by default instead of a short fixed window, and the launch is llama.cpp itself, not a fork behind an API.	Every llama.cpp flag, plus placement across cards and system RAM decided for you and shown to you.
llama.cpp or koboldcpp	Your flags. What the planner derives is a starting point, not a cage.	Instead of a launcher screen per run, the Setup tab remembers a plan per model and re-derives it when you change the context or the card.	A second engine (stable-diffusion.cpp) that shares the GPU without you scripting the unload, a chat UI with tools, documents and artifacts, and a benchmark that tells you whether a quant behaves, not just whether it loads.
ComfyUI, Forge or stable-diffusion.cpp	Your `.safetensors` and `.gguf` checkpoints and LoRAs. Bring your own file, or take one of ours.	No node graph. This is a prompt box with model, size, steps, sampler, LoRA attachment and per-model prompt profiles, plus image editing. If you live in node graphs, keep ComfyUI; this is the other path.	The chat model prompts the image model for you, and the two never fight over VRAM. Video and music are in the same place.
Open WebUI and a docker stack	Your habits: chat with tools, documents, knowledge base, multiple models, a LAN you share with.	One installer instead of compose. No container, no port map, no 4 GB image. Sharing to other machines is a switch with a PIN, not a reverse proxy.	The engines are in the box, so there is nothing to point at. Image, video, voice and a browser your agent can use come with it.
SillyTavern	The idea. Characters, consistent looks, long stories.	Roleplay is a chat mode with its own memory and per-character image generation instead of a separate front end talking to a separate backend.	Character art and scene images from the same GPU that runs the story, swapped in automatically.
Pinokio	The one-click promise.	One app rather than a catalog of separate apps, each with its own environment and its own idea of the GPU.	The pieces are designed to share a card, so they do.

Model adoption covers GGUF today. MLX models on macOS are Hugging Face repo snapshots and download through the app. The scan runs inside Easy Setup; run it again after pulling new models elsewhere, or use the file picker.

What it looks like on a 12 GB card

The RTX 3060 and 4060 class is the most common card we see. Here is what Easy Setup does with one, in order.

Reads the card and the RAM. Video memory, system memory, CPU, and whether a second card exists. Shown to you in one line before anything downloads.
Picks a chat model that fits with context to spare. A mid-size model at Q4_K_M with the context sized to what is left, not a fixed 4k. If you already have a suitable GGUF from LM Studio or Ollama, it offers that first.
Adds an image model that fits. One that will run on 12 GB with the text encoder placed where there is room. You can swap it later for anything you already have.
Decides coexist or one-at-a-time. Both fit? They stay loaded together. They do not? Chat unloads while an image renders and comes back afterwards, pinned in RAM so the round trip is seconds. You see which mode it chose and can force the other.
Runs the fit test and, if you ask, the benchmark. Loads, warms up, and tells you the tokens per second and what actually landed where. The benchmark checks tool calls, editing and long context on the model you launched.

Numbers on the Advanced page come from our dev rig, a 5090 plus a 3090. Run the fit test on yours before you trust anything, including us.

What is open, and what is not

The app is proprietary and free. We are not going to dress that up.
The engines are the open ones, unmodified where possible and credited: llama.cpp, stable-diffusion.cpp, whisper.cpp, sherpa-onnx, mlx-lm. Our llama.cpp patch stack is public at amurgola/luma-llamacpp.
Models are plain files in a folder you choose. Conversations are in a SQLite database on your disk. There is no account.
The extension format is public and extensions ship as plain zips. The Extensions tab is where the openness lives.
The app sends one version check-in so we can count installs. No analytics, no crash reporting. You can turn the check-in off, and auto-update is a setting.

What you do not get

Node graphs. ComfyUI is deeper for image pipelines and will stay that way.
A Linux CUDA build of stable-diffusion.cpp. None exists upstream yet, so NVIDIA on Linux renders images through Vulkan. Chat uses CUDA on Linux fine.
A tiny binary. It is an Electron app, under 200 MB, and it is a browser because the agent side needs one.

Drive it from the tools you already use

Turn on Local API in Settings and the running chat model is served OpenAI-compatible at http://127.0.0.1:8317/v1, loopback only, no key: point Cline, Continue, a JetBrains plugin or any OpenAI client at it. It is a transparent proxy to llama-server, so tools, response_format and streaming work as llama.cpp implements them. For other machines, Network Sharing exposes the same model at /sharing/llm/v1/chat/completions behind a token over TLS. The rest of the app is an API too: REST on port 3000, a built-in MCP server so Claude Desktop or Cursor can use the browser as tools, and WebDriver and Chrome DevTools Protocol endpoints so existing Selenium, Playwright and Puppeteer scripts attach unchanged. API reference · MCP · Docker.

Keep your models. Lose the juggling.