iLab CONJURE: A Local-First WebUI Workbench for GPT Image and Gemini

What iLab CONJURE Actually Solves

iLab CONJURE addresses a specific pain: managing many AI image generation tasks across multiple models without losing track of outputs. If you juggle GPT Image, Gemini, and Codex, you likely have separate tools or browser tabs, each with its own prompt history and output folder. This project consolidates them into one local WebUI with a unified model directory, a shared gallery, prompt templates, and a paginated history stored in SQLite. The intended user is a developer or power user who wants automation via a CLI and a visual interface, not a casual user who only needs a single image now and then. The README positions it as local-first, meaning your data stays on your machine, and it offers a portable package for those who prefer a ComfyUI-style unzip-and-run approach.

How the Architecture Fits Together

The core is a Python server that runs a WebUI, with the front-end built from TypeScript and CSS compiled into a single static file. The data flow is straightforward: you configure providers in the settings, pick a model, enter a prompt, and the server sends the request to the chosen backend. The README lists two main authentication paths: an OpenAI-compatible API mode for stable, shared use, and an advanced local OAuth mode that reuses your Codex or ChatGPT login to call internal endpoints. The latter is explicitly for personal use only. The history system uses SQLite for pagination, search, and filtering, and you can export selected tasks as ZIP files, either with images only or images plus prompts. The gallery and templates are rendered lazily, which the README claims improves performance when resizing the window or refreshing.

Getting It Running: Commands and Config

Installation follows a standard Python flow. You clone the repository, create a virtual environment, and install dependencies with pinned hashes. The README gives these commands: git clone, cd, python3 -m venv .venv, then .venv/bin/python -m pip install --require-hashes -r requirements-webui.txt. For a manual start, you run .venv/bin/python -m codex_image.webui.server codex_image.webui.app:app --host 127.0.0.1 --port 8787 --no-access-log, then open http://127.0.0.1:8787/. On macOS, you can double-click Start WebUI.command; on Windows, Start WebUI.bat. The standard packages for macOS and Windows include a Rust tray launcher and a migration assistant that copies old portable data on first run. The portable packages keep data in a local data/ directory, and updates are handled by scripts that verify a signed manifest and SHA256 checksums.

The Concurrency and Queue Model

One of the standout features is the support for concurrent tasks and a local queue. The README mentions multi-task concurrency, local queue status, and a paginated history library. This is not just a single request-response tool; you can fire off multiple generations and monitor their progress. The network settings let you set a global timeout for each image request, from 1 to 30 minutes with a default of 10, and retry counts from 0 to 5 with a default of 2. Each retry gets a fresh full timeout window. This is a practical design for flaky network connections or rate-limited APIs. However, the documentation does not specify how many tasks can run in parallel or how the queue prioritizes them. That is a gap. You will need to test the concurrency limits against your provider's rate limits yourself.

The History and Gallery Features Are Deeper Than Most

The history page is not a simple list. It supports SQLite pagination, search by prompt or task ID, filtering by favorites, tags, or no tags, and a grid or list view. You can select up to 300 tasks at once for batch operations. Exporting tasks to ZIP is a thoughtful touch, especially because each image can carry its own optimized prompt, falling back to the original prompt when needed. The gallery and chips system also stands out: you can have public gallery references, recent reference images, color chips, prompt fragment chips, and prompt templates. This is aimed at users who iterate on styles and want to reuse components. The image editor adds another layer, supporting multiple layers, locked aspect ratio transforms, Shift for free transform, and local erase. That is a lot of functionality in one tool, but it also means a steeper learning curve.

A Real Limitation: The OAuth Mode Is a Trap

The biggest caveat is the Codex OAuth mode. The README is blunt: it is not an official OpenAI integration, and the interface may change, break, or be affected by account, product, or usage rules. The project explicitly warns against using it for production, team deployments, or public services. This is a genuine failure mode. If you rely on it for daily work, you risk sudden breakage with no recourse. The recommended path is the OpenAI-compatible API mode, which is stable and suitable for shared workstations. Another limitation is the lack of signing on macOS builds. The DMGs are not signed or notarized, so macOS will block them initially, and you must manually bypass the quarantine. That is a friction point for less technical users. Additionally, the Windows standard ZIP still requires manual replacement on updates, which can be tedious.

Alternatives and the Trade-Offs

The obvious alternative is to use the official ChatGPT or Gemini web interfaces directly, or a tool like ComfyUI for local generation. The difference is in approach: the official web interfaces are cloud-hosted, have no local history or queue management, and lock you into a single model. ComfyUI is a node-based workflow that gives you granular control over diffusion pipelines but requires more setup and does not natively support GPT Image or Gemini APIs. iLab CONJURE sits in between: it is a managed workbench with a WebUI, not a node editor, and it abstracts multiple providers behind one interface. If you need deep model control, ComfyUI is more flexible. If you only need occasional images, the official interfaces are simpler. iLab CONJURE wins when you want a unified local gallery, history, and batch processing across providers.

Maintenance and Upgrade Costs

The project has a clear release cadence, with recent versions v0.8.1, v0.8.2, and v0.8.3. The README describes an update helper for macOS that checks a signed manifest, downloads a DMG, verifies SHA256, and replaces the app with rollback protection. On Windows, updates are manual. The portable packages include an update script that validates Ed25519 signatures and SHA256, preserves data/, and backs up replaced files to .backup/. The license is AGPL-3.0, which has implications if you modify and distribute the code, but for local use it is not a concern. The dependency installation uses pinned hashes, which is good for reproducibility but means you must re-run the install when dependencies change. The project also warns not to commit OAuth files, API keys, local images, or the SQLite database to Git, which is a practical reminder for anyone using the source checkout.

Editorial conclusion

Adopt iLab CONJURE if you are an individual or small team that wants a local-first, multi-model image generation workbench with a shared gallery, prompt templates, and a searchable history, and you are comfortable using OpenAI-compatible APIs for stability. Do not rely on the Codex OAuth mode for production, team, or public deployments, as the README warns it is not an official integration and may break anytime. Before committing, verify your provider's API supports the Images or Responses endpoints, test the concurrency settings against your rate limits, and check that the unsigned macOS builds and manual Windows updates fit your workflow.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes