Imagine having your own version of ChatGPT or DeepSeek running entirely on your personal computer. The data is stored on your device — no subscriptions, no cloud servers, no third-party access. Just a fully independent, private, and customizable AI assistant.

This is the idea behind local language models. Several tools make this possible, including **Ollama**, **vLLM**, and **GPT4All**. In this article, we’ll focus on the latter: what GPT4All is, how it works, and why it might become your go-to solution for private AI.

## How Text-Based Neural Networks Work

At the heart of every AI tool that processes text is a **Large Language Model (LLM)**, a neural network designed to function as a kind of general linguistic intelligence. These models are capable of:

- holding natural conversations; 
- analyzing data, drawing conclusions, and suggesting solutions; 
- explaining complex concepts in simple terms; 
- translating or adapting text to different tones and styles; 
- generating, reviewing, and commenting on code.

Popular examples include the already-mentioned **ChatGPT** and **DeepSeek**, as well as **Claude**, **Qwen**, and **xAI (Grok)**, among others.

## How Local LLMs Differ from Cloud-Based Ones

The biggest advantage of cloud-based models is that all the heavy computation is conducted on the provider’s servers. Users only need a browser or an API key to access them. However, this convenience comes with trade-offs:

- **Internet dependence.** No network connection means no AI. The model simply won’t run offline. 
- **Usage limits.** Cloud services often cap the number of requests, data size, or speed — especially in free tiers. 
- **Privacy risks.** Every query goes through external servers, which can be a major concern for anyone handling sensitive data.

**Local LLMs** take the opposite approach. They’re smaller and optimized for full offline operation. Some of their key strengths include:

- **Self-sufficiency.** They run directly on your computer, independent of internet access, pricing tiers, or server queues. 
- **Privacy.** All inputs and outputs are stored on the device. Nothing is sent to the cloud. 
- **Flexibility.** You can switch between models for different tasks or connect your own knowledge bases.

For businesses, local LLMs mean more **control**, **security**, and **autonomy**. For developers, these may serve as a **playground for experimentation** — testing hypotheses, building prototypes, or processing documents without external limits or hidden costs.

## What Makes GPT4All Useful

**GPT4All** is a full-fledged ecosystem for working with local language models. Think of it as an “[**Amuse**](https://pixcraft.io/blog/stable-diffusion-how-to-deploy-an-ai-image-generator-on-your-computer) for text”: not merely a raw engine, but a polished platform that makes interacting with AI smooth, flexible, and efficient.

The app allows you to:

- **Install and run different models,** from lightweight options to more advanced ones. Simply pick a language model from the catalog, download it, and start chatting. 
- **Work using an intuitive interface.** It’s as easy as “load the model and ask a question”. 
- **Use your own documents** to get responses based directly on their content.

## How to Install GPT4All

Setting up GPT4All is quick and straightforward. Simply download the installer, run it, and complete a short setup process.

**1. Go to the** [**official website**](https://www.nomic.ai/gpt4all) and choose the version for your operating system: Windows (`.exe`), macOS (`.dmg`), or Ubuntu (`.run`).

**2. Install and launch the application.** GPT4All automatically creates a working directory where it stores models, chat history, and settings.

**3. Download a language model** from the **Models** section or through the **Find Models** option on the main screen. Once downloaded, it will appear in the **Installed Models** library.

<Img
img="/api/uploads/01_ustmodel_e3f4df5815.png"
alt="Installed models in GPT4All"
/>

**4. Start the chat.** As with many cloud-based models, a prompt input field is located at the bottom, with the conversation window above it.

<Img
img="/api/uploads/02_dialexmpl_13c8034ecf.png"
alt="Dialog window in GPT4All"
/>

The **GPT4All** tab in the **Explore Models** section offers a catalog of models optimized for local use. Many of them run smoothly on standard CPUs; no dedicated GPU required.

<Img
img="/api/uploads/03_mdlctlg_fe56a7a2c5.png"
alt="Model catalog in GPT4All"
/>

It’s also possible to browse for additional LLMs on **HuggingFace** through a dedicated tab. However, the developers note that external models **aren’t guaranteed to work**, and many of them will require extra adjustments.

<Img
img="/api/uploads/04_mdlsrch_8d7934be7f.png"
alt="LLM search"
/>

GPT4All can also connect to **external cloud APIs** such as **OpenAI**, **Groq**, **Mistral**, and other OpenAI-compatible services. Though in that case, responses are generated remotely. Before enabling this feature, make sure it aligns with your privacy and data-handling policies.

## Which Models Are Available for GPT4All

The GPT4All catalog includes a wide selection of language models. Some are lightweight and run comfortably on modest hardware, while others demand more resources but offer performance closer to cloud-based LLMs. Your best choice depends on the task at hand and your computer’s specs:

- **Up to 4B parameters.** The fastest and most lightweight models, great for short prompts or quick notes. Examples include Qwen2-1.5B-Instruct and Llama 3.2 1B / 3B Instruct. 
- **Around 7–8B parameters.** Require more power but offer a solid balance between speed and output quality. Examples include GPT4All Falcon and Reasoner v1. 
- **13B parameters and above.** Resource-demanding, but capable of deeper reasoning and more coherent responses. Examples include Hermes and Snoozy.

Below are some of the most popular LLMs available in GPT4All, along with their strengths and limitations based on user feedback.

### GPT4All Falcon

A very fast model based on Falcon and finetuned by Nomic AI. Simple, versatile, and perfect for exploring what the app can do.

- **Strengths:** fast response speed with moderate hardware requirements. 
- **Weaknesses:** limited reasoning depth, tends to produce generic answers.

### Llama 3 Instruct

A modern, flexible model from the Llama 3 family. Well-suited for open-ended chats, Q&A, and general text generation or analysis.

- **Strengths:** runs smoothly even without a GPU; produces logical, natural-sounding responses. 
- **Weaknesses:** weaker reasoning compared to larger models; may lose context in longer conversations; performance varies depending on the version and quantization level.

### DeepSeek R1 Distill Qwen 7B / 14B

These models are distilled versions of DeepSeek R1. The 7B model, based on Qwen2.5-Math, is optimized for analytical and logical tasks, while the 14B model is more general-purpose, offering deeper reasoning and more natural language output.

- **Strengths:** suitable for step-by-step reasoning, analysis, and problem-solving; the 14B version provides richer, more precise answers. 
- **Weaknesses:** the 7B version struggles with longer reasoning chains, while the 14B model requires substantial resources (at least 16 GB of VRAM).

### Reasoner v1

An experimental model focused on reasoning and code-related work. It doesn’t just output answers but performs the logical steps to reach them.

- **Strengths:** can analyze, infer, and test hypotheses; includes a built-in JavaScript interpreter. 
- **Weaknesses:** may sound too formal or technical in casual conversations.

### Mistral Instruct

One of the most popular mid-sized models. Trained to follow instructions precisely, answer questions clearly, and produce structured, coherent text.

- **Strengths:** consistent, well-organized responses with a good balance between quality and performance. 
- **Weaknesses:** not ideal for highly technical or deeply logical tasks compared to larger models; may lose context or oversimplify reasoning; output quality depends strongly on prompt design.

### Orca 2

Developed by Microsoft, this model emphasizes reasoning and step-by-step analysis. It’s intended as a compact alternative to large-scale LLMs.

- **Strengths:** handles logical and analytical problems effectively, producing clear and structured reasoning. 
- **Weaknesses:** optimized for single-turn responses rather than extended dialogue; performance may vary depending on topic and prompt phrasing.

## How RAG Enables Working with Your Own Documents

While large language models can process enormous amounts of data, there’s still one crucial limitation: **they only “know” the information they were trained on**. If a model isn’t familiar with your internal documents, policies, or manuals, it can’t reference them in its responses.

That’s where **RAG**, or **Retrieval-Augmented Generation**, comes in. This method combines two steps:

- **Retrieval:** finding relevant information from your own sources. 
- **Generation:** producing an answer based on that retrieved content.

With RAG, you can connect your own files, knowledge bases, or internal documentation, allowing the model to generate answers based on your data. For example, if an employee asks, “How do I correctly submit a vacation request?”, a system powered by RAG would:

**1.** Locate the document describing the process.

**2.** Extract the relevant section.

**3.** Send it to the model along with the query.

**4.** Generate a clear, accurate response based on that material.

The result is a context-aware answer built on your organization’s internal information, not just general knowledge.

In GPT4All, RAG functionality is provided through the **LocalDocs** feature, which lets you create collections of documents. Simply point the app to a folder, and it will automatically index all the files it contains.

When new files are added, GPT4All breaks them into small text fragments and generates **vector embeddings** — mathematical representations that capture each fragment’s semantic meaning.

<Img
img="/api/uploads/05_embdng_a97c0474ef.png"
alt="Embedding в LocalDocs"
/>

When a user submits a prompt, the system compares it to these vectors, finds the most relevant text pieces, and sends them to the model along with the original question. The model then formulates a response based on this retrieved material.

<Img
img="/api/uploads/06_diallocdocs_48d09e9dc6.png"
alt="Chat based on local documents"
/>

GPT4All supports text formats such as `.txt` and `.docx`, as well as PDF, and Markdown (`.md`). It’s important to keep text clean and well-formatted, for instance, by removing redundant Markdown symbols or formatting code. The clearer the content, the more accurate the retrieval and the final response will be.

## Using GPT4All as a Local API Server

In addition to its desktop interface, GPT4All can also run as a local API server. This is especially useful if you want to integrate a local model into your company’s workflows, such as to automate text generation, document processing, or internal data analysis.

To enable the API server, follow this path: 

**Settings → Application → Advanced → Enable Local API Server**

Once activated, the server becomes available at `http://localhost:4891/v1`. The number may vary depending on the chosen port.

<Img
img="/api/uploads/07_apion_46bb3d255b.png"
alt="Enabling API server in GPT4All"
/>

The LocalDocs feature can also be accessed through the API. Your files never leave your computer: the API simply passes the necessary text fragments to the model so it can generate a context-aware response. Keep in mind that while the API can use existing document collections, creating and indexing new ones must be done through the app interface.

## Conclusion

GPT4All puts the control over language models into your hands. It enables a truly personal form of artificial intelligence: one that runs locally, integrates into your digital workspace, and operates entirely on your terms, all without relying on cloud services, subscriptions, or external servers.

This article explores GPT4All — a tool that lets you run text-based AI models directly on your own computer. Learn how it works, what features it offers, and what makes it useful.

small_gptall_cover.png

thumbnail_gptall_cover.png

gptall_cover.png

Local AI Under Your Control: The Possibilities of GPT4All

Over the past few decades, email has come a long way — from simple text messages to visually rich newsletters filled with graphics, animation, and interactivity. Yet as content became more diverse, so did the demands on email layout and coding.

To make email crafting comfortable and efficient under modern conditions, we developed a dedicated **TJML framework**. In this article, we’ll take a closer look at how it works and what makes it stand out when compared to other email coding methods.

## Is Manual HTML Coding Still Relevant Today

Manual HTML coding was once the only way to achieve maximum control and precision in email design. However, the technologies evolved, which has also affected email clients; each of them has its own peculiarities and rendering rules.

Today, you need to keep numerous details in mind: how external styles behave, whether media queries work, and how tables and paddings are handled across different clients. Moreover, many people check their inboxes on smartphones, which means every email must also be adapted for vertical screens and mobile operating systems.

Basically, a single email has to be created in **three different versions**:

- for modern desktop and web clients; 
- for mobile devices; 
- for Outlook on Windows, where CSS support is still heavily limited.

AMP technology deserves a special mention. It has made interactive emails possible thanks to carousels, forms, and other dynamic components. But technically, this means that you must provide both an AMP version and a regular HTML version of the same message for those email clients that don’t support interactive components.

### Where Visual Builders May Come In Handy

In modern marketing workflows, it’s impossible to rely solely on manual coding. One of the alternatives is **email builders**: modern, user-friendly tools for creating email campaigns. They require no coding skills and let you design professional templates in just a few minutes.

For example, the [**Pixcraft visual email builder**](https://pixcraft.io/) allows you to assemble emails using a drag-and-drop interface: simply drag the desired elements onto the canvas and adjust them. Component management (including AMP) is available directly in the interface. The resulting templates are compatible with most email clients and easily adapt to mobile screens. One more option is the [**Pixcraft plugin for Figma**](https://www.figma.com/community/plugin/1403763341617358835/pixcraft-email-export-html-email-code-from-your-figma-design-responsive-outlook-gmail-ios), which can turn a finished design into a responsive HTML email.

Still, behind every message is a code that makes it work, and sometimes, editing it directly is inevitable. Can this process be just as convenient and modern? The answer is yes — with the help of TJML.

## What Is TJML

TJML is an email framework developed by the Pixcraft team for building HTML and AMP emails. It combines the simplicity of a block-based approach with the flexibility of manual coding, all while preserving familiar syntax.

A basic TJML email structure may look like this:

```xml
<tjml>
 <m-body>
 <m-wrap width="600">
 
 </m-wrap>
 </m-body>
</tjml>
```

Here’s what each component does:

- `<tjml>` — the root container that wraps the entire code; 
- `<m-body>` — the main body of the email containing all its content; 
- `<m-wrap>` — a wrapper responsible for width, padding, background, alignment, and other layout parameters.

To build multi-column layouts, TJML provides two types of content composition that determine how blocks behave on mobile devices:

- **Non-restructurable blocks.** Here, elements remain in a single row. The `<m-row>` component wraps `<m-column>` elements, which scale on mobile. 
- **Restructurable blocks.** These are `<m-box>` elements wrapped inside `<m-boxes>`. In mobile view, they automatically stack vertically if they no longer fit in one row.

These structures can be filled with content blocks such as text (`<m-text>`), images (`<m-img>`), buttons (`<m-button>`), and more. Please read the detailed [**documentation**](https://docs.pixcraft.io/en/tjml/) to learn more about all available components and attributes.

Here’s a simplified example of a TJML-based email:

```xml
<m-body bgcolor="#ffffff" font-family="Arial, sans-serif">
 <m-wrap width="600" padding="20px" bgcolor="#f9f9f9">
 <m-text font-size="20px" color="#333333" align="center">
 Hello! This email was created using TJML.
 </m-text>
 <m-button href="https://docs.pixcraft.io/en/tjml/" bgcolor="#6a66d3" color="#ffffff" border-radius="6px" width="200">
 Learn more
 </m-button>
 </m-wrap>
</m-body>
```

## What Makes TJML Special

### Code Editing Directly in the Browser

To start working with TJML, all that’s required is the online [**Playground**](https://app.pixcraft.io/playground/) editor. Here, you can code and preview your email in real time, toggle between desktop and mobile views, test dark mode, and inspect the generated HTML output.

<Img
img="/api/uploads/codeplgrnd_1286fc7955.png"
alt="Email created in Playground"
/>

TJML can also be used in any IDE of your choice. For extra comfort, we’ve also developed the following: 

- a special [**VS Code plugin**](https://marketplace.visualstudio.com/items?itemName=Pixcraft.vscode-tjml) that enables autocomplete and tooltips for all components and attributes; 
- [**web-types**](https://app.pixcraft.io/tjml/web-types.json) support for JetBrains products like WebStorm and PhpStorm.

### HTML and AMP in a Single Code

In a traditional approach, AMP and HTML versions of an email are built separately as two distinct templates. TJML simplifies this process by generating both versions simultaneously within the same markup.

If you want to show a specific block in one version only, you can use conditional rendering:

`<m-wrap m-if="isAmp">  </m-wrap>`

`<m-wrap m-if="!isAmp">  </m-wrap>`

TJML automatically includes all required AMP components (such as `amp-carousel`, `amp-form`, or `amp-list`) whenever they are used in the code.

### Rendering Across Email Clients

One of TJML’s main advantages is its smart approach to cross-client compatibility, including support for Outlook and Yandex Mail:

- The desktop **Outlook** email client uses a rendering engine that ignores modern CSS properties. TJML automatically inserts VML blocks and conditional comments to ensure correct display of backgrounds, alignment, and spacing (including in older versions). 
- **Yandex Mail**, on the other hand, doesn’t support media queries. TJML structures the layout in a way that preserves responsiveness even without them.

To put it simply, TJML eliminates the tedious routine of cross-client adaptation. Compatibility and rendering issues are handled at the framework level.

### Code Size Control and Optimization

In email marketing, message size is just as important as its content. For example, Gmail clips emails larger than **102 KB**, which may break layouts or affect tracking pixels.

TJML monitors the code size and warns you if it exceeds recommended limits. You can also use built-in optimization to remove unnecessary spaces, line breaks, and unused styles. The result is a lightweight, stable message that displays correctly and won’t be clipped by email clients.

### Error Checking and Typography

TJML continuously validates the email structure and nesting of `m`-elements. The framework alerts the user in case of any inconsistencies. In addition, it includes an automatic typograph, which inserts non-breaking spaces to prevent orphaned prepositions and conjunctions, ensuring the email looks clean not only technically but also visually.

## Pixel-Perfect Layout

To avoid discrepancies between the design mockup and final layout, TJML includes a **Pixel Perfect** tool. Simply upload a version of your design in a graphic format (e.g., PNG or JPG) and align it with your TJML template using this tag:

`<tjml pixel-perfect="img/mockup.png">`

After that, you may specify the offset and blending mode to visually compare the mockup and the email layout.

## Automating Email Creation with ChatGPT

To make the process of crafting TJML emails even easier, we came up with a [**special version of ChatGPT**](https://chatgpt.com/g/g-6823ad1f3c208191b9ce2d58bf3bb724-tjml) specifically for the framework. It can generate complete email layouts from a simple prompt: all you have to do is enter the description, and within seconds, you’ll receive a TJML code that can be customized to suit the requirements at hand.

<Img
img="/api/uploads/codechgp_de5b9f44d6.png"
alt="Email generation in a special ChatGPT version"
/>

Yet the functionality doesn’t end there. This ChatGPT version can also:

- **edit existing code** based on text instructions; 
- **explain how TJML works**, including the purpose of each tag and which attributes to use in different scenarios.

## Results and Efficiency

The framework has already proven itself in real-life production workflows and is ready for daily use.

For example, when TJML was implemented at a major Russian marketing agency, this showed a significant increase in productivity. Even for complex emails, coding speed improved by more than **50%**, and for AMP emails, the speed improved by **about 1.5×** without any loss of quality.

Another key metric is **code cleanliness and compactness**. In benchmark tests, an uncompressed TJML email weighed only about **13.5 KB**, compared to over **22 KB** for an equivalent created using [**MJML**](https://pixcraft.io/blog/email-frameworks-mjml-vs-tjml). Smaller size means faster loading times and a lower risk of clipping in Gmail.

One more major advantage is TJML’s **low entry barrier**. The framework lets you focus on the structure and design rather than worrying about technical adaptation for a variety of email clients. Combined with its **strong rendering stability**, TJML stands out as a reliable and efficient solution for professional email production.

## Conclusion

With TJML, the process of building email campaigns becomes fast, stable, and convenient. Quality control is ensured at every step, from the initial creative concept to the final delivery. For marketing professionals, this means less time spent on debugging and more time for content and creativity.

This article explains how TJML framework by Pixcraft simplifies email coding, what features make it even more convenient, and how to speed up the process using a special version of ChatGPT.

small_изображение1 (1).png

thumbnail_изображение1 (1).png

cov_pic_1.png

TJML Framework: How to Create Emails Quickly and Easily in 2025

Cloud-based AI image generators like **Midjourney** or **DALL-E** have already become widely-used tools. They are designed for ease of use, creating illustrations based on text prompts in just a few seconds. Their operation is simplified, but customization options are limited.

However, there is an alternative solution: **Stable Diffusion**, a flexible tool that you can deploy **on your own computer** and configure it to suit your needs. In this article, we will take a look at how Stable Diffusion works, what you need to pay attention to during installation, and how to achieve relevant, high-quality results.
## What is Stable Diffusion
Stable Diffusion is AI-based software that generates images using diffusion processes. Its architecture allows for creating illustrations in a wide variety of styles, from cartoonish to photorealistic.

But how does it differ from Midjourney or DALL-E? And is it really worth trying? Here’s what makes Stable Diffusion stand out:

- **Freedom and flexibility**. Stable Diffusion gives you full control over the image generation process. You can choose among different checkpoints (generation models), experiment with sampling algorithms, and fine-tune the style and quality of images.

- **Distributed free of charge**. Stable Diffusion is an open-source project. Unlike cloud solutions, you don’t have to wait in a server queue or pay for a subscription. The only potential limitation is the hardware requirements.

- **Less copyright restrictions**. Cloud services often impose restrictions on commercial use or editing of generated images. Many Stable Diffusion models don’t have such constraints, so you are free to use the generated illustrations, provided you comply with the license terms of the specific model.
## How Does the Image Generation Work
To put it simply, Stable Diffusion creates a random set of pixels and gradually “cleans” the noise, eventually turning them into an image. Here is how it works:

**1.** First, it generates “noise” that serves as the starting point for the process.

**2.** Then the noise is “cleaned” step by step. Colors, shapes, and recognizable objects begin to appear.

**3.** With each following step, the generated image aligns more precisely with the description.

<Img
img="/api/uploads/01_shagi_ad6cb3f4fc.jpg"
alt="Step-by-step image generation example"
src="Image generation steps for the “Cat on a sofa, white and gray fur” prompt"
/>

Image generation algorithm includes several key components:

- **Text Encoder**. Converts text prompt into an **embedding** (a numeric array). The embedding serves as a code that tells the software what exactly needs to be generated.

- **U-Net**. The main component responsible for iterative “denoising.” At each step, it assesses the current version of the image and determines how it should be adjusted to better match the prompt.

- **VAE (Variational Autoencoder)**. Converts the latent representation (a compressed, abstract “draft”) into a finished image. Different VAE versions are available for Stable Diffusion: some reproduce colors and textures better while others help generate more realistic or stylized images.
## How to Deploy Stable Diffusion
Stable Diffusion requires fairly powerful hardware to run smoothly. Here are the minimum recommended specifications:

- **Graphics Card**: at least 6GB of video memory, ideally 8GB or more (for example, NVIDIA RTX 2060, RTX 3060, or newer).

- **Processor**: a modern multi-core CPU. Although the GPU handles most of the workload, the CPU prepares and loads models.

- **RAM**: starting at 8–16GB. The more, the better.

- **Disk Space**: 10–30GB free space. More is recommended to store the software, checkpoints, and the required add-ons.

### Installation
The most popular and reliable interface for running Stable Diffusion is the **AUTOMATIC1111 Web UI**. It allows users to generate images directly in the browser via a user-friendly web interface.

To run it properly, first you need to install **Python** and **git**. After that, download the current version of AUTOMATIC1111 from the official [GitHub repository](https://github.com/AUTOMATIC1111/stable-diffusion-webui) and follow the step-by-step installation guide in the project documentation.
### For Users with AMD Graphics Cards
Owners of AMD graphics cards may encounter difficulties running Stable Diffusion since by default its models are optimized for **CUDA** (a parallel computing technology by NVIDIA). Although AMD offers an equivalent called **ROCm**, its official support is limited.

Still, it is possible to deploy AUTOMATIC1111 on PCs with AMD graphics cards. The simplest and most convenient way would be to use the [AMUSE](https://www.amuse-ai.com/) application. This is a graphical launcher for Windows PCs that supports various models and offers extensive settings and parameters (in professional mode).
## How to Generate Images Based on Descriptions
The core mode of Stable Diffusion is **text2img**. Here, the user provides a description and sets the desired parameters, after which the model processes the prompt and generates an image. Below are some of the key settings that influence the generation process:

- **Prompt**. Text description that Stable Diffusion follows when creating the image. Prompts must be in **English**. The best option is to use **keywords and short, simple phrases** while avoiding long, adjective-heavy sentences.

- **Negative Prompt**. Describes what Stable Diffusion should avoid when generating an image. Same rules apply here as well: for better results, use keywords or short phrases in English.

<Img
img="/api/uploads/02_prompt_ecd6283c94.jpg"
alt="Prompt and Negative Prompt placement and examples"
src="Prompt (top) and Negative Prompt (bottom) examples in AUTOMATIC1111"
/>

- **Sampling Method (Sampler)**. Algorithm that manages the step-by-step transformation of noise into an actual image. Sampler may affect style, details, generation speed, and the number of steps needed for the required outcome.

Popular options include:

**1. Euler a**. Fast and versatile, suitable for a small number of steps (20–30).

**2. DPM++ 2M**. Offers good details and stability, works well with higher step counts (30–50).

**3. Heun**. Experimental method. Slower, but sometimes produces unique textures and styles.

**4. DDIM**. Fast option to create smoother details, especially effective within the range of 25–50 steps.

<Img
img="/api/uploads/03_samplers_5f6f5f5de6.jpg"
alt="Example of images created using different samplers"
src="Images generated by different samplers for the “Portrait of a fantasy warrior, silver armor, cinematic lighting” prompt"
/>

More samplers are available in the interface. Try different options to find which of them suit you best.

<Img
img="/api/uploads/04_samplers_list_5985372f35.jpg"
alt="A list of samplers in AUTOMATIC1111"
src="A drop-down list of samplers"
/>

- **Sampling Steps**. The number of steps Stable Diffusion takes to create an image. More steps yield higher accuracy but longer generation time.

<Img
img="/api/uploads/05_steps_159265cf1e.jpg"
alt="Step-by-step image generation in AUTOMATIC1111"
src="Image generation results at different steps for the “Woman, curly hair, smiles at camera” prompt"
/>

- **CFG Scale**. Controls how strictly the model adheres to the prompt. For instance, **low values (1–3)** lead to loose interpretation and may bring abstract results. **Medium values (7–9)** offer a more balanced outcome. **High values (12+)** provide maximum adherence but may cause artifacts and unnatural details.

<Img
img="/api/uploads/06_cfg_scale_810abaa466.jpg"
alt="Images generated with different CFG values"
src="Different CFG values for the “Man in a hat, smiling, wine glass in right hand” prompt"
/>

- **Width / Height**. The resolution of the output image in pixels. For optimal quality, it’s better to adhere to the resolution which the model was trained on. For example, the default resolution for **Stable Diffusion 1.4 / 1.5** stands at **512×512**. 

- **Seed**. A number that determines the starting point from which the image is generated. When it’s set to **-1**, each result will be unique. Yet with a fixed seed and unchanged parameters, the result will be identical each time: this is useful for reproducing a specific output.

- **Script**. Allows to use additional plugins on top of the main generation process. For example, the **X/Y/Z Plot** script generates a grid of images with varying parameters (steps, samplers, checkpoints, etc.). This makes it easy to compare how different settings affect the output with the same prompt.

<Img
img="/api/uploads/07_script_508d890be3.jpg"
alt="Images generated using different checkpoints"
src="Image grid showcasing how different checkpoints handled the “Portrait of a fantasy warrior, silver armor, cinematic lighting” prompt"
/>

## Tips for Achieving High-Quality Results
Below are basic recommendations to optimize the image generation process.

- Start with the following values: **Steps ≈ 16** and **CFG = 7**. This ensures quick generation with reasonable accuracy and good prompt adherence. Note that parameter combinations are individual for each case. It’s recommended to experiment with different samplers and checkpoints to find the best balance of quality and rendering time.

- If the output doesn’t meet your expectations, try other **Sampling Methods**. Different samplers handle the same prompt differently.

- If there are deformations or unwanted elements in the image, try using **Negative Prompts**. Note that accurate result is not 100% guaranteed, especially with vague or abstract prompts.

- For **high-resolution images** (1024×1024 and above), **20–30 steps** are usually enough. Higher counts significantly increase rendering time and may cause errors.

Alternatively, generate images at their native resolution and upscale them as described below.
## How to Increase Image Size in Stable Diffusion
It’s possible to set the generated image size manually, yet large deviations from native resolution may negatively impact the outcome. In this case, the better option is to use **upscalers**: they enlarge images while minimizing quality loss. 

Here’s how they work: first, the illustration is generated at the native resolution. Next, the upscaler enlarges it and restores details. This approach makes it easier to create images suitable for printing, large layouts, or high-detail retouching.

In the AUTOMATIC1111 interface, upscaling works like this:

- **Upload the image**. Go to the **Extras** tab and either drag the generated image into the dedicated field or click on the field and select the image from a folder.

<Img
img="/api/uploads/08_field_3bd58ba4f9.jpg"
alt="Image uploading field in the Extras tab"
/>

- **Choose an upscaler**. Some of those are available by default, but you can install more if needed. This lets you choose the optimal algorithm for your goals, from minor scaling to deep texture restoration.

Notable upscalers include:

**1. Lanczos**. Simple and fast, good for small scaling (1.5x or 2x). The downside is, it doesn’t restore details but simply enlarges the image.

**2. R-ESRGAN**. Neural network upscaler that restores fine details and textures, including in photorealistic images.

**3. LDSR**. Enlarges the image while adding missing details. Useful for stylized or complex illustrations but relatively slow.

<Img
img="/api/uploads/09_upscalers_d1db0f905a.jpg"
alt="A drop-down list of upscalers"
src="Upscalers list example in AUTOMATIC1111"
/>

- **Set the scaling factor**. Specify the desired scale (e.g., 2x or 4x) and hit the “Generate” button to receive a higher-resolution image ready for further processing.

<Img
img="/api/uploads/10_upscaled_image_e1f5421ec0.jpg"
alt="Upscaled image example"
src="Example of a 2x image scaling by R-ESRGAN 4x+"
/>

And if installing and configuring AUTOMATIC1111 or Amuse sounds like a hassle, try generating images directly in the [**Pixcraft**](https://app.pixcraft.io/user/register) editor. To do this, drag the **Image** primitive onto the canvas, hit the **Click to upload** button, and select **AI**.

Simply describe the image you want to generate, set its proportions, and optionally choose a desired style from the list. Within a few seconds, the result will be ready for adding to the email template. It’s faster and more convenient than setting up Stable Diffusion manually.

<Img
img="/api/uploads/0010_gifpixcr2_5fb048c10b.gif"
alt="AI-generated image in Pixcraft"
src="Image generation in Pixcraft"
/>

## Conclusion
While Stable Diffusion requires considerable resources and attention to detail, it offers far more possibilities than cloud services. If you invest some time in setup and testing, you will get not just an AI generator but a fully customizable tool for a wide range of tasks.

Try different checkpoints and samplers, adjust every parameter, and assess the results. All this will help you master the tool faster and unlock the full potential of Stable Diffusion.

How to install and run Stable Diffusion AI image generator on your PC: instructions, core functions, and practical advice.

Articles by tag: AI