Rework `Vt` into `Engine`

- Moves as much data out of the `Vm`
- Removes duplication with call_vm and call_vt flavours
- Uses tracked chain instead of fixed int for determining max nesting depth
- This means that nesting checks now generalizes to layout and realization, to detect crashing show rules and overly nested layouts

89 files changed, 1204 insertions, 983 deletions

diff --git a/crates/typst-ide/src/analyze.rs b/crates/typst-ide/src/analyze.rs
index f3e417d5..8c5117f7 100644
--- a/crates/typst-ide/src/analyze.rs
+++ b/crates/typst-ide/src/analyze.rs
@@ -1,9 +1,10 @@
 use comemo::Track;
 use ecow::{eco_vec, EcoString, EcoVec};
-use typst::eval::{Route, Tracer, Vm};
+use typst::engine::{Engine, Route};
+use typst::eval::{Tracer, Vm};
 use typst::foundations::{Label, Scopes, Value};
 use typst::introspection::{Introspector, Locator};
-use typst::layout::{Frame, Vt};
+use typst::layout::Frame;
 use typst::model::BibliographyElem;
 use typst::syntax::{ast, LinkedNode, Span, SyntaxKind};
 use typst::World;
@@ -46,7 +47,6 @@ pub fn analyze_expr(world: &dyn World, node: &LinkedNode) -> EcoVec<Value> {
 
 /// Try to load a module from the current source file.
 pub fn analyze_import(world: &dyn World, source: &LinkedNode) -> Option<Value> {
-    let id = source.span().id()?;
     let source = analyze_expr(world, source).into_iter().next()?;
     if source.scope().is_some() {
         return Some(source);
@@ -55,15 +55,15 @@ pub fn analyze_import(world: &dyn World, source: &LinkedNode) -> Option<Value> {
     let mut locator = Locator::default();
     let introspector = Introspector::default();
     let mut tracer = Tracer::new();
-    let vt = Vt {
+    let engine = Engine {
         world: world.track(),
+        route: Route::default(),
         introspector: introspector.track(),
         locator: &mut locator,
         tracer: tracer.track_mut(),
     };
 
-    let route = Route::default();
-    let mut vm = Vm::new(vt, route.track(), Some(id), Scopes::new(Some(world.library())));
+    let mut vm = Vm::new(engine, Scopes::new(Some(world.library())), Span::detached());
     typst::eval::import(&mut vm, source, Span::detached(), true)
         .ok()
         .map(Value::Module)
diff --git a/crates/typst-macros/src/elem.rs b/crates/typst-macros/src/elem.rs
index 9791427b..ce80cc66 100644
--- a/crates/typst-macros/src/elem.rs
+++ b/crates/typst-macros/src/elem.rs
@@ -1083,7 +1083,7 @@ fn create_construct_impl(element: &Elem) -> TokenStream {
     quote! {
         impl #foundations::Construct for #ident {
             fn construct(
-                vm: &mut ::typst::eval::Vm,
+                engine: &mut ::typst::engine::Engine,
                 args: &mut #foundations::Args,
             ) -> ::typst::diag::SourceResult<#foundations::Content> {
                 #(#pre)*
@@ -1115,7 +1115,7 @@ fn create_set_impl(element: &Elem) -> TokenStream {
     quote! {
         impl #foundations::Set for #ident {
             fn set(
-                vm: &mut ::typst::eval::Vm,
+                engine: &mut ::typst::engine::Engine,
                 args: &mut #foundations::Args,
             ) -> ::typst::diag::SourceResult<#foundations::Styles> {
                 let mut styles = #foundations::Styles::new();
diff --git a/crates/typst-macros/src/func.rs b/crates/typst-macros/src/func.rs
index 8537ac4f..953df428 100644
--- a/crates/typst-macros/src/func.rs
+++ b/crates/typst-macros/src/func.rs
@@ -36,8 +36,7 @@ struct Func {
 #[derive(Default)]
 struct SpecialParams {
     self_: Option<Param>,
-    vm: bool,
-    vt: bool,
+    engine: bool,
     args: bool,
     span: bool,
 }
@@ -171,8 +170,7 @@ fn parse_param(
     };
 
     match ident.to_string().as_str() {
-        "vm" => special.vm = true,
-        "vt" => special.vt = true,
+        "engine" => special.engine = true,
         "args" => special.args = true,
         "span" => special.span = true,
         _ => {
@@ -322,13 +320,12 @@ fn create_wrapper_closure(func: &Func) -> TokenStream {
             .as_ref()
             .map(bind)
             .map(|tokens| quote! { #tokens, });
-        let vm_ = func.special.vm.then(|| quote! { vm, });
-        let vt_ = func.special.vt.then(|| quote! { &mut vm.vt, });
+        let vt_ = func.special.engine.then(|| quote! { engine, });
         let args_ = func.special.args.then(|| quote! { args, });
         let span_ = func.special.span.then(|| quote! { args.span, });
         let forwarded = func.params.iter().filter(|param| !param.external).map(bind);
         quote! {
-            __typst_func(#self_ #vm_ #vt_ #args_ #span_ #(#forwarded,)*)
+            __typst_func(#self_ #vt_ #args_ #span_ #(#forwarded,)*)
         }
     };
 
@@ -336,7 +333,7 @@ fn create_wrapper_closure(func: &Func) -> TokenStream {
     let ident = &func.ident;
     let parent = func.parent.as_ref().map(|ty| quote! { #ty:: });
     quote! {
-        |vm, args| {
+        |engine, args| {
             let __typst_func = #parent #ident;
             #handlers
             #finish
diff --git a/crates/typst-syntax/src/span.rs b/crates/typst-syntax/src/span.rs
index 14e5e216..8138a316 100644
--- a/crates/typst-syntax/src/span.rs
+++ b/crates/typst-syntax/src/span.rs
@@ -2,6 +2,8 @@ use std::fmt::{self, Debug, Formatter};
 use std::num::NonZeroU64;
 use std::ops::Range;
 
+use ecow::EcoString;
+
 use crate::FileId;
 
 /// A unique identifier for a syntax node.
@@ -80,6 +82,14 @@ impl Span {
     pub const fn number(self) -> u64 {
         self.0.get() & ((1 << Self::BITS) - 1)
     }
+
+    /// Resolve a file location relative to this span's source.
+    pub fn resolve_path(self, path: &str) -> Result<FileId, EcoString> {
+        let Some(file) = self.id() else {
+            return Err("cannot access file system from here".into());
+        };
+        Ok(file.join(path))
+    }
 }
 
 /// A value with a span locating it in the source code.
diff --git a/crates/typst/src/engine.rs b/crates/typst/src/engine.rs
new file mode 100644
index 00000000..189034cf
--- /dev/null
+++ b/crates/typst/src/engine.rs
@@ -0,0 +1,159 @@
+use std::cell::Cell;
+
+use comemo::{Track, Tracked, TrackedMut, Validate};
+
+use crate::diag::SourceResult;
+use crate::eval::Tracer;
+use crate::introspection::{Introspector, Locator};
+use crate::syntax::FileId;
+use crate::World;
+
+/// The maxmium stack nesting depth.
+const MAX_DEPTH: usize = 64;
+
+/// Holds all data needed during compilation.
+pub struct Engine<'a> {
+    /// The compilation environment.
+    pub world: Tracked<'a, dyn World + 'a>,
+    /// Provides access to information about the document.
+    pub introspector: Tracked<'a, Introspector>,
+    /// The route the engine took during compilation. This is used to detect
+    /// cyclic imports and too much nesting.
+    pub route: Route<'a>,
+    /// Provides stable identities to elements.
+    pub locator: &'a mut Locator<'a>,
+    /// The tracer for inspection of the values an expression produces.
+    pub tracer: TrackedMut<'a, Tracer>,
+}
+
+impl Engine<'_> {
+    /// Perform a fallible operation that does not immediately terminate further
+    /// execution. Instead it produces a delayed error that is only promoted to
+    /// a fatal one if it remains at the end of the introspection loop.
+    pub fn delayed<F, T>(&mut self, f: F) -> T
+    where
+        F: FnOnce(&mut Self) -> SourceResult<T>,
+        T: Default,
+    {
+        match f(self) {
+            Ok(value) => value,
+            Err(errors) => {
+                self.tracer.delay(errors);
+                T::default()
+            }
+        }
+    }
+}
+
+/// The route the engine took during compilation. This is used to detect
+/// cyclic imports and too much nesting.
+#[derive(Clone)]
+pub struct Route<'a> {
+    // We need to override the constraint's lifetime here so that `Tracked` is
+    // covariant over the constraint. If it becomes invariant, we're in for a
+    // world of lifetime pain.
+    outer: Option<Tracked<'a, Self, <Route<'static> as Validate>::Constraint>>,
+    /// This is set if this route segment was inserted through the start of a
+    /// module evaluation.
+    id: Option<FileId>,
+    /// This is set whenever we enter a function, nested layout, or are applying
+    /// a show rule. The length of this segment plus the lengths of all `outer`
+    /// route segments make up the length of the route. If the length of the
+    /// route exceeds `MAX_DEPTH`, then we throw a "maximum ... depth exceeded"
+    /// error.
+    len: usize,
+    /// The upper bound we've established for the parent chain length. We don't
+    /// know the exact length (that would defeat the whole purpose because it
+    /// would prevent cache reuse of some computation at different,
+    /// non-exceeding depths).
+    upper: Cell<usize>,
+}
+
+impl<'a> Route<'a> {
+    /// Create a new, empty route.
+    pub fn root() -> Self {
+        Self { id: None, outer: None, len: 0, upper: Cell::new(0) }
+    }
+
+    /// Insert a new id into the route.
+    ///
+    /// You must guarantee that `outer` lives longer than the resulting
+    /// route is ever used.
+    pub fn insert(outer: Tracked<'a, Self>, id: FileId) -> Self {
+        Route {
+            outer: Some(outer),
+            id: Some(id),
+            len: 0,
+            upper: Cell::new(usize::MAX),
+        }
+    }
+
+    /// Extend the route without another id.
+    pub fn extend(outer: Tracked<'a, Self>) -> Self {
+        Route {
+            outer: Some(outer),
+            id: None,
+            len: 1,
+            upper: Cell::new(usize::MAX),
+        }
+    }
+
+    /// Start tracking this route.
+    ///
+    /// In comparison to [`Track::track`], this method skips this chain link
+    /// if it does not contribute anything.
+    pub fn track(&self) -> Tracked<'_, Self> {
+        match self.outer {
+            Some(outer) if self.id.is_none() && self.len == 0 => outer,
+            _ => Track::track(self),
+        }
+    }
+
+    /// Increase the nesting depth for this route segment.
+    pub fn increase(&mut self) {
+        self.len += 1;
+    }
+
+    /// Decrease the nesting depth for this route segment.
+    pub fn decrease(&mut self) {
+        self.len -= 1;
+    }
+
+    /// Check whether the nesting depth exceeds the limit.
+    pub fn exceeding(&self) -> bool {
+        !self.within(MAX_DEPTH)
+    }
+}
+
+#[comemo::track]
+impl<'a> Route<'a> {
+    /// Whether the given id is part of the route.
+    pub fn contains(&self, id: FileId) -> bool {
+        self.id == Some(id) || self.outer.map_or(false, |outer| outer.contains(id))
+    }
+
+    /// Whether the route's depth is less than or equal to the given depth.
+    pub fn within(&self, depth: usize) -> bool {
+        if self.upper.get().saturating_add(self.len) <= depth {
+            return true;
+        }
+
+        match self.outer {
+            Some(_) if depth < self.len => false,
+            Some(outer) => {
+                let within = outer.within(depth - self.len);
+                if within && depth < self.upper.get() {
+                    self.upper.set(depth);
+                }
+                within
+            }
+            None => true,
+        }
+    }
+}
+
+impl Default for Route<'_> {
+    fn default() -> Self {
+        Self::root()
+    }
+}
diff --git a/crates/typst/src/eval/access.rs b/crates/typst/src/eval/access.rs
index ff0b7512..99b2f72e 100644
--- a/crates/typst/src/eval/access.rs
+++ b/crates/typst/src/eval/access.rs
@@ -31,7 +31,7 @@ impl Access for ast::Ident<'_> {
         let span = self.span();
         let value = vm.scopes.get_mut(&self).at(span)?;
         if vm.inspected == Some(span) {
-            vm.vt.tracer.value(value.clone());
+            vm.engine.tracer.value(value.clone());
         }
         Ok(value)
     }
diff --git a/crates/typst/src/eval/call.rs b/crates/typst/src/eval/call.rs
index 7ccebe85..a57cb112 100644
--- a/crates/typst/src/eval/call.rs
+++ b/crates/typst/src/eval/call.rs
@@ -2,13 +2,13 @@ use comemo::{Prehashed, Tracked, TrackedMut};
 use ecow::EcoVec;
 
 use crate::diag::{bail, error, At, HintedStrResult, SourceResult, Trace, Tracepoint};
+use crate::engine::Engine;
 use crate::eval::{Access, Eval, FlowEvent, Route, Tracer, Vm};
 use crate::foundations::{
     call_method_mut, is_mutating_method, Arg, Args, Bytes, Closure, Content, Func,
     IntoValue, NativeElement, Scope, Scopes, Value,
 };
 use crate::introspection::{Introspector, Locator};
-use crate::layout::Vt;
 use crate::math::{Accent, AccentElem, LrElem};
 use crate::symbols::Symbol;
 use crate::syntax::ast::{self, AstNode};
@@ -16,23 +16,19 @@ use crate::syntax::{Spanned, SyntaxNode};
 use crate::text::TextElem;
 use crate::World;
 
-/// The maxmium function call depth.
-const MAX_CALL_DEPTH: usize = 64;
-
 impl Eval for ast::FuncCall<'_> {
     type Output = Value;
 
     #[tracing::instrument(name = "FuncCall::eval", skip_all)]
     fn eval(self, vm: &mut Vm) -> SourceResult<Self::Output> {
         let span = self.span();
-        if vm.depth >= MAX_CALL_DEPTH {
-            bail!(span, "maximum function call depth exceeded");
-        }
-
         let callee = self.callee();
         let in_math = in_math(callee);
         let callee_span = callee.span();
         let args = self.args();
+        if vm.engine.route.exceeding() {
+            bail!(span, "maximum function call depth exceeded");
+        }
 
         // Try to evaluate as a call to an associated function or field.
         let (callee, mut args) = if let ast::Expr::FieldAccess(access) = callee {
@@ -146,7 +142,7 @@ impl Eval for ast::FuncCall<'_> {
 
         let callee = callee.cast::<Func>().at(callee_span)?;
         let point = || Tracepoint::Call(callee.name().map(Into::into));
-        let f = || callee.call_vm(vm, args).trace(vm.world(), point, span);
+        let f = || callee.call(&mut vm.engine, args).trace(vm.world(), point, span);
 
         // Stacker is broken on WASM.
         #[cfg(target_arch = "wasm32")]
@@ -229,7 +225,6 @@ impl Eval for ast::Closure<'_> {
         // Define the closure.
         let closure = Closure {
             node: self.to_untyped().clone(),
-            file: vm.file,
             defaults,
             captured,
         };
@@ -246,11 +241,10 @@ pub(crate) fn call_closure(
     func: &Func,
     closure: &Prehashed<Closure>,
     world: Tracked<dyn World + '_>,
-    route: Tracked<Route>,
     introspector: Tracked<Introspector>,
+    route: Tracked<Route>,
     locator: Tracked<Locator>,
     tracer: TrackedMut<Tracer>,
-    depth: usize,
     mut args: Args,
 ) -> SourceResult<Value> {
     let node = closure.node.cast::<ast::Closure>().unwrap();
@@ -260,13 +254,18 @@ pub(crate) fn call_closure(
     let mut scopes = Scopes::new(None);
     scopes.top = closure.captured.clone();
 
-    // Prepare VT.
+    // Prepare the engine.
     let mut locator = Locator::chained(locator);
-    let vt = Vt { world, introspector, locator: &mut locator, tracer };
+    let engine = Engine {
+        world,
+        introspector,
+        route: Route::extend(route),
+        locator: &mut locator,
+        tracer,
+    };
 
     // Prepare VM.
-    let mut vm = Vm::new(vt, route, closure.file, scopes);
-    vm.depth = depth;
+    let mut vm = Vm::new(engine, scopes, node.span());
 
     // Provide the closure itself for recursive calls.
     if let Some(name) = node.name() {
@@ -279,6 +278,7 @@ pub(crate) fn call_closure(
         .children()
         .filter(|p| matches!(p, ast::Param::Pos(_)))
         .count();
+
     let num_pos_args = args.to_pos().len();
     let sink_size = num_pos_args.checked_sub(num_pos_params);
 
diff --git a/crates/typst/src/eval/code.rs b/crates/typst/src/eval/code.rs
index 1df5876c..06b2f226 100644
--- a/crates/typst/src/eval/code.rs
+++ b/crates/typst/src/eval/code.rs
@@ -40,7 +40,7 @@ fn eval_code<'a>(
                 }
 
                 let tail = eval_code(vm, exprs)?.display();
-                Value::Content(tail.styled_with_recipe(vm, recipe)?)
+                Value::Content(tail.styled_with_recipe(&mut vm.engine, recipe)?)
             }
             _ => expr.eval(vm)?,
         };
@@ -130,7 +130,7 @@ impl Eval for ast::Expr<'_> {
         .spanned(span);
 
         if vm.inspected == Some(span) {
-            vm.vt.tracer.value(v.clone());
+            vm.engine.tracer.value(v.clone());
         }
 
         Ok(v)
diff --git a/crates/typst/src/eval/import.rs b/crates/typst/src/eval/import.rs
index 79daf999..aa3388a1 100644
--- a/crates/typst/src/eval/import.rs
+++ b/crates/typst/src/eval/import.rs
@@ -38,7 +38,7 @@ impl Eval for ast::ModuleImport<'_> {
             if let ast::Expr::Ident(ident) = self.source() {
                 if ident.as_str() == new_name.as_str() {
                     // Warn on `import x as x`
-                    vm.vt.tracer.warn(warning!(
+                    vm.engine.tracer.warn(warning!(
                         new_name.span(),
                         "unnecessary import rename to same name",
                     ));
@@ -73,7 +73,7 @@ impl Eval for ast::ModuleImport<'_> {
                             if renamed_item.original_name().as_str()
                                 == renamed_item.new_name().as_str()
                             {
-                                vm.vt.tracer.warn(warning!(
+                                vm.engine.tracer.warn(warning!(
                                     renamed_item.new_name().span(),
                                     "unnecessary import rename to same name",
                                 ));
@@ -145,27 +145,37 @@ fn import_package(vm: &mut Vm, spec: PackageSpec, span: Span) -> SourceResult<Mo
     let entrypoint_id = manifest_id.join(&manifest.package.entrypoint);
     let source = vm.world().source(entrypoint_id).at(span)?;
     let point = || Tracepoint::Import;
-    Ok(eval(vm.world(), vm.route, TrackedMut::reborrow_mut(&mut vm.vt.tracer), &source)
-        .trace(vm.world(), point, span)?
-        .with_name(manifest.package.name))
+    Ok(eval(
+        vm.world(),
+        vm.engine.route.track(),
+        TrackedMut::reborrow_mut(&mut vm.engine.tracer),
+        &source,
+    )
+    .trace(vm.world(), point, span)?
+    .with_name(manifest.package.name))
 }
 
 /// Import a file from a path.
 fn import_file(vm: &mut Vm, path: &str, span: Span) -> SourceResult<Module> {
     // Load the source file.
     let world = vm.world();
-    let id = vm.resolve_path(path).at(span)?;
+    let id = span.resolve_path(path).at(span)?;
     let source = world.source(id).at(span)?;
 
     // Prevent cyclic importing.
-    if vm.route.contains(source.id()) {
+    if vm.engine.route.contains(source.id()) {
         bail!(span, "cyclic import");
     }
 
     // Evaluate the file.
     let point = || Tracepoint::Import;
-    eval(world, vm.route, TrackedMut::reborrow_mut(&mut vm.vt.tracer), &source)
-        .trace(world, point, span)
+    eval(
+        world,
+        vm.engine.route.track(),
+        TrackedMut::reborrow_mut(&mut vm.engine.tracer),
+        &source,
+    )
+    .trace(world, point, span)
 }
 
 /// A parsed package manifest.
diff --git a/crates/typst/src/eval/markup.rs b/crates/typst/src/eval/markup.rs
index 16ea9eef..a40b978e 100644
--- a/crates/typst/src/eval/markup.rs
+++ b/crates/typst/src/eval/markup.rs
@@ -43,7 +43,7 @@ fn eval_markup<'a>(
                 }
 
                 let tail = eval_markup(vm, exprs)?;
-                seq.push(tail.styled_with_recipe(vm, recipe)?)
+                seq.push(tail.styled_with_recipe(&mut vm.engine, recipe)?)
             }
             expr => match expr.eval(vm)? {
                 Value::Label(label) => {
@@ -139,11 +139,11 @@ impl Eval for ast::Strong<'_> {
     fn eval(self, vm: &mut Vm) -> SourceResult<Self::Output> {
         let body = self.body();
         if body.exprs().next().is_none() {
-            vm.vt
-                .tracer
-                .warn(warning!(self.span(), "no text within stars").with_hint(
+            vm.engine.tracer.warn(
+                warning!(self.span(), "no text within stars").with_hint(
                     "using multiple consecutive stars (e.g. **) has no additional effect",
-                ));
+                ),
+            );
         }
 
         Ok(StrongElem::new(body.eval(vm)?).pack())
@@ -157,7 +157,7 @@ impl Eval for ast::Emph<'_> {
     fn eval(self, vm: &mut Vm) -> SourceResult<Self::Output> {
         let body = self.body();
         if body.exprs().next().is_none() {
-            vm.vt
+            vm.engine
                 .tracer
                 .warn(warning!(self.span(), "no text within underscores").with_hint(
                     "using multiple consecutive underscores (e.g. __) has no additional effect"
diff --git a/crates/typst/src/eval/mod.rs b/crates/typst/src/eval/mod.rs
index eaba69e0..9de4f1b7 100644
--- a/crates/typst/src/eval/mod.rs
+++ b/crates/typst/src/eval/mod.rs
@@ -26,9 +26,9 @@ pub(crate) use self::flow::*;
 use comemo::{Track, Tracked, TrackedMut};
 
 use crate::diag::{bail, SourceResult};
+use crate::engine::{Engine, Route};
 use crate::foundations::{Cast, Module, NativeElement, Scope, Scopes, Value};
 use crate::introspection::{Introspector, Locator};
-use crate::layout::Vt;
 use crate::math::EquationElem;
 use crate::syntax::{ast, parse, parse_code, parse_math, Source, Span};
 use crate::World;
@@ -48,22 +48,23 @@ pub fn eval(
         panic!("Tried to cyclicly evaluate {:?}", id.vpath());
     }
 
-    // Prepare VT.
+    // Prepare the engine.
     let mut locator = Locator::new();
     let introspector = Introspector::default();
-    let vt = Vt {
+    let engine = Engine {
         world,
+        route: Route::insert(route, id),
         introspector: introspector.track(),
         locator: &mut locator,
         tracer,
     };
 
     // Prepare VM.
-    let route = Route::insert(route, id);
+    let root = source.root();
     let scopes = Scopes::new(Some(world.library()));
-    let mut vm = Vm::new(vt, route.track(), Some(id), scopes);
+    let mut vm = Vm::new(engine, scopes, root.span());
 
-    let root = source.root();
+    // Check for well-formedness unless we are in trace mode.
     let errors = root.errors();
     if !errors.is_empty() && vm.inspected.is_none() {
         return Err(errors.into_iter().map(Into::into).collect());
@@ -108,26 +109,27 @@ pub fn eval_string(
 
     root.synthesize(span);
 
+    // Check for well-formedness.
     let errors = root.errors();
     if !errors.is_empty() {
         return Err(errors.into_iter().map(Into::into).collect());
     }
 
-    // Prepare VT.
+    // Prepare the engine.
     let mut tracer = Tracer::new();
     let mut locator = Locator::new();
     let introspector = Introspector::default();
-    let vt = Vt {
+    let engine = Engine {
         world,
         introspector: introspector.track(),
+        route: Route::default(),
         locator: &mut locator,
         tracer: tracer.track_mut(),
     };
 
     // Prepare VM.
-    let route = Route::default();
     let scopes = Scopes::new(Some(world.library()));
-    let mut vm = Vm::new(vt, route.track(), None, scopes);
+    let mut vm = Vm::new(engine, scopes, root.span());
     vm.scopes.scopes.push(scope);
 
     // Evaluate the code.
diff --git a/crates/typst/src/eval/rules.rs b/crates/typst/src/eval/rules.rs
index c85b747b..e34fe5cd 100644
--- a/crates/typst/src/eval/rules.rs
+++ b/crates/typst/src/eval/rules.rs
@@ -24,7 +24,7 @@ impl Eval for ast::SetRule<'_> {
             })
             .at(target.span())?;
         let args = self.args().eval(vm)?;
-        Ok(target.set(vm, args)?.spanned(self.span()))
+        Ok(target.set(&mut vm.engine, args)?.spanned(self.span()))
     }
 }
 
diff --git a/crates/typst/src/eval/vm.rs b/crates/typst/src/eval/vm.rs
index c34c1070..8cedb906 100644
--- a/crates/typst/src/eval/vm.rs
+++ b/crates/typst/src/eval/vm.rs
@@ -1,74 +1,37 @@
-use comemo::{Track, Tracked, Validate};
+use comemo::Tracked;
 
-use crate::diag::{bail, StrResult};
+use crate::engine::Engine;
 use crate::eval::FlowEvent;
 use crate::foundations::{IntoValue, Scopes};
-use crate::layout::Vt;
 use crate::syntax::ast::{self, AstNode};
-use crate::syntax::{FileId, Span};
+use crate::syntax::Span;
 use crate::World;
 
 /// A virtual machine.
 ///
-/// Holds the state needed to [evaluate](crate::eval::eval()) Typst sources. A new
-/// virtual machine is created for each module evaluation and function call.
+/// Holds the state needed to [evaluate](crate::eval::eval()) Typst sources. A
+/// new virtual machine is created for each module evaluation and function call.
 pub struct Vm<'a> {
     /// The underlying virtual typesetter.
-    pub(crate) vt: Vt<'a>,
-    /// The route of source ids the VM took to reach its current location.
-    pub(crate) route: Tracked<'a, Route<'a>>,
-    /// The id of the currently evaluated file.
-    pub(crate) file: Option<FileId>,
+    pub(crate) engine: Engine<'a>,
     /// A control flow event that is currently happening.
     pub(crate) flow: Option<FlowEvent>,
     /// The stack of scopes.
     pub(crate) scopes: Scopes<'a>,
-    /// The current call depth.
-    pub(crate) depth: usize,
     /// A span that is currently under inspection.
     pub(crate) inspected: Option<Span>,
 }
 
 impl<'a> Vm<'a> {
     /// Create a new virtual machine.
-    pub fn new(
-        vt: Vt<'a>,
-        route: Tracked<'a, Route>,
-        file: Option<FileId>,
-        scopes: Scopes<'a>,
-    ) -> Self {
-        let inspected = file.and_then(|id| vt.tracer.inspected(id));
-        Self {
-            vt,
-            route,
-            file,
-            flow: None,
-            scopes,
-            depth: 0,
-            inspected,
-        }
+    pub fn new(engine: Engine<'a>, scopes: Scopes<'a>, target: Span) -> Self {
+        let inspected = target.id().and_then(|id| engine.tracer.inspected(id));
+        Self { engine, flow: None, scopes, inspected }
     }
 
     /// Access the underlying world.
     pub fn world(&self) -> Tracked<'a, dyn World + 'a> {
-        self.vt.world
-    }
-
-    /// The id of the currently evaluated file.
-    ///
-    /// Returns `None` if the VM is in a detached context, e.g. when evaluating
-    /// a user-provided string.
-    pub fn file(&self) -> Option<FileId> {
-        self.file
-    }
-
-    /// Resolve a path relative to the currently evaluated file.
-    pub fn resolve_path(&self, path: &str) -> StrResult<FileId> {
-        let Some(file) = self.file else {
-            bail!("cannot access file system from here");
-        };
-
-        Ok(file.join(path))
+        self.engine.world
     }
 
     /// Define a variable in the current scope.
@@ -76,52 +39,8 @@ impl<'a> Vm<'a> {
     pub fn define(&mut self, var: ast::Ident, value: impl IntoValue) {
         let value = value.into_value();
         if self.inspected == Some(var.span()) {
-            self.vt.tracer.value(value.clone());
+            self.engine.tracer.value(value.clone());
         }
         self.scopes.top.define(var.get().clone(), value);
     }
 }
-
-/// A route of source ids.
-#[derive(Default)]
-pub struct Route<'a> {
-    // We need to override the constraint's lifetime here so that `Tracked` is
-    // covariant over the constraint. If it becomes invariant, we're in for a
-    // world of lifetime pain.
-    outer: Option<Tracked<'a, Self, <Route<'static> as Validate>::Constraint>>,
-    id: Option<FileId>,
-}
-
-impl<'a> Route<'a> {
-    /// Create a new route with just one entry.
-    pub fn new(id: Option<FileId>) -> Self {
-        Self { id, outer: None }
-    }
-
-    /// Insert a new id into the route.
-    ///
-    /// You must guarantee that `outer` lives longer than the resulting
-    /// route is ever used.
-    pub fn insert(outer: Tracked<'a, Self>, id: FileId) -> Self {
-        Route { outer: Some(outer), id: Some(id) }
-    }
-
-    /// Start tracking this locator.
-    ///
-    /// In comparison to [`Track::track`], this method skips this chain link
-    /// if it does not contribute anything.
-    pub fn track(&self) -> Tracked<'_, Self> {
-        match self.outer {
-            Some(outer) if self.id.is_none() => outer,
-            _ => Track::track(self),
-        }
-    }
-}
-
-#[comemo::track]
-impl<'a> Route<'a> {
-    /// Whether the given id is part of the route.
-    pub fn contains(&self, id: FileId) -> bool {
-        self.id == Some(id) || self.outer.map_or(false, |outer| outer.contains(id))
-    }
-}
diff --git a/crates/typst/src/foundations/args.rs b/crates/typst/src/foundations/args.rs
index af5d07b1..e11fe2bb 100644
--- a/crates/typst/src/foundations/args.rs
+++ b/crates/typst/src/foundations/args.rs
@@ -320,3 +320,26 @@ impl PartialEq for Arg {
         self.name == other.name && self.value.v == other.value.v
     }
 }
+
+/// Things that can be used as arguments.
+pub trait IntoArgs {
+    /// Convert into arguments, attaching the `fallback` span in case `Self`
+    /// doesn't have a span.
+    fn into_args(self, fallback: Span) -> Args;
+}
+
+impl IntoArgs for Args {
+    fn into_args(self, _: Span) -> Args {
+        self
+    }
+}
+
+impl<I, T> IntoArgs for I
+where
+    I: IntoIterator<Item = T>,
+    T: IntoValue,
+{
+    fn into_args(self, fallback: Span) -> Args {
+        Args::new(fallback, self)
+    }
+}
diff --git a/crates/typst/src/foundations/array.rs b/crates/typst/src/foundations/array.rs
index 47afa9e2..8f2e9149 100644
--- a/crates/typst/src/foundations/array.rs
+++ b/crates/typst/src/foundations/array.rs
@@ -8,7 +8,8 @@ use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 
 use crate::diag::{At, SourceResult, StrResult};
-use crate::eval::{ops, Vm};
+use crate::engine::Engine;
+use crate::eval::ops;
 use crate::foundations::{
     cast, func, repr, scope, ty, Args, Bytes, CastInfo, FromValue, Func, IntoValue,
     Reflect, Repr, Value, Version,
@@ -297,14 +298,17 @@ impl Array {
     #[func]
     pub fn find(
         &self,
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// The function to apply to each item. Must return a boolean.
         searcher: Func,
     ) -> SourceResult<Option<Value>> {
         for item in self.iter() {
-            let args = Args::new(searcher.span(), [item.clone()]);
-            if searcher.call_vm(vm, args)?.cast::<bool>().at(searcher.span())? {
+            if searcher
+                .call(engine, [item.clone()])?
+                .cast::<bool>()
+                .at(searcher.span())?
+            {
                 return Ok(Some(item.clone()));
             }
         }
@@ -316,14 +320,17 @@ impl Array {
     #[func]
     pub fn position(
         &self,
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// The function to apply to each item. Must return a boolean.
         searcher: Func,
     ) -> SourceResult<Option<i64>> {
         for (i, item) in self.iter().enumerate() {
-            let args = Args::new(searcher.span(), [item.clone()]);
-            if searcher.call_vm(vm, args)?.cast::<bool>().at(searcher.span())? {
+            if searcher
+                .call(engine, [item.clone()])?
+                .cast::<bool>()
+                .at(searcher.span())?
+            {
                 return Ok(Some(i as i64));
             }
         }
@@ -388,15 +395,14 @@ impl Array {
     #[func]
     pub fn filter(
         &self,
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// The function to apply to each item. Must return a boolean.
         test: Func,
     ) -> SourceResult<Array> {
         let mut kept = EcoVec::new();
         for item in self.iter() {
-            let args = Args::new(test.span(), [item.clone()]);
-            if test.call_vm(vm, args)?.cast::<bool>().at(test.span())? {
+            if test.call(engine, [item.clone()])?.cast::<bool>().at(test.span())? {
                 kept.push(item.clone())
             }
         }
@@ -408,17 +414,12 @@ impl Array {
     #[func]
     pub fn map(
         self,
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// The function to apply to each item.
         mapper: Func,
     ) -> SourceResult<Array> {
-        self.into_iter()
-            .map(|item| {
-                let args = Args::new(mapper.span(), [item]);
-                mapper.call_vm(vm, args)
-            })
-            .collect()
+        self.into_iter().map(|item| mapper.call(engine, [item])).collect()
     }
 
     /// Returns a new array with the values alongside their indices.
@@ -518,8 +519,8 @@ impl Array {
     #[func]
     pub fn fold(
         self,
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// The initial value to start with.
         init: Value,
         /// The folding function. Must have two parameters: One for the
@@ -528,8 +529,7 @@ impl Array {
     ) -> SourceResult<Value> {
         let mut acc = init;
         for item in self {
-            let args = Args::new(folder.span(), [acc, item]);
-            acc = folder.call_vm(vm, args)?;
+            acc = folder.call(engine, [acc, item])?;
         }
         Ok(acc)
     }
@@ -579,14 +579,13 @@ impl Array {
     #[func]
     pub fn any(
         self,
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// The function to apply to each item. Must return a boolean.
         test: Func,
     ) -> SourceResult<bool> {
         for item in self {
-            let args = Args::new(test.span(), [item]);
-            if test.call_vm(vm, args)?.cast::<bool>().at(test.span())? {
+            if test.call(engine, [item])?.cast::<bool>().at(test.span())? {
                 return Ok(true);
             }
         }
@@ -598,14 +597,13 @@ impl Array {
     #[func]
     pub fn all(
         self,
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// The function to apply to each item. Must return a boolean.
         test: Func,
     ) -> SourceResult<bool> {
         for item in self {
-            let args = Args::new(test.span(), [item]);
-            if !test.call_vm(vm, args)?.cast::<bool>().at(test.span())? {
+            if !test.call(engine, [item])?.cast::<bool>().at(test.span())? {
                 return Ok(false);
             }
         }
@@ -714,8 +712,8 @@ impl Array {
     #[func]
     pub fn sorted(
         self,
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// The callsite span.
         span: Span,
         /// If given, applies this function to the elements in the array to
@@ -728,7 +726,7 @@ impl Array {
         let mut key_of = |x: Value| match &key {
             // NOTE: We are relying on `comemo`'s memoization of function
             // evaluation to not excessively reevaluate the `key`.
-            Some(f) => f.call_vm(vm, Args::new(f.span(), [x])),
+            Some(f) => f.call(engine, [x]),
             None => Ok(x),
         };
         vec.make_mut().sort_by(|a, b| {
@@ -762,8 +760,8 @@ impl Array {
     #[func(title = "Deduplicate")]
     pub fn dedup(
         self,
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// If given, applies this function to the elements in the array to
         /// determine the keys to deduplicate by.
         #[named]
@@ -773,7 +771,7 @@ impl Array {
         let mut key_of = |x: Value| match &key {
             // NOTE: We are relying on `comemo`'s memoization of function
             // evaluation to not excessively reevaluate the `key`.
-            Some(f) => f.call_vm(vm, Args::new(f.span(), [x])),
+            Some(f) => f.call(engine, [x]),
             None => Ok(x),
         };
 
diff --git a/crates/typst/src/foundations/cast.rs b/crates/typst/src/foundations/cast.rs
index fbd5ab14..e3b7dd01 100644
--- a/crates/typst/src/foundations/cast.rs
+++ b/crates/typst/src/foundations/cast.rs
@@ -12,6 +12,7 @@ use crate::diag::{At, SourceResult, StrResult};
 use crate::foundations::{repr, Repr, Type, Value};
 use crate::syntax::{Span, Spanned};
 
+#[rustfmt::skip]
 #[doc(inline)]
 pub use typst_macros::{cast, Cast};
 
diff --git a/crates/typst/src/foundations/content.rs b/crates/typst/src/foundations/content.rs
index 7a402629..111b33ea 100644
--- a/crates/typst/src/foundations/content.rs
+++ b/crates/typst/src/foundations/content.rs
@@ -10,7 +10,7 @@ use serde::{Serialize, Serializer};
 use smallvec::smallvec;
 
 use crate::diag::{SourceResult, StrResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{
     elem, func, scope, ty, Dict, Element, FromValue, Guard, IntoValue, Label,
     NativeElement, Recipe, Repr, Selector, Str, Style, Styles, Value,
@@ -299,16 +299,19 @@ impl Content {
     /// Access the child and styles.
     pub fn to_styled(&self) -> Option<(&Content, &Styles)> {
         let styled = self.to::<StyledElem>()?;
-
         let child = styled.child();
         let styles = styled.styles();
         Some((child, styles))
     }
 
     /// Style this content with a recipe, eagerly applying it if possible.
-    pub fn styled_with_recipe(self, vm: &mut Vm, recipe: Recipe) -> SourceResult<Self> {
+    pub fn styled_with_recipe(
+        self,
+        engine: &mut Engine,
+        recipe: Recipe,
+    ) -> SourceResult<Self> {
         if recipe.selector.is_none() {
-            recipe.apply_vm(vm, self)
+            recipe.apply(engine, self)
         } else {
             Ok(self.styled(recipe))
         }
diff --git a/crates/typst/src/foundations/datetime.rs b/crates/typst/src/foundations/datetime.rs
index f50daf72..78290c99 100644
--- a/crates/typst/src/foundations/datetime.rs
+++ b/crates/typst/src/foundations/datetime.rs
@@ -8,7 +8,7 @@ use time::macros::format_description;
 use time::{format_description, Month, PrimitiveDateTime};
 
 use crate::diag::{bail, StrResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{
     cast, func, repr, scope, ty, Dict, Duration, Repr, Smart, Str, Value,
 };
@@ -296,16 +296,15 @@ impl Datetime {
     /// ```
     #[func]
     pub fn today(
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// An offset to apply to the current UTC date. If set to `{auto}`, the
         /// offset will be the local offset.
         #[named]
         #[default]
         offset: Smart<i64>,
     ) -> StrResult<Datetime> {
-        Ok(vm
-            .vt
+        Ok(engine
             .world
             .today(offset.as_custom())
             .ok_or("unable to get the current date")?)
diff --git a/crates/typst/src/foundations/element.rs b/crates/typst/src/foundations/element.rs
index 64b47b78..8e4d159a 100644
--- a/crates/typst/src/foundations/element.rs
+++ b/crates/typst/src/foundations/element.rs
@@ -10,13 +10,12 @@ use once_cell::sync::Lazy;
 use smallvec::SmallVec;
 
 use crate::diag::{SourceResult, StrResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{
     cast, Args, Content, Dict, Func, Label, ParamInfo, Repr, Scope, Selector, StyleChain,
     Styles, Value,
 };
 use crate::introspection::Location;
-use crate::layout::Vt;
 use crate::syntax::Span;
 use crate::text::{Lang, Region};
 use crate::util::Static;
@@ -66,13 +65,17 @@ impl Element {
     }
 
     /// Construct an instance of this element.
-    pub fn construct(self, vm: &mut Vm, args: &mut Args) -> SourceResult<Content> {
-        (self.0.construct)(vm, args)
+    pub fn construct(
+        self,
+        engine: &mut Engine,
+        args: &mut Args,
+    ) -> SourceResult<Content> {
+        (self.0.construct)(engine, args)
     }
 
     /// Execute the set rule for the element and return the resulting style map.
-    pub fn set(self, vm: &mut Vm, mut args: Args) -> SourceResult<Styles> {
-        let styles = (self.0.set)(vm, &mut args)?;
+    pub fn set(self, engine: &mut Engine, mut args: Args) -> SourceResult<Styles> {
+        let styles = (self.0.set)(engine, &mut args)?;
         args.finish()?;
         Ok(styles)
     }
@@ -275,7 +278,7 @@ pub trait Construct {
     ///
     /// This is passed only the arguments that remain after execution of the
     /// element's set rule.
-    fn construct(vm: &mut Vm, args: &mut Args) -> SourceResult<Content>
+    fn construct(engine: &mut Engine, args: &mut Args) -> SourceResult<Content>
     where
         Self: Sized;
 }
@@ -283,7 +286,7 @@ pub trait Construct {
 /// An element's set rule.
 pub trait Set {
     /// Parse relevant arguments into style properties for this element.
-    fn set(vm: &mut Vm, args: &mut Args) -> SourceResult<Styles>
+    fn set(engine: &mut Engine, args: &mut Args) -> SourceResult<Styles>
     where
         Self: Sized;
 }
@@ -295,8 +298,8 @@ pub struct NativeElementData {
     pub title: &'static str,
     pub docs: &'static str,
     pub keywords: &'static [&'static str],
-    pub construct: fn(&mut Vm, &mut Args) -> SourceResult<Content>,
-    pub set: fn(&mut Vm, &mut Args) -> SourceResult<Styles>,
+    pub construct: fn(&mut Engine, &mut Args) -> SourceResult<Content>,
+    pub set: fn(&mut Engine, &mut Args) -> SourceResult<Styles>,
     pub vtable: fn(of: TypeId) -> Option<*const ()>,
     pub field_id: fn(name: &str) -> Option<u8>,
     pub field_name: fn(u8) -> Option<&'static str>,
@@ -320,13 +323,14 @@ cast! {
 /// rule.
 pub trait Synthesize {
     /// Prepare the element for show rule application.
-    fn synthesize(&mut self, vt: &mut Vt, styles: StyleChain) -> SourceResult<()>;
+    fn synthesize(&mut self, engine: &mut Engine, styles: StyleChain)
+        -> SourceResult<()>;
 }
 
 /// The base recipe for an element.
 pub trait Show {
     /// Execute the base recipe for this element.
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content>;
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content>;
 }
 
 /// Post-process an element after it was realized.
diff --git a/crates/typst/src/foundations/func.rs b/crates/typst/src/foundations/func.rs
index f1da6e37..6729b39d 100644
--- a/crates/typst/src/foundations/func.rs
+++ b/crates/typst/src/foundations/func.rs
@@ -6,14 +6,12 @@ use ecow::{eco_format, EcoString};
 use once_cell::sync::Lazy;
 
 use crate::diag::{bail, SourceResult, StrResult};
-use crate::eval::{Route, Vm};
+use crate::engine::Engine;
 use crate::foundations::{
-    cast, repr, scope, ty, Args, CastInfo, Content, Element, IntoValue, Scope, Scopes,
-    Selector, Type, Value,
+    cast, repr, scope, ty, Args, CastInfo, Content, Element, IntoArgs, Scope, Selector,
+    Type, Value,
 };
-use crate::introspection::Locator;
-use crate::layout::Vt;
-use crate::syntax::{ast, FileId, Span, SyntaxNode};
+use crate::syntax::{ast, Span, SyntaxNode};
 use crate::util::Static;
 
 #[doc(inline)]
@@ -252,7 +250,13 @@ impl Func {
     }
 
     /// Call the function with the given arguments.
-    pub fn call_vm(&self, vm: &mut Vm, mut args: Args) -> SourceResult<Value> {
+    #[tracing::instrument(skip_all)]
+    pub fn call(&self, engine: &mut Engine, args: impl IntoArgs) -> SourceResult<Value> {
+        self.call_impl(engine, args.into_args(self.span))
+    }
+
+    /// Non-generic implementation of `call`.
+    fn call_impl(&self, engine: &mut Engine, mut args: Args) -> SourceResult<Value> {
         let _span = tracing::info_span!(
             "call",
             name = self.name().unwrap_or("<anon>"),
@@ -261,59 +265,32 @@ impl Func {
 
         match &self.repr {
             Repr::Native(native) => {
-                let value = (native.function)(vm, &mut args)?;
+                let value = (native.function)(engine, &mut args)?;
                 args.finish()?;
                 Ok(value)
             }
             Repr::Element(func) => {
-                let value = func.construct(vm, &mut args)?;
+                let value = func.construct(engine, &mut args)?;
                 args.finish()?;
                 Ok(Value::Content(value))
             }
-            Repr::Closure(closure) => {
-                // Determine the route inside the closure.
-                let fresh = Route::new(closure.file);
-                let route = if vm.file.is_none() { fresh.track() } else { vm.route };
-                crate::eval::call_closure(
-                    self,
-                    closure,
-                    vm.world(),
-                    route,
-                    vm.vt.introspector,
-                    vm.vt.locator.track(),
-                    TrackedMut::reborrow_mut(&mut vm.vt.tracer),
-                    vm.depth + 1,
-                    args,
-                )
-            }
+            Repr::Closure(closure) => crate::eval::call_closure(
+                self,
+                closure,
+                engine.world,
+                engine.introspector,
+                engine.route.track(),
+                engine.locator.track(),
+                TrackedMut::reborrow_mut(&mut engine.tracer),
+                args,
+            ),
             Repr::With(with) => {
                 args.items = with.1.items.iter().cloned().chain(args.items).collect();
-                with.0.call_vm(vm, args)
+                with.0.call(engine, args)
             }
         }
     }
 
-    /// Call the function with a Vt.
-    #[tracing::instrument(skip_all)]
-    pub fn call_vt<T: IntoValue>(
-        &self,
-        vt: &mut Vt,
-        args: impl IntoIterator<Item = T>,
-    ) -> SourceResult<Value> {
-        let route = Route::default();
-        let scopes = Scopes::new(None);
-        let mut locator = Locator::chained(vt.locator.track());
-        let vt = Vt {
-            world: vt.world,
-            introspector: vt.introspector,
-            locator: &mut locator,
-            tracer: TrackedMut::reborrow_mut(&mut vt.tracer),
-        };
-        let mut vm = Vm::new(vt, route.track(), None, scopes);
-        let args = Args::new(self.span(), args);
-        self.call_vm(&mut vm, args)
-    }
-
     /// The function's span.
     pub fn span(&self) -> Span {
         self.span
@@ -443,7 +420,7 @@ pub trait NativeFunc {
 /// Defines a native function.
 #[derive(Debug)]
 pub struct NativeFuncData {
-    pub function: fn(&mut Vm, &mut Args) -> SourceResult<Value>,
+    pub function: fn(&mut Engine, &mut Args) -> SourceResult<Value>,
     pub name: &'static str,
     pub title: &'static str,
     pub docs: &'static str,
@@ -495,8 +472,6 @@ pub struct ParamInfo {
 pub struct Closure {
     /// The closure's syntax node. Must be castable to `ast::Closure`.
     pub node: SyntaxNode,
-    /// The source file where the closure was defined.
-    pub file: Option<FileId>,
     /// Default values of named parameters.
     pub defaults: Vec<Value>,
     /// Captured values from outer scopes.
diff --git a/crates/typst/src/foundations/mod.rs b/crates/typst/src/foundations/mod.rs
index b2c35194..4ddc2162 100644
--- a/crates/typst/src/foundations/mod.rs
+++ b/crates/typst/src/foundations/mod.rs
@@ -60,6 +60,7 @@ pub use self::ty::*;
 pub use self::value::*;
 pub use self::version::*;
 
+#[rustfmt::skip]
 #[doc(hidden)]
 pub use {
     ecow::{eco_format, eco_vec},
@@ -70,7 +71,8 @@ pub use {
 use ecow::EcoString;
 
 use crate::diag::{bail, SourceResult, StrResult};
-use crate::eval::{EvalMode, Vm};
+use crate::engine::Engine;
+use crate::eval::EvalMode;
 use crate::syntax::Spanned;
 
 /// Foundational types and functions.
@@ -251,8 +253,8 @@ impl assert {
 /// ```
 #[func(title = "Evaluate")]
 pub fn eval(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// A string of Typst code to evaluate.
     ///
     /// The code in the string cannot interact with the file system.
@@ -289,5 +291,5 @@ pub fn eval(
     for (key, value) in dict {
         scope.define(key, value);
     }
-    crate::eval::eval_string(vm.world(), &text, span, mode, scope)
+    crate::eval::eval_string(engine.world, &text, span, mode, scope)
 }
diff --git a/crates/typst/src/foundations/plugin.rs b/crates/typst/src/foundations/plugin.rs
index 6071b3bd..89237f94 100644
--- a/crates/typst/src/foundations/plugin.rs
+++ b/crates/typst/src/foundations/plugin.rs
@@ -3,10 +3,10 @@ use std::hash::{Hash, Hasher};
 use std::sync::{Arc, Mutex};
 
 use ecow::{eco_format, EcoString};
-use wasmi::{AsContext, AsContextMut, Caller, Engine, Linker, Module};
+use wasmi::{AsContext, AsContextMut};
 
 use crate::diag::{bail, At, SourceResult, StrResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{func, repr, scope, ty, Bytes};
 use crate::syntax::Spanned;
 use crate::World;
@@ -152,14 +152,14 @@ impl Plugin {
     /// Creates a new plugin from a WebAssembly file.
     #[func(constructor)]
     pub fn construct(
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// Path to a WebAssembly file.
         path: Spanned<EcoString>,
     ) -> SourceResult<Plugin> {
         let Spanned { v: path, span } = path;
-        let id = vm.resolve_path(&path).at(span)?;
-        let data = vm.world().file(id).at(span)?;
+        let id = span.resolve_path(&path).at(span)?;
+        let data = engine.world.file(id).at(span)?;
         Plugin::new(data).at(span)
     }
 }
@@ -168,11 +168,11 @@ impl Plugin {
     /// Create a new plugin from raw WebAssembly bytes.
     #[comemo::memoize]
     pub fn new(bytes: Bytes) -> StrResult<Self> {
-        let engine = Engine::default();
-        let module = Module::new(&engine, bytes.as_slice())
+        let engine = wasmi::Engine::default();
+        let module = wasmi::Module::new(&engine, bytes.as_slice())
             .map_err(|err| format!("failed to load WebAssembly module ({err})"))?;
 
-        let mut linker = Linker::new(&engine);
+        let mut linker = wasmi::Linker::new(&engine);
         linker
             .func_wrap(
                 "typst_env",
@@ -323,7 +323,10 @@ impl Hash for Plugin {
 }
 
 /// Write the arguments to the plugin function into the plugin's memory.
-fn wasm_minimal_protocol_write_args_to_buffer(mut caller: Caller<StoreData>, ptr: u32) {
+fn wasm_minimal_protocol_write_args_to_buffer(
+    mut caller: wasmi::Caller<StoreData>,
+    ptr: u32,
+) {
     let memory = caller.get_export("memory").unwrap().into_memory().unwrap();
     let arguments = std::mem::take(&mut caller.data_mut().args);
     let mut offset = ptr as usize;
@@ -342,7 +345,7 @@ fn wasm_minimal_protocol_write_args_to_buffer(mut caller: Caller<StoreData>, ptr
 
 /// Extracts the output of the plugin function from the plugin's memory.
 fn wasm_minimal_protocol_send_result_to_host(
-    mut caller: Caller<StoreData>,
+    mut caller: wasmi::Caller<StoreData>,
     ptr: u32,
     len: u32,
 ) {
diff --git a/crates/typst/src/foundations/str.rs b/crates/typst/src/foundations/str.rs
index 4b56971a..83bde675 100644
--- a/crates/typst/src/foundations/str.rs
+++ b/crates/typst/src/foundations/str.rs
@@ -8,10 +8,10 @@ use serde::{Deserialize, Serialize};
 use unicode_segmentation::UnicodeSegmentation;
 
 use crate::diag::{bail, At, SourceResult, StrResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{
-    cast, dict, func, repr, scope, ty, Args, Array, Bytes, Dict, Func, IntoValue, Label,
-    Repr, Type, Value, Version,
+    cast, dict, func, repr, scope, ty, Array, Bytes, Dict, Func, IntoValue, Label, Repr,
+    Type, Value, Version,
 };
 use crate::layout::Align;
 use crate::syntax::{Span, Spanned};
@@ -422,8 +422,8 @@ impl Str {
     #[func]
     pub fn replace(
         &self,
-        /// The virtual machine.
-        vm: &mut Vm,
+        /// The engine.
+        engine: &mut Engine,
         /// The pattern to search for.
         pattern: StrPattern,
         /// The string to replace the matches with or a function that gets a
@@ -449,8 +449,8 @@ impl Str {
             match &replacement {
                 Replacement::Str(s) => output.push_str(s),
                 Replacement::Func(func) => {
-                    let args = Args::new(func.span(), [dict.into_value()]);
-                    let piece = func.call_vm(vm, args)?.cast::<Str>().at(func.span())?;
+                    let piece =
+                        func.call(engine, [dict])?.cast::<Str>().at(func.span())?;
                     output.push_str(&piece);
                 }
             }
diff --git a/crates/typst/src/foundations/styles.rs b/crates/typst/src/foundations/styles.rs
index 78bd24d6..ca6a9e78 100644
--- a/crates/typst/src/foundations/styles.rs
+++ b/crates/typst/src/foundations/styles.rs
@@ -10,12 +10,10 @@ use once_cell::sync::Lazy;
 use smallvec::SmallVec;
 
 use crate::diag::{SourceResult, Trace, Tracepoint};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, func, ty, Args, Content, Element, Func, NativeElement, Repr, Selector,
-    Show, Value,
+    cast, elem, func, ty, Content, Element, Func, NativeElement, Repr, Selector, Show,
 };
-use crate::layout::Vt;
 use crate::syntax::Span;
 use crate::text::{FontFamily, FontList, TextElem};
 
@@ -58,8 +56,8 @@ struct StyleElem {
 
 impl Show for StyleElem {
     #[tracing::instrument(name = "StyleElem::show", skip_all)]
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
-        Ok(self.func().call_vt(vt, [styles.to_map()])?.display())
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+        Ok(self.func().call(engine, [styles.to_map()])?.display())
     }
 }
 
@@ -356,37 +354,23 @@ impl Recipe {
     }
 
     /// Apply the recipe to the given content.
-    pub fn apply_vm(&self, vm: &mut Vm, content: Content) -> SourceResult<Content> {
-        match &self.transform {
-            Transformation::Content(content) => Ok(content.clone()),
+    pub fn apply(&self, engine: &mut Engine, content: Content) -> SourceResult<Content> {
+        let mut content = match &self.transform {
+            Transformation::Content(content) => content.clone(),
             Transformation::Func(func) => {
-                let args = Args::new(self.span, [Value::Content(content.clone())]);
-                let mut result = func.call_vm(vm, args);
-                // For selector-less show rules, a tracepoint makes no sense.
+                let mut result = func.call(engine, [content.clone()]);
                 if self.selector.is_some() {
                     let point = || Tracepoint::Show(content.func().name().into());
-                    result = result.trace(vm.world(), point, content.span());
+                    result = result.trace(engine.world, point, content.span());
                 }
-                Ok(result?.display())
+                result?.display()
             }
-            Transformation::Style(styles) => Ok(content.styled_with_map(styles.clone())),
-        }
-    }
-
-    /// Apply the recipe to the given content.
-    pub fn apply_vt(&self, vt: &mut Vt, content: Content) -> SourceResult<Content> {
-        match &self.transform {
-            Transformation::Content(content) => Ok(content.clone()),
-            Transformation::Func(func) => {
-                let mut result = func.call_vt(vt, [Value::Content(content.clone())]);
-                if self.selector.is_some() {
-                    let point = || Tracepoint::Show(content.func().name().into());
-                    result = result.trace(vt.world, point, content.span());
-                }
-                Ok(result?.display())
-            }
-            Transformation::Style(styles) => Ok(content.styled_with_map(styles.clone())),
+            Transformation::Style(styles) => content.styled_with_map(styles.clone()),
+        };
+        if content.span().is_detached() {
+            content = content.spanned(self.span);
         }
+        Ok(content)
     }
 }
 
diff --git a/crates/typst/src/foundations/ty.rs b/crates/typst/src/foundations/ty.rs
index 47add6ec..4c2098f3 100644
--- a/crates/typst/src/foundations/ty.rs
+++ b/crates/typst/src/foundations/ty.rs
@@ -8,6 +8,7 @@ use crate::diag::StrResult;
 use crate::foundations::{cast, func, Func, NativeFuncData, Repr, Scope, Value};
 use crate::util::Static;
 
+#[rustfmt::skip]
 #[doc(inline)]
 pub use typst_macros::{scope, ty};
 
diff --git a/crates/typst/src/introspection/counter.rs b/crates/typst/src/introspection/counter.rs
index 7b073681..ce485997 100644
--- a/crates/typst/src/introspection/counter.rs
+++ b/crates/typst/src/introspection/counter.rs
@@ -6,6 +6,7 @@ use ecow::{eco_format, eco_vec, EcoString, EcoVec};
 use smallvec::{smallvec, SmallVec};
 
 use crate::diag::{At, SourceResult, StrResult};
+use crate::engine::{Engine, Route};
 use crate::eval::Tracer;
 use crate::foundations::{
     cast, elem, func, scope, select_where, ty, Array, Content, Element, Func, IntoValue,
@@ -13,7 +14,7 @@ use crate::foundations::{
     Value,
 };
 use crate::introspection::{Introspector, Locatable, Location, Locator, Meta};
-use crate::layout::{Frame, FrameItem, PageElem, Vt};
+use crate::layout::{Frame, FrameItem, PageElem};
 use crate::math::EquationElem;
 use crate::model::{FigureElem, HeadingElem, Numbering, NumberingPattern};
 use crate::util::NonZeroExt;
@@ -222,9 +223,13 @@ impl Counter {
     }
 
     /// Gets the current and final value of the state combined in one state.
-    pub fn both(&self, vt: &mut Vt, location: Location) -> SourceResult<CounterState> {
-        let sequence = self.sequence(vt)?;
-        let offset = vt
+    pub fn both(
+        &self,
+        engine: &mut Engine,
+        location: Location,
+    ) -> SourceResult<CounterState> {
+        let sequence = self.sequence(engine)?;
+        let offset = engine
             .introspector
             .query(&self.selector().before(location.into(), true))
             .len();
@@ -232,10 +237,10 @@ impl Counter {
         let (mut final_state, final_page) = sequence.last().unwrap().clone();
         if self.is_page() {
             let at_delta =
-                vt.introspector.page(location).get().saturating_sub(at_page.get());
+                engine.introspector.page(location).get().saturating_sub(at_page.get());
             at_state.step(NonZeroUsize::ONE, at_delta);
             let final_delta =
-                vt.introspector.pages().get().saturating_sub(final_page.get());
+                engine.introspector.pages().get().saturating_sub(final_page.get());
             final_state.step(NonZeroUsize::ONE, final_delta);
         }
         Ok(CounterState(smallvec![at_state.first(), final_state.first()]))
@@ -247,13 +252,14 @@ impl Counter {
     /// of counter updates from quadratic to linear.
     fn sequence(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
     ) -> SourceResult<EcoVec<(CounterState, NonZeroUsize)>> {
         self.sequence_impl(
-            vt.world,
-            vt.introspector,
-            vt.locator.track(),
-            TrackedMut::reborrow_mut(&mut vt.tracer),
+            engine.world,
+            engine.introspector,
+            engine.route.track(),
+            engine.locator.track(),
+            TrackedMut::reborrow_mut(&mut engine.tracer),
         )
     }
 
@@ -263,11 +269,18 @@ impl Counter {
         &self,
         world: Tracked<dyn World + '_>,
         introspector: Tracked<Introspector>,
+        route: Tracked<Route>,
         locator: Tracked<Locator>,
         tracer: TrackedMut<Tracer>,
     ) -> SourceResult<EcoVec<(CounterState, NonZeroUsize)>> {
         let mut locator = Locator::chained(locator);
-        let mut vt = Vt { world, introspector, locator: &mut locator, tracer };
+        let mut engine = Engine {
+            world,
+            introspector,
+            route: Route::extend(route),
+            locator: &mut locator,
+            tracer,
+        };
 
         let mut state = CounterState::init(&self.0);
         let mut page = NonZeroUsize::ONE;
@@ -288,7 +301,7 @@ impl Counter {
                 Some(countable) => countable.update(),
                 None => Some(CounterUpdate::Step(NonZeroUsize::ONE)),
             } {
-                state.update(&mut vt, update)?;
+                state.update(&mut engine, update)?;
             }
 
             stops.push((state.clone(), page));
@@ -399,21 +412,22 @@ impl Counter {
     #[func]
     pub fn at(
         &self,
-        /// The virtual typesetter.
-        vt: &mut Vt,
+        /// The engine.
+        engine: &mut Engine,
         /// The location at which the counter value should be retrieved. A
         /// suitable location can be retrieved from [`locate`]($locate) or
         /// [`query`]($query).
         location: Location,
     ) -> SourceResult<CounterState> {
-        let sequence = self.sequence(vt)?;
-        let offset = vt
+        let sequence = self.sequence(engine)?;
+        let offset = engine
             .introspector
             .query(&self.selector().before(location.into(), true))
             .len();
         let (mut state, page) = sequence[offset].clone();
         if self.is_page() {
-            let delta = vt.introspector.page(location).get().saturating_sub(page.get());
+            let delta =
+                engine.introspector.page(location).get().saturating_sub(page.get());
             state.step(NonZeroUsize::ONE, delta);
         }
 
@@ -425,8 +439,8 @@ impl Counter {
     #[func]
     pub fn final_(
         &self,
-        /// The virtual typesetter.
-        vt: &mut Vt,
+        /// The engine.
+        engine: &mut Engine,
         /// Can be an arbitrary location, as its value is irrelevant for the
         /// method's return value. Why is it required then? Typst has to
         /// evaluate parts of your code multiple times to determine all counter
@@ -438,10 +452,10 @@ impl Counter {
         location: Location,
     ) -> SourceResult<CounterState> {
         let _ = location;
-        let sequence = self.sequence(vt)?;
+        let sequence = self.sequence(engine)?;
         let (mut state, page) = sequence.last().unwrap().clone();
         if self.is_page() {
-            let delta = vt.introspector.pages().get().saturating_sub(page.get());
+            let delta = engine.introspector.pages().get().saturating_sub(page.get());
             state.step(NonZeroUsize::ONE, delta);
         }
         Ok(state)
@@ -544,12 +558,17 @@ impl CounterState {
     }
 
     /// Advance the counter and return the numbers for the given heading.
-    pub fn update(&mut self, vt: &mut Vt, update: CounterUpdate) -> SourceResult<()> {
+    pub fn update(
+        &mut self,
+        engine: &mut Engine,
+        update: CounterUpdate,
+    ) -> SourceResult<()> {
         match update {
             CounterUpdate::Set(state) => *self = state,
             CounterUpdate::Step(level) => self.step(level, 1),
             CounterUpdate::Func(func) => {
-                *self = func.call_vt(vt, self.0.iter().copied())?.cast().at(func.span())?
+                *self =
+                    func.call(engine, self.0.iter().copied())?.cast().at(func.span())?
             }
         }
         Ok(())
@@ -575,8 +594,12 @@ impl CounterState {
     }
 
     /// Display the counter state with a numbering.
-    pub fn display(&self, vt: &mut Vt, numbering: &Numbering) -> SourceResult<Content> {
-        Ok(numbering.apply_vt(vt, &self.0)?.display())
+    pub fn display(
+        &self,
+        engine: &mut Engine,
+        numbering: &Numbering,
+    ) -> SourceResult<Content> {
+        Ok(numbering.apply(engine, &self.0)?.display())
     }
 }
 
@@ -608,8 +631,8 @@ struct DisplayElem {
 
 impl Show for DisplayElem {
     #[tracing::instrument(name = "DisplayElem::show", skip_all)]
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
-        Ok(vt.delayed(|vt| {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+        Ok(engine.delayed(|engine| {
             let location = self.location().unwrap();
             let counter = self.counter();
             let numbering = self
@@ -633,12 +656,12 @@ impl Show for DisplayElem {
                 .unwrap_or_else(|| NumberingPattern::from_str("1.1").unwrap().into());
 
             let state = if *self.both() {
-                counter.both(vt, location)?
+                counter.both(engine, location)?
             } else {
-                counter.at(vt, location)?
+                counter.at(engine, location)?
             };
 
-            state.display(vt, &numbering)
+            state.display(engine, &numbering)
         }))
     }
 }
@@ -657,7 +680,7 @@ struct UpdateElem {
 
 impl Show for UpdateElem {
     #[tracing::instrument(name = "UpdateElem::show", skip(self))]
-    fn show(&self, _: &mut Vt, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
         Ok(Content::empty())
     }
 }
@@ -693,15 +716,15 @@ impl ManualPageCounter {
     }
 
     /// Advance past a page.
-    pub fn visit(&mut self, vt: &mut Vt, page: &Frame) -> SourceResult<()> {
+    pub fn visit(&mut self, engine: &mut Engine, page: &Frame) -> SourceResult<()> {
         for (_, item) in page.items() {
             match item {
-                FrameItem::Group(group) => self.visit(vt, &group.frame)?,
+                FrameItem::Group(group) => self.visit(engine, &group.frame)?,
                 FrameItem::Meta(Meta::Elem(elem), _) => {
                     let Some(elem) = elem.to::<UpdateElem>() else { continue };
                     if *elem.key() == CounterKey::Page {
                         let mut state = CounterState(smallvec![self.logical]);
-                        state.update(vt, elem.update().clone())?;
+                        state.update(engine, elem.update().clone())?;
                         self.logical = state.first();
                     }
                 }
diff --git a/crates/typst/src/introspection/locate.rs b/crates/typst/src/introspection/locate.rs
index 1c4f0e5a..69dcadd8 100644
--- a/crates/typst/src/introspection/locate.rs
+++ b/crates/typst/src/introspection/locate.rs
@@ -1,7 +1,7 @@
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{elem, func, Content, Func, NativeElement, Show, StyleChain};
 use crate::introspection::Locatable;
-use crate::layout::Vt;
 
 /// Provides access to the location of content.
 ///
@@ -37,11 +37,11 @@ struct LocateElem {
 }
 
 impl Show for LocateElem {
-    #[tracing::instrument(name = "LocateElem::show", skip(self, vt))]
-    fn show(&self, vt: &mut Vt, _: StyleChain) -> SourceResult<Content> {
-        Ok(vt.delayed(|vt| {
+    #[tracing::instrument(name = "LocateElem::show", skip(self, engine))]
+    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
+        Ok(engine.delayed(|engine| {
             let location = self.location().unwrap();
-            Ok(self.func().call_vt(vt, [location])?.display())
+            Ok(self.func().call(engine, [location])?.display())
         }))
     }
 }
diff --git a/crates/typst/src/introspection/location.rs b/crates/typst/src/introspection/location.rs
index b70dc4ad..0ceaac8b 100644
--- a/crates/typst/src/introspection/location.rs
+++ b/crates/typst/src/introspection/location.rs
@@ -2,7 +2,7 @@ use std::num::NonZeroUsize;
 
 use ecow::EcoString;
 
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{cast, func, scope, ty, Dict, Repr};
 use crate::model::Numbering;
 
@@ -45,8 +45,8 @@ impl Location {
     /// If you want to know the value of the page counter, use
     /// `{counter(page).at(loc)}` instead.
     #[func]
-    pub fn page(self, vm: &mut Vm) -> NonZeroUsize {
-        vm.vt.introspector.page(self)
+    pub fn page(self, engine: &mut Engine) -> NonZeroUsize {
+        engine.introspector.page(self)
     }
 
     /// Return a dictionary with the page number and the x, y position for this
@@ -56,8 +56,8 @@ impl Location {
     /// If you only need the page number, use `page()` instead as it allows
     /// Typst to skip unnecessary work.
     #[func]
-    pub fn position(self, vm: &mut Vm) -> Dict {
-        vm.vt.introspector.position(self).into()
+    pub fn position(self, engine: &mut Engine) -> Dict {
+        engine.introspector.position(self).into()
     }
 
     /// Returns the page numbering pattern of the page at this location. This
@@ -68,8 +68,8 @@ impl Location {
     /// If the page numbering is set to `none` at that location, this function
     /// returns `none`.
     #[func]
-    pub fn page_numbering(self, vm: &mut Vm) -> Option<Numbering> {
-        vm.vt.introspector.page_numbering(self).cloned()
+    pub fn page_numbering(self, engine: &mut Engine) -> Option<Numbering> {
+        engine.introspector.page_numbering(self).cloned()
     }
 }
 
@@ -83,5 +83,5 @@ cast! {
     type Location,
 }
 
-/// Makes this element locatable through `vt.locate`.
+/// Makes this element locatable through `engine.locate`.
 pub trait Locatable {}
diff --git a/crates/typst/src/introspection/metadata.rs b/crates/typst/src/introspection/metadata.rs
index 4042bc04..15d144eb 100644
--- a/crates/typst/src/introspection/metadata.rs
+++ b/crates/typst/src/introspection/metadata.rs
@@ -1,7 +1,7 @@
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{elem, Behave, Behaviour, Content, Show, StyleChain, Value};
 use crate::introspection::Locatable;
-use crate::layout::Vt;
 
 /// Exposes a value to the query system without producing visible content.
 ///
@@ -31,7 +31,7 @@ pub struct MetadataElem {
 }
 
 impl Show for MetadataElem {
-    fn show(&self, _vt: &mut Vt, _styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, _styles: StyleChain) -> SourceResult<Content> {
         Ok(Content::empty())
     }
 }
diff --git a/crates/typst/src/introspection/query.rs b/crates/typst/src/introspection/query.rs
index 1024238e..5b70ba51 100644
--- a/crates/typst/src/introspection/query.rs
+++ b/crates/typst/src/introspection/query.rs
@@ -1,4 +1,4 @@
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{func, Array, LocatableSelector, Value};
 use crate::introspection::Location;
 
@@ -129,8 +129,8 @@ use crate::introspection::Location;
 /// ```
 #[func]
 pub fn query(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// Can be an element function like a `heading` or `figure`, a `{<label>}`
     /// or a more complex selector like `{heading.where(level: 1)}`.
     ///
@@ -152,7 +152,7 @@ pub fn query(
     location: Location,
 ) -> Array {
     let _ = location;
-    let vec = vm.vt.introspector.query(&target.0);
+    let vec = engine.introspector.query(&target.0);
     vec.into_iter()
         .map(|elem| Value::Content(elem.into_inner()))
         .collect()
diff --git a/crates/typst/src/introspection/state.rs b/crates/typst/src/introspection/state.rs
index af6d7933..8479bace 100644
--- a/crates/typst/src/introspection/state.rs
+++ b/crates/typst/src/introspection/state.rs
@@ -2,13 +2,13 @@ use comemo::{Tracked, TrackedMut};
 use ecow::{eco_format, eco_vec, EcoString, EcoVec};
 
 use crate::diag::SourceResult;
+use crate::engine::{Engine, Route};
 use crate::eval::Tracer;
 use crate::foundations::{
     cast, elem, func, scope, select_where, ty, Content, Func, NativeElement, Repr,
     Selector, Show, Str, StyleChain, Value,
 };
 use crate::introspection::{Introspector, Locatable, Location, Locator};
-use crate::layout::Vt;
 use crate::World;
 
 /// Manages stateful parts of your document.
@@ -204,12 +204,13 @@ impl State {
     ///
     /// This has to happen just once for all states, cutting down the number
     /// of state updates from quadratic to linear.
-    fn sequence(&self, vt: &mut Vt) -> SourceResult<EcoVec<Value>> {
+    fn sequence(&self, engine: &mut Engine) -> SourceResult<EcoVec<Value>> {
         self.sequence_impl(
-            vt.world,
-            vt.introspector,
-            vt.locator.track(),
-            TrackedMut::reborrow_mut(&mut vt.tracer),
+            engine.world,
+            engine.introspector,
+            engine.route.track(),
+            engine.locator.track(),
+            TrackedMut::reborrow_mut(&mut engine.tracer),
         )
     }
 
@@ -219,11 +220,18 @@ impl State {
         &self,
         world: Tracked<dyn World + '_>,
         introspector: Tracked<Introspector>,
+        route: Tracked<Route>,
         locator: Tracked<Locator>,
         tracer: TrackedMut<Tracer>,
     ) -> SourceResult<EcoVec<Value>> {
         let mut locator = Locator::chained(locator);
-        let mut vt = Vt { world, introspector, locator: &mut locator, tracer };
+        let mut engine = Engine {
+            world,
+            introspector,
+            route: Route::extend(route),
+            locator: &mut locator,
+            tracer,
+        };
         let mut state = self.init.clone();
         let mut stops = eco_vec![state.clone()];
 
@@ -231,7 +239,7 @@ impl State {
             let elem = elem.to::<UpdateElem>().unwrap();
             match elem.update() {
                 StateUpdate::Set(value) => state = value.clone(),
-                StateUpdate::Func(func) => state = func.call_vt(&mut vt, [state])?,
+                StateUpdate::Func(func) => state = func.call(&mut engine, [state])?,
             }
             stops.push(state.clone());
         }
@@ -295,15 +303,15 @@ impl State {
     #[func]
     pub fn at(
         &self,
-        /// The virtual typesetter.
-        vt: &mut Vt,
+        /// The engine.
+        engine: &mut Engine,
         /// The location at which the state's value should be retrieved. A
         /// suitable location can be retrieved from [`locate`]($locate) or
         /// [`query`]($query).
         location: Location,
     ) -> SourceResult<Value> {
-        let sequence = self.sequence(vt)?;
-        let offset = vt
+        let sequence = self.sequence(engine)?;
+        let offset = engine
             .introspector
             .query(&self.selector().before(location.into(), true))
             .len();
@@ -314,8 +322,8 @@ impl State {
     #[func]
     pub fn final_(
         &self,
-        /// The virtual typesetter.
-        vt: &mut Vt,
+        /// The engine.
+        engine: &mut Engine,
         /// Can be an arbitrary location, as its value is irrelevant for the
         /// method's return value. Why is it required then? As noted before,
         /// Typst has to evaluate parts of your code multiple times to determine
@@ -327,7 +335,7 @@ impl State {
         location: Location,
     ) -> SourceResult<Value> {
         let _ = location;
-        let sequence = self.sequence(vt)?;
+        let sequence = self.sequence(engine)?;
         Ok(sequence.last().unwrap().clone())
     }
 }
@@ -377,13 +385,13 @@ struct DisplayElem {
 }
 
 impl Show for DisplayElem {
-    #[tracing::instrument(name = "DisplayElem::show", skip(self, vt))]
-    fn show(&self, vt: &mut Vt, _: StyleChain) -> SourceResult<Content> {
-        Ok(vt.delayed(|vt| {
+    #[tracing::instrument(name = "DisplayElem::show", skip(self, engine))]
+    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
+        Ok(engine.delayed(|engine| {
             let location = self.location().unwrap();
-            let value = self.state().at(vt, location)?;
+            let value = self.state().at(engine, location)?;
             Ok(match self.func() {
-                Some(func) => func.call_vt(vt, [value])?.display(),
+                Some(func) => func.call(engine, [value])?.display(),
                 None => value.display(),
             })
         }))
@@ -404,7 +412,7 @@ struct UpdateElem {
 
 impl Show for UpdateElem {
     #[tracing::instrument(name = "UpdateElem::show")]
-    fn show(&self, _: &mut Vt, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
         Ok(Content::empty())
     }
 }
diff --git a/crates/typst/src/layout/align.rs b/crates/typst/src/layout/align.rs
index 74db4373..3d4017f3 100644
--- a/crates/typst/src/layout/align.rs
+++ b/crates/typst/src/layout/align.rs
@@ -3,10 +3,11 @@ use std::ops::Add;
 use ecow::{eco_format, EcoString};
 
 use crate::diag::{bail, SourceResult, StrResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, func, scope, ty, Content, Fold, Repr, Resolve, Show, StyleChain,
 };
-use crate::layout::{Abs, Axes, Axis, Dir, Side, Vt};
+use crate::layout::{Abs, Axes, Axis, Dir, Side};
 use crate::text::TextElem;
 
 /// Aligns content horizontally and vertically.
@@ -46,7 +47,7 @@ pub struct AlignElem {
 
 impl Show for AlignElem {
     #[tracing::instrument(name = "AlignElem::show", skip_all)]
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(self
             .body()
             .clone()
diff --git a/crates/typst/src/layout/columns.rs b/crates/typst/src/layout/columns.rs
index 852ef8f8..275dbbeb 100644
--- a/crates/typst/src/layout/columns.rs
+++ b/crates/typst/src/layout/columns.rs
@@ -1,9 +1,10 @@
 use std::num::NonZeroUsize;
 
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{elem, Behave, Behaviour, Content, StyleChain};
 use crate::layout::{
-    Abs, Axes, Dir, Fragment, Frame, Layout, Length, Point, Ratio, Regions, Rel, Size, Vt,
+    Abs, Axes, Dir, Fragment, Frame, Layout, Length, Point, Ratio, Regions, Rel, Size,
 };
 use crate::text::TextElem;
 use crate::util::Numeric;
@@ -60,7 +61,7 @@ impl Layout for ColumnsElem {
     #[tracing::instrument(name = "ColumnsElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -69,7 +70,7 @@ impl Layout for ColumnsElem {
         // Separating the infinite space into infinite columns does not make
         // much sense.
         if !regions.size.x.is_finite() {
-            return body.layout(vt, styles, regions);
+            return body.layout(engine, styles, regions);
         }
 
         // Determine the width of the gutter and each column.
@@ -94,7 +95,7 @@ impl Layout for ColumnsElem {
         };
 
         // Layout the children.
-        let mut frames = body.layout(vt, styles, pod)?.into_iter();
+        let mut frames = body.layout(engine, styles, pod)?.into_iter();
         let mut finished = vec![];
 
         let dir = TextElem::dir_in(styles);
diff --git a/crates/typst/src/layout/container.rs b/crates/typst/src/layout/container.rs
index cb65d4d8..cdc5c489 100644
--- a/crates/typst/src/layout/container.rs
+++ b/crates/typst/src/layout/container.rs
@@ -1,10 +1,11 @@
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, AutoValue, Content, NativeElement, Resolve, Smart, StyleChain, Value,
 };
 use crate::layout::{
     Abs, Axes, Corners, Em, Fr, Fragment, FrameKind, Layout, Length, Ratio, Regions, Rel,
-    Sides, Size, Spacing, VElem, Vt,
+    Sides, Size, Spacing, VElem,
 };
 use crate::util::Numeric;
 use crate::visualize::{clip_rect, Paint, Stroke};
@@ -112,7 +113,7 @@ impl Layout for BoxElem {
     #[tracing::instrument(name = "BoxElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -140,7 +141,7 @@ impl Layout for BoxElem {
         // Select the appropriate base and expansion for the child depending
         // on whether it is automatically or relatively sized.
         let pod = Regions::one(size, expand);
-        let mut frame = body.layout(vt, styles, pod)?.into_frame();
+        let mut frame = body.layout(engine, styles, pod)?.into_frame();
 
         // Enforce correct size.
         *frame.size_mut() = expand.select(size, frame.size());
@@ -344,7 +345,7 @@ impl Layout for BlockElem {
     #[tracing::instrument(name = "BlockElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -368,7 +369,7 @@ impl Layout for BlockElem {
             // Measure to ensure frames for all regions have the same width.
             if sizing.x == Smart::Auto {
                 let pod = Regions::one(size, Axes::splat(false));
-                let frame = body.measure(vt, styles, pod)?.into_frame();
+                let frame = body.measure(engine, styles, pod)?.into_frame();
                 size.x = frame.width();
                 expand.x = true;
             }
@@ -403,7 +404,7 @@ impl Layout for BlockElem {
                 pod.last = None;
             }
 
-            let mut frames = body.layout(vt, styles, pod)?.into_frames();
+            let mut frames = body.layout(engine, styles, pod)?.into_frames();
             for (frame, &height) in frames.iter_mut().zip(&heights) {
                 *frame.size_mut() =
                     expand.select(Size::new(size.x, height), frame.size());
@@ -411,7 +412,7 @@ impl Layout for BlockElem {
             frames
         } else {
             let pod = Regions::one(size, expand);
-            let mut frames = body.layout(vt, styles, pod)?.into_frames();
+            let mut frames = body.layout(engine, styles, pod)?.into_frames();
             *frames[0].size_mut() = expand.select(size, frames[0].size());
             frames
         };
diff --git a/crates/typst/src/layout/flow.rs b/crates/typst/src/layout/flow.rs
index 1c97c110..b4e7afd1 100644
--- a/crates/typst/src/layout/flow.rs
+++ b/crates/typst/src/layout/flow.rs
@@ -1,12 +1,13 @@
 use comemo::Prehashed;
 
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{elem, Content, NativeElement, Resolve, Smart, StyleChain};
 use crate::introspection::{Meta, MetaElem};
 use crate::layout::{
     Abs, AlignElem, Axes, BlockElem, ColbreakElem, ColumnsElem, FixedAlign, Fr, Fragment,
     Frame, FrameItem, Layout, PlaceElem, Point, Regions, Rel, Size, Spacing, VAlign,
-    VElem, Vt,
+    VElem,
 };
 use crate::model::{FootnoteElem, FootnoteEntry, ParElem};
 use crate::util::Numeric;
@@ -30,7 +31,7 @@ impl Layout for FlowElem {
     #[tracing::instrument(name = "FlowElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -51,9 +52,9 @@ impl Layout for FlowElem {
             }
 
             if let Some(elem) = child.to::<VElem>() {
-                layouter.layout_spacing(vt, elem, styles)?;
+                layouter.layout_spacing(engine, elem, styles)?;
             } else if let Some(elem) = child.to::<ParElem>() {
-                layouter.layout_par(vt, elem, styles)?;
+                layouter.layout_par(engine, elem, styles)?;
             } else if child.is::<LineElem>()
                 || child.is::<RectElem>()
                 || child.is::<SquareElem>()
@@ -64,7 +65,7 @@ impl Layout for FlowElem {
                 || child.is::<PathElem>()
             {
                 let layoutable = child.with::<dyn Layout>().unwrap();
-                layouter.layout_single(vt, layoutable, styles)?;
+                layouter.layout_single(engine, layoutable, styles)?;
             } else if child.is::<MetaElem>() {
                 let mut frame = Frame::soft(Size::zero());
                 frame.meta(styles, true);
@@ -75,20 +76,20 @@ impl Layout for FlowElem {
                     movable: false,
                 });
             } else if let Some(placed) = child.to::<PlaceElem>() {
-                layouter.layout_placed(vt, placed, styles)?;
+                layouter.layout_placed(engine, placed, styles)?;
             } else if child.can::<dyn Layout>() {
-                layouter.layout_multiple(vt, child, styles)?;
+                layouter.layout_multiple(engine, child, styles)?;
             } else if child.is::<ColbreakElem>() {
                 if !layouter.regions.backlog.is_empty() || layouter.regions.last.is_some()
                 {
-                    layouter.finish_region(vt)?;
+                    layouter.finish_region(engine)?;
                 }
             } else {
                 bail!(child.span(), "unexpected flow child");
             }
         }
 
-        layouter.finish(vt)
+        layouter.finish(engine)
     }
 }
 
@@ -193,12 +194,12 @@ impl<'a> FlowLayouter<'a> {
     #[tracing::instrument(name = "FlowLayouter::layout_spacing", skip_all)]
     fn layout_spacing(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         v: &VElem,
         styles: StyleChain,
     ) -> SourceResult<()> {
         self.layout_item(
-            vt,
+            engine,
             match v.amount() {
                 Spacing::Rel(rel) => FlowItem::Absolute(
                     rel.resolve(styles).relative_to(self.initial.y),
@@ -213,7 +214,7 @@ impl<'a> FlowLayouter<'a> {
     #[tracing::instrument(name = "FlowLayouter::layout_par", skip_all)]
     fn layout_par(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         par: &ParElem,
         styles: StyleChain,
     ) -> SourceResult<()> {
@@ -221,7 +222,13 @@ impl<'a> FlowLayouter<'a> {
         let leading = ParElem::leading_in(styles);
         let consecutive = self.last_was_par;
         let lines = par
-            .layout(vt, styles, consecutive, self.regions.base(), self.regions.expand.x)?
+            .layout(
+                engine,
+                styles,
+                consecutive,
+                self.regions.base(),
+                self.regions.expand.x,
+            )?
             .into_frames();
 
         let mut sticky = self.items.len();
@@ -236,20 +243,20 @@ impl<'a> FlowLayouter<'a> {
         if let Some(first) = lines.first() {
             if !self.regions.size.y.fits(first.height()) && !self.regions.in_last() {
                 let carry: Vec<_> = self.items.drain(sticky..).collect();
-                self.finish_region(vt)?;
+                self.finish_region(engine)?;
                 for item in carry {
-                    self.layout_item(vt, item)?;
+                    self.layout_item(engine, item)?;
                 }
             }
         }
 
         for (i, frame) in lines.into_iter().enumerate() {
             if i > 0 {
-                self.layout_item(vt, FlowItem::Absolute(leading, true))?;
+                self.layout_item(engine, FlowItem::Absolute(leading, true))?;
             }
 
             self.layout_item(
-                vt,
+                engine,
                 FlowItem::Frame { frame, align, sticky: false, movable: true },
             )?;
         }
@@ -262,15 +269,18 @@ impl<'a> FlowLayouter<'a> {
     #[tracing::instrument(name = "FlowLayouter::layout_single", skip_all)]
     fn layout_single(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         content: &dyn Layout,
         styles: StyleChain,
     ) -> SourceResult<()> {
         let align = AlignElem::alignment_in(styles).resolve(styles);
         let sticky = BlockElem::sticky_in(styles);
         let pod = Regions::one(self.regions.base(), Axes::splat(false));
-        let frame = content.layout(vt, styles, pod)?.into_frame();
-        self.layout_item(vt, FlowItem::Frame { frame, align, sticky, movable: true })?;
+        let frame = content.layout(engine, styles, pod)?.into_frame();
+        self.layout_item(
+            engine,
+            FlowItem::Frame { frame, align, sticky, movable: true },
+        )?;
         self.last_was_par = false;
         Ok(())
     }
@@ -278,7 +288,7 @@ impl<'a> FlowLayouter<'a> {
     /// Layout a placed element.
     fn layout_placed(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         placed: &PlaceElem,
         styles: StyleChain,
     ) -> SourceResult<()> {
@@ -290,15 +300,15 @@ impl<'a> FlowLayouter<'a> {
             align.x().unwrap_or_default().resolve(styles)
         });
         let y_align = alignment.map(|align| align.y().map(VAlign::fix));
-        let frame = placed.layout(vt, styles, self.regions)?.into_frame();
+        let frame = placed.layout(engine, styles, self.regions)?.into_frame();
         let item = FlowItem::Placed { frame, x_align, y_align, delta, float, clearance };
-        self.layout_item(vt, item)
+        self.layout_item(engine, item)
     }
 
     /// Layout into multiple regions.
     fn layout_multiple(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         block: &Content,
         styles: StyleChain,
     ) -> SourceResult<()> {
@@ -313,7 +323,7 @@ impl<'a> FlowLayouter<'a> {
 
         if self.regions.is_full() {
             // Skip directly if region is already full.
-            self.finish_region(vt)?;
+            self.finish_region(engine)?;
         }
 
         // How to align the block.
@@ -328,7 +338,7 @@ impl<'a> FlowLayouter<'a> {
 
         // Layout the block itself.
         let sticky = BlockElem::sticky_in(styles);
-        let fragment = block.layout(vt, styles, self.regions)?;
+        let fragment = block.layout(engine, styles, self.regions)?;
 
         for (i, frame) in fragment.into_iter().enumerate() {
             // Find footnotes in the frame.
@@ -337,14 +347,14 @@ impl<'a> FlowLayouter<'a> {
             }
 
             if i > 0 {
-                self.finish_region(vt)?;
+                self.finish_region(engine)?;
             }
 
             let item = FlowItem::Frame { frame, align, sticky, movable: false };
-            self.layout_item(vt, item)?;
+            self.layout_item(engine, item)?;
         }
 
-        self.try_handle_footnotes(vt, notes)?;
+        self.try_handle_footnotes(engine, notes)?;
 
         self.root = is_root;
         self.regions.root = false;
@@ -355,7 +365,11 @@ impl<'a> FlowLayouter<'a> {
 
     /// Layout a finished frame.
     #[tracing::instrument(name = "FlowLayouter::layout_item", skip_all)]
-    fn layout_item(&mut self, vt: &mut Vt, mut item: FlowItem) -> SourceResult<()> {
+    fn layout_item(
+        &mut self,
+        engine: &mut Engine,
+        mut item: FlowItem,
+    ) -> SourceResult<()> {
         match item {
             FlowItem::Absolute(v, weak) => {
                 if weak
@@ -372,7 +386,7 @@ impl<'a> FlowLayouter<'a> {
             FlowItem::Frame { ref frame, movable, .. } => {
                 let height = frame.height();
                 if !self.regions.size.y.fits(height) && !self.regions.in_last() {
-                    self.finish_region(vt)?;
+                    self.finish_region(engine)?;
                 }
 
                 self.regions.size.y -= height;
@@ -380,12 +394,12 @@ impl<'a> FlowLayouter<'a> {
                     let mut notes = Vec::new();
                     find_footnotes(&mut notes, frame);
                     self.items.push(item);
-                    if !self.handle_footnotes(vt, &mut notes, true, false)? {
+                    if !self.handle_footnotes(engine, &mut notes, true, false)? {
                         let item = self.items.pop();
-                        self.finish_region(vt)?;
+                        self.finish_region(engine)?;
                         self.items.extend(item);
                         self.regions.size.y -= height;
-                        self.handle_footnotes(vt, &mut notes, true, true)?;
+                        self.handle_footnotes(engine, &mut notes, true, true)?;
                     }
                     return Ok(());
                 }
@@ -429,7 +443,7 @@ impl<'a> FlowLayouter<'a> {
                 if self.root {
                     let mut notes = vec![];
                     find_footnotes(&mut notes, frame);
-                    self.try_handle_footnotes(vt, notes)?;
+                    self.try_handle_footnotes(engine, notes)?;
                 }
             }
             FlowItem::Footnote(_) => {}
@@ -440,7 +454,7 @@ impl<'a> FlowLayouter<'a> {
     }
 
     /// Finish the frame for one region.
-    fn finish_region(&mut self, vt: &mut Vt) -> SourceResult<()> {
+    fn finish_region(&mut self, engine: &mut Engine) -> SourceResult<()> {
         // Trim weak spacing.
         while self
             .items
@@ -567,23 +581,23 @@ impl<'a> FlowLayouter<'a> {
 
         // Try to place floats.
         for item in std::mem::take(&mut self.pending_floats) {
-            self.layout_item(vt, item)?;
+            self.layout_item(engine, item)?;
         }
 
         Ok(())
     }
 
     /// Finish layouting and return the resulting fragment.
-    fn finish(mut self, vt: &mut Vt) -> SourceResult<Fragment> {
+    fn finish(mut self, engine: &mut Engine) -> SourceResult<Fragment> {
         if self.expand.y {
             while !self.regions.backlog.is_empty() {
-                self.finish_region(vt)?;
+                self.finish_region(engine)?;
             }
         }
 
-        self.finish_region(vt)?;
+        self.finish_region(engine)?;
         while !self.items.is_empty() {
-            self.finish_region(vt)?;
+            self.finish_region(engine)?;
         }
 
         Ok(Fragment::frames(self.finished))
@@ -593,12 +607,12 @@ impl<'a> FlowLayouter<'a> {
 impl FlowLayouter<'_> {
     fn try_handle_footnotes(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         mut notes: Vec<FootnoteElem>,
     ) -> SourceResult<()> {
-        if self.root && !self.handle_footnotes(vt, &mut notes, false, false)? {
-            self.finish_region(vt)?;
-            self.handle_footnotes(vt, &mut notes, false, true)?;
+        if self.root && !self.handle_footnotes(engine, &mut notes, false, false)? {
+            self.finish_region(engine)?;
+            self.handle_footnotes(engine, &mut notes, false, true)?;
         }
         Ok(())
     }
@@ -607,7 +621,7 @@ impl FlowLayouter<'_> {
     #[tracing::instrument(skip_all)]
     fn handle_footnotes(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         notes: &mut Vec<FootnoteElem>,
         movable: bool,
         force: bool,
@@ -624,14 +638,14 @@ impl FlowLayouter<'_> {
             }
 
             if !self.has_footnotes {
-                self.layout_footnote_separator(vt)?;
+                self.layout_footnote_separator(engine)?;
             }
 
             self.regions.size.y -= self.footnote_config.gap;
-            let checkpoint = vt.locator.clone();
+            let checkpoint = engine.locator.clone();
             let frames = FootnoteEntry::new(notes[k].clone())
                 .pack()
-                .layout(vt, self.styles, self.regions.with_root(false))?
+                .layout(engine, self.styles, self.regions.with_root(false))?
                 .into_frames();
 
             // If the entries didn't fit, abort (to keep footnote and entry
@@ -649,8 +663,8 @@ impl FlowLayouter<'_> {
                     self.regions.size.y -= item.height();
                 }
 
-                // Undo Vt modifications.
-                *vt.locator = checkpoint;
+                // Undo locator modifications.
+                *engine.locator = checkpoint;
 
                 return Ok(false);
             }
@@ -659,8 +673,8 @@ impl FlowLayouter<'_> {
             for (i, frame) in frames.into_iter().enumerate() {
                 find_footnotes(notes, &frame);
                 if i > 0 {
-                    self.finish_region(vt)?;
-                    self.layout_footnote_separator(vt)?;
+                    self.finish_region(engine)?;
+                    self.layout_footnote_separator(engine)?;
                     self.regions.size.y -= self.footnote_config.gap;
                 }
                 self.regions.size.y -= frame.height();
@@ -682,12 +696,12 @@ impl FlowLayouter<'_> {
 
     /// Layout and save the footnote separator, typically a line.
     #[tracing::instrument(skip_all)]
-    fn layout_footnote_separator(&mut self, vt: &mut Vt) -> SourceResult<()> {
+    fn layout_footnote_separator(&mut self, engine: &mut Engine) -> SourceResult<()> {
         let expand = Axes::new(self.regions.expand.x, false);
         let pod = Regions::one(self.regions.base(), expand);
         let separator = &self.footnote_config.separator;
 
-        let mut frame = separator.layout(vt, self.styles, pod)?.into_frame();
+        let mut frame = separator.layout(engine, self.styles, pod)?.into_frame();
         frame.size_mut().y += self.footnote_config.clearance;
         frame.translate(Point::with_y(self.footnote_config.clearance));
 
diff --git a/crates/typst/src/layout/grid.rs b/crates/typst/src/layout/grid.rs
index cc7d1d25..606aa4a7 100644
--- a/crates/typst/src/layout/grid.rs
+++ b/crates/typst/src/layout/grid.rs
@@ -3,12 +3,13 @@ use std::num::NonZeroUsize;
 use smallvec::{smallvec, SmallVec};
 
 use crate::diag::{bail, SourceResult, StrResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, Array, Content, NativeElement, Resolve, StyleChain, Value,
 };
 use crate::layout::{
     Abs, Axes, Dir, Fr, Fragment, Frame, Layout, Length, Point, Regions, Rel, Size,
-    Sizing, Vt,
+    Sizing,
 };
 use crate::syntax::Span;
 use crate::text::TextElem;
@@ -128,7 +129,7 @@ impl Layout for GridElem {
     #[tracing::instrument(name = "GridElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -148,7 +149,7 @@ impl Layout for GridElem {
         );
 
         // Measure the columns and layout the grid row-by-row.
-        Ok(layouter.layout(vt)?.fragment)
+        Ok(layouter.layout(engine)?.fragment)
     }
 }
 
@@ -311,24 +312,24 @@ impl<'a> GridLayouter<'a> {
     }
 
     /// Determines the columns sizes and then layouts the grid row-by-row.
-    pub fn layout(mut self, vt: &mut Vt) -> SourceResult<GridLayout> {
-        self.measure_columns(vt)?;
+    pub fn layout(mut self, engine: &mut Engine) -> SourceResult<GridLayout> {
+        self.measure_columns(engine)?;
 
         for y in 0..self.rows.len() {
             // Skip to next region if current one is full, but only for content
             // rows, not for gutter rows.
             if self.regions.is_full() && (!self.has_gutter || y % 2 == 0) {
-                self.finish_region(vt)?;
+                self.finish_region(engine)?;
             }
 
             match self.rows[y] {
-                Sizing::Auto => self.layout_auto_row(vt, y)?,
-                Sizing::Rel(v) => self.layout_relative_row(vt, v, y)?,
+                Sizing::Auto => self.layout_auto_row(engine, y)?,
+                Sizing::Rel(v) => self.layout_relative_row(engine, v, y)?,
                 Sizing::Fr(v) => self.lrows.push(Row::Fr(v, y)),
             }
         }
 
-        self.finish_region(vt)?;
+        self.finish_region(engine)?;
 
         Ok(GridLayout {
             fragment: Fragment::frames(self.finished),
@@ -339,7 +340,7 @@ impl<'a> GridLayouter<'a> {
 
     /// Determine all column sizes.
     #[tracing::instrument(name = "GridLayouter::measure_columns", skip_all)]
-    fn measure_columns(&mut self, vt: &mut Vt) -> SourceResult<()> {
+    fn measure_columns(&mut self, engine: &mut Engine) -> SourceResult<()> {
         // Sum of sizes of resolved relative tracks.
         let mut rel = Abs::zero();
 
@@ -365,7 +366,7 @@ impl<'a> GridLayouter<'a> {
         let available = self.regions.size.x - rel;
         if available >= Abs::zero() {
             // Determine size of auto columns.
-            let (auto, count) = self.measure_auto_columns(vt, available)?;
+            let (auto, count) = self.measure_auto_columns(engine, available)?;
 
             // If there is remaining space, distribute it to fractional columns,
             // otherwise shrink auto columns.
@@ -386,7 +387,7 @@ impl<'a> GridLayouter<'a> {
     /// Measure the size that is available to auto columns.
     fn measure_auto_columns(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         available: Abs,
     ) -> SourceResult<(Abs, usize)> {
         let mut auto = Abs::zero();
@@ -413,7 +414,7 @@ impl<'a> GridLayouter<'a> {
 
                     let size = Size::new(available, height);
                     let pod = Regions::one(size, Axes::splat(false));
-                    let frame = cell.measure(vt, self.styles, pod)?.into_frame();
+                    let frame = cell.measure(engine, self.styles, pod)?.into_frame();
                     resolved.set_max(frame.width());
                 }
             }
@@ -474,14 +475,14 @@ impl<'a> GridLayouter<'a> {
 
     /// Layout a row with automatic height. Such a row may break across multiple
     /// regions.
-    fn layout_auto_row(&mut self, vt: &mut Vt, y: usize) -> SourceResult<()> {
+    fn layout_auto_row(&mut self, engine: &mut Engine, y: usize) -> SourceResult<()> {
         // Determine the size for each region of the row. If the first region
         // ends up empty for some column, skip the region and remeasure.
-        let mut resolved = match self.measure_auto_row(vt, y, true)? {
+        let mut resolved = match self.measure_auto_row(engine, y, true)? {
             Some(resolved) => resolved,
             None => {
-                self.finish_region(vt)?;
-                self.measure_auto_row(vt, y, false)?.unwrap()
+                self.finish_region(engine)?;
+                self.measure_auto_row(engine, y, false)?.unwrap()
             }
         };
 
@@ -492,7 +493,7 @@ impl<'a> GridLayouter<'a> {
 
         // Layout into a single region.
         if let &[first] = resolved.as_slice() {
-            let frame = self.layout_single_row(vt, first, y)?;
+            let frame = self.layout_single_row(engine, first, y)?;
             self.push_row(frame, y);
             return Ok(());
         }
@@ -510,12 +511,12 @@ impl<'a> GridLayouter<'a> {
         }
 
         // Layout into multiple regions.
-        let fragment = self.layout_multi_row(vt, &resolved, y)?;
+        let fragment = self.layout_multi_row(engine, &resolved, y)?;
         let len = fragment.len();
         for (i, frame) in fragment.into_iter().enumerate() {
             self.push_row(frame, y);
             if i + 1 < len {
-                self.finish_region(vt)?;
+                self.finish_region(engine)?;
             }
         }
 
@@ -526,7 +527,7 @@ impl<'a> GridLayouter<'a> {
     /// if `can_skip` is false.
     fn measure_auto_row(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         y: usize,
         can_skip: bool,
     ) -> SourceResult<Option<Vec<Abs>>> {
@@ -537,7 +538,7 @@ impl<'a> GridLayouter<'a> {
                 let mut pod = self.regions;
                 pod.size.x = rcol;
 
-                let frames = cell.measure(vt, self.styles, pod)?.into_frames();
+                let frames = cell.measure(engine, self.styles, pod)?.into_frames();
 
                 // Skip the first region if one cell in it is empty. Then,
                 // remeasure.
@@ -568,17 +569,17 @@ impl<'a> GridLayouter<'a> {
     /// multiple regions, but it may force a region break.
     fn layout_relative_row(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         v: Rel<Length>,
         y: usize,
     ) -> SourceResult<()> {
         let resolved = v.resolve(self.styles).relative_to(self.regions.base().y);
-        let frame = self.layout_single_row(vt, resolved, y)?;
+        let frame = self.layout_single_row(engine, resolved, y)?;
 
         // Skip to fitting region.
         let height = frame.height();
         while !self.regions.size.y.fits(height) && !self.regions.in_last() {
-            self.finish_region(vt)?;
+            self.finish_region(engine)?;
 
             // Don't skip multiple regions for gutter and don't push a row.
             if self.has_gutter && y % 2 == 1 {
@@ -594,7 +595,7 @@ impl<'a> GridLayouter<'a> {
     /// Layout a row with fixed height and return its frame.
     fn layout_single_row(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         height: Abs,
         y: usize,
     ) -> SourceResult<Frame> {
@@ -612,7 +613,7 @@ impl<'a> GridLayouter<'a> {
                 if self.rows[y] == Sizing::Auto {
                     pod.full = self.regions.full;
                 }
-                let frame = cell.layout(vt, self.styles, pod)?.into_frame();
+                let frame = cell.layout(engine, self.styles, pod)?.into_frame();
                 output.push_frame(pos, frame);
             }
 
@@ -625,7 +626,7 @@ impl<'a> GridLayouter<'a> {
     /// Layout a row spanning multiple regions.
     fn layout_multi_row(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         heights: &[Abs],
         y: usize,
     ) -> SourceResult<Fragment> {
@@ -648,7 +649,7 @@ impl<'a> GridLayouter<'a> {
                 pod.size.x = rcol;
 
                 // Push the layouted frames into the individual output frames.
-                let fragment = cell.layout(vt, self.styles, pod)?;
+                let fragment = cell.layout(engine, self.styles, pod)?;
                 for (output, frame) in outputs.iter_mut().zip(fragment) {
                     output.push_frame(pos, frame);
                 }
@@ -667,7 +668,7 @@ impl<'a> GridLayouter<'a> {
     }
 
     /// Finish rows for one region.
-    fn finish_region(&mut self, vt: &mut Vt) -> SourceResult<()> {
+    fn finish_region(&mut self, engine: &mut Engine) -> SourceResult<()> {
         // Determine the height of existing rows in the region.
         let mut used = Abs::zero();
         let mut fr = Fr::zero();
@@ -697,7 +698,7 @@ impl<'a> GridLayouter<'a> {
                 Row::Fr(v, y) => {
                     let remaining = self.regions.full - used;
                     let height = v.share(fr, remaining);
-                    (self.layout_single_row(vt, height, y)?, y)
+                    (self.layout_single_row(engine, height, y)?, y)
                 }
             };
 
diff --git a/crates/typst/src/layout/hide.rs b/crates/typst/src/layout/hide.rs
index b72f2ad2..50ce8467 100644
--- a/crates/typst/src/layout/hide.rs
+++ b/crates/typst/src/layout/hide.rs
@@ -1,9 +1,9 @@
 use smallvec::smallvec;
 
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{elem, Content, Show, StyleChain};
 use crate::introspection::{Meta, MetaElem};
-use crate::layout::Vt;
 
 /// Hides content without affecting layout.
 ///
@@ -26,7 +26,7 @@ pub struct HideElem {
 
 impl Show for HideElem {
     #[tracing::instrument(name = "HideElem::show", skip(self))]
-    fn show(&self, _: &mut Vt, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
         Ok(self.body().clone().styled(MetaElem::set_data(smallvec![Meta::Hide])))
     }
 }
diff --git a/crates/typst/src/layout/inline/mod.rs b/crates/typst/src/layout/inline/mod.rs
index 44b2e113..ba88f74e 100644
--- a/crates/typst/src/layout/inline/mod.rs
+++ b/crates/typst/src/layout/inline/mod.rs
@@ -11,12 +11,13 @@ use self::shaping::{
     END_PUNCT_PAT,
 };
 use crate::diag::{bail, SourceResult};
+use crate::engine::{Engine, Route};
 use crate::eval::Tracer;
 use crate::foundations::{Content, Resolve, Smart, StyleChain};
 use crate::introspection::{Introspector, Locator, MetaElem};
 use crate::layout::{
     Abs, AlignElem, Axes, BoxElem, Dir, Em, FixedAlign, Fr, Fragment, Frame, HElem,
-    Layout, Point, Regions, Size, Sizing, Spacing, Vt,
+    Layout, Point, Regions, Size, Sizing, Spacing,
 };
 use crate::math::EquationElem;
 use crate::model::{Linebreaks, ParElem};
@@ -30,7 +31,7 @@ use crate::World;
 /// Layout's content inline.
 pub(crate) fn layout_inline(
     children: &[Prehashed<Content>],
-    vt: &mut Vt,
+    engine: &mut Engine,
     styles: StyleChain,
     consecutive: bool,
     region: Size,
@@ -42,6 +43,7 @@ pub(crate) fn layout_inline(
         children: &[Prehashed<Content>],
         world: Tracked<dyn World + '_>,
         introspector: Tracked<Introspector>,
+        route: Tracked<Route>,
         locator: Tracked<Locator>,
         tracer: TrackedMut<Tracer>,
         styles: StyleChain,
@@ -50,7 +52,13 @@ pub(crate) fn layout_inline(
         expand: bool,
     ) -> SourceResult<Fragment> {
         let mut locator = Locator::chained(locator);
-        let mut vt = Vt { world, introspector, locator: &mut locator, tracer };
+        let mut engine = Engine {
+            world,
+            introspector,
+            route: Route::extend(route),
+            locator: &mut locator,
+            tracer,
+        };
 
         // Collect all text into one string for BiDi analysis.
         let (text, segments, spans) = collect(children, &styles, consecutive)?;
@@ -58,28 +66,29 @@ pub(crate) fn layout_inline(
         // Perform BiDi analysis and then prepare paragraph layout by building a
         // representation on which we can do line breaking without layouting
         // each and every line from scratch.
-        let p = prepare(&mut vt, children, &text, segments, spans, styles, region)?;
+        let p = prepare(&mut engine, children, &text, segments, spans, styles, region)?;
 
         // Break the paragraph into lines.
-        let lines = linebreak(&vt, &p, region.x - p.hang);
+        let lines = linebreak(&engine, &p, region.x - p.hang);
 
         // Stack the lines into one frame per region.
-        finalize(&mut vt, &p, &lines, region, expand)
+        finalize(&mut engine, &p, &lines, region, expand)
     }
 
     let fragment = cached(
         children,
-        vt.world,
-        vt.introspector,
-        vt.locator.track(),
-        TrackedMut::reborrow_mut(&mut vt.tracer),
+        engine.world,
+        engine.introspector,
+        engine.route.track(),
+        engine.locator.track(),
+        TrackedMut::reborrow_mut(&mut engine.tracer),
         styles,
         consecutive,
         region,
         expand,
     )?;
 
-    vt.locator.visit_frames(&fragment);
+    engine.locator.visit_frames(&fragment);
     Ok(fragment)
 }
 
@@ -520,7 +529,7 @@ fn collect<'a>(
 /// Prepare paragraph layout by shaping the whole paragraph and layouting all
 /// contained inline-level content.
 fn prepare<'a>(
-    vt: &mut Vt,
+    engine: &mut Engine,
     children: &'a [Prehashed<Content>],
     text: &'a str,
     segments: Vec<(Segment<'a>, StyleChain<'a>)>,
@@ -546,7 +555,7 @@ fn prepare<'a>(
         let end = cursor + segment.len();
         match segment {
             Segment::Text(_) => {
-                shape_range(&mut items, vt, &bidi, cursor..end, &spans, styles);
+                shape_range(&mut items, engine, &bidi, cursor..end, &spans, styles);
             }
             Segment::Spacing(spacing) => match spacing {
                 Spacing::Rel(v) => {
@@ -559,7 +568,7 @@ fn prepare<'a>(
             },
             Segment::Equation(equation) => {
                 let pod = Regions::one(region, Axes::splat(false));
-                let mut frame = equation.layout(vt, styles, pod)?.into_frame();
+                let mut frame = equation.layout(engine, styles, pod)?.into_frame();
                 frame.translate(Point::with_y(TextElem::baseline_in(styles)));
                 items.push(Item::Frame(frame));
             }
@@ -568,7 +577,7 @@ fn prepare<'a>(
                     items.push(Item::Fractional(v, Some((elem, styles))));
                 } else {
                     let pod = Regions::one(region, Axes::splat(false));
-                    let mut frame = elem.layout(vt, styles, pod)?.into_frame();
+                    let mut frame = elem.layout(engine, styles, pod)?.into_frame();
                     frame.translate(Point::with_y(TextElem::baseline_in(styles)));
                     items.push(Item::Frame(frame));
                 }
@@ -655,7 +664,7 @@ fn add_cjk_latin_spacing(items: &mut [Item]) {
 /// items for them.
 fn shape_range<'a>(
     items: &mut Vec<Item<'a>>,
-    vt: &Vt,
+    engine: &Engine,
     bidi: &BidiInfo<'a>,
     range: Range,
     spans: &SpanMapper,
@@ -666,8 +675,16 @@ fn shape_range<'a>(
     let region = TextElem::region_in(styles);
     let mut process = |range: Range, level: BidiLevel| {
         let dir = if level.is_ltr() { Dir::LTR } else { Dir::RTL };
-        let shaped =
-            shape(vt, range.start, &bidi.text[range], spans, styles, dir, lang, region);
+        let shaped = shape(
+            engine,
+            range.start,
+            &bidi.text[range],
+            spans,
+            styles,
+            dir,
+            lang,
+            region,
+        );
         items.push(Item::Text(shaped));
     };
 
@@ -732,7 +749,7 @@ fn shared_get<T: PartialEq>(
 }
 
 /// Find suitable linebreaks.
-fn linebreak<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<Line<'a>> {
+fn linebreak<'a>(engine: &Engine, p: &'a Preparation<'a>, width: Abs) -> Vec<Line<'a>> {
     let linebreaks = p.linebreaks.unwrap_or_else(|| {
         if p.justify {
             Linebreaks::Optimized
@@ -742,22 +759,26 @@ fn linebreak<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<Line<'a>> {
     });
 
     match linebreaks {
-        Linebreaks::Simple => linebreak_simple(vt, p, width),
-        Linebreaks::Optimized => linebreak_optimized(vt, p, width),
+        Linebreaks::Simple => linebreak_simple(engine, p, width),
+        Linebreaks::Optimized => linebreak_optimized(engine, p, width),
     }
 }
 
 /// Perform line breaking in simple first-fit style. This means that we build
 /// lines greedily, always taking the longest possible line. This may lead to
 /// very unbalanced line, but is fast and simple.
-fn linebreak_simple<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<Line<'a>> {
+fn linebreak_simple<'a>(
+    engine: &Engine,
+    p: &'a Preparation<'a>,
+    width: Abs,
+) -> Vec<Line<'a>> {
     let mut lines = Vec::with_capacity(16);
     let mut start = 0;
     let mut last = None;
 
     breakpoints(p, |end, breakpoint| {
         // Compute the line and its size.
-        let mut attempt = line(vt, p, start..end, breakpoint);
+        let mut attempt = line(engine, p, start..end, breakpoint);
 
         // If the line doesn't fit anymore, we push the last fitting attempt
         // into the stack and rebuild the line from the attempt's end. The
@@ -766,7 +787,7 @@ fn linebreak_simple<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<Line
             if let Some((last_attempt, last_end)) = last.take() {
                 lines.push(last_attempt);
                 start = last_end;
-                attempt = line(vt, p, start..end, breakpoint);
+                attempt = line(engine, p, start..end, breakpoint);
             }
         }
 
@@ -806,7 +827,11 @@ fn linebreak_simple<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<Line
 /// computed and stored in dynamic programming table) is minimal. The final
 /// result is simply the layout determined for the last breakpoint at the end of
 /// text.
-fn linebreak_optimized<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<Line<'a>> {
+fn linebreak_optimized<'a>(
+    engine: &Engine,
+    p: &'a Preparation<'a>,
+    width: Abs,
+) -> Vec<Line<'a>> {
     /// The cost of a line or paragraph layout.
     type Cost = f64;
 
@@ -829,7 +854,7 @@ fn linebreak_optimized<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<L
     let mut table = vec![Entry {
         pred: 0,
         total: 0.0,
-        line: line(vt, p, 0..0, Breakpoint::Mandatory),
+        line: line(engine, p, 0..0, Breakpoint::Mandatory),
     }];
 
     let em = p.size;
@@ -844,7 +869,7 @@ fn linebreak_optimized<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<L
             // Layout the line.
             let start = pred.line.end;
 
-            let attempt = line(vt, p, start..end, breakpoint);
+            let attempt = line(engine, p, start..end, breakpoint);
 
             // Determine how much the line's spaces would need to be stretched
             // to make it the desired width.
@@ -953,7 +978,7 @@ fn linebreak_optimized<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<L
 
 /// Create a line which spans the given range.
 fn line<'a>(
-    vt: &Vt,
+    engine: &Engine,
     p: &'a Preparation,
     mut range: Range,
     breakpoint: Breakpoint,
@@ -1016,9 +1041,9 @@ fn line<'a>(
         // are no other items in the line.
         if hyphen || start + shaped.text.len() > range.end || maybe_adjust_last_glyph {
             if hyphen || start < range.end || before.is_empty() {
-                let mut reshaped = shaped.reshape(vt, &p.spans, start..range.end);
+                let mut reshaped = shaped.reshape(engine, &p.spans, start..range.end);
                 if hyphen || shy {
-                    reshaped.push_hyphen(vt, p.fallback);
+                    reshaped.push_hyphen(engine, p.fallback);
                 }
 
                 if let Some(last_glyph) = reshaped.glyphs.last() {
@@ -1069,7 +1094,7 @@ fn line<'a>(
         if range.start + shaped.text.len() > end || maybe_adjust_first_glyph {
             // If the range is empty, we don't want to push an empty text item.
             if range.start < end {
-                let reshaped = shaped.reshape(vt, &p.spans, range.start..end);
+                let reshaped = shaped.reshape(engine, &p.spans, range.start..end);
                 width += reshaped.width;
                 first = Some(Item::Text(reshaped));
             }
@@ -1129,7 +1154,7 @@ fn line<'a>(
 
 /// Combine layouted lines into one frame per region.
 fn finalize(
-    vt: &mut Vt,
+    engine: &mut Engine,
     p: &Preparation,
     lines: &[Line],
     region: Size,
@@ -1150,7 +1175,7 @@ fn finalize(
     // Stack the lines into one frame per region.
     let mut frames: Vec<Frame> = lines
         .iter()
-        .map(|line| commit(vt, p, line, width, region.y))
+        .map(|line| commit(engine, p, line, width, region.y))
         .collect::<SourceResult<_>>()?;
 
     // Prevent orphans.
@@ -1181,7 +1206,7 @@ fn merge(first: &mut Frame, second: Frame, leading: Abs) {
 
 /// Commit to a line and build its frame.
 fn commit(
-    vt: &mut Vt,
+    engine: &mut Engine,
     p: &Preparation,
     line: &Line,
     width: Abs,
@@ -1276,7 +1301,7 @@ fn commit(
                 if let Some((elem, styles)) = elem {
                     let region = Size::new(amount, full);
                     let pod = Regions::one(region, Axes::new(true, false));
-                    let mut frame = elem.layout(vt, *styles, pod)?.into_frame();
+                    let mut frame = elem.layout(engine, *styles, pod)?.into_frame();
                     frame.translate(Point::with_y(TextElem::baseline_in(*styles)));
                     push(&mut offset, frame);
                 } else {
@@ -1284,7 +1309,8 @@ fn commit(
                 }
             }
             Item::Text(shaped) => {
-                let frame = shaped.build(vt, justification_ratio, extra_justification);
+                let frame =
+                    shaped.build(engine, justification_ratio, extra_justification);
                 push(&mut offset, frame);
             }
             Item::Frame(frame) | Item::Meta(frame) => {
diff --git a/crates/typst/src/layout/inline/shaping.rs b/crates/typst/src/layout/inline/shaping.rs
index 69e70967..08a617dc 100644
--- a/crates/typst/src/layout/inline/shaping.rs
+++ b/crates/typst/src/layout/inline/shaping.rs
@@ -9,8 +9,9 @@ use rustybuzz::{Tag, UnicodeBuffer};
 use unicode_script::{Script, UnicodeScript};
 
 use super::SpanMapper;
+use crate::engine::Engine;
 use crate::foundations::StyleChain;
-use crate::layout::{Abs, Dir, Em, Frame, FrameItem, Point, Size, Vt};
+use crate::layout::{Abs, Dir, Em, Frame, FrameItem, Point, Size};
 use crate::syntax::Span;
 use crate::text::{
     decorate, families, features, variant, Font, FontVariant, Glyph, Lang, Region,
@@ -213,11 +214,11 @@ impl<'a> ShapedText<'a> {
     /// [justifiable glyph](ShapedGlyph::is_justifiable) will get.
     pub fn build(
         &self,
-        vt: &Vt,
+        engine: &Engine,
         justification_ratio: f64,
         extra_justification: Abs,
     ) -> Frame {
-        let (top, bottom) = self.measure(vt);
+        let (top, bottom) = self.measure(engine);
         let size = Size::new(self.width, top + bottom);
 
         let mut offset = Abs::zero();
@@ -307,7 +308,7 @@ impl<'a> ShapedText<'a> {
     }
 
     /// Measure the top and bottom extent of this text.
-    fn measure(&self, vt: &Vt) -> (Abs, Abs) {
+    fn measure(&self, engine: &Engine) -> (Abs, Abs) {
         let mut top = Abs::zero();
         let mut bottom = Abs::zero();
 
@@ -323,7 +324,7 @@ impl<'a> ShapedText<'a> {
         if self.glyphs.is_empty() {
             // When there are no glyphs, we just use the vertical metrics of the
             // first available font.
-            let world = vt.world;
+            let world = engine.world;
             for family in families(self.styles) {
                 if let Some(font) = world
                     .book()
@@ -387,7 +388,7 @@ impl<'a> ShapedText<'a> {
     /// The text `range` is relative to the whole paragraph.
     pub fn reshape(
         &'a self,
-        vt: &Vt,
+        engine: &Engine,
         spans: &SpanMapper,
         text_range: Range<usize>,
     ) -> ShapedText<'a> {
@@ -409,7 +410,7 @@ impl<'a> ShapedText<'a> {
             }
         } else {
             shape(
-                vt,
+                engine,
                 text_range.start,
                 text,
                 spans,
@@ -422,8 +423,8 @@ impl<'a> ShapedText<'a> {
     }
 
     /// Push a hyphen to end of the text.
-    pub fn push_hyphen(&mut self, vt: &Vt, fallback: bool) {
-        let world = vt.world;
+    pub fn push_hyphen(&mut self, engine: &Engine, fallback: bool) {
+        let world = engine.world;
         let book = world.book();
         let fallback_func = if fallback {
             Some(|| book.select_fallback(None, self.variant, "-"))
@@ -553,7 +554,7 @@ impl Debug for ShapedText<'_> {
 
 /// Holds shaping results and metadata common to all shaped segments.
 struct ShapingContext<'a, 'v> {
-    vt: &'a Vt<'v>,
+    engine: &'a Engine<'v>,
     spans: &'a SpanMapper,
     glyphs: Vec<ShapedGlyph>,
     used: Vec<Font>,
@@ -568,7 +569,7 @@ struct ShapingContext<'a, 'v> {
 /// Shape text into [`ShapedText`].
 #[allow(clippy::too_many_arguments)]
 pub(super) fn shape<'a>(
-    vt: &Vt,
+    engine: &Engine,
     base: usize,
     text: &'a str,
     spans: &SpanMapper,
@@ -579,7 +580,7 @@ pub(super) fn shape<'a>(
 ) -> ShapedText<'a> {
     let size = TextElem::size_in(styles);
     let mut ctx = ShapingContext {
-        vt,
+        engine,
         spans,
         size,
         glyphs: vec![],
@@ -630,7 +631,7 @@ fn shape_segment<'a>(
     }
 
     // Find the next available family.
-    let world = ctx.vt.world;
+    let world = ctx.engine.world;
     let book = world.book();
     let mut selection = families.find_map(|family| {
         book.select(family, ctx.variant)
diff --git a/crates/typst/src/layout/layout.rs b/crates/typst/src/layout/layout.rs
index e2c0fa2b..45b7c54a 100644
--- a/crates/typst/src/layout/layout.rs
+++ b/crates/typst/src/layout/layout.rs
@@ -1,6 +1,7 @@
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{dict, elem, func, Content, Func, NativeElement, StyleChain};
-use crate::layout::{Fragment, Layout, Regions, Size, Vt};
+use crate::layout::{Fragment, Layout, Regions, Size};
 
 /// Provides access to the current outer container's (or page's, if none) size
 /// (width and height).
@@ -68,7 +69,7 @@ impl Layout for LayoutElem {
     #[tracing::instrument(name = "LayoutElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -77,8 +78,8 @@ impl Layout for LayoutElem {
         let Size { x, y } = regions.base();
         let result = self
             .func()
-            .call_vt(vt, [dict! { "width" => x, "height" => y }])?
+            .call(engine, [dict! { "width" => x, "height" => y }])?
             .display();
-        result.layout(vt, styles, regions)
+        result.layout(engine, styles, regions)
     }
 }
diff --git a/crates/typst/src/layout/measure.rs b/crates/typst/src/layout/measure.rs
index 2b82c58b..1aff7ad4 100644
--- a/crates/typst/src/layout/measure.rs
+++ b/crates/typst/src/layout/measure.rs
@@ -1,5 +1,5 @@
 use crate::diag::SourceResult;
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{dict, func, Content, Dict, StyleChain, Styles};
 use crate::layout::{Abs, Axes, Layout, Regions, Size};
 
@@ -41,8 +41,8 @@ use crate::layout::{Abs, Axes, Layout, Regions, Size};
 /// `height`, both of type [`length`]($length).
 #[func]
 pub fn measure(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// The content whose size to measure.
     content: Content,
     /// The styles with which to layout the content.
@@ -50,7 +50,7 @@ pub fn measure(
 ) -> SourceResult<Dict> {
     let pod = Regions::one(Axes::splat(Abs::inf()), Axes::splat(false));
     let styles = StyleChain::new(&styles);
-    let frame = content.measure(&mut vm.vt, styles, pod)?.into_frame();
+    let frame = content.measure(engine, styles, pod)?.into_frame();
     let Size { x, y } = frame.size();
     Ok(dict! { "width" => x, "height" => y })
 }
diff --git a/crates/typst/src/layout/mod.rs b/crates/typst/src/layout/mod.rs
index f291cfe9..1e1bcf9b 100644
--- a/crates/typst/src/layout/mod.rs
+++ b/crates/typst/src/layout/mod.rs
@@ -34,7 +34,6 @@ mod size;
 mod spacing;
 mod stack;
 mod transform;
-mod vt;
 
 pub use self::abs::*;
 pub use self::align::*;
@@ -67,13 +66,13 @@ pub use self::size::*;
 pub use self::spacing::*;
 pub use self::stack::*;
 pub use self::transform::*;
-pub use self::vt::*;
 
 pub(crate) use self::inline::*;
 
 use comemo::{Tracked, TrackedMut};
 
-use crate::diag::SourceResult;
+use crate::diag::{bail, error, SourceResult};
+use crate::engine::{Engine, Route};
 use crate::eval::Tracer;
 use crate::foundations::{category, Category, Content, Scope, StyleChain};
 use crate::introspection::{Introspector, Locator};
@@ -122,7 +121,11 @@ pub fn define(global: &mut Scope) {
 /// Root-level layout.
 pub trait LayoutRoot {
     /// Layout into one frame per page.
-    fn layout_root(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Document>;
+    fn layout_root(
+        &self,
+        engine: &mut Engine,
+        styles: StyleChain,
+    ) -> SourceResult<Document>;
 }
 
 /// Layout into regions.
@@ -130,7 +133,7 @@ pub trait Layout {
     /// Layout into one frame per region.
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment>;
@@ -142,50 +145,64 @@ pub trait Layout {
     #[tracing::instrument(name = "Layout::measure", skip_all)]
     fn measure(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
-        let mut locator = Locator::chained(vt.locator.track());
-        let mut vt = Vt {
-            world: vt.world,
-            introspector: vt.introspector,
+        let mut locator = Locator::chained(engine.locator.track());
+        let mut engine = Engine {
+            world: engine.world,
+            route: engine.route.clone(),
+            introspector: engine.introspector,
             locator: &mut locator,
-            tracer: TrackedMut::reborrow_mut(&mut vt.tracer),
+            tracer: TrackedMut::reborrow_mut(&mut engine.tracer),
         };
-        self.layout(&mut vt, styles, regions)
+        self.layout(&mut engine, styles, regions)
     }
 }
 
 impl LayoutRoot for Content {
     #[tracing::instrument(name = "Content::layout_root", skip_all)]
-    fn layout_root(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Document> {
+    fn layout_root(
+        &self,
+        engine: &mut Engine,
+        styles: StyleChain,
+    ) -> SourceResult<Document> {
         #[comemo::memoize]
         fn cached(
             content: &Content,
             world: Tracked<dyn World + '_>,
             introspector: Tracked<Introspector>,
+            route: Tracked<Route>,
             locator: Tracked<Locator>,
             tracer: TrackedMut<Tracer>,
             styles: StyleChain,
         ) -> SourceResult<Document> {
             let mut locator = Locator::chained(locator);
-            let mut vt = Vt { world, introspector, locator: &mut locator, tracer };
+            let mut engine = Engine {
+                world,
+                introspector,
+                route: Route::extend(route),
+                locator: &mut locator,
+                tracer,
+            };
             let scratch = Scratch::default();
-            let (realized, styles) = realize_root(&mut vt, &scratch, content, styles)?;
+            let (realized, styles) =
+                realize_root(&mut engine, &scratch, content, styles)?;
             realized
                 .with::<dyn LayoutRoot>()
                 .unwrap()
-                .layout_root(&mut vt, styles)
+                .layout_root(&mut engine, styles)
         }
 
         tracing::info!("Starting layout");
         cached(
             self,
-            vt.world,
-            vt.introspector,
-            vt.locator.track(),
-            TrackedMut::reborrow_mut(&mut vt.tracer),
+            engine.world,
+            engine.introspector,
+            engine.route.track(),
+            engine.locator.track(),
+            TrackedMut::reborrow_mut(&mut engine.tracer),
             styles,
         )
     }
@@ -195,7 +212,7 @@ impl Layout for Content {
     #[tracing::instrument(name = "Content::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -205,34 +222,49 @@ impl Layout for Content {
             content: &Content,
             world: Tracked<dyn World + '_>,
             introspector: Tracked<Introspector>,
+            route: Tracked<Route>,
             locator: Tracked<Locator>,
             tracer: TrackedMut<Tracer>,
             styles: StyleChain,
             regions: Regions,
         ) -> SourceResult<Fragment> {
             let mut locator = Locator::chained(locator);
-            let mut vt = Vt { world, introspector, locator: &mut locator, tracer };
+            let mut engine = Engine {
+                world,
+                introspector,
+                route: Route::extend(route),
+                locator: &mut locator,
+                tracer,
+            };
+
+            if engine.route.exceeding() {
+                bail!(error!(content.span(), "maximum layout depth exceeded")
+                    .with_hint("try to reduce the amount of nesting in your layout"));
+            }
+
             let scratch = Scratch::default();
-            let (realized, styles) = realize_block(&mut vt, &scratch, content, styles)?;
+            let (realized, styles) =
+                realize_block(&mut engine, &scratch, content, styles)?;
             realized
                 .with::<dyn Layout>()
                 .unwrap()
-                .layout(&mut vt, styles, regions)
+                .layout(&mut engine, styles, regions)
         }
 
         tracing::info!("Layouting `Content`");
 
         let fragment = cached(
             self,
-            vt.world,
-            vt.introspector,
-            vt.locator.track(),
-            TrackedMut::reborrow_mut(&mut vt.tracer),
+            engine.world,
+            engine.introspector,
+            engine.route.track(),
+            engine.locator.track(),
+            TrackedMut::reborrow_mut(&mut engine.tracer),
             styles,
             regions,
         )?;
 
-        vt.locator.visit_frames(&fragment);
+        engine.locator.visit_frames(&fragment);
         Ok(fragment)
     }
 }
diff --git a/crates/typst/src/layout/pad.rs b/crates/typst/src/layout/pad.rs
index f5762409..35dfd0b4 100644
--- a/crates/typst/src/layout/pad.rs
+++ b/crates/typst/src/layout/pad.rs
@@ -1,8 +1,7 @@
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{elem, Content, Resolve, StyleChain};
-use crate::layout::{
-    Abs, Fragment, Layout, Length, Point, Regions, Rel, Sides, Size, Vt,
-};
+use crate::layout::{Abs, Fragment, Layout, Length, Point, Regions, Rel, Sides, Size};
 
 /// Adds spacing around content.
 ///
@@ -63,7 +62,7 @@ impl Layout for PadElem {
     #[tracing::instrument(name = "PadElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -78,7 +77,7 @@ impl Layout for PadElem {
         let mut backlog = vec![];
         let padding = sides.resolve(styles);
         let pod = regions.map(&mut backlog, |size| shrink(size, padding));
-        let mut fragment = self.body().layout(vt, styles, pod)?;
+        let mut fragment = self.body().layout(engine, styles, pod)?;
 
         for frame in &mut fragment {
             // Apply the padding inversely such that the grown size padded
diff --git a/crates/typst/src/layout/page.rs b/crates/typst/src/layout/page.rs
index 411f9769..96e6d96a 100644
--- a/crates/typst/src/layout/page.rs
+++ b/crates/typst/src/layout/page.rs
@@ -4,6 +4,7 @@ use std::ptr;
 use std::str::FromStr;
 
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, AutoValue, Cast, Content, Dict, Fold, Func, NativeElement, Resolve,
     Smart, StyleChain, Value,
@@ -11,7 +12,7 @@ use crate::foundations::{
 use crate::introspection::{Counter, CounterKey, ManualPageCounter, Meta};
 use crate::layout::{
     Abs, Align, AlignElem, Axes, ColumnsElem, Dir, Fragment, Frame, HAlign, Layout,
-    Length, Point, Ratio, Regions, Rel, Sides, Size, VAlign, Vt,
+    Length, Point, Ratio, Regions, Rel, Sides, Size, VAlign,
 };
 
 use crate::model::Numbering;
@@ -342,7 +343,7 @@ impl PageElem {
     #[tracing::instrument(skip_all)]
     pub fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         page_counter: &mut ManualPageCounter,
         extend_to: Option<Parity>,
@@ -393,7 +394,7 @@ impl PageElem {
         regions.root = true;
 
         // Layout the child.
-        let mut frames = child.layout(vt, styles, regions)?.into_frames();
+        let mut frames = child.layout(engine, styles, regions)?.into_frames();
 
         // Align the child to the pagebreak's parity.
         // Check for page count after adding the pending frames
@@ -496,7 +497,7 @@ impl PageElem {
                 let sub = content
                     .clone()
                     .styled(AlignElem::set_alignment(align))
-                    .layout(vt, styles, pod)?
+                    .layout(engine, styles, pod)?
                     .into_frame();
 
                 if ptr::eq(marginal, &header) || ptr::eq(marginal, &background) {
@@ -510,7 +511,7 @@ impl PageElem {
                 frame.fill(fill.clone());
             }
 
-            page_counter.visit(vt, frame)?;
+            page_counter.visit(engine, frame)?;
 
             // Add a PDF page label if there is a numbering.
             if let Some(num) = numbering {
@@ -675,10 +676,14 @@ pub enum Marginal {
 
 impl Marginal {
     /// Resolve the marginal based on the page number.
-    pub fn resolve(&self, vt: &mut Vt, page: usize) -> SourceResult<Cow<'_, Content>> {
+    pub fn resolve(
+        &self,
+        engine: &mut Engine,
+        page: usize,
+    ) -> SourceResult<Cow<'_, Content>> {
         Ok(match self {
             Self::Content(content) => Cow::Borrowed(content),
-            Self::Func(func) => Cow::Owned(func.call_vt(vt, [page])?.display()),
+            Self::Func(func) => Cow::Owned(func.call(engine, [page])?.display()),
         })
     }
 }
diff --git a/crates/typst/src/layout/place.rs b/crates/typst/src/layout/place.rs
index 537b47ed..3c0012aa 100644
--- a/crates/typst/src/layout/place.rs
+++ b/crates/typst/src/layout/place.rs
@@ -1,10 +1,9 @@
 use crate::diag::{bail, At, Hint, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     elem, Behave, Behaviour, Content, NativeElement, Smart, StyleChain,
 };
-use crate::layout::{
-    Align, Axes, Em, Fragment, Layout, Length, Regions, Rel, VAlign, Vt,
-};
+use crate::layout::{Align, Axes, Em, Fragment, Layout, Length, Regions, Rel, VAlign};
 
 /// Places content at an absolute position.
 ///
@@ -91,7 +90,7 @@ impl Layout for PlaceElem {
     #[tracing::instrument(name = "PlaceElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -118,7 +117,7 @@ impl Layout for PlaceElem {
             .aligned(alignment.unwrap_or_else(|| Align::CENTER));
 
         let pod = Regions::one(base, Axes::splat(false));
-        let frame = child.layout(vt, styles, pod)?.into_frame();
+        let frame = child.layout(engine, styles, pod)?.into_frame();
         Ok(Fragment::frame(frame))
     }
 }
diff --git a/crates/typst/src/layout/repeat.rs b/crates/typst/src/layout/repeat.rs
index 29e34e18..c733ea7d 100644
--- a/crates/typst/src/layout/repeat.rs
+++ b/crates/typst/src/layout/repeat.rs
@@ -1,7 +1,8 @@
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{elem, Content, NativeElement, Resolve, StyleChain};
 use crate::layout::{
-    Abs, AlignElem, Axes, Fragment, Frame, Layout, Point, Regions, Size, Vt,
+    Abs, AlignElem, Axes, Fragment, Frame, Layout, Point, Regions, Size,
 };
 use crate::util::Numeric;
 
@@ -37,12 +38,12 @@ impl Layout for RepeatElem {
     #[tracing::instrument(name = "RepeatElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
         let pod = Regions::one(regions.size, Axes::new(false, false));
-        let piece = self.body().layout(vt, styles, pod)?.into_frame();
+        let piece = self.body().layout(engine, styles, pod)?.into_frame();
         let align = AlignElem::alignment_in(styles).resolve(styles);
 
         let fill = regions.size.x;
diff --git a/crates/typst/src/layout/stack.rs b/crates/typst/src/layout/stack.rs
index e4dd029a..fe36cc63 100644
--- a/crates/typst/src/layout/stack.rs
+++ b/crates/typst/src/layout/stack.rs
@@ -1,10 +1,11 @@
 use std::fmt::{self, Debug, Formatter};
 
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{cast, elem, Content, Resolve, StyleChain};
 use crate::layout::{
     Abs, AlignElem, Axes, Axis, Dir, FixedAlign, Fr, Fragment, Frame, Layout, Point,
-    Regions, Size, Spacing, Vt,
+    Regions, Size, Spacing,
 };
 use crate::util::{Get, Numeric};
 
@@ -54,7 +55,7 @@ impl Layout for StackElem {
     #[tracing::instrument(name = "StackElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -75,7 +76,7 @@ impl Layout for StackElem {
                         layouter.layout_spacing(kind);
                     }
 
-                    layouter.layout_block(vt, block, styles)?;
+                    layouter.layout_block(engine, block, styles)?;
                     deferred = spacing;
                 }
             }
@@ -199,7 +200,7 @@ impl<'a> StackLayouter<'a> {
     #[tracing::instrument(name = "StackLayouter::layout_block", skip_all)]
     fn layout_block(
         &mut self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         block: &Content,
         styles: StyleChain,
     ) -> SourceResult<()> {
@@ -217,7 +218,7 @@ impl<'a> StackLayouter<'a> {
         }
         .resolve(styles);
 
-        let fragment = block.layout(vt, styles, self.regions)?;
+        let fragment = block.layout(engine, styles, self.regions)?;
         let len = fragment.len();
         for (i, frame) in fragment.into_iter().enumerate() {
             // Grow our size, shrink the region and save the frame for later.
diff --git a/crates/typst/src/layout/transform.rs b/crates/typst/src/layout/transform.rs
index 51cc5d54..bfc35825 100644
--- a/crates/typst/src/layout/transform.rs
+++ b/crates/typst/src/layout/transform.rs
@@ -1,8 +1,9 @@
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{elem, Content, Resolve, StyleChain};
 use crate::layout::{
     Abs, Align, Angle, Axes, FixedAlign, Fragment, HAlign, Layout, Length, Ratio,
-    Regions, Rel, VAlign, Vt,
+    Regions, Rel, VAlign,
 };
 
 /// Moves content without affecting layout.
@@ -40,12 +41,12 @@ impl Layout for MoveElem {
     #[tracing::instrument(name = "MoveElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
         let pod = Regions::one(regions.base(), Axes::splat(false));
-        let mut frame = self.body().layout(vt, styles, pod)?.into_frame();
+        let mut frame = self.body().layout(engine, styles, pod)?.into_frame();
         let delta = Axes::new(self.dx(styles), self.dy(styles)).resolve(styles);
         let delta = delta.zip_map(regions.base(), Rel::relative_to);
         frame.translate(delta.to_point());
@@ -106,12 +107,12 @@ impl Layout for RotateElem {
     #[tracing::instrument(name = "RotateElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
         let pod = Regions::one(regions.base(), Axes::splat(false));
-        let mut frame = self.body().layout(vt, styles, pod)?.into_frame();
+        let mut frame = self.body().layout(engine, styles, pod)?.into_frame();
         let Axes { x, y } = self
             .origin(styles)
             .resolve(styles)
@@ -171,12 +172,12 @@ impl Layout for ScaleElem {
     #[tracing::instrument(name = "ScaleElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
         let pod = Regions::one(regions.base(), Axes::splat(false));
-        let mut frame = self.body().layout(vt, styles, pod)?.into_frame();
+        let mut frame = self.body().layout(engine, styles, pod)?.into_frame();
         let Axes { x, y } = self
             .origin(styles)
             .resolve(styles)
diff --git a/crates/typst/src/layout/vt.rs b/crates/typst/src/layout/vt.rs
deleted file mode 100644
index 78b8c511..00000000
--- a/crates/typst/src/layout/vt.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use comemo::{Tracked, TrackedMut};
-
-use crate::diag::SourceResult;
-use crate::eval::Tracer;
-use crate::introspection::{Introspector, Locator};
-use crate::World;
-
-/// A virtual typesetter.
-///
-/// Holds the state needed during compilation.
-pub struct Vt<'a> {
-    /// The compilation environment.
-    pub world: Tracked<'a, dyn World + 'a>,
-    /// Provides access to information about the document.
-    pub introspector: Tracked<'a, Introspector>,
-    /// Provides stable identities to elements.
-    pub locator: &'a mut Locator<'a>,
-    /// The tracer for inspection of the values an expression produces.
-    pub tracer: TrackedMut<'a, Tracer>,
-}
-
-impl Vt<'_> {
-    /// Perform a fallible operation that does not immediately terminate further
-    /// execution. Instead it produces a delayed error that is only promoted to
-    /// a fatal one if it remains at the end of the introspection loop.
-    pub fn delayed<F, T>(&mut self, f: F) -> T
-    where
-        F: FnOnce(&mut Self) -> SourceResult<T>,
-        T: Default,
-    {
-        match f(self) {
-            Ok(value) => value,
-            Err(errors) => {
-                self.tracer.delay(errors);
-                T::default()
-            }
-        }
-    }
-}
diff --git a/crates/typst/src/lib.rs b/crates/typst/src/lib.rs
index 8d0001c8..52634d45 100644
--- a/crates/typst/src/lib.rs
+++ b/crates/typst/src/lib.rs
@@ -40,6 +40,7 @@ extern crate self as typst;
 #[macro_use]
 pub mod util;
 pub mod diag;
+pub mod engine;
 pub mod eval;
 pub mod foundations;
 pub mod introspection;
@@ -62,12 +63,13 @@ use comemo::{Prehashed, Track, Tracked, Validate};
 use ecow::{EcoString, EcoVec};
 
 use crate::diag::{warning, FileResult, SourceDiagnostic, SourceResult};
-use crate::eval::{Route, Tracer};
+use crate::engine::{Engine, Route};
+use crate::eval::Tracer;
 use crate::foundations::{
     Array, Bytes, Content, Datetime, Module, Scope, StyleChain, Styles,
 };
 use crate::introspection::{Introspector, Locator};
-use crate::layout::{Align, Dir, LayoutRoot, Vt};
+use crate::layout::{Align, Dir, LayoutRoot};
 use crate::model::Document;
 use crate::syntax::{FileId, PackageSpec, Source, Span};
 use crate::text::{Font, FontBook};
@@ -122,15 +124,17 @@ fn typeset(
 
         let constraint = <Introspector as Validate>::Constraint::new();
         let mut locator = Locator::new();
-        let mut vt = Vt {
+        let mut engine = Engine {
             world,
+            route: Route::default(),
             tracer: tracer.track_mut(),
             locator: &mut locator,
             introspector: introspector.track_with(&constraint),
         };
 
         // Layout!
-        document = content.layout_root(&mut vt, styles)?;
+        document = content.layout_root(&mut engine, styles)?;
+
         introspector = Introspector::new(&document.pages);
         iter += 1;
 
diff --git a/crates/typst/src/loading/cbor.rs b/crates/typst/src/loading/cbor.rs
index a1189dbe..ddf559f3 100644
--- a/crates/typst/src/loading/cbor.rs
+++ b/crates/typst/src/loading/cbor.rs
@@ -1,7 +1,7 @@
 use ecow::{eco_format, EcoString};
 
 use crate::diag::{At, SourceResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{func, scope, Bytes, Value};
 use crate::syntax::Spanned;
 use crate::World;
@@ -16,14 +16,14 @@ use crate::World;
 /// whether they are whole numbers.
 #[func(scope, title = "CBOR")]
 pub fn cbor(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// Path to a CBOR file.
     path: Spanned<EcoString>,
 ) -> SourceResult<Value> {
     let Spanned { v: path, span } = path;
-    let id = vm.resolve_path(&path).at(span)?;
-    let data = vm.world().file(id).at(span)?;
+    let id = span.resolve_path(&path).at(span)?;
+    let data = engine.world.file(id).at(span)?;
     cbor::decode(Spanned::new(data, span))
 }
 
diff --git a/crates/typst/src/loading/csv.rs b/crates/typst/src/loading/csv.rs
index e195f190..0d009560 100644
--- a/crates/typst/src/loading/csv.rs
+++ b/crates/typst/src/loading/csv.rs
@@ -1,7 +1,7 @@
 use ecow::{eco_format, EcoString};
 
 use crate::diag::{bail, At, SourceResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{cast, func, scope, Array, IntoValue, Value};
 use crate::loading::Readable;
 use crate::syntax::Spanned;
@@ -26,8 +26,8 @@ use crate::World;
 /// ```
 #[func(scope, title = "CSV")]
 pub fn csv(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// Path to a CSV file.
     path: Spanned<EcoString>,
     /// The delimiter that separates columns in the CSV file.
@@ -37,8 +37,8 @@ pub fn csv(
     delimiter: Delimiter,
 ) -> SourceResult<Array> {
     let Spanned { v: path, span } = path;
-    let id = vm.resolve_path(&path).at(span)?;
-    let data = vm.world().file(id).at(span)?;
+    let id = span.resolve_path(&path).at(span)?;
+    let data = engine.world.file(id).at(span)?;
     self::csv::decode(Spanned::new(Readable::Bytes(data), span), delimiter)
 }
 
diff --git a/crates/typst/src/loading/json.rs b/crates/typst/src/loading/json.rs
index cf209971..aae1f4ad 100644
--- a/crates/typst/src/loading/json.rs
+++ b/crates/typst/src/loading/json.rs
@@ -1,7 +1,7 @@
 use ecow::{eco_format, EcoString};
 
 use crate::diag::{At, SourceResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{func, scope, Str, Value};
 use crate::loading::Readable;
 use crate::syntax::Spanned;
@@ -46,14 +46,14 @@ use crate::World;
 /// ```
 #[func(scope, title = "JSON")]
 pub fn json(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// Path to a JSON file.
     path: Spanned<EcoString>,
 ) -> SourceResult<Value> {
     let Spanned { v: path, span } = path;
-    let id = vm.resolve_path(&path).at(span)?;
-    let data = vm.world().file(id).at(span)?;
+    let id = span.resolve_path(&path).at(span)?;
+    let data = engine.world.file(id).at(span)?;
     json::decode(Spanned::new(Readable::Bytes(data), span))
 }
 
diff --git a/crates/typst/src/loading/read.rs b/crates/typst/src/loading/read.rs
index 49a86699..50772bee 100644
--- a/crates/typst/src/loading/read.rs
+++ b/crates/typst/src/loading/read.rs
@@ -1,7 +1,7 @@
 use ecow::EcoString;
 
 use crate::diag::{At, SourceResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{func, Cast};
 use crate::loading::Readable;
 use crate::syntax::Spanned;
@@ -24,8 +24,8 @@ use crate::World;
 /// ```
 #[func]
 pub fn read(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// Path to a file.
     path: Spanned<EcoString>,
     /// The encoding to read the file with.
@@ -36,8 +36,8 @@ pub fn read(
     encoding: Option<Encoding>,
 ) -> SourceResult<Readable> {
     let Spanned { v: path, span } = path;
-    let id = vm.resolve_path(&path).at(span)?;
-    let data = vm.world().file(id).at(span)?;
+    let id = span.resolve_path(&path).at(span)?;
+    let data = engine.world.file(id).at(span)?;
     Ok(match encoding {
         None => Readable::Bytes(data),
         Some(Encoding::Utf8) => Readable::Str(
diff --git a/crates/typst/src/loading/toml.rs b/crates/typst/src/loading/toml.rs
index a4388f74..6884e6fe 100644
--- a/crates/typst/src/loading/toml.rs
+++ b/crates/typst/src/loading/toml.rs
@@ -1,7 +1,7 @@
 use ecow::{eco_format, EcoString};
 
 use crate::diag::{At, SourceResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{func, scope, Str, Value};
 use crate::loading::Readable;
 use crate::syntax::{is_newline, Spanned};
@@ -29,14 +29,14 @@ use crate::World;
 /// ```
 #[func(scope, title = "TOML")]
 pub fn toml(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// Path to a TOML file.
     path: Spanned<EcoString>,
 ) -> SourceResult<Value> {
     let Spanned { v: path, span } = path;
-    let id = vm.resolve_path(&path).at(span)?;
-    let data = vm.world().file(id).at(span)?;
+    let id = span.resolve_path(&path).at(span)?;
+    let data = engine.world.file(id).at(span)?;
     toml::decode(Spanned::new(Readable::Bytes(data), span))
 }
 
diff --git a/crates/typst/src/loading/xml.rs b/crates/typst/src/loading/xml.rs
index 73aeb32a..338b2f30 100644
--- a/crates/typst/src/loading/xml.rs
+++ b/crates/typst/src/loading/xml.rs
@@ -1,7 +1,7 @@
 use ecow::EcoString;
 
 use crate::diag::{format_xml_like_error, At, FileError, SourceResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{dict, func, scope, Array, Dict, IntoValue, Str, Value};
 use crate::loading::Readable;
 use crate::syntax::Spanned;
@@ -57,14 +57,14 @@ use crate::World;
 /// ```
 #[func(scope, title = "XML")]
 pub fn xml(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// Path to an XML file.
     path: Spanned<EcoString>,
 ) -> SourceResult<Value> {
     let Spanned { v: path, span } = path;
-    let id = vm.resolve_path(&path).at(span)?;
-    let data = vm.world().file(id).at(span)?;
+    let id = span.resolve_path(&path).at(span)?;
+    let data = engine.world.file(id).at(span)?;
     xml::decode(Spanned::new(Readable::Bytes(data), span))
 }
 
diff --git a/crates/typst/src/loading/yaml.rs b/crates/typst/src/loading/yaml.rs
index 03dd2a2c..501e3066 100644
--- a/crates/typst/src/loading/yaml.rs
+++ b/crates/typst/src/loading/yaml.rs
@@ -1,7 +1,7 @@
 use ecow::{eco_format, EcoString};
 
 use crate::diag::{At, SourceResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{func, scope, Str, Value};
 use crate::loading::Readable;
 use crate::syntax::Spanned;
@@ -38,14 +38,14 @@ use crate::World;
 /// ```
 #[func(scope, title = "YAML")]
 pub fn yaml(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// Path to a YAML file.
     path: Spanned<EcoString>,
 ) -> SourceResult<Value> {
     let Spanned { v: path, span } = path;
-    let id = vm.resolve_path(&path).at(span)?;
-    let data = vm.world().file(id).at(span)?;
+    let id = span.resolve_path(&path).at(span)?;
+    let data = engine.world.file(id).at(span)?;
     yaml::decode(Spanned::new(Readable::Bytes(data), span))
 }
 
diff --git a/crates/typst/src/math/cancel.rs b/crates/typst/src/math/cancel.rs
index 7a72f44a..6d3026b8 100644
--- a/crates/typst/src/math/cancel.rs
+++ b/crates/typst/src/math/cancel.rs
@@ -191,7 +191,7 @@ fn draw_cancel_line(
             CancelAngle::Angle(v) => *v,
             // This specifies a function that takes the default angle as input.
             CancelAngle::Func(func) => {
-                func.call_vt(ctx.vt, [default])?.cast().at(span)?
+                func.call(ctx.engine, [default])?.cast().at(span)?
             }
         },
     };
diff --git a/crates/typst/src/math/ctx.rs b/crates/typst/src/math/ctx.rs
index 0f7ad933..9352f08b 100644
--- a/crates/typst/src/math/ctx.rs
+++ b/crates/typst/src/math/ctx.rs
@@ -9,8 +9,9 @@ use unicode_math_class::MathClass;
 use unicode_segmentation::UnicodeSegmentation;
 
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{Content, NativeElement, Smart, StyleChain, Styles};
-use crate::layout::{Abs, Axes, BoxElem, Em, Frame, Layout, Regions, Size, Vt};
+use crate::layout::{Abs, Axes, BoxElem, Em, Frame, Layout, Regions, Size};
 use crate::math::{
     FrameFragment, GlyphFragment, LayoutMath, MathFragment, MathRow, MathSize, MathStyle,
     MathVariant, THICK,
@@ -43,7 +44,7 @@ macro_rules! percent {
 
 /// The context for math layout.
 pub struct MathContext<'a, 'b, 'v> {
-    pub vt: &'v mut Vt<'b>,
+    pub engine: &'v mut Engine<'b>,
     pub regions: Regions<'static>,
     pub font: &'a Font,
     pub ttf: &'a ttf_parser::Face<'a>,
@@ -62,7 +63,7 @@ pub struct MathContext<'a, 'b, 'v> {
 
 impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
     pub fn new(
-        vt: &'v mut Vt<'b>,
+        engine: &'v mut Engine<'b>,
         styles: StyleChain<'a>,
         regions: Regions,
         font: &'a Font,
@@ -103,7 +104,7 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
 
         let variant = variant(styles);
         Self {
-            vt,
+            engine,
             regions: Regions::one(regions.base(), Axes::splat(false)),
             font,
             ttf: font.ttf(),
@@ -167,13 +168,13 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
 
     pub fn layout_box(&mut self, boxed: &BoxElem) -> SourceResult<Frame> {
         Ok(boxed
-            .layout(self.vt, self.outer.chain(&self.local), self.regions)?
+            .layout(self.engine, self.outer.chain(&self.local), self.regions)?
             .into_frame())
     }
 
     pub fn layout_content(&mut self, content: &Content) -> SourceResult<Frame> {
         Ok(content
-            .layout(self.vt, self.outer.chain(&self.local), self.regions)?
+            .layout(self.engine, self.outer.chain(&self.local), self.regions)?
             .into_frame())
     }
 
@@ -270,7 +271,7 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
         let frame = ParElem::new(vec![Prehashed::new(elem)])
             .spanned(span)
             .layout(
-                self.vt,
+                self.engine,
                 self.outer.chain(&self.local),
                 false,
                 Size::splat(Abs::inf()),
@@ -288,7 +289,7 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
     }
 
     pub fn realize(&mut self, content: &Content) -> SourceResult<Option<Content>> {
-        realize(self.vt, content, self.outer.chain(&self.local))
+        realize(self.engine, content, self.outer.chain(&self.local))
     }
 
     pub fn style(&mut self, style: MathStyle) {
diff --git a/crates/typst/src/math/equation.rs b/crates/typst/src/math/equation.rs
index fb58a5b7..f5fa6061 100644
--- a/crates/typst/src/math/equation.rs
+++ b/crates/typst/src/math/equation.rs
@@ -1,6 +1,7 @@
 use std::num::NonZeroUsize;
 
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     elem, Content, Finalize, Guard, NativeElement, Resolve, Show, Smart, StyleChain,
     Synthesize,
@@ -8,7 +9,7 @@ use crate::foundations::{
 use crate::introspection::{Count, Counter, CounterUpdate, Locatable};
 use crate::layout::{
     Abs, Align, AlignElem, Axes, Dir, Em, FixedAlign, Fragment, Layout, Point, Regions,
-    Size, Vt,
+    Size,
 };
 use crate::math::{LayoutMath, MathContext};
 use crate::model::{Numbering, Outlinable, ParElem, Refable, Supplement};
@@ -88,12 +89,18 @@ pub struct EquationElem {
 }
 
 impl Synthesize for EquationElem {
-    fn synthesize(&mut self, vt: &mut Vt, styles: StyleChain) -> SourceResult<()> {
+    fn synthesize(
+        &mut self,
+        engine: &mut Engine,
+        styles: StyleChain,
+    ) -> SourceResult<()> {
         // Resolve the supplement.
         let supplement = match self.supplement(styles) {
             Smart::Auto => TextElem::packed(Self::local_name_in(styles)),
             Smart::Custom(None) => Content::empty(),
-            Smart::Custom(Some(supplement)) => supplement.resolve(vt, [self.clone()])?,
+            Smart::Custom(Some(supplement)) => {
+                supplement.resolve(engine, [self.clone()])?
+            }
         };
 
         self.push_block(self.block(styles));
@@ -106,7 +113,7 @@ impl Synthesize for EquationElem {
 
 impl Show for EquationElem {
     #[tracing::instrument(name = "EquationElem::show", skip_all)]
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let mut realized = self.clone().pack().guarded(Guard::Base(Self::elem()));
         if self.block(styles) {
             realized = AlignElem::new(realized).pack();
@@ -133,7 +140,7 @@ impl Layout for EquationElem {
     #[tracing::instrument(name = "EquationElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -143,7 +150,7 @@ impl Layout for EquationElem {
 
         // Find a math font.
         let variant = variant(styles);
-        let world = vt.world;
+        let world = engine.world;
         let Some(font) = families(styles).find_map(|family| {
             let id = world.book().select(family, variant)?;
             let font = world.font(id)?;
@@ -153,7 +160,7 @@ impl Layout for EquationElem {
             bail!(self.span(), "current font does not support math");
         };
 
-        let mut ctx = MathContext::new(vt, styles, regions, &font, block);
+        let mut ctx = MathContext::new(engine, styles, regions, &font, block);
         let mut frame = ctx.layout_frame(self)?;
 
         if block {
@@ -161,7 +168,7 @@ impl Layout for EquationElem {
                 let pod = Regions::one(regions.base(), Axes::splat(false));
                 let counter = Counter::of(Self::elem())
                     .display(Some(numbering), false)
-                    .layout(vt, styles, pod)?
+                    .layout(engine, styles, pod)?
                     .into_frame();
 
                 let full_counter_width = counter.width() + NUMBER_GUTTER.resolve(styles);
@@ -274,7 +281,7 @@ impl Refable for EquationElem {
 }
 
 impl Outlinable for EquationElem {
-    fn outline(&self, vt: &mut Vt) -> SourceResult<Option<Content>> {
+    fn outline(&self, engine: &mut Engine) -> SourceResult<Option<Content>> {
         if !self.block(StyleChain::default()) {
             return Ok(None);
         }
@@ -294,8 +301,8 @@ impl Outlinable for EquationElem {
 
         let numbers = self
             .counter()
-            .at(vt, self.location().unwrap())?
-            .display(vt, &numbering)?;
+            .at(engine, self.location().unwrap())?
+            .display(engine, &numbering)?;
 
         Ok(Some(supplement + numbers))
     }
diff --git a/crates/typst/src/model/bibliography.rs b/crates/typst/src/model/bibliography.rs
index f6e189e1..626468dc 100644
--- a/crates/typst/src/model/bibliography.rs
+++ b/crates/typst/src/model/bibliography.rs
@@ -20,7 +20,8 @@ use smallvec::{smallvec, SmallVec};
 use typed_arena::Arena;
 
 use crate::diag::{bail, error, At, FileError, SourceResult, StrResult};
-use crate::eval::{eval_string, EvalMode, Vm};
+use crate::engine::Engine;
+use crate::eval::{eval_string, EvalMode};
 use crate::foundations::{
     cast, elem, ty, Args, Array, Bytes, CastInfo, Content, Finalize, FromValue,
     IntoValue, Label, NativeElement, Reflect, Repr, Scope, Show, Smart, Str, StyleChain,
@@ -28,7 +29,7 @@ use crate::foundations::{
 };
 use crate::introspection::{Introspector, Locatable, Location};
 use crate::layout::{
-    BlockElem, Em, GridElem, HElem, PadElem, Sizing, TrackSizings, VElem, Vt,
+    BlockElem, Em, GridElem, HElem, PadElem, Sizing, TrackSizings, VElem,
 };
 use crate::model::{
     CitationForm, CiteGroup, Destination, FootnoteElem, HeadingElem, LinkElem, ParElem,
@@ -88,7 +89,7 @@ pub struct BibliographyElem {
     /// Path(s) to Hayagriva `.yml` and/or BibLaTeX `.bib` files.
     #[required]
     #[parse(
-        let (paths, bibliography) = Bibliography::parse(vm, args)?;
+        let (paths, bibliography) = Bibliography::parse(engine, args)?;
         paths
     )]
     pub path: BibliographyPaths,
@@ -120,7 +121,7 @@ pub struct BibliographyElem {
     /// a [CSL file](https://citationstyles.org/). Some of the styles listed
     /// below appear twice, once with their full name and once with a short
     /// alias.
-    #[parse(CslStyle::parse(vm, args)?)]
+    #[parse(CslStyle::parse(engine, args)?)]
     #[default(CslStyle::from_name("ieee").unwrap())]
     pub style: CslStyle,
 
@@ -169,9 +170,10 @@ impl BibliographyElem {
     }
 
     /// Whether the bibliography contains the given key.
-    pub fn has(vt: &Vt, key: impl Into<PicoStr>) -> bool {
+    pub fn has(engine: &Engine, key: impl Into<PicoStr>) -> bool {
         let key = key.into();
-        vt.introspector
+        engine
+            .introspector
             .query(&Self::elem().select())
             .iter()
             .any(|elem| elem.to::<Self>().unwrap().bibliography().has(key))
@@ -195,7 +197,7 @@ impl BibliographyElem {
 }
 
 impl Synthesize for BibliographyElem {
-    fn synthesize(&mut self, _vt: &mut Vt, styles: StyleChain) -> SourceResult<()> {
+    fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
         self.push_full(self.full(styles));
         self.push_style(self.style(styles));
         self.push_lang(TextElem::lang_in(styles));
@@ -206,7 +208,7 @@ impl Synthesize for BibliographyElem {
 
 impl Show for BibliographyElem {
     #[tracing::instrument(name = "BibliographyElem::show", skip_all)]
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         const COLUMN_GUTTER: Em = Em::new(0.65);
         const INDENT: Em = Em::new(1.5);
 
@@ -219,9 +221,9 @@ impl Show for BibliographyElem {
             seq.push(HeadingElem::new(title).with_level(NonZeroUsize::ONE).pack());
         }
 
-        Ok(vt.delayed(|vt| {
+        Ok(engine.delayed(|engine| {
             let span = self.span();
-            let works = Works::generate(vt.world, vt.introspector).at(span)?;
+            let works = Works::generate(engine.world, engine.introspector).at(span)?;
             let references = works
                 .references
                 .as_ref()
@@ -316,7 +318,7 @@ pub struct Bibliography {
 impl Bibliography {
     /// Parse the bibliography argument.
     fn parse(
-        vm: &mut Vm,
+        engine: &mut Engine,
         args: &mut Args,
     ) -> SourceResult<(BibliographyPaths, Bibliography)> {
         let Spanned { v: paths, span } =
@@ -327,8 +329,8 @@ impl Bibliography {
             .0
             .iter()
             .map(|path| {
-                let id = vm.resolve_path(path).at(span)?;
-                vm.world().file(id).at(span)
+                let id = span.resolve_path(path).at(span)?;
+                engine.world.file(id).at(span)
             })
             .collect::<SourceResult<Vec<Bytes>>>()?;
 
@@ -438,19 +440,19 @@ pub struct CslStyle {
 
 impl CslStyle {
     /// Parse the style argument.
-    pub fn parse(vm: &mut Vm, args: &mut Args) -> SourceResult<Option<CslStyle>> {
+    pub fn parse(engine: &mut Engine, args: &mut Args) -> SourceResult<Option<CslStyle>> {
         let Some(Spanned { v: string, span }) =
             args.named::<Spanned<EcoString>>("style")?
         else {
             return Ok(None);
         };
 
-        Ok(Some(Self::parse_impl(vm, &string).at(span)?))
+        Ok(Some(Self::parse_impl(engine, &string, span).at(span)?))
     }
 
     /// Parse the style argument with `Smart`.
     pub fn parse_smart(
-        vm: &mut Vm,
+        engine: &mut Engine,
         args: &mut Args,
     ) -> SourceResult<Option<Smart<CslStyle>>> {
         let Some(Spanned { v: smart, span }) =
@@ -462,13 +464,13 @@ impl CslStyle {
         Ok(Some(match smart {
             Smart::Auto => Smart::Auto,
             Smart::Custom(string) => {
-                Smart::Custom(Self::parse_impl(vm, &string).at(span)?)
+                Smart::Custom(Self::parse_impl(engine, &string, span).at(span)?)
             }
         }))
     }
 
     /// Parse internally.
-    fn parse_impl(vm: &mut Vm, string: &str) -> StrResult<CslStyle> {
+    fn parse_impl(engine: &mut Engine, string: &str, span: Span) -> StrResult<CslStyle> {
         let ext = Path::new(string)
             .extension()
             .and_then(OsStr::to_str)
@@ -476,8 +478,8 @@ impl CslStyle {
             .to_lowercase();
 
         if ext == "csl" {
-            let id = vm.resolve_path(string)?;
-            let data = vm.world().file(id)?;
+            let id = span.resolve_path(string)?;
+            let data = engine.world.file(id)?;
             CslStyle::from_data(&data)
         } else {
             CslStyle::from_name(string)
diff --git a/crates/typst/src/model/cite.rs b/crates/typst/src/model/cite.rs
index 7ead5907..3657e83d 100644
--- a/crates/typst/src/model/cite.rs
+++ b/crates/typst/src/model/cite.rs
@@ -1,9 +1,9 @@
 use crate::diag::{bail, At, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, Cast, Content, Label, NativeElement, Show, Smart, StyleChain, Synthesize,
 };
 use crate::introspection::Locatable;
-use crate::layout::Vt;
 use crate::model::bibliography::Works;
 use crate::model::CslStyle;
 use crate::text::{Lang, Region, TextElem};
@@ -85,7 +85,7 @@ pub struct CiteElem {
     ///
     /// When set to `{auto}`, automatically use the
     /// [bibliography's style]($bibliography.style) for the citations.
-    #[parse(CslStyle::parse_smart(vm, args)?)]
+    #[parse(CslStyle::parse_smart(engine, args)?)]
     pub style: Smart<CslStyle>,
 
     /// The text language setting where the citation is.
@@ -100,7 +100,7 @@ pub struct CiteElem {
 }
 
 impl Synthesize for CiteElem {
-    fn synthesize(&mut self, _vt: &mut Vt, styles: StyleChain) -> SourceResult<()> {
+    fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
         self.push_supplement(self.supplement(styles));
         self.push_form(self.form(styles));
         self.push_style(self.style(styles));
@@ -143,12 +143,12 @@ pub struct CiteGroup {
 }
 
 impl Show for CiteGroup {
-    #[tracing::instrument(name = "CiteGroup::show", skip(self, vt))]
-    fn show(&self, vt: &mut Vt, _: StyleChain) -> SourceResult<Content> {
-        Ok(vt.delayed(|vt| {
+    #[tracing::instrument(name = "CiteGroup::show", skip(self, engine))]
+    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
+        Ok(engine.delayed(|engine| {
             let location = self.location().unwrap();
             let span = self.span();
-            Works::generate(vt.world, vt.introspector)
+            Works::generate(engine.world, engine.introspector)
                 .at(span)?
                 .citations
                 .get(&location)
diff --git a/crates/typst/src/model/document.rs b/crates/typst/src/model/document.rs
index f6ea7d24..373a1545 100644
--- a/crates/typst/src/model/document.rs
+++ b/crates/typst/src/model/document.rs
@@ -2,12 +2,12 @@ use comemo::Prehashed;
 use ecow::EcoString;
 
 use crate::diag::{bail, SourceResult, StrResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, Args, Array, Construct, Content, Datetime, Smart, StyleChain, Value,
 };
 use crate::introspection::ManualPageCounter;
-use crate::layout::{Frame, LayoutRoot, PageElem, Vt};
+use crate::layout::{Frame, LayoutRoot, PageElem};
 
 /// The root element of a document and its metadata.
 ///
@@ -56,7 +56,7 @@ pub struct DocumentElem {
 }
 
 impl Construct for DocumentElem {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &mut Engine, args: &mut Args) -> SourceResult<Content> {
         bail!(args.span, "can only be used in set rules")
     }
 }
@@ -64,7 +64,11 @@ impl Construct for DocumentElem {
 impl LayoutRoot for DocumentElem {
     /// Layout the document into a sequence of frames, one per page.
     #[tracing::instrument(name = "DocumentElem::layout_root", skip_all)]
-    fn layout_root(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Document> {
+    fn layout_root(
+        &self,
+        engine: &mut Engine,
+        styles: StyleChain,
+    ) -> SourceResult<Document> {
         tracing::info!("Document layout");
 
         let mut pages = vec![];
@@ -88,7 +92,8 @@ impl LayoutRoot for DocumentElem {
                         .to::<PageElem>()?
                         .clear_to(styles)
                 });
-                let fragment = page.layout(vt, styles, &mut page_counter, extend_to)?;
+                let fragment =
+                    page.layout(engine, styles, &mut page_counter, extend_to)?;
                 pages.extend(fragment);
             } else {
                 bail!(child.span(), "unexpected document child");
diff --git a/crates/typst/src/model/emph.rs b/crates/typst/src/model/emph.rs
index 1b7f654c..de7b8bef 100644
--- a/crates/typst/src/model/emph.rs
+++ b/crates/typst/src/model/emph.rs
@@ -1,6 +1,6 @@
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{elem, Content, Show, StyleChain};
-use crate::layout::Vt;
 use crate::text::{ItalicToggle, TextElem};
 
 /// Emphasizes content by setting it in italics.
@@ -35,7 +35,7 @@ pub struct EmphElem {
 
 impl Show for EmphElem {
     #[tracing::instrument(name = "EmphElem::show", skip(self))]
-    fn show(&self, _: &mut Vt, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
         Ok(self.body().clone().styled(TextElem::set_emph(ItalicToggle)))
     }
 }
diff --git a/crates/typst/src/model/enum.rs b/crates/typst/src/model/enum.rs
index f440bc39..f4583f8d 100644
--- a/crates/typst/src/model/enum.rs
+++ b/crates/typst/src/model/enum.rs
@@ -1,12 +1,13 @@
 use std::str::FromStr;
 
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, scope, Array, Content, Fold, NativeElement, Smart, StyleChain,
 };
 use crate::layout::{
     Axes, BlockElem, Em, Fragment, GridLayouter, HAlign, Layout, Length, Regions, Sizing,
-    Spacing, VAlign, Vt,
+    Spacing, VAlign,
 };
 use crate::model::{Numbering, NumberingPattern, ParElem};
 use crate::text::TextElem;
@@ -209,7 +210,7 @@ impl Layout for EnumElem {
     #[tracing::instrument(name = "EnumElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -239,7 +240,7 @@ impl Layout for EnumElem {
 
             let resolved = if full {
                 parents.push(number);
-                let content = numbering.apply_vt(vt, &parents)?.display();
+                let content = numbering.apply(engine, &parents)?.display();
                 parents.pop();
                 content
             } else {
@@ -247,7 +248,7 @@ impl Layout for EnumElem {
                     Numbering::Pattern(pattern) => {
                         TextElem::packed(pattern.apply_kth(parents.len(), number))
                     }
-                    other => other.apply_vt(vt, &[number])?.display(),
+                    other => other.apply(engine, &[number])?.display(),
                 }
             };
 
@@ -277,7 +278,7 @@ impl Layout for EnumElem {
             self.span(),
         );
 
-        Ok(layouter.layout(vt)?.fragment)
+        Ok(layouter.layout(engine)?.fragment)
     }
 }
 
diff --git a/crates/typst/src/model/figure.rs b/crates/typst/src/model/figure.rs
index 26a96db1..e6ab7a2a 100644
--- a/crates/typst/src/model/figure.rs
+++ b/crates/typst/src/model/figure.rs
@@ -5,6 +5,7 @@ use std::str::FromStr;
 use ecow::EcoString;
 
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, scope, select_where, Content, Element, Finalize, NativeElement, Selector,
     Show, Smart, StyleChain, Synthesize,
@@ -12,7 +13,7 @@ use crate::foundations::{
 use crate::introspection::{
     Count, Counter, CounterKey, CounterUpdate, Locatable, Location,
 };
-use crate::layout::{Align, BlockElem, Em, HAlign, Length, PlaceElem, VAlign, VElem, Vt};
+use crate::layout::{Align, BlockElem, Em, HAlign, Length, PlaceElem, VAlign, VElem};
 use crate::model::{Numbering, NumberingPattern, Outlinable, Refable, Supplement};
 use crate::syntax::Spanned;
 use crate::text::{Lang, Region, TextElem};
@@ -220,7 +221,11 @@ impl FigureElem {
 }
 
 impl Synthesize for FigureElem {
-    fn synthesize(&mut self, vt: &mut Vt, styles: StyleChain) -> SourceResult<()> {
+    fn synthesize(
+        &mut self,
+        engine: &mut Engine,
+        styles: StyleChain,
+    ) -> SourceResult<()> {
         let numbering = self.numbering(styles);
 
         // Determine the figure's kind.
@@ -264,7 +269,7 @@ impl Synthesize for FigureElem {
                 };
 
                 let target = descendant.unwrap_or_else(|| Cow::Borrowed(self.body()));
-                Some(supplement.resolve(vt, [target])?)
+                Some(supplement.resolve(engine, [target])?)
             }
         };
 
@@ -296,7 +301,7 @@ impl Synthesize for FigureElem {
 
 impl Show for FigureElem {
     #[tracing::instrument(name = "FigureElem::show", skip_all)]
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let mut realized = self.body().clone();
 
         // Build the caption, if any.
@@ -364,7 +369,7 @@ impl Refable for FigureElem {
 }
 
 impl Outlinable for FigureElem {
-    fn outline(&self, vt: &mut Vt) -> SourceResult<Option<Content>> {
+    fn outline(&self, engine: &mut Engine) -> SourceResult<Option<Content>> {
         if !self.outlined(StyleChain::default()) {
             return Ok(None);
         }
@@ -384,7 +389,7 @@ impl Outlinable for FigureElem {
             self.numbering(StyleChain::default()),
         ) {
             let location = self.location().unwrap();
-            let numbers = counter.at(vt, location)?.display(vt, &numbering)?;
+            let numbers = counter.at(engine, location)?.display(engine, &numbering)?;
 
             if !supplement.is_empty() {
                 supplement += TextElem::packed('\u{a0}');
@@ -538,7 +543,7 @@ impl FigureCaption {
 }
 
 impl Synthesize for FigureCaption {
-    fn synthesize(&mut self, _: &mut Vt, styles: StyleChain) -> SourceResult<()> {
+    fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
         self.push_position(self.position(styles));
         self.push_separator(Smart::Custom(self.get_separator(styles)));
         Ok(())
@@ -547,7 +552,7 @@ impl Synthesize for FigureCaption {
 
 impl Show for FigureCaption {
     #[tracing::instrument(name = "FigureCaption::show", skip_all)]
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let mut realized = self.body().clone();
 
         if let (Some(mut supplement), Some(numbering), Some(counter), Some(location)) = (
@@ -556,7 +561,7 @@ impl Show for FigureCaption {
             self.counter(),
             self.figure_location(),
         ) {
-            let numbers = counter.at(vt, *location)?.display(vt, numbering)?;
+            let numbers = counter.at(engine, *location)?.display(engine, numbering)?;
             if !supplement.is_empty() {
                 supplement += TextElem::packed('\u{a0}');
             }
diff --git a/crates/typst/src/model/footnote.rs b/crates/typst/src/model/footnote.rs
index d51ee226..df88b58c 100644
--- a/crates/typst/src/model/footnote.rs
+++ b/crates/typst/src/model/footnote.rs
@@ -4,12 +4,13 @@ use std::str::FromStr;
 use comemo::Prehashed;
 
 use crate::diag::{bail, error, At, SourceResult, StrResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, scope, Content, Finalize, Label, NativeElement, Show, Smart, StyleChain,
     Synthesize,
 };
 use crate::introspection::{Count, Counter, CounterUpdate, Locatable, Location};
-use crate::layout::{Abs, Em, HElem, Length, Ratio, Vt};
+use crate::layout::{Abs, Em, HElem, Length, Ratio};
 use crate::model::{Destination, Numbering, NumberingPattern, ParElem};
 use crate::text::{SuperElem, TextElem, TextSize};
 use crate::util::NonZeroExt;
@@ -107,14 +108,15 @@ impl FootnoteElem {
     }
 
     /// Returns the location of the definition of this footnote.
-    pub fn declaration_location(&self, vt: &Vt) -> StrResult<Location> {
+    pub fn declaration_location(&self, engine: &Engine) -> StrResult<Location> {
         match self.body() {
             FootnoteBody::Reference(label) => {
-                let element: Prehashed<Content> = vt.introspector.query_label(*label)?;
+                let element: Prehashed<Content> =
+                    engine.introspector.query_label(*label)?;
                 let footnote = element
                     .to::<FootnoteElem>()
                     .ok_or("referenced element should be a footnote")?;
-                footnote.declaration_location(vt)
+                footnote.declaration_location(engine)
             }
             _ => Ok(self.location().unwrap()),
         }
@@ -122,7 +124,7 @@ impl FootnoteElem {
 }
 
 impl Synthesize for FootnoteElem {
-    fn synthesize(&mut self, _vt: &mut Vt, styles: StyleChain) -> SourceResult<()> {
+    fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
         self.push_numbering(self.numbering(styles).clone());
         Ok(())
     }
@@ -130,12 +132,12 @@ impl Synthesize for FootnoteElem {
 
 impl Show for FootnoteElem {
     #[tracing::instrument(name = "FootnoteElem::show", skip_all)]
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
-        Ok(vt.delayed(|vt| {
-            let loc = self.declaration_location(vt).at(self.span())?;
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+        Ok(engine.delayed(|engine| {
+            let loc = self.declaration_location(engine).at(self.span())?;
             let numbering = self.numbering(styles);
             let counter = Counter::of(Self::elem());
-            let num = counter.at(vt, loc)?.display(vt, numbering)?;
+            let num = counter.at(engine, loc)?.display(engine, numbering)?;
             let sup = SuperElem::new(num).pack();
             let loc = loc.variant(1);
             // Add zero-width weak spacing to make the footnote "sticky".
@@ -271,7 +273,7 @@ pub struct FootnoteEntry {
 }
 
 impl Show for FootnoteEntry {
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let note = self.note();
         let number_gap = Em::new(0.05);
         let default = StyleChain::default();
@@ -283,7 +285,7 @@ impl Show for FootnoteEntry {
             ))
         };
 
-        let num = counter.at(vt, loc)?.display(vt, numbering)?;
+        let num = counter.at(engine, loc)?.display(engine, numbering)?;
         let sup = SuperElem::new(num)
             .pack()
             .linked(Destination::Location(loc))
diff --git a/crates/typst/src/model/heading.rs b/crates/typst/src/model/heading.rs
index 3365f00c..6f8932d4 100644
--- a/crates/typst/src/model/heading.rs
+++ b/crates/typst/src/model/heading.rs
@@ -1,12 +1,13 @@
 use std::num::NonZeroUsize;
 
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, Content, Finalize, NativeElement, Show, Smart, StyleChain, Styles,
     Synthesize,
 };
 use crate::introspection::{Count, Counter, CounterUpdate, Locatable};
-use crate::layout::{BlockElem, Em, HElem, VElem, Vt};
+use crate::layout::{BlockElem, Em, HElem, VElem};
 use crate::model::{Numbering, Outlinable, Refable, Supplement};
 use crate::text::{FontWeight, Lang, LocalName, Region, SpaceElem, TextElem, TextSize};
 use crate::util::{option_eq, NonZeroExt};
@@ -126,12 +127,18 @@ pub struct HeadingElem {
 }
 
 impl Synthesize for HeadingElem {
-    fn synthesize(&mut self, vt: &mut Vt, styles: StyleChain) -> SourceResult<()> {
+    fn synthesize(
+        &mut self,
+        engine: &mut Engine,
+        styles: StyleChain,
+    ) -> SourceResult<()> {
         // Resolve the supplement.
         let supplement = match self.supplement(styles) {
             Smart::Auto => TextElem::packed(Self::local_name_in(styles)),
             Smart::Custom(None) => Content::empty(),
-            Smart::Custom(Some(supplement)) => supplement.resolve(vt, [self.clone()])?,
+            Smart::Custom(Some(supplement)) => {
+                supplement.resolve(engine, [self.clone()])?
+            }
         };
 
         self.push_level(self.level(styles));
@@ -146,7 +153,7 @@ impl Synthesize for HeadingElem {
 
 impl Show for HeadingElem {
     #[tracing::instrument(name = "HeadingElem::show", skip_all)]
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let mut realized = self.body().clone();
         if let Some(numbering) = self.numbering(styles).as_ref() {
             realized = Counter::of(Self::elem())
@@ -214,7 +221,7 @@ impl Refable for HeadingElem {
 }
 
 impl Outlinable for HeadingElem {
-    fn outline(&self, vt: &mut Vt) -> SourceResult<Option<Content>> {
+    fn outline(&self, engine: &mut Engine) -> SourceResult<Option<Content>> {
         if !self.outlined(StyleChain::default()) {
             return Ok(None);
         }
@@ -223,8 +230,8 @@ impl Outlinable for HeadingElem {
         let default = StyleChain::default();
         if let Some(numbering) = self.numbering(default).as_ref() {
             let numbers = Counter::of(Self::elem())
-                .at(vt, self.location().unwrap())?
-                .display(vt, numbering)?;
+                .at(engine, self.location().unwrap())?
+                .display(engine, numbering)?;
             content = numbers + SpaceElem::new().pack() + content;
         };
 
diff --git a/crates/typst/src/model/link.rs b/crates/typst/src/model/link.rs
index 27a05737..5d1b4f19 100644
--- a/crates/typst/src/model/link.rs
+++ b/crates/typst/src/model/link.rs
@@ -1,11 +1,12 @@
 use ecow::{eco_format, EcoString};
 
 use crate::diag::{At, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, Content, Label, NativeElement, Repr, Show, Smart, StyleChain,
 };
 use crate::introspection::Location;
-use crate::layout::{Position, Vt};
+use crate::layout::Position;
 use crate::text::{Hyphenate, TextElem};
 
 /// Links to a URL or a location in the document.
@@ -89,14 +90,14 @@ impl LinkElem {
 }
 
 impl Show for LinkElem {
-    #[tracing::instrument(name = "LinkElem::show", skip(self, vt))]
-    fn show(&self, vt: &mut Vt, _: StyleChain) -> SourceResult<Content> {
+    #[tracing::instrument(name = "LinkElem::show", skip(self, engine))]
+    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
         let body = self.body().clone();
         let linked = match self.dest() {
             LinkTarget::Dest(dest) => body.linked(dest.clone()),
-            LinkTarget::Label(label) => vt
-                .delayed(|vt| {
-                    let elem = vt.introspector.query_label(*label).at(self.span())?;
+            LinkTarget::Label(label) => engine
+                .delayed(|engine| {
+                    let elem = engine.introspector.query_label(*label).at(self.span())?;
                     let dest = Destination::Location(elem.location().unwrap());
                     Ok(Some(body.clone().linked(dest)))
                 })
diff --git a/crates/typst/src/model/list.rs b/crates/typst/src/model/list.rs
index e9275f03..623cafa2 100644
--- a/crates/typst/src/model/list.rs
+++ b/crates/typst/src/model/list.rs
@@ -1,11 +1,12 @@
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, scope, Array, Content, Fold, Func, NativeElement, Smart, StyleChain,
     Value,
 };
 use crate::layout::{
     Axes, BlockElem, Em, Fragment, GridLayouter, HAlign, Layout, Length, Regions, Sizing,
-    Spacing, VAlign, Vt,
+    Spacing, VAlign,
 };
 use crate::model::ParElem;
 use crate::text::TextElem;
@@ -130,7 +131,7 @@ impl Layout for ListElem {
     #[tracing::instrument(name = "ListElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -146,7 +147,7 @@ impl Layout for ListElem {
         let depth = self.depth(styles);
         let marker = self
             .marker(styles)
-            .resolve(vt, depth)?
+            .resolve(engine, depth)?
             // avoid '#set align' interference with the list
             .aligned(HAlign::Start + VAlign::Top);
 
@@ -172,7 +173,7 @@ impl Layout for ListElem {
             self.span(),
         );
 
-        Ok(layouter.layout(vt)?.fragment)
+        Ok(layouter.layout(engine)?.fragment)
     }
 }
 
@@ -198,12 +199,12 @@ pub enum ListMarker {
 
 impl ListMarker {
     /// Resolve the marker for the given depth.
-    fn resolve(&self, vt: &mut Vt, depth: usize) -> SourceResult<Content> {
+    fn resolve(&self, engine: &mut Engine, depth: usize) -> SourceResult<Content> {
         Ok(match self {
             Self::Content(list) => {
                 list.get(depth).or(list.last()).cloned().unwrap_or_default()
             }
-            Self::Func(func) => func.call_vt(vt, [depth])?.display(),
+            Self::Func(func) => func.call(engine, [depth])?.display(),
         })
     }
 }
diff --git a/crates/typst/src/model/numbering.rs b/crates/typst/src/model/numbering.rs
index fa7a88c4..d91a5c52 100644
--- a/crates/typst/src/model/numbering.rs
+++ b/crates/typst/src/model/numbering.rs
@@ -5,9 +5,9 @@ use chinese_number::{ChineseCase, ChineseCountMethod, ChineseVariant, NumberToCh
 use ecow::{eco_format, EcoString, EcoVec};
 
 use crate::diag::SourceResult;
-use crate::eval::Vm;
-use crate::foundations::{cast, func, Args, Func, Str, Value};
-use crate::layout::{PdfPageLabel, PdfPageLabelStyle, Vt};
+use crate::engine::Engine;
+use crate::foundations::{cast, func, Func, Str, Value};
+use crate::layout::{PdfPageLabel, PdfPageLabelStyle};
 use crate::text::Case;
 
 /// Applies a numbering to a sequence of numbers.
@@ -35,8 +35,8 @@ use crate::text::Case;
 /// ```
 #[func]
 pub fn numbering(
-    /// The virtual machine.
-    vm: &mut Vm,
+    /// The engine.
+    engine: &mut Engine,
     /// Defines how the numbering works.
     ///
     /// **Counting symbols** are `1`, `a`, `A`, `i`, `I`, `い`, `イ`, `א`, `가`,
@@ -68,7 +68,7 @@ pub fn numbering(
     #[variadic]
     numbers: Vec<usize>,
 ) -> SourceResult<Value> {
-    numbering.apply_vm(vm, &numbers)
+    numbering.apply(engine, &numbers)
 }
 
 /// How to number a sequence of things.
@@ -82,21 +82,10 @@ pub enum Numbering {
 
 impl Numbering {
     /// Apply the pattern to the given numbers.
-    pub fn apply_vm(&self, vm: &mut Vm, numbers: &[usize]) -> SourceResult<Value> {
+    pub fn apply(&self, engine: &mut Engine, numbers: &[usize]) -> SourceResult<Value> {
         Ok(match self {
             Self::Pattern(pattern) => Value::Str(pattern.apply(numbers).into()),
-            Self::Func(func) => {
-                let args = Args::new(func.span(), numbers.iter().copied());
-                func.call_vm(vm, args)?
-            }
-        })
-    }
-
-    /// Apply the pattern to the given numbers.
-    pub fn apply_vt(&self, vt: &mut Vt, numbers: &[usize]) -> SourceResult<Value> {
-        Ok(match self {
-            Self::Pattern(pattern) => Value::Str(pattern.apply(numbers).into()),
-            Self::Func(func) => func.call_vt(vt, numbers.iter().copied())?,
+            Self::Func(func) => func.call(engine, numbers.iter().copied())?,
         })
     }
 
diff --git a/crates/typst/src/model/outline.rs b/crates/typst/src/model/outline.rs
index 3b23098e..91526a9c 100644
--- a/crates/typst/src/model/outline.rs
+++ b/crates/typst/src/model/outline.rs
@@ -2,12 +2,13 @@ use std::num::NonZeroUsize;
 use std::str::FromStr;
 
 use crate::diag::{bail, error, At, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, scope, select_where, Content, Finalize, Func, LocatableSelector,
     NativeElement, Show, Smart, StyleChain,
 };
 use crate::introspection::{Counter, CounterKey, Locatable};
-use crate::layout::{BoxElem, Fr, HElem, HideElem, Length, Rel, RepeatElem, Spacing, Vt};
+use crate::layout::{BoxElem, Fr, HElem, HideElem, Length, Rel, RepeatElem, Spacing};
 use crate::model::{Destination, HeadingElem, NumberingPattern, ParbreakElem, Refable};
 use crate::syntax::Span;
 use crate::text::{Lang, LinebreakElem, LocalName, Region, SpaceElem, TextElem};
@@ -186,7 +187,7 @@ impl OutlineElem {
 
 impl Show for OutlineElem {
     #[tracing::instrument(name = "OutlineElem::show", skip_all)]
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let mut seq = vec![ParbreakElem::new().pack()];
         // Build the outline title.
         if let Some(title) = self.title(styles) {
@@ -201,11 +202,11 @@ impl Show for OutlineElem {
         let depth = self.depth(styles).unwrap_or(NonZeroUsize::new(usize::MAX).unwrap());
 
         let mut ancestors: Vec<&Content> = vec![];
-        let elems = vt.introspector.query(&self.target(styles).0);
+        let elems = engine.introspector.query(&self.target(styles).0);
 
         for elem in &elems {
             let Some(entry) = OutlineEntry::from_outlinable(
-                vt,
+                engine,
                 self.span(),
                 elem.clone().into_inner(),
                 self.fill(styles),
@@ -229,7 +230,7 @@ impl Show for OutlineElem {
                 ancestors.pop();
             }
 
-            OutlineIndent::apply(indent, vt, &ancestors, &mut seq, self.span())?;
+            OutlineIndent::apply(indent, engine, &ancestors, &mut seq, self.span())?;
 
             // Add the overridable outline entry, followed by a line break.
             seq.push(entry.pack());
@@ -292,7 +293,7 @@ impl LocalName for OutlineElem {
 /// `#outline()` element.
 pub trait Outlinable: Refable {
     /// Produce an outline item for this element.
-    fn outline(&self, vt: &mut Vt) -> SourceResult<Option<Content>>;
+    fn outline(&self, engine: &mut Engine) -> SourceResult<Option<Content>>;
 
     /// Returns the nesting level of this element.
     fn level(&self) -> NonZeroUsize {
@@ -311,7 +312,7 @@ pub enum OutlineIndent {
 impl OutlineIndent {
     fn apply(
         indent: &Option<Smart<Self>>,
-        vt: &mut Vt,
+        engine: &mut Engine,
         ancestors: &Vec<&Content>,
         seq: &mut Vec<Content>,
         span: Span,
@@ -330,8 +331,8 @@ impl OutlineIndent {
                     if let Some(numbering) = ancestor_outlinable.numbering() {
                         let numbers = ancestor_outlinable
                             .counter()
-                            .at(vt, ancestor.location().unwrap())?
-                            .display(vt, &numbering)?;
+                            .at(engine, ancestor.location().unwrap())?
+                            .display(engine, &numbering)?;
 
                         hidden += numbers + SpaceElem::new().pack();
                     };
@@ -355,7 +356,7 @@ impl OutlineIndent {
             Some(Smart::Custom(OutlineIndent::Func(func))) => {
                 let depth = ancestors.len();
                 let LengthOrContent(content) =
-                    func.call_vt(vt, [depth])?.cast().at(span)?;
+                    func.call(engine, [depth])?.cast().at(span)?;
                 if !content.is_empty() {
                     seq.push(content);
                 }
@@ -455,7 +456,7 @@ impl OutlineEntry {
     /// be outlined (e.g. heading with 'outlined: false'), does not generate an
     /// entry instance (returns `Ok(None)`).
     fn from_outlinable(
-        vt: &mut Vt,
+        engine: &mut Engine,
         span: Span,
         elem: Content,
         fill: Option<Content>,
@@ -464,27 +465,27 @@ impl OutlineEntry {
             bail!(span, "cannot outline {}", elem.func().name());
         };
 
-        let Some(body) = outlinable.outline(vt)? else {
+        let Some(body) = outlinable.outline(engine)? else {
             return Ok(None);
         };
 
         let location = elem.location().unwrap();
-        let page_numbering = vt
+        let page_numbering = engine
             .introspector
             .page_numbering(location)
             .cloned()
             .unwrap_or_else(|| NumberingPattern::from_str("1").unwrap().into());
 
         let page = Counter::new(CounterKey::Page)
-            .at(vt, location)?
-            .display(vt, &page_numbering)?;
+            .at(engine, location)?
+            .display(engine, &page_numbering)?;
 
         Ok(Some(Self::new(outlinable.level(), elem, body, fill, page)))
     }
 }
 
 impl Show for OutlineEntry {
-    fn show(&self, _vt: &mut Vt, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
         let mut seq = vec![];
         let elem = self.element();
 
diff --git a/crates/typst/src/model/par.rs b/crates/typst/src/model/par.rs
index 84274661..c9f64efb 100644
--- a/crates/typst/src/model/par.rs
+++ b/crates/typst/src/model/par.rs
@@ -1,12 +1,12 @@
 use comemo::Prehashed;
 
 use crate::diag::SourceResult;
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{
     elem, Args, Cast, Construct, Content, NativeElement, Set, Smart, StyleChain,
     Unlabellable,
 };
-use crate::layout::{Em, Fragment, Length, Size, Vt};
+use crate::layout::{Em, Fragment, Length, Size};
 
 /// Arranges text, spacing and inline-level elements into a paragraph.
 ///
@@ -108,11 +108,11 @@ pub struct ParElem {
 }
 
 impl Construct for ParElem {
-    fn construct(vm: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(engine: &mut Engine, args: &mut Args) -> SourceResult<Content> {
         // The paragraph constructor is special: It doesn't create a paragraph
         // element. Instead, it just ensures that the passed content lives in a
         // separate paragraph and styles it.
-        let styles = Self::set(vm, args)?;
+        let styles = Self::set(engine, args)?;
         let body = args.expect::<Content>("body")?;
         Ok(Content::sequence([
             ParbreakElem::new().pack(),
@@ -127,7 +127,7 @@ impl ParElem {
     #[tracing::instrument(name = "ParElement::layout", skip_all)]
     pub fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         consecutive: bool,
         region: Size,
@@ -135,7 +135,7 @@ impl ParElem {
     ) -> SourceResult<Fragment> {
         crate::layout::layout_inline(
             self.children(),
-            vt,
+            engine,
             styles,
             consecutive,
             region,
diff --git a/crates/typst/src/model/quote.rs b/crates/typst/src/model/quote.rs
index 489e2657..2a709071 100644
--- a/crates/typst/src/model/quote.rs
+++ b/crates/typst/src/model/quote.rs
@@ -1,9 +1,10 @@
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, Content, Finalize, Label, NativeElement, Show, Smart, StyleChain,
     Synthesize,
 };
-use crate::layout::{Align, BlockElem, Em, HElem, PadElem, Spacing, VElem, Vt};
+use crate::layout::{Align, BlockElem, Em, HElem, PadElem, Spacing, VElem};
 use crate::model::{CitationForm, CiteElem};
 use crate::text::{SmartQuoteElem, SpaceElem, TextElem};
 
@@ -145,7 +146,7 @@ cast! {
 }
 
 impl Synthesize for QuoteElem {
-    fn synthesize(&mut self, _: &mut Vt, styles: StyleChain) -> SourceResult<()> {
+    fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
         self.push_block(self.block(styles));
         self.push_quotes(self.quotes(styles));
         Ok(())
@@ -153,7 +154,7 @@ impl Synthesize for QuoteElem {
 }
 
 impl Show for QuoteElem {
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let mut realized = self.body().clone();
         let block = self.block(styles);
 
diff --git a/crates/typst/src/model/reference.rs b/crates/typst/src/model/reference.rs
index 7f328e28..d64de1ae 100644
--- a/crates/typst/src/model/reference.rs
+++ b/crates/typst/src/model/reference.rs
@@ -1,12 +1,12 @@
 use ecow::eco_format;
 
 use crate::diag::{bail, At, Hint, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, Content, Func, IntoValue, Label, NativeElement, Show, Smart, StyleChain,
     Synthesize,
 };
 use crate::introspection::{Counter, Locatable};
-use crate::layout::Vt;
 use crate::math::EquationElem;
 use crate::model::{
     BibliographyElem, CiteElem, Destination, Figurable, FootnoteElem, Numbering,
@@ -137,14 +137,18 @@ pub struct RefElem {
 }
 
 impl Synthesize for RefElem {
-    fn synthesize(&mut self, vt: &mut Vt, styles: StyleChain) -> SourceResult<()> {
-        let citation = self.to_citation(vt, styles)?;
+    fn synthesize(
+        &mut self,
+        engine: &mut Engine,
+        styles: StyleChain,
+    ) -> SourceResult<()> {
+        let citation = self.to_citation(engine, styles)?;
         self.push_citation(Some(citation));
         self.push_element(None);
 
         let target = *self.target();
-        if !BibliographyElem::has(vt, target) {
-            if let Ok(elem) = vt.introspector.query_label(target) {
+        if !BibliographyElem::has(engine, target) {
+            if let Ok(elem) = engine.introspector.query_label(target) {
                 self.push_element(Some(elem.into_inner()));
                 return Ok(());
             }
@@ -156,18 +160,18 @@ impl Synthesize for RefElem {
 
 impl Show for RefElem {
     #[tracing::instrument(name = "RefElem::show", skip_all)]
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
-        Ok(vt.delayed(|vt| {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+        Ok(engine.delayed(|engine| {
             let target = *self.target();
-            let elem = vt.introspector.query_label(target);
+            let elem = engine.introspector.query_label(target);
             let span = self.span();
 
-            if BibliographyElem::has(vt, target) {
+            if BibliographyElem::has(engine, target) {
                 if elem.is_ok() {
                     bail!(span, "label occurs in the document and its bibliography");
                 }
 
-                return Ok(self.to_citation(vt, styles)?.spanned(span).pack());
+                return Ok(self.to_citation(engine, styles)?.spanned(span).pack());
             }
 
             let elem = elem.at(span)?;
@@ -211,14 +215,14 @@ impl Show for RefElem {
 
             let numbers = refable
                 .counter()
-                .at(vt, elem.location().unwrap())?
-                .display(vt, &numbering.trimmed())?;
+                .at(engine, elem.location().unwrap())?
+                .display(engine, &numbering.trimmed())?;
 
             let supplement = match self.supplement(styles).as_ref() {
                 Smart::Auto => refable.supplement(),
                 Smart::Custom(None) => Content::empty(),
                 Smart::Custom(Some(supplement)) => {
-                    supplement.resolve(vt, [(*elem).clone()])?
+                    supplement.resolve(engine, [(*elem).clone()])?
                 }
             };
 
@@ -234,10 +238,14 @@ impl Show for RefElem {
 
 impl RefElem {
     /// Turn the reference into a citation.
-    pub fn to_citation(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<CiteElem> {
+    pub fn to_citation(
+        &self,
+        engine: &mut Engine,
+        styles: StyleChain,
+    ) -> SourceResult<CiteElem> {
         let mut elem = CiteElem::new(*self.target());
         elem.set_location(self.location().unwrap());
-        elem.synthesize(vt, styles)?;
+        elem.synthesize(engine, styles)?;
         elem.push_supplement(match self.supplement(styles).clone() {
             Smart::Custom(Some(Supplement::Content(content))) => Some(content),
             _ => None,
@@ -258,12 +266,12 @@ impl Supplement {
     /// Tries to resolve the supplement into its content.
     pub fn resolve<T: IntoValue>(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         args: impl IntoIterator<Item = T>,
     ) -> SourceResult<Content> {
         Ok(match self {
             Supplement::Content(content) => content.clone(),
-            Supplement::Func(func) => func.call_vt(vt, args)?.display(),
+            Supplement::Func(func) => func.call(engine, args)?.display(),
         })
     }
 }
diff --git a/crates/typst/src/model/strong.rs b/crates/typst/src/model/strong.rs
index 40b99b2f..666a4aa0 100644
--- a/crates/typst/src/model/strong.rs
+++ b/crates/typst/src/model/strong.rs
@@ -1,6 +1,6 @@
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{elem, Content, Show, StyleChain};
-use crate::layout::Vt;
 use crate::text::{TextElem, WeightDelta};
 
 /// Strongly emphasizes content by increasing the font weight.
@@ -39,7 +39,7 @@ pub struct StrongElem {
 
 impl Show for StrongElem {
     #[tracing::instrument(name = "StrongElem::show", skip_all)]
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(self
             .body()
             .clone()
diff --git a/crates/typst/src/model/table.rs b/crates/typst/src/model/table.rs
index 278b898c..31c6636f 100644
--- a/crates/typst/src/model/table.rs
+++ b/crates/typst/src/model/table.rs
@@ -1,11 +1,12 @@
 use crate::diag::{At, SourceResult, StrResult};
+use crate::engine::Engine;
 use crate::foundations::{
     elem, Array, CastInfo, Content, FromValue, Func, IntoValue, NativeElement, Reflect,
     Smart, StyleChain, Value,
 };
 use crate::layout::{
     Abs, Align, AlignElem, Axes, Fragment, FrameItem, GridLayouter, Layout, Length,
-    Point, Regions, Rel, Sides, Size, TrackSizings, Vt,
+    Point, Regions, Rel, Sides, Size, TrackSizings,
 };
 use crate::model::Figurable;
 use crate::text::{Lang, LocalName, Region};
@@ -158,7 +159,7 @@ impl Layout for TableElem {
     #[tracing::instrument(name = "TableElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -181,7 +182,7 @@ impl Layout for TableElem {
 
                 let x = i % cols;
                 let y = i / cols;
-                if let Smart::Custom(alignment) = align.resolve(vt, x, y)? {
+                if let Smart::Custom(alignment) = align.resolve(engine, x, y)? {
                     child = child.styled(AlignElem::set_alignment(alignment));
                 }
 
@@ -197,7 +198,7 @@ impl Layout for TableElem {
             GridLayouter::new(tracks, gutter, &cells, regions, styles, self.span());
 
         // Measure the columns and layout the grid row-by-row.
-        let mut layout = layouter.layout(vt)?;
+        let mut layout = layouter.layout(engine)?;
 
         // Add lines and backgrounds.
         for (frame, rows) in layout.fragment.iter_mut().zip(&layout.rows) {
@@ -236,7 +237,7 @@ impl Layout for TableElem {
             for (x, &col) in layout.cols.iter().enumerate() {
                 let mut dy = Abs::zero();
                 for row in rows {
-                    if let Some(fill) = fill.resolve(vt, x, row.y)? {
+                    if let Some(fill) = fill.resolve(engine, x, row.y)? {
                         let pos = Point::new(dx, dy);
                         let size = Size::new(col, row.height);
                         let rect = Geometry::Rect(size).filled(fill);
@@ -275,10 +276,10 @@ pub enum Celled<T> {
 
 impl<T: Default + Clone + FromValue> Celled<T> {
     /// Resolve the value based on the cell position.
-    pub fn resolve(&self, vt: &mut Vt, x: usize, y: usize) -> SourceResult<T> {
+    pub fn resolve(&self, engine: &mut Engine, x: usize, y: usize) -> SourceResult<T> {
         Ok(match self {
             Self::Value(value) => value.clone(),
-            Self::Func(func) => func.call_vt(vt, [x, y])?.cast().at(func.span())?,
+            Self::Func(func) => func.call(engine, [x, y])?.cast().at(func.span())?,
             Self::Array(array) => x
                 .checked_rem(array.len())
                 .and_then(|i| array.get(i))
diff --git a/crates/typst/src/model/terms.rs b/crates/typst/src/model/terms.rs
index 1d256626..bbb6129a 100644
--- a/crates/typst/src/model/terms.rs
+++ b/crates/typst/src/model/terms.rs
@@ -1,9 +1,10 @@
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, scope, Array, Content, NativeElement, Smart, StyleChain,
 };
 use crate::layout::{
-    BlockElem, Em, Fragment, HElem, Layout, Length, Regions, Spacing, VElem, Vt,
+    BlockElem, Em, Fragment, HElem, Layout, Length, Regions, Spacing, VElem,
 };
 use crate::model::ParElem;
 use crate::util::Numeric;
@@ -110,7 +111,7 @@ impl Layout for TermsElem {
     #[tracing::instrument(name = "TermsElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -139,7 +140,7 @@ impl Layout for TermsElem {
 
         Content::sequence(seq)
             .styled(ParElem::set_hanging_indent(hanging_indent + indent))
-            .layout(vt, styles, regions)
+            .layout(engine, styles, regions)
     }
 }
 
diff --git a/crates/typst/src/realize/mod.rs b/crates/typst/src/realize/mod.rs
index 2b5ce22d..c2f19303 100644
--- a/crates/typst/src/realize/mod.rs
+++ b/crates/typst/src/realize/mod.rs
@@ -10,7 +10,8 @@ use std::mem;
 use smallvec::smallvec;
 use typed_arena::Arena;
 
-use crate::diag::{bail, SourceResult};
+use crate::diag::{bail, error, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     Content, Finalize, Guard, NativeElement, Recipe, Selector, Show, StyleChain,
     StyleVecBuilder, Styles, Synthesize,
@@ -18,7 +19,7 @@ use crate::foundations::{
 use crate::introspection::{Locatable, Meta, MetaElem};
 use crate::layout::{
     AlignElem, BlockElem, BoxElem, ColbreakElem, FlowElem, HElem, Layout, LayoutRoot,
-    PageElem, PagebreakElem, Parity, PlaceElem, VElem, Vt,
+    PageElem, PagebreakElem, Parity, PlaceElem, VElem,
 };
 use crate::math::{EquationElem, LayoutMath};
 use crate::model::{
@@ -33,6 +34,58 @@ use crate::visualize::{
     SquareElem,
 };
 
+/// Realize into an element that is capable of root-level layout.
+#[tracing::instrument(skip_all)]
+pub fn realize_root<'a>(
+    engine: &mut Engine,
+    scratch: &'a Scratch<'a>,
+    content: &'a Content,
+    styles: StyleChain<'a>,
+) -> SourceResult<(Cow<'a, Content>, StyleChain<'a>)> {
+    if content.can::<dyn LayoutRoot>() && !applicable(content, styles) {
+        return Ok((Cow::Borrowed(content), styles));
+    }
+
+    let mut builder = Builder::new(engine, scratch, true);
+    builder.accept(content, styles)?;
+    builder.interrupt_page(Some(styles), true)?;
+    let (pages, shared) = builder.doc.unwrap().pages.finish();
+    Ok((Cow::Owned(DocumentElem::new(pages.to_vec()).pack()), shared))
+}
+
+/// Realize into an element that is capable of block-level layout.
+#[tracing::instrument(skip_all)]
+pub fn realize_block<'a>(
+    engine: &mut Engine,
+    scratch: &'a Scratch<'a>,
+    content: &'a Content,
+    styles: StyleChain<'a>,
+) -> SourceResult<(Cow<'a, Content>, StyleChain<'a>)> {
+    // These elements implement `Layout` but still require a flow for
+    // proper layout.
+    if content.can::<dyn Layout>()
+        && !content.is::<BoxElem>()
+        && !content.is::<LineElem>()
+        && !content.is::<RectElem>()
+        && !content.is::<SquareElem>()
+        && !content.is::<EllipseElem>()
+        && !content.is::<CircleElem>()
+        && !content.is::<ImageElem>()
+        && !content.is::<PolygonElem>()
+        && !content.is::<PathElem>()
+        && !content.is::<PlaceElem>()
+        && !applicable(content, styles)
+    {
+        return Ok((Cow::Borrowed(content), styles));
+    }
+
+    let mut builder = Builder::new(engine, scratch, false);
+    builder.accept(content, styles)?;
+    builder.interrupt_par()?;
+    let (children, shared) = builder.flow.0.finish();
+    Ok((Cow::Owned(FlowElem::new(children.to_vec()).pack()), shared))
+}
+
 /// Whether the target is affected by show rules in the given style chain.
 pub fn applicable(target: &Content, styles: StyleChain) -> bool {
     if target.needs_preparation() {
@@ -59,7 +112,7 @@ pub fn applicable(target: &Content, styles: StyleChain) -> bool {
 
 /// Apply the show rules in the given style chain to a target.
 pub fn realize(
-    vt: &mut Vt,
+    engine: &mut Engine,
     target: &Content,
     styles: StyleChain,
 ) -> SourceResult<Option<Content>> {
@@ -67,12 +120,12 @@ pub fn realize(
     if target.needs_preparation() {
         let mut elem = target.clone();
         if target.can::<dyn Locatable>() || target.label().is_some() {
-            let location = vt.locator.locate(hash128(target));
+            let location = engine.locator.locate(hash128(target));
             elem.set_location(location);
         }
 
         if let Some(elem) = elem.with_mut::<dyn Synthesize>() {
-            elem.synthesize(vt, styles)?;
+            elem.synthesize(engine, styles)?;
         }
 
         elem.mark_prepared();
@@ -97,7 +150,7 @@ pub fn realize(
     for recipe in styles.recipes() {
         let guard = Guard::Nth(n);
         if recipe.applicable(target) && !target.is_guarded(guard) {
-            if let Some(content) = try_apply(vt, target, recipe, guard)? {
+            if let Some(content) = try_apply(engine, target, recipe, guard)? {
                 realized = Some(content);
                 break;
             }
@@ -109,7 +162,7 @@ pub fn realize(
     if let Some(showable) = target.with::<dyn Show>() {
         let guard = Guard::Base(target.func());
         if realized.is_none() && !target.is_guarded(guard) {
-            realized = Some(showable.show(vt, styles)?);
+            realized = Some(showable.show(engine, styles)?);
         }
     }
 
@@ -127,7 +180,7 @@ pub fn realize(
 
 /// Try to apply a recipe to the target.
 fn try_apply(
-    vt: &mut Vt,
+    engine: &mut Engine,
     target: &Content,
     recipe: &Recipe,
     guard: Guard,
@@ -138,7 +191,7 @@ fn try_apply(
                 return Ok(None);
             }
 
-            recipe.apply_vt(vt, target.clone().guarded(guard)).map(Some)
+            recipe.apply(engine, target.clone().guarded(guard)).map(Some)
         }
 
         Some(Selector::Label(label)) => {
@@ -146,7 +199,7 @@ fn try_apply(
                 return Ok(None);
             }
 
-            recipe.apply_vt(vt, target.clone().guarded(guard)).map(Some)
+            recipe.apply(engine, target.clone().guarded(guard)).map(Some)
         }
 
         Some(Selector::Regex(regex)) => {
@@ -172,7 +225,7 @@ fn try_apply(
                 }
 
                 let piece = make(m.as_str()).guarded(guard);
-                let transformed = recipe.apply_vt(vt, piece)?;
+                let transformed = recipe.apply(engine, piece)?;
                 result.push(transformed);
                 cursor = m.end();
             }
@@ -202,62 +255,10 @@ fn try_apply(
     }
 }
 
-/// Realize into an element that is capable of root-level layout.
-#[tracing::instrument(skip_all)]
-pub fn realize_root<'a>(
-    vt: &mut Vt,
-    scratch: &'a Scratch<'a>,
-    content: &'a Content,
-    styles: StyleChain<'a>,
-) -> SourceResult<(Cow<'a, Content>, StyleChain<'a>)> {
-    if content.can::<dyn LayoutRoot>() && !applicable(content, styles) {
-        return Ok((Cow::Borrowed(content), styles));
-    }
-
-    let mut builder = Builder::new(vt, scratch, true);
-    builder.accept(content, styles)?;
-    builder.interrupt_page(Some(styles), true)?;
-    let (pages, shared) = builder.doc.unwrap().pages.finish();
-    Ok((Cow::Owned(DocumentElem::new(pages.to_vec()).pack()), shared))
-}
-
-/// Realize into an element that is capable of block-level layout.
-#[tracing::instrument(skip_all)]
-pub fn realize_block<'a>(
-    vt: &mut Vt,
-    scratch: &'a Scratch<'a>,
-    content: &'a Content,
-    styles: StyleChain<'a>,
-) -> SourceResult<(Cow<'a, Content>, StyleChain<'a>)> {
-    // These elements implement `Layout` but still require a flow for
-    // proper layout.
-    if content.can::<dyn Layout>()
-        && !content.is::<BoxElem>()
-        && !content.is::<LineElem>()
-        && !content.is::<RectElem>()
-        && !content.is::<SquareElem>()
-        && !content.is::<EllipseElem>()
-        && !content.is::<CircleElem>()
-        && !content.is::<ImageElem>()
-        && !content.is::<PolygonElem>()
-        && !content.is::<PathElem>()
-        && !content.is::<PlaceElem>()
-        && !applicable(content, styles)
-    {
-        return Ok((Cow::Borrowed(content), styles));
-    }
-
-    let mut builder = Builder::new(vt, scratch, false);
-    builder.accept(content, styles)?;
-    builder.interrupt_par()?;
-    let (children, shared) = builder.flow.0.finish();
-    Ok((Cow::Owned(FlowElem::new(children.to_vec()).pack()), shared))
-}
-
 /// Builds a document or a flow element from content.
 struct Builder<'a, 'v, 't> {
-    /// The virtual typesetter.
-    vt: &'v mut Vt<'t>,
+    /// The engine.
+    engine: &'v mut Engine<'t>,
     /// Scratch arenas for building.
     scratch: &'a Scratch<'a>,
     /// The current document building state.
@@ -282,9 +283,9 @@ pub struct Scratch<'a> {
 }
 
 impl<'a, 'v, 't> Builder<'a, 'v, 't> {
-    fn new(vt: &'v mut Vt<'t>, scratch: &'a Scratch<'a>, top: bool) -> Self {
+    fn new(engine: &'v mut Engine<'t>, scratch: &'a Scratch<'a>, top: bool) -> Self {
         Self {
-            vt,
+            engine,
             scratch,
             doc: top.then(DocBuilder::default),
             flow: FlowBuilder::default(),
@@ -304,9 +305,19 @@ impl<'a, 'v, 't> Builder<'a, 'v, 't> {
                 self.scratch.content.alloc(EquationElem::new(content.clone()).pack());
         }
 
-        if let Some(realized) = realize(self.vt, content, styles)? {
+        if let Some(realized) = realize(self.engine, content, styles)? {
+            self.engine.route.increase();
+            if self.engine.route.exceeding() {
+                bail!(error!(content.span(), "maximum show rule depth exceeded")
+                    .with_hint("check whether the show rule matches its own output")
+                    .with_hint(
+                        "this is a current compiler limitation that will be resolved in the future"
+                    ));
+            }
             let stored = self.scratch.content.alloc(realized);
-            return self.accept(stored, styles);
+            let v = self.accept(stored, styles);
+            self.engine.route.decrease();
+            return v;
         }
 
         if let Some((elem, local)) = content.to_styled() {
diff --git a/crates/typst/src/text/deco.rs b/crates/typst/src/text/deco.rs
index f7ee8cbc..348ddf34 100644
--- a/crates/typst/src/text/deco.rs
+++ b/crates/typst/src/text/deco.rs
@@ -4,8 +4,9 @@ use ttf_parser::{GlyphId, OutlineBuilder};
 use ecow::{eco_format, EcoString};
 
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{cast, elem, ty, Content, Fold, Repr, Show, Smart, StyleChain};
-use crate::layout::{Abs, Em, Frame, FrameItem, Length, Point, Size, Vt};
+use crate::layout::{Abs, Em, Frame, FrameItem, Length, Point, Size};
 use crate::syntax::Span;
 use crate::text::{
     BottomEdge, BottomEdgeMetric, TextElem, TextItem, TopEdge, TopEdgeMetric,
@@ -85,7 +86,7 @@ pub struct UnderlineElem {
 
 impl Show for UnderlineElem {
     #[tracing::instrument(name = "UnderlineElem::show", skip_all)]
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(self.body().clone().styled(TextElem::set_deco(Decoration {
             line: DecoLine::Underline {
                 stroke: self.stroke(styles).unwrap_or_default(),
@@ -177,7 +178,7 @@ pub struct OverlineElem {
 
 impl Show for OverlineElem {
     #[tracing::instrument(name = "OverlineElem::show", skip_all)]
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(self.body().clone().styled(TextElem::set_deco(Decoration {
             line: DecoLine::Overline {
                 stroke: self.stroke(styles).unwrap_or_default(),
@@ -254,7 +255,7 @@ pub struct StrikeElem {
 
 impl Show for StrikeElem {
     #[tracing::instrument(name = "StrikeElem::show", skip_all)]
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(self.body().clone().styled(TextElem::set_deco(Decoration {
             // Note that we do not support evade option for strikethrough.
             line: DecoLine::Strikethrough {
@@ -324,7 +325,7 @@ pub struct HighlightElem {
 
 impl Show for HighlightElem {
     #[tracing::instrument(name = "HighlightElem::show", skip_all)]
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(self.body().clone().styled(TextElem::set_deco(Decoration {
             line: DecoLine::Highlight {
                 fill: self.fill(styles),
diff --git a/crates/typst/src/text/mod.rs b/crates/typst/src/text/mod.rs
index 45de35f9..da3580a5 100644
--- a/crates/typst/src/text/mod.rs
+++ b/crates/typst/src/text/mod.rs
@@ -35,7 +35,7 @@ use rustybuzz::{Feature, Tag};
 use ttf_parser::Rect;
 
 use crate::diag::{bail, error, SourceResult, StrResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{
     cast, category, elem, Args, Array, Cast, Category, Construct, Content, Dict, Fold,
     NativeElement, Never, PlainText, Repr, Resolve, Scope, Set, Smart, StyleChain, Value,
@@ -656,11 +656,11 @@ impl Repr for TextElem {
 }
 
 impl Construct for TextElem {
-    fn construct(vm: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(engine: &mut Engine, args: &mut Args) -> SourceResult<Content> {
         // The text constructor is special: It doesn't create a text element.
         // Instead, it leaves the passed argument structurally unchanged, but
         // styles all text in it.
-        let styles = Self::set(vm, args)?;
+        let styles = Self::set(engine, args)?;
         let body = args.expect::<Content>("body")?;
         Ok(body.styled_with_map(styles))
     }
diff --git a/crates/typst/src/text/raw.rs b/crates/typst/src/text/raw.rs
index 1142281c..6962dbce 100644
--- a/crates/typst/src/text/raw.rs
+++ b/crates/typst/src/text/raw.rs
@@ -10,12 +10,12 @@ use syntect::parsing::{SyntaxDefinition, SyntaxSet, SyntaxSetBuilder};
 use unicode_segmentation::UnicodeSegmentation;
 
 use crate::diag::{At, FileError, SourceResult, StrResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, scope, Args, Array, Bytes, Content, Finalize, Fold, NativeElement,
     PlainText, Show, Smart, StyleChain, Styles, Synthesize, Value,
 };
-use crate::layout::{BlockElem, Em, HAlign, Vt};
+use crate::layout::{BlockElem, Em, HAlign};
 use crate::model::Figurable;
 use crate::syntax::{split_newlines, LinkedNode, Spanned};
 use crate::text::{
@@ -191,7 +191,7 @@ pub struct RawElem {
     /// ```
     /// ````
     #[parse(
-        let (syntaxes, syntaxes_data) = parse_syntaxes(vm, args)?;
+        let (syntaxes, syntaxes_data) = parse_syntaxes(engine, args)?;
         syntaxes
     )]
     #[fold]
@@ -229,7 +229,7 @@ pub struct RawElem {
     /// ```
     /// ````
     #[parse(
-        let (theme_path, theme_data) = parse_theme(vm, args)?;
+        let (theme_path, theme_data) = parse_theme(engine, args)?;
         theme_path.map(Some)
     )]
     #[borrowed]
@@ -288,7 +288,7 @@ impl RawElem {
 }
 
 impl Synthesize for RawElem {
-    fn synthesize(&mut self, _vt: &mut Vt, styles: StyleChain) -> SourceResult<()> {
+    fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
         self.push_lang(self.lang(styles).clone());
 
         let mut text = self.text().clone();
@@ -393,7 +393,7 @@ impl Synthesize for RawElem {
 
 impl Show for RawElem {
     #[tracing::instrument(name = "RawElem::show", skip_all)]
-    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let mut lines = EcoVec::with_capacity((2 * self.lines().len()).saturating_sub(1));
         for (i, line) in self.lines().iter().enumerate() {
             if i != 0 {
@@ -495,7 +495,7 @@ pub struct RawLine {
 }
 
 impl Show for RawLine {
-    fn show(&self, _vt: &mut Vt, _styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, _styles: StyleChain) -> SourceResult<Content> {
         Ok(self.body().clone())
     }
 }
@@ -676,7 +676,7 @@ fn load_syntaxes(paths: &SyntaxPaths, bytes: &[Bytes]) -> StrResult<Arc<SyntaxSe
 /// Function to parse the syntaxes argument.
 /// Much nicer than having it be part of the `element` macro.
 fn parse_syntaxes(
-    vm: &mut Vm,
+    engine: &mut Engine,
     args: &mut Args,
 ) -> SourceResult<(Option<SyntaxPaths>, Option<Vec<Bytes>>)> {
     let Some(Spanned { v: paths, span }) =
@@ -690,8 +690,8 @@ fn parse_syntaxes(
         .0
         .iter()
         .map(|path| {
-            let id = vm.resolve_path(path).at(span)?;
-            vm.world().file(id).at(span)
+            let id = span.resolve_path(path).at(span)?;
+            engine.world.file(id).at(span)
         })
         .collect::<SourceResult<Vec<Bytes>>>()?;
 
@@ -713,7 +713,7 @@ fn load_theme(path: &str, bytes: &Bytes) -> StrResult<Arc<synt::Theme>> {
 /// Function to parse the theme argument.
 /// Much nicer than having it be part of the `element` macro.
 fn parse_theme(
-    vm: &mut Vm,
+    engine: &mut Engine,
     args: &mut Args,
 ) -> SourceResult<(Option<EcoString>, Option<Bytes>)> {
     let Some(Spanned { v: path, span }) = args.named::<Spanned<EcoString>>("theme")?
@@ -722,8 +722,8 @@ fn parse_theme(
     };
 
     // Load theme file.
-    let id = vm.resolve_path(&path).at(span)?;
-    let data = vm.world().file(id).at(span)?;
+    let id = span.resolve_path(&path).at(span)?;
+    let data = engine.world.file(id).at(span)?;
 
     // Check that parsing works.
     let _ = load_theme(&path, &data).at(span)?;
diff --git a/crates/typst/src/text/shift.rs b/crates/typst/src/text/shift.rs
index 73f28343..e467d6c0 100644
--- a/crates/typst/src/text/shift.rs
+++ b/crates/typst/src/text/shift.rs
@@ -1,8 +1,9 @@
 use ecow::EcoString;
 
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{elem, Content, Show, StyleChain};
-use crate::layout::{Em, Length, Vt};
+use crate::layout::{Em, Length};
 use crate::text::{variant, SpaceElem, TextElem, TextSize};
 use crate::World;
 
@@ -48,12 +49,12 @@ pub struct SubElem {
 
 impl Show for SubElem {
     #[tracing::instrument(name = "SubElem::show", skip_all)]
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body().clone();
         let mut transformed = None;
         if self.typographic(styles) {
             if let Some(text) = search_text(&body, true) {
-                if is_shapable(vt, &text, styles) {
+                if is_shapable(engine, &text, styles) {
                     transformed = Some(TextElem::packed(text));
                 }
             }
@@ -108,12 +109,12 @@ pub struct SuperElem {
 
 impl Show for SuperElem {
     #[tracing::instrument(name = "SuperElem::show", skip_all)]
-    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body().clone();
         let mut transformed = None;
         if self.typographic(styles) {
             if let Some(text) = search_text(&body, false) {
-                if is_shapable(vt, &text, styles) {
+                if is_shapable(engine, &text, styles) {
                     transformed = Some(TextElem::packed(text));
                 }
             }
@@ -149,8 +150,8 @@ fn search_text(content: &Content, sub: bool) -> Option<EcoString> {
 
 /// Checks whether the first retrievable family contains all code points of the
 /// given string.
-fn is_shapable(vt: &Vt, text: &str, styles: StyleChain) -> bool {
-    let world = vt.world;
+fn is_shapable(engine: &Engine, text: &str, styles: StyleChain) -> bool {
+    let world = engine.world;
     for family in TextElem::font_in(styles) {
         if let Some(font) = world
             .book()
diff --git a/crates/typst/src/visualize/image/mod.rs b/crates/typst/src/visualize/image/mod.rs
index 722e77a6..159dc14a 100644
--- a/crates/typst/src/visualize/image/mod.rs
+++ b/crates/typst/src/visualize/image/mod.rs
@@ -14,13 +14,14 @@ use comemo::{Prehashed, Tracked};
 use ecow::EcoString;
 
 use crate::diag::{bail, At, SourceResult, StrResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, func, scope, Bytes, Cast, Content, NativeElement, Resolve, Smart,
     StyleChain,
 };
 use crate::layout::{
     Abs, Axes, FixedAlign, Fragment, Frame, FrameItem, Layout, Length, Point, Regions,
-    Rel, Size, Vt,
+    Rel, Size,
 };
 use crate::loading::Readable;
 use crate::model::Figurable;
@@ -57,8 +58,8 @@ pub struct ImageElem {
     #[parse(
         let Spanned { v: path, span } =
             args.expect::<Spanned<EcoString>>("path to image file")?;
-        let id = vm.resolve_path(&path).at(span)?;
-        let data = vm.world().file(id).at(span)?;
+        let id = span.resolve_path(&path).at(span)?;
+        let data = engine.world.file(id).at(span)?;
         path
     )]
     #[borrowed]
@@ -145,7 +146,7 @@ impl Layout for ImageElem {
     #[tracing::instrument(name = "ImageElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
@@ -181,7 +182,7 @@ impl Layout for ImageElem {
             data.clone().into(),
             format,
             self.alt(styles),
-            vt.world,
+            engine.world,
             &families(styles).map(|s| s.into()).collect::<Vec<_>>(),
         )
         .at(self.span())?;
diff --git a/crates/typst/src/visualize/line.rs b/crates/typst/src/visualize/line.rs
index 118395ec..ece93727 100644
--- a/crates/typst/src/visualize/line.rs
+++ b/crates/typst/src/visualize/line.rs
@@ -1,7 +1,8 @@
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{elem, NativeElement, StyleChain};
 use crate::layout::{
-    Abs, Angle, Axes, Fragment, Frame, FrameItem, Layout, Length, Regions, Rel, Size, Vt,
+    Abs, Angle, Axes, Fragment, Frame, FrameItem, Layout, Length, Regions, Rel, Size,
 };
 use crate::util::Numeric;
 use crate::visualize::{Geometry, Stroke};
@@ -61,7 +62,7 @@ impl Layout for LineElem {
     #[tracing::instrument(name = "LineElem::layout", skip_all)]
     fn layout(
         &self,
-        _: &mut Vt,
+        _: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
diff --git a/crates/typst/src/visualize/path.rs b/crates/typst/src/visualize/path.rs
index f2e1466f..6ed07cb2 100644
--- a/crates/typst/src/visualize/path.rs
+++ b/crates/typst/src/visualize/path.rs
@@ -1,11 +1,12 @@
 use kurbo::{CubicBez, ParamCurveExtrema};
 
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     array, cast, elem, Array, NativeElement, Reflect, Resolve, Smart, StyleChain,
 };
 use crate::layout::{
-    Abs, Axes, Fragment, Frame, FrameItem, Layout, Length, Point, Regions, Rel, Size, Vt,
+    Abs, Axes, Fragment, Frame, FrameItem, Layout, Length, Point, Regions, Rel, Size,
 };
 use crate::visualize::{FixedStroke, Geometry, Paint, Shape, Stroke};
 
@@ -73,7 +74,7 @@ impl Layout for PathElem {
     #[tracing::instrument(name = "PathElem::layout", skip_all)]
     fn layout(
         &self,
-        _: &mut Vt,
+        _: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
diff --git a/crates/typst/src/visualize/pattern.rs b/crates/typst/src/visualize/pattern.rs
index 55d68500..3014a8e0 100644
--- a/crates/typst/src/visualize/pattern.rs
+++ b/crates/typst/src/visualize/pattern.rs
@@ -5,7 +5,7 @@ use comemo::Prehashed;
 use ecow::{eco_format, EcoString};
 
 use crate::diag::{bail, error, SourceResult};
-use crate::eval::Vm;
+use crate::engine::Engine;
 use crate::foundations::{func, scope, ty, Content, Repr, Smart, StyleChain};
 use crate::layout::{Abs, Axes, Em, Frame, Layout, Length, Regions, Size};
 use crate::syntax::{Span, Spanned};
@@ -120,7 +120,7 @@ impl Pattern {
     /// ```
     #[func(constructor)]
     pub fn construct(
-        vm: &mut Vm,
+        engine: &mut Engine,
         /// The bounding box of each cell of the pattern.
         #[named]
         #[default(Spanned::new(Smart::Auto, Span::detached()))]
@@ -173,11 +173,11 @@ impl Pattern {
         let region = size.unwrap_or_else(|| Axes::splat(Abs::inf()));
 
         // Layout the pattern.
-        let world = vm.vt.world;
+        let world = engine.world;
         let library = world.library();
         let styles = StyleChain::new(&library.styles);
         let pod = Regions::one(region, Axes::splat(false));
-        let mut frame = body.layout(&mut vm.vt, styles, pod)?.into_frame();
+        let mut frame = body.layout(engine, styles, pod)?.into_frame();
 
         // Check that the frame is non-zero.
         if size.is_auto() && frame.size().is_zero() {
diff --git a/crates/typst/src/visualize/polygon.rs b/crates/typst/src/visualize/polygon.rs
index 3b818fa4..7436f63e 100644
--- a/crates/typst/src/visualize/polygon.rs
+++ b/crates/typst/src/visualize/polygon.rs
@@ -1,11 +1,12 @@
 use std::f64::consts::PI;
 
 use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
 use crate::foundations::{
     elem, func, scope, Content, NativeElement, Resolve, Smart, StyleChain,
 };
 use crate::layout::{
-    Axes, Em, Fragment, Frame, FrameItem, Layout, Length, Point, Regions, Rel, Vt,
+    Axes, Em, Fragment, Frame, FrameItem, Layout, Length, Point, Regions, Rel,
 };
 use crate::util::Numeric;
 use crate::visualize::{FixedStroke, Geometry, Paint, Path, Shape, Stroke};
@@ -125,7 +126,7 @@ impl Layout for PolygonElem {
     #[tracing::instrument(name = "PolygonElem::layout", skip_all)]
     fn layout(
         &self,
-        _: &mut Vt,
+        _: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
diff --git a/crates/typst/src/visualize/shape.rs b/crates/typst/src/visualize/shape.rs
index d1a2a155..fcdcfc31 100644
--- a/crates/typst/src/visualize/shape.rs
+++ b/crates/typst/src/visualize/shape.rs
@@ -1,10 +1,11 @@
 use std::f64::consts::SQRT_2;
 
 use crate::diag::SourceResult;
+use crate::engine::Engine;
 use crate::foundations::{elem, Content, NativeElement, Resolve, Smart, StyleChain};
 use crate::layout::{
     Abs, Axes, Corner, Corners, Fragment, Frame, FrameItem, Layout, Length, Point, Ratio,
-    Regions, Rel, Sides, Size, Vt,
+    Regions, Rel, Sides, Size,
 };
 use crate::syntax::Span;
 use crate::util::Get;
@@ -134,12 +135,12 @@ impl Layout for RectElem {
     #[tracing::instrument(name = "RectElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
         layout(
-            vt,
+            engine,
             styles,
             regions,
             ShapeKind::Rect,
@@ -240,12 +241,12 @@ impl Layout for SquareElem {
     #[tracing::instrument(name = "SquareElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
         layout(
-            vt,
+            engine,
             styles,
             regions,
             ShapeKind::Square,
@@ -318,12 +319,12 @@ impl Layout for EllipseElem {
     #[tracing::instrument(name = "EllipseElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
         layout(
-            vt,
+            engine,
             styles,
             regions,
             ShapeKind::Ellipse,
@@ -421,12 +422,12 @@ impl Layout for CircleElem {
     #[tracing::instrument(name = "CircleElem::layout", skip_all)]
     fn layout(
         &self,
-        vt: &mut Vt,
+        engine: &mut Engine,
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
         layout(
-            vt,
+            engine,
             styles,
             regions,
             ShapeKind::Circle,
@@ -446,7 +447,7 @@ impl Layout for CircleElem {
 #[tracing::instrument(name = "shape::layout", skip_all)]
 #[allow(clippy::too_many_arguments)]
 fn layout(
-    vt: &mut Vt,
+    engine: &mut Engine,
     styles: StyleChain,
     regions: Regions,
     kind: ShapeKind,
@@ -473,7 +474,7 @@ fn layout(
         let child = child.clone().padded(inset.map(|side| side.map(Length::from)));
         let expand = sizing.as_ref().map(Smart::is_custom);
         let pod = Regions::one(region, expand);
-        frame = child.layout(vt, styles, pod)?.into_frame();
+        frame = child.layout(engine, styles, pod)?.into_frame();
 
         // Enforce correct size.
         *frame.size_mut() = expand.select(region, frame.size());
@@ -484,7 +485,7 @@ fn layout(
             frame.set_size(Size::splat(frame.size().max_by_side()));
             let length = frame.size().max_by_side().min(region.min_by_side());
             let pod = Regions::one(Size::splat(length), Axes::splat(true));
-            frame = child.layout(vt, styles, pod)?.into_frame();
+            frame = child.layout(engine, styles, pod)?.into_frame();
         }
 
         // Enforce correct size again.