@fugood/llama.node 0.3.16 → 0.4.0

package/src/LlamaContext.cpp

@@ -12,6 +12,91 @@
 #include "SaveSessionWorker.h"
 #include "TokenizeWorker.h"
 
+// Helper function for formatted strings (for console logs)
+template<typename ... Args>
+static std::string format_string(const std::string& format, Args ... args) {
+    int size_s = std::snprintf(nullptr, 0, format.c_str(), args ...) + 1; // +1 for null terminator
+    if (size_s <= 0) { return "Error formatting string"; }
+    auto size = static_cast<size_t>(size_s);
+    std::unique_ptr<char[]> buf(new char[size]);
+    std::snprintf(buf.get(), size, format.c_str(), args ...);
+    return std::string(buf.get(), buf.get() + size - 1); // -1 to exclude null terminator
+}
+
+// Computes FNV-1a hash of the data
+static std::string fnv_hash(const uint8_t* data, size_t len) {
+  const uint64_t fnv_prime = 0x100000001b3ULL;
+  uint64_t hash = 0xcbf29ce484222325ULL;
+
+  for (size_t i = 0; i < len; ++i) {
+    hash ^= data[i];
+    hash *= fnv_prime;
+  }
+  return std::to_string(hash);
+}
+
+static const std::string base64_chars =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  "abcdefghijklmnopqrstuvwxyz"
+  "0123456789+/";
+
+// Base64 decoding function
+static std::vector<uint8_t> base64_decode(const std::string &encoded_string) {
+  std::vector<uint8_t> decoded;
+  int in_len = encoded_string.size();
+  int i = 0;
+  int j = 0;
+  int in_ = 0;
+  unsigned char char_array_4[4], char_array_3[3];
+
+  while (in_len-- && (encoded_string[in_] != '=')) {
+    if (isspace(encoded_string[in_])) {
+      in_++;
+      continue;
+    }
+
+    if (encoded_string[in_] == '=' || base64_chars.find(encoded_string[in_]) == std::string::npos) {
+      break;
+    }
+
+    char_array_4[i++] = encoded_string[in_]; in_++;
+    if (i == 4) {
+      for (i = 0; i < 4; i++) {
+        char_array_4[i] = base64_chars.find(char_array_4[i]);
+      }
+
+      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+      for (i = 0; i < 3; i++) {
+        decoded.push_back(char_array_3[i]);
+      }
+      i = 0;
+    }
+  }
+
+  if (i) {
+    for (j = i; j < 4; j++) {
+      char_array_4[j] = 0;
+    }
+
+    for (j = 0; j < 4; j++) {
+      char_array_4[j] = base64_chars.find(char_array_4[j]);
+    }
+
+    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+    for (j = 0; j < i - 1; j++) {
+      decoded.push_back(char_array_3[j]);
+    }
+  }
+
+  return decoded;
+}
+
 using json = nlohmann::ordered_json;
 
 // loadModelInfo(path: string): object
@@ -116,6 +201,15 @@ void LlamaContext::Init(Napi::Env env, Napi::Object &exports) {
        InstanceMethod<&LlamaContext::GetLoadedLoraAdapters>(
            "getLoadedLoraAdapters",
            static_cast<napi_property_attributes>(napi_enumerable)),
+       InstanceMethod<&LlamaContext::InitMultimodal>(
+           "initMultimodal",
+           static_cast<napi_property_attributes>(napi_enumerable)),
+       InstanceMethod<&LlamaContext::IsMultimodalEnabled>(
+           "isMultimodalEnabled",
+           static_cast<napi_property_attributes>(napi_enumerable)),
+       InstanceMethod<&LlamaContext::ReleaseMultimodal>(
+           "releaseMultimodal",
+           static_cast<napi_property_attributes>(napi_enumerable)),
        InstanceMethod<&LlamaContext::Release>(
            "release", static_cast<napi_property_attributes>(napi_enumerable)),
        StaticMethod<&LlamaContext::ModelInfo>(
@@ -173,8 +267,8 @@ LlamaContext::LlamaContext(const Napi::CallbackInfo &info)
   auto options = info[0].As<Napi::Object>();
 
   common_params params;
-  params.model = get_option<std::string>(options, "model", "");
-  if (params.model.empty()) {
+  params.model.path = get_option<std::string>(options, "model", "");
+  if (params.model.path.empty()) {
     Napi::TypeError::New(env, "Model is required").ThrowAsJavaScriptException();
   }
 
@@ -211,6 +305,7 @@ LlamaContext::LlamaContext(const Napi::CallbackInfo &info)
   params.flash_attn = get_option<bool>(options, "flash_attn", false);
   params.cache_type_k = kv_cache_type_from_str(get_option<std::string>(options, "cache_type_k", "f16").c_str());
   params.cache_type_v = kv_cache_type_from_str(get_option<std::string>(options, "cache_type_v", "f16").c_str());
+  params.ctx_shift = get_option<bool>(options, "ctx_shift", true);
 
   params.use_mlock = get_option<bool>(options, "use_mlock", false);
   params.use_mmap = get_option<bool>(options, "use_mmap", true);
@@ -447,7 +542,6 @@ Napi::Value LlamaContext::GetFormattedChat(const Napi::CallbackInfo &info) {
     Napi::TypeError::New(env, "Array expected").ThrowAsJavaScriptException();
   }
   auto messages = json_stringify(info[0].As<Napi::Array>());
-  printf("messages: %s\n", messages.c_str());
   auto chat_template = info[1].IsString() ? info[1].ToString().Utf8Value() : "";
 
   auto has_params = info.Length() >= 2;
@@ -544,6 +638,25 @@ Napi::Value LlamaContext::Completion(const Napi::CallbackInfo &info) {
     }
   }
 
+  // Process image_paths parameter
+  std::vector<std::string> image_paths;
+  if (options.Has("image_paths")) {
+    if (options.Get("image_paths").IsArray()) {
+      auto image_paths_array = options.Get("image_paths").As<Napi::Array>();
+      for (size_t i = 0; i < image_paths_array.Length(); i++) {
+        image_paths.push_back(image_paths_array.Get(i).ToString().Utf8Value());
+      }
+    } else if (options.Get("image_paths").IsString()) {
+      image_paths.push_back(options.Get("image_paths").ToString().Utf8Value());
+    }
+  }
+
+  // Check if multimodal is enabled when image_paths are provided
+  if (!image_paths.empty() && !(_has_multimodal && _mtmd_ctx != nullptr)) {
+    Napi::Error::New(env, "Multimodal support must be enabled via initMultimodal to use image_paths").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
   int32_t chat_format = get_option<int32_t>(options, "chat_format", 0);
 
   common_params params = _sess->params();
@@ -726,17 +839,17 @@ Napi::Value LlamaContext::Completion(const Napi::CallbackInfo &info) {
   }
 
   auto *worker =
-      new LlamaCompletionWorker(info, _sess, callback, params, stop_words, chat_format);
+      new LlamaCompletionWorker(info, _sess, callback, params, stop_words, chat_format, image_paths);
   worker->Queue();
   _wip = worker;
-  worker->onComplete([this]() { _wip = nullptr; });
+  worker->OnComplete([this]() { _wip = nullptr; });
   return worker->Promise();
 }
 
 // stopCompletion(): void
 void LlamaContext::StopCompletion(const Napi::CallbackInfo &info) {
   if (_wip != nullptr) {
-    _wip->Stop();
+    _wip->SetStop();
   }
 }
 
@@ -889,14 +1002,110 @@ Napi::Value LlamaContext::GetLoadedLoraAdapters(const Napi::CallbackInfo &info)
 Napi::Value LlamaContext::Release(const Napi::CallbackInfo &info) {
   auto env = info.Env();
   if (_wip != nullptr) {
-    _wip->Stop();
+    _wip->SetStop();
   }
   if (_sess == nullptr) {
     auto promise = Napi::Promise::Deferred(env);
     promise.Resolve(env.Undefined());
     return promise.Promise();
   }
+  
+  // Clear the mtmd context reference in the session
+  if (_mtmd_ctx != nullptr) {
+    _sess->set_mtmd_ctx(nullptr);
+  }
+  
   auto *worker = new DisposeWorker(info, std::move(_sess));
   worker->Queue();
   return worker->Promise();
 }
+
+LlamaContext::~LlamaContext() {
+  if (_mtmd_ctx != nullptr) {
+    mtmd_free(_mtmd_ctx);
+    _mtmd_ctx = nullptr;
+    _has_multimodal = false;
+  }
+}
+
+// initMultimodal(options: { path: string, use_gpu?: boolean }): boolean
+Napi::Value LlamaContext::InitMultimodal(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsObject()) {
+    Napi::TypeError::New(env, "Object expected for mmproj path").ThrowAsJavaScriptException();
+  }
+
+  auto options = info[0].As<Napi::Object>();
+  auto mmproj_path = options.Get("path").ToString().Utf8Value();
+  auto use_gpu = options.Get("use_gpu").ToBoolean().Value();
+
+  if (mmproj_path.empty()) {
+    Napi::TypeError::New(env, "mmproj path is required").ThrowAsJavaScriptException();
+  }
+
+  console_log(env, "Initializing multimodal with mmproj path: " + mmproj_path);
+
+  auto model = _sess->model();
+  auto ctx = _sess->context();
+  if (model == nullptr) {
+    Napi::Error::New(env, "Model not loaded").ThrowAsJavaScriptException();
+    return Napi::Boolean::New(env, false);
+  }
+
+  if (_mtmd_ctx != nullptr) {
+    mtmd_free(_mtmd_ctx);
+    _mtmd_ctx = nullptr;
+    _has_multimodal = false;
+  }
+
+  // Initialize mtmd context
+  mtmd_context_params mtmd_params = mtmd_context_params_default();
+  mtmd_params.use_gpu = use_gpu;
+  mtmd_params.print_timings = false;
+  mtmd_params.n_threads = _sess->params().cpuparams.n_threads;
+  mtmd_params.verbosity = (ggml_log_level)GGML_LOG_LEVEL_INFO;
+
+  console_log(env, format_string("Initializing mtmd context with threads=%d, use_gpu=%d", 
+                   mtmd_params.n_threads, mtmd_params.use_gpu ? 1 : 0));
+
+  _mtmd_ctx = mtmd_init_from_file(mmproj_path.c_str(), model, mtmd_params);
+  if (_mtmd_ctx == nullptr) {
+    Napi::Error::New(env, "Failed to initialize multimodal context").ThrowAsJavaScriptException();
+    return Napi::Boolean::New(env, false);
+  }
+
+  _has_multimodal = true;
+  
+  // Share the mtmd context with the session
+  _sess->set_mtmd_ctx(_mtmd_ctx);
+
+  // Check if the model uses M-RoPE or non-causal attention
+  bool uses_mrope = mtmd_decode_use_mrope(_mtmd_ctx);
+  bool uses_non_causal = mtmd_decode_use_non_causal(_mtmd_ctx);
+  console_log(env, format_string("Model multimodal properties: uses_mrope=%d, uses_non_causal=%d",
+             uses_mrope ? 1 : 0, uses_non_causal ? 1 : 0));
+
+  console_log(env, "Multimodal context initialized successfully with mmproj: " + mmproj_path);
+  return Napi::Boolean::New(env, true);
+}
+
+// isMultimodalEnabled(): boolean
+Napi::Value LlamaContext::IsMultimodalEnabled(const Napi::CallbackInfo &info) {
+  return Napi::Boolean::New(info.Env(), _has_multimodal && _mtmd_ctx != nullptr);
+}
+
+// releaseMultimodal(): void
+void LlamaContext::ReleaseMultimodal(const Napi::CallbackInfo &info) {
+  if (_mtmd_ctx != nullptr) {
+    // Clear the mtmd context reference in the session
+    if (_sess != nullptr) {
+      _sess->set_mtmd_ctx(nullptr);
+    }
+    
+    // Free the mtmd context
+    mtmd_free(_mtmd_ctx);
+    _mtmd_ctx = nullptr;
+    _has_multimodal = false;
+  }
+}

package/src/LlamaContext.h

@@ -1,10 +1,13 @@
 #include "common.hpp"
+#include "tools/mtmd/mtmd.h"
+#include "tools/mtmd/clip.h"
 
 class LlamaCompletionWorker;
 
 class LlamaContext : public Napi::ObjectWrap<LlamaContext> {
 public:
   LlamaContext(const Napi::CallbackInfo &info);
+  ~LlamaContext();
   static void ToggleNativeLog(const Napi::CallbackInfo &info);
   static Napi::Value ModelInfo(const Napi::CallbackInfo& info);
   static void Init(Napi::Env env, Napi::Object &exports);
@@ -24,6 +27,11 @@ private:
   void RemoveLoraAdapters(const Napi::CallbackInfo &info);
   Napi::Value GetLoadedLoraAdapters(const Napi::CallbackInfo &info);
   Napi::Value Release(const Napi::CallbackInfo &info);
+  
+  // Multimodal methods
+  Napi::Value InitMultimodal(const Napi::CallbackInfo &info);
+  Napi::Value IsMultimodalEnabled(const Napi::CallbackInfo &info);
+  void ReleaseMultimodal(const Napi::CallbackInfo &info);
 
   std::string _info;
   Napi::Object _meta;
@@ -31,4 +39,8 @@ private:
   common_chat_templates_ptr _templates;
   std::vector<common_adapter_lora_info> _lora;
   LlamaCompletionWorker *_wip = nullptr;
+  
+  // Multimodal support
+  mtmd_context *_mtmd_ctx = nullptr;
+  bool _has_multimodal = false;
 };

package/src/common.hpp

@@ -4,6 +4,7 @@
 #include "common/sampling.h"
 #include "chat.h"
 #include "llama.h"
+#include "tools/mtmd/mtmd.h"
 #include <memory>
 #include <mutex>
 #include <napi.h>
@@ -82,10 +83,23 @@ public:
   inline const common_params &params() const { return params_; }
 
   inline std::mutex &get_mutex() { return mutex; }
+  
+  // Getter for the multimodal context
+  inline const mtmd_context* get_mtmd_ctx() const { 
+    return _mtmd_ctx; 
+  }
+  
+  // Setter for the multimodal context
+  inline void set_mtmd_ctx(mtmd_context* ctx) {
+    _mtmd_ctx = ctx;
+  }
 
   void dispose() {
     std::lock_guard<std::mutex> lock(mutex);
     tokens_.clear();
+    
+    // mtmd_ctx is owned by LlamaContext, so we don't free it here
+    _mtmd_ctx = nullptr;
   }
 
 private:
@@ -93,6 +107,7 @@ private:
   const common_params params_;
   std::vector<llama_token> tokens_{};
   std::mutex mutex;
+  mtmd_context* _mtmd_ctx = nullptr;
 };
 
 typedef std::shared_ptr<LlamaSession> LlamaSessionPtr;

package/src/llama.cpp/.github/workflows/build-linux-cross.yml

@@ -0,0 +1,233 @@
+name: Build on Linux using cross-compiler
+on:
+  workflow_dispatch:
+  workflow_call:
+
+jobs:
+  ubuntu-24-riscv64-cpu-cross:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Riscv
+        run: |
+          sudo dpkg --add-architecture riscv64
+
+          # Add arch-specific repositories for non-amd64 architectures
+          cat << EOF | sudo tee /etc/apt/sources.list.d/riscv64-ports.list
+          deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ noble main universe
+          deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ noble-updates main universe
+          deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ noble-security main universe
+          deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ noble-backports main universe
+          EOF
+
+          sudo apt-get update || true    ;# Prevent failure due to missing URLs.
+
+          sudo apt-get install -y --no-install-recommends \
+                  build-essential \
+                  gcc-14-riscv64-linux-gnu \
+                  g++-14-riscv64-linux-gnu \
+                  libcurl4-openssl-dev:riscv64
+
+      - name: Build
+        run: |
+          cmake -B build -DCMAKE_BUILD_TYPE=Release \
+                         -DGGML_OPENMP=OFF \
+                         -DLLAMA_BUILD_EXAMPLES=ON \
+                         -DLLAMA_BUILD_TOOLS=ON \
+                         -DLLAMA_BUILD_TESTS=OFF \
+                         -DCMAKE_SYSTEM_NAME=Linux \
+                         -DCMAKE_SYSTEM_PROCESSOR=riscv64 \
+                         -DCMAKE_C_COMPILER=riscv64-linux-gnu-gcc-14 \
+                         -DCMAKE_CXX_COMPILER=riscv64-linux-gnu-g++-14 \
+                         -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+                         -DCMAKE_FIND_ROOT_PATH=/usr/lib/riscv64-linux-gnu \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=ONLY \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=BOTH
+
+          cmake --build build --config Release -j $(nproc)
+
+  ubuntu-24-riscv64-vulkan-cross:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Riscv
+        run: |
+          sudo dpkg --add-architecture riscv64
+
+          # Add arch-specific repositories for non-amd64 architectures
+          cat << EOF | sudo tee /etc/apt/sources.list.d/riscv64-ports.list
+          deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ noble main universe
+          deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ noble-updates main universe
+          deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ noble-security main universe
+          deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ noble-backports main universe
+          EOF
+
+          sudo apt-get update || true    ;# Prevent failure due to missing URLs.
+
+          sudo apt-get install -y --no-install-recommends \
+                  build-essential \
+                  glslc \
+                  gcc-14-riscv64-linux-gnu \
+                  g++-14-riscv64-linux-gnu \
+                  libvulkan-dev:riscv64 \
+                  libcurl4-openssl-dev:riscv64
+
+      - name: Build
+        run: |
+          cmake -B build -DCMAKE_BUILD_TYPE=Release \
+                         -DGGML_VULKAN=ON \
+                         -DGGML_OPENMP=OFF \
+                         -DLLAMA_BUILD_EXAMPLES=ON \
+                         -DLLAMA_BUILD_TOOLS=ON \
+                         -DLLAMA_BUILD_TESTS=OFF \
+                         -DCMAKE_SYSTEM_NAME=Linux \
+                         -DCMAKE_SYSTEM_PROCESSOR=riscv64 \
+                         -DCMAKE_C_COMPILER=riscv64-linux-gnu-gcc-14 \
+                         -DCMAKE_CXX_COMPILER=riscv64-linux-gnu-g++-14 \
+                         -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+                         -DCMAKE_FIND_ROOT_PATH=/usr/lib/riscv64-linux-gnu \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=ONLY \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=BOTH
+
+          cmake --build build --config Release -j $(nproc)
+
+  ubuntu-24-arm64-vulkan-cross:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Arm64
+        run: |
+          sudo dpkg --add-architecture arm64
+
+          # Add arch-specific repositories for non-amd64 architectures
+          cat << EOF | sudo tee /etc/apt/sources.list.d/arm64-ports.list
+          deb [arch=arm64] http://ports.ubuntu.com/ubuntu-ports/ noble main universe
+          deb [arch=arm64] http://ports.ubuntu.com/ubuntu-ports/ noble-updates main universe
+          deb [arch=arm64] http://ports.ubuntu.com/ubuntu-ports/ noble-security main universe
+          deb [arch=arm64] http://ports.ubuntu.com/ubuntu-ports/ noble-backports main universe
+          EOF
+
+          sudo apt-get update || true    ;# Prevent failure due to missing URLs.
+
+          sudo apt-get install -y --no-install-recommends \
+                  build-essential \
+                  glslc \
+                  crossbuild-essential-arm64 \
+                  libvulkan-dev:arm64 \
+                  libcurl4-openssl-dev:arm64
+
+      - name: Build
+        run: |
+          cmake -B build -DCMAKE_BUILD_TYPE=Release \
+                         -DGGML_VULKAN=ON \
+                         -DGGML_OPENMP=OFF \
+                         -DLLAMA_BUILD_EXAMPLES=ON \
+                         -DLLAMA_BUILD_TOOLS=ON \
+                         -DLLAMA_BUILD_TESTS=OFF \
+                         -DCMAKE_SYSTEM_NAME=Linux \
+                         -DCMAKE_SYSTEM_PROCESSOR=aarch64 \
+                         -DCMAKE_C_COMPILER=aarch64-linux-gnu-gcc \
+                         -DCMAKE_CXX_COMPILER=aarch64-linux-gnu-g++ \
+                         -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+                         -DCMAKE_FIND_ROOT_PATH=/usr/lib/aarch64-linux-gnu \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=ONLY \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=BOTH
+
+          cmake --build build --config Release -j $(nproc)
+
+  ubuntu-24-ppc64el-cpu-cross:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup PowerPC64le
+        run: |
+          sudo dpkg --add-architecture ppc64el
+
+          # Add arch-specific repositories for non-amd64 architectures
+          cat << EOF | sudo tee /etc/apt/sources.list.d/ppc64el-ports.list
+          deb [arch=ppc64el] http://ports.ubuntu.com/ubuntu-ports/ noble main universe
+          deb [arch=ppc64el] http://ports.ubuntu.com/ubuntu-ports/ noble-updates main universe
+          deb [arch=ppc64el] http://ports.ubuntu.com/ubuntu-ports/ noble-security main universe
+          deb [arch=ppc64el] http://ports.ubuntu.com/ubuntu-ports/ noble-backports main universe
+          EOF
+
+          sudo apt-get update || true    ;# Prevent failure due to missing URLs.
+
+          sudo apt-get install -y --no-install-recommends \
+                  build-essential \
+                  gcc-14-powerpc64le-linux-gnu \
+                  g++-14-powerpc64le-linux-gnu \
+                  libcurl4-openssl-dev:ppc64el
+
+      - name: Build
+        run: |
+          cmake -B build -DCMAKE_BUILD_TYPE=Release \
+                         -DGGML_OPENMP=OFF \
+                         -DLLAMA_BUILD_EXAMPLES=ON \
+                         -DLLAMA_BUILD_TOOLS=ON \
+                         -DLLAMA_BUILD_TESTS=OFF \
+                         -DCMAKE_SYSTEM_NAME=Linux \
+                         -DCMAKE_SYSTEM_PROCESSOR=ppc64 \
+                         -DCMAKE_C_COMPILER=powerpc64le-linux-gnu-gcc-14 \
+                         -DCMAKE_CXX_COMPILER=powerpc64le-linux-gnu-g++-14 \
+                         -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+                         -DCMAKE_FIND_ROOT_PATH=/usr/lib/powerpc64le-linux-gnu \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=ONLY \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=BOTH
+
+          cmake --build build --config Release -j $(nproc)
+
+  ubuntu-24-ppc64el-vulkan-cross:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup PowerPC64le
+        run: |
+          sudo dpkg --add-architecture ppc64el
+
+          # Add arch-specific repositories for non-amd64 architectures
+          cat << EOF | sudo tee /etc/apt/sources.list.d/ppc64el-ports.list
+          deb [arch=ppc64el] http://ports.ubuntu.com/ubuntu-ports/ noble main universe
+          deb [arch=ppc64el] http://ports.ubuntu.com/ubuntu-ports/ noble-updates main universe
+          deb [arch=ppc64el] http://ports.ubuntu.com/ubuntu-ports/ noble-security main universe
+          deb [arch=ppc64el] http://ports.ubuntu.com/ubuntu-ports/ noble-backports main universe
+          EOF
+
+          sudo apt-get update || true    ;# Prevent failure due to missing URLs.
+
+          sudo apt-get install -y --no-install-recommends \
+                  build-essential \
+                  glslc \
+                  gcc-14-powerpc64le-linux-gnu \
+                  g++-14-powerpc64le-linux-gnu \
+                  libvulkan-dev:ppc64el \
+                  libcurl4-openssl-dev:ppc64el
+
+      - name: Build
+        run: |
+          cmake -B build -DCMAKE_BUILD_TYPE=Release \
+                         -DGGML_VULKAN=ON \
+                         -DGGML_OPENMP=OFF \
+                         -DLLAMA_BUILD_EXAMPLES=ON \
+                         -DLLAMA_BUILD_TOOLS=ON \
+                         -DLLAMA_BUILD_TESTS=OFF \
+                         -DCMAKE_SYSTEM_NAME=Linux \
+                         -DCMAKE_SYSTEM_PROCESSOR=ppc64 \
+                         -DCMAKE_C_COMPILER=powerpc64le-linux-gnu-gcc-14 \
+                         -DCMAKE_CXX_COMPILER=powerpc64le-linux-gnu-g++-14 \
+                         -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+                         -DCMAKE_FIND_ROOT_PATH=/usr/lib/powerpc64le-linux-gnu \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=ONLY \
+                         -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=BOTH
+
+          cmake --build build --config Release -j $(nproc)