typst 0.15.1.6 → 0.15.1.9.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97e4afa751e5a0bded609e423ea893b263ac5676afe79fe4bcde12761bd242dd
-  data.tar.gz: 112c45f8dbebcdcbcec318948b879dc47f44dc5c2bd5a143e4c035928dec6473
+  metadata.gz: 3c7cc49e13eced386fc44cfb914ebf07dc5892490730f3fd4fbed7448e974f74
+  data.tar.gz: 1f7e43e5d752bf8817f22ad3a3da673f1370f697d93effe05d69fe15128960e9
 SHA512:
-  metadata.gz: d825ef788371496a9b354cf1b22d3ea06c9f7fe2e3d1cc56b18310a9af1fede42fe449b23964c20f2b34df98a31155846d21750da0eaed97d146abbd4a7ad425
-  data.tar.gz: 0c561636ed80e29170ba849853ecd0c8342cb3abc609fb1d7ffeadc466eda702d537a454e1becd36e61f7339adc320ab6177adaf84d3bd8ef048ba6e7ddab222
+  metadata.gz: c44932e11673f6881589eb84e1e7a736e1116adf8c4f9200d4e14da7624eeb24df01320dac16faea7f5ac3e0d8567ea44c400422c94c57e250e7c705d289643c
+  data.tar.gz: 8b5689a033596181456b73a321f7df85b3ecd66b67865a33b6030b9560d0474b596f330564b7c335bf0f15bb9e469129fea424d01f1ac97ef1f13f595a7511c8

data/Cargo.lock

@@ -2060,18 +2060,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.128"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45ca28513560e56cfb79a62b1fce363c73af170a182024ce880c77ee9429920a"
+checksum = "02faf625bb10ba893e3ae620f19c9fb1b5f8fcae0fe4eb86bb3f2230fad75edb"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.128"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce04b2c55eff3a21aaa623fcc655d94373238e72cac6b3e1a3641ff31649f99a"
+checksum = "05be6f9c86fe5482808162826f6c047d093b3670582296c770de1d94f8066694"
 dependencies = [
  "bindgen",
  "lazy_static",

data/Cargo.toml

@@ -1,3 +1,6 @@
 [workspace]
 members = ["ext/typst"]
-resolver = "2"
+resolver = "2"
+
+[profile.release]
+strip = true

data/README.md

@@ -263,13 +263,67 @@ max_age = 10
 Typst::clear_cache(max_age)
 ```
 
+### Experimental
+
+#### Threads and concurrency
+
+A new experimental `concurrent` flag is added to work around Ruby's global VM lock and speed things up for batch workloads.
+
+Set the option globally
+```ruby
+Typst.concurrent = true
+```
+
+Or set the option per call
+```ruby
+Typst(body: invoice, concurrent: true)
+```
+
+Compiling releases Ruby's global VM lock, so several threads can compile at the
+same time and genuinely use several cores.
+
+```ruby
+docs = invoices.map { |invoice| Thread.new { Typst(body: invoice, concurrent: true).compile(:pdf) } }.map(&:value)
+```
+
+Eight threads compiling the same document, measured on a 24-core machine:
+
+| threads | documents/second | cores busy |
+|--------:|-----------------:|-----------:|
+|       1 |              9.9 |       1.00 |
+|       8 |             36.0 |       7.65 |
+
+That is throughput across documents, not speed within one. typst parallelizes
+page runs, so a document with a single page layout is one run and stays on one
+core no matter how many threads it is given.
+
+Threads share the compilation cache and the font discovery. Compiling different
+sources, with different `sys_inputs`, font paths and roots, at the same time is
+safe.
+
+Three things to know:
+
+* A compile cannot be interrupted. `Thread#kill` and `Ctrl-C` take effect once
+  it returns.
+* Package storage is not safe to populate concurrently. Threads that need the
+  same not-yet-cached package each download their own copy and untar it
+  straight into the same directory, over each other; on Windows that fails
+  outright rather than clobbering. Compile once to warm the cache before
+  fanning out. Reading a package already on disk from many threads is safe.
+* `clear_cache` takes the cache's write lock, so calling it in a loop while other
+  threads compile will starve them. Measured with four threads compiling and one
+  evicting as fast as it could, the compiles took 400 times longer. Call it
+  between batches of documents, not between documents.
+
 ## Contributors & Acknowledgements
 typst-rb is based on [typst-py](https://github.com/messense/typst-py) by [messense](https://github.com/messense)\
 clear_cache was contributed by [NRicciVestmark](https://github.com/NRicciVestmark)\
 CI improvements were contributed by [am1006](https://github.com/am1006)\
 Defect resolutions by [adam12](https://github.com/adam12) and [walterdavis](https://github.com/walterdavis)\
 Design suggestions by [alec-c4](https://github.com/alec-c4)\
-Compiler warnings were contributed by [TheSoloHacker47](https://github.com/TheSoloHacker47)
+Compiler warnings were contributed by [TheSoloHacker47](https://github.com/TheSoloHacker47) \
+Font optimization patches were contributed by [dmke](https://github.com/dmke) \
+Concurrency patches were contributed by [dmke](https://github.com/dmke)
 
 ## License
 

data/README.typ

@@ -270,6 +270,61 @@ max_age = 10
 Typst::clear_cache(max_age)
 ```
 
+=== Experimental
+
+==== Threads and concurrency
+
+A new experimental `concurrent` flag is added to work around Ruby's global VM lock and speed things up for batch workloads.
+
+Set the option globally
+```ruby
+Typst.concurrent = true
+```
+
+Or set the option per call
+```ruby
+Typst(body: invoice, concurrent: true)
+```
+
+Compiling releases Ruby's global VM lock, so several threads can compile at the
+same time and genuinely use several cores.
+
+```ruby
+docs = invoices.map { |invoice| Thread.new { Typst(body: invoice, concurrent: true).compile(:pdf) } }.map(&:value)
+```
+
+Eight threads compiling the same document, measured on a 24-core machine:
+
+#table(
+  columns: 3,
+  align: (right, right, right),
+  table.header([threads], [documents/second], [cores busy]),
+  [1], [9.9], [1.00],
+  [8], [36.0], [7.65],
+)
+
+That is throughput across documents, not speed within one. typst parallelizes
+page runs, so a document with a single page layout is one run and stays on one
+core no matter how many threads it is given.
+
+Threads share the compilation cache and the font discovery. Compiling different
+sources, with different `sys_inputs`, font paths and roots, at the same time is
+safe.
+
+Three things to know:
+
+- A compile cannot be interrupted. `Thread#kill` and `Ctrl-C` take effect once
+  it returns.
+- Package storage is not safe to populate concurrently. Threads that need the
+  same not-yet-cached package each download their own copy and untar it
+  straight into the same directory, over each other; on Windows that fails
+  outright rather than clobbering. Compile once to warm the cache before
+  fanning out. Reading a package already on disk from many threads is safe.
+- `clear_cache` takes the cache's write lock, so calling it in a loop while other
+  threads compile will starve them. Measured with four threads compiling and one
+  evicting as fast as it could, the compiles took 400 times longer. Call it
+  between batches of documents, not between documents.
+
 == Contributors & Acknowledgements
 typst-rb is based on #link("https://github.com/messense/typst-py")[typst-py] by #link("https://github.com/messense")[messense]\
 clear_cache was contributed by #link("https://github.com/NRicciVestmark")[NRicciVestmark]\
@@ -277,6 +332,7 @@ CI improvements were contributed by #link("https://github.com/am1006")[am1006]\
 Defect resolutions by #link("https://github.com/adam12")[adam12] and #link("https://github.com/walterdavis")[walterdavis]\
 Design suggestions by #link("https://github.com/alec-c4")[alec-c4]\
 Compiler warnings were contributed by #link("https://github.com/TheSoloHacker47")[TheSoloHacker47]
+Concurrency patches were contributed by #link("https://github.com/dmke")[dmke]
 
 == License
 

data/Rakefile

@@ -30,10 +30,18 @@ end
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['test/*_test.rb']
+  # Absolute, because test/typst_test.rb chdirs into its own directory as it
+  # loads and the loader resolves what follows it against the working directory.
+  t.test_files = FileList['test/*_test.rb'].map { |f| File.expand_path(f) }
   t.verbose = true
 end
 
+task 'benchmark' do |t|
+  Dir.glob("benchmarks/*.rb").each do |b|
+    sh "bundle exec ruby #{b}"
+  end
+end
+
 task 'gem:native' do |t|
   CROSS_PLATFORMS.each do |platform|
     sh "bundle exec rb-sys-dock --platform #{platform} --build"
@@ -45,4 +53,4 @@ task 'gem:native:push' do |t|
   CROSS_PLATFORMS.each do |platform|
     sh "gem push pkg/typst-#{spec.version}-#{platform}.gem"
   end
-end
+end

data/ext/typst/Cargo.toml

@@ -52,4 +52,4 @@ walkdir = "2.4.0"
 
 # enable rb-sys feature to test against Ruby head. This is only needed if you
 # want to work with the unreleased, in-development, next version of Ruby
-rb-sys = { version = "0.9.128", default-features = false, features = ["stable-api-compiled-fallback"] }
+rb-sys = { version = "0.9.130", default-features = false, features = ["stable-api-compiled-fallback"] }

data/ext/typst/extconf.rb

@@ -1,4 +1,15 @@
 require "mkmf"
 require "rb_sys/mkmf"
 
+module RbSys
+    class CargoBuilder < Gem::Ext::Builder
+        alias_method :old_platform_specific_rustc_args, :platform_specific_rustc_args
+        def new_platform_specific_rustc_args(dest_dir, flags = [])
+            flags += ["-l", "kernel32"] if mingw_target? # add kernel32 before libruby to avoid the sleep bug
+            old_platform_specific_rustc_args(dest_dir, flags)
+        end
+        alias_method :platform_specific_rustc_args, :new_platform_specific_rustc_args
+    end
+end
+
 create_rust_makefile("typst/typst")

data/ext/typst/src/lib.rs

@@ -7,15 +7,16 @@ use query::{query as typst_query, QueryCommand, SerializationFormat};
 use typst::foundations::{Dict, Value};
 use typst_library::Feature;
 use typst_pdf::PdfStandard;
+use nogvl::without_gvl;
 use world::SystemWorld;
 
 mod compiler;
 mod download;
+mod nogvl;
 mod query;
 mod world;
 
 fn to_html(
-    ruby: &Ruby,
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
@@ -24,13 +25,13 @@ fn to_html(
     render_bleed: bool,
     pretty: bool,
     sys_inputs: HashMap<String, String>,
-) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+) -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
     let input = input.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+        .map_err(|err| err.to_string())?;
 
     let root = if let Some(root) = root {
         root.canonicalize()
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+        .map_err(|err| err.to_string())?
     } else if let Some(dir) = input.parent() {
         dir.into()
     } else {
@@ -60,32 +61,53 @@ fn to_html(
         .ignore_system_fonts(ignore_system_fonts)
         .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
-        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let compiled = world
         .compile(Some("html"), None, &Vec::new(), pretty, render_bleed)
-        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     Ok(compiled)
 }
 
-fn to_svg(
+fn route_to_html(
     ruby: &Ruby,
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
     ignore_system_fonts: bool,
     ignore_embedded_fonts: bool,
+    concurrent: bool,
     render_bleed: bool,
     pretty: bool,
     sys_inputs: HashMap<String, String>,
 ) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+    if concurrent {
+        without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
+            to_html(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
+        })
+    } else {
+        to_html(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
+    }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+}
+
+fn to_svg(
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    render_bleed: bool,
+    pretty: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
     let input = input.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let root = if let Some(root) = root {
         root.canonicalize()
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+            .map_err(|msg| msg.to_string())?
     } else if let Some(dir) = input.parent() {
         dir.into()
     } else {
@@ -102,32 +124,53 @@ fn to_svg(
         .ignore_system_fonts(ignore_system_fonts)
         .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
-        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let compiled = world
         .compile(Some("svg"), None, &Vec::new(), pretty, render_bleed)
-        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     Ok(compiled)
 }
 
-fn to_png(
+fn route_to_svg(
     ruby: &Ruby,
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
     ignore_system_fonts: bool,
     ignore_embedded_fonts: bool,
+    concurrent: bool,
     render_bleed: bool,
+    pretty: bool,
     sys_inputs: HashMap<String, String>,
-    ppi: Option<f32>,
 ) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+    if concurrent {
+        without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
+            to_svg(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
+        })
+    } else {
+        to_svg(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
+    }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+}
+
+fn to_png(
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    render_bleed: bool,
+    sys_inputs: HashMap<String, String>,
+    ppi: Option<f32>,
+) -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
     let input = input.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let root = if let Some(root) = root {
         root.canonicalize()
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+            .map_err(|msg| msg.to_string())?
     } else if let Some(dir) = input.parent() {
         dir.into()
     } else {
@@ -144,17 +187,38 @@ fn to_png(
         .ignore_system_fonts(ignore_system_fonts)
         .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
-        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let compiled = world
         .compile(Some("png"), ppi, &Vec::new(), false, render_bleed)
-        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     Ok(compiled)
 }
 
-fn to_pdf(
+fn route_to_png(
     ruby: &Ruby,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    concurrent: bool,
+    render_bleed: bool,
+    sys_inputs: HashMap<String, String>,
+    ppi: Option<f32>,
+) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+    if concurrent {
+        without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
+            to_png(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, sys_inputs, ppi)
+        })
+    } else {
+        to_png(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, sys_inputs, ppi)
+    }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+}
+
+fn to_pdf(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
@@ -163,13 +227,13 @@ fn to_pdf(
     pretty: bool,
     sys_inputs: HashMap<String, String>,
     pdf_standards: Vec<String>,
-) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+) -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
     let input = input.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let root = if let Some(root) = root {
         root.canonicalize()
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+            .map_err(|msg| msg.to_string())?
     } else if let Some(dir) = input.parent() {
         dir.into()
     } else {
@@ -186,7 +250,7 @@ fn to_pdf(
         .ignore_system_fonts(ignore_system_fonts)
         .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
-        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let pdf_standards_lookup: HashMap::<&str, PdfStandard> = HashMap::from([
         ("1.4", PdfStandard::V_1_4),
@@ -213,19 +277,40 @@ fn to_pdf(
         let result = pdf_standards_lookup.get(pdf_standard.as_str());
         match result {
             Some(value) => pdf_standards_vec.push(*value),
-            _ => return Err(magnus::Error::new(ruby.exception_arg_error(), "Unknown PdfStandard")),
+            _ => return Err("Unknown PdfStandard".to_string()),
         }
     }
 
     let compiled = world
         .compile(Some("pdf"), None, &pdf_standards_vec, pretty, true)
-        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     Ok(compiled)
 }
 
-fn query(
+fn route_to_pdf(
     ruby: &Ruby,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    concurrent: bool,
+    pretty: bool,
+    sys_inputs: HashMap<String, String>,
+    pdf_standards: Vec<String>,
+) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+    if concurrent {
+        without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
+            to_pdf(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, pretty, sys_inputs, pdf_standards)
+        })
+    } else {
+        to_pdf(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, pretty, sys_inputs, pdf_standards)
+    }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+}
+
+fn query(
     selector: String,
     field: Option<String>,
     one: bool,
@@ -236,19 +321,19 @@ fn query(
     ignore_system_fonts: bool,
     ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
-) -> Result<String, Error> {
+) -> Result<String, String> {
     let format = match format.unwrap().to_ascii_lowercase().as_str() {
         "json" => SerializationFormat::Json,
         "yaml" => SerializationFormat::Yaml,
-        _ => return Err(magnus::Error::new(ruby.exception_arg_error(), "unsupported serialization format"))?,
+        _ => return Err("unsupported serialization format".to_string()),
     };
 
     let input = input.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let root = if let Some(root) = root {
         root.canonicalize()
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+            .map_err(|msg| msg.to_string())?
     } else if let Some(dir) = input.parent() {
         dir.into()
     } else {
@@ -265,7 +350,7 @@ fn query(
     .ignore_system_fonts(ignore_system_fonts)
     .ignore_embedded_fonts(ignore_embedded_fonts)
     .build()
-    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+    .map_err(|msg| msg.to_string())?;
 
     let result = typst_query(
         &mut world,
@@ -279,24 +364,53 @@ fn query(
 
     match result {
         Ok(data) => Ok(data),
-        Err(msg) => Err(magnus::Error::new(ruby.exception_arg_error(), msg.to_string())),
+        Err(msg) => return Err(msg.to_string()),
+    }
+}
+
+fn route_query(
+    ruby: &Ruby,
+    selector: String,
+    field: Option<String>,
+    one: bool,
+    format: Option<String>,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    concurrent: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<String, Error> {
+    if concurrent {
+        without_gvl(move || -> Result<String, String> {
+            query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, sys_inputs)
+        })
+    } else {
+        query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, sys_inputs)
     }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
 }
 
 fn clear_cache(_ruby: &Ruby, max_age: usize) {
     comemo::evict(max_age);
 }
 
+fn clear_font_cache(_ruby: &Ruby) {
+    world::clear_font_cache();
+}
+
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     env_logger::init();
 
     let module = ruby.define_module("Typst")?;
-    module.define_singleton_method("_to_pdf", function!(to_pdf, 8))?;
-    module.define_singleton_method("_to_svg", function!(to_svg, 8))?;
-    module.define_singleton_method("_to_png", function!(to_png, 8))?;
-    module.define_singleton_method("_to_html", function!(to_html, 8))?;
-    module.define_singleton_method("_query", function!(query, 10))?;
+    module.define_singleton_method("_to_pdf", function!(route_to_pdf, 9))?;
+    module.define_singleton_method("_to_svg", function!(route_to_svg, 9))?;
+    module.define_singleton_method("_to_png", function!(route_to_png, 9))?;
+    module.define_singleton_method("_to_html", function!(route_to_html, 9))?;
+    module.define_singleton_method("_query", function!(route_query, 11))?;
     module.define_singleton_method("_clear_cache", function!(clear_cache, 1))?;
+    module.define_singleton_method("_clear_font_cache", function!(clear_font_cache, 0))?;
     Ok(())
 }

data/ext/typst/src/nogvl.rs

@@ -0,0 +1,49 @@
+use std::ffi::c_void;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+/// Runs `f` with the GVL released, so other Ruby threads keep running while
+/// Typst compiles.
+///
+/// `f` runs on the calling OS thread and must not touch the Ruby API — no
+/// `Ruby` handle, no `Value`, no allocation of Ruby objects. Convert to and
+/// from Ruby types outside of this call.
+///
+/// No unblocking function is registered, so the call cannot be interrupted;
+/// a compile always runs to completion. That matches the previous behaviour,
+/// where holding the GVL made the compile uninterruptible anyway.
+pub fn without_gvl<F, T>(f: F) -> T
+where
+    F: FnOnce() -> T,
+{
+    struct Payload<F, T> {
+        f: Option<F>,
+        result: Option<std::thread::Result<T>>,
+    }
+
+    // A Rust panic must not unwind across the C frame that Ruby pushes here,
+    // so it is caught and resumed once we hold the GVL again.
+    unsafe extern "C" fn trampoline<F, T>(data: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> T,
+    {
+        let payload = &mut *data.cast::<Payload<F, T>>();
+        let f = payload.f.take().expect("closure called twice");
+        payload.result = Some(catch_unwind(AssertUnwindSafe(f)));
+        std::ptr::null_mut()
+    }
+
+    let mut payload = Payload { f: Some(f), result: None };
+    unsafe {
+        rb_sys::rb_thread_call_without_gvl(
+            Some(trampoline::<F, T>),
+            (&raw mut payload).cast::<c_void>(),
+            None,
+            std::ptr::null_mut(),
+        );
+    }
+
+    match payload.result.take().expect("closure was not called") {
+        Ok(value) => value,
+        Err(panic) => std::panic::resume_unwind(panic),
+    }
+}

data/ext/typst/src/world.rs

@@ -7,10 +7,10 @@ use chrono::{DateTime, Datelike, FixedOffset, Local};
 use typst::diag::{FileError, FileResult, StrResult};
 use typst::foundations::{Bytes, Datetime, Dict, Duration};
 use typst::syntax::{FileId, Lines, Source, VirtualPath, VirtualRoot, RootedPath};
-use typst::text::{Font, FontBook};
+use typst::text::{Font, FontBook, FontInfo};
 use typst::utils::LazyHash;
 use typst::{Features, Library, LibraryExt, World};
-use typst_kit::fonts::{self, FontStore};
+use typst_kit::fonts::{self, FontPath, FontStore};
 use typst_kit::packages::{FsPackages, SystemPackages, UniversePackages};
 
 /// A world that provides access to the operating system.
@@ -195,7 +195,7 @@ impl SystemWorldBuilder {
     }
 
     pub fn build(self) -> StrResult<SystemWorld> {
-        let fonts = Arc::new(build_font_store(self.ignore_system_fonts, self.ignore_embedded_fonts, self.font_paths));
+        let fonts = font_store(self.ignore_system_fonts, self.ignore_embedded_fonts, self.font_paths);
 
         let package_storage = system_packages(self.package_path, self.package_cache_path);
 
@@ -217,13 +217,84 @@ impl SystemWorldBuilder {
     }
 }
 
+/// Font discovery, which is far too slow to repeat on every compile.
+///
+/// A full system font scan takes about 95 ms, which for a small document
+/// dwarfs the compilation itself. `FontStore` cannot be cloned, so the
+/// discovered fonts are kept alongside the assembled stores.
+struct FontCache {
+    /// The locations found by walking the system font directories.
+    system: Option<Arc<Vec<(PathBuf, u32, FontInfo)>>>,
+    /// The fonts shipped with typst, already parsed.
+    embedded: Option<Arc<Vec<(Font, FontInfo)>>>,
+    /// A store per combination of the two ignore flags, for compiles that
+    /// bring no font paths of their own. Sharing one keeps the fonts a
+    /// document uses loaded between compiles and hashes the book only once.
+    stores: [Option<Arc<FontStore>>; 4],
+}
+
+const EMPTY_FONT_CACHE: FontCache =
+    FontCache { system: None, embedded: None, stores: [const { None }; 4] };
+
+static FONT_CACHE: Mutex<FontCache> = Mutex::new(EMPTY_FONT_CACHE);
+
+/// Forgets everything discovered so far, so that the next compile picks up
+/// fonts installed or removed since.
+pub fn clear_font_cache() {
+    *FONT_CACHE.lock().unwrap() = EMPTY_FONT_CACHE;
+}
+
+/// Reads a cache field, filling it on a miss.
+///
+/// The lock is not held while building, so two threads missing at once both
+/// build and one result is dropped. That wastes a scan but keeps a 95 ms
+/// build off the lock.
+fn cached<T>(
+    select: impl Fn(&mut FontCache) -> &mut Option<Arc<T>>,
+    build: impl FnOnce() -> T,
+) -> Arc<T> {
+    let hit = select(&mut FONT_CACHE.lock().unwrap()).clone();
+    if let Some(value) = hit {
+        return value;
+    }
+
+    let value = Arc::new(build());
+    *select(&mut FONT_CACHE.lock().unwrap()) = Some(value.clone());
+    value
+}
+
+/// Obtains a font store for the given configuration.
+///
+/// Extra font paths are scanned on every compile. They are usually a
+/// temporary directory written by `Typst.build_world_from_s`, so their
+/// contents can change between compiles and caching on them would grow
+/// without bound.
+fn font_store(ignore_system_fonts: bool, ignore_embedded_fonts: bool, font_paths: Vec<PathBuf>) -> Arc<FontStore> {
+    if !font_paths.is_empty() {
+        return Arc::new(build_font_store(ignore_system_fonts, ignore_embedded_fonts, font_paths));
+    }
+
+    let index = usize::from(ignore_system_fonts) << 1 | usize::from(ignore_embedded_fonts);
+    cached(
+        move |cache| &mut cache.stores[index],
+        || build_font_store(ignore_system_fonts, ignore_embedded_fonts, Vec::new()),
+    )
+}
+
 fn build_font_store(ignore_system_fonts: bool, ignore_embedded_fonts: bool, font_paths: Vec<PathBuf>) -> FontStore {
     let mut fonts = FontStore::new();
     if !ignore_system_fonts {
-        fonts.extend(fonts::system());
+        let system = cached(
+            |cache| &mut cache.system,
+            || fonts::system().map(|(path, info)| (path.path, path.index, info)).collect(),
+        );
+        fonts.extend(system.iter().map(|(path, index, info)| {
+            (FontPath { path: path.clone(), index: *index }, info.clone())
+        }));
     }
     if !ignore_embedded_fonts {
-        fonts.extend(fonts::embedded());
+        let embedded = cached(|cache| &mut cache.embedded, || fonts::embedded().collect());
+        fonts.extend(embedded.iter().cloned());
     }
     for path in font_paths {
         fonts.extend(fonts::scan(&path));

data/lib/base.rb

@@ -38,12 +38,13 @@ module Typst
       options[:ignore_embedded_fonts] ||= false
       options[:pretty] ||= false
       options[:render_bleed] ||= false
+      options[:concurrent] ||= Typst.concurrent
     
       self.options = options
     end
 
     def typst_options
-      [:file, :root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :render_bleed]
+      [:file, :root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :concurrent, :render_bleed]
     end
 
     def typst_args(opts)

data/lib/query.rb

@@ -2,9 +2,9 @@ module Typst
   class Query < Base
     attr_accessor :format
 
-    def initialize(selector, input, field: nil, one: false, format: "json", root: ".", font_paths: [], ignore_system_fonts: false, ignore_embedded_fonts: false, sys_inputs: {})
+    def initialize(selector, input, field: nil, one: false, format: "json", root: ".", font_paths: [], ignore_system_fonts: false, ignore_embedded_fonts: false, concurrent: false, sys_inputs: {})
       self.format = format
-      @result = Typst::_query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, sys_inputs)
+      @result = Typst::_query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, concurrent, sys_inputs)
     end
 
     def result(raw: false)

data/lib/typst.rb

@@ -4,6 +4,7 @@ end
 
 module Typst
   @@formats = {}
+  @@concurrent = false
 
   def self.register_format(**format)
     @@formats.merge!(format)
@@ -13,10 +14,24 @@ module Typst
     @@formats
   end
 
+  def self.concurrent
+    @@concurrent
+  end
+
+  def self.concurrent=(value)
+    @@concurrent = value
+  end
+
   def self.clear_cache(max_age = 0)
     Typst::_clear_cache(max_age)
   end
 
+  # Discards the discovered system and embedded fonts, so that the next
+  # compile picks up fonts installed or removed since the first one.
+  def self.clear_font_cache
+    Typst::_clear_font_cache
+  end
+
   def self.build_world_from_s(main_source, **options, &blk)
     dependencies = options[:dependencies] ||= {}
     fonts = options[:fonts] ||= {}
@@ -30,16 +45,18 @@ module Typst
         File.binwrite(tmp_dep_file, dep_source)
       end
 
-      relative_font_path = Pathname.new(tmp_dir).join("fonts")
-      relative_font_path.mkpath
-      fonts.each do |font_name, font_bytes|
-        tmp_font_file = relative_font_path.join(font_name)
-        File.binwrite(tmp_font_file, font_bytes)
+      unless fonts.empty?
+        relative_font_path = Pathname.new(tmp_dir).join("fonts")
+        relative_font_path.mkpath
+        fonts.each do |font_name, font_bytes|
+          tmp_font_file = relative_font_path.join(font_name)
+          File.binwrite(tmp_font_file, font_bytes)
+        end
+        options[:font_paths] = (options[:font_paths] || []) + [relative_font_path]
       end
 
       options[:file] = tmp_main_file
       options[:root] = tmp_dir
-      options[:font_paths] = [relative_font_path]
 
       blk.call(options)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typst
 version: !ruby/object:Gem::Version
-  version: 0.15.1.6
+  version: 0.15.1.9.pre
 platform: ruby
 authors:
 - Flinn
@@ -18,7 +18,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.128
+        version: 0.9.130
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -28,7 +28,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.128
+        version: 0.9.130
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
@@ -88,6 +88,7 @@ files:
 - ext/typst/src/compiler.rs
 - ext/typst/src/download.rs
 - ext/typst/src/lib.rs
+- ext/typst/src/nogvl.rs
 - ext/typst/src/package.rs
 - ext/typst/src/query.rs
 - ext/typst/src/world.rs
@@ -117,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.19
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Ruby binding to typst, a new markup-based typesetting system that is powerful
   and easy to learn.