What is Stable Diffusion Explained for Beginners in 2026

Last Tuesday, I watched my 14-year-old nephew type “a cyberpunk samurai riding a neon motorcycle through Tokyo rain” into an app on his laptop and get a stunning, high-quality image back in about 10 seconds. Three years ago, that would’ve cost you money, required technical knowledge, and taken several minutes. That’s Stable Diffusion, and it’s now the democratized backbone of how millions of people create images with AI. If you’ve wondered what this technology actually is, how it works, and whether you should care about it, this guide is exactly what you need.

Understanding What Stable Diffusion Actually Is

Stable Diffusion is an AI model that converts text descriptions, called prompts, directly into images. You type what you want to see, and it generates it for you. Think of it less like a search engine finding existing images and more like having an invisible artist who’s trained on billions of images and can paint what you describe in seconds.

The model is open source, meaning anyone can download it, run it, and modify it. This is fundamentally different from closed services like DALL-E 3 or Midjourney, where you’re essentially renting access to someone else’s computers. With Stable Diffusion, you can actually own the technology and run it locally on your own machine.

It was developed by CompVis, a research group, in partnership with Stability AI and other organizations. The first version launched in August 2022, and we’re now in 2026 with multiple iterations that are significantly better. The latest versions, like SDXL 1.0 and the newer models, produce photorealistic images that honestly rival commercial tools in most use cases.

The “stable” part of the name refers to how the model works architecturally, not that it never crashes. I’ve had plenty of runs where the output was unusable, but generally speaking, the outputs are consistent and reliable.

How Does Stable Diffusion Actually Work? The Real Mechanics

I’ll be honest: the full technical explanation involves diffusion processes, latent spaces, and autoencoder mathematics. But you don’t need to understand quantum physics to drive a car, so let me break this down practically.

The core concept is this: Stable Diffusion uses something called a “latent diffusion model.” Basically, it starts with complete noise, like TV static. Then, guided by your text description, it gradually removes that noise, step by step, until a coherent image emerges. It’s like watching a photograph develop in a darkroom, but it’s all happening in mathematical space inside a computer.

The model has different components working together. First, there’s an encoder that breaks down images into a compressed mathematical representation. Then there’s the actual diffusion process, where noise gets progressively removed while being steered by your text prompt. Finally, there’s a decoder that converts that mathematical representation back into an actual image you can see.

The text prompt gets processed by another AI component called a text encoder, which converts your words into mathematical vectors that the model understands. So when you write “a red car,” the model doesn’t read English words, it reads mathematical representations of “redness,” “car-ness,” and so on.

This happens in what’s called “latent space,” which is essentially a compressed, mathematical representation of images rather than the full pixel data. This is why it’s faster than methods that work directly with pixels. Instead of generating millions of pixel values, it’s working with a much smaller mathematical space.

Why Stable Diffusion Changed Everything for Creators

Before Stable Diffusion, AI image generation was locked behind closed doors. DALL-E existed but required credits you had to buy. Commercial tools cost money and ran on someone else’s servers. If you’re a concept artist, designer, or content creator, you were either paying subscription fees or using lower-quality, older models.

Stable Diffusion’s open-source nature meant developers immediately built free tools on top of it. Automatic1111’s WebUI became the standard interface for running it locally. ComfyUI offered more advanced control. Hugging Face became a hub for community models. Within months, you had dozens of free tools and thousands of custom models trained on specific art styles, characters, or aesthetics.

The price question is important. Running Stable Diffusion on your own computer costs literally nothing except electricity. A high-quality GPU like an RTX 4060 costs about 250 to 300 dollars and will generate images for years. Compare that to Midjourney at 20 dollars a month or DALL-E 3 at 15 cents per image.

The speed is another game-changer. On decent hardware, you’re getting images in 10 to 30 seconds, which is comparable to or faster than commercial alternatives. I regularly generate 20 to 30 test images in an hour for concept work, and it would cost me 3 to 5 dollars in API credits with other tools.

For professionals, this means you can iterate incredibly fast. Need 50 variations of a scene for a commercial shoot? Generate them all locally without worrying about credit costs. That’s economically game-changing for freelancers and small studios.

Getting Started: Installation and Running It Yourself

If you want to run Stable Diffusion locally, you’ll need decent hardware. The absolute minimum is a GPU with at least 6GB of VRAM. Nvidia cards work best, though AMD cards work too. On my RTX 4070, generating a 512×512 image takes about 8 seconds. On a 6GB card, the same operation takes closer to 30 seconds.

CPU-only generation is possible but painfully slow. We’re talking 5 to 10 minutes per image. It’s technically viable but not practical for actual work. If you have an older gaming laptop with a GPU, that’ll probably work fine for experimentation.

The easiest way to get started is downloading Automatic1111’s WebUI, which has a simple installation process. There’s usually a one-click installer for Windows. On Mac, it’s a bit more involved but still straightforward. On Linux, it depends on your setup, but the community is helpful.

Once installed, you launch the application, and you get a web interface in your browser. You type your prompt, adjust some settings, and click generate. That’s genuinely it. The complexity comes later when you start tweaking parameters, using control nets, or training custom models.

If you don’t want to deal with installation at all, there are online services that run Stable Diffusion on their servers. Replicate offers API access cheaply. RunwayML provides a nice interface. These aren’t free, but they cost a fraction of Midjourney, usually 1 to 5 dollars for hundreds of generations.

Understanding Prompts: The Art and Science of Telling AI What You Want

Here’s something that surprised me when I first started using Stable Diffusion: the quality of your image output is directly tied to how specifically you describe what you want. Vague prompts create vague images. Detailed prompts create detailed images.

A bad prompt: “a car.” A good prompt: “a sleek red sports car, low angle, dramatic cinematic lighting, photorealistic, shot with a 50mm lens, shallow depth of field, professional photography.”

The difference is night and day. The second prompt gives the model specific instructions about style, angle, lighting, and technical parameters. It knows exactly what you’re after.

Effective prompts include several components: the main subject, the art style, lighting conditions, camera angle, composition details, and quality keywords. You don’t need all of them every time, but more information generally means better results.

There’s a psychology to prompt writing that I’ve learned through three years of daily use. Words matter. “Cinematic” pushes the model toward movie-like imagery. “Photorealistic” makes it aim for camera-quality images. “Painted” or “digital art” shifts toward stylized results. “Hyperdetailed” makes it add more texture and complexity.

Negative prompts are equally important. These tell the model what NOT to include. I almost always add “blurry, low quality, artifacts, deformed hands” to my negative prompt because Stable Diffusion, particularly older versions, sometimes struggled with hands and blur artifacts.

One honest limitation: Stable Diffusion doesn’t understand complex instructions as well as human artists do. If you ask for “a person reading a newspaper while sitting in a café,” it might place the newspaper incorrectly or make the hands weird. It’s gotten better with newer versions, but you’ll still encounter strange compositional errors sometimes.

Different Versions and Models: SDXL and What’s New in 2026

Stable Diffusion 1.5 was the workhorse model for years. It was smaller, faster, and could run on limited hardware. But its outputs were noticeably lower quality than commercial alternatives, especially at generating text within images or producing photorealistic results.

SDXL 1.0 changed everything. Released in 2023, it’s nearly three times larger than SD 1.5, and the quality jump is dramatic. Images look significantly more detailed and realistic. It handles complex prompts better. Text generation within images improved substantially. The tradeoff is it requires more VRAM, usually 12GB or higher for comfortable operation.

By 2026, we’re seeing refinements and specialized models built on top of SDXL. There are turbo versions that sacrifice some quality for speed, finishing generation in 3 to 4 seconds instead of 20. There are distilled models, variations trained on specific art styles, and models optimized for particular use cases like portrait generation or product photography.

The community has created thousands of custom models, called LoRAs and checkpoints, trained on specific aesthetics. Want anime-style images? There’s a model for that. Want photorealistic dogs? Someone’s trained a model on thousands of dog photographs. Want images in the style of specific artists? There are models for that too.

This is where Stable Diffusion’s open-source nature really shines. The experimentation happening in the community is incredible. New techniques get released weekly. Someone figures out a way to improve image quality, posts it on GitHub, and within days, dozens of interfaces and tools have integrated it.

Real-World Applications That Actually Work

I use Stable Diffusion for concept art, marketing visuals, and social media content. The practical reality is that it’s exceptional for some applications and completely inadequate for others.

Concept art is where it genuinely excels. Need 30 variations of what a futuristic building might look like? Generate them in 10 minutes. Need to explore different lighting conditions for a scene? Generate 10 versions with different lighting keywords. It’s a brainstorming tool that dramatically accelerates the ideation phase. I use it for every client project to explore directions before committing time to human artists.

Marketing visuals and social media graphics work well too. When I need generic lifestyle imagery, background scenes, or stylized illustrations, Stable Diffusion is fast and effective. A 1000-image ad campaign that would’ve cost 5000 dollars in stock photography or commissioning now costs me time and electricity.

Product visualization is practical but requires specific techniques. If you’re designing products and want to visualize them in different environments, it’s better than photography but requires detailed prompts and sometimes additional tools like control nets to maintain consistency.

Where it struggles: text within images, hands and complex anatomy, specific faces and identities, maintaining consistency across multiple images of the same subject, and technical diagrams. If your project requires consistent character appearance across 50 images, you’ll need workarounds. If you need readable text in images, prepare to regenerate multiple times.

For commercial photography replacement, it’s still not there. If you need actual product shots for e-commerce, professional photography still wins. If you need headshots of actual people, hiring a photographer is still the professional standard. The tech is getting closer, but we’re not quite at “replace all human creators” territory.

Comparing Stable Diffusion to Other AI Image Tools

DALL-E 3 is proprietary, runs on OpenAI’s servers, and costs 20 cents per image at 1024×1024 resolution. The quality is genuinely excellent, and it handles text in images better than Stable Diffusion. The downside is ongoing costs and you don’t own the technology.

Midjourney costs 20 dollars monthly for a subscription or 10 dollars per 200 generations if you buy credits. The image quality is outstanding, particularly photorealistic outputs. Many professionals use it as their primary tool because the results are reliable and the interface is simple. But again, you’re renting access, and your images aren’t generated locally.

Adobe’s Firefly is integrated into Creative Cloud for subscribers. It’s solid but not as advanced as SDXL yet. It’s convenient if you’re already in Adobe’s ecosystem, but it doesn’t match dedicated tools.

Runway ML is really a video-first tool now, though they have image generation. Their strength is AI video, not image quality.

Google’s Gemini Image Generation was recent, but I haven’t seen it match SDXL’s consistency or quality. It’s still developing.

The honest breakdown: if you’re willing to spend money and want the most reliable, highest-quality results with the least setup, Midjourney is probably your answer. If you want to own your technology, never pay per image, and are willing to spend time learning and tweaking, Stable Diffusion is unmatched in value. If you’re a professional needing photorealism and fine control, DALL-E 3 or Midjourney at higher resolutions still edge out SDXL.

For beginners specifically, I’d recommend trying Midjourney’s free trial first. It’s the easiest way to understand what AI image generation can do without technical setup. Then if you want to dive deeper and save money long-term, explore Stable Diffusion.

Control Nets and Advanced Techniques That Actually Work

One of Stable Diffusion’s killer features is something called ControlNet, developed by community members. This lets you provide the model with a reference image that constrains its output.

For example, you can give it a sketch, and the model will generate a fully rendered image based on that sketch while following your text prompt. You can provide a pose reference photo, and it’ll generate a new image in that exact pose. You can provide a depth map to control composition and perspective.

This is genuinely powerful for workflows. I use sketch-to-image ControlNet constantly for architectural visualization. I sketch out roughly what I want, upload it, and the model generates a fully rendered version matching my composition. This would take hours with Photoshop brushes but takes minutes with ControlNet.

There’s also Inpainting, where you mask out part of an image and ask the model to regenerate just that section. If hands look wrong, mask the hands and regenerate. If a background looks odd, replace it. This is game-changing for iterative refinement.

Image-to-image is another technique where you upload a reference image and ask the model to transform it. You can adjust the strength parameter to control how much it changes. Low strength keeps the composition and colors similar but increases details. High strength creates something entirely new inspired by the input.

These advanced techniques require learning the tools, but they genuinely expand what’s possible. The WebUI supports all of them, though the learning curve is real.

Training Custom Models: When and Why

If you have specific visual needs, you can train custom models on your own data. This is called fine-tuning, and there are different approaches.

LoRA training is the most accessible. LoRA stands for “Low-Rank Adaptation,” and it’s basically creating a small add-on to the base model that captures specific visual characteristics. You provide 5 to 50 images of whatever you want the model to understand, run a training process that takes 20 to 60 minutes on decent hardware, and you get a LoRA file you can use with the base model.

I’ve trained LoRAs on architectural styles, product designs, and specific client aesthetics. Once trained, you add it to your prompt, and every image you generate follows that style. It’s incredibly useful for maintaining brand consistency.

Full model fine-tuning is more complex and requires more data and computational resources. You’re essentially retraining a significant portion of the model. Unless you have 200+ images and specific needs, LoRA is probably sufficient.

The practical reality: training is worth doing if you have a repeating need for visual consistency across many generations. If you’re doing one-off projects, the time investment isn’t worth it.

Common Mistakes to Avoid

The biggest mistake beginners make is assuming Stable Diffusion can read their mind. You need to be specific. “A nice landscape” generates trash. “A misty mountain valley at sunset with dramatic lighting, photorealistic, 4K” generates something you can actually use.

Using generic prompts from prompt databases is another common error. Those prompts are designed for specific models or versions. A SDXL prompt will often fail in Stable Diffusion 1.5. A prompt that worked perfectly last year might not work the same way with a new model. Always adapt prompts to your specific setup.

Not using negative prompts is a mistake. That’s like painting without an eraser. Negative prompts are free ways to prevent common issues. I virtually never generate without including common artifacts in my negative prompt.

Ignoring image seeds is something I see constantly. Seeds determine the randomness. If you generate something you like and want variations, using the same seed but adjusting other parameters gives you related outputs. Ignoring seeds means you’re starting from scratch every time.

Trying to use free tier online tools without understanding limitations. Many free services severely restrict generation frequency or quality. You’ll get frustrated thinking Stable Diffusion is bad when really you’re using a throttled version.

Expecting it to handle complex requests like “a specific person doing something specific in a specific location” consistently. The model struggles with complex scene instructions. Keep requests focused for reliability.

Not experimenting with different models for different tasks. Some models are better for photorealism, others for anime, others for oil painting style. Trying to use one model for everything is inefficient.

The Honest Limitations You’ll Actually Encounter

Stable Diffusion is incredible technology, but it’s not magic. There are real limitations that matter depending on your use case.

Text generation within images is significantly improved but still unreliable. If you need readable text in your generated images, expect to regenerate multiple times. The model often inverts letters, creates nonsensical characters, or places text in impossible ways. DALL-E 3 is genuinely better at this.

Hands and feet are notoriously difficult. While they’ve improved dramatically since 2022, weird, distorted, or extra fingers still appear frequently. You’ll use the inpainting tool to fix hands constantly.

Faces with specific identities are unreliable. You can’t generate consistent images of a specific person reliably unless you use LoRA training with lots of reference images. This is also an ethical and legal minefield you need to consider.

Complex compositions with multiple subjects sometimes fail. The model gets confused about spatial relationships. If you ask for “five people in a meeting room,” you might get six people, or people partially merged together, or the meeting room missing entirely.

Consistency across multiple images is difficult. If you generate image 1, then want image 2 to match its style, composition, and characters, that requires specific techniques and often manual adjustment.

Understanding scale and proportion is still imperfect. A person standing next to a building might be too large or too small, or the proportions might be mathematically wrong. The model is improving at this, but it’s not solved.

And honestly, sometimes it just produces ugly images. There’s randomness involved. You might generate 10 images before getting something usable. That’s not a bug, it’s just how the technology works currently.

The Legality and Ethics Conversation

Stable Diffusion was trained on a dataset called LAION-5B, which contains billions of images scraped from the internet. This created legal uncertainty. Some artists argue their work was used without permission to train a model that competes with their labor. Lawsuits are ongoing as of 2026.

This is a genuine ethical concern worth thinking about. If you generate images using Stable Diffusion, you’re using technology trained on potentially copyrighted work without explicit permission. That said, the output images are yours, and copyright law currently doesn’t prohibit using AI tools to create derivative works in most jurisdictions.

Using Stable Diffusion to generate realistic images of real people without consent is ethically and legally problematic. Don’t do it. Using it to generate images of specific real people and spreading them as real is potentially defamatory.

For commercial use, check your specific jurisdiction’s laws and your insurance. Most commercial uses are fine, but large corporations increasingly have policies about AI-generated content, particularly if it’s used to replace human creators in ways that seem exploitative.

The practical reality: use Stable Diffusion as a tool to augment human creativity, not replace human creators. Use it for exploration and ideation, not to put artists out of work. That’s both ethically sound and practically better for the quality of the work.

System Requirements and Hardware Recommendations

For running Stable Diffusion locally, you need a GPU. An older GPU like an RTX 2080 or RTX 3070 will work, but generation is slow. A newer GPU like an RTX 4070 or RTX 4080 is comfortable, generating 512×512 images in 8 to 15 seconds.

If you want to run SDXL comfortably, plan on 12GB of VRAM minimum. That means a RTX 3080 Ti, RTX 4090, RTX 4080 Super, or equivalent. These cards cost 500 to 1500 dollars. If you want to run it on a budget, you can use an RTX 4060, which costs about 250 dollars and has 8GB of VRAM, though you’ll need to use optimization techniques to run SDXL.

AMD cards work but require some additional setup. The software support is less mature than Nvidia, but it’s viable. Intel Arc GPUs work too, though they’re slower than equivalent Nvidia cards.

If you have an older computer without a good GPU, you can rent GPU time. Google Colab offers free GPU access if you run code in their environment. Paperspace and Lambda Labs offer cheap GPU access, usually 0.30 to 0.50 dollars per hour.

The electricity cost is real but small. A powerful GPU might use 250 to 400 watts under full load. If you generate 50 images daily, that’s maybe 20 to 40 kilowatt-hours monthly, costing 2 to 5 dollars depending on your electricity rates.

Storage is another consideration. Models take up space. A base SDXL checkpoint is 5 to 7 GB. LoRAs take 50 to 500 MB each. If you download dozens of models and LoRAs, you’ll need 50 to 100 GB of storage. SSDs are cheap, so this isn’t really a limiting factor anymore.

Setting Up Your First Local Installation

I’ll walk you through this because it’s genuinely simpler than most people think.

First, make sure you have Python installed. On Windows, grab Python from python.org, version 3.10 or 3.11. During installation, check “Add Python to PATH.” This is important.

Next, download Automatic1111’s WebUI from the GitHub repository. You’ll find a link on their releases page. It’s just a zip file. Extract it to a folder somewhere you’ll remember, like your Documents folder.

Inside that folder, you’ll see a batch file on Windows called “webui-user.bat.” Double-click it. This will launch the installation process. The first time you run it, it’ll download dependencies and the base model. This takes 10 to 30 minutes depending on your internet speed.

Once installation completes, it’ll print a URL, typically “http://127.0.0.1:7860.” Paste that into your browser. You’ll see the WebUI interface. At this point, you’re ready to generate images.

Start with the default settings. Type a prompt, hit generate, and wait. Your first image might take a minute or two as everything initializes, but subsequent images will be faster.

Once you’re comfortable, explore the settings. Sampling steps, guidance scale, and checkpoint selection are the key parameters that affect output. The WebUI has built-in help, so hover over settings to understand them.

Building Workflows and Integrating Into Creative Process

Using Stable Diffusion effectively requires integrating it into your actual creative process, not using it as a gimmick.

For concept work, I use it early in the process. Before commissioning a human artist, I generate 20 to 50 variations exploring different directions, lighting, composition, and style. This costs me 10 to 20 minutes and electricity. Then I pick the best directions and commission human artists to refine them. This is faster and cheaper than describing what I want verbally.

For social media, I use it for generic lifestyle imagery and stylized graphics. Real lifestyle photos are still better, but when you need something quick or specific, generation is practical.

For client presentations, I generate mockups showing how a design would look in context. A product rendered in a lifestyle context, or a design shown in an environment. This helps clients visualize what they’re approving before committing resources.

For personal projects, I just experiment. Sometimes I spend an hour generating variations of weird ideas just to see what the model does with them. It’s genuinely fun.

The key is using it strategically. It’s not a replacement for planning, creativity, or human artists. It’s a tool that accelerates certain parts of creative work. The best creative outcomes I’ve seen combine human direction with AI generation, then human refinement.

Final Thoughts

I’ve been using Stable Diffusion daily for three years, and my perspective is this: it’s the most important creative technology released in the last decade. Not because it replaces human creativity, but because it democratizes certain aspects of visual production in ways that are genuinely game-changing.

A freelancer with limited budgets can now explore ideas that would’ve required hiring expensive concept artists. A small marketing team can generate product visuals without a photographer. Educators can create custom educational materials. Artists can explore styles and techniques they couldn’t otherwise afford to experiment with.

The limitations are real. It’s not ready to replace professional photography, illustration, or artistic direction. It makes mistakes constantly. It’s biased in ways we’re still discovering. The ethics around training data remain unresolved.

But the trajectory is clear. Every month, new techniques improve quality. Every update handles complex prompts better. Every release makes it more accessible. By 2026, it’s genuinely useful technology, not a novelty.

My honest recommendation: if you’re curious, spend an afternoon learning it. Download the WebUI, generate 50 images, explore what it can and can’t do. It costs nothing except time. You might find it useless for your work, and that’s fine. Or you might find it unlocks creative possibilities you couldn’t explore before. Either way, you’ll understand the technology better than 95% of people talking about it online.

Frequently Asked Questions

Do I need to pay anything to use Stable Diffusion?

Not if you run it locally on your own computer. The software is free, open source, and you own your hardware. However, you do need a decent GPU, which costs money upfront. If you don’t have or want to buy hardware, you can use online services like Replicate that charge per generation, usually a fraction of a cent per image. Completely free tier options exist but are usually limited or slow.

Can I use Stable Diffusion to generate images of real people?

Technically yes, but ethically and legally, there are significant issues. Generating realistic images of real people without consent is problematic. Using AI-generated images of real people and presenting them as real is potentially defamatory. I’d strongly recommend avoiding this use case unless you have explicit consent and are being transparent about the AI involvement.

How does Stable Diffusion compare to hiring a human artist?

Fundamentally, they serve different purposes. Stable Diffusion is fast, cheap, and good for exploration and iteration. Human artists bring creativity, understanding of intent, and the ability to handle complex or subjective requests. The best approach is often using AI for ideation and mockups, then hiring human artists for final execution and refinement. They complement each other rather than competing.

Can I use Stable Diffusion images commercially?

Yes, generally you can use the images you generate commercially. However, check the specific license of the model you’re using and any custom models you incorporate. Also consider your jurisdiction’s laws around AI-generated content. Some organizations have policies restricting AI-generated imagery in their workflows. For high-stakes commercial work, it’s worth checking with a lawyer about your specific use case.

How long does it take to generate an image?

On modern GPUs like an RTX 4070, generating a 512×512 image takes 10 to 30 seconds. Larger images take longer. SDXL takes longer than Stable Diffusion 1.5. The first image takes longer because the model needs to load into memory. After that, subsequent images are faster. Online services might take 10 to 60 seconds depending on queue time.

What’s the difference between LoRA and checkpoints?

Checkpoints are complete model files containing all the weights and parameters needed for image generation. They’re usually 5 to 7 GB. LoRAs are small addition files, usually 50 to 500 MB, that modify how the base model behaves. You load a checkpoint as your main model, then add LoRAs on top to adjust the output. Think of checkpoints as complete recipes and LoRAs as flavor modifications.

Can Stable Diffusion replace professional photography?

Not currently, and probably not for years. AI generation is fantastic for product mockups and conceptual imagery, but for professional-grade photography with specific lighting, composition, and human presence, professional photographers still produce better results consistently. The gap is closing, but it’s not closed yet. I’d use Stable Diffusion for exploration, not for final commercial photography.

What should I include in my negative prompt?

Common problematic elements include “blurry,” “low quality,” “artifacts,” “deformed,” “extra fingers,” “extra limbs,” and “worst quality.” You should tailor your negative prompt based on the specific generation. If you’re generating a portrait, add “bad anatomy.” If you’re generating a hand, add “extra fingers.” The more specific your negative prompt, the better your results.

Can I train Stable Diffusion on my own images?

Yes, through LoRA training. Provide 5 to 50 images of what you want the model to understand, run the training script for 20 to 60 minutes, and you get a LoRA file. Then you can use that LoRA in your prompts. This is how people create models for specific art styles, character designs, or aesthetics. It’s accessible and doesn’t require deep technical knowledge anymore.

What’s the best online service if I don’t want to run it locally?

Replicate is probably the best balance of price and quality. You pay per image, usually 0.01 to 0.05 dollars per generation depending on the model. RunwayML is good if you also need video tools. For absolute lowest cost once you account for overhead, I’d still recommend running locally if you have or can get hardware, but if that’s not feasible, Replicate is the practical choice.