v0.2.4

• Precise mode is closer to the original at the same size: most experts are at 3 bits a weight now (by how much each is used), the
  rest at 2. KL divergence vs the original bf16 (wikitext-2, 32 x 512): 0.22 -> 0.15, perplexity 1.076x -> 1.037x the original's. On
  the mixed text set (code, docs, five languages, an agent transcript), over the original's 64 most likely tokens: 0.180 -> 0.136,
  top-1 87% -> 88%. Long documents: 0.073 -> 0.042. It writes about 10% slower than v0.2.3's precise (same build, warm chat on the 4080 SUPER: 100 vs 112 tok/s; after a 4K prompt 75 vs 91). Still 82 GB.
• Best mode too: 4 bits for the experts that carry about 80% of the work, 3 for the rest. wikitext-2 KL 0.165 -> 0.12 (perplexity
  1.052x -> 1.041x); mixed text set 0.146 -> 0.097, top-1 87.6% -> 89.9%; long documents 0.039 -> 0.028. About 5% slower than v0.2.3's
  best (warm chat 98 vs 104 tok/s). 90 GB in all (was 89), 64 GB of RAM.
• The new experts are new downloads, precise-v2/ (45 GB) and best-v2/ (53 GB): ./setup.sh fetches them, or tools/download.sh
  (--best). The old precise/ and best/ folders can be deleted after. Engines before v0.2.4 keep using the old folders. On
  Windows, run tools\install.ps1 after git pull first (setup.ps1 doesn't update the engine yet).
• Long prompts are read faster: a ~4K-token prompt's first token 1.70 -> 1.30 s in fast mode on the 4080 SUPER, 2.16 -> 1.84 s in
  precise. The experts are copied to the GPU through buffers of the copier threads' own instead of the driver's slow path.
• A named tool_choice gets one call to that tool (fast mode sometimes added a second one). Fast passes 18 of the 19 tool-call tests;
  the 12-round loop still overruns now and then with fast's experts.
• docs/CLIENTS.md: Hermes Agent needs a 64K context (GLYD_CTX=65536).
• Tested on Windows Server 2022 on an AWS L4 with only NVIDIA's driver installed (no CUDA toolkit): install, download, every test in
  tests/, the bench and the MCP server.

v0.2.3

• Images: PNG and JPEG in OpenAI image_url parts (base64, or a URL on a public host) and Anthropic image blocks, up to 1,024 tokens an image by default. The image encoder runs on the GPU and matches the reference model within bf16 noise; on a 4080 SUPER an image adds 0.3-2 s to the prompt, text speed is unchanged. Not yet: video, a camera's orientation tag, uploads on the chat page.
• Up to 4 requests at once (GLYD_USERS, 1 to 8), each streaming from the start; past that they wait in order. One user's speed is unchanged; total speed stays near one user's. A new long prompt pauses the other streams while it is read.
• Two cards: GLYD_GPUS=0,1 tools/serve.sh splits the layers over them and the second card's VRAM holds more experts. On 2x4090: the same output as one card, byte for byte; 189 vs 186 tok/s there.
• The MCP server reports its name as condor. New tests: tests/test_vision.py, tests/test_parallel.py.
• Still known: with the fast experts two of the 19 tool-call tests in tests/test_agents.py fail (a forced tool choice gets a second call; the 12-round tool loop overruns); 19 of 19 with precise and best.

Files: glyd-engine + libglyd_gpu_cuda13.so (Linux x86-64, glibc 2.34+), glyd-engine.exe + libglyd_gpu_cuda13.dll (Windows x64), SHA256SUMS. NVIDIA driver 580+. No new model download.

Upgrading: git pull, then ./setup.sh (it installs the new engine; nothing downloads again). On Windows run tools\install.ps1 after git pull.

v0.2.2

• Fast mode, same size, closer to the original: its experts are packed a new way, still 2 bits a weight. KL divergence vs bf16 (wikitext-2) 0.53 -> 0.39, top-1 79% -> 83%; on a mixed text set over the original's 64 most likely tokens 0.397 -> 0.295, top-1 78% -> 81%. GSM8K 149/150, MMLU-Pro 121/150. Speed the same on short and 4K prompts, 10-15% slower writing after a 30K prompt (124 / 116 / 125 tok/s on my 4080 SUPER).
• Fast mode's experts are a new download, fast/ (29 GB): ./setup.sh fetches them, or tools/download.sh --fast; the old pack/ folder can be deleted after. Precise and best need no new download.
• Known: with the new fast experts two of the 19 tool-call tests in tests/test_agents.py fail (a forced tool choice gets a second call; the 12-round tool loop overruns); 19 of 19 with precise and best. On the list for v0.2.3.
• The project is Condor; the repository is surya-koritala/condor (old links redirect).

Files: glyd-engine + libglyd_gpu_cuda13.so (Linux x86-64, glibc 2.34+), glyd-engine.exe + libglyd_gpu_cuda13.dll (Windows x64), SHA256SUMS. NVIDIA driver 580+.

Upgrading: git pull, then ./setup.sh (it installs the new engine, and the new fast experts if you use fast mode). On Windows run tools\install.ps1 after git pull, then tools\download.ps1 -Fast for fast mode.

v0.2.1

• Best mode: ./setup.sh asks, or tools/download.sh --best then tools/serve.sh --best (-Best on Windows). About 30% of the experts at 4 bits, the rest at 3. KL divergence vs bf16 (wikitext-2) 0.165, vs precise's 0.22. GSM8K 149/150, MMLU-Pro 128/150. About 10% slower than precise on short prompts. 52 GB of experts, 64 GB of RAM. Precise stays the default.
• MCP server on Ubuntu 22.04: glyd_stop left the server running and could stop the program that launched the MCP server. Fixed. glyd_start's fast and best modes now work on Linux.
• The Monitor tab and the bench block name best mode.

Files: glyd-engine + libglyd_gpu_cuda13.so (Linux x86-64, glibc 2.34+), glyd-engine.exe + libglyd_gpu_cuda13.dll (Windows x64), SHA256SUMS. NVIDIA driver 580+.

Upgrading: git pull, then ./setup.sh (it installs the new engine). On Windows run tools\install.ps1 after git pull. Precise and fast need no new download.

v0.2.0

• Precise mode is closer to the original model: experts repacked with calibration, the other weights at 6 bits. KL divergence vs bf16 (wikitext-2) 0.40 -> 0.22. GSM8K 148/150, MMLU-Pro 126/150.
• Windows 10/11 x64, native: setup.ps1 in PowerShell.
• 12 GB cards and 32 GB of RAM: setup picks fast mode below 64 GB.
• Tool calls and JSON mode work with agent frameworks; a second request waits its turn instead of failing.
• The repo is now glyd-condor; old links redirect.

Files: glyd-engine + libglyd_gpu_cuda13.so (Linux x86-64, glibc 2.34+), glyd-engine.exe + libglyd_gpu_cuda13.dll (Windows x64), SHA256SUMS. NVIDIA driver 580+.

Upgrading: git pull, then tools/download.sh (or tools\download.ps1) once to get the new precise pack, then start as usual. Fast mode needs no new download.

v0.1.1

Fixes for v0.1.0:

• The engine now runs on Ubuntu 22.04 and other Linux distributions from 2022 on. v0.1.0's engine needed a newer system library (glibc 2.38+) and failed to start there.
• setup.sh says how to update an NVIDIA driver older than 580.
• Tested on a clean Ubuntu 22.04 machine with an NVIDIA A10 (Ampere, 24 GB): all checks pass, 101 tokens/s in chat.

Install or update: git pull && ./setup.sh (it installs this engine when the old one is missing; to replace an installed v0.1.0, run tools/install.sh first).

Files: glyd-engine (compiled; Ampere, Ada, Hopper and Blackwell GPUs), libglyd_gpu_cuda13.so, SHA256SUMS. The engine is under the Business Source License 1.1 (ENGINE-LICENSE): free for personal and other non-commercial use.

v0.1.0

Qwen3.8-Flash-Next (180B, 512 experts a layer) on one 16 GB NVIDIA GPU with Glyd's own engine.

Install (Linux x86-64, NVIDIA RTX 30/40/50 series or newer with 16 GB+ and driver 580+, 64 GB RAM, about 90 GB of disk):

git clone https://github.com/surya-koritala/glyd-qwen-3.8-flash && cd glyd-qwen-3.8-flash
./setup.sh

setup.sh installs the engine from this release (checked against SHA256SUMS; nothing else to install), downloads the model from Hugging
Face and opens the chat app at http://127.0.0.1:8080/. The OpenAI- and Anthropic-compatible API is at http://127.0.0.1:8080/v1.

What's in it

• Two modes: precise (the default, best for code) and fast (about 15-20% faster).
• On an RTX 4080 SUPER: 117 tokens/s in a chat in precise mode, 135 in fast (up to 169-173 greedy); a 32K-token prompt read
  in about 7 s; contexts up to 262,144 tokens.
• GSM8K 148/150 in both modes; MMLU-Pro 124/150 precise, 118/150 fast.
• A chat app with tables, highlighted code, flowcharts, live previews of the pages and games it writes, and a live Monitor.
• Tool calls, streaming and reasoning over both APIs; follow-up messages reuse the conversation; Stop ends the answer at once.
• An MCP server (glyd-engine qwenmcp) and a speed test (tools/bench.sh).

Files

• glyd-engine: the Glyd engine (compiled; Ampere, Ada, Hopper and Blackwell GPUs).
• libglyd_gpu_cuda13.so: its CUDA library.
• SHA256SUMS.

The engine is under the Business Source License 1.1 (ENGINE-LICENSE): free for personal and other non-commercial use. The rest of
the repository is Apache-2.0.