Struct SystemWorld 

pub struct SystemWorld { /* private fields */ }

A world that provides access to the operating system.

This struct is cheap to create because all expensive resources (fonts, packages, library, file cache) are globally shared.

Thread Safety

SystemWorld is Send + Sync because all mutable state is behind thread-safe locks in global statics.

Custom Inputs

By default, SystemWorld uses the global shared library (no sys.inputs). To provide custom inputs, use SystemWorld::with_inputs:

let world = SystemWorld::new(path, root)
    .with_inputs([("title", "Hello"), ("author", "Alice")]);

Implementations

impl SystemWorld

pub fn new(entry_file: &Path, root_dir: &Path) -> Self

Create a new world for compiling a specific file.

This is cheap because fonts/packages/library/file-cache are globally shared. No per-instance allocation is needed.

Arguments

• entry_file - Path to the .typ file to compile
• root_dir - Project root directory for resolving imports

Returns

A new SystemWorld ready for compilation.

pub fn with_inputs<I, K, V>(self, inputs: I) -> Self

where I: IntoIterator<Item = (K, V)>, K: Into<Str>, V: IntoValue,

Configure sys.inputs for the compilation.

This creates a custom library with the specified inputs accessible via sys.inputs in Typst documents.

Arguments

• inputs - Key-value pairs to make available as sys.inputs

Example

use typst_batch::world::SystemWorld;
use std::path::Path;

let world = SystemWorld::new(Path::new("doc.typ"), Path::new("."))
    .with_inputs([("title", "Hello"), ("author", "Alice")]);

In your Typst document:

#let title = sys.inputs.at("title", default: "Untitled")
= #title

Performance Note

Using this method creates a new library instance, bypassing the global shared library. For batch compilation without inputs, use SystemWorld::new.

pub fn with_inputs_dict(self, inputs: Dict) -> Self

Configure sys.inputs from a pre-built Dict.

This is useful when you already have a Dict of inputs.

Example

use typst::foundations::{Dict, IntoValue};

let mut inputs = Dict::new();
inputs.insert("version".into(), "1.0".into_value());

let world = SystemWorld::new(path, root).with_inputs_dict(inputs);

pub fn with_library(self, library: LazyHash<Library>) -> Self

Configure a custom library for the compilation.

Use this for full control over the library configuration. Create a custom library with crate::library::create_library_with_inputs.

pub fn root(&self) -> &Path

Get the project root directory.

pub fn source_with_virtual<V: VirtualFileSystem>( &self, id: FileId, virtual_fs: &V, ) -> FileResult<Source>

Load source with virtual file system support.

pub fn file_with_virtual<V: VirtualFileSystem>( &self, id: FileId, virtual_fs: &V, ) -> FileResult<Bytes>

Load file with virtual file system support.

Trait Implementations

impl World for SystemWorld

Implementation of Typst’s World trait.

This trait provides the compilation environment:

• Standard library access
• Font discovery
• File system access
• Package management (via file resolution)
• Current date/time

fn library(&self) -> &LazyHash<Library>

Returns the standard library.

Returns either the global shared library or a custom library with sys.inputs if configured via SystemWorld::with_inputs.

fn book(&self) -> &LazyHash<FontBook>

Returns the font book for font lookup.

The font book indexes all available fonts for name-based lookup.

fn main(&self) -> FileId

Returns the main source file ID.

This is the entry point for compilation.

fn source(&self, id: FileId) -> FileResult<Source>

Load a source file by ID.

Returns the parsed source code, using the file slot cache for incremental compilation.

Uses the global virtual data provider registered via [crate::file::set_virtual_provider].

fn file(&self, id: FileId) -> FileResult<Bytes>

Load a file’s raw bytes by ID.

Used for binary files (images, etc.) that don’t need parsing.

Uses the global virtual data provider registered via [crate::file::set_virtual_provider].

fn font(&self, index: usize) -> Option<Font>

Load a font by index.

Fonts are indexed in the order they were discovered during font search. The index comes from font book lookups.

fn today(&self, offset: Option<i64>) -> Option<Datetime>

Get the current date.

Returns the date at the time of first access within this compilation. The time is captured once and reused for consistency.

Arguments

• offset - Optional UTC offset in hours. If None, uses local timezone.