gguf-cpp 0.0.3__tar.gz → 0.0.4__tar.gz

{gguf_cpp-0.0.3 → gguf_cpp-0.0.4}/CMakeLists.txt

@@ -6,9 +6,11 @@
 #   diffusion       -> src/gguf_cpp/diffuser/bin    (spawned by the diffuser panel)
 #   gguf_quantizer  -> src/gguf_cpp/editor/lib      (ctypes-loaded by the editor panel)
 #
-# The engine tree shares a single ggml kernels/ directory between all three,
-# so the compute kernels compile once. Modeled on the wrappers the three
-# standalone packages (gguf-server, gguf-diffusion, gguf-editor) used.
+# The engine tree shares a single ggml kernels/ directory between all three, so
+# the compute kernels compile once. Its own options are GGUF_CPP_*, so most of
+# what this file does is shape that build for a wheel; see vendor/gguf.cpp/
+# CMakeLists.txt for the engine itself and engine/README.md for how the tree is
+# assembled.
 cmake_minimum_required(VERSION 3.15)
 project(gguf_cpp C CXX)
 
@@ -27,21 +29,23 @@ set(GGUF_CPP_ENGINE_DIR "" CACHE PATH "Path to the unified gguf.cpp engine sourc
 if(NOT GGUF_CPP_ENGINE_DIR AND DEFINED ENV{GGUF_CPP_ENGINE_DIR})
     set(GGUF_CPP_ENGINE_DIR "$ENV{GGUF_CPP_ENGINE_DIR}")
 endif()
-if(NOT GGUF_CPP_ENGINE_DIR AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/vendor/engine/CMakeLists.txt")
-    set(GGUF_CPP_ENGINE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/vendor/engine")
+if(NOT GGUF_CPP_ENGINE_DIR AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/vendor/gguf.cpp/CMakeLists.txt")
+    set(GGUF_CPP_ENGINE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/vendor/gguf.cpp")
 endif()
-if(NOT GGUF_CPP_ENGINE_DIR OR NOT EXISTS "${GGUF_CPP_ENGINE_DIR}/app/CMakeLists.txt")
+if(NOT GGUF_CPP_ENGINE_DIR OR NOT EXISTS "${GGUF_CPP_ENGINE_DIR}/kernels/CMakeLists.txt")
     message(FATAL_ERROR
         "gguf.cpp engine source not found. Provide it via one of:\n"
-        "  - the vendored copy at vendor/engine\n"
-        "  - -DGGUF_CPP_ENGINE_DIR=/path/to/engine or the same env var")
+        "  - the vendored tree at vendor/gguf.cpp (python scripts/vendor_engine.py)\n"
+        "  - -DGGUF_CPP_ENGINE_DIR=/path/to/gguf.cpp or the same env var")
 endif()
 get_filename_component(GGUF_CPP_ENGINE_DIR "${GGUF_CPP_ENGINE_DIR}" ABSOLUTE)
 message(STATUS "gguf-cpp: engine source at ${GGUF_CPP_ENGINE_DIR}")
 
 # ── Option helper ────────────────────────────────────────────────────────────
-# Values are read from the environment as well as -D, because `pip install`
-# makes environment variables far easier to pass than CMake defines:
+# The engine declares its own GGUF_CPP_* options; declaring them here first
+# wins, because option() leaves an existing cache entry alone. Values are read
+# from the environment as well as -D, because `pip install` makes environment
+# variables far easier to pass than CMake defines:
 #   GGUF_CPP_CUDA=1 pip install .
 #   CMAKE_ARGS="-DGGUF_CPP_CUDA=ON" pip install .
 function(gguf_cpp_option name docstring default)
@@ -51,12 +55,49 @@ function(gguf_cpp_option name docstring default)
     option(${name} "${docstring}" "${default}")
 endfunction()
 
+# ── Components ───────────────────────────────────────────────────────────────
+gguf_cpp_option(GGUF_CPP_SERVER    "Build the LLM server engine" ON)
+gguf_cpp_option(GGUF_CPP_DIFFUSION "Build the diffusion engine"  ON)
+gguf_cpp_option(GGUF_CPP_QUANTIZER "Build the quantizer engine"  ON)
+
+# ── GPU / accelerator backends ───────────────────────────────────────────────
+# One switch per backend drives the whole engine: the shared ggml kernels
+# (server + diffusion) and, for CUDA/HIP/Metal, the quantizer's own device
+# kernels. Anything else ggml supports can still be passed through as -DGGML_*.
+gguf_cpp_option(GGUF_CPP_CUDA   "Build the engine with the CUDA backend"   OFF)
+gguf_cpp_option(GGUF_CPP_HIP    "Build the engine with the HIP backend"    OFF)
+gguf_cpp_option(GGUF_CPP_VULKAN "Build the engine with the Vulkan backend" OFF)
+if(APPLE)  # matches the engine's own default; APPLE is "" elsewhere, not a valid default
+    set(_gguf_metal_default ON)
+else()
+    set(_gguf_metal_default OFF)
+endif()
+gguf_cpp_option(GGUF_CPP_METAL  "Build the engine with the Metal backend"  ${_gguf_metal_default})
+gguf_cpp_option(GGUF_CPP_BLAS   "Build the engine with the BLAS backend"   OFF)
+
+# ── HTTPS / OpenSSL ──────────────────────────────────────────────────────────
+# Off by default (the engine itself defaults it on). OpenSSL is only needed to
+# *download* models over HTTPS (-hf / URL arguments); the panels always hand the
+# engine local file paths, so the dependency buys nothing and costs portability:
+# find_package(OpenSSL) happily picks up a foreign-ABI install — an MSYS2 /
+# MinGW libcrypto next to an MSVC toolchain puts MinGW headers on cl.exe's
+# include path and breaks httplib.cpp, download.cpp and hf-cache.cpp with
+# "winnt.h: fatal error C1189: No supported target architecture".
+gguf_cpp_option(GGUF_SERVER_OPENSSL
+    "Link the LLM server against OpenSSL for HTTPS model downloads" OFF)
+
+# Router mode (`--models`) spawns child servers via subprocess.h — harmless to
+# keep and the GUI's custom-command box can use it.
+gguf_cpp_option(GGUF_SERVER_SUBPROCESS
+    "Support router mode (the LLM server spawns child servers)" ON)
+
 # ── Windows / MinGW toolchain fixes ──────────────────────────────────────────
 if(WIN32 AND NOT MSVC)
     # MinGW-w64's headers pin _WIN32_WINNT to a Windows 7-era value before the
     # engine gets a chance to set it; cpp-httplib then hard-errors and
-    # ::CreateFile2 goes undeclared. Set it up front, matching what the engine
-    # expects everywhere else.
+    # ::CreateFile2 goes undeclared, which takes down httplib.cpp, download.cpp
+    # and hf-cache.cpp. Set it up front, matching what the engine expects
+    # everywhere else.
     add_compile_definitions(_WIN32_WINNT=0x0A00 WINVER=0x0A00 NTDDI_VERSION=0x0A000000)
 
     # A MinGW-built binary otherwise needs libstdc++-6.dll, libgcc_s_seh-1.dll
@@ -93,55 +134,17 @@ endif()
 # ── Shape the engine build for a single-file-per-artifact wheel ──────────────
 # Static libs (ggml, llama, llama-common, mtmd, diffusion, …) linked straight
 # into the executables keep the wheel to standalone binaries with no
-# rpath/DLL handling. The quantizer stays a shared library by design (ctypes).
-set(BUILD_SHARED_LIBS  OFF CACHE BOOL "gguf-cpp: static engine for single-file installs" FORCE)
+# rpath/DLL handling. The quantizer stays a shared library by design (ctypes) —
+# the engine sets CMAKE_POSITION_INDEPENDENT_CODE so it can link static ggml.
+set(BUILD_SHARED_LIBS    OFF CACHE BOOL "gguf-cpp: static engine for single-file installs" FORCE)
+set(SD_BUILD_SHARED_LIBS OFF CACHE BOOL "gguf-cpp: static diffusion library" FORCE)
 
 # The engine's own install() rules would put artifacts in the wheel's data
 # directory; ours below place them inside the package instead.
-set(GGUF_SERVER_INSTALL OFF CACHE BOOL "gguf-cpp: install rules are ours" FORCE)
-
-# Router mode (`--models`) spawns child servers via subprocess.h — harmless to
-# keep and the GUI's custom-command box can use it.
-gguf_cpp_option(GGUF_CPP_SUBPROCESS
-    "Support router mode (the server engine spawns child servers)" ON)
-set(GGUF_SERVER_SUBPROCESS ${GGUF_CPP_SUBPROCESS} CACHE BOOL "" FORCE)
-
-# ── HTTPS / OpenSSL ──────────────────────────────────────────────────────────
-# Off by default: OpenSSL is only needed to *download* models over HTTPS; the
-# panels always hand the engine local file paths, so the dependency buys
-# nothing and costs portability (a foreign-ABI OpenSSL next to the toolchain
-# breaks the build on Windows).
-gguf_cpp_option(GGUF_CPP_OPENSSL
-    "Link the server engine against OpenSSL for HTTPS model downloads" OFF)
-set(GGUF_SERVER_OPENSSL ${GGUF_CPP_OPENSSL} CACHE BOOL "" FORCE)
-
-# ── GPU / accelerator backends ───────────────────────────────────────────────
-# One switch per backend drives the whole engine: the shared ggml kernels
-# (server + diffusion) and, for CUDA/HIP, the quantizer's own device kernels.
-# Anything else ggml supports can still be passed straight through as -DGGML_*.
-gguf_cpp_option(GGUF_CPP_CUDA   "Build the engine with the CUDA backend"   OFF)
-gguf_cpp_option(GGUF_CPP_HIP    "Build the engine with the HIP backend"    OFF)
-gguf_cpp_option(GGUF_CPP_VULKAN "Build the engine with the Vulkan backend" OFF)
-if(APPLE)  # matches the engine's own default; APPLE is "" elsewhere, not a valid default
-    set(_gguf_metal_default ON)
-else()
-    set(_gguf_metal_default OFF)
-endif()
-gguf_cpp_option(GGUF_CPP_METAL  "Build the engine with the Metal backend"  ${_gguf_metal_default})
-
-set(GGUF_SERVER_CUDA   ${GGUF_CPP_CUDA}   CACHE BOOL "" FORCE)
-set(GGUF_SERVER_HIP    ${GGUF_CPP_HIP}    CACHE BOOL "" FORCE)
-set(GGUF_SERVER_VULKAN ${GGUF_CPP_VULKAN} CACHE BOOL "" FORCE)
-set(GGUF_SERVER_METAL  ${GGUF_CPP_METAL}  CACHE BOOL "" FORCE)
-
-# The quantizer's GPU path is its own small kernel set, not ggml; CUDA/HIP
-# follow the engine-wide switch. Its Metal path stays opt-in (QUANTIZER_METAL),
-# matching the standalone gguf-editor defaults.
-set(QUANTIZER_CUDA ${GGUF_CPP_CUDA} CACHE BOOL "" FORCE)
-set(QUANTIZER_HIP  ${GGUF_CPP_HIP}  CACHE BOOL "" FORCE)
+set(GGUF_CPP_INSTALL OFF CACHE BOOL "gguf-cpp: install rules are ours" FORCE)
 
 set(GGUF_CPP_ENABLED_BACKENDS "")
-foreach(backend IN ITEMS CUDA HIP VULKAN METAL)
+foreach(backend IN ITEMS CUDA HIP VULKAN METAL BLAS)
     if(GGUF_CPP_${backend})
         list(APPEND GGUF_CPP_ENABLED_BACKENDS ${backend})
     endif()
@@ -155,8 +158,8 @@ endif()
 
 # ── Embedded web UI ──────────────────────────────────────────────────────────
 # The server engine embeds whatever static assets live in GGUF_SERVER_UI_DIR
-# (default <engine>/ui/dist). The tree ships none, so the engine is API-only —
-# irrelevant here, because this package serves its own GUI.
+# (default <engine>/llm/ui/dist). The tree ships none, so the engine is
+# API-only — irrelevant here, because this package serves its own GUI.
 if(NOT DEFINED CACHE{GGUF_SERVER_UI_DIR} AND DEFINED ENV{GGUF_SERVER_UI_DIR})
     set(GGUF_SERVER_UI_DIR "$ENV{GGUF_SERVER_UI_DIR}" CACHE PATH
         "directory with web UI assets to embed into the server engine")
@@ -167,46 +170,48 @@ endif()
 # the libraries they link against.
 add_subdirectory("${GGUF_CPP_ENGINE_DIR}" "${CMAKE_BINARY_DIR}/gguf-cpp-engine" EXCLUDE_FROM_ALL)
 
-foreach(required_target IN ITEMS gguf-server diffusion-cli gguf_quantizer)
-    if(NOT TARGET ${required_target})
-        message(FATAL_ERROR "engine did not define the ${required_target} target — is ${GGUF_CPP_ENGINE_DIR} the unified gguf.cpp source tree?")
-    endif()
-endforeach()
-
 add_custom_target(gguf_cpp_engine ALL)
-add_dependencies(gguf_cpp_engine gguf-server diffusion-cli gguf_quantizer)
+
+if(GGUF_CPP_SERVER)
+    if(NOT TARGET gguf-server)
+        message(FATAL_ERROR "engine did not define the gguf-server target — is ${GGUF_CPP_ENGINE_DIR} the unified gguf.cpp source tree?")
+    endif()
+    add_dependencies(gguf_cpp_engine gguf-server)
+endif()
+if(GGUF_CPP_DIFFUSION)
+    if(NOT TARGET diffusion-cli)
+        message(FATAL_ERROR "engine did not define the diffusion-cli target")
+    endif()
+    add_dependencies(gguf_cpp_engine diffusion-cli)
+endif()
+if(GGUF_CPP_QUANTIZER)
+    if(NOT TARGET gguf_quantizer)
+        message(FATAL_ERROR "engine did not define the gguf_quantizer target")
+    endif()
+    add_dependencies(gguf_cpp_engine gguf_quantizer)
+endif()
 
 # ── Install into the panel packages ──────────────────────────────────────────
 # Install into the wheel (SKBUILD_PLATLIB_DIR) and also into the source tree
 # so editable installs (`pip install -e .`) find the artifacts — the same dual
 # install the three standalone packages used.
-install(
-    PROGRAMS $<TARGET_FILE:gguf-server>
-    DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/src/gguf_cpp/server/bin"
-)
-install(
-    PROGRAMS $<TARGET_FILE:diffusion-cli>
-    DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/src/gguf_cpp/diffuser/bin"
-)
-install(
-    TARGETS gguf_quantizer
-    LIBRARY DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/src/gguf_cpp/editor/lib"
-    RUNTIME DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/src/gguf_cpp/editor/lib"
-    ARCHIVE DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/src/gguf_cpp/editor/lib"
-)
+set(_gguf_dests "${CMAKE_CURRENT_SOURCE_DIR}/src/gguf_cpp")
 if(DEFINED SKBUILD_PLATLIB_DIR)
-    install(
-        PROGRAMS $<TARGET_FILE:gguf-server>
-        DESTINATION "${SKBUILD_PLATLIB_DIR}/gguf_cpp/server/bin"
-    )
-    install(
-        PROGRAMS $<TARGET_FILE:diffusion-cli>
-        DESTINATION "${SKBUILD_PLATLIB_DIR}/gguf_cpp/diffuser/bin"
-    )
-    install(
-        TARGETS gguf_quantizer
-        LIBRARY DESTINATION "${SKBUILD_PLATLIB_DIR}/gguf_cpp/editor/lib"
-        RUNTIME DESTINATION "${SKBUILD_PLATLIB_DIR}/gguf_cpp/editor/lib"
-        ARCHIVE DESTINATION "${SKBUILD_PLATLIB_DIR}/gguf_cpp/editor/lib"
-    )
+    list(APPEND _gguf_dests "${SKBUILD_PLATLIB_DIR}/gguf_cpp")
 endif()
+
+foreach(dest IN LISTS _gguf_dests)
+    if(GGUF_CPP_SERVER)
+        install(PROGRAMS $<TARGET_FILE:gguf-server> DESTINATION "${dest}/server/bin")
+    endif()
+    if(GGUF_CPP_DIFFUSION)
+        install(PROGRAMS $<TARGET_FILE:diffusion-cli> DESTINATION "${dest}/diffuser/bin")
+    endif()
+    if(GGUF_CPP_QUANTIZER)
+        install(TARGETS gguf_quantizer
+            LIBRARY DESTINATION "${dest}/editor/lib"
+            RUNTIME DESTINATION "${dest}/editor/lib"
+            ARCHIVE DESTINATION "${dest}/editor/lib"
+        )
+    endif()
+endforeach()

{gguf_cpp-0.0.3 → gguf_cpp-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gguf-cpp
-Version: 0.0.3
+Version: 0.0.4
 Summary: Unified GUI + engine for GGUF models: local LLM server, image generation and GGUF editing/quantization, all on one bundled gguf.cpp engine
 Author-Email: gguf <info@gguf.us>
 License: MIT
@@ -67,13 +67,35 @@ gguf-cpp editor devices
 ## Layout
 
 ```
-vendor/engine/           the unified gguf.cpp engine (one CMake build)
+vendor/gguf.cpp/         the unified gguf.cpp engine (one CMake build)
   kernels/               shared ggml kernels (CPU + optional GPU backends)
-  src/ common/ mtmd/     GGUF LLM runtime
-  app/                   the gguf-server HTTP server
+  llm/                   GGUF LLM runtime + the gguf-server HTTP server
   diffusion/             diffusion runtime + CLI
-  quantizer/             quantizer shared library (shares the kernels above)
+  quantizer/             quantizer shared library
+engine/                  the hand written CMake files, overlaid onto the above
+scripts/vendor_engine.py assembles vendor/gguf.cpp from the three checkouts
 src/gguf_cpp/            the Python package
   server/ diffuser/ editor/   the three panels (backend + web frontend each)
   gui.py static/         the unified 3-panel GUI shell
 ```
+
+Each front end under `vendor/gguf.cpp/` is one self-contained directory, so an
+engine update touches only the directory it belongs to. The tree is generated,
+not edited: everything hand written lives in `engine/` and is laid on top by the
+vendoring script.
+
+## Updating the engine
+
+`vendor/gguf.cpp/` is assembled from three sibling checkouts — `../server`,
+`../diffusion` and `../quantizer`. Pull those, then:
+
+```bash
+python scripts/vendor_engine.py
+```
+
+The script copies each checkout into its own subdirectory, drops the two
+redundant ggml copies in favour of the shared `kernels/`, applies the handful of
+mechanical edits the merge needs (each one reported as it runs), and lays
+`engine/` over the result. If an edit no longer matches, it fails rather than
+emit a tree that would not build. See `engine/README.md` for what changes and
+why.

{gguf_cpp-0.0.3 → gguf_cpp-0.0.4}/README.md

@@ -49,13 +49,35 @@ gguf-cpp editor devices
 ## Layout
 
 ```
-vendor/engine/           the unified gguf.cpp engine (one CMake build)
+vendor/gguf.cpp/         the unified gguf.cpp engine (one CMake build)
   kernels/               shared ggml kernels (CPU + optional GPU backends)
-  src/ common/ mtmd/     GGUF LLM runtime
-  app/                   the gguf-server HTTP server
+  llm/                   GGUF LLM runtime + the gguf-server HTTP server
   diffusion/             diffusion runtime + CLI
-  quantizer/             quantizer shared library (shares the kernels above)
+  quantizer/             quantizer shared library
+engine/                  the hand written CMake files, overlaid onto the above
+scripts/vendor_engine.py assembles vendor/gguf.cpp from the three checkouts
 src/gguf_cpp/            the Python package
   server/ diffuser/ editor/   the three panels (backend + web frontend each)
   gui.py static/         the unified 3-panel GUI shell
 ```
+
+Each front end under `vendor/gguf.cpp/` is one self-contained directory, so an
+engine update touches only the directory it belongs to. The tree is generated,
+not edited: everything hand written lives in `engine/` and is laid on top by the
+vendoring script.
+
+## Updating the engine
+
+`vendor/gguf.cpp/` is assembled from three sibling checkouts — `../server`,
+`../diffusion` and `../quantizer`. Pull those, then:
+
+```bash
+python scripts/vendor_engine.py
+```
+
+The script copies each checkout into its own subdirectory, drops the two
+redundant ggml copies in favour of the shared `kernels/`, applies the handful of
+mechanical edits the merge needs (each one reported as it runs), and lays
+`engine/` over the result. If an edit no longer matches, it fails rather than
+emit a tree that would not build. See `engine/README.md` for what changes and
+why.

gguf_cpp-0.0.4/engine/CMakeLists.txt

@@ -0,0 +1,217 @@
+# gguf.cpp — the unified engine behind the gguf-cpp package.
+#
+# One CMake project, one set of compute kernels, three front ends:
+#
+#   kernels/     the shared ggml (CPU + optional GPU backends), built once
+#   llm/         llama runtime + the OpenAI-compatible HTTP server (gguf-server)
+#   diffusion/   the stable-diffusion runtime + its CLI (diffusion)
+#   quantizer/   the GGUF quantizer shared library (gguf_quantizer, ctypes)
+#
+# Previously each front end carried its own copy of ggml and was configured and
+# compiled separately. Here they are configured together and every backend —
+# CPU, CUDA, HIP, Vulkan, Metal — is compiled exactly once and linked into all
+# three artifacts.
+#
+# Layout is produced by ../scripts/vendor_engine.py; this file and the
+# CMakeLists.txt of llm/, diffusion/ and quantizer/ are the hand written part.
+
+cmake_minimum_required(VERSION 3.15...3.28)
+project("gguf.cpp" C CXX)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+if (NOT XCODE AND NOT MSVC AND NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+message(STATUS "gguf.cpp: CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+
+set(CMAKE_C_STANDARD          11)
+set(CMAKE_C_STANDARD_REQUIRED true)
+set(CMAKE_CXX_STANDARD        17)
+set(CMAKE_CXX_STANDARD_REQUIRED true)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+# The quantizer ships as a shared library that links the otherwise static ggml,
+# so every object in the build has to be position independent.
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if (WIN32)
+    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+endif()
+if (MSVC)
+    add_compile_definitions(_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING)
+    add_compile_options("$<$<COMPILE_LANGUAGE:C>:/utf-8>"   "$<$<COMPILE_LANGUAGE:CXX>:/utf-8>")
+    add_compile_options("$<$<COMPILE_LANGUAGE:C>:/bigobj>"  "$<$<COMPILE_LANGUAGE:CXX>:/bigobj>")
+    add_compile_options("$<$<COMPILE_LANGUAGE:C>:/MP>"      "$<$<COMPILE_LANGUAGE:CXX>:/MP>")
+    list(APPEND CMAKE_VS_GLOBALS UseMultiToolTask=true)
+    list(APPEND CMAKE_VS_GLOBALS EnforceProcessCountAcrossBuilds=true)
+    # statically link the CRT so the binaries run without the VC++ redistributable
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>" CACHE STRING "" FORCE)
+endif()
+
+# ── Components ───────────────────────────────────────────────────────────────
+
+option(GGUF_CPP_SERVER    "gguf.cpp: build the LLM server engine"  ON)
+option(GGUF_CPP_DIFFUSION "gguf.cpp: build the diffusion engine"   ON)
+option(GGUF_CPP_QUANTIZER "gguf.cpp: build the quantizer engine"   ON)
+option(GGUF_CPP_INSTALL   "gguf.cpp: install the built artifacts"  ON)
+
+# ── Backends ─────────────────────────────────────────────────────────────────
+#
+# One switch per accelerator for the whole engine: the backend is compiled once
+# and shared by the server, the diffuser and the quantizer's ggml path. The
+# per-engine spellings the three source trees used before (GGUF_SERVER_CUDA,
+# SD_CUDA, QUANTIZER_CUDA, …) are accepted as aliases so existing build
+# invocations keep working.
+
+if (APPLE)
+    set(GGUF_CPP_METAL_DEFAULT ON)
+else()
+    set(GGUF_CPP_METAL_DEFAULT OFF)
+endif()
+
+option(GGUF_CPP_CUDA   "gguf.cpp: CUDA backend (NVIDIA)"        OFF)
+option(GGUF_CPP_HIP    "gguf.cpp: HIP/ROCm backend (AMD)"       OFF)
+option(GGUF_CPP_VULKAN "gguf.cpp: Vulkan backend"               OFF)
+option(GGUF_CPP_METAL  "gguf.cpp: Metal backend (Apple)"        ${GGUF_CPP_METAL_DEFAULT})
+option(GGUF_CPP_BLAS   "gguf.cpp: BLAS backend"                 OFF)
+
+foreach (alias IN ITEMS GGUF_SERVER_CUDA SD_CUDA QUANTIZER_CUDA)
+    if (${alias})
+        set(GGUF_CPP_CUDA ON)
+    endif()
+endforeach()
+foreach (alias IN ITEMS GGUF_SERVER_HIP SD_HIPBLAS QUANTIZER_HIP)
+    if (${alias})
+        set(GGUF_CPP_HIP ON)
+    endif()
+endforeach()
+foreach (alias IN ITEMS GGUF_SERVER_VULKAN SD_VULKAN)
+    if (${alias})
+        set(GGUF_CPP_VULKAN ON)
+    endif()
+endforeach()
+foreach (alias IN ITEMS GGUF_SERVER_METAL SD_METAL QUANTIZER_METAL)
+    if (${alias})
+        set(GGUF_CPP_METAL ON)
+    endif()
+endforeach()
+if (GGUF_SERVER_BLAS)
+    set(GGUF_CPP_BLAS ON)
+endif()
+
+if (GGUF_CPP_CUDA AND GGUF_CPP_HIP)
+    message(FATAL_ERROR "gguf.cpp: GGUF_CPP_CUDA and GGUF_CPP_HIP are mutually exclusive")
+endif()
+
+set(GGUF_CPP_BACKENDS "CPU")
+if (GGUF_CPP_CUDA)
+    set(GGML_CUDA ON)
+    list(APPEND GGUF_CPP_BACKENDS "CUDA")
+endif()
+if (GGUF_CPP_HIP)
+    set(GGML_HIP ON)
+    list(APPEND GGUF_CPP_BACKENDS "HIP")
+endif()
+if (GGUF_CPP_VULKAN)
+    set(GGML_VULKAN ON)
+    list(APPEND GGUF_CPP_BACKENDS "Vulkan")
+endif()
+if (GGUF_CPP_METAL)
+    set(GGML_METAL ON)
+    list(APPEND GGUF_CPP_BACKENDS "Metal")
+endif()
+if (GGUF_CPP_BLAS)
+    set(GGML_BLAS ON)
+    list(APPEND GGUF_CPP_BACKENDS "BLAS")
+endif()
+string(REPLACE ";" ", " GGUF_CPP_BACKEND_LIST "${GGUF_CPP_BACKENDS}")
+message(STATUS "gguf.cpp: backends: ${GGUF_CPP_BACKEND_LIST}")
+
+# The quantizer's GPU paths are its own hand written kernels, kept independent
+# of the ggml backends (they run without a ggml context).
+set(QUANTIZER_CUDA  ${GGUF_CPP_CUDA})
+set(QUANTIZER_HIP   ${GGUF_CPP_HIP})
+set(QUANTIZER_METAL ${GGUF_CPP_METAL})
+
+# ── Diagnostics ──────────────────────────────────────────────────────────────
+
+option(GGUF_CPP_ALL_WARNINGS      "gguf.cpp: enable all compiler warnings" ON)
+option(GGUF_CPP_FATAL_WARNINGS    "gguf.cpp: enable -Werror"               OFF)
+option(GGUF_CPP_SANITIZE_THREAD    "gguf.cpp: thread sanitizer"            OFF)
+option(GGUF_CPP_SANITIZE_ADDRESS   "gguf.cpp: address sanitizer"           OFF)
+option(GGUF_CPP_SANITIZE_UNDEFINED "gguf.cpp: undefined sanitizer"         OFF)
+
+# the vendored sources still use the LLAMA_* names internally
+set(LLAMA_ALL_WARNINGS       ${GGUF_CPP_ALL_WARNINGS})
+set(LLAMA_FATAL_WARNINGS     ${GGUF_CPP_FATAL_WARNINGS})
+set(LLAMA_SANITIZE_THREAD    ${GGUF_CPP_SANITIZE_THREAD})
+set(LLAMA_SANITIZE_ADDRESS   ${GGUF_CPP_SANITIZE_ADDRESS})
+set(LLAMA_SANITIZE_UNDEFINED ${GGUF_CPP_SANITIZE_UNDEFINED})
+
+set(GGML_ALL_WARNINGS   ${GGUF_CPP_ALL_WARNINGS})
+set(GGML_FATAL_WARNINGS ${GGUF_CPP_FATAL_WARNINGS})
+
+# ── Shared kernels ───────────────────────────────────────────────────────────
+
+# The diffusion runtime asserts GGML_MAX_NAME >= 128 (ggml_extend.hpp). It is a
+# compile-time constant that changes the layout of struct ggml_tensor, so it has
+# to be set for *everything* — kernels, llama runtime and both front ends —
+# before the first target is defined.
+add_compile_definitions(GGML_MAX_NAME=128)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/llm/cmake/")
+include(build-info)
+
+if (NOT DEFINED LLAMA_BUILD_NUMBER)
+    set(LLAMA_BUILD_NUMBER ${BUILD_NUMBER})
+endif()
+if (NOT DEFINED LLAMA_BUILD_COMMIT)
+    set(LLAMA_BUILD_COMMIT ${BUILD_COMMIT})
+endif()
+set(LLAMA_INSTALL_VERSION 0.0.${LLAMA_BUILD_NUMBER})
+set(GGML_BUILD_NUMBER ${LLAMA_BUILD_NUMBER})
+set(GGML_BUILD_COMMIT ${LLAMA_BUILD_COMMIT})
+
+if (NOT DEFINED GGML_LLAMAFILE)
+    set(GGML_LLAMAFILE_DEFAULT ON)
+endif()
+if (NOT DEFINED GGML_CUDA_GRAPHS)
+    set(GGML_CUDA_GRAPHS_DEFAULT ON)
+endif()
+
+# Everything links ggml statically: one executable per front end, no shared
+# object to locate at run time.
+if (NOT DEFINED BUILD_SHARED_LIBS)
+    set(BUILD_SHARED_LIBS OFF)
+endif()
+
+set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
+
+add_subdirectory(kernels)   # ggml — built once, shared by all three front ends
+
+# ── Front ends ───────────────────────────────────────────────────────────────
+
+if (GGUF_CPP_SERVER)
+    add_subdirectory(llm)
+endif()
+
+if (GGUF_CPP_DIFFUSION)
+    add_subdirectory(diffusion)
+endif()
+
+if (GGUF_CPP_QUANTIZER)
+    add_subdirectory(quantizer)
+endif()
+
+# A single target that builds every enabled front end in one go — this is what
+# the Python package's CMakeLists depends on.
+add_custom_target(gguf-cpp-engines ALL)
+foreach (component IN ITEMS gguf-server diffusion-cli gguf_quantizer)
+    if (TARGET ${component})
+        add_dependencies(gguf-cpp-engines ${component})
+    endif()
+endforeach()

gguf_cpp-0.0.4/engine/README.md

@@ -0,0 +1,74 @@
+# engine/ — the hand written part of gguf.cpp
+
+`vendor/gguf.cpp` is assembled by `scripts/vendor_engine.py`: it copies the
+sources from the three upstream checkouts and then lays these files on top.
+Keeping them here means the vendored tree stays disposable — re-running the
+script against newer checkouts is the whole update procedure.
+
+```
+engine/
+    CMakeLists.txt                     the unified top level
+    llm/CMakeLists.txt                 replaces ../server/CMakeLists.txt
+    diffusion/CMakeLists.txt           replaces ../diffusion/CMakeLists.txt
+    quantizer/CMakeLists.txt           replaces ../quantizer/CMakeLists.txt
+    quantizer/src/kernels/qz-ggml.h    the quantizer's view of the shared ggml
+    quantizer/src/kernels/qz-compat.c  the two helpers ggml does not provide
+```
+
+## What changes, and why
+
+**One kernels tree.** `../server` and `../diffusion` each carried a full ggml
+(0.17.0 and 0.15.3). The shared `kernels/` is the server's: its public headers
+are a superset of the diffusion tree's, and `ggml-impl.h` — the one internal
+header the diffusion runtime reaches into — is identical in both. The top level
+adds `kernels/` once, before any front end, so every backend is compiled a
+single time.
+
+**Global settings move up.** Standards, output directories, MSVC flags, the
+backend switches (`GGUF_CPP_CUDA` and friends, mapped onto `GGML_*`) and the
+build info are set once at the top level. The per-engine spellings the three
+trees used (`GGUF_SERVER_CUDA`, `SD_CUDA`, `QUANTIZER_CUDA`, …) are still
+accepted as aliases. `GGML_MAX_NAME=128` — which the diffusion runtime asserts
+and which changes the layout of `struct ggml_tensor` — is set for the whole
+build rather than one subtree.
+
+**Position independent code everywhere.** The quantizer ships as a shared
+library that links the otherwise static ggml.
+
+**The quantizer stops carrying kernels.** Standalone it was deliberately
+ggml-free: a verbatim copy of `ggml-quants.c` and `ggml-common.h`, plus
+`qz-traits.c` / `qz-init.cpp` re-implementing the type-trait table, the fp16 and
+bf16 row conversions and `ggml_quantize_chunk()`. All of that is in the shared
+kernels, so the copies are gone and `gguf_quantizer` links `ggml-base` instead.
+What remains is `qz-compat.c`: `qz_dequantize()` (over `ggml_get_type_traits()
+->to_float`) and `qz_is_quantize_target()`. `qz-ggml.h` keeps the include the
+quantizer's sources already used and just forwards to the real `ggml.h`.
+
+The upshot is that the type-trait table, the fp16/bf16 row conversions and
+`ggml_quantize_chunk()` exist exactly once in the build. Standalone they were a
+hand-maintained duplicate that had to be edited for every quant type the fork
+adds — `q2_0` was patched into `qz-traits.c` by hand, and anything added after
+it would have silently disagreed with what the server and diffuser can read.
+
+**No quantizer CLI.** The editor panel drives the library through ctypes, so
+`../quantizer/src/main.cpp` is not vendored and only `gguf_quantizer` is built.
+
+## Rewrites the vendor script applies
+
+Mechanical substitutions, reported as they run — anything else would mean
+upstream changed and the merge needs a look, so a rewrite that no longer matches
+is a hard error:
+
+| File | Change |
+|------|--------|
+| `quantizer/src/{quantize.cpp,gguf_io.h,device.h}` | `#include "kernels/ggml.h"` → `"kernels/qz-ggml.h"` |
+| `llm/cmake/common.cmake` | ggml's cmake helpers now sit one directory further up |
+| `kernels/src/CMakeLists.txt` | skip an enabled-but-not-vendored ggml backend instead of aborting (`GGML_BLAS` defaults ON on Apple, and no `ggml-blas/` is vendored) |
+
+Two paths need no rewrite:
+
+* the diffusion runtime's `#include "kernels/src/ggml-impl.h"` — its CMakeLists
+  adds the engine root to the include path, where `kernels/` now lives;
+* `diffusion/cli/CMakeLists.txt`'s `${PROJECT_SOURCE_DIR}/src` — the overlay's
+  `diffusion/CMakeLists.txt` keeps its `project("diffusion")` call, so
+  `PROJECT_SOURCE_DIR` still points at the diffusion subtree.