Preface

In addition to Diffusion Bee introduced in the previous article, there is another free local AI image generation tool suitable for running on M series Macs: Draw Things.

Draw Things Introduction and Installation

Software Introduction

Draw ThingsIt is a local image generation tool optimized for macOS and Apple M series chips, and also supports multiple models such as Stable Diffusion, ControlNet and LoRA. It has rich functions, including text generation image, image repair, parameter adjustment, etc., suitable for users who need to customize the generation details. At the same time, it provides a simple interface and built-in model management functions, taking into account ease of use and flexibility. It is a multi-functional image generation tool that integrates advanced functions and high performance.

---

Many options involved in this article (such as LoRA, ControlNet, strength, seed, number of steps, text guidance, sampler, etc.) are basic concepts in diffusion models (such as Stable Diffusion). The following is a brief explanation:

1. LoRA(Low-Rank Adaptation): A lightweight model fine-tuning method for optimization of a specific style or task.
2. ControlNet: An extension tool of the diffusion model that can control the generation results by input images or other conditions (such as edge maps).
3. strength(Strength): Used for image-to-image generation, controls the influence of the input image on the final generated result.
4. seed(Seed): Controls randomness. Fixed seeds can reproduce the same results.
5. Steps(Steps): The number of iterations when the model generates an image, which affects the image quality and generation time.
6. Text guidance(Text Guidance): Influence the generation results through text prompts.
7. Sampler(Sampler): Determines the sampling strategy of the diffusion process, such as Euler, DDIM, etc., which affects the generated quality and style.

For detailed explanation and setting effects, please refer to the previous article:Free entry-level local AI image generation tool on the Home Data Center series Mac (Part 1): Diffusion Bee setting parameter detailed explanation and practical demonstration.

---

Draw Things vs Diffusion Bee

The following is a simple comparison between Draw Things and Diffusion Bee in terms of functionality, usability, performance, and usage scenarios:

• Feature Comparison

characteristic	Draw Things	Diffusion Bee
Support Model	Support multiple SD models	Support multiple SD models
Multi-model switching	Supports basic models and extended models (ControlNet, LoRA), no need to reload when switching basic model versions	Supports loading up to 3 LoRA model combinations. Changing the base model version requires reloading
Tool scalability	Support multiple plugins	No plugin support
Generate Mode	Supports txt2img, img2img and other generation modes	Supports txt2img, img2img and other generation modes

• Usability comparison

characteristic	Draw Things	Diffusion Bee
Interface Design	Intuitive and simple	Simple but less functional
Difficulty	Flexible configuration, requires little familiarity	Simple configuration, ready to use
Difficulty of operation	Lower	Low
Community Support	active	limited

• Performance Comparison

characteristic	Draw Things	Diffusion Bee
Hardware Requirements	Support M series chips	Support M series chips
Spawn Speed	fast	medium
Memory usage	Moderate	Low
stability	high	high

• Comparison of usage scenarios

characteristic	Draw Things	Diffusion Bee
Suitable for beginners	yes	yes
Suitable for advanced users	yes	no
Recommended scenarios	High demand generation tasks	Basic generation tasks

Comparison Summary: Diffusion Bee emphasizes a one-click generation experience, but offers less flexibility and is suitable for novice users with no technical background. Draw Things' default configuration is more suitable for both beginners and advanced users with a certain level of technical skill, retaining a certain degree of flexibility. Therefore, as the sequel to "Entry-Level Local AI Image Generation Tools," Draw Things can be considered an advanced version of Diffusion Bee.

Install

Draw Things' official website address is as follows:https://drawthings.ai/To install the app, just search for "Draw Thing" in the Mac App Store and install it (you can also install it directly from the following link:App Store LinkAt the same time, Draw Things has another advantage over Diffusion Bee: in addition to the Mac version, there are also iPhone and iPad versions (this is also one of the reasons why Draw Things has the "server assistance" feature discussed below):

Draw Things Practice

initialization

Similar to Diffusion Bee, the first step before officially using Draw Things is to download a base model. The difference is that Diffusion Bee has a default recommended base model: "Default_SDB_0.1" (the corresponding Stable Diffusion core version is "Stable Diffusion v1.5"), while Draw Things requires you to choose the base model yourself:

Start downloading the model (there are 4 ckpt format files with a total size of nearly 5G):

set up

The Draw Things settings are the core of generating images. If you only need to generate classes, the options in the "Basic" mode in the settings will cover them:

Then take a look at the generated effect using the default parameters + default prompt words in "Basic" mode:

Below the canvas area on the lower right is the toolbar, and the descriptions of each button are as follows:

Right-click on the icon to insert a picture for more options:

Note 1: The options outlined in red on the left side of the images above are those available in "Basic" mode. Selecting "Advanced" changes these options to toggles for advanced features (such as image-to-image conversion and magnifiers). Selecting "All" combines all the options in both "Basic" and "Advanced" (similar to the "Advanced Options" in Diffusion Bee). However, since these options have been explained in detail in the previous article, and since they are all explained in Chinese in Draw Things, anyone with a basic understanding will understand them easily enough, I won't bother explaining them in this article (Diffusion Bee's options are all in English).

Note 2: In Diffusion Bee, each function is separate, such as "Text to Image", "Image to Image", "Repair", "Amplifier", etc., while in Draw Things, these functions are all available as options. For example, "Image to Image" is in the Intensity option:

The Enlarger (enhances photo resolution) function is an option in the Advanced mode:

From these differences, we can see that there are still differences in the usage concepts of the two softwares, Diffusion Bee is more suitable for beginners with zero basic knowledge (each function is separated and clear at a glance), while Draw Things is suitable for friends who have a certain understanding of diffusion model. For me, I obviously prefer Draw Things.

Note 3: Diffusion Bee and Draw Things can both support Chinese prompts in theory, but the model you download needs to be trained with Chinese content, so whether it can be supported depends on the basic model you download. The ones I downloaded do not support Chinese prompts and need to be translated into English.

Note 4: This article mainly introduces the interface and functions of Draw Things and its major differences compared to Diffusion Bee. As for the impact of different parameter settings on the effect of generating pictures, this article will not cover it. If you need, you can try it yourself, or refer to the examples of similar operations of Diffusion Bee in the previous article.

script

In Draw Things, the scripting part is mainly used to extend and customize the generation process (Diffusion Bee does not have this feature). It provides users with another way to adjust the generation details, add additional effects or implement advanced generation tasks besides adjusting the settings options.

Take the preset script as an example:

In fact, the effect is the same as the "Settings" - "Basic" - "Intensity" - "Image to Image" option:

In this case, the effect is the same no matter which method is used. But more often, a script contains the effects of multiple options combined, such as the functions provided by community scripts:

Take the first "Flux Auto Workflow" as an example:

As can be seen from the comments at the beginning of the script above, the script integrates multiple functions such as text generation image, batch processing, random prompt word generation, and extended canvas, optimizes the parameter usage of Flux and other popular models, and provides flexible performance and mode selection. The degree of automation is high. Specifically, it mainly includes the following points:

1. Support multiple generation tasks

• Text-to-Image: Basic generation task.

• Batch Image Refine: A group of images can be batch optimized and refined.

• Outpainting: Supports the extension of existing images to generate larger canvas content.

• Batch Prompts: Multiple prompt words can be processed at the same time to generate multiple corresponding pictures.

• Random Prompt: Built-in random prompt word engine, which can automatically generate high-quality prompt words and also supports customization according to user preferences.

2. Support multiple models and automatic optimization

• Designed for Flux models: Two models (Flux Dev 8-bit and Dev to Schnell LoRA) need to be used at the same time, and the most suitable model will be automatically selected based on the accuracy priority.

• Compatible with other popular models: Supports automatic parameter setting and is compatible with common models including DreamShaper Turbo, Kolors, SDXL, SD3, Schnell, etc.

3. Performance optimization and multi-mode selection

• Provides three different performance modes, including optimization parameters, to suit different needs (e.g. performance priority, effect priority, etc.).

• Especially suitable for beginners, it simplifies parameter adjustment during the generation process.

4. Flexible workflow and mode switching

• Supports multiple workflows and generation modes to achieve different image generation effects.

• Allow users to switch freely between different modes to meet specific creative needs.

From the above descriptions, we can see that scripts can provide higher flexibility and realize automated operations such as dynamic adjustment, batch processing, and multi-stage generation. They are suitable for complex or efficient needs. It is difficult to achieve these functions by manually adjusting options alone.

---

For novice users, scripts can be used to quickly achieve the effect of combining and setting multiple function options: if the task requires repeated adjustment of multiple parameters or multi-step operations (such as gradually adjusting the noise intensity), manual operation will become very cumbersome; for advanced users, if Draw Things introduces new algorithms or model functions, but the default interface does not support them, scripts can provide interfaces to call these functions so that users can try new features.

Therefore, whether for novice or advanced users, the script function can greatly improve work efficiency. This function is also one of the main reasons why Draw Things is an "advanced version" compared to Diffusion Bee.

---

PEFT

PEFT (Parameter-Efficient Fine-Tuning) Module is a functional module in Draw Things that is specifically used to manage and apply lightweight fine-tuning models. Its main function is to help users achieve advanced generation effects such as style customization and domain migration by efficiently loading and dynamically adjusting fine-tuning technologies such as LoRA (Low-Rank Adaptation) (there are many options in the red box in the figure below, so I won’t take screenshots one by one):

Compared to the LoRA configuration in "Settings" - "Basics," PEFT offers deeper management capabilities, including automatic optimization of model compatibility, multi-LoRA model overlay, dynamic parameter adjustment, and support for other PEFT technologies (such as P-Tuning or Adapter extensions). It also offers deep integration with scripting and batch generation capabilities, providing greater flexibility and efficiency for complex creative workflows. It serves as a core tool for personalized image generation and advanced operations.

---

exist Draw Things In the "Settings" option, "LoRA Configuration" and "PEFT Module" both involve loading and using LoRA, but their uses and functional scopes differ, mainly in "management depth" and "flexibility". The following are the differences and connections between the two:

1. LoRA configuration in settings

• Scope: The LoRA configuration in the settings is mainly used to quickly load and adjust one or more LoRA models for direct application in the generation process.

• How to use: In the "Basic" option, you can manually select multiple LoRA models and specify their weights (degree of influence); suitable for simple scenarios, such as superimposing multiple LoRA models to generate images of a specific style.

• flexibility: Parameter adjustment is relatively basic, focusing mainly on strength (weight) and model loading order, suitable for users who do not need complex operations.

2. Functions of PEFT module

PEFT moduleProvides more advanced and granular LoRA management capabilities, with greater focus and capabilities than the LoRA configuration in Settings:

• Advanced management features:Automatically optimize loading: The PEFT module will perform adaptability optimization for different LoRA models to ensure compatibility and performance between models;Dynamic model adjustment: Different parameter layers of LoRA can be dynamically switched, superimposed, or even individually controlled during the generation process.

• Support more PEFT technologies：PEFT is not limited to LoRA, but may also support other lightweight fine-tuning technologies (such as P-Tuning, Adapter, etc.), expanding the toolset available to users.

• Workflow Integration: The PEFT module may be more tightly integrated with scripts or other modules (such as batch generation) and can be flexibly called in complex workflows.

3. Core differences

Function	LoRA configuration in settings	PEFT module
Usage scenarios	Quickly load and apply LoRA	Advanced management, dynamic adjustment, and support for multiple lightweight models
Supporting technologies	Mainly for LoRA	Expand support for other technologies of PEFT
Complexity	Basic functions, easy to use	More powerful features for advanced users
Dynamic Control	Basic parameter adjustment	Support dynamic switching and optimization during the generation process
Integrate with workflow	Independent operation, less related to other functions	Can be deeply integrated with scripts, batch generation and other functions

---

If you just need to quickly load one or several LoRA models and adjust their influence weights, the LoRA configuration in "Settings" is sufficient. But if you need more sophisticated management of LoRA (such as dynamic switching, parameter optimization) or want to explore a wider range of lightweight fine-tuning techniques,PEFT moduleIt provides higher flexibility and functionality. It is more suitable for users who need complex generation effects and process control.

Note: I have also used a special section in the "previous article" to introduce the practical operation of LoRA, including how to download the LoRA model. Friends who are interested can refer to the instructions in the "previous article". I will not go into details in this article.

Server Assistance

Function Introduction

DrawThings' Server Assist feature allows users to offload image generation tasks to other devices on the same network (such as computers with more powerful computing power) by enabling the gRPC API service, accelerating processing while reducing resource usage and heat generation on the main device. This approach supports local and remote computing, maintaining data privacy while significantly improving performance. It is suitable for scenarios such as high-resolution image generation and multi-tasking collaboration.

---

What is gRPC: gRPC is a high-performance Remote Procedure Call (RPC) framework that is widely used for cross-language and cross-platform service communications. It uses Protocol Buffers (protobuf) as the interface definition language and data serialization protocol, and is fast and efficient.

The gRPC API service in "Draw Things" can be understood as distributing computing tasks to other devices in the local area network through gRPC, thereby utilizing their computing resources (such as more powerful GPUs) to accelerate image generation tasks.

---

Features and advantages

Features of Server Assist

1. Combining local and remote computing

• When running an application on a host device (such as an iPhone or iPad), you can delegate part or all of the computing tasks to a remote computer in the same network (as mentioned earlier in the article, Draw Things supports deployment on MAC, iPhone, and iPad at the same time).

• Avoid the main device from affecting performance or generating heat due to insufficient computing power.

2. gRPC API Service

• Leverage gRPC (remote procedure call framework) to communicate efficiently with remote computing devices.

• The remote device needs to run a server program that specifically supports the gRPC API, which can handle the image generation task and return the results.

3. Cross-device collaboration

• Supports collaborative work of multiple devices within a local area network, for example, the main device is used for control interface and some lightweight computing, and the remote devices focus on heavy-load tasks (such as model inference).

4. Open source and flexible

• Draw Things uses open standards, allowing it to seamlessly integrate with community-maintained server-side programs.

Advantages of Server Assistance

1. Performance Improvements

• Use high-performance remote GPUs to speed up inference for complex tasks.

• Reduce resource consumption of the master device.

2. flexibility

• The task execution location can be switched at any time to adapt to different usage scenarios.

3. Local Privacy

• Compared to a fully cloud solution, server-assisted functions remain local and no sensitive data is uploaded to the public cloud.

---

Possible use cases:

• High-resolution image generation：Mobile phones have limited computing power, so desktop-level GPUs are used to accelerate the generation of large-size images.

• Multi-tasking collaboration: Run multiple tasks simultaneously and distribute some tasks to remote devices.

• Energy saving and heat management: Reduce the load on the main device to avoid overheating of the device.

Note:

1. Model compatibility: Make sure that the master and remote devices use compatible Stable Diffusion model versions.
2. Network stability: The server assistance function is sensitive to network latency and is recommended to be used in a high-bandwidth, low-latency LAN environment.
3. Server configuration requirements: The remote device needs to have sufficient computing power (such as NVIDIA GPU and corresponding driver support).

---

How to enable Draw Things' server assistance

Here are the brief steps for setup and use:

1. Enable gRPC service on the remote device

• Make sure a server that supports the Stable Diffusion model (such as diffusers or other PyTorch-based implementations) is installed on the remote device.

• Install required dependencies:

pip install grpcio protobuf diffusers

• Start the gRPC API server. For example, run a sample server program to handle image generation requests.

2. Configure the Draw Things client

• In the Draw Things settings on the master device, find Server Assistance options.

• Enter the IP address and port of the remote device (make sure both devices are on the same network).

• Test the connection to ensure that the client can access the remote server normally.

3. Start generating tasks

• Choose to use server-assisted mode in Draw Things.

• The image generation task will be assigned to the remote device for processing, and the processing results will be returned to the main device.

4. Network and Firewall Settings

• Make sure that the remote device's firewall allows communication on the specified ports.

• If you cannot connect, check that the network settings support direct communication between devices.

Note: The above are just brief steps. In reality, it is not that simple. I will write an article to explain it in detail later.

Additional knowledge: Support AI applications similar to "server assistance" functions

This type of AI application is mainly concentrated in areas that require a large amount of computing resources, such as deep learning reasoning, training tasks, and generative AI applications. This type of application usually allows users to use the computing power of remote devices for distributed computing through a local area network or the Internet.

Here are some apps and tools with similar functions. Similar to Draw Things’ “Server Assist” feature, these apps and tools can offload high-load computing tasks to remote devices to provide users with more efficient computing power usage while retaining a certain degree of local control and data privacy:

1. Stable Diffusion related tools

Automatic1111 WebUI

• Features: Supports connecting to a remote server through a web interface and running Stable Diffusion inference using the server’s GPU.

• Implementation: Users can set up the API service of the WebUI, or call remote device resources through the SD API interface.

• Usage scenarios: Perform model inference and control on lightweight devices (such as laptops), but transfer the actual calculations to remote servers.

ComfyUI

• Features: Modular image generation interface, support for distributed deployment, control of remote inference nodes via WebSocket or API.

• Implementation: Multiple devices can be connected and different tasks (such as processing, synthesis, etc.) can be assigned to remote nodes.

2. Text generation applications

Oobabooga Text Generation WebUI

• Features: Used to run large language models (such as LLaMA, GPT-J, etc.), and supports setting up remote servers as inference devices.

• Implementation: Start local or remote inference services through server.py, and the user's front-end interface can connect to these services.

• Usage scenario: Users access the model on a regular device, but the computation is performed by a remote GPU or TPU.

3. Video generation and editing

Runway ML

• Features: Supports video generation and editing tasks based on Stable Diffusion, and supports connecting to custom remote inference servers in some scenarios.

• Implementation: Users can deploy the inference part to the cloud or a server in the local area network through the API provided by Runway.

• Usage scenario: Video editing and preview are performed on a local lightweight device, and complex calculations (such as stylized rendering) are completed by the remote GPU.

4. AI-assisted painting and 3D modeling

Blender (AI Acceleration Plugin)

• Features: Support for integration of Stable Diffusion into Blender for texture generation via plugins (such as Dream Textures), allowing connection to remote servers for high-performance tasks.

• Implementation: Users can set up remote computing nodes to work with local Blender software.

• Usage scenarios: Perform modeling tasks on the local device and outsource complex texture generation or high-resolution rendering to a remote server.

5. Distributed Deep Learning Training

Ray Serve

• Features: Ray is a distributed computing framework that supports deploying AI reasoning tasks to multiple machines.

• Implementation: With Ray Serve, you can easily implement distributed reasoning or training tasks and automatically distribute the load.

• Usage scenarios: AI models need to be run on multiple devices simultaneously, such as real-time recommendation systems or massively parallel reasoning.

TensorFlow Serving and PyTorch Serve

• Features: Supports deployment of AI models as API services, allowing client calls in the LAN or the Internet.

• Implementation: Configurable multi-instance services, providing load balancing and distributed reasoning capabilities.

• Usage scenarios: Remotely call AI models to perform prediction tasks, suitable for developers and enterprise-level applications.

6. Other Generative AI Applications

DeepFaceLab

• Features: A tool for face replacement that supports distributing compute-intensive tasks (such as model training or video processing) to multiple devices.

• Implementation: Speed up the face swapping process by setting up remote inference nodes.

• Usage scenario: Process video materials on a regular computer and offload heavy-load calculations to a remote server.

DreamBooth Training Tools

• Features: Supports distributing DreamBooth model training and generation tasks to remote devices.

• Implementation: Call high-performance devices through the local area network or cloud services to perform custom model training.

7. Cloud and local collaboration tools

NVIDIA Omniverse

• Features: A real-time collaborative 3D design platform that supports AI and rendering tasks accelerated by NVIDIA GPUs and supports remote computing collaboration.

• Implementation: Users can operate model designs on lightweight devices and utilize remote GPUs for real-time computing and rendering.

Hugging Face Inference API

• Features: Provides cloud-based AI inference services, allowing users to call models through APIs and combine them with local processing.

• Implementation: Data pre-processing and management are performed locally, and complex tasks are sent to the cloud for execution.

Afterword

This article isn't focused on a detailed explanation of how to use DrawThings to generate AI images. For AI image generation tools like these, whether the beginner-friendly Diffusion Bee or the more comprehensive DrawThings, being able to use them is one thing, but truly using them effectively requires a certain level of knowledge and extensive practice. From understanding the fundamentals of diffusion models to becoming familiar with various parameters (such as sampling steps and CFG scale), to selecting the appropriate base model and auxiliary models like LoRA, and exploring the optimal combination of prompt words and parameters, all of these require time and trial and error. This content not only exceeds the scope of this article but also requires a much more systematic study and summary than would be possible in a single article. (I'm just a beginner myself, and I still have a lot of knowledge and experience to learn and accumulate.)

The real purpose of writing this article is to explain why Draw Things is an "advanced" tool compared to Diffusion Bee from the perspective of "tool features and usage ideas". By introducing its functional features (such as scripting, PEFT, server assistance, etc.), I hope to help friends with a certain foundation to get started quickly, so that they can exert its capabilities faster and more efficiently, saving a lot of learning time.

For those who are interested in in-depth research on generative AI image creation, this article hopes to be your first step in getting started with Draw Things and provide a higher starting point for subsequent deeper exploration.