An apprentice for your studio.

You draw the outline. It lays in the colour — in your palette, your hand. You do the shading. Atelier is an AI apprentice that learns your style from your own pieces and takes the legwork off your desk, so you can spend your time on the finer details. It runs on your own computer; your work never leaves it and is never used to train anyone's AI.

Download for Mac, Windows or Linux View the code

Free and open source. Unsigned builds (see the Download notes). The app fetches two pretrained models once (~3 GB), then runs offline. Version 0.1.4 — sharper brushwork, a composition lock, an apprentice you can train on your own work, and a log of every run.

The Atelier app: your pieces, your outline and a prompt with sliders, and the coloured results
Three benches and a studio log: your work (the apprentice studies it, and can be trained on it) · the brief — your outline or sketch, a few words, and six controls · the pieces, coloured in your style and ready for your hand. Every run is kept in the History rail on the left.

How the apprenticeship works

Like any apprentice, it starts by studying your work — then it takes the parts of the job you'd happily hand off.

1
It studies your work.Drop in a few pieces — JPGs, PNGs, phone photos (HEIC is fine; photographed drawings are cropped to the sheet of paper). Atelier reads your palette, tone and brush texture into a small style book: a file in the app's folder that describes your hand, and nothing else.
2
You draw the outline.Sketch it the way you always do, photograph or scan it, drop it in. Add a few words if you like — a fox reading under a tree, warm, quiet. A slider sets how much freedom the apprentice gets with your lines: keep them exactly, or let it reinterpret.
3
It lays in the colour — in your style.The apprentice paints your outline with your palette and brushwork (neural style transfer from the pieces your words point at; a small text-to-image model fills in what you describe, in your medium). Mood words — warm, quiet, dramatic, dark — steer the pieces it works from and grade the colour. Your marks are read at the size you actually made them, so the texture stays crisp instead of smearing.
4
Your composition is held.Layout lives in the broad shapes of a picture; brushwork and palette live in the fine ones. The composition lock keeps the large shapes of your drawing while the styling rewrites everything above them — the horizon stays a horizon and your trees stay trees, instead of dissolving into someone else's shapes.
5
You do the shading and the finishing.Ask for one take or eight, pick the one that feels right, and take it back to your desk for the detail only you would add. Every result lands in a gallery folder you own, and every run stays in the History rail — reopen it weeks later, run it again, or load its settings and change one thing.

Private by construction

An apprentice that works in your studio — not in someone else's cloud. Your art stays in one folder on your computer, and nowhere else.
  • No account, no upload, no server of ours. The app is a local program that opens a window.
  • The only network access is a one-time download of two public, pretrained models. After that, switch the network off: it keeps working.
  • Nothing here trains a shared model on your work. The “style book” — and the apprentice's eye, if you train one — are files in the app's folder describing your palette and marks, used only to paint for you. Delete the folder and the apprentice forgets everything.
  • The History rail is just the gallery folder: every run is a small record next to its images, on your disk. No sync, no account, nothing phoning home.
  • Open source, so all of this can be checked — and the sandbox folder is a plain folder you can open any time from inside the app.

The apprentice's own eye

Press one button and Atelier trains a small model — a variational autoencoder — on your pieces and nothing else. It takes a few minutes on your own machine, and it learns one thing: what your paint looks like up close, at the scale you actually make marks.

From then on it sits over the apprentice's shoulder, asking of every patch: is this something I have seen this artist do? The general-purpose network underneath knows a million photographs of the world, which is why, pushed hard, it starts smuggling other people's faces and objects into your picture. Your own eye knows only your work, and pulls the picture back toward it.

Optional, and yours: the trained eye is a file in your folder, trained on your pieces, used only to paint for you — delete it and the apprentice forgets. Trained on a handful of pieces it learns your colour and the feel of your marks, not how you draw a hand: a nudge in the right direction, not a second artist. The architecture is adapted from a face-generation VAE we built for a computer-vision course, including its most useful lesson — the plain autoencoder beat the adversarial version we wrote alongside it.

The controls

Style strengthHow hard your style is pushed onto the piece: a gentle tint of your palette → fully repainted in your brushwork. Around 0.6–0.9 keeps the drawing intact.
Composition lockHow much of your layout survives the styling. 0 lets the style rewrite the big shapes; 0.5 (the default) keeps your horizon, your figures, your framing.
Sketch freedomHow much licence the apprentice gets with your outline: faithful to every line → only loosely inspired by it. Or colour the sketch exactly as it is.
Apprentice's eyeHow much weight your trained eye carries, once you have trained one.
Quality · detailIterations and working resolution — finer results take longer. About a minute per piece at the defaults.
Pieces · seedHow many to paint (the first is the one that took the style best) and an optional seed so the same brief gives the same piece again.

Download

All builds: github.com/seaneven-web/atelier/releases. The builds are unsigned: on macOS right-click → Open the first time (Gatekeeper); on Windows choose “More info → Run anyway” (SmartScreen). First launch offers the one-time model download (~3 GB). Needs ~8 GB of RAM; a GPU is used when present, otherwise the CPU (about a minute per piece).

Or run it from source

git clone https://github.com/seaneven-web/atelier && cd atelier
python3 -m venv .venv && .venv/bin/pip install -r requirements.txt -r requirements-desktop.txt
.venv/bin/python atelier_app.py          # the app
.venv/bin/python atelier.py paint "a hippo eating cheese" --portfolio ~/DadsArt   # the command line

What an apprentice can and can't do

It carries your palette, texture and tone very well; it carries your composition less well — which is exactly why the outline should be yours, and why the composition lock exists. More pieces help it learn, and cleanly photographed pieces help most. Asked for something without a sketch, it composes the scene itself (a small text-to-image model) and then paints it in your style — handy, but less yours. A deeper apprenticeship (fine-tuning the content model on your work, a LoRA) would learn your composition too; it needs a real GPU and is the natural next step.