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

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

@@ -6,11 +6,9 @@
 #   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. 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.
+# 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.
 cmake_minimum_required(VERSION 3.15)
 project(gguf_cpp C CXX)
 
@@ -29,23 +27,21 @@ 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/gguf.cpp/CMakeLists.txt")
-    set(GGUF_CPP_ENGINE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/vendor/gguf.cpp")
+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")
 endif()
-if(NOT GGUF_CPP_ENGINE_DIR OR NOT EXISTS "${GGUF_CPP_ENGINE_DIR}/kernels/CMakeLists.txt")
+if(NOT GGUF_CPP_ENGINE_DIR OR NOT EXISTS "${GGUF_CPP_ENGINE_DIR}/app/CMakeLists.txt")
     message(FATAL_ERROR
         "gguf.cpp engine source not found. Provide it via one of:\n"
-        "  - 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")
+        "  - the vendored copy at vendor/engine\n"
+        "  - -DGGUF_CPP_ENGINE_DIR=/path/to/engine 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 ────────────────────────────────────────────────────────────
-# 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:
+# 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)
@@ -55,49 +51,12 @@ 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, which takes down httplib.cpp, download.cpp
-    # and hf-cache.cpp. Set it up front, matching what the engine expects
-    # everywhere else.
+    # ::CreateFile2 goes undeclared. 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
@@ -134,17 +93,55 @@ 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) —
-# 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)
+# 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)
 
 # 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_CPP_INSTALL OFF CACHE BOOL "gguf-cpp: install rules are ours" FORCE)
+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_ENABLED_BACKENDS "")
-foreach(backend IN ITEMS CUDA HIP VULKAN METAL BLAS)
+foreach(backend IN ITEMS CUDA HIP VULKAN METAL)
     if(GGUF_CPP_${backend})
         list(APPEND GGUF_CPP_ENABLED_BACKENDS ${backend})
     endif()
@@ -158,8 +155,8 @@ endif()
 
 # ── Embedded web UI ──────────────────────────────────────────────────────────
 # The server engine embeds whatever static assets live in GGUF_SERVER_UI_DIR
-# (default <engine>/llm/ui/dist). The tree ships none, so the engine is
-# API-only — irrelevant here, because this package serves its own GUI.
+# (default <engine>/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")
@@ -170,48 +167,46 @@ endif()
 # the libraries they link against.
 add_subdirectory("${GGUF_CPP_ENGINE_DIR}" "${CMAKE_BINARY_DIR}/gguf-cpp-engine" EXCLUDE_FROM_ALL)
 
-add_custom_target(gguf_cpp_engine ALL)
-
-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?")
+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()
-    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()
+endforeach()
+
+add_custom_target(gguf_cpp_engine ALL)
+add_dependencies(gguf_cpp_engine gguf-server diffusion-cli gguf_quantizer)
 
 # ── 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.
-set(_gguf_dests "${CMAKE_CURRENT_SOURCE_DIR}/src/gguf_cpp")
+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"
+)
 if(DEFINED SKBUILD_PLATLIB_DIR)
-    list(APPEND _gguf_dests "${SKBUILD_PLATLIB_DIR}/gguf_cpp")
+    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"
+    )
 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.4 → gguf_cpp-0.0.6}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: gguf-cpp
-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
+Version: 0.0.6
+Summary: Unified GUI + engine for GGUF models: local LLM server, image/video generation and GGUF editing/quantization, all on one bundled gguf.cpp engine
 Author-Email: gguf <info@gguf.us>
 License: MIT
 Classifier: License :: OSI Approved :: MIT License
@@ -19,10 +19,10 @@ Description-Content-Type: text/markdown
 # gguf-cpp
 
 One package for working with GGUF models locally: an OpenAI-compatible LLM
-server, a diffusion image generator and a GGUF metadata/tensor editor with a
-built-in quantizer — three panels on one GUI, powered by one unified
-**gguf.cpp** engine compiled in a single build with a shared set of ggml
-kernels.
+server, a diffusion image/video/audio generator and a GGUF metadata/tensor
+editor with a built-in quantizer — three panels on one GUI, powered by one
+unified **gguf.cpp** engine compiled in a single build with a shared set of
+ggml kernels.
 
 ## Install
 
@@ -46,6 +46,8 @@ gguf-cpp                 # unified GUI — Server / Diffuser / Editor panels
 python -m gguf_cpp       # same thing
 ```
 
+![screenshot](https://raw.githubusercontent.com/gguf-org/gguf-desktop/master/demo15.gif)
+
 Each panel also runs on its own, exactly like the standalone
 gguf-server / gguf-diffusion / gguf-editor packages did:
 
@@ -67,35 +69,15 @@ gguf-cpp editor devices
 ## Layout
 
 ```
-vendor/gguf.cpp/         the unified gguf.cpp engine (one CMake build)
+vendor/engine/           the unified gguf.cpp engine (one CMake build)
   kernels/               shared ggml kernels (CPU + optional GPU backends)
-  llm/                   GGUF LLM runtime + the gguf-server HTTP server
+  src/ common/ mtmd/     GGUF LLM runtime
+  app/                   the gguf-server HTTP server
   diffusion/             diffusion runtime + CLI
-  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
+  quantizer/             quantizer shared library (shares the kernels above)
 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.
+![screenshot](https://raw.githubusercontent.com/gguf-org/gguf-desktop/master/pizza.jpg)

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

@@ -1,10 +1,10 @@
 # gguf-cpp
 
 One package for working with GGUF models locally: an OpenAI-compatible LLM
-server, a diffusion image generator and a GGUF metadata/tensor editor with a
-built-in quantizer — three panels on one GUI, powered by one unified
-**gguf.cpp** engine compiled in a single build with a shared set of ggml
-kernels.
+server, a diffusion image/video/audio generator and a GGUF metadata/tensor
+editor with a built-in quantizer — three panels on one GUI, powered by one
+unified **gguf.cpp** engine compiled in a single build with a shared set of
+ggml kernels.
 
 ## Install
 
@@ -28,6 +28,8 @@ gguf-cpp                 # unified GUI — Server / Diffuser / Editor panels
 python -m gguf_cpp       # same thing
 ```
 
+![screenshot](https://raw.githubusercontent.com/gguf-org/gguf-desktop/master/demo15.gif)
+
 Each panel also runs on its own, exactly like the standalone
 gguf-server / gguf-diffusion / gguf-editor packages did:
 
@@ -49,35 +51,15 @@ gguf-cpp editor devices
 ## Layout
 
 ```
-vendor/gguf.cpp/         the unified gguf.cpp engine (one CMake build)
+vendor/engine/           the unified gguf.cpp engine (one CMake build)
   kernels/               shared ggml kernels (CPU + optional GPU backends)
-  llm/                   GGUF LLM runtime + the gguf-server HTTP server
+  src/ common/ mtmd/     GGUF LLM runtime
+  app/                   the gguf-server HTTP server
   diffusion/             diffusion runtime + CLI
-  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
+  quantizer/             quantizer shared library (shares the kernels above)
 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.
+![screenshot](https://raw.githubusercontent.com/gguf-org/gguf-desktop/master/pizza.jpg)

{gguf_cpp-0.0.4 → gguf_cpp-0.0.6}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "scikit_build_core.build"
 [project]
 name = "gguf-cpp"
 dynamic = ["version"]
-description = "Unified GUI + engine for GGUF models: local LLM server, image generation and GGUF editing/quantization, all on one bundled gguf.cpp engine"
+description = "Unified GUI + engine for GGUF models: local LLM server, image/video generation and GGUF editing/quantization, all on one bundled gguf.cpp engine"
 readme = "README.md"
 license = { text = "MIT" }
 authors = [{ name = "gguf", email = "info@gguf.us" }]
@@ -33,8 +33,7 @@ wheel.packages = ["src/gguf_cpp"]
 wheel.py-api = "py3"
 cmake.version = ">=3.15"
 minimum-version = "0.9"
-sdist.include = ["vendor/gguf.cpp/**", "engine/**", "scripts/**"]
-sdist.exclude = ["build", "vendor/gguf.cpp/**/build"]
+sdist.include = ["vendor/engine/*"]
 
 [tool.scikit-build.metadata.version]
 provider = "scikit_build_core.metadata.regex"

gguf_cpp-0.0.6/src/gguf_cpp/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.0.6'

gguf_cpp-0.0.6/vendor/engine/.gitignore

@@ -0,0 +1,16 @@
+build/
+build-*/
+cmake-build-*/
+.cache/
+compile_commands.json
+
+# web UI bundle, provisioned separately (see README)
+ui/dist/
+
+*.gguf
+*.o
+*.a
+*.so
+*.dylib
+*.dll
+*.exe

gguf_cpp-0.0.6/vendor/engine/CMakeLists.txt

@@ -0,0 +1,177 @@
+cmake_minimum_required(VERSION 3.14...3.28) # for add_link_options and implicit target directories.
+project("gguf-cpp" C CXX)
+
+#
+# gguf.cpp: the unified engine — LLM server + diffusion + quantizer, all
+# compiled from one tree against one shared copy of the ggml kernels.
+#
+#   kernels/     ggml compute kernels (CPU + optional GPU backends), shared
+#   src/         the GGUF model runtime (libllama)
+#   common/      argument parsing, chat templates, sampling, logging
+#   mtmd/        multimodal (vision/audio) projector support
+#   app/         the gguf-server HTTP server
+#   ui/          embedded web UI assets (optional, empty by default)
+#   diffusion/   the diffusion runtime + `diffusion` CLI (links shared ggml)
+#   quantizer/   the standalone quantizer shared library (shares ggml-quants)
+#   thirdparty/  cpp-httplib, nlohmann/json, stb, miniaudio, subprocess.h
+#
+# There is no vendored llama.cpp checkout and no external ggml: everything is
+# compiled from the sources in this directory, in a single build.
+#
+
+set(CMAKE_WARN_UNUSED_CLI YES)
+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("CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+set(CMAKE_C_STANDARD          11)
+set(CMAKE_C_STANDARD_REQUIRED true)
+set(CMAKE_CXX_STANDARD        17)
+set(CMAKE_CXX_STANDARD_REQUIRED true)
+
+if (MINGW OR EMSCRIPTEN)
+    set(BUILD_SHARED_LIBS_DEFAULT OFF)
+else()
+    set(BUILD_SHARED_LIBS_DEFAULT ON)
+endif()
+
+option(BUILD_SHARED_LIBS "build shared libraries" ${BUILD_SHARED_LIBS_DEFAULT})
+
+if (WIN32)
+    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+endif()
+
+if (MSVC)
+    add_compile_options("$<$<COMPILE_LANGUAGE:C>:/utf-8>")
+    add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:/utf-8>")
+    add_compile_options("$<$<COMPILE_LANGUAGE:C>:/bigobj>")
+    add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:/bigobj>")
+    list(APPEND CMAKE_VS_GLOBALS UseMultiToolTask=true)
+    list(APPEND CMAKE_VS_GLOBALS EnforceProcessCountAcrossBuilds=true)
+endif()
+
+#
+# Options
+#
+
+# backends - these simply forward to the matching ggml option
+option(GGUF_SERVER_CUDA     "gguf-server: CUDA backend"                     OFF)
+option(GGUF_SERVER_HIP      "gguf-server: ROCm/HIP backend"                 OFF)
+option(GGUF_SERVER_METAL    "gguf-server: Metal backend"                    ${APPLE})
+option(GGUF_SERVER_VULKAN   "gguf-server: Vulkan backend"                   OFF)
+option(GGUF_SERVER_BLAS     "gguf-server: BLAS backend"                     OFF)
+
+# features
+option(GGUF_SERVER_OPENSSL  "gguf-server: use OpenSSL for HTTPS model downloads"    ON)
+option(GGUF_SERVER_INSTALL  "gguf-server: install the binary on `cmake --install`"  ON)
+
+# subprocess spawning powers `--models` router mode; not available everywhere
+if (CMAKE_SYSTEM_NAME STREQUAL "iOS" OR CMAKE_SYSTEM_NAME STREQUAL "Android" OR ANDROID
+        OR CMAKE_SYSTEM_NAME STREQUAL "Emscripten" OR EMSCRIPTEN)
+    set(GGUF_SERVER_SUBPROCESS_DEFAULT OFF)
+else()
+    set(GGUF_SERVER_SUBPROCESS_DEFAULT ON)
+endif()
+option(GGUF_SERVER_SUBPROCESS "gguf-server: support router mode (spawns child servers)" ${GGUF_SERVER_SUBPROCESS_DEFAULT})
+
+# diagnostics
+option(GGUF_SERVER_ALL_WARNINGS      "gguf-server: enable all compiler warnings" ON)
+option(GGUF_SERVER_FATAL_WARNINGS    "gguf-server: enable -Werror flag"          OFF)
+option(GGUF_SERVER_SANITIZE_THREAD    "gguf-server: enable thread sanitizer"     OFF)
+option(GGUF_SERVER_SANITIZE_ADDRESS   "gguf-server: enable address sanitizer"    OFF)
+option(GGUF_SERVER_SANITIZE_UNDEFINED "gguf-server: enable undefined sanitizer"  OFF)
+
+# the vendored sources still use the LLAMA_* names internally
+set(LLAMA_ALL_WARNINGS       ${GGUF_SERVER_ALL_WARNINGS})
+set(LLAMA_FATAL_WARNINGS     ${GGUF_SERVER_FATAL_WARNINGS})
+set(LLAMA_SANITIZE_THREAD    ${GGUF_SERVER_SANITIZE_THREAD})
+set(LLAMA_SANITIZE_ADDRESS   ${GGUF_SERVER_SANITIZE_ADDRESS})
+set(LLAMA_SANITIZE_UNDEFINED ${GGUF_SERVER_SANITIZE_UNDEFINED})
+set(LLAMA_SUBPROCESS         ${GGUF_SERVER_SUBPROCESS})
+set(LLAMA_OPENSSL            ${GGUF_SERVER_OPENSSL})
+
+if (GGUF_SERVER_CUDA)
+    message(STATUS "gguf-server: CUDA backend enabled")
+    set(GGML_CUDA ON)
+endif()
+if (GGUF_SERVER_HIP)
+    message(STATUS "gguf-server: HIP backend enabled")
+    set(GGML_HIP ON)
+    # ggml-hip's device-stub objects must be position-independent, or the
+    # default-PIE executable link fails on distros that default to PIE
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif()
+if (GGUF_SERVER_METAL)
+    message(STATUS "gguf-server: Metal backend enabled")
+    set(GGML_METAL ON)
+endif()
+if (GGUF_SERVER_VULKAN)
+    message(STATUS "gguf-server: Vulkan backend enabled")
+    set(GGML_VULKAN ON)
+endif()
+if (GGUF_SERVER_BLAS)
+    message(STATUS "gguf-server: BLAS backend enabled")
+    set(GGML_BLAS ON)
+endif()
+
+#
+# Version / build info
+#
+
+include(build-info)
+include(common)
+
+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})
+
+#
+# ggml options that the runtime relies on
+#
+
+set(GGML_ALL_WARNINGS   ${LLAMA_ALL_WARNINGS})
+set(GGML_FATAL_WARNINGS ${LLAMA_FATAL_WARNINGS})
+
+if (NOT DEFINED GGML_LLAMAFILE)
+    set(GGML_LLAMAFILE_DEFAULT ON)
+endif()
+if (NOT DEFINED GGML_CUDA_GRAPHS)
+    set(GGML_CUDA_GRAPHS_DEFAULT ON)
+endif()
+
+set(GGML_BUILD_NUMBER ${LLAMA_BUILD_NUMBER})
+set(GGML_BUILD_COMMIT ${LLAMA_BUILD_COMMIT})
+
+#
+# Build
+#
+
+# Diffusion models carry tensor names longer than ggml's default 64-byte
+# cap. GGML_MAX_NAME sizes a field inside struct ggml_tensor, so it must be
+# identical for every consumer of the shared kernels — set it globally
+# before anything compiles.
+add_compile_definitions(GGML_MAX_NAME=128)
+
+add_subdirectory(kernels)            # ggml (shared by everything below)
+add_subdirectory(src)                # llama
+add_subdirectory(thirdparty/cpp-httplib)
+add_subdirectory(common)             # llama-common
+add_subdirectory(mtmd)               # multimodal
+add_subdirectory(ui)                 # embedded web UI assets
+add_subdirectory(app)                # the gguf-server binary
+add_subdirectory(diffusion)          # diffusion runtime + CLI
+add_subdirectory(quantizer)          # quantizer shared library

gguf_cpp-0.0.6/vendor/engine/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 gguf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.