A few years ago, the first day I finally got access to an AI image generator, I was so excited that I immediately sat down and wrote an article about it (using Node.js and OpenAI's DALL-E). The magic of turning thoughts directly into digital pixels felt like holding a real-life magic wand.

But back then, accessing these models wasn't a walk in the park. Our primary option was Midjourney, which meant you had to struggle on Discord, and sometimes you couldn't do anything due to rate limits and servers being very busy.

Accessing image generation back then felt like trying to order a coffee during a flash mob.

Thankfully, the landscape has completely shifted. Today, not only can we run state-of-the-art models like Stable Diffusion on consumer hardware, but we can do it locally, offline, and completely free of charge. We don't need any API keys, there aren't any subscription rate limits, and there's no Discord channels to deal with.

In this tutorial, we'll build a local web application using Node.js, Express, Socket.io, and the QVAC SDK to run a quantized Stable Diffusion 2.1 model.

Table of Contents

• Prerequisites

• What is QVAC?

• How Stable Diffusion Works Under the Hood

• GPU Limitations: Metal, AMD, and the Intel Mac Trap

• The Image Generation Pipeline

• Complete Implementation

• Codebase Breakdown

• Conclusion

• Resources and Further Reading

Prerequisites

To get the most out of this tutorial, you should have a solid foundation in web backend and frontend basics:

• Node.js and ES Modules: Basic familiarity with modern JavaScript modules (import/export), async loops, and event listeners.

• Express and WebSockets: Familiarity with routing static files and sending real-time messages over WebSockets with socket.io.

• HTML and Vanilla CSS: Understanding of basic DOM manipulation and style bindings.

• Development environment: A local machine with Node.js installed.

What is QVAC?

Developed by Tether, QVAC is a family of local inference tools designed to execute machine learning models directly on client hardware.

Instead of routing inference requests to expensive cloud-hosted APIs (such as DALL-E or Midjourney), QVAC bundles pre-compiled machine learning runtimes (like llama.cpp for text, whisper.cpp for transcription, and custom diffusion backends) directly into Node.js, mobile, and desktop runtimes.

Running local AI models with QVAC offers several practical advantages:

• Zero API costs: Generate as many images as your hardware can handle without recurring costs.

• Privacy-first: Prompts and generated images are kept entirely in memory on your local machine.

• Offline independence: Run your application in isolated networks, on flights, or in regions without internet access.

How Stable Diffusion Works Under the Hood

To execute image generation locally without running out of RAM, QVAC leverages a quantized Stable Diffusion 2.1 GGUF model (SD_V2_1_1B_Q8_0).

But how does this actual image generation process work conceptually? Let's make one thing clear: this is not a scientific paper. We aren't going to dive into the underlying multivariable calculus, probability distributions, or stochastic differential equations because I'm not a low-level machine learning researcher (and let's be honest, neither of us wants to stare at Greek symbols and linear algebra formulas on a screen when we could be writing clean JavaScript).

Instead, let's understand how these models work conceptually, using some intuitive developer analogies.

The World-Class Sculptor Analogy

At its core, modern AI image generation turns randomness into reality. Instead of "painting" an image from scratch, pixel-by-pixel, like a human illustrator with a brush, the AI essentially acts as a world-class sculptor, carving an image out of a block of digital static.

The most dominant technology behind this today is Diffusion, which powers models like Stable Diffusion, Midjourney, and Google's Imagen series.

Here is the conceptual step-by-step breakdown of how this block of static turns into art:

1. The Training Phase (Learning the Patterns)

Before a model can generate anything, it has to look at billions of images and their corresponding text descriptions. During this phase, developers do something counterintuitive: they intentionally ruin the images.

• Adding noise: The system takes a clear picture (for example, of a cat) and gradually adds random digital static (noise) pixel-by-pixel until the original image is completely unrecognizable.

• Learning to reverse it: The AI's job is to look at a noisy image and predict exactly how much noise was added at that specific step. By doing this billions of times, it becomes an expert at denoising – that is, turning chaos back into order.

2. Connecting Words to Visuals (CLIP)

To make sure the AI knows what a "cat wearing a top hat" looks like, it uses a text-to-image bridge, often powered by a system called CLIP (Contrastive Language-Image Pre-training).

• CLIP translates human language into a mathematical map (called an embedding).

• In this map, the words "cat" and the actual pixels of a cat sit very close together. This ensures that when you type a prompt, the AI knows exactly which visual concepts to pull from its memory.

3. The Generation Phase (The Reverse Diffusion Loop)

When you type a prompt and hit "Generate," the magic happens in reverse:

• The blank canvas: The AI starts with a canvas of pure, 100% random digital noise (it looks like old television static).

• The prompt guidance: The AI looks at your prompt and uses its text embedding to guide its eye. It looks at the random static and asks, "Where in this mess can I start to see a cat?"

• Step-by-step denoising: The AI subtracts a little bit of noise, sharpening the image slightly. It repeats this loop 20 to 50 times. With every step, fuzzy shapes turn into rough outlines, textures appear, and eventually, a crisp, clean, brand-new image emerges.

Fun fact about seeds: Because the process starts with completely random static every single time, typing the exact same prompt twice will always give you a completely different image (unless you lock down the starting randomness using a specific number called a Seed).

Here's an illustration of denoising with diffusion models:

Latent Diffusion: Keeping it Fast (The VAE)

Generating high-resolution images pixel-by-pixel requires massive computing power. If we tried to do this directly in pixel space on consumer hardware, our computers would melt, and a single generation would take hours.

To fix this, modern models use Latent Diffusion.

Instead of working with the full-sized image, a component called an encoder compresses the image into a smaller, abstract mathematical space (the "latent space"). Think of it as a shrunken playground where all the noisy/denoising math happens. Because this playground is so small, the computations are incredibly fast.

Once the denoising loop finishes in the latent space, another component called the decoder (specifically, a Variational Autoencoder, or VAE) blows it back up into a sharp, high-resolution image for you to see.

Architectures Supported by QVAC

When you run local inference with QVAC, the SDK hooks into optimized, community-maintained C++ backends. QVAC manages the hardware bindings and model lifecycles for different AI modalities:

1. Text generation (llama.cpp): Used for large language models (LLMs) like Llama 3 or Mistral, executing auto-regressive token prediction.

2. Audio transcription (whisper.cpp): Used for highly optimized speech-to-text transcription.

3. Image Generation (stable-diffusion.cpp / sdcpp-generation): Our focus in this tutorial. QVAC supports two distinct approaches for image generation depending on the model architecture you choose:

   • The Bundled Model Approach (Stable Diffusion 1.5/2.1/XL): The traditional approach where the entire pipeline (Text Encoders, VAE, and the main Diffusion UNet) is baked into a single, unified GGUF file (for example, SD_V2_1_1B_Q8_0).

     This is incredibly convenient for local deployments because you only need to manage and load one file to start generating images.

   • The Modular Multi-Model Approach (Flux): Modern architectures like FLUX.1 use a much more complex setup. Instead of a single file, Flux splits its computational brain into separate components. You load a core Diffusion Transformer (DiT) model, but you must also separately load large text encoders (like T5-v1.1-xxl and CLIP-L) and an independent VAE model.

     While this requires more complex orchestration to load multiple GGUF files simultaneously, it provides vastly superior prompt adherence and photorealism by utilizing dedicated, massive text-understanding models.

4. Speech synthesis (TTS): Specialized architectures like Chatterbox (transformer-based zero-shot voice cloning) and Supertonic (diffusion-based speech denoising).

When running machine learning models locally on Apple Mac hardware, QVAC will try to automatically accelerate execution by compiling compute pipelines for the Metal API to utilize the system's GPU.

If you're on an Apple Silicon Mac (M1, M2, M3, M4, or M5 chip), this works seamlessly, and generation will compile on the Apple Neural Engine and Unified GPU memory in seconds.

But if you're running on an older Intel-based Mac with a discrete AMD Radeon GPU (such as the AMD Radeon Pro 5500M commonly found in 16-inch MacBook Pros), you'll run into a major driver-level limitation:

• The macOS Metal driver for older AMD discrete GPUs doesn't support the modern machine learning compute shaders and matrix reduction operators used by stable-diffusion.cpp.

• When the inference worker attempts to run these unsupported operations, the driver fails to compile the pipeline and triggers a hard C++ crash (SIGABRT) inside the ggml-metal-ops.cpp shader encoder, abruptly exiting the background worker process.

If you hit this hardware roadblock, the default GPU configuration will crash the application every time you trigger an image generation.

To resolve this, you should configure the model to run on the CPU instead by setting the model configuration parameter device to "cpu" and specifying the threads (for example, threads: 4). While generating images on the CPU takes longer than on a GPU, it runs successfully on any machine, regardless of how old or limited its GPU is.

The Image Generation Pipeline

To coordinate the local execution lifecycle, our app sets up a real-time event pipeline:

[Browser Client]                                  [Node.js Server]
       |                                                 |
       | ------ 1. Connects & Checks Model --------->    |
       | <----- 2. Downloads & Loads Model ----------     | (Model Cached locally)
       |                                                 |
       | ------ 3. Submits prompt ("Cozy cabin...") ->  |
       |                                                 |
       |                                                 | === [ QVAC Inference Engine ] ===
       |                                                 | 
       | <----- 4. Denoising Step Updates (e.g. 5/20) -- | (Streams steps in real time)
       |                                                 |
       | <----- 5. Sends final image (Base64 DataURL) -- | (Direct in-memory payload)
       |                                                 |

Complete Implementation

Let's look at the implementation. You can clone the full project repository to follow along, or build it from scratch by creating a project folder, running npm init -y, installing the dependencies (@qvac/sdk, express, socket.io, concurrently), and configuring "type": "module" in your package.json.

1. Server Configuration (server.js)

Create a file named server.js and paste the following implementation:

import express from 'express';
import path from 'path';
import http from 'http';
import { Server } from 'socket.io';
import fs from 'fs';
import { fileURLToPath } from 'url';
import { loadModel, unloadModel, getLoadedModelInfo, diffusion, SD_V2_1_1B_Q8_0 } from "@qvac/sdk";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const app = express();
const server = http.createServer(app);
const io = new Server(server);

const PORT = process.env.PORT || 3000;

app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));

const CONFIG_PATH = path.join(__dirname, '.device-preference.json');

function getPreferredDevice() {
  try {
    if (fs.existsSync(CONFIG_PATH)) {
      const data = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
      return data.device || null;
    }
  } catch (err) {
    console.error('Failed to read device preference:', err.message);
  }
  return null;
}

function setPreferredDevice(device) {
  try {
    fs.writeFileSync(CONFIG_PATH, JSON.stringify({ device }), 'utf8');
  } catch (err) {
    console.error('Failed to write device preference:', err.message);
  }
}

// Global model state
let loadedModelId = process.modelId || null;
let modelLoadPercent = 0;
let modelLoadStatus = 'Awaiting trigger...';
let isModelLoading = false;

const modelSize = (SD_V2_1_1B_Q8_0.expectedSize / (1024 * 1024 * 1024)).toFixed(2) + ' GB';

function broadcastModelProgress(percent, status) {
  io.emit('model-download-progress', { percent, status, size: modelSize });
}

io.on('connection', (socket) => {
  console.log('Client connected:', socket.id);

  socket.on('disconnect', () => {
    console.log('Client disconnected:', socket.id);
  });

  // Trigger model download
  socket.on('trigger-model-download', async () => {
    // If already loaded, verify it's still alive in the worker
    if (loadedModelId) {
      try {
        await getLoadedModelInfo({ modelId: loadedModelId });
        socket.emit('model-download-progress', {
          percent: 100,
          status: 'Model fully loaded locally.',
          size: modelSize
        });
        return;
      } catch (err) {
        console.log('Model ID was stale/not found, resetting state and reloading...', err.message);
        loadedModelId = null;
        process.modelId = null;
      }
    }

    // If currently loading, report current progress
    if (isModelLoading) {
      socket.emit('model-download-progress', {
        percent: Math.round(modelLoadPercent),
        status: modelLoadStatus,
        size: modelSize
      });
      return;
    }

    isModelLoading = true;
    modelLoadPercent = 0;
    modelLoadStatus = 'Initiating model download...';
    broadcastModelProgress(modelLoadPercent, modelLoadStatus);

    try {
      console.log('Starting model download...');
      const preferredDevice = getPreferredDevice();
      const loadConfig = { prediction: "v" };
      if (preferredDevice) {
        loadConfig.device = preferredDevice;
        if (preferredDevice === 'cpu') {
          loadConfig.threads = 4;
        }
        console.log(`Using cached device preference: ${preferredDevice}`);
      }

      loadedModelId = await loadModel({
        modelSrc: SD_V2_1_1B_Q8_0,
        modelType: "sdcpp-generation",
        modelConfig: loadConfig,
        onProgress: (p) => {
          modelLoadPercent = p.percentage;
          modelLoadStatus = p.percentage >= 100 ? 'Model fully loaded locally.' : `Downloading model weights... (${p.percentage.toFixed(1)}%)`;
          broadcastModelProgress(Math.round(modelLoadPercent), modelLoadStatus);
        }
      });
      process.modelId = loadedModelId;

      isModelLoading = false;
      console.log('Model loaded successfully. ID:', loadedModelId);
    } catch (err) {
      isModelLoading = false;
      modelLoadPercent = 0;
      modelLoadStatus = 'Failed to load model: ' + err.message;
      console.error('Failed to load model:', err);
      broadcastModelProgress(0, modelLoadStatus);
      socket.emit('error_event', { message: 'Failed to load model: ' + err.message });
    }
  });

  socket.on('generate', async (data) => {
    const { prompt, ratio } = data;
    if (!prompt || prompt.trim() === '') {
      socket.emit('error_event', { message: 'Prompt is required' });
      return;
    }

    if (!loadedModelId) {
      socket.emit('error_event', { message: 'Model is not loaded yet' });
      return;
    }

    const runDiffusion = async (modelIdToUse) => {
      socket.emit('progress', {
        percent: 0,
        status: 'Starting diffusion process...',
        sub: 'DIFFUSION INITIALIZING'
      });

      console.log(`Generating image for prompt: "\({prompt}" with ratio: \){ratio} using model ID: ${modelIdToUse}`);

      const { progressStream, outputs, stats } = diffusion({
        modelId: modelIdToUse,
        prompt,
      });

      // Stream progress steps
      for await (const { step, totalSteps } of progressStream) {
        const percent = Math.round((step / totalSteps) * 100);
        socket.emit('progress', {
          percent,
          status: `Denoising step \({step}/\){totalSteps}...`,
          sub: 'RUNNING DIFFUSION'
        });
      }

      // Resolve output buffers
      const buffers = await outputs;
      if (!buffers || buffers.length === 0) {
        throw new Error('No image buffer returned from diffusion model.');
      }

      // Convert image buffer to a base64 Data URL instead of saving to disk
      const base64Data = Buffer.from(buffers[0]).toString('base64');
      const dataUrl = `data:image/png;base64,${base64Data}`;

      // Emit success
      socket.emit('success', {
        url: dataUrl,
        prompt,
        seed: (await stats).seed || -1
      });

      console.log(`Image generated and emitted successfully as base64 Data URL.`);
    };

    try {
      await runDiffusion(loadedModelId);
    } catch (err) {
      console.error('Image generation failed:', err);

      const isCrash = err.code === 50205 || (err.message && err.message.includes('WORKER_CRASHED'));
      if (isCrash) {
        console.log('Worker crashed during GPU execution. Attempting CPU fallback...');

        // Save device preference so we load CPU directly next time and prevent double loading
        setPreferredDevice('cpu');

        // Reset the stale model state
        loadedModelId = null;
        process.modelId = null;

        socket.emit('progress', {
          percent: 0,
          status: 'GPU driver crashed. Automatically falling back to CPU mode...',
          sub: 'CPU FALLBACK LOADING'
        });

        try {
          console.log('Loading model on CPU...');
          isModelLoading = true;
          modelLoadPercent = 0;
          modelLoadStatus = 'Loading CPU model weights...';
          broadcastModelProgress(modelLoadPercent, modelLoadStatus);

          loadedModelId = await loadModel({
            modelSrc: SD_V2_1_1B_Q8_0,
            modelType: "sdcpp-generation",
            modelConfig: { prediction: "v", device: 'cpu', threads: 4 },
            onProgress: (p) => {
              modelLoadPercent = p.percentage;
              modelLoadStatus = `Loading CPU model weights... (${p.percentage.toFixed(1)}%)`;
              broadcastModelProgress(Math.round(modelLoadPercent), modelLoadStatus);
            }
          });
          process.modelId = loadedModelId;
          isModelLoading = false;
          console.log('Model loaded successfully on CPU. ID:', loadedModelId);

          // Retry diffusion on CPU
          await runDiffusion(loadedModelId);
        } catch (cpuErr) {
          console.error('CPU fallback execution failed:', cpuErr);
          isModelLoading = false;
          socket.emit('error_event', { message: 'Image generation failed on CPU: ' + cpuErr.message });
        }
      } else {
        if (err.message && (err.message.includes('MODEL_NOT_FOUND') || err.message.includes('not found'))) {
          loadedModelId = null;
          process.modelId = null;
          broadcastModelProgress(0, 'Model state lost. Please re-trigger download.');
        }
        socket.emit('error_event', { message: 'Image generation failed: ' + err.message });
      }
    }
  });
});

app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

server.listen(PORT, () => {
  console.log(`Server is running at http://localhost:${PORT}`);
});

// Clean exit handler
async function handleCleanup() {
  const modelId = process.modelId || loadedModelId;
  if (modelId && modelId !== 'mock-model-id') {
    try {
      await unloadModel({ modelId, clearStorage: false });
    } catch (err) {}
  }
  process.exit(0);
}

process.on('SIGINT', handleCleanup);
process.on('SIGTERM', handleCleanup);

2. Frontend Architecture Summary

Since our application runs completely locally, the frontend is a single-page web app built with vanilla HTML, CSS, and client-side JavaScript that communicates with our Express server over Socket.io WebSockets.

Rather than cluttering this tutorial with hundreds of lines of UI templates and style sheets, we'll keep the focus entirely on the backend orchestration. You can grab the complete HTML layout, Tailwind styles, and client script from the GitHub Repository.

Here is a summary of how the client communicates with the server under the hood:

1. Preflight sync (trigger-model-download): As soon as the page loads, the client establishes a WebSocket connection and emits trigger-model-download. The server intercepts this to check if the model is cached/loading, and begins broadcasting progress.

2. Denoising stream (progress): During image generation, the server constantly streams progress events containing denoising statistics (for example Denoising step 12/20...). The client updates the visual progress bar and status labels accordingly.

3. Data URL delivery (success): When the diffusion steps are completed, the server converts the binary image buffer into a Base64 string and emits a success event. The client binds this Base64 Data URL directly to the source of the <img> element for direct local display and instant download.

Codebase Breakdown

Let’s lift the hood on the key mechanisms that make our local offline image generator work smoothly.

1. Multi-Client Model ID Binding (process.modelId)

Quantized weights take a significant amount of memory. Every time we call loadModel(), QVAC boots a separate C++ background process (a Bare worker) to host the GGML runtime.

To prevent spawning multiple processes or loading the 2.3 GB GGUF model multiple times when a client refreshes a page or opens another browser tab, we store the loaded model ID globally on Node’s process object:

let loadedModelId = process.modelId || null;
// ...
process.modelId = loadedModelId;

This acts as a process-wide singleton registry. But using a global variable introduces a challenge: stale worker processes. If a client triggers a model load, gets an ID, and the background worker process later crashes or is killed, process.modelId remains populated with a dead reference.

To resolve this, every time a new client connects and requests a model download trigger, we preflight the model ID using getLoadedModelInfo:

if (loadedModelId) {
  try {
    await getLoadedModelInfo({ modelId: loadedModelId });
    socket.emit('model-download-progress', { percent: 100, status: 'Model fully loaded locally.' });
    return;
  } catch (err) {
    console.log('Model ID was stale, resetting state...', err.message);
    loadedModelId = null;
    process.modelId = null;
  }
}

If the background worker is dead, getLoadedModelInfo throws an error. The catch block intercepts this, wipes the stale references, and safely restarts the loading routine.

[!IMPORTANT] Process singleton integrity: Always preflight model state visibility before initiating inference. Without validation checks, attempting diffusion() on a stale model ID will trigger immediate client-side connection timeouts and silent backend worker failures.

2. In-Memory Image Serialization (Zero Disk Writes)

Writing generated images to the server's hard drive creates significant I/O overhead. It forces you to write custom cron cleanup scripts to delete old image files, and runs the risk of running out of disk space on systems with high user traffic.

Since QVAC’s diffusion() function outputs generated PNG files directly as in-memory binary buffers (Uint8Array), we bypass the local file system entirely. We serialize the binary array into a Base64 string directly in memory:

const base64Data = Buffer.from(buffers[0]).toString('base64');
const dataUrl = `data:image/png;base64,${base64Data}`;

This Data URL is transmitted over WebSockets to the client, which immediately binds it to the image element:

• Zero disk overhead: The server doesn't write a single byte to the hard drive, preserving SSD life and preventing storage bloat.

• Instant delivery: Transmission is handled entirely within network memory buffers, bypassing disk serialization latency.

• Effortless client integration: The client doesn't need to request a static image URL path. It directly renders the Base64 Data URL, allowing users to save or download the image instantly.

3. GPU-to-CPU Fallback & Preference Cache Strategy

One of the biggest challenges with local-first AI is client hardware heterogeneity. For example, older Intel Macs with discrete AMD Radeon GPUs support Apple's Metal framework, but lack the modern tensor reduction operators used by the Stable Diffusion engine, causing a hard C++ crash (SIGABRT) inside ggml-metal-ops.cpp.

To keep the application running and ensure we don't trigger the model loading twice (once on the incompatible GPU on startup, and once on the CPU fallback after the first prompt crash), we use a persistent device preference cache file (.device-preference.json) alongside our C++ worker crash interceptor:

try {
  await runDiffusion(loadedModelId);
} catch (err) {
  const isCrash = err.code === 50205 || err.message.includes('WORKER_CRASHED');
  if (isCrash) {
    // 1. Cache the CPU preference on disk
    setPreferredDevice('cpu');

    // 2. Reset stale references
    loadedModelId = null;
    process.modelId = null;

    // 3. Automatically load the model on CPU with multi-threading
    loadedModelId = await loadModel({
      modelSrc: SD_V2_1_1B_Q8_0,
      modelType: "sdcpp-generation",
      modelConfig: { prediction: "v", device: "cpu", threads: 4 }
    });
    process.modelId = loadedModelId;

    // 4. Transparently retry generation
    await runDiffusion(loadedModelId);
  }
}

This approach utilizes a two-layered defense:

1. Dynamic recovery: If a GPU driver error triggers a crash, the app intercepts it, saves "device": "cpu" to the .device-preference.json file, dynamically reloads the weights into CPU threads, and retries the generation. The client simply sees a status update indicating CPU fallback is occurring, surviving what would otherwise be a fatal crash.

2. Preference persistence: The next time the server starts or a page is loaded, the preflight loading routine reads the cached preference from the disk and loads the CPU model immediately:

const preferredDevice = getPreferredDevice(); // Reads .device-preference.json
const loadConfig = { prediction: "v" };
if (preferredDevice) {
  loadConfig.device = preferredDevice;
  if (preferredDevice === 'cpu') {
    loadConfig.threads = 4;
  }
}
loadedModelId = await loadModel({
  modelSrc: SD_V2_1_1B_Q8_0,
  modelType: "sdcpp-generation",
  modelConfig: loadConfig,
  // ...
});

This prevents the server from making redundant GPU load attempts on subsequent sessions, ensuring that the model is loaded only once and directly onto the correct hardware execution target.

[!WARNING] CPU Fallback Latency: While CPU mode guarantees resilience across older hardware, it uses sequential multi-threaded calculations instead of GPU hardware cores. Consequently, generation times will be significantly longer (typically 1 to 2 minutes on CPU compared to 10 to 15 seconds on a compatible GPU). Make sure to design responsive progress loaders in the UI to manage user expectations during fallback.

Conclusion

Running local-first Stable Diffusion with QVAC gives you absolute control over your inference costs and data privacy. By coupling on-device GGML models with a simple Node.js WebSocket backend, you can build responsive web tools that run completely offline without ever spending money on cloud APIs.

As mobile and desktop system-on-chip architectures continue to pack more neural engines, local-first AI architectures will become an increasingly powerful option for modern developers.

Resources and Further Reading

• QVAC Image-to-Image Generation Documentation

• QVAC SDK GitHub Repository

• Stable Diffusion GGUF models on Hugging Face

• Socket.io WebSockets Guide

• Full codebase