How to Steal a Style From Any Image (and Reuse It)

Over one weekend in March 2025, several million people turned their holiday photos into Studio Ghibli frames. Sam Altman said OpenAI's GPUs were melting. Hayao Miyazaki, shown an AI animation demo by NHK back in 2016, had already given his verdict on that sort of thing: he called it an insult to life itself.

Here's the part nobody mentions. Almost none of those millions could reproduce their result on purpose a week later. They typed a studio name, got a look, and lost it. That's the real problem with learning to steal a style from any image: the theft takes 20 seconds, and the reuse is where everyone falls over.

This guide covers the whole loop, not the party trick. You'll capture a style off a single reference, store it in a form you actually own, apply it across new subjects, test whether it transferred, and plan for the day the model that produced it gets deprecated. We'll also tell you where the law sits, which is more permissive and more uncomfortable than most articles admit.

The workflow, in full, before we expand any of it:

1. Separate style from content so you know what you're lifting.
2. Pick a method: describe the style in words, or feed the model the picture.
3. Capture it as a written spec or a reference code.
4. Store it somewhere that survives a model upgrade.
5. Test it on a subject the reference never contained.
6. Check the licence and the ethics before it goes near a paying client.

Style is separable from content, and that's the whole trick

You can steal a style because style is statistically distinct from subject matter, and this has been measurable since 2016.

Gatys, Ecker and Bethge showed that the correlations between a convolutional network's feature maps, the Gram matrices, encode texture, brushwork and colour independently of where things sit in the frame. Style is the statistics. Content is the arrangement. Optimise an image to match one picture's statistics and another picture's arrangement, and you get the first one's look wearing the second one's subject.

Diffusion models moved the mechanism but kept the finding. The InstantX team's InstantStyle paper (Haofan Wang and colleagues, April 2024) found that if you mute every part of a pretrained IP-Adapter except a small number of "style blocks", you get clean style transfer with no fine-tuning at all. The IP-Adapter paper it builds on, from Ye and co-authors, adds roughly 22 million parameters and reports results comparable to fully fine-tuned models. B-LoRA, from Frenkel and colleagues at ECCV 2024, splits style from content by training exactly 2 SDXL blocks, jointly, from one image. Train either block alone and the separation collapses.

So the separation is real, and it's also imperfect and architecture-specific. That imperfection has a name later in this piece: style bleed.

Two ways to steal a style: words, or the picture itself

Every method in circulation is one of two things, and the split runs right through the search results for this topic.

Method A is reverse-engineering. You point a vision model at the reference and make it write down what it sees: medium, line quality, palette, lighting, grain. You end up with text. We'll call that a style spec, and we'll use the term throughout, because the format matters more than the tool that made it.

Method B is reference conditioning. You hand the picture straight to the generator and let it extract the signal itself. Midjourney's --sref, Recraft's custom styles, Google's Nano Banana, OpenAI's image edits and Black Forest Labs' Flux Kontext all work this way.

Pick by reuse horizon, not by fidelity. Method B wins on how close the output looks to the reference today. Method A wins on whether you'll still have the style in 18 months. If the look is for one campaign, condition on the image. If it's your brand for the next 3 years, write it down.

Method A: turn the reference into text you own

Getting a usable style spec out of a vision model is mostly a matter of stopping it from describing the subject.

Ask GPT, Claude or Gemini "what style is this?" and you'll get a paragraph about a woman in a red coat. The fix is to name the axes and forbid the subject explicitly: describe technique, composition, colour and surface, not what is depicted. The svgapp method, which is the most-copied version of this online, codifies 6 axes: line quality, colour palette, shading technique, texture and surface, composition, and medium. Recraft's own documentation points users down the same path, using a vision model to write the style prompt that the image model then consumes.

Specificity is the difference between a spec that works and one that doesn't. "Soft lines" is worthless. "Textured edges, thickness varying 1 to 3pt, ink bleed at terminals" survives being handed to a different model next year.

What this looks like:

• Force a schema. Request JSON with fixed keys and enforce it through structured outputs or a function call, so every reference you process comes back in the same shape and you can diff two specs against each other.
• Split positive from negative. The spec carries what the style is and what it must never do (no gradients, no lens flare, no rendered text). Negatives do more work than people expect once the subject gets complicated.
• Keep it short enough to survive. Very long specs dilute the style signal. If your JSON runs past a screen, you've started describing the photograph rather than the look.

The failure modes are consistent: the model describes the subject anyway, invents hex values it never sampled, or pads the palette with colours that appear on 4 pixels. Read the spec against the reference before you trust it, and delete any line you can't point at.

Method B: hand over the picture and tune the dial

Reference conditioning gets you closer to the reference faster, and every tool implements it slightly differently.

Midjourney's --sref takes a URL or a numeric code and moves colour, medium, texture and lighting across without the subject. --sw sets the strength, from 0 to 1000, defaulting to 100. Community testing puts the usable band somewhere around 65 to 175, though we'd flag that as folklore rather than vendor guidance: it comes from fan sites, not Midjourney's docs, and we haven't run a controlled sweep ourselves.

Recraft takes a different route. Feed it between 1 and 10 reference images and it returns a style_id with no training step, callable from the API forever after, with a choice between capturing style essentials only or style plus composition. That style_id is the closest thing on the market to a saved brand style.

The rest condition per request and remember nothing.

The prices matter more than they look. Nano Banana, released 7 October 2025, bills at $30 per million output tokens and burns about 1,290 tokens on a 1024px image, which lands at $0.039. Nano Banana 2 Lite comes in near $0.034 with roughly 4-second latency. A Segmind IP-Adapter style-transfer call takes about 16.6 seconds. Style capture stopped being an expense somewhere in 2025; it's now a rounding error on a coffee.

Training is cheap too, if you want a style that lives in weights rather than in a vendor's database. Flux LoRAs want 10 to 30 images, with 25 to 30 the common recommendation, and SDXL style LoRAs closer to 30 to 50. The ConsisLoRA authors report a single-image style run finishing in about 12 minutes on one RTX 4090. fal.ai charges $2.50 for a 1,000-step Flux Kontext training batch.

*JammyJar exists partly because of the table above: its Themes feature takes reference images, extracts a reusable style, and lets you fire the same style at Gemini, GPT Image or Recraft without rebuilding it three times.

Assume your style will break, then design around it

Everything that makes reference conditioning convenient also makes it perishable.

A JSON spec is a style spec. A Midjourney code is a style spec. A trained LoRA is a style spec. The difference is what happens when the vendor ships a new model. Midjourney codes created before June 2025 need --sv 4 appended to look the way they did on the day you saved them. OpenAI has gpt-image-1 down for deprecation on 23 October 2026, which retires every workflow pinned to it. Recraft's style_id sits inside Recraft's versioning, not yours.

Text doesn't have this problem, because text isn't an embedding. Hand a well-written spec to a model that didn't exist when you wrote it and you'll get something in the neighbourhood, then tune. Hand it a numeric code and you'll get nothing.

Our take: keep both. The reference code for fidelity this quarter, the written spec as the backup that outlives the vendor. Write the spec the day you save the code, not the day the code stops working.

Go build: open your current brand style, whatever form it's in, and write down the version number of the model that produced it and the date. If you can't, you don't have a style. You have a lucky result.

Prove the transfer worked, don't vibe it

Almost nobody teaches the verification step, which is why so many "style systems" quietly aren't one.

The academic tooling exists. CLIP image similarity, DINO similarity, Gram-based style loss, and CSD (Contrastive Style Descriptors, from Somepalli and colleagues at ECCV 2024) all measure style proximity, and StyleAligned was evaluated with CLIP and DINO. The catch is that they're softer than they look. A 2026 arXiv paper from Frochte shows raw CSD cosine failing as an absolute same-versus-different score across many artists, and CLIP and DINO both conflate content similarity with style similarity. A high number can just mean both images contain a cat.

So use the metrics as a relative signal and run these 3 checks by eye instead.

• Hold the subject, swap the style. Generate the same subject twice, once with the spec and once without. If the two look similar, your style isn't doing anything and the base model is.
• Change the subject entirely. Apply the style to something the reference never contained. A portrait style that only works on portraits is a portrait, not a style.
• Look for leakage. Put the output beside the reference and hunt for objects, poses or backgrounds that travelled across. Anything shared that isn't texture, palette or light is content bleed.

Run all 3 on a set of 4 images before you sign off a style. It takes about 10 minutes and it's the only thing standing between a reusable style and a nice accident.

Style isn't copyrightable, and that isn't the end of the question

The legal answer is clearer than the ethical one, so take them in that order.

Under the idea/expression split in both US and EU copyright law, style is an idea. Nobody owns dark fantasy. Nobody owns flat pastel isometric. Copying the look of a body of work is not, on its own, infringement of that work.

The live litigation hasn't changed that, and in one case it moved the other way. In Getty Images v Stability AI, decided in the UK High Court on 4 November 2025, Getty dropped its primary copyright and database-right claims partway through trial and lost everything else except 2 trade mark findings, which Mrs Justice Joanna Smith herself described as historic and extremely limited in scope. Getty was granted permission to appeal the secondary infringement point on 16 December 2025. In the US, Andersen v Stability AI survived motions to dismiss on training-copy theories and remains unresolved on the merits. Both cases are about training data, not about whether your pastel isometric look belongs to anyone.

Four things do bite, and they have nothing to do with style as such:

• Specific works. Reproducing a recognisable individual image is a different act from adopting a look.
• Trade dress and passing off. A style that makes buyers think they're buying from someone else is a commercial problem, not an aesthetic one.
• Right of publicity. Real people's likenesses carry their own rules.
• Authorship of your output. The US Copyright Office reaffirmed on 29 January 2025 that purely AI-generated material isn't copyrightable and that prompts alone don't make you an author. Your stolen style may be legal and still leave you nothing to enforce.

Japan sits differently. Article 30-4 permits training broadly, but the Agency for Cultural Affairs, whose 2024 consultation drew 24,938 comments before the final report in March 2024, concluded that enjoyment and non-enjoyment purposes can coexist, which pulls consent-free use back when the output imitates a specific living creator. And from 2 August 2026, Article 50 of the EU AI Act requires machine-readable marking of AI-generated content and labelling of deepfakes, so provenance is now an obligation rather than a courtesy.

Which leaves the Ghibli question. OpenAI's stated position in March 2025 was that it refuses living artists' styles but permits studio styles, a line that is easier to code than to defend. Legal permission and ethical defensibility live in different files. Copy a genre, a medium, an era, a movement. Copying one living illustrator whose entire income is that look is a decision, and you should make it deliberately rather than discover it in your brand guidelines 6 months later.

When it bleeds, fix the reference before you touch the weights

Most failed style transfers fail the same 5 ways, and the fixes run in a fixed order.

Style bleed is content escaping the reference: a chair, a pose, a horizon that keeps reappearing. Fix it by choosing a cleaner reference with one technique and one simple subject, then add subject-specific negatives.

Prompt override is your text prompt fighting the reference and winning. Cut the prompt back to the subject and nothing else, then reintroduce detail one clause at a time.

Weight mis-tuning is the --sw problem. Run a permutation sweep across the range rather than guessing, and record the number that worked next to the code.

Style collapse shows up when subjects get complex: the look holds on a single object and dissolves on a crowded scene. Simplify the composition or accept that the style has a ceiling.

Watermark artefacts are the strangest failure and the most instructive. Getty watermarks turning up in Stable Diffusion outputs is documented, and it's a reminder that a reference carries everything in it, including the things you didn't look at.

Work down that list in order. The reference is wrong far more often than the settings are.

Why this matters more in 2026 than it did in 2025

The Ghibli weekend was a demonstration that style capture had become free. What it didn't demonstrate was ownership.

Anyone can pull a look off an image now, for about 4 cents, in 4 seconds. The scarce thing is a style you can still apply in a year, across a model you haven't heard of yet, and prove is yours in the sense that matters commercially: consistent, documented, and not borrowed from someone who'd recognise it. That's a filing problem more than a generation problem. The tools solved the hard half and left you the boring half.

FAQ

How do you steal a style from any image?
Two ways. Either point a vision model at the reference and have it write a structured description of the technique, palette, lighting and surface, which you then reuse as text, or feed the image directly to a generator that supports reference conditioning, like Midjourney's --sref, Recraft's custom styles or Google's Nano Banana. Text is more portable. Reference images are more accurate today.

Is it legal to copy an art style with AI?
Style itself isn't protected by copyright in the US or the EU, because it counts as an idea rather than an expression. Copying specific works, imitating trade dress, or using a real person's likeness are separate matters that can still create liability. The US Copyright Office also confirmed in January 2025 that purely AI-generated output isn't copyrightable, so you may not own the result.

What's the cheapest way to reuse a style across many images?
Reference conditioning through a hosted API. Google's Nano Banana costs about $0.039 per 1024px image and Nano Banana 2 Lite about $0.034, while OpenAI's gpt-image-1 runs from $0.011 to $0.25 depending on quality and size. Training a style LoRA is a larger upfront cost, around $2.50 for a 1,000-step Flux Kontext batch on fal.ai.

Why does my AI style keep changing between generations?
Usually version drift. Style codes and saved styles are pinned to a specific model version, so a vendor update changes what they produce. Midjourney codes created before June 2025 need --sv 4 to look the way they originally did, and OpenAI's gpt-image-1 is scheduled for deprecation on 23 October 2026. Keep a written style spec as your backup copy.

How do I know whether the style actually transferred?
Run 3 checks. Generate the same subject with and without the style and confirm they differ. Apply the style to a subject the reference never contained. Then compare output and reference for shared objects or poses, which indicate content bleed rather than style transfer. Automated metrics like CSD and CLIP help but aren't reliable as absolute scores.

The look was never the hard part

Those millions of Ghibli portraits are gone. Not deleted, just unrepeatable, because nobody wrote anything down.

Style capture is solved and free. Style ownership is filing, testing and a note about which model version made the thing. Write the spec, save the code, run the 3 checks on 4 images, and record the date. Do that once and you have a style. Skip it and you have a screenshot.

Pick your best-performing image from the last month and reverse-engineer it into a spec this week. It's the one you already know works.

Ready to try it? JammyJar turns a reference image into a saved theme you can point at any of its models.