Performance

Rosettes is designed for predictable, high performance. State machine lexers provide O(n) time complexity with no worst-case surprises.

Benchmarks vs Pygments

Tested on a 10,000-line Python file:

Benchmarked on Apple M1 Pro, Python 3.14. Results vary by hardware—runpython -m benchmarks.benchmark_vs_pygmentsto measure on your system.

Time Complexity

O(n) Guaranteed

Rosettes processes each character exactly once:

Linear scaling—no exponential blowup.

Comparison with Regex

Regex-based highlighters can exhibit catastrophic backtracking:

Pattern: (a+)+$
Input:   "aaaaaaaaaaaaaaaaaaaaaaaaaaaa!"

Regex:   Exponential time (2^n attempts)
Rosettes: Linear time (n character reads)

Memory Usage

Rosettes uses minimal memory:

Tokens areNamedTuples—lightweight and cache-friendly.

Optimization Tips

Usehighlight_many()for Multiple Blocks

For 8+ code blocks, parallel processing is faster:

# Slow: sequential
results = [highlight(code, lang) for code, lang in blocks]

# Fast: parallel (for 8+ blocks)
results = highlight_many(blocks)

Skip Line Features When Not Needed

Line numbers and line highlighting use the slower code path:

# Fast path (no line features)
html = highlight(code, "python")

# Slow path (line features enabled)
html = highlight(code, "python", show_linenos=True)
html = highlight(code, "python", hl_lines={1, 2, 3})

The difference is ~15% for typical code blocks.

Reuse Lexer Instances

Lexers are cached automatically:

from rosettes import get_lexer

# Same instance returned (cached)
lexer1 = get_lexer("python")
lexer2 = get_lexer("python")
assert lexer1 is lexer2  # True

No need to manually cache lexers.

Parallel Scaling

GIL Python (3.13 and earlier)

With the GIL, parallel highlighting provides limited benefit:

The GIL prevents true parallelism, but I/O overlapping provides some benefit.

Free-Threading (3.14t)

With free-threading enabled, true parallelism is achieved:

Near-linear scaling up to 4 workers, then diminishing returns due to memory bandwidth.

Profiling

Profile your highlighting withcProfile:

import cProfile
from rosettes import highlight

code = open("large_file.py").read()

cProfile.run('highlight(code, "python")', sort="cumtime")

Or usetimeitfor quick benchmarks:

import timeit
from rosettes import highlight

code = "def foo(): pass\n" * 10000

time = timeit.timeit(
    lambda: highlight(code, "python"),
    number=100,
)
print(f"Average: {time/100*1000:.2f}ms")

Comparison Table

Next Steps

• Comparison — Detailed Rosettes vs Pygments comparison
• Parallel Processing — Usinghighlight_many()