diff --git a/Cargo.toml b/Cargo.toml
index e14ae09..62fce03 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,14 +28,11 @@ codegen-units = 16
 [dependencies]
 base64 = "0.23.0"
 fast5ever = { git = "https://github.com/AnswerDotAI/fast5ever" }
-fastpylight = { git = "https://github.com/AnswerDotAI/fastpylight", default-features = false, features = ["standard-languages", "themes"], optional = true }
 html-escape = ">=0.2"
 pyo3 = { version = ">=0.28", optional = true }
 unicode-properties = "0.1"
 
 [features]
-default = ["hl"]
-hl = ["dep:fastpylight"]
 python = ["dep:pyo3"]
 extension-module = ["python", "pyo3/extension-module"]
 
diff --git a/DEV.md b/DEV.md
index e67009c..c2eab1a 100644
--- a/DEV.md
+++ b/DEV.md
@@ -96,6 +96,13 @@ gen_docs()
 
 Rust renders provisional markup and does no HTML parsing. `python/mdhtml/__init__.py` sends that markup through `mdhtml2dom`, backed by [fast5ever](https://github.com/AnswerDotAI/fast5ever) (html5ever with an arena DOM and Python bindings), so parsing, tree construction, and serialization are the WHATWG algorithms as one engine spells them. The README describes the public API and `docs/DIALECT.md` defines the resulting DOM contract.
 
+Non-Markdown syntax highlighting is an optional Python-layer adapter rather
+than a Rust dependency. Python imports fastpylight lazily and passes its result
+through `HtmlExportOptions::hl_fn`; the base Rust crate therefore carries no
+fastpylight or tree-sitter code. Without the `hl` extra, `mdhtml2html` leaves
+those code blocks plain and reports a warning, while Markdown fences continue
+to use mdhtml's own highlighter.
+
 `ops()` is the semantic-operation view over that DOM. Its traversal follows both ordinary children and inert `template.content`, returning live fast5ever nodes so source-specific pipelines can detach or replace operations without adding mutation policy to mdhtml.
 
 ## Render callbacks
diff --git a/README.md b/README.md
index d1db7df..c32db0c 100644
--- a/README.md
+++ b/README.md
@@ -61,6 +61,13 @@ Install via pip to get both the Python API and the `md2mdhtml` CLI:
 pip install mdhtml
 ```
 
+The base install has no syntax-highlighter dependency. Install `mdhtml[hl]` for
+fastpylight highlighting and the theme assets used by `md2html` and `viewmd`:
+
+```bash
+pip install 'mdhtml[hl]'
+```
+
 The CLI reads Markdown from stdin or from an optional file path and writes an MDHTML fragment to stdout:
 
 ```bash
@@ -72,7 +79,7 @@ md2mdhtml --implicit_figures input.md > out.html
 md2mdhtml --no-bare_autolinks input.md > out.html
 ```
 
-`md2html` goes the rest of the way, lowering that fragment to a finished HTML page: references baked, headings and captions numbered, code highlighted (```` ```markdown ```` fences by mdhtml itself, everything else by fastpylight), mustache tokens shown as styled pills, and the assets those features need (`dialect_css`, light and dark fastpylight themes, KaTeX plus `math_js`) composed into the page. With no `--out` it writes the page under `~/.cache/md2html/` and opens it in a browser, inlining local images so the page renders from anywhere; piped, it writes to stdout instead, and `--out -` forces that even at a terminal. `--fragment` emits the body alone. `--frontmatter` recognizes a leading metadata block (see below), and ```mermaid fences become diagrams drawn in place by mermaid.js. References default to `--refs=ids`, which shows each reference's target id and never fails on a draft; `--refs=resolve` numbers them and raises on a broken one, and `--refs=lenient` numbers what it can and warns about the rest.
+`md2html` goes the rest of the way, lowering that fragment to a finished HTML page: references baked, headings and captions numbered, code highlighted (```` ```markdown ```` fences by mdhtml itself, everything else by the optional fastpylight extra), mustache tokens shown as styled pills, and the assets those features need (`dialect_css`, light and dark fastpylight themes, KaTeX plus `math_js`) composed into the page. With no `--out` it writes the page under `~/.cache/md2html/` and opens it in a browser, inlining local images so the page renders from anywhere; piped, it writes to stdout instead, and `--out -` forces that even at a terminal. `--fragment` emits the body alone. `--frontmatter` recognizes a leading metadata block (see below), and ```mermaid fences become diagrams drawn in place by mermaid.js. References default to `--refs=ids`, which shows each reference's target id and never fails on a draft; `--refs=resolve` numbers them and raises on a broken one, and `--refs=lenient` numbers what it can and warns about the rest.
 
 ```bash
 md2html input.md
@@ -365,7 +372,7 @@ The result is still a body fragment (a str subclass carrying a `warnings` list;
 - `{=html}` raw data is decoded and spliced in place; raw data for other formats is removed. Malformed payloads are dropped with a warning.
 - A `colwidths` attribute lowers to a `<colgroup>`; `fr` values share the width remaining after fixed lengths.
 - A `width` attribute on a table lowers to an inline style width (bare number = px; invalid values stay visible); it merges last, so it beats `colwidths`' `width:100%`.
-- Code blocks with a language are highlighted (natively, via the statically linked fastpylight engine): `hl='spans'` (default) emits `hl-*` classed spans, `hl='api'` wraps the block in the `<hl-code>` element for the CSS Custom Highlight API, and `hl=None` leaves code untouched. Two per-block hooks customize this: `hl_lang(text, lang)` may return a corrected language before highlighting (e.g. mapping a `%%sql` first line to `sql`), and `code_wrap(html, lang, text)` may return replacement markup for the finished block (a copy-button wrapper, a mermaid `pre`).
+- Code blocks with a language are highlighted through the optional [fastpylight](https://github.com/AnswerDotAI/fastpylight) package (`pip install 'mdhtml[hl]'`): `hl='spans'` (default) emits `hl-*` classed spans, `hl='api'` wraps the block in the `<hl-code>` element for the CSS Custom Highlight API, and `hl=None` leaves code untouched. Without fastpylight installed, code blocks render plain and a warning reports it (```` ```markdown ```` fences always self-highlight, with no dependency). Rust consumers get the same seam as the `hl_fn` slot on `HtmlExportOptions`: a `(code, lang, mode)` hook returning highlighted markup. Two per-block hooks customize this: `hl_lang(text, lang)` may return a corrected language before highlighting (e.g. mapping a `%%sql` first line to `sql`), and `code_wrap(html, lang, text)` may return replacement markup for the finished block (a copy-button wrapper, a mermaid `pre`).
 - `toc=True` prepends a `<nav class="toc">` of the headings.
 - `auto_ids` (on by default) derives pandoc-style ids for headings without one, deduplicated per export — pass `auto_ids=False` for fragments sharing a page.
 - A `div` classed `details` lowers to a `<details>` element; a first-child heading becomes its `<summary>` (id kept, excluded from the TOC and numbering). Non-HTML exporters degrade it to a bold label line; the class word is reserved by [the dialect's converter obligations](docs/DIALECT.md#converter-obligations).
@@ -445,4 +452,3 @@ maturin develop && pytest -q
 ```
 
 The spec-conformance suite is `tests/test_conformance.py`: it renders the fixtures under `tests/source/` and compares normalized HTML trees. Run just that file with `pytest tests/test_conformance.py -v` to see per-example ids.
-
diff --git a/pyproject.toml b/pyproject.toml
index ffd59b9..b5722fa 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,6 +29,7 @@ Issues = "https://github.com/AnswerDotAI/mdhtml/issues"
 
 [project.optional-dependencies]
 fill = ["execnb>=0.3.2"]
+hl = ["fastpylight>=0.1.6"]
 dev = ["fastship>=0.0.14", "maturin~=1.0", "pytest", "execnb>=0.3.2", "fastpylight>=0.1.6", "math-core~=0.7.0"]
 
 [project.entry-points.fastaudit_safe_native]
diff --git a/python/mdhtml/__init__.py b/python/mdhtml/__init__.py
index 97ab989..a195523 100644
--- a/python/mdhtml/__init__.py
+++ b/python/mdhtml/__init__.py
@@ -6,7 +6,7 @@
 from fast5ever import Element, Node, parse_fragment as mdhtml2dom
 from ._native import (blocks as _blocks, edit_nodes as _edit_nodes, highlight_md, mdhtml2md,
     md2mdhtml as _md2mdhtml, wiki2mdhtml as _wiki2mdhtml)
-from .export import dialect_css, math_js, meta_table, theme_css, themes, mdhtml2html
+from .export import dialect_css, math_js, meta_table, mdhtml2html
 from .md import _normalize_offsets, md2gfm
 from .fill import frontmatter_data, instantiate, fill_md, tokens
 from .typst import mdhtml2pdf, mdhtml2typst
diff --git a/python/mdhtml/export.py b/python/mdhtml/export.py
index 1de66e3..a61f5a5 100644
--- a/python/mdhtml/export.py
+++ b/python/mdhtml/export.py
@@ -6,10 +6,10 @@
 
 from fast5ever import Element
 from ._native import HeadingNums, Resolver as _Resolver, group_plan, anchors, ref_tokens, ref_variant, target_kind
-from ._native import REFTYPES, SCHEMES, decode_raw as _decode_raw, dialect_css, export_html as _export_html, math_js as _math_js, theme_css, themes
+from ._native import REFTYPES, SCHEMES, decode_raw as _decode_raw, dialect_css, export_html as _export_html, math_js as _math_js
 
 
-__all__ = ["SCHEMES", "REFTYPES", "ref_tokens", "ref_variant", "target_kind", "anchors", "decode_raw", "tmpl_node", "group_plan", "HeadingNums", "Resolver", "mdhtml2html", "math_js", "meta_table", "dialect_css", "theme_css", "themes"]
+__all__ = ["SCHEMES", "REFTYPES", "ref_tokens", "ref_variant", "target_kind", "anchors", "decode_raw", "tmpl_node", "group_plan", "HeadingNums", "Resolver", "mdhtml2html", "math_js", "meta_table", "dialect_css"]
 
 
 _HEADS = {"h1", "h2", "h3", "h4", "h5", "h6"}
@@ -62,6 +62,24 @@ def _els(el): return [c for c in el.children if isinstance(c, Element)]
 def _text(el): return " ".join(el.to_text().split())
 
 
+def _fastpylight():
+    "The fastpylight module, imported lazily: highlighting and themes install via `pip install 'mdhtml[hl]'`."
+    try: import fastpylight
+    except ImportError as e: raise ImportError("highlighting and themes need fastpylight: pip install 'mdhtml[hl]'") from e
+    return fastpylight
+
+
+def _hl_fn(hl):
+    "A per-block highlighter callback wrapping fastpylight, or None when it isn't installed (the exporter then warns)."
+    try: fp = _fastpylight()
+    except ImportError: return None
+    f = fp.highlight_spans if hl == "spans" else fp.highlight
+    def go(text, lang):
+        try: return f(text, lang)
+        except ValueError: return None  # unknown language: the block stays plain
+    return go
+
+
 def mdhtml2html(src, dest=None, reftypes: dict | None = None, number_headings=None, hl: str | None = "spans", auto_ids: bool = True,
     toc: bool = False, refs: str = "resolve", id_prefix: str = "", fn_salt: str = "", hl_lang=None, code_wrap=None) -> Html:
     """Lower MDHTML (a string or DocumentFragment; never mutated) to finished HTML: cross-references
@@ -84,10 +102,13 @@ def mdhtml2html(src, dest=None, reftypes: dict | None = None, number_headings=No
     distinct. Per code block, `hl_lang(text, lang)` may
     return a corrected language (`lang` is None for a bare fence), and `code_wrap(html, lang, text)`
     may return replacement markup for the highlighted block (None keeps it; `text` is unescaped).
+    Highlighting comes from the optional fastpylight package (`pip install 'mdhtml[hl]'`);
+    without it, code blocks render plain and a warning reports it.
     Returns an `Html` str carrying `.warnings`; `dest` also writes it to a file."""
     if refs not in ("resolve", "ids", "lenient"): raise ValueError(f"unknown refs mode {refs!r}")
     if not isinstance(src, str): src = src.to_html()
-    out, warnings = _export_html(src, reftypes, number_headings, hl, toc, refs, id_prefix, fn_salt, hl_lang, code_wrap, auto_ids)
+    hl_fn = None if hl is None else _hl_fn(hl)
+    out, warnings = _export_html(src, reftypes, number_headings, hl, toc, refs, id_prefix, fn_salt, hl_lang, code_wrap, hl_fn, auto_ids)
     res = Html(out, warnings)
     if dest is not None: Path(dest).write_text(res, encoding="utf-8")
     return res
diff --git a/python/mdhtml/md2html.py b/python/mdhtml/md2html.py
index c32cbd5..e8e359a 100644
--- a/python/mdhtml/md2html.py
+++ b/python/mdhtml/md2html.py
@@ -9,7 +9,8 @@
 from fastcore.meta import delegates
 from fastcore.script import call_parse
 
-from . import dialect_css, math_js, meta_table, mdhtml2dom, theme_css, mdhtml2html, md2mdhtml
+from . import dialect_css, math_js, meta_table, mdhtml2dom, mdhtml2html, md2mdhtml
+from .export import _fastpylight
 from .mustache import MUSTACHE, mustache_pill
 from fast5ever import Element
 from ._cli import parse_args, read_src
@@ -53,7 +54,7 @@ def _code_wrap(html, lang, text):
 
 def page(body, title="mdhtml", theme="vscode_light", dark_theme="vscode_dark", preview=False, math=True, head=()):
     "A standalone HTML page around an exported `body` fragment, with the assets its features need; `head` chunks (`<style>`, `<script>`, `<link>`, ...) are inserted verbatim at the end of `<head>`"
-    hl = "".join(f"@media (prefers-color-scheme: {m}) {{\n{theme_css(t)}}}\n" for m, t in (("light", theme), ("dark", dark_theme)))
+    hl = "".join(f"@media (prefers-color-scheme: {m}) {{\n{_fastpylight().theme_css(t)}}}\n" for m, t in (("light", theme), ("dark", dark_theme)))
     css = PAGE_CSS + dialect_css(preview=preview) + hl
     katex = (f'<link rel="stylesheet" href="{KATEX}/katex.min.css">\n'
         f'<script type="module">import katex from "{KATEX}/katex.mjs";\n{math_js()}</script>') if math else ""
@@ -87,7 +88,7 @@ def main(
     number_headings: NumMode = None,  # Heading numbering scheme
     toc: bool = False,  # Prepend a table of contents
     hl: HlMode = HlMode.spans,  # Code highlighting: classed spans, the Highlight API, or off
-    theme: str = "vscode_light",  # Code colors in light mode: any name from `mdhtml.themes()`
+    theme: str = "vscode_light",  # Code colors in light mode: any name from `fastpylight.themes()`
     dark_theme: str = "vscode_dark",  # Code colors in dark mode
     templates: bool = True,  # Show mustache `{{tokens}}` as styled pills
     auto_ids: bool = True,  # Derive ids for headings
diff --git a/python/mdhtml/viewmd.py b/python/mdhtml/viewmd.py
index 49e2ddc..19f74c8 100644
--- a/python/mdhtml/viewmd.py
+++ b/python/mdhtml/viewmd.py
@@ -10,7 +10,8 @@
 from aidialog.dialog import dlg2md
 from aidialog.ipynb import read_ipynb
 
-from . import DASHES, replacements, theme_css, mdhtml2html, md2mdhtml
+from . import DASHES, replacements, mdhtml2html, md2mdhtml
+from .export import _fastpylight
 from .mustache import MUSTACHE, mustache_pill
 from ._cli import parse_args, read_src
 from . import meta_table
@@ -33,7 +34,7 @@ def _copy_wrap(html, lang, text):
 
 def assets():
     "The viewer's stylesheet, controls, and script, as one blob appended to the page body"
-    hl = "".join(theme_css(t, f'[data-hl="{t}"] pre code') for _, lt, dk in THEMES for t in (lt, dk))
+    hl = "".join(_fastpylight().theme_css(t, f'[data-hl="{t}"] pre code') for _, lt, dk in THEMES for t in (lt, dk))
     opts = "".join(f'<option value="{lbl}">{lbl}</option>' for lbl, _, _ in THEMES)
     return (f"<style>{VIEW_CSS}{hl}</style>{CONTROLS.replace('__OPTS__', opts)}"
         f"<script>{VIEW_JS.replace('__THEMES__', json.dumps(THEMES))}</script>")
diff --git a/src/chunk.rs b/src/chunk.rs
index 0159196..cb4bc41 100644
--- a/src/chunk.rs
+++ b/src/chunk.rs
@@ -1,8 +1,8 @@
 //! Fast hierarchical Markdown chunking, following the existing Wikipedia
 //! pipeline's H2, H3, H4, then paragraph passes.
 
-use crate::{Block, Document, Options, render_md};
 use crate::block::parse_block_boundaries;
+use crate::{Block, Document, Options, render_md};
 use std::ops::Range;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -244,8 +244,7 @@ fn range_words(range: &StructuralRange, word_totals: &[usize]) -> usize {
 fn structural_sections(range: &StructuralRange, level: Option<u8>, starts: &[ChunkStart]) -> Vec<StructuralRange> {
     let mut cuts = vec![range.blocks.start];
     cuts.extend((range.blocks.start + 1..range.blocks.end).filter(|&i| level.is_none_or(|level| starts[i] == ChunkStart::Heading(level))));
-    cuts
-        .iter()
+    cuts.iter()
         .enumerate()
         .map(|(i, &start)| StructuralRange {
             blocks: start..cuts.get(i + 1).copied().unwrap_or(range.blocks.end),
diff --git a/src/export_html.rs b/src/export_html.rs
index 7c9bb7d..1d7457f 100644
--- a/src/export_html.rs
+++ b/src/export_html.rs
@@ -36,9 +36,13 @@ pub enum RefsMode {
 }
 
 /// Per-code-block hooks. Errors short-circuit the export; the pyo3 bridge
-/// stores the original Python exception and re-raises it.
+/// stores the original Python exception and re-raises it. `HlHook` receives
+/// `(code, lang, mode)` and returns highlighted markup: inner spans or a whole
+/// `<pre><code>` block for `Spans`, `<hl-code toks=...>` component markup for
+/// `Api`. `None` leaves the block plain.
 pub type HlLangHook<'a> = &'a (dyn Fn(&str, Option<&str>) -> Result<Option<String>, String> + Send + Sync);
 pub type CodeWrapHook<'a> = &'a (dyn Fn(&str, Option<&str>, &str) -> Result<Option<String>, String> + Send + Sync);
+pub type HlHook<'a> = &'a (dyn Fn(&str, &str, HlMode) -> Result<Option<String>, String> + Send + Sync);
 
 #[derive(Default)]
 pub struct HtmlExportOptions<'a> {
@@ -51,6 +55,7 @@ pub struct HtmlExportOptions<'a> {
     pub fn_salt: String,
     pub hl_lang: Option<HlLangHook<'a>>,
     pub code_wrap: Option<CodeWrapHook<'a>>,
+    pub hl_fn: Option<HlHook<'a>>,
     pub auto_ids: bool,
 }
 
@@ -207,7 +212,7 @@ impl Exporter {
                 self.table_width(t);
             }
         }
-        let hl_on = opts.hl.is_some() && cfg!(feature = "hl");
+        let hl_on = opts.hl.is_some();
         if hl_on || opts.hl_lang.is_some() || opts.code_wrap.is_some() {
             for &pre in &els {
                 if ename(&self.dom, pre) == Some("pre") {
@@ -564,30 +569,47 @@ impl Exporter {
                 }
             }
         }
-        #[cfg_attr(not(feature = "hl"), allow(unused_mut))] // reassigned only in api mode
         let mut cur = pre;
-        #[cfg(feature = "hl")]
         if opts.hl.is_some()
             && let Some(l) = &lang
         {
             // The dialect highlights itself: `md` fences go through
-            // `highlight_md` (always span-shaped), everything else through
-            // fastpylight.
+            // `highlight_md` (always span-shaped); every other language goes
+            // to the `hl_fn` hook, when one is provided.
             let own = matches!(l.as_str(), "markdown" | "md");
-            let inner = if own {
+            if !own && opts.hl_fn.is_none() && !self.warnings.iter().any(|w| w.starts_with("highlighting requested")) {
+                self.warnings
+                    .push("highlighting requested but no highlighter provided: code blocks render plain (from Python, pip install 'mdhtml[hl]')".to_string());
+            }
+            let markup = if own {
                 Some(crate::highlight::highlight_md(&text, "hl-"))
             } else if opts.hl == Some(HlMode::Spans) {
-                fastpylight::highlighted_inner(&text, l, "hl-").ok()
+                match opts.hl_fn {
+                    Some(hook) => hook(&text, l, HlMode::Spans)?,
+                    None => None,
+                }
             } else {
                 None
             };
-            if let Some(inner) = inner {
-                let frag = parse_fragment(&inner, "body");
-                let imported = self.dom.import(&frag, DOCUMENT);
+            if let Some(markup) = markup {
+                // A hook may return inner spans or a whole `<pre><code>` block;
+                // either way our own wrapper elements and their attributes stay.
+                let frag = parse_fragment(&markup, "body");
+                let mut src = DOCUMENT;
+                if let [root] = el_children(&frag, DOCUMENT)[..]
+                    && ename(&frag, root) == Some("pre")
+                    && let Some(c) = el_children(&frag, root).into_iter().find(|&c| ename(&frag, c) == Some("code"))
+                {
+                    src = c;
+                }
                 self.dom.clear_children(code);
-                self.dom.append_child(code, imported).unwrap();
+                for child in frag.children(src).to_vec() {
+                    let imported = self.dom.import(&frag, child);
+                    self.dom.append_child(code, imported).unwrap();
+                }
             } else if opts.hl == Some(HlMode::Api)
-                && let Ok(markup) = fastpylight::highlight_component(&text, l)
+                && let Some(hook) = opts.hl_fn
+                && let Some(markup) = hook(&text, l, HlMode::Api)?
             {
                 let frag = parse_fragment(&markup, "body");
                 let root = el_children(&frag, DOCUMENT).first().copied();
diff --git a/src/lib.rs b/src/lib.rs
index c484feb..b6af9a9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -29,10 +29,12 @@ pub use ast::{
     Align, Attr, Block, DefinitionItem, DefinitionTerm, Document, Footnote, HtmlToken, Inline, ListItem, Operation, OperationArg, TableCell, TableCellData,
     TableRow, TableRowData,
 };
-pub use fast5ever;
 pub use block::BlockSpan;
-pub use chunk::{ChunkStart, MdChunk, MdChunkRange, document_chunk_ranges_structural, document_chunks_structural, md_chunks, md_chunks_greedy, md_chunks_structural};
+pub use chunk::{
+    ChunkStart, MdChunk, MdChunkRange, document_chunk_ranges_structural, document_chunks_structural, md_chunks, md_chunks_greedy, md_chunks_structural,
+};
 pub use diagnostic::{Diagnostic, Severity};
+pub use fast5ever;
 pub use inline::{EditNode, XrefSeg};
 pub use line::{LineOffset, SourceLocation, SourceSpan};
 pub use markdown::{dom2md, mdhtml2md};
diff --git a/src/python.rs b/src/python.rs
index 75d8200..cdc8db0 100644
--- a/src/python.rs
+++ b/src/python.rs
@@ -364,21 +364,6 @@ fn highlight_md(src: &str, class_prefix: &str) -> String {
     crate::highlight::highlight_md(src, class_prefix)
 }
 
-/// CSS coloring `hl='spans'` output for one of the linked highlighter's
-/// themes; `themes()` lists their names.
-#[cfg(feature = "hl")]
-#[pyfunction]
-#[pyo3(signature = (theme, selector="pre code", class_prefix="hl-"))]
-fn theme_css(theme: &str, selector: Option<&str>, class_prefix: &str) -> PyResult<String> {
-    fastpylight::theme_css(theme, selector, class_prefix).map_err(|e| vr(e.to_string()))
-}
-
-#[cfg(feature = "hl")]
-#[pyfunction]
-fn themes() -> Vec<&'static str> {
-    fastpylight::themes()
-}
-
 /// Heading numbering per a `{lvlText: numFmt}` scheme (Word semantics):
 /// `bump` at each heading, then read its display or full-context number.
 #[pyclass(subclass, module = "mdhtml._native")]
@@ -562,11 +547,7 @@ fn _native(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(decode_raw, m)?)?;
     m.add_function(wrap_pyfunction!(math_js, m)?)?;
     m.add_function(wrap_pyfunction!(dialect_css, m)?)?;
-    #[cfg(feature = "hl")]
-    m.add_function(wrap_pyfunction!(theme_css, m)?)?;
     m.add_function(wrap_pyfunction!(highlight_md, m)?)?;
-    #[cfg(feature = "hl")]
-    m.add_function(wrap_pyfunction!(themes, m)?)?;
     m.add_class::<HeadingNums>()?;
     m.add_class::<Resolver>()?;
     m.add_function(wrap_pyfunction!(export_html, m)?)?;
@@ -1044,7 +1025,7 @@ fn attr_node<'py>(py: Python<'py>, attrs: &Attr) -> PyResult<Bound<'py, PyDict>>
 // ---------------------------------------------------------------------------
 
 #[pyfunction]
-#[pyo3(signature = (src, reftypes, number_headings, hl, toc, refs, id_prefix, fn_salt, hl_lang, code_wrap, auto_ids))]
+#[pyo3(signature = (src, reftypes, number_headings, hl, toc, refs, id_prefix, fn_salt, hl_lang, code_wrap, hl_fn, auto_ids))]
 fn export_html(
     py: Python<'_>,
     src: &str,
@@ -1057,6 +1038,7 @@ fn export_html(
     fn_salt: &str,
     hl_lang: Option<Py<PyAny>>,
     code_wrap: Option<Py<PyAny>>,
+    hl_fn: Option<Py<PyAny>>,
     auto_ids: bool,
 ) -> PyResult<(String, Vec<String>)> {
     use crate::export_html::{HlMode, HtmlExportOptions, NumberHeadings, RefsMode};
@@ -1085,6 +1067,11 @@ fn export_html(
             Python::attach(|py| f.bind(py).call1((html, lang, text))?.extract()).map_err(&stash)
         }
     });
+    let hl_fn_c = hl_fn.as_ref().map(|f| {
+        move |text: &str, lang: &str, _mode: HlMode| -> Result<Option<String>, String> {
+            Python::attach(|py| f.bind(py).call1((text, lang))?.extract()).map_err(&stash)
+        }
+    });
     let opts = HtmlExportOptions {
         reftypes,
         number_headings,
@@ -1103,9 +1090,10 @@ fn export_html(
         fn_salt: fn_salt.to_string(),
         hl_lang: hl_lang_c.as_ref().map(|c| c as _),
         code_wrap: code_wrap_c.as_ref().map(|c| c as _),
+        hl_fn: hl_fn_c.as_ref().map(|c| c as _),
         auto_ids,
     };
-    let result = if hl_lang.is_none() && code_wrap.is_none() {
+    let result = if hl_lang.is_none() && code_wrap.is_none() && hl_fn.is_none() {
         py.detach(|| crate::export_html::export_html(src, &opts))
     } else {
         crate::export_html::export_html(src, &opts)
diff --git a/src/wikitext.rs b/src/wikitext.rs
index c1a80bf..e4c42b3 100644
--- a/src/wikitext.rs
+++ b/src/wikitext.rs
@@ -166,8 +166,7 @@ fn ref_tag(src: &str) -> bool {
 
 fn starts_tag(src: &str, name: &str) -> bool {
     let prefix = format!("<{name}");
-    starts_ascii_case(src, &prefix)
-        && src.as_bytes().get(prefix.len()).is_some_and(|byte| matches!(byte, b' ' | b'\t' | b'\r' | b'\n' | b'/' | b'>'))
+    starts_ascii_case(src, &prefix) && src.as_bytes().get(prefix.len()).is_some_and(|byte| matches!(byte, b' ' | b'\t' | b'\r' | b'\n' | b'/' | b'>'))
 }
 
 fn tagged_len(src: &str, tag: &str) -> Option<usize> {
@@ -559,11 +558,7 @@ mod document {
             if part.is_empty() {
                 continue;
             }
-            if let Some(Inline::Text(current)) = items.last_mut() {
-                current.push_str(part)
-            } else {
-                items.push(Inline::Text(part.to_string()))
-            }
+            if let Some(Inline::Text(current)) = items.last_mut() { current.push_str(part) } else { items.push(Inline::Text(part.to_string())) }
         }
     }
 
@@ -621,7 +616,7 @@ mod document {
                     break;
                 }
             } else if rest.starts_with("[[") {
-                if let Some(end) = balanced(rest, 2, "]]" ) {
+                if let Some(end) = balanced(rest, 2, "]]") {
                     if let Some(link) = wikilink_node(&rest[2..end], &rest[..end + 2], context) {
                         out.push(link)
                     }
@@ -682,11 +677,7 @@ mod document {
                     at += 1;
                 }
             } else {
-                let next = rest
-                    .char_indices()
-                    .skip(1)
-                    .find(|(_, ch)| matches!(ch, '<' | '{' | '[' | '\''))
-                    .map_or(src.len(), |(offset, _)| at + offset);
+                let next = rest.char_indices().skip(1).find(|(_, ch)| matches!(ch, '<' | '{' | '[' | '\'')).map_or(src.len(), |(offset, _)| at + offset);
                 push_text(&mut out, &src[at..next]);
                 at = next;
             }
@@ -736,9 +727,8 @@ mod document {
         let mut depth = 1;
         let mut at = open;
         while at < src.len() {
-            let next_open = find_ascii_case(&src[at..], &format!("<{name}"))
-                .map(|offset| at + offset)
-                .filter(|&offset| tag_boundary(src, offset + name.len() + 1));
+            let next_open =
+                find_ascii_case(&src[at..], &format!("<{name}")).map(|offset| at + offset).filter(|&offset| tag_boundary(src, offset + name.len() + 1));
             let next_close = find_ascii_case(&src[at..], &close).map(|offset| at + offset);
             match (next_open, next_close) {
                 (_, None) => return None,
@@ -957,7 +947,8 @@ mod tests {
     fn multiline_templates_and_references_reach_the_inline_scanner_whole() {
         let source = "Before<ref>{{cite web\n|url=x}}</ref>.\n\n{{Infobox\n|name=Example\n|nested={{small|yes}}\n}}\n\nAfter";
         let markdown = wiki2md(source);
-        assert!(!markdown.contains("<ref") && !markdown.contains("cite web"), "{markdown}");
+        assert!(!markdown.contains("<ref"), "{markdown}");
+        assert!(markdown.contains("[^__note1]: {{#cite web}}x{{/cite web}}"), "{markdown}");
         assert!(markdown.contains("data-name=\"Infobox\""), "{markdown}");
         assert!(markdown.contains("data-name=\"nested\""), "{markdown}");
         assert!(!markdown.lines().any(|line| line.trim() == "}}"), "{markdown}");
@@ -966,7 +957,7 @@ mod tests {
     #[test]
     fn multiline_math_is_not_template_syntax() {
         let html = wiki2mdhtml(":<math>\n\\mathbf{{a}} = 1</math>");
-        assert!(html.contains("\\mathbf{{a}} = 1</span>"), "{html}");
+        assert!(html.contains("\\mathbf{{a}} = 1</div>"), "{html}");
         assert!(!html.contains("<template"), "{html}");
     }
 
diff --git a/tests/test_export.py b/tests/test_export.py
index 5e0923e..3660423 100644
--- a/tests/test_export.py
+++ b/tests/test_export.py
@@ -102,6 +102,18 @@ def test_hl_modes():
     assert '<hl-code toks=' in api and 'x = 1' in api
 
 
+def test_hl_without_fastpylight(monkeypatch):
+    import mdhtml.export
+    def gone(): raise ImportError('no fastpylight')
+    monkeypatch.setattr(mdhtml.export, '_fastpylight', gone)
+    mdh = md2mdhtml('```python\nx = 1\n```\n\n```md\n# t\n```')
+    h = mdhtml2html(mdh)
+    assert '<code class="language-python">x = 1\n</code>' in h      # plain block, wrapper kept
+    assert '<span class="hl-' in h                                  # md self-highlighting still works
+    assert any('mdhtml[hl]' in w for w in h.warnings)
+    assert mdhtml2html(mdh, hl=None).warnings == []                 # no highlighting asked: no warning
+
+
 def test_toc():
     h = mdhtml2html(md2mdhtml('# One {#sec-a}\n\nText.\n\n## Two {#sec-b}\n\n# Three'), toc=True)
     assert '<nav class="toc">' in h
diff --git a/tests/wikitext.rs b/tests/wikitext.rs
index d00ae0e..1373a22 100644
--- a/tests/wikitext.rs
+++ b/tests/wikitext.rs
@@ -28,9 +28,11 @@ fn templates_are_semantic_instructions() {
 }
 #[test]
 fn comments_are_not_content_or_template_names() {
-    let html = wiki2mdhtml("Before<!-- hidden --> after {{Multiple image
+    let html = wiki2mdhtml(
+        "Before<!-- hidden --> after {{Multiple image
 <!-- Essential parameters -->
-|caption=Shown}}");
+|caption=Shown}}",
+    );
     assert!(!html.contains("hidden") && !html.contains("Essential parameters"), "{html}");
     assert!(html.contains(r#"data-name="Multiple image""#), "{html}");
 }