OpenLayer

Alpha v0.19.0 · free & open source

Local AI layers,
inside Photoshop.

OpenLayer connects Photoshop to your own ComfyUI server. Generate with Stable Diffusion, SDXL, and Flux — then import results as editable layers. Your art, your GPU, your machine. No cloud. No credits. No subscription.

Download alpha Star on GitHub
  • 100% local
  • Open source · MIT
  • Photoshop 2024+
  • ComfyUI powered
OpenLayer v0.6 Text to Image generating and importing a comic-style result inside Adobe Photoshop.
Text to Image, where the work happens. Generate locally, preview in OpenLayer, and keep every result as an editable Photoshop layer.

v0.10 setup that explains itself

Local generation that now feels at home inside Photoshop.

OpenLayer starts with dependable local workflows — text to image, image to image, sketch to image, experimental inpaint and outpaint, pixel upscale, lossless PNG source capture, live previews, diagnostics, and clean import into the active document. v0.10 turns to the part nobody enjoys: setup. Workflow Health now tells you when a "missing" model is really just one folder over, and names the repository behind a missing custom node. The plugin zip is also built to spec for the first time, which is what makes it unpack correctly on macOS.

Tools

What works now

Text to Image

Stable

Prompt, negative prompt, size, steps, CFG, and seed into your checkpoint of choice — SD 1.x, SDXL, plus experimental Flux fp8 and Z-Image-Turbo presets.

Image to Image

Stable

Capture the active layer or visible canvas as lossless PNG, reinterpret it with a prompt, and import the result — optionally automatically.

Sketch to Image

Experimental

Guide generation with your linework through an SD 1.x LineArt ControlNet workflow, with adjustable control strength.

Inpaint

Experimental

Make a Photoshop selection, capture source and mask, repaint just that region with SD inpainting or Flux Fill, and import aligned to your selection.

Outpaint

Experimental

Extend content beyond the canvas edges with Flux Fill and per-edge padding and feathering control.

Upscale

Stable

Enhance layers with local upscale models such as 4x-UltraSharp — fast pixel/model upscaling through ComfyUI.

Prompt from Layer

Stable

Describe any layer or canvas into editable prompt text with Florence-2 PromptGen, then send it straight to Text to Image.

Live Painting

Experimental

Keep painting and OpenLayer keeps repainting — a fast local preview tier that follows your strokes, plus a slower Krea-2 Turbo refine pass on demand.

Multi-Reference

Experimental

Capture several layers into an ordered list and compose them into one picture with FLUX.2 Klein — clothing, props, setting, and lighting carry across from each reference. A specific person's face does not; treat it as scene composition, not as a way to place someone recognisable into a picture.

Layer Tools

Stable

Send pixels the other way. Export the active layer, the current selection, or the selection mask — to a file you pick, or straight into ComfyUI's input folder where a workflow can use it.

Workflow Health

Built in

One click tells you which presets are ready on your ComfyUI — missing models, missing nodes, and beginner-friendly next steps.

More under the hood
  • Local ComfyUI connection with active-port discovery and one-click availability checks.
  • PNG/lossless source capture from raw Photoshop Imaging API pixels.
  • Live KSampler step previews streamed into the panel while generating.
  • Queue-aware Cancel Generation that never kills another client's job on a shared server.
  • GPU and VRAM detection with beginner-friendly model family recommendations.
  • Per-preset recommended defaults applied when you switch workflows.
  • Copy Diagnostics: a local, private setup report for bug reports.
  • Session history with prompt, model, seed, dimensions, source mode, and one-click Reuse Settings.
  • Experimental checkpoint mode with clear compatibility warnings for SD3, Flux, and Z-Image families.
  • Workflow compatibility foundation that separates checkpoint presets from diffusion-model-stack presets.
  • UXP-safe vanilla TypeScript interface — no fragile browser APIs inside Photoshop.
  • Typed AI-layer metadata foundation for future persistent, reproducible AI layers.

Interface shots · v0.6

Proof from the real Photoshop panel

Each view below is a real local workflow, compressed for the web and loaded only when it approaches the viewport.

OpenLayer v0.6 compact dashboard with available, experimental, and unavailable tools clearly grouped.
The v0.6 dashboardA compact launcher keeps generation tools close, groups workflow and history utilities, and dims features that are not ready yet.
OpenLayer v0.6 Text to Image controls and generated comic preview.
Focused Text to ImagePrompt, model, sampler controls, status, preview, and import remain readable in a narrow docked panel.
OpenLayer Upscale result displayed in Photoshop with generated layers visible in the Layers panel.
Upscale stays layer-nativeLocal model upscaling returns to the active document as a named Photoshop layer instead of a detached download.
OpenLayer Live Painting with a sticky tool header and preview beside the active Photoshop canvas.
Context that stays pinnedThe v0.6 tool header keeps Back to Tools and the current workflow visible while longer panels scroll beneath it.
A simple painted figure in Photoshop transformed into a local AI preview through OpenLayer Live Painting.
Paint, capture, respondThe Live Painting spike turns rough color blocking into a local preview while preserving the Photoshop document as the source of truth.

Live demos

Watch it run, unedited

Full local sessions, not clips — a real ComfyUI server and a real Photoshop window, start to finish.

Inpaint and Outpaint, liveRepainting a selection and extending canvas edges with Flux Fill, recorded from an earlier alpha build.
Start to finish, one serverText to Image through Upscale, run end to end against a local ComfyUI server, from an earlier alpha build.

Oldest to newest

How the OpenLayer interface evolved

The visual language stayed dark, local, and Photoshop-aware. Each release removed friction while preserving the original goal: make AI output behave like editable layer work.

  1. Early OpenLayer dashboard with large tool cards and status badges.
    1 · The first launcherThe earliest README dashboard established the tool-card model and made unfinished workflows explicit, but used much more vertical space.
  2. Earlier OpenLayer landing-page closing section with the gold layered logo and project mission.
    2 · A durable visual identityThe black canvas, gold layer mark, and careful-step message became the design foundation retained by the v0.6 page.
  3. Earlier Prompt from Layer screen with captured image and generated description.
    3 · Workflows became complete screensPrompt from Layer connected capture, local Florence-2 description, editing, copying, and handoff to Text to Image.
  4. OpenLayer Live Painting turning a rough orange monster sketch into a local AI preview in Photoshop.
    4 · The panel began responding to the canvasThe Live Painting experiment proved that repeated local capture and generation could follow fast Photoshop sketch changes.
  5. Current OpenLayer v0.6 compact dashboard.
    5 · v0.6 compact UXP interfaceToday the dashboard is denser, clearer, and more honest about availability, with stable UXP typography and room for the next artist tools.

Workflow

How it works

  1. Run ComfyUI locally on the OpenLayer port (8190 by default).
  2. Open the panel in Photoshop and click Check ComfyUI.
  3. Pick a tool — capture a layer, canvas, or selection where needed.
  4. Generate and watch live sampler previews in the panel.
  5. Import the result as a new named Photoshop layer.

Setup

Run it locally in minutes

1

Download and double-click

Grab openlayer-v0.19.0-alpha.ccx from the latest release and double-click it. Creative Cloud installs the panel — no developer tools, nothing to build.

2

Open it in Photoshop

Creative Cloud will note that the plugin is not verified by Adobe, since it is not from Adobe Exchange. Accept, then find it under Plugins > OpenLayer. Prefer to build from source? The README has the UXP Developer Tool route.

3

Start ComfyUI

python main.py --listen 127.0.0.1 --port 8190 --preview-method auto
4

Create the first layer

Check ComfyUI, choose a checkpoint, enter a prompt, generate, and import the result into the active document.

Missing a model? The Setup screen lists every one the presets need and downloads it for you — one at a time, resumable, and only after a confirmation naming the file size, the folder it lands in, and the host it comes from. Licence-gated weights and custom node packages are the exceptions and stay a manual job; the screen says which is which.

OpenLayer defaults to http://127.0.0.1:8190 so it can run beside other local tools that may already use port 8188 — but you do not have to move your server. If ComfyUI is already running anywhere, open Settings and click Find ComfyUI Active Port; OpenLayer finds it, connects, and reports Ready. --preview-method auto enables live step previews.

Current alpha status

What this release is honest about

Separated preview panel is ready to test

A second dockable panel shows the current generation at any size, mirroring every tool including Live Painting. It can be pinned to one tool, and it imports the result into your document without going back to the dashboard. It has passed a real Photoshop UXP smoke test.

An AI assistant can drive the panel

Claude, Codex, or anything else that speaks the Model Context Protocol can call OpenLayer's seven tools directly, running the panel's own buttons in your open document. It is local-only, off until you turn it on, and not included in the download — it lives in the repository. Verified end to end generating real images in Photoshop with Claude, and separately confirmed connecting and reading panel state with Codex.

Testing alpha

OpenLayer v0.19.0-alpha is for local testing and feedback. It is not production-ready yet.

Multi-Reference composes; it does not preserve likeness

48 test generations found clothing, props, setting, and lighting carry across from a reference layer — a specific person's face does not, even from a clean studio portrait. It is honest as a composition tool and should not be used expecting a recognisable result.

Inpaint is experimental

v0.19.0 retains the upload and alignment fixes while output quality across checkpoints continues to be validated by testers.

Flux Fill is experimental

Flux1-dev fp8 Text to Image, Flux Fill Inpaint, and Outpaint run locally but still need careful validation and tuning.

Custom workflows are future work

OpenLayer keeps API and source workflow folders, but custom workflow import and automatic node mapping are not built yet.

Honest alpha boundaries
  • txt2img-basic, img2img-basic, and sketch2img-linecn-basic are starter workflows, not final production presets.
  • Sketch to Image targets SD 1.x with epicrealism_naturalSinRC1VAE.safetensors and offers LineArt, Scribble and Depth ControlNet presets, each needing its own ControlNet model.
  • Custom ComfyUI workflows may need node ID updates in the preset registry.
  • GPU-aware recommendations are advisory only. OpenLayer does not auto-switch models or workflows yet.
  • Layer, canvas, and mask capture is limited to 16 megapixels until a downscale option is added.
  • Inpaint and Outpaint should be tested on duplicate layers first.
  • Prompt from Layer requires the local Florence-2 PromptGen model and the comfyui-florence2 nodes. The custom-scripts pack is no longer needed.
  • Upscale uses pixel/model upscale only. Generative upscale, tiled diffusion, and creative enhancement are future work.
  • Custom workflow import, batch variants, and true persistent Photoshop AI layer metadata are future work. v0.19.0 keeps the shared metadata foundation and session-history wiring.
  • The LoRA list cannot be filtered by which model a LoRA suits: ComfyUI reports only a name and size. Entries are labelled from their filenames and likely matches sorted first, but a mismatched LoRA loads without error and quietly does nothing.
  • CI does not run Photoshop, UXP, or ComfyUI integration tests.
  • Live sampler previews require ComfyUI to be started with --preview-method auto.
  • Progress is shown in the generation status panel rather than pinned to the screen header, so it scrolls with the form.
  • The ComfyUI setup pack ships the requirements list and a downloader, not the model weights. An internet connection is required.
  • The Setup screen downloads models but not custom node packages, which keep Copy Link and go through ComfyUI-Manager. It also refuses to fetch licence-gated weights, because an unauthenticated download saves a sign-in page under the model's filename rather than a model.
  • The Agent Bridge is not part of the .ccx/.zip download — a Photoshop plugin package cannot start a Node program, so it lives in the repository. The panel asking the assistant for a prompt additionally depends on the AI client supporting MCP sampling, which is optional in the protocol.
  • Multi-Reference's list is capped at 8 references, a sanity bound rather than a measured limit — testing found no reference count, up to 6, at which composition quality fell off. Reference order matters more than count: an object that has to sit behind the other subjects renders more reliably earlier in the list.

Roadmap

Where OpenLayer goes next

v0.1–v0.2 · Foundation

Text to Image, preview, import, checkpoint selection, Image to Image, Sketch LINECN, source capture, and setup documentation.

v0.4–v0.5 · Working workflows

PNG capture, diagnostics, Prompt from Layer, Upscale, queue-aware Cancel, History metadata, live previews, and experimental Inpaint and Outpaint.

v0.6 · Compact UXP interface

A denser dashboard, sticky headers, determinate progress, Advanced settings, clearer availability, and prompt fields hardened in the real Photoshop renderer.

v0.7 · Preview panel and guided setup

A separated dockable preview panel mirroring every tool, a generated ComfyUI setup pack with verified model download locations, and one fewer custom-node dependency.

v0.8 · Correctness and maintainability

Persistent preview pinning, the missing editable workflow sources plus a source/API drift check, four user-visible fixes to status and progress, and a smaller App.ts.

v0.9 · Layer Tools

Export the active layer, the current selection, or the selection mask to a file or straight into ComfyUI's input folder — and every tool's messages finally stay on its own screen.

v0.10 · Setup diagnostics

Workflow Health finds models sitting in the wrong folder and names the repository behind a missing node — and the plugin zip is finally built to spec, so it unpacks correctly on macOS.

v0.11 · Know what you need

A Setup screen listing every model and node package with its folder, size and status — usable before ComfyUI is even running — plus a ranking of which presets your card will actually run well.

v0.12 · Flux.2 and an honest preset list

A Text to Image preset for the GGUF-quantised FLUX.2-dev, built on ComfyUI's own advanced sampler chain — and every preset the panel lists is now one you can actually run, because the two that never could have been are gone.

v0.13 · LoRAs and in-panel downloads

An optional LoRA on eleven presets, two new Sketch to Image ControlNet presets, and a Setup screen that downloads missing models itself from the project's own pinned URLs instead of only telling you where to find them.

v0.19 · Multi-reference composition

Compose one image from an ordered list of captured layers with FLUX.2 Klein, gated on 48 live test generations before any screen was built: reference order affects output more than reference count, and a specific person's likeness does not carry the way clothing and setting do.

Next · Reliability and artist control

Finish Inpaint and Outpaint alignment, strengthen workflow validation, and turn the metadata foundation into repeatable layer-level iteration.

Future artist tools

Guided custom workflow import, ControlNet panels, LoRA browsing, batch variants, persistent AI layer metadata, and faster live-preview generation.

Build local AI layers, one careful step at a time.

OpenLayer is early, practical, and open for contributors who care about artists, local workflows, and clean Photoshop integration.

Explore the repository ← Back to Home