diff --git a/Cargo.lock b/Cargo.lock
index 8db7819e..2dd4e5f9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -637,6 +637,7 @@ dependencies = [
  "tiny-skia",
  "tracy-client-sys",
  "uapi",
+ "walkdir",
  "with_builtin_macros",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 05379806..3dbce079 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -74,6 +74,8 @@ repc = "0.1.1"
 anyhow = "1.0.79"
 bstr = { version = "1.9.0", default-features = false, features = ["std"] }
 cc = "1.0.86"
+blake3 = "1.8.2"
+walkdir = "2.5.0"
 
 #[profile.dev.build-override]
 #opt-level = 3
diff --git a/build/vulkan.rs b/build/vulkan.rs
index 9318d331..6a903a43 100644
--- a/build/vulkan.rs
+++ b/build/vulkan.rs
@@ -1,9 +1,14 @@
-use {anyhow::bail, std::process::Command};
+mod hash;
+
+use {crate::vulkan::hash::unchanged, anyhow::bail, std::process::Command};
 
 pub fn main() -> anyhow::Result<()> {
     if !std::fs::exists("compile-shaders")? {
         return Ok(());
     }
+    if unchanged() {
+        return Ok(());
+    }
     let code = Command::new("cargo")
         .args([
             "run",
diff --git a/build/vulkan/hash.rs b/build/vulkan/hash.rs
new file mode 100644
index 00000000..dabd45fc
--- /dev/null
+++ b/build/vulkan/hash.rs
@@ -0,0 +1,32 @@
+use {std::fmt::Write, walkdir::WalkDir};
+
+pub const ROOT: &str = "src/gfx_apis/vulkan/shaders";
+pub const HASH: &str = "src/gfx_apis/vulkan/shaders_hash.txt";
+
+fn calculate_hash() -> anyhow::Result<String> {
+    let dir = WalkDir::new(ROOT);
+    let mut files = vec![];
+    for file in dir {
+        let file = file?;
+        if file.file_type().is_file() {
+            files.push(file.path().to_path_buf());
+        }
+    }
+    files.sort();
+    let mut out = String::new();
+    for file in files {
+        let data = std::fs::read(&file)?;
+        writeln!(out, "{} {}", blake3::hash(&data).to_hex(), file.display())?;
+    }
+    Ok(out)
+}
+
+pub fn unchanged() -> bool {
+    let Ok(actual) = std::fs::read_to_string(HASH) else {
+        return false;
+    };
+    let Ok(expected) = calculate_hash() else {
+        return false;
+    };
+    actual == expected
+}
diff --git a/compile-shaders/Cargo.lock b/compile-shaders/Cargo.lock
index f1564570..66784e8b 100644
--- a/compile-shaders/Cargo.lock
+++ b/compile-shaders/Cargo.lock
@@ -49,15 +49,6 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
 
-[[package]]
-name = "cmake"
-version = "0.1.54"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7caa3f9de89ddbe2c607f4101924c5abec803763ae9534e4f4d7d8f84aa81f0"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "compile-shaders-build-rs"
 version = "0.1.0"
@@ -102,27 +93,12 @@ version = "0.2.175"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
 
-[[package]]
-name = "link-cplusplus"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f78c730aaa7d0b9336a299029ea49f9ee53b0ed06e9202e8cb7db9bae7b8c82"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "pkg-config"
 version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 
-[[package]]
-name = "roxmltree"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
-
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -145,14 +121,9 @@ dependencies = [
 [[package]]
 name = "shaderc-sys"
 version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdceb85b2c6d2c27b95ffe2d341063dfded0aca8046f7f60c544bbeaeaf8bcae"
 dependencies = [
- "cmake",
  "libc",
- "link-cplusplus",
  "pkg-config",
- "roxmltree",
 ]
 
 [[package]]
diff --git a/compile-shaders/Cargo.toml b/compile-shaders/Cargo.toml
index f639be3e..c2ca5f4f 100644
--- a/compile-shaders/Cargo.toml
+++ b/compile-shaders/Cargo.toml
@@ -1,3 +1,6 @@
 [workspace]
 resolver = "3"
-members = ["build-rs", "compile", "core"]
+members = ["build-rs", "compile", "core", "shaderc-sys"]
+
+[patch."crates-io"]
+shaderc-sys.path = "shaderc-sys"
diff --git a/compile-shaders/build-rs/src/main.rs b/compile-shaders/build-rs/src/main.rs
index 13895519..8e62c22d 100644
--- a/compile-shaders/build-rs/src/main.rs
+++ b/compile-shaders/build-rs/src/main.rs
@@ -1,14 +1,7 @@
-use {
-    anyhow::bail,
-    compile_shaders_core::{ROOT, unchanged},
-    std::process::Command,
-};
+use {anyhow::bail, compile_shaders_core::ROOT, std::process::Command};
 
 fn main() -> anyhow::Result<()> {
     println!("cargo:rerun-if-changed={}", ROOT);
-    if unchanged() {
-        return Ok(());
-    }
     let code = Command::new("cargo")
         .args([
             "run",
diff --git a/compile-shaders/core/src/lib.rs b/compile-shaders/core/src/lib.rs
index b9a7b348..53647204 100644
--- a/compile-shaders/core/src/lib.rs
+++ b/compile-shaders/core/src/lib.rs
@@ -1,36 +1,6 @@
-use {std::fmt::Write, walkdir::WalkDir};
+include!("../../../build/vulkan/hash.rs");
 
-pub const ROOT: &str = "src/gfx_apis/vulkan/shaders";
 pub const BIN: &str = "src/gfx_apis/vulkan/shaders_bin";
-pub const HASH: &str = "src/gfx_apis/vulkan/shaders_hash.txt";
-
-fn calculate_hash() -> anyhow::Result<String> {
-    let dir = WalkDir::new(ROOT);
-    let mut files = vec![];
-    for file in dir {
-        let file = file?;
-        if file.file_type().is_file() {
-            files.push(file.path().to_path_buf());
-        }
-    }
-    files.sort();
-    let mut out = String::new();
-    for file in files {
-        let data = std::fs::read(&file)?;
-        writeln!(out, "{} {}", blake3::hash(&data).to_hex(), file.display())?;
-    }
-    Ok(out)
-}
-
-pub fn unchanged() -> bool {
-    let Ok(actual) = std::fs::read_to_string(HASH) else {
-        return false;
-    };
-    let Ok(expected) = calculate_hash() else {
-        return false;
-    };
-    actual == expected
-}
 
 pub fn update_hash() -> anyhow::Result<()> {
     std::fs::write(HASH, calculate_hash()?)?;
diff --git a/compile-shaders/shaderc-sys/Cargo.toml b/compile-shaders/shaderc-sys/Cargo.toml
new file mode 100644
index 00000000..dda295b7
--- /dev/null
+++ b/compile-shaders/shaderc-sys/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "shaderc-sys"
+version = "0.10.1"
+edition = "2024"
+authors = ["Lei Zhang <antiagainst@gmail.com>", "Mr. Knapp <knappador@gmail.com>"]
+
+[dependencies]
+libc = "0.2"
+
+[build-dependencies]
+pkg-config = "0.3"
diff --git a/compile-shaders/shaderc-sys/build.rs b/compile-shaders/shaderc-sys/build.rs
new file mode 100644
index 00000000..d479f75b
--- /dev/null
+++ b/compile-shaders/shaderc-sys/build.rs
@@ -0,0 +1,5 @@
+use pkg_config::Config;
+
+fn main() {
+    Config::new().probe("shaderc").unwrap();
+}
diff --git a/compile-shaders/shaderc-sys/src/lib.rs b/compile-shaders/shaderc-sys/src/lib.rs
new file mode 100644
index 00000000..6d278ebf
--- /dev/null
+++ b/compile-shaders/shaderc-sys/src/lib.rs
@@ -0,0 +1,198 @@
+// Copyright 2016 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![allow(non_camel_case_types)]
+
+extern crate libc;
+use libc::{c_char, c_int, c_void, size_t};
+
+pub enum ShadercCompiler {}
+pub enum ShadercCompileOptions {}
+pub enum ShadercCompilationResult {}
+
+#[repr(C)]
+pub struct shaderc_include_result {
+    pub source_name: *const c_char,
+    pub source_name_length: size_t,
+    pub content: *const c_char,
+    pub content_length: size_t,
+    pub user_data: *mut c_void,
+}
+
+type shaderc_include_resolve_fn = extern "C" fn(
+    user_data: *mut c_void,
+    requested_source: *const c_char,
+    type_: c_int,
+    requesting_source: *const c_char,
+    include_depth: size_t,
+) -> *mut shaderc_include_result;
+
+type shaderc_include_result_release_fn =
+    extern "C" fn(user_data: *mut c_void, include_result: *mut shaderc_include_result);
+
+unsafe extern "C" {
+    pub fn shaderc_compiler_initialize() -> *mut ShadercCompiler;
+    pub fn shaderc_compiler_release(compiler: *mut ShadercCompiler);
+
+    pub fn shaderc_compile_into_spv(
+        compiler: *const ShadercCompiler,
+        source_text: *const c_char,
+        source_size: size_t,
+        shader_kind: i32,
+        input_file_name: *const c_char,
+        entry_point_name: *const c_char,
+        additional_options: *const ShadercCompileOptions,
+    ) -> *mut ShadercCompilationResult;
+    pub fn shaderc_compile_into_spv_assembly(
+        compiler: *const ShadercCompiler,
+        source_text: *const c_char,
+        source_size: size_t,
+        shader_kind: i32,
+        input_file_name: *const c_char,
+        entry_point_name: *const c_char,
+        additional_options: *const ShadercCompileOptions,
+    ) -> *mut ShadercCompilationResult;
+    pub fn shaderc_compile_into_preprocessed_text(
+        compiler: *const ShadercCompiler,
+        source_text: *const c_char,
+        source_size: size_t,
+        shader_kind: i32,
+        input_file_name: *const c_char,
+        entry_point_name: *const c_char,
+        additional_options: *const ShadercCompileOptions,
+    ) -> *mut ShadercCompilationResult;
+    pub fn shaderc_assemble_into_spv(
+        compiler: *const ShadercCompiler,
+        source_assembly: *const c_char,
+        source_size: size_t,
+        additional_options: *const ShadercCompileOptions,
+    ) -> *mut ShadercCompilationResult;
+
+    pub fn shaderc_compile_options_initialize() -> *mut ShadercCompileOptions;
+    pub fn shaderc_compile_options_clone(
+        options: *const ShadercCompileOptions,
+    ) -> *mut ShadercCompileOptions;
+    pub fn shaderc_compile_options_release(options: *mut ShadercCompileOptions);
+
+    pub fn shaderc_compile_options_add_macro_definition(
+        options: *mut ShadercCompileOptions,
+        name: *const c_char,
+        name_length: size_t,
+        value: *const c_char,
+        vaule_length: size_t,
+    );
+    pub fn shaderc_compile_options_set_source_language(
+        options: *mut ShadercCompileOptions,
+        language: i32,
+    );
+    pub fn shaderc_compile_options_set_generate_debug_info(options: *mut ShadercCompileOptions);
+    pub fn shaderc_compile_options_set_optimization_level(
+        options: *mut ShadercCompileOptions,
+        level: i32,
+    );
+    pub fn shaderc_compile_options_set_forced_version_profile(
+        options: *mut ShadercCompileOptions,
+        version: c_int,
+        profile: i32,
+    );
+    pub fn shaderc_compile_options_set_include_callbacks(
+        options: *mut ShadercCompileOptions,
+        resolver: shaderc_include_resolve_fn,
+        result_releaser: shaderc_include_result_release_fn,
+        user_data: *mut c_void,
+    );
+    pub fn shaderc_compile_options_set_suppress_warnings(options: *mut ShadercCompileOptions);
+    pub fn shaderc_compile_options_set_warnings_as_errors(options: *mut ShadercCompileOptions);
+    pub fn shaderc_compile_options_set_target_env(
+        options: *mut ShadercCompileOptions,
+        env: i32,
+        version: u32,
+    );
+    pub fn shaderc_compile_options_set_target_spirv(
+        options: *mut ShadercCompileOptions,
+        version: i32,
+    );
+    pub fn shaderc_compile_options_set_limit(
+        options: *mut ShadercCompileOptions,
+        limit: i32,
+        value: c_int,
+    );
+    pub fn shaderc_compile_options_set_auto_bind_uniforms(
+        options: *mut ShadercCompileOptions,
+        auto_bind: bool,
+    );
+    pub fn shaderc_compile_options_set_auto_combined_image_sampler(
+        options: *mut ShadercCompileOptions,
+        auto_combine: bool,
+    );
+    pub fn shaderc_compile_options_set_hlsl_io_mapping(
+        options: *mut ShadercCompileOptions,
+        hlsl_iomap: bool,
+    );
+    pub fn shaderc_compile_options_set_hlsl_offsets(
+        options: *mut ShadercCompileOptions,
+        hlsl_offsets: bool,
+    );
+    pub fn shaderc_compile_options_set_binding_base(
+        options: *mut ShadercCompileOptions,
+        resource_kind: c_int,
+        base: u32,
+    );
+    pub fn shaderc_compile_options_set_binding_base_for_stage(
+        options: *mut ShadercCompileOptions,
+        shader_kind: c_int,
+        resource_kind: c_int,
+        base: u32,
+    );
+    pub fn shaderc_compile_options_set_hlsl_register_set_and_binding(
+        options: *mut ShadercCompileOptions,
+        register: *const c_char,
+        set: *const c_char,
+        binding: *const c_char,
+    );
+    pub fn shaderc_compile_options_set_auto_map_locations(
+        options: *mut ShadercCompileOptions,
+        auto_map: bool,
+    );
+    pub fn shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage(
+        options: *mut ShadercCompileOptions,
+        shader_kind: c_int,
+        register: *const c_char,
+        set: *const c_char,
+        binding: *const c_char,
+    );
+    pub fn shaderc_compile_options_set_hlsl_functionality1(
+        options: *mut ShadercCompileOptions,
+        enable: bool,
+    );
+    pub fn shaderc_compile_options_set_invert_y(options: *mut ShadercCompileOptions, enable: bool);
+    pub fn shaderc_compile_options_set_nan_clamp(options: *mut ShadercCompileOptions, enable: bool);
+
+    pub fn shaderc_result_release(result: *mut ShadercCompilationResult);
+    pub fn shaderc_result_get_compilation_status(result: *const ShadercCompilationResult) -> i32;
+    pub fn shaderc_result_get_num_errors(result: *const ShadercCompilationResult) -> size_t;
+    pub fn shaderc_result_get_num_warnings(result: *const ShadercCompilationResult) -> size_t;
+    pub fn shaderc_result_get_error_message(
+        result: *const ShadercCompilationResult,
+    ) -> *const c_char;
+    pub fn shaderc_result_get_length(result: *const ShadercCompilationResult) -> size_t;
+    pub fn shaderc_result_get_bytes(result: *const ShadercCompilationResult) -> *const c_char;
+
+    pub fn shaderc_get_spv_version(version: *mut c_int, revision: *mut c_int);
+    pub fn shaderc_parse_version_profile(
+        str: *const c_char,
+        version: *mut c_int,
+        profile: *mut i32,
+    ) -> bool;
+}