red-candle 1.7.0 → 1.8.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d1b83311f0ad99adaffb886efda12291e9499ba112742e471e7b1eace390cee
-  data.tar.gz: 6156968c937204767fda21adfc6069e55a9571018f064ac56821d61472cc9cc1
+  metadata.gz: 3b4ad17010839981938eb7c963ce84b02aee0779412da77ca8f3dca5f3ff9ec8
+  data.tar.gz: 296b45a80b1cf14c4f2a9d20a0984f06da7433f6dbb92290c7e0e10e194481ad
 SHA512:
-  metadata.gz: 57abc7d285ebb3c67c438d861563247ec1130b03bee5fab418670bd926de58ad2bc06b2328732c362f46a4f8a8ccb7d85d7bd0e4b7a384838e290dadb7ed2be4
-  data.tar.gz: 2f10da2df023629d59b2c2454efa886a87e0738d99801e6bb25b951431856b083780167190a6ba735c3c51cb8d170ed16a9c163f19aaf44fc8b95a72f8ea4b5e
+  metadata.gz: 7d154e4a2fe3b4afddf59908c270820ae12e26d28934eff2a7cd628a7a66c153c1e02427f4939d891c27ceb6250ef26bc51f97f6862e9d7e8c4531a354b7dea4
+  data.tar.gz: f1bb5d35dac744b44ca9879334116436c80f495e722b8edfb68bd90022df3e32840b040bb1504d7acc0a93b70b31a27781ae098b4d2520184a9cae2ecdde899a

data/Cargo.lock

@@ -174,9 +174,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-rs"
-version = "1.14.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b8ff6c09cd57b16da53641caa860168b88c172a5ee163b0288d3d6eea12786"
+checksum = "5ec2f1fc3ec205783a5da9a7e6c1509cc69dedf09a1949e412c1e18469326d00"
 dependencies = [
  "aws-lc-sys",
  "zeroize",
@@ -184,11 +184,10 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.31.0"
+version = "0.41.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e44d16778acaf6a9ec9899b92cebd65580b83f685446bf2e1f5d3d732f99dcd"
+checksum = "1a2f9779ce85b93ab6170dd940ad0169b5766ff848247aff13bb788b832fe3f4"
 dependencies = [
- "bindgen 0.72.1",
  "cc",
  "cmake",
  "dunce",
@@ -268,26 +267,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "bindgen"
-version = "0.72.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
-dependencies = [
- "bitflags 2.9.4",
- "cexpr",
- "clang-sys",
- "itertools 0.13.0",
- "log",
- "prettyplease",
- "proc-macro2",
- "quote",
- "regex",
- "rustc-hash 2.1.1",
- "shlex",
- "syn",
-]
-
 [[package]]
 name = "bindgen_cuda"
 version = "0.1.6"
@@ -427,7 +406,7 @@ dependencies = [
  "image",
  "magnus",
  "outlines-core",
- "rand 0.8.5",
+ "rand 0.10.1",
  "safetensors 0.3.3",
  "serde",
  "serde_json",
@@ -458,7 +437,7 @@ dependencies = [
  "num_cpus",
  "objc2-foundation",
  "objc2-metal",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rand_distr",
  "rayon",
  "safetensors 0.7.0",
@@ -520,7 +499,7 @@ dependencies = [
  "candle-nn",
  "fancy-regex 0.17.0",
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rayon",
  "serde",
  "serde_json",
@@ -581,6 +560,17 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
+[[package]]
+name = "chacha20"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.42"
@@ -693,6 +683,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -981,7 +980,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1102,7 +1101,7 @@ dependencies = [
  "cudarc 0.19.3",
  "half",
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rand_distr",
 ]
 
@@ -1121,6 +1120,12 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
 [[package]]
 name = "foldhash"
 version = "0.2.0"
@@ -1543,11 +1548,25 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
+ "r-efi 5.3.0",
  "wasi 0.14.5+wasi-0.2.4",
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "rand_core 0.10.1",
+ "wasip2",
+ "wasip3",
+]
+
 [[package]]
 name = "getset"
 version = "0.1.6"
@@ -1611,7 +1630,7 @@ dependencies = [
  "cfg-if",
  "crunchy",
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rand_distr",
 ]
 
@@ -1620,6 +1639,9 @@ name = "hashbrown"
 version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+]
 
 [[package]]
 name = "hashbrown"
@@ -1629,7 +1651,7 @@ checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 dependencies = [
  "allocator-api2",
  "equivalent",
- "foldhash",
+ "foldhash 0.2.0",
  "serde",
  "serde_core",
 ]
@@ -1659,7 +1681,7 @@ dependencies = [
  "log",
  "native-tls",
  "num_cpus",
- "rand 0.8.5",
+ "rand 0.8.6",
  "reqwest",
  "rustls",
  "serde",
@@ -1900,6 +1922,12 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -1975,6 +2003,7 @@ checksum = "206a8042aec68fa4a62e8d3f7aa4ceb508177d9324faf261e1959e495b7a1921"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.5",
+ "serde",
 ]
 
 [[package]]
@@ -2115,6 +2144,12 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
 [[package]]
 name = "lebe"
 version = "0.5.3"
@@ -2144,7 +2179,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667"
 dependencies = [
  "cfg-if",
- "windows-targets 0.53.3",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -2653,15 +2688,14 @@ dependencies = [
 
 [[package]]
 name = "openssl"
-version = "0.10.73"
+version = "0.10.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8505734d46c8ab1e19a1dce3aef597ad87dcb4c37e7188231769bd6bd51cebf8"
+checksum = "a45fa2aa886c42762255da344f0a0d313e254066c46aad76f300c3d3da62d967"
 dependencies = [
  "bitflags 2.9.4",
  "cfg-if",
  "foreign-types 0.3.2",
  "libc",
- "once_cell",
  "openssl-macros",
  "openssl-sys",
 ]
@@ -2685,9 +2719,9 @@ checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.109"
+version = "0.9.116"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90096e2e47630d78b7d1c20952dc621f957103f8bc2c8359ec81290d75238571"
+checksum = "f28a22dc7140cda5f096e5e7724a6962ca81a7f8bfd2979f9b18c11af56318c4"
 dependencies = [
  "cc",
  "libc",
@@ -2939,7 +2973,7 @@ dependencies = [
  "bytes",
  "getrandom 0.3.3",
  "lru-slab",
- "rand 0.9.2",
+ "rand 0.9.4",
  "ring",
  "rustc-hash 2.1.1",
  "rustls",
@@ -2962,7 +2996,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.60.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2980,11 +3014,17 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "rand"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"
 dependencies = [
  "libc",
  "rand_chacha 0.3.1",
@@ -2993,14 +3033,25 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.2"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
 ]
 
+[[package]]
+name = "rand"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
+dependencies = [
+ "chacha20",
+ "getrandom 0.4.2",
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "rand_chacha"
 version = "0.3.1"
@@ -3039,6 +3090,12 @@ dependencies = [
  "getrandom 0.3.3",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
 [[package]]
 name = "rand_distr"
 version = "0.5.1"
@@ -3046,7 +3103,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463"
 dependencies = [
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.4",
 ]
 
 [[package]]
@@ -3076,7 +3133,7 @@ dependencies = [
  "num-traits",
  "paste",
  "profiling",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rand_chacha 0.9.0",
  "simd_helpers",
  "thiserror 2.0.16",
@@ -3165,7 +3222,7 @@ version = "0.9.124"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "568068db4102230882e6d4ae8de6632e224ca75fe5970f6e026a04e91ed635d3"
 dependencies = [
- "bindgen 0.69.5",
+ "bindgen",
  "lazy_static",
  "proc-macro2",
  "quote",
@@ -3330,7 +3387,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.61.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3361,9 +3418,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.10"
+version = "0.103.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -3455,6 +3512,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+
 [[package]]
 name = "seq-macro"
 version = "0.3.6"
@@ -3541,7 +3604,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
  "digest",
 ]
 
@@ -3728,9 +3791,9 @@ dependencies = [
 
 [[package]]
 name = "tar"
-version = "0.4.45"
+version = "0.4.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973"
+checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
 dependencies = [
  "filetime",
  "libc",
@@ -3747,7 +3810,7 @@ dependencies = [
  "getrandom 0.3.3",
  "once_cell",
  "rustix",
- "windows-sys 0.61.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3847,7 +3910,7 @@ dependencies = [
  "monostate",
  "onig",
  "paste",
- "rand 0.8.5",
+ "rand 0.8.6",
  "rayon",
  "rayon-cond 0.3.0",
  "regex",
@@ -3882,7 +3945,7 @@ dependencies = [
  "monostate",
  "onig",
  "paste",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rayon",
  "rayon-cond 0.4.0",
  "regex",
@@ -4168,6 +4231,12 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a1a07cc7db3810833284e8d372ccdc6da29741639ecc70c9ec107df0fa6154c"
 
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
 [[package]]
 name = "unicode_categories"
 version = "0.1.1"
@@ -4304,7 +4373,16 @@ version = "1.0.0+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "03fa2761397e5bd52002cd7e73110c71af2109aca4e521a9f40473fe685b0a24"
 dependencies = [
- "wit-bindgen",
+ "wit-bindgen 0.45.1",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen 0.51.0",
 ]
 
 [[package]]
@@ -4379,6 +4457,28 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
+]
+
 [[package]]
 name = "wasm-streams"
 version = "0.4.2"
@@ -4392,6 +4492,18 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.9.4",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.78"
@@ -4458,7 +4570,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -4807,6 +4919,94 @@ version = "0.45.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c573471f125075647d03df72e026074b7203790d41351cd6edc96f46bcccd36"
 
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.9.4",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.1"

data/ext/candle/Cargo.toml

@@ -20,7 +20,7 @@ safetensors = "0.3"
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1.45", features = ["rt", "macros"] }
-rand = "0.8"
+rand = "0.10"
 outlines-core = "0.2.11"
 image = "0.25"
 

data/ext/candle/src/gvl.rs

@@ -0,0 +1,58 @@
+/// GVL (Global VM Lock) release support for Ruby.
+///
+/// Ruby's GVL prevents other Ruby threads from running while native code
+/// executes. For long-running operations (LLM inference, reranking, embedding),
+/// we release the GVL so other threads (TUI render loops, HTTP servers, etc.)
+/// can run concurrently.
+///
+/// SAFETY: Code running without the GVL must NOT call any Ruby API.
+
+use std::os::raw::c_void;
+
+type UnblockFn = unsafe extern "C" fn(*mut c_void);
+
+extern "C" {
+    fn rb_thread_call_without_gvl(
+        func: unsafe extern "C" fn(*mut c_void) -> *mut c_void,
+        data1: *mut c_void,
+        ubf: Option<UnblockFn>,
+        data2: *mut c_void,
+    ) -> *mut c_void;
+}
+
+/// Run a closure without the GVL. The closure must not call any Ruby API.
+pub fn without_gvl<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    struct CallData<F, R> {
+        func: Option<F>,
+        result: Option<R>,
+    }
+
+    unsafe extern "C" fn call_func<F, R>(data: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> R,
+    {
+        let data = &mut *(data as *mut CallData<F, R>);
+        let func = data.func.take().unwrap();
+        data.result = Some(func());
+        std::ptr::null_mut()
+    }
+
+    let mut data = CallData {
+        func: Some(f),
+        result: None,
+    };
+
+    unsafe {
+        rb_thread_call_without_gvl(
+            call_func::<F, R>,
+            &mut data as *mut _ as *mut c_void,
+            None,
+            std::ptr::null_mut(),
+        );
+    }
+
+    data.result.unwrap()
+}

data/ext/candle/src/lib.rs

@@ -4,6 +4,7 @@ use crate::ruby::candle_utils;
 use crate::ruby::utils::ensure_hf_cache_dir;
 use crate::ruby::Result;
 
+pub mod gvl;
 pub mod llm;
 pub mod ruby;
 pub mod structured;

data/ext/candle/src/ruby/embedding_model.rs

@@ -104,14 +104,15 @@ impl EmbeddingModel {
     /// pooling_method: "pooled", "pooled_normalized", or "cls" (default: "pooled")
     pub fn embedding(&self, input: String, pooling_method: String) -> Result<Tensor> {
         let ruby = Ruby::get().unwrap();
-        match &self.0.model {
-            Some(model) => {
-                match &self.0.tokenizer {
-                    Some(tokenizer) => Ok(Tensor(self.compute_embedding(input, model, tokenizer, &pooling_method)?)),
-                    None => Err(magnus::Error::new(ruby.exception_runtime_error(), "Tokenizer not found"))
-                }
+        match (&self.0.model, &self.0.tokenizer) {
+            (Some(model), Some(tokenizer)) => {
+                let result = crate::gvl::without_gvl(|| {
+                    self.compute_embedding(input, model, tokenizer, &pooling_method)
+                });
+                Ok(Tensor(result?))
             }
-            None => Err(magnus::Error::new(ruby.exception_runtime_error(), "Model not found"))
+            (None, _) => Err(magnus::Error::new(ruby.exception_runtime_error(), "Model not found")),
+            (_, None) => Err(magnus::Error::new(ruby.exception_runtime_error(), "Tokenizer not found")),
         }
     }
 
@@ -119,14 +120,15 @@ impl EmbeddingModel {
     /// &RETURNS&: Tensor
     pub fn embeddings(&self, input: String) -> Result<Tensor> {
         let ruby = Ruby::get().unwrap();
-        match &self.0.model {
-            Some(model) => {
-                match &self.0.tokenizer {
-                    Some(tokenizer) => Ok(Tensor(self.compute_embeddings(input, model, tokenizer)?)),
-                    None => Err(magnus::Error::new(ruby.exception_runtime_error(), "Tokenizer not found"))
-                }
+        match (&self.0.model, &self.0.tokenizer) {
+            (Some(model), Some(tokenizer)) => {
+                let result = crate::gvl::without_gvl(|| {
+                    self.compute_embeddings(input, model, tokenizer)
+                });
+                Ok(Tensor(result?))
             }
-            None => Err(magnus::Error::new(ruby.exception_runtime_error(), "Model not found"))
+            (None, _) => Err(magnus::Error::new(ruby.exception_runtime_error(), "Model not found")),
+            (_, None) => Err(magnus::Error::new(ruby.exception_runtime_error(), "Tokenizer not found")),
         }
     }
 

data/ext/candle/src/ruby/llm.rs

@@ -5,6 +5,7 @@ use std::sync::Arc;
 use crate::llm::{GenerationConfig as RustGenerationConfig, TextGenerator, mistral::Mistral as RustMistral, llama::Llama as RustLlama, gemma::Gemma as RustGemma, qwen::Qwen as RustQwen, qwen3::Qwen3 as RustQwen3, phi::Phi as RustPhi, granite::Granite as RustGranite, granitemoehybrid::GraniteMoeHybrid as RustGraniteMoeHybrid, glm4::Glm4 as RustGlm4, QuantizedGGUF as RustQuantizedGGUF};
 use crate::ruby::{Result, Device};
 use crate::ruby::structured::StructuredConstraint;
+use crate::gvl;
 
 // Use an enum to handle different model types instead of trait objects
 enum ModelType {
@@ -422,7 +423,7 @@ impl LLM {
         })
     }
 
-    /// Generate text from a prompt
+    /// Generate text from a prompt (releases GVL during inference)
     pub fn generate(&self, prompt: String, config: Option<&GenerationConfig>) -> Result<String> {
         let ruby = Ruby::get().unwrap();
         let config = config
@@ -435,8 +436,13 @@ impl LLM {
         };
         let mut model_ref = model.borrow_mut();
 
-        model_ref.generate(&prompt, &config)
-            .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("Generation failed: {}", e)))
+        // Release the GVL during inference so other Ruby threads can run
+        // (e.g., TUI render loops, HTTP servers, etc.)
+        let result = gvl::without_gvl(|| {
+            model_ref.generate(&prompt, &config)
+        });
+
+        result.map_err(|e| Error::new(ruby.exception_runtime_error(), format!("Generation failed: {}", e)))
     }
 
     /// Generate text with streaming output

data/ext/candle/src/ruby/ner.rs

@@ -173,8 +173,10 @@ impl NER {
         let ruby = Ruby::get().unwrap();
         let threshold = confidence_threshold.unwrap_or(0.9) as f32;
 
-        // Use common tokenization and prediction logic
-        let (encoding, probs_vec) = self.tokenize_and_predict(&text)?;
+        // Release GVL during tokenization + model forward pass
+        let (encoding, probs_vec) = crate::gvl::without_gvl(|| {
+            self.tokenize_and_predict(&text)
+        })?;
 
         let tokens = encoding.get_tokens();
         let offsets = encoding.get_offsets();
@@ -208,8 +210,10 @@ impl NER {
     /// Get token-level predictions with labels and confidence scores
     pub fn predict_tokens(&self, text: String) -> Result<RArray> {
         let ruby = Ruby::get().unwrap();
-        // Use common tokenization and prediction logic
-        let (encoding, probs_vec) = self.tokenize_and_predict(&text)?;
+        // Release GVL during tokenization + model forward pass
+        let (encoding, probs_vec) = crate::gvl::without_gvl(|| {
+            self.tokenize_and_predict(&text)
+        })?;
 
         let tokens = encoding.get_tokens();
 

data/ext/candle/src/ruby/reranker.rs

@@ -18,6 +18,7 @@ use hf_hub::{api::sync::Api, Repo, RepoType};
 use tokenizers::{EncodeInput, Tokenizer};
 use std::cell::RefCell;
 use crate::ruby::{Device, Result};
+use crate::gvl;
 use crate::tokenizer::{TokenizerWrapper, loader::TokenizerLoader};
 
 enum RerankerModel {
@@ -164,39 +165,27 @@ impl Reranker {
     }
 
     /// Extract CLS embeddings from the model output, handling Metal device workarounds
-    fn extract_cls_embeddings(&self, embeddings: &Tensor) -> std::result::Result<Tensor, Error> {
-        let ruby = Ruby::get().unwrap();
-        let runtime_error = ruby.exception_runtime_error();
-
+    fn extract_cls_embeddings(&self, embeddings: &Tensor) -> std::result::Result<Tensor, String> {
         let cls_embeddings = if self.device.is_metal() {
-            // Metal has issues with tensor indexing, use a different approach
             let (batch_size, seq_len, hidden_size) = embeddings.dims3()
-                .map_err(|e| Error::new(runtime_error, format!("Failed to get dims: {}", e)))?;
-
-            // Reshape to [batch * seq_len, hidden] then take first hidden vectors for each batch
+                .map_err(|e| format!("Failed to get dims: {}", e))?;
             let reshaped = embeddings.reshape((batch_size * seq_len, hidden_size))
-                .map_err(|e| Error::new(runtime_error, format!("Failed to reshape: {}", e)))?;
-
-            // Extract CLS tokens (first token of each sequence)
+                .map_err(|e| format!("Failed to reshape: {}", e))?;
             let mut cls_vecs = Vec::new();
             for i in 0..batch_size {
                 let start_idx = i * seq_len;
                 let cls_vec = reshaped.narrow(0, start_idx, 1)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to extract CLS: {}", e)))?;
+                    .map_err(|e| format!("Failed to extract CLS: {}", e))?;
                 cls_vecs.push(cls_vec);
             }
-
-            // Stack the CLS vectors
             Tensor::cat(&cls_vecs, 0)
-                .map_err(|e| Error::new(runtime_error, format!("Failed to cat CLS tokens: {}", e)))?
+                .map_err(|e| format!("Failed to cat CLS tokens: {}", e))?
         } else {
             embeddings.i((.., 0))
-                .map_err(|e| Error::new(runtime_error, format!("Failed to extract CLS token: {}", e)))?
+                .map_err(|e| format!("Failed to extract CLS token: {}", e))?
         };
-
-        // Ensure tensor is contiguous for downstream operations
         cls_embeddings.contiguous()
-            .map_err(|e| Error::new(runtime_error, format!("Failed to make CLS embeddings contiguous: {}", e)))
+            .map_err(|e| format!("Failed to make CLS embeddings contiguous: {}", e))
     }
 
     pub fn debug_tokenization(&self, query: String, document: String) -> std::result::Result<RHash, Error> {
@@ -231,124 +220,147 @@ impl Reranker {
         let runtime_error = ruby.exception_runtime_error();
         let documents: Vec<String> = documents.to_vec()?;
 
+        // Release the GVL for the entire compute portion (tokenization + inference + scoring).
+        // None of this calls Ruby API.
+        let ranked_docs = gvl::without_gvl(|| -> std::result::Result<Vec<(String, f32, usize)>, String> {
+            self.compute_rerank(&query, &documents, &pooling_method, apply_sigmoid)
+        });
+
+        let ranked_docs = ranked_docs
+            .map_err(|e| Error::new(runtime_error, e))?;
+
+        // Build result array (requires GVL for Ruby object creation)
+        let result_array = ruby.ary_new();
+        for (doc, score, doc_id) in ranked_docs {
+            let tuple = ruby.ary_new();
+            tuple.push(doc)?;
+            tuple.push(ruby.float_from_f64(score as f64))?;
+            tuple.push(doc_id)?;
+            result_array.push(tuple)?;
+        }
+        Ok(result_array)
+    }
+
+    /// Pure compute portion of reranking — no Ruby API calls.
+    /// Returns ranked (document, score, original_index) tuples.
+    fn compute_rerank(&self, query: &str, documents: &[String], pooling_method: &str, apply_sigmoid: bool) -> std::result::Result<Vec<(String, f32, usize)>, String> {
         // Create query-document pairs for cross-encoder
         let query_and_docs: Vec<EncodeInput> = documents
             .iter()
-            .map(|d| (query.clone(), d.clone()).into())
+            .map(|d| (query.to_string(), d.clone()).into())
             .collect();
 
-        // Tokenize batch using inner tokenizer for access to token type IDs
+        // Tokenize batch
         let encodings = self.tokenizer.inner().encode_batch(query_and_docs, true)
-            .map_err(|e| Error::new(runtime_error, format!("Tokenization failed: {}", e)))?;
+            .map_err(|e| format!("Tokenization failed: {}", e))?;
 
-        // Convert to tensors
-        let token_ids = encodings
+        let token_ids_vec = encodings
             .iter()
             .map(|e| e.get_ids().to_vec())
             .collect::<Vec<_>>();
 
-        let token_type_ids = encodings
+        let token_type_ids_vec = encodings
             .iter()
             .map(|e| e.get_type_ids().to_vec())
             .collect::<Vec<_>>();
 
-        let token_ids = Tensor::new(token_ids, &self.device)
-            .map_err(|e| Error::new(runtime_error, format!("Failed to create tensor: {}", e)))?;
-        let token_type_ids = Tensor::new(token_type_ids, &self.device)
-            .map_err(|e| Error::new(runtime_error, format!("Failed to create token type ids tensor: {}", e)))?;
+        let token_ids = Tensor::new(token_ids_vec, &self.device)
+            .map_err(|e| format!("Failed to create tensor: {}", e))?;
+        let token_type_ids = Tensor::new(token_type_ids_vec, &self.device)
+            .map_err(|e| format!("Failed to create token type ids tensor: {}", e))?;
 
         // Compute scores based on model type
         let scores = match &self.model {
             RerankerModel::Bert { model, pooler, classifier } => {
                 let attention_mask = token_ids.ne(0u32)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to create attention mask: {}", e)))?;
+                    .map_err(|e| format!("Failed to create attention mask: {}", e))?;
 
                 // Forward pass through BERT
                 let embeddings = model.forward(&token_ids, &token_type_ids, Some(&attention_mask))
-                    .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
+                    .map_err(|e| format!("Model forward pass failed: {}", e))?;
 
                 // Apply pooling based on the specified method
-                let pooled_embeddings = match pooling_method.as_str() {
+                let pooled_embeddings = match pooling_method {
                     "pooler" => {
                         let cls_embeddings = self.extract_cls_embeddings(&embeddings)?;
                         let pooled = pooler.forward(&cls_embeddings)
-                            .map_err(|e| Error::new(runtime_error, format!("Pooler forward failed: {}", e)))?;
+                            .map_err(|e| format!("Pooler forward failed: {}", e))?;
                         pooled.tanh()
-                            .map_err(|e| Error::new(runtime_error, format!("Tanh activation failed: {}", e)))?
+                            .map_err(|e| format!("Tanh activation failed: {}", e))?
                     },
                     "cls" => {
                         self.extract_cls_embeddings(&embeddings)?
                     },
                     "mean" => {
                         let (_batch, seq_len, _hidden) = embeddings.dims3()
-                            .map_err(|e| Error::new(runtime_error, format!("Failed to get tensor dimensions: {}", e)))?;
+                            .map_err(|e| format!("Failed to get tensor dimensions: {}", e))?;
                         let sum = embeddings.sum(1)
-                            .map_err(|e| Error::new(runtime_error, format!("Failed to sum embeddings: {}", e)))?;
+                            .map_err(|e| format!("Failed to sum embeddings: {}", e))?;
                         (sum / (seq_len as f64))
-                            .map_err(|e| Error::new(runtime_error, format!("Failed to compute mean: {}", e)))?
+                            .map_err(|e| format!("Failed to compute mean: {}", e))?
                     },
-                    _ => return Err(Error::new(runtime_error,
-                        format!("Unknown pooling method: {}. Use 'pooler', 'cls', or 'mean'", pooling_method)))
+                    _ => return Err(
+                        format!("Unknown pooling method: {}. Use 'pooler', 'cls', or 'mean'", pooling_method))
                 };
 
                 let pooled_embeddings = pooled_embeddings.contiguous()
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to make pooled_embeddings contiguous: {}", e)))?;
+                    .map_err(|e| format!("Failed to make pooled_embeddings contiguous: {}", e))?;
                 let logits = classifier.forward(&pooled_embeddings)
-                    .map_err(|e| Error::new(runtime_error, format!("Classifier forward failed: {}", e)))?;
+                    .map_err(|e| format!("Classifier forward failed: {}", e))?;
                 logits.squeeze(1)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to squeeze tensor: {}", e)))?
+                    .map_err(|e| format!("Failed to squeeze tensor: {}", e))?
             }
             RerankerModel::XLMRoberta { model, pad_token_id } => {
                 let attention_mask = token_ids.ne(*pad_token_id)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to create attention mask: {}", e)))?;
+                    .map_err(|e| format!("Failed to create attention mask: {}", e))?;
 
                 // XLMRobertaForSequenceClassification returns logits directly
                 let logits = model.forward(&token_ids, &attention_mask, &token_type_ids)
-                    .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
+                    .map_err(|e| format!("Model forward pass failed: {}", e))?;
                 logits.squeeze(1)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to squeeze tensor: {}", e)))?
+                    .map_err(|e| format!("Failed to squeeze tensor: {}", e))?
             }
             RerankerModel::DeBERTa { model, pooler, classifier, pad_token_id } => {
                 let attention_mask = token_ids.ne(*pad_token_id)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to create attention mask: {}", e)))?;
+                    .map_err(|e| format!("Failed to create attention mask: {}", e))?;
 
                 // Forward through DeBERTa encoder
                 let encoder_output = model.forward(&token_ids, Some(token_type_ids.clone()), Some(attention_mask))
-                    .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
+                    .map_err(|e| format!("Model forward pass failed: {}", e))?;
 
                 // Pool and classify
                 let pooled = pooler.forward(&encoder_output)
-                    .map_err(|e| Error::new(runtime_error, format!("Pooler forward failed: {}", e)))?;
+                    .map_err(|e| format!("Pooler forward failed: {}", e))?;
                 let logits = classifier.forward(&pooled)
-                    .map_err(|e| Error::new(runtime_error, format!("Classifier forward failed: {}", e)))?;
+                    .map_err(|e| format!("Classifier forward failed: {}", e))?;
                 logits.squeeze(1)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to squeeze tensor: {}", e)))?
+                    .map_err(|e| format!("Failed to squeeze tensor: {}", e))?
             }
             RerankerModel::ModernBert { model, head_dense, head_norm, classifier, pad_token_id } => {
                 let attention_mask = token_ids.ne(*pad_token_id)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to create attention mask: {}", e)))?;
+                    .map_err(|e| format!("Failed to create attention mask: {}", e))?;
                 let attention_mask_f32 = attention_mask.to_dtype(DType::F32)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to convert attention mask: {}", e)))?;
+                    .map_err(|e| format!("Failed to convert attention mask: {}", e))?;
 
                 // Forward through ModernBERT encoder
                 let encoder_output = model.forward(&token_ids, &attention_mask_f32)
-                    .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
+                    .map_err(|e| format!("Model forward pass failed: {}", e))?;
 
                 // CLS pooling, then head (dense + GELU + norm) + classifier
                 let cls = encoder_output.i((.., 0, ..))
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to extract CLS: {}", e)))?
+                    .map_err(|e| format!("Failed to extract CLS: {}", e))?
                     .contiguous()
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to make contiguous: {}", e)))?;
+                    .map_err(|e| format!("Failed to make contiguous: {}", e))?;
                 let hidden = head_dense.forward(&cls)
-                    .map_err(|e| Error::new(runtime_error, format!("Head dense failed: {}", e)))?;
+                    .map_err(|e| format!("Head dense failed: {}", e))?;
                 let hidden = hidden.gelu_erf()
-                    .map_err(|e| Error::new(runtime_error, format!("GELU activation failed: {}", e)))?;
+                    .map_err(|e| format!("GELU activation failed: {}", e))?;
                 let hidden = head_norm.forward(&hidden)
-                    .map_err(|e| Error::new(runtime_error, format!("Head norm failed: {}", e)))?;
+                    .map_err(|e| format!("Head norm failed: {}", e))?;
                 let logits = classifier.forward(&hidden)
-                    .map_err(|e| Error::new(runtime_error, format!("Classifier forward failed: {}", e)))?;
+                    .map_err(|e| format!("Classifier forward failed: {}", e))?;
                 logits.squeeze(1)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to squeeze tensor: {}", e)))?
+                    .map_err(|e| format!("Failed to squeeze tensor: {}", e))?
             }
             RerankerModel::Qwen3 { model, yes_token_id, no_token_id } => {
                 // Qwen3 reranker: decoder-based yes/no scoring
@@ -356,7 +368,7 @@ impl Reranker {
                 let mut scores_vec: Vec<f32> = Vec::with_capacity(documents.len());
                 let mut model = model.borrow_mut();
 
-                for doc in &documents {
+                for doc in documents.iter() {
                     // Build the Qwen3 reranker prompt
                     let prompt = format!(
                         "<|im_start|>system\nJudge whether the Document meets the requirements based on the Query and the Instruct provided. Note that the answer can only be \"yes\" or \"no\".<|im_end|>\n<|im_start|>user\n<Instruct>: Given a web search query, retrieve relevant passages that answer the query\n<Query>: {}\n<Document>: {}<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n",
@@ -365,7 +377,7 @@ impl Reranker {
 
                     // Tokenize the prompt
                     let encoding = self.tokenizer.inner().encode(prompt.as_str(), false)
-                        .map_err(|e| Error::new(runtime_error, format!("Tokenization failed: {}", e)))?;
+                        .map_err(|e| format!("Tokenization failed: {}", e))?;
                     let input_ids: Vec<u32> = encoding.get_ids().to_vec();
 
                     // Clear KV cache for each document
@@ -373,28 +385,28 @@ impl Reranker {
 
                     // Forward pass — get logits for the last token position
                     let input_tensor = Tensor::new(&input_ids[..], &self.device)
-                        .map_err(|e| Error::new(runtime_error, format!("Failed to create tensor: {}", e)))?
+                        .map_err(|e| format!("Failed to create tensor: {}", e))?
                         .unsqueeze(0)
-                        .map_err(|e| Error::new(runtime_error, format!("Failed to unsqueeze: {}", e)))?;
+                        .map_err(|e| format!("Failed to unsqueeze: {}", e))?;
 
                     let logits = model.forward(&input_tensor, 0)
-                        .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
+                        .map_err(|e| format!("Model forward pass failed: {}", e))?;
 
                     // logits shape: [1, 1, vocab_size] → flatten to [vocab_size]
                     let logits = logits.flatten_all()
-                        .map_err(|e| Error::new(runtime_error, format!("Failed to flatten: {}", e)))?
+                        .map_err(|e| format!("Failed to flatten: {}", e))?
                         .to_dtype(DType::F32)
-                        .map_err(|e| Error::new(runtime_error, format!("Failed to convert dtype: {}", e)))?;
+                        .map_err(|e| format!("Failed to convert dtype: {}", e))?;
 
                     // Extract yes/no logits and compute score
                     let yes_logit: f32 = logits.i(*yes_token_id as usize)
-                        .map_err(|e| Error::new(runtime_error, format!("Failed to get yes logit: {}", e)))?
+                        .map_err(|e| format!("Failed to get yes logit: {}", e))?
                         .to_scalar()
-                        .map_err(|e| Error::new(runtime_error, format!("Failed to convert yes logit: {}", e)))?;
+                        .map_err(|e| format!("Failed to convert yes logit: {}", e))?;
                     let no_logit: f32 = logits.i(*no_token_id as usize)
-                        .map_err(|e| Error::new(runtime_error, format!("Failed to get no logit: {}", e)))?
+                        .map_err(|e| format!("Failed to get no logit: {}", e))?
                         .to_scalar()
-                        .map_err(|e| Error::new(runtime_error, format!("Failed to convert no logit: {}", e)))?;
+                        .map_err(|e| format!("Failed to convert no logit: {}", e))?;
 
                     // softmax over [yes, no] → P(yes)
                     let max_logit = yes_logit.max(no_logit);
@@ -407,24 +419,25 @@ impl Reranker {
 
                 // Build scores tensor for uniform handling below
                 Tensor::new(scores_vec.as_slice(), &self.device)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to create scores tensor: {}", e)))?
+                    .map_err(|e| format!("Failed to create scores tensor: {}", e))?
             }
         };
 
         // Optionally apply sigmoid activation
         let scores = if apply_sigmoid {
             sigmoid(&scores)
-                .map_err(|e| Error::new(runtime_error, format!("Sigmoid failed: {}", e)))?
+                .map_err(|e| format!("Sigmoid failed: {}", e))?
         } else {
             scores
         };
 
         let scores_vec: Vec<f32> = scores.to_vec1()
-            .map_err(|e| Error::new(runtime_error, format!("Failed to convert scores to vec: {}", e)))?;
+            .map_err(|e| format!("Failed to convert scores to vec: {}", e))?;
 
         // Create tuples with document, score, and original index
         let mut ranked_docs: Vec<(String, f32, usize)> = documents
-            .into_iter()
+            .iter()
+            .cloned()
             .zip(scores_vec)
             .enumerate()
             .map(|(idx, (doc, score))| (doc, score, idx))
@@ -433,16 +446,7 @@ impl Reranker {
         // Sort documents by relevance score (descending)
         ranked_docs.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
 
-        // Build result array with [doc, score, doc_id]
-        let result_array = ruby.ary_new();
-        for (doc, score, doc_id) in ranked_docs {
-            let tuple = ruby.ary_new();
-            tuple.push(doc)?;
-            tuple.push(ruby.float_from_f64(score as f64))?;
-            tuple.push(doc_id)?;
-            result_array.push(tuple)?;
-        }
-        Ok(result_array)
+        Ok(ranked_docs)
     }
 
     /// Get the tokenizer used by this model

data/lib/candle/version.rb

@@ -1,5 +1,5 @@
 # :nocov:
 module Candle
-  VERSION = "1.7.0"
+  VERSION = "1.8.0.pre1"
 end
 # :nocov:

data/lib/candle.rb

@@ -1,5 +1,19 @@
 require_relative "candle/logger"
-require "candle/candle"
+
+# Load the compiled Rust extension. Precompiled (platform) gems install it into a
+# Ruby-ABI-versioned subdir (lib/candle/<major.minor>/candle.{so,bundle}) so a single
+# fat gem can carry a binary per Ruby version; source/dev builds place it flat at
+# lib/candle/candle.{so,bundle}. Try the versioned path first, fall back to the flat
+# one. Resolution goes through $LOAD_PATH (`require`, never `require_relative`) because
+# RubyGems installs native extensions outside the gem's lib/ dir — see
+# spec/require_spec.rb and Issue #75.
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "candle/#{Regexp.last_match(1)}/candle"
+rescue LoadError
+  require "candle/candle"
+end
+
 require_relative "candle/tensor"
 require_relative "candle/device_utils"
 require_relative "candle/embedding_model_type"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: red-candle
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0.pre1
 platform: ruby
 authors:
 - Christopher Petersen
@@ -215,6 +215,7 @@ files:
 - ext/candle/build.rs
 - ext/candle/extconf.rb
 - ext/candle/rustfmt.toml
+- ext/candle/src/gvl.rs
 - ext/candle/src/lib.rs
 - ext/candle/src/llm/constrained_generation_test.rs
 - ext/candle/src/llm/gemma.rs
@@ -290,7 +291,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '3.3'
 requirements:
 - Rust >= 1.85
-rubygems_version: 4.0.6
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby gem for running state-of-the-art language models locally. Access LLMs,
   embeddings, rerankers, and NER models directly from Ruby using Rust-powered Candle