Formatters

Lumis separates parsing from rendering. The parser finds tokens; the formatter decides how those tokens become output.

Built-in formatter types

Output	CLI	Rust	Elixir	JavaScript	Java
HTML with inline styles	html-inline	HtmlInlineBuilder	:html_inline	htmlInline()	Formatter.HTML_INLINE
HTML with CSS classes	html-linked	HtmlLinkedBuilder	:html_linked	htmlLinked()	Formatter.HTML_LINKED
HTML with CSS variables for multiple themes	html-multi-themes	HtmlMultiThemesBuilder	:html_multi_themes	htmlMultiThemes()	—
ANSI terminal output	terminal	TerminalBuilder	:terminal	terminal()	Formatter.TERMINAL
BBCode with scope tags	bbcode-scoped	BBCodeScopedBuilder	:bbcode_scoped	bbcodeScoped()	Formatter.BBCODE

Each built-in formatter has a dedicated page with options and more examples:

• HTML Inline
• HTML Linked
• HTML Multi-Themes
• Terminal
• BBCode Scoped

HTML Inline

Self-contained output with no external CSS.

JavaScript

import {highlight} from '@lumis-sh/lumis';
import {htmlInline} from '@lumis-sh/lumis/formatters';
import javascript from '@lumis-sh/lumis/langs/javascript';
import dracula from '@lumis-sh/themes/dracula';

const html = await highlight(
  'const x = 1',
  htmlInline({language: javascript, theme: dracula, preClass: 'code-block'})
);

Rust

use lumis::{highlight, HtmlInlineBuilder, languages::Language, themes};

let formatter = HtmlInlineBuilder::new()
    .language(Language::Rust)
    .theme(Some(themes::get("dracula").unwrap()))
    .pre_class(Some("code-block".to_string()))
    .build()
    .unwrap();

let html = highlight("fn main() {}", formatter);

Elixir

Lumis.highlight!(
  "fn main() {}",
  formatter: {:html_inline, language: "rust", theme: "dracula", pre_class: "code-block"}
)

Java

import io.roastedroot.lumis4j.core.Formatter;
import io.roastedroot.lumis4j.core.Lang;
import io.roastedroot.lumis4j.core.Lumis;
import io.roastedroot.lumis4j.core.Theme;

var lumis = Lumis.builder().build();

var highlighter = lumis.highlighter()
    .withLang(Lang.RUST)
    .withTheme(Theme.DRACULA)
    .withFormatter(Formatter.HTML_INLINE)
    .build();

var html = highlighter.highlight("fn main() {}").string();
lumis.close();

CLI

lumis highlight main.rs --formatter html-inline --theme dracula

HTML Linked

Smaller HTML. Pair with a CSS theme file.

JavaScript

import '@lumis-sh/themes/css/dracula.css';
import {highlight} from '@lumis-sh/lumis';
import {htmlLinked} from '@lumis-sh/lumis/formatters';
import javascript from '@lumis-sh/lumis/langs/javascript';

const html = await highlight(
  'const x = 1',
  htmlLinked({language: javascript, preClass: 'code-block'})
);

Rust

use lumis::{highlight, HtmlLinkedBuilder, languages::Language};

let formatter = HtmlLinkedBuilder::new()
    .language(Language::Rust)
    .pre_class(Some("code-block".to_string()))
    .build()
    .unwrap();

let html = highlight("fn main() {}", formatter);

Elixir

Lumis.highlight!(
  "fn main() {}",
  formatter: {:html_linked, language: "rust", pre_class: "code-block"}
)

Java

import io.roastedroot.lumis4j.core.Formatter;
import io.roastedroot.lumis4j.core.Lang;
import io.roastedroot.lumis4j.core.Lumis;

var lumis = Lumis.builder().build();

var highlighter = lumis.highlighter()
    .withLang(Lang.RUST)
    .withFormatter(Formatter.HTML_LINKED)
    .build();

var html = highlighter.highlight("fn main() {}").string();
lumis.close();

CLI

lumis highlight main.rs --formatter html-linked

HTML Multi-Themes

One block, multiple themes via CSS custom properties.

JavaScript

import {highlight} from '@lumis-sh/lumis';
import {htmlMultiThemes} from '@lumis-sh/lumis/formatters';
import javascript from '@lumis-sh/lumis/langs/javascript';
import githubLight from '@lumis-sh/themes/github_light';
import githubDark from '@lumis-sh/themes/github_dark';

const html = await highlight(
  'const x = 1',
  htmlMultiThemes({
    language: javascript,
    themes: {light: githubLight, dark: githubDark},
    defaultTheme: 'light-dark()',
  })
);

Rust

use lumis::{highlight, HtmlMultiThemesBuilder, languages::Language, themes};
use std::collections::HashMap;

let mut theme_map = HashMap::new();
theme_map.insert("light".to_string(), themes::get("github_light").unwrap());
theme_map.insert("dark".to_string(), themes::get("github_dark").unwrap());

let formatter = HtmlMultiThemesBuilder::new()
    .language(Language::Javascript)
    .themes(theme_map)
    .default_theme("light-dark()")
    .build()
    .unwrap();

let html = highlight("const x = 1", formatter);

Elixir

Lumis.highlight!(
  "const x = 1",
  formatter: {:html_multi_themes,
    language: "javascript",
    themes: [light: "github_light", dark: "github_dark"],
    default_theme: "light-dark()"
  }
)

Java

import io.roastedroot.lumis4j.core.Formatter;
import io.roastedroot.lumis4j.core.Lang;
import io.roastedroot.lumis4j.core.Lumis;
import io.roastedroot.lumis4j.core.Theme;

var lumis = Lumis.builder().build();

var highlighter = lumis.highlighter()
    .withLang(Lang.RUST)
    .withTheme(Theme.DRACULA)
    .withFormatter(Formatter.TERMINAL)
    .build();

var ansi = highlighter.highlight("fn main() {}").string();
lumis.close();

CLI

lumis highlight main.rs \
  --formatter html-multi-themes \
  --themes light:github_light \
  --themes dark:github_dark \
  --default-theme light-dark()

Java does not support HTML Multi-Themes in lumis4j at the moment.

Terminal

ANSI output for the terminal.

JavaScript

import {highlight} from '@lumis-sh/lumis';
import {terminal} from '@lumis-sh/lumis/formatters';
import javascript from '@lumis-sh/lumis/langs/javascript';
import dracula from '@lumis-sh/themes/dracula';

const ansi = await highlight(
  'const x = 1',
  terminal({language: javascript, theme: dracula})
);

Rust

use lumis::{highlight, TerminalBuilder, languages::Language, themes};

let formatter = TerminalBuilder::new()
    .language(Language::Rust)
    .theme(Some(themes::get("dracula").unwrap()))
    .build()
    .unwrap();

let ansi = highlight("fn main() {}", formatter);
println!("{}", ansi);

Elixir

Lumis.highlight!(
  "fn main() {}",
  formatter: {:terminal, language: "rust", theme: "dracula"}
)

Java

import io.roastedroot.lumis4j.core.Formatter;
import io.roastedroot.lumis4j.core.Lang;
import io.roastedroot.lumis4j.core.Lumis;
import io.roastedroot.lumis4j.core.Theme;

var lumis = Lumis.builder().build();

var highlighter = lumis.highlighter()
    .withLang(Lang.RUST)
    .withTheme(Theme.DRACULA)
    .withFormatter(Formatter.TERMINAL)
    .build();

var ansi = highlighter.highlight("fn main() {}").string();
lumis.close();

CLI

lumis highlight main.rs --theme dracula

BBCode Scoped

Scope-based BBCode output for BBCode-aware renderers and custom pipelines.

JavaScript

import {highlight} from '@lumis-sh/lumis';
import {bbcodeScoped} from '@lumis-sh/lumis/formatters';
import javascript from '@lumis-sh/lumis/langs/javascript';

const output = await highlight(
  'const x = "[url=x]"',
  bbcodeScoped({language: javascript})
);

Rust

use lumis::{highlight, BBCodeScopedBuilder, languages::Language};

let output = highlight(
    "fn main() {}",
    BBCodeScopedBuilder::new()
        .language(Language::Rust)
        .build()
        .unwrap(),
);

Elixir

Lumis.highlight!(
  ~s(const x = "[url=x]"),
  formatter: {:bbcode_scoped, language: "javascript"}
)

Java

import io.roastedroot.lumis4j.core.Formatter;
import io.roastedroot.lumis4j.core.Lang;
import io.roastedroot.lumis4j.core.Lumis;

var lumis = Lumis.builder().build();

var highlighter = lumis.highlighter()
    .withLang(Lang.JAVASCRIPT)
    .withFormatter(Formatter.BBCODE)
    .build();

var output = highlighter.highlight("const x = \"[url=x]\"").string();
lumis.close();

CLI

lumis highlight main.rs --formatter bbcode-scoped

Custom formatters

Rust and JavaScript expose lower-level formatter APIs so you can render tokens however you want.

• Rust: implement the Formatter trait
• JavaScript: pass a formatter object with language and format(source), then call the sync free functions highlightIter() or highlightEvents() inside format() — see source

For deeper formatter-specific options, use the dedicated pages above. For theme data and formatter helpers, continue with Themes.