Неделю назад я рассказывал на Хабре про z3l.FastHtmlParser — HTML-парсер для .NET, который вместо DOM строит плоский список тегов и разбирает страницу в 10–30 раз быстрее HtmlAgilityPack и AngleSharp. Тогда у него не было ни CSS-селекторов, ни XPath, и жил он только в .NET.
За неделю появились и CSS-селекторы, и XPath 1.0, а сама библиотека переехала ещё на семь языков: Go, Rust, Java, TypeScript, Python, PHP и Ruby. Это не «Hello world»: 6–11 тысяч строк в каждой реализации — токенизатор, правила необязательных закрывающих тегов из HTML5, все 2125 именованных сущностей, XPath 1.0 и CSS-селекторы. Алгоритм везде один и тот же, и каждый порт сверяется с оригиналом на одних и тех же страницах.

Семь портов за неделю — это, конечно, не я один. Кто на самом деле вёз телегу, видно по логотипу.
Получился эксперимент, который редко удаётся поставить: одна и та же настоящая задача, восемь языков, две ОС и один и тот же процессор. Значит, можно наконец ответить на вопрос, за который в комментариях убивают. Готовьте вилы.
Условия
Одно железо. Физический сервер с AMD Ryzen 7 3800X (8 ядер, 16 потоков).
Linux — Ubuntu 26.04 прямо на этом сервере, бенчмарки в Docker, официальные образы:
dotnet/sdk:10.0,golang:1.27,rust:1.100,maven:3-eclipse-temurin-21,node:26,python:3.14,php:8.4-cli,ruby:4.0.Windows — Windows 10 LTSC в виртуалке KVM на этом же сервере, 12 vCPU. Версии те же: .NET 10.0.12, Go 1.27.4, Rust 1.100, Java 21.0.13, Node 26.13, Python 3.14.10, PHP 8.4.27, Ruby 4.0.9.
PHP — с opcache и tracing JIT на обеих ОС. Ruby — без JIT, а на Linux ещё с YJIT и с новым ZJIT (в сборке RubyInstaller для Windows YJIT нет).
Строго по очереди. Ни один бенчмарк не работал одновременно с другим, Linux и Windows — тоже. Сервер боевой: на нём крутятся MySQL, RabbitMQ и десяток сервисов, так что фоновая нагрузка не нулевая (load average 1–3 из 16), зато одинаковая для обеих ОС.
Две задачи. Разбор страницы и скрапинг — разбор плюс извлечение 20 книг (название, цена, рейтинг) или 10 цитат. Страницы — сохранённые books.toscrape.com (51 KB), quotes.toscrape.com (11 KB), webscraper.io laptops (38 KB), books ×10 (510 KB) и books без
</li>и</p>. Перед замером каждый бенчмарк проверяет, что все библиотеки вернули одни и те же записи.Время — медиана на вызов после прогрева. В C# — BenchmarkDotNet, в Go —
testing.B(медиана трёх прогонов), в остальных — одинаковый цикл «секунда прогрева, потом партии вызовов, берём медиану».Погрешность — до 10%. Повторные прогоны одного и того же бенчмарка расходились до 10%: C# на books — 55 и 58 μs на Linux, 64 и 59 μs на Windows; Java на Windows — 73 μs вчера и 66 μs сегодня. Поэтому разница меньше 10% в этой статье — ничья.
Результат
Разбор books.toscrape.com, 51 KB (меньше — лучше):
Место |
Язык |
Linux |
Windows |
|---|---|---|---|
1–4 |
Python (Rust внутри) |
54 μs |
67 μs |
1–4 |
C# |
55 μs |
64 μs |
1–4 |
Rust |
56 μs |
61 μs |
1–4 |
Java |
59 μs |
66 μs |
5 |
Go |
84 μs |
102 μs |
6 |
Node.js (TypeScript) |
183 μs |
201 μs |
7 |
PHP + JIT |
360 μs |
516 μs |
8 |
Ruby + YJIT |
818 μs |
— |
9 |
Ruby |
1.60 ms |
1.53 ms |
Первые четыре места — в пределах погрешности.
Разбор, все страницы — Linux и Windows
Linux:
Страница |
Rust |
C# |
Python |
Java |
Go |
Node.js |
PHP |
Ruby |
Ruby + YJIT |
|---|---|---|---|---|---|---|---|---|---|
quotes, 11 KB |
15 μs |
16 μs |
17 μs |
17 μs |
24 μs |
65 μs |
110 μs |
466 μs |
240 μs |
laptops, 38 KB |
46 μs |
51 μs |
47 μs |
62 μs |
74 μs |
173 μs |
303 μs |
1.40 ms |
1.22 ms |
books, 51 KB |
56 μs |
55 μs |
54 μs |
59 μs |
84 μs |
183 μs |
360 μs |
1.60 ms |
818 μs |
books ×10, 510 KB |
563 μs |
611 μs |
546 μs |
617 μs |
857 μs |
2.27 ms |
3.59 ms |
15.3 ms |
8.02 ms |
books без |
52 μs |
61 μs |
55 μs |
63 μs |
82 μs |
234 μs |
390 μs |
1.83 ms |
1.49 ms |
Windows:
Страница |
Rust |
C# |
Python |
Java |
Go |
Node.js |
PHP |
Ruby |
|---|---|---|---|---|---|---|---|---|
quotes, 11 KB |
17 μs |
20 μs |
18 μs |
19 μs |
29 μs |
68 μs |
153 μs |
455 μs |
laptops, 38 KB |
50 μs |
54 μs |
56 μs |
66 μs |
88 μs |
204 μs |
448 μs |
1.31 ms |
books, 51 KB |
61 μs |
64 μs |
67 μs |
66 μs |
102 μs |
201 μs |
516 μs |
1.53 ms |
books ×10, 510 KB |
602 μs |
637 μs |
654 μs |
677 μs |
944 μs |
2.27 ms |
5.11 ms |
15.4 ms |
books без |
55 μs |
61 μs |
63 μs |
71 μs |
100 μs |
224 μs |
514 μs |
1.91 ms |
Скрапинг 20 книг (разбор + извлечение), Linux / Windows. У каждого порта три способа искать: свои методы Find, CSS-селекторы и XPath.
Язык |
Find API |
CSS |
XPath |
|---|---|---|---|
Rust |
73 / 82 μs |
73 / 87 μs |
117 / 191 μs |
C# |
75 / 70 μs |
74 / 82 μs |
117 / 109 μs |
Java |
86 / 93 μs |
120 / 111 μs |
102 / 108 μs |
Go |
106 / 129 μs |
117 / 131 μs |
216 / 265 μs |
Python |
117 / 155 μs |
94 / 128 μs |
123 / 243 μs |
Node.js |
230 / 239 μs |
285 / 275 μs |
269 / 304 μs |
PHP |
514 / 636 μs |
609 / 758 μs |
784 / 927 μs |
Ruby + YJIT |
1.01 ms / — |
1.15 ms / — |
1.30 ms / — |
Ruby |
2.08 / 2.14 ms |
2.21 / 2.22 ms |
3.05 / 2.75 ms |
Порты против местных чемпионов
Сравнивать языки между собой весело, но пользователю важнее другое: стоит ли брать порт вместо того, чем уже пользуется его экосистема. Порты писались неделю, и вылизаны они явно меньше оригинала. Вот как они выглядят против лучшего, что было на своих платформах до них.
Разбор books.toscrape.com, 51 KB — во сколько раз порт быстрее (Linux / Windows; меньше 1 — порт медленнее):
Язык |
Порт, Linux |
Самый быстрый конкурент |
Порт быстрее |
Популярная альтернатива |
Порт быстрее |
|---|---|---|---|---|---|
Rust |
56 μs |
tl |
1.5x / 1.7x |
scraper (html5ever) |
22x / 25x |
C# |
55 μs |
HtmlAgilityPack |
12x / 12x |
AngleSharp |
21x / 18x |
Python |
54 μs |
selectolax (lexbor, C) |
8.4x / 6.3x |
BeautifulSoup |
226x / 213x |
Java |
59 μs |
Jericho |
6.7x / 6.0x |
jsoup |
8.0x / 7.2x |
Go |
84 μs |
10x / 9.6x |
goquery |
10x / 9.6x |
|
Node.js |
183 μs |
htmlparser2 |
5.3x / 4.3x |
cheerio |
16x / 9.9x |
PHP |
360 μs |
Dom\HTMLDocument (lexbor, C) |
1.5x / 1.5x |
DOMDocument (libxml2, C) |
2.6x / 2.8x |
Ruby + YJIT |
818 μs |
Nokogiri (libxml2, C) |
1.3x / — |
Nokogiri |
1.3x / — |
Ruby |
1.60 ms |
Nokogiri (libxml2, C) |
0.6x / 0.9x |
Nokogiri |
0.6x / 0.9x |
Скрапинг 20 книг — лучший из трёх API порта против лучшего конкурента:
Язык |
Порт, Linux |
Самый быстрый конкурент |
Порт быстрее |
|---|---|---|---|
Rust |
73 μs |
tl (CSS) |
1.7x / 2.1x |
C# |
74 μs |
HtmlAgilityPack (XPath) |
11x / 12x |
Python |
94 μs |
selectolax (CSS) |
6.2x / 4.8x |
Java |
86 μs |
jsoup (CSS) |
8.2x / 7.5x |
Go |
106 μs |
goquery (CSS) |
9.1x / 8.3x |
Node.js |
230 μs |
node-html-parser |
6.1x / 4.9x |
PHP |
514 μs |
Dom\HTMLDocument (CSS) |
1.4x / 1.6x |
Ruby + YJIT |
1.01 ms |
Nokogiri (XPath) |
1.9x / — |
Ruby |
2.08 ms |
Nokogiri (XPath) |
0.9x / 1.1x |
В семи языках из восьми порт быстрее всего, что было в экосистеме, — на обеих ОС и в обеих задачах. Причём в Python, PHP и Ruby главные конкуренты написаны на C: selectolax и Dom\HTMLDocument — это lexbor, lxml, DOMDocument и Nokogiri — libxml2. Чистый PHP обгоняет встроенный в PHP 8.4 парсер на C в полтора раза.
Самый близкий конкурент — tl в Rust, всего в 1.5–2 раза медленнее. Но tl — zero-copy-парсер без декодирования сущностей и без комбинатора потомков в селекторах, то есть делает меньше.
Ruby — особый случай. Без JIT порт идёт вровень с Nokogiri на Windows (разбор на 8% медленнее, скрапинг на 14% быстрее) и проигрывает ей на Linux, где Nokogiri заметно быстрее: в 1.6 раза на разборе. С YJIT порт обгоняет Nokogiri: в 1.3 раза на разборе и в 1.9 раза на скрапинге.
Откуда такой разрыв? C-библиотеки делают в 10 раз больше работы: строят полное DOM-дерево с объектом на каждый узел, создают неявные <html> и <tbody>, а потом ещё и заворачивают найденные узлы в объекты Python, PHP или Ruby. Парсер, который хранит теги как пары чисел-смещений в исходной строке, делает ровно то, что нужно для скрапинга, и не больше.
А теперь — почему каждая строчка этих таблиц оскорбит кого-нибудь из читателей.
Тезис 1. Python догнал Rust
На Linux Python разбирает страницу за 54 μs, Rust — за 56. На Windows — 67 и 61.
Конечно, это жульничество: Python-версия — это 790 строк обвязки на PyO3 вокруг Rust-версии. Внутри fh.parse(html) работает не интерпретатор, а тот же машинный код, что и в Rust. А то, что на Linux Python на 2 μs быстрее самого Rust, — это шум и флаги сборки: Python-обёртка собрана с fat LTO, бенчмарк Rust — с thin LTO.
На скрапинге видно, чем платит Python: пересечением границы. Каждый найденный тег и каждая строка становятся объектами Python, и Find-API отстаёт от чистого Rust в 1.6 раза (117 μs против 73). А CSS-селекторы — всего на 30% (94 μs): весь поиск идёт внутри Rust, и граница пересекается один раз. Чем реже код переходит из Python в Rust и обратно, тем ближе он к Rust.
Провокация тут в другом. В споре «Python медленный» обычно забывают, что в продакшене Python и не исполняет горячий код: numpy, pandas, lxml, selectolax, pydantic-core, orjson написаны на C или Rust. Python — это язык, на котором вызывают быстрый код. И если для вашей задачи есть нативное ядро, Python-сервис окажется быстрее «честного» сервиса на Go, который всё делает сам.
Мораль: «быстрый язык» — это часто язык, который удачно делегирует.
Тезис 2. Go — самый медленный из компилируемых
Go разбирает страницу за 84 μs — в полтора раза медленнее Rust, C#, Java и даже Python. На Windows то же самое: 102 μs против 61–67.
При этом Go-версия написана аккуратно: на разбор — 2 аллокации, сборщик мусора в замере почти не участвует. Дело не в GC, а в компиляторе. Компилятор Go сознательно оптимизирует меньше — ради скорости сборки: скромнее инлайнинг, меньше устранённых проверок границ массивов, нет автовекторизации. В Go есть и PGO, но только по заранее снятому профилю (default.pgo), и включают его единицы. А JIT в .NET и HotSpot собирает профиль сам, прямо во время работы, и компилирует под горячие ветки.
Go остаётся прекрасным языком для сервисов — быстрая сборка, простота, предсказуемость. Но «Go быстрый, потому что компилируется» — это миф. Он быстрый относительно Python и Ruby. Не относительно JVM и .NET.
Тезис 3. C# и Java — это почти Rust. А «C# обогнал Rust» — это про Windows
На Linux разбор: C# — 55 μs, Rust — 56, Java — 59. Скрапинг: Rust — 73, C# — 75, Java — 86. Ничья, Java чуть позади.
На Windows картина другая: на скрапинге C# первый — 70 μs против 82 у Rust, а на XPath разрыв почти вдвое: 109 μs против 191. В первом черновике этой статьи заголовок был «C# обогнал Rust». А потом я посмотрел на Linux, где Rust и C# идут вровень, и стал разбираться.
Причина — аллокатор. .NET выделяет объекты в своей куче одинаково на любой ОС: сдвигом указателя. А Rust по умолчанию берёт системный аллокатор: на Linux это malloc из glibc, на Windows — HeapAlloc. XPath-движок создаёт много маленьких векторов и строк, и системная куча Windows на этом проседает. Две строчки — и Rust на Windows переходит на mimalloc:
#[global_allocator] static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
Rust на Windows |
HeapAlloc (по умолчанию) |
mimalloc |
Для сравнения: Linux |
|---|---|---|---|
Разбор books, 51 KB |
61 μs |
55 μs |
56 μs |
Скрапинг, Find API |
82 μs |
69 μs |
73 μs |
Скрапинг, XPath |
191 μs |
125 μs |
117 μs |
И C# снова не впереди: 70 μs против 69. На Linux mimalloc не меняет ничего (разбор — 55 против 56 μs, XPath — 117 против 117): malloc из glibc для этой нагрузки и так хорош.
Мораль: у языка со сборщиком мусора аллокатор свой и одинаковый везде, а у Rust — тот, что даст ОС. На Windows это стоит Rust до полутора раз.
И ещё о честности: C#-версия — оригинал, и она вылизана сильнее остальных: ArrayPool, Span<char>, векторизованные IndexOfAny, CollectionsMarshal.SetCount, Dictionary.AlternateLookup для поиска по span без аллокации строк. Но и Java-версия, где ничего такого нет, отстаёт от Rust на 5–18%. Если вам нужно «почти как Rust», но без borrow checker’а, — это ваши языки.
Тезис 4. NativeAOT медленнее JIT, а серверный GC не помогает
Раз уж C# в первой четвёрке, проверим, как его ускорить. Две популярные идеи: скомпилировать заранее (NativeAOT) и включить серверный сборщик мусора. BenchmarkDotNet собирал NativeAOT под тот же набор инструкций, что использует JIT на этом процессоре (x86-64-v3, AVX2), так что дело не в нём.
C#, время; в скобках — относительно обычного JIT на той же ОС:
Задача |
ОС |
JIT |
JIT + server GC |
NativeAOT |
NativeAOT + server GC |
|---|---|---|---|---|---|
Разбор books, 51 KB |
Linux |
58 μs |
66 μs (1.14) |
75 μs (1.30) |
81 μs (1.40) |
Windows |
59 μs |
64 μs (1.08) |
83 μs (1.40) |
87 μs (1.47) |
|
Разбор books ×10, 510 KB |
Linux |
614 μs |
625 μs (1.02) |
765 μs (1.24) |
823 μs (1.34) |
Windows |
600 μs |
626 μs (1.04) |
824 μs (1.37) |
864 μs (1.44) |
|
Скрапинг 20 книг, Find API |
Linux |
72 μs |
80 μs (1.11) |
89 μs (1.24) |
100 μs (1.40) |
Windows |
73 μs |
75 μs (1.02) |
100 μs (1.36) |
104 μs (1.41) |
|
Скрапинг 20 книг, XPath |
Linux |
121 μs |
150 μs (1.24) |
153 μs (1.26) |
181 μs (1.50) |
Windows |
129 μs |
132 μs (1.02) |
156 μs (1.21) |
169 μs (1.31) |
|
Скрапинг 10 цитат |
Linux |
25 μs |
27 μs (1.06) |
32 μs (1.27) |
35 μs (1.41) |
Windows |
25 μs |
26 μs (1.05) |
37 μs (1.45) |
38 μs (1.50) |
NativeAOT медленнее JIT на 20–50%. Главная причина — динамический PGO. JIT в .NET сначала компилирует метод быстро и с замерами, смотрит, какие ветки горячие и какие типы реально приходят в интерфейсные вызовы, и перекомпилирует под это: девиртуализирует вызовы, встраивает горячее, раскладывает код так, чтобы горячий путь шёл подряд. NativeAOT компилирует всё заранее, вслепую. Статический PGO для NativeAOT существует, но им почти никто не пользуется.
Серверный GC медленнее на 2–15%, а на XPath, где аллокаций больше всего, — до 24%. У серверного GC своя куча на каждое ядро и гораздо больший бюджет нулевого поколения: сборок меньше, но новые объекты ложатся в память, которой уже нет в кэше. В однопоточном парсере это чистый проигрыш; серверный GC окупается, когда память одновременно выделяют много потоков.
NativeAOT — это про старт за миллисекунды, компактный деплой и отсутствие JIT в рантайме. Не про пиковую скорость.
Тезис 5. Node.js в 3.3 раза медленнее Rust — и это отличный результат
V8 — чудо инженерии. Динамически типизированный язык с JIT держится в 3.3 раза от Rust на разборе (183 μs против 56) и в 3.1 раза на скрапинге. Ни один другой динамический язык в этой таблице и близко не подошёл: PHP вдвое медленнее Node.js, Ruby с YJIT — в 4.5 раза.
Главный тормоз тут даже не V8, а строки JavaScript: UTF-16, иммутабельные, без дешёвых срезов-представлений. Парсер, построенный на смещениях в исходной строке, хорошо ложится на эту модель — поэтому и разрыв такой небольшой.
Тезис 6. Ruby: YJIT удваивает скорость
Ruby 4.0 на Linux — порт и Nokogiri:
Задача |
Порт, без JIT |
Порт, ZJIT |
Порт, YJIT |
Nokogiri (libxml2) |
|---|---|---|---|---|
Разбор books, 51 KB |
1.60 ms |
1.25 ms |
818 μs |
1.01 ms |
Разбор books ×10, 510 KB |
15.3 ms |
12.1 ms |
8.02 ms |
9.58 ms |
Разбор books без |
1.83 ms |
1.64 ms |
1.49 ms |
1.01 ms |
Скрапинг 20 книг |
2.08 ms |
1.42 ms |
1.01 ms |
1.90 ms |
Скрапинг 10 цитат |
789 μs |
529 μs |
375 μs |
964 μs |
YJIT ускоряет чистый Ruby вдвое и на разборе, и на скрапинге. Новый ZJIT из Ruby 4.0 пока даёт меньше: +28% на разборе и +46% на скрапинге. Nokogiri от JIT не ускоряется вовсе — её горячий код написан на C, — поэтому с YJIT порт на чистом Ruby обгоняет её почти везде.
Исключение — страница без закрывающих тегов: Ruby-версия тратит на ней на 14–25% больше, чем на обычной, а с YJIT — на 80% больше, тогда как Rust, Go и Python разницы не замечают. Есть что оптимизировать.
Обидно за Windows: в сборках RubyInstaller YJIT нет, и там Ruby навсегда остаётся интерпретатором.
Тезис 7. Windows против Linux: виртуалка ни при чём
Windows здесь работает в виртуалке на том же сервере, что и Linux, так что первое подозрение — виртуализация. Rust с mimalloc снимает его: 55 μs в виртуалке Windows и 55 μs на голом железе Linux. Для этой нагрузки виртуализация не стоит почти ничего.
Насколько Windows медленнее Linux на том же железе (разбор books, 51 KB):
Что |
Linux |
Windows |
Windows медленнее на |
|---|---|---|---|
Rust, системный аллокатор |
56 μs |
61 μs |
9% |
Rust + mimalloc |
55 μs |
55 μs |
0% |
C# (два прогона) |
55–58 μs |
59–64 μs |
2–17% |
Java |
59 μs |
66 μs |
12% |
Node.js |
183 μs |
201 μs |
10% |
Go |
84 μs |
102 μs |
22% |
Python (Rust внутри) |
54 μs |
67 μs |
24% |
PHP + JIT |
360 μs |
516 μs |
43% |
Ruby |
1.60 ms |
1.53 ms |
−4% |
lxml (Python, libxml2) |
590 μs |
1.51 ms |
156% |
Dom\HTMLDocument (PHP, lexbor) |
524 μs |
777 μs |
48% |
Nokogiri (Ruby, libxml2) |
1.01 ms |
1.41 ms |
40% |
selectolax (Python, lexbor) |
455 μs |
421 μs |
−7% |
htmlparser2 (Node.js) |
977 μs |
870 μs |
−11% |
Что из этого следует:
Рантаймы со своим аллокатором — .NET, JVM, V8 — работают на обеих ОС одинаково, в пределах шума. Это касается и чужих библиотек на них: jsoup и AngleSharp отличаются на 1–3%.
Rust и Python-обёртка над Rust проседают на Windows из-за системной кучи (см. тезис 3). На XPath в Python разрыв почти двукратный: 243 μs против 123.
Интерпретаторы и C-библиотеки зависят от сборки. Одна из причин в PHP: официальные сборки под Windows делает MSVC, а он не умеет computed goto, поэтому Zend VM там работает в более медленном режиме CALL вместо HYBRID. lxml на Windows в 2.6 раза медленнее, Nokogiri — на 40%. Но бывает и наоборот: selectolax и htmlparser2 на Windows быстрее на 7–11%. Всё решает конкретная сборка конкретной библиотеки.
Go на Windows медленнее на 22%, хотя аллокатор у него свой. Объяснения у меня нет — буду рад подсказкам в комментариях.
Отдельная провокация: если ваш сервис на PHP или на Python с lxml крутится на Windows, переезд на Linux даст больше, чем переписывание на другой язык.
Тезис 8. Самый быстрый язык — не самый многословный
Сколько непустых строк заняла одна и та же функциональность:
Язык |
Строк |
|---|---|
TypeScript |
5,950 |
C# |
6,950 |
Java |
7,170 |
Go |
8,800 |
Ruby |
8,900 |
PHP |
10,100 |
Rust |
10,750 |
Python |
790 (обвязка над Rust) |
Rust-версия — одна из самых быстрых и самая длинная. Ruby, известный своей лаконичностью, оказался длиннее C# и Java: когда пишешь на Ruby парсер, который должен быть быстрым, идиоматичный Ruby заканчивается и начинается ручная работа с индексами в строке. На TypeScript вышло короче всего.
Оговорки, без которых меня справедливо разнесут
Это один алгоритм, один автор и одна задача. Разбор HTML — это работа со строками и ветвлениями; на численных задачах, на многопоточности или на I/O картина может быть другой.
Порты оптимизированы неодинаково. C#-версия — оригинал, остальные — недельные порты. В Go и Ruby наверняка осталось что ускорить. Пулреквесты, которые двигают свой язык вверх по таблице, приветствуются.
Разные измерительные стенды и шум до 10%. BenchmarkDotNet,
testing.Bи самописный медианный цикл немного по-разному считают, а сервер не простаивает. Разница в 10% между соседними строками — ничья; разница в 2 раза — нет.Всё по умолчанию. Go без PGO, Rust без
target-cpu=nativeи с системным аллокатором, как в большинстве проектов. Векторизованный поиск символов в Rust (memchr) сам определяет AVX2 во время работы.Python — это Rust. Я это сказал. Чистая Python-реализация была бы в районе Ruby, а то и ниже.
Windows — в виртуалке. Для наших парсеров она ничего не стоит (Rust + mimalloc), но библиотекам, которые строят большие DOM-деревья, виртуализация может стоить больше: промахи TLB при двухуровневой трансляции адресов дороже.
Однопоточный замер. В многопоточном скрапинге в игру вступят GC, аллокаторы и модель потоков — и серверный GC может показать себя иначе. Это тема отдельной статьи.
Итог
Если для холивара всё-таки нужна одна строчка: на разборе Rust ≈ C# ≈ Java ≈ Python (Rust внутри) > Go > Node.js > PHP > Ruby + YJIT > Ruby.
Но если вы хотите, чтобы ваш скрапер стал быстрее, менять язык — не первое, что стоит делать:
Язык при одном и том же алгоритме даёт 1.5 раза между первой четвёркой и Go, 3.3 раза — до Node.js, 6.4 раза — до PHP.
Алгоритм внутри одного языка даёт от 1.5 до 226 раз против местных библиотек, причём порты на PHP и Ruby обгоняют библиотеки на C.
Настройки рантайма весят почти как язык: NativeAOT вместо JIT — на 20–50% дольше, системный аллокатор Windows — до полутора раз дольше для Rust, Windows вместо Linux — на 43% дольше для PHP.
Структуры данных важнее языка, а рантайм и ОС — почти так же важны, как язык.
Все восемь реализаций и бенчмарки открыты — запускайте на своём железе и присылайте свои цифры. Для C# варианты JIT/NativeAOT и workstation/server GC запускаются одной командой: dotnet run -c Release --project benchmarks/z3l.FastHtmlParser.Benchmarks -- --runtime-variants --filter '*ParseBenchmarks.FastHtmlParser' '*ScrapeBenchmarks.*_FastHtmlParser*'.
Первая статья, про C#-версию: https://habr.com/ru/articles/1106746/
C# (оригинал): https://github.com/romanti3172/z3l.FastHtmlParser
TypeScript: https://github.com/romanti3172/fasthtmlparser-js
Комментарии (62)

economist75
18.11.2026 13:52Тема с чистым Python осталась не раскрыта. И если скорость наверняка была бы не очень, допустим на уровне Ruby, то число строк вполне могло оказаться 3-4 тыс.
На практике на чистом Python писать парсер влом, ведь проще использовать что-то готовое (pandas итп) - и вот тут как раз можно здорово сэкономить и строки, и скорость выполнения. То что при этом получится не чистый python абсолютно нормально, но сильно ломает логику и смысл подобных компитишнов.

romanti3172 Автор
18.11.2026 13:52Это всё-таки не компетишн, а скорее промоушн :) Можно и на чистом питоне — https://github.com/romanti3172/fasthtmlparser-pure
Без C, Rust и зависимостей, API тот же, что у версии с Rust внутри. Со скоростью примерно уровень Ruby, чуть ниже. Та же виндовая виртуалка, что в статье:
- разбор страницы books (51 КБ): 2,1 мс. У Ruby без JIT — 1,5 мс, у BeautifulSoup с html.parser — 19 мс, у lxml (C) — 1,6 мс;
- скрапинг 20 книг: 2,6 мс. У BeautifulSoup — 22,5 мс, у lxml — 2,8 мс.
Выходит, от Ruby отстаёт в 1,2–1,4 раза, BeautifulSoup обгоняет раз в 8–9, а с lxml на скрапинге идёт вровень. Версия с Rust внутри, конечно, быстрее ещё в 20–30 раз, потому в статье и была она.
Строк вышло ~4 700 руками плюс 2 500 сгенерированной таблицы HTML5-сущностей, так что ваши 3–4 тысячи почти в точку. Тесты те же, что у остальных портов: на 117 страницах и 569 XPath/CSS-запросах всё совпадает с .NET байт в байт. Повторить замер:
python bench/bench.py.А pandas.read_html, кстати, внутри использует тот же lxml (или BeautifulSoup) и читает только таблицы.

economist75
18.11.2026 13:52Спасибо, вот теперь картинка полная и довольно дружелюбная ко всем участникам. Сейчас такое увидишь редко. Если честно, и не припомню (в рунете).

Siemargl
18.11.2026 13:52А в поддержке франкенштейны в разы хуже. Нужно разбираться в нескольких языках и в нюансах по интеропу.
Так что забываем про питон, а из остальных трех берём тот, какой лучше знают в рабочей группе.

romanti3172 Автор
18.11.2026 13:52Зависит от объёмов. Если парсить десятки терабайт в день — разница очень ощутима, в деньгах за железо. А если пару страничек — конечно, то, что удобнее команде.

Siemargl
18.11.2026 13:52В твоей же табличке первые 5 результатов нос к носу. Какая там разница?
Я, кстати ещё бы память смотрел, тот же rss

romanti3172 Автор
18.11.2026 13:52так это не то что нравится, а вполне конкретная одна либа, с портами на разные языки

savostin
18.11.2026 13:52Windows — Windows 10 LTSC в виртуалке KVM
Похоже на нечестную игру.
Да и сравнивать микросекунды, когда погрешность измерения уже рядом имхо пальцем в небо.

romanti3172 Автор
18.11.2026 13:52нечестно по отношению к кому, если есть группа сравнений всех кого можно внутри одно и той же виртуалки?

savostin
18.11.2026 13:52не честно запихивать одну OS в виртуалку, а другую - нет.

romanti3172 Автор
18.11.2026 13:52по ним сравнение отдельно идет, отдельно колонка в винде, отдельно в линуксе

Andreas_Fogel
18.11.2026 13:52Скорее всего говорить, что парсер на расте тут достиг своего пика не стоит. Надо смотреть исходный код и что в нем написано. Если мы уберем логирование и прочий оверхед мусор, будем держать все в стеке и добавим микроаренку с 1 преаллокацией, то раст может раза в 2 или 3 стать быстрее. А это уже быстрее быстрого. Тем более что тут возможно не только avx2 можно будет применить, но и другие инструкции.

romanti3172 Автор
18.11.2026 13:52да тут уже все хорошо
Логирования нет вообще. Ни log, ни tracing, ни println. Единственная зависимость — memchr.
Преаллокация уже есть, и она лучше одноразовой «микроаренки». В parse.rs:67 сначала считаются все <, это точная верхняя граница числа тегов. Под неё один раз выделяется массив узлов в thread-local scratch-буфере, который переиспользуется между вызовами. На повторных документах аллокаций на теги нет совсем.
SIMD уже работает. Горячий цикл ищет символы через memchr/memchr3/memmem. Эти функции сами выбирают AVX2, SSE2 или NEON под процессор.
Ленивость. Текст и атрибуты не декодируются при парсинге, только при обращении. Это как раз срезает оверхед

Flux
18.11.2026 13:52Вы же просто напросто не читали "вами же" написанный код, если даже на коммент с хабра не в состоянии ответить сами и пересылаете его агенту.

romanti3172 Автор
18.11.2026 13:52мне так удобней, я еще и посуду в посудомойке мою

Flux
18.11.2026 13:52Во первых, аналогия дерьмовая.
Во вторых, попытки острить у вас так себе.
В третьих, ваш вклад в "вашу" кодовую базу нулевой, а предлагать людям тратить время на чтение слопа который вы даже не писали - проявление банального неуважения на границе с хамством.
Если будете отвечать - попросите агента, естественная речь ему даётся лучше чем вам, как видимо и программирование. И это не комплимент ллмкам.

v_0ver
18.11.2026 13:52Я бы не доверял лошади которая пишет
edition = "2021". Я попросил свою лошадь и она достала ещё +5% перформанса, найдя лишние проходы и аллокации:Упростил реализацию и сократил лишние аллокации: - CSS использует общий итератор; поиск первого совпадения обходится без временного Vec. - XPath фильтрует вектор через retain и заимствует строки через Cow. - Нормализация строк больше не требует повторной проверки UTF-8. - Обработка URL использует truncate вместо копирования промежуточных векторов.И это без профилирования и доработки общего алгоритма.

romanti3172 Автор
18.11.2026 13:52супер, попросите свою PR создать, 2021 оставлен, чтобы собиралось на компиляторах от 1.80

Flux
18.11.2026 13:52За неделю появились и CSS-селекторы, и XPath 1.0, а сама библиотека переехала ещё на семь языков: Go, Rust, Java, TypeScript, Python, PHP и Ruby.
В заголовке идет речь про "сравнение языков", хотя на самом деле сравнивалась нейрослопная дрисня которую вряд ли даже читали.
В чем ценность статьи тогда?

romanti3172 Автор
18.11.2026 13:52Лошадка помогала конечно, восемь портов на разные языки за неделю руками никто не напишет. Но «не читали» — мимо: у всех портов общий набор тестов, каждый XPath/CSS-запрос сверяется с эталоном C#-версии по хэшам
А смысл как раз в этом: алгоритм везде один и тот же, ведёт себя одинаково, так что разница в цифрах — это разница языков, а не того, кто как написал. Ну и в своих языках оно реально быстрее того, что было до сих пор.

Flux
18.11.2026 13:52Но «не читали» — мимо: у всех портов общий набор тестов, каждый XPath/CSS-запрос сверяется с эталоном C#-версии по хэшам
Вы немного не то утверждение опровергаете. То что "тесты прошли" не означает что код был вами прочитан, осознан и утвержден.
так что разница в цифрах — это разница языков, а не того, кто как написал
Нет, разницей языков это бы было если бы каждую имплементацию писал специалист с учетом знания каждого конкретного языка, его рантайма и библиотеки. В вашем сравнении предполагается что LLM выдала идеальный код для каждого языка (тесты же зеленые), а значит на конечную производительность влияет только сам язык а не качество кода что, разумеется, не верно.

UFO_01
18.11.2026 13:52Вывсёврёти, нейронка пишет код лучше всех кожаных на любом языке, и вовсе не может подгонять результат под тесты и бенчи, так Альтман сказал.

svl87
18.11.2026 13:52дело даже не в том что дрисню написал нейрослоп, такие статьи выходили регулярно и до ИИ-эры. было по классике, сравнивали какую-нибудь программу с либой от васяна на C с python-программой с либой написанной на C, а то и с asm вставками, отлаженной и оптимизированной годами. И получали что python быстрее программы на C.
сейчас в эпоху ИИ не вижу смысла начинать проекты на языках с GC и на языках пропитанных UB, очень слабыми стандартными либами и прочими приколами. В итоге выбора особо-то и не остается, ну вы сами поняли к чем это

UFO_01
18.11.2026 13:52Мы поняли, останется только раст, а так как код всё равно никто не читает, смысла от экспертизы в конкретном языке нет. /s

ImagineTables
18.11.2026 13:52Неделю назад я рассказывал на Хабре про z3l.FastHtmlParser — HTML-парсер для .NET, который вместо DOM строит плоский список тегов и разбирает страницу в 10–30 раз быстрее HtmlAgilityPack и AngleSharp.
Во времена XML считалось само собой, что парсер, который не строит DOM (SAX-парсер), и должен быть быстрее, и кушать меньше памяти, и поэтому быть ещё быстрее. Вот только результат годится для узкого набора задач, типа десериализации настроек.

ris58h
18.11.2026 13:52Вот только результат годится для узкого набора задач
Это DOM годится для узкого набора задач, где этот DOM преобразуется. Кому это нужно кроме браузера?

ImagineTables
18.11.2026 13:52Virtually any kind of XML validation requires access to the document in full. The most trivial example is that an attribute declared in the DTD to be of type IDREF, requires that there be only one element in the document that uses the same value for an ID attribute. To validate this in a SAX parser, one must keep track of all ID attributes (any one of them might end up being referenced by an IDREF attribute at the very end); as well as every IDREF attribute until it is resolved. Similarly, to validate that each element has an acceptable sequence of child elements, information about what child elements have been seen for each parent must be kept until the parent closes.
Additionally, some kinds of XML processing simply require having access to the entire document. XSLT and XPath, for example, need to be able to access any node at any time in the parsed XML tree. Editors and browsers likewise need to be able to display, modify, and perhaps re-validate at any time. While a SAX parser may well be used to construct such a tree initially, SAX provides no help for such processing as a whole.

romanti3172 Автор
18.11.2026 13:52в цитате, — про потоковую обработку: SAX прошёл документ и забыл. Здесь документ целиком в памяти, с родителями и границами каждого тега, так что XPath как раз и ходит к любому узлу в любой момент — со всеми осями. Чего нет — так это редактирования и DTD-валидации, но для парсинга HTML они и не нужны

ImagineTables
18.11.2026 13:52Я говорил именно про парсинг XML.
Мне любопытно, а для чего может пригодиться парсинг HTML без построения DOM’а?

romanti3172 Автор
18.11.2026 13:52вытащить со страницы цены, ссылки, карточки товаров, профили, тексты и это десятки терабайт в день на некоторых задачах

ImagineTables
18.11.2026 13:52Ясно, спасибо. Я от скрейпинга далёк и думал, что:
Все магазины сейчас мгновенно банят за, допустим, не скачивание картинок или ещё чего подозрительное. Я заходил в некоторые через обычный Firefox… ну, не совсем обычный, в нём запрещён канвас, доступ к списку шрифтов и ещё кое-что… открывал в отдельной вкладке картинку, не помню — из
<img>или из стиля, чтобы сделать zoom 500% и рассмотреть получше, и меня тут же начинали мучить капчей, а потом банили. Разбанивали в ручном режиме, но перед этим просили прислать скриншот. Видимо, чтобы убедиться, что браузер там где-то рядом хотя бы пробегал.Цены в разметке не отгружают. По крайней мере, Fix Price, потому что когда он меня забанил и
api.fix-priceдавала403, страница была пустой, это я помню точно.

romanti3172 Автор
18.11.2026 13:52В начальной странице цен нет, да. Но если открыть её браузером через автоматизацию, получаешь снимок DOM уже со всем, и это обычный HTML его и парсишь. Антиботы есть, но не везде такие жёсткие.

romanti3172 Автор
18.11.2026 13:52для парсинга DOM не нужен, SAX это потоковый парсинг если что, один раз прочитали и назад не возвращаемся, тут же вполне себе ходим туда обратно по необходимости, у элемента можно получить родительский, соседние элементы, соседние эелементы того же уровня и в таком духе

UFO_01
18.11.2026 13:52Чистый PHP обгоняет встроенный в PHP 8.4 парсер на C в полтора раза.
Как минимум тут я скорее поверю что коровы летают, нежели что чистый php обходит lexbor. Подозреваю что вместо построения полноценного DOM дерева использовался прямой поиск нужных тегов.
Неделю назад я рассказывал на Хабре про z3l.FastHtmlParser — HTML-парсер для .NET, который вместо DOM строит плоский список тегов и разбирает страницу в 10–30 раз быстрее HtmlAgilityPack и AngleSharp.
А, ну это многое объясняет. Кто бы мог подумать что простой парсинг быстрее чем построение DOM дерева.
Python-версия — это 790 строк обвязки на PyO3 вокруг Rust-версии
Что там кстати про разницу языков?
«быстрый язык» — это часто язык, который удачно делегирует.
Круто конечно, но мы тут вроде реализации на конкретном языке обсуждаем, нет? Ну и круто конечно сравнивать результаты только на учебных полигонах, не посмотрев что на реальных страницах, могли бы и получше клод запрячь.
стоит ли брать порт вместо того, чем уже пользуется его экосистема. Порты писались неделю, и вылизаны они явно меньше оригинала.
Так на вопрос не ответили, отвечу за вас: НЕТ.

romanti3172 Автор
18.11.2026 13:52есть и на чистом python'e https://github.com/romanti3172/fasthtmlparser-pure работает уныло

yahooyaks
18.11.2026 13:52Самый быстрый язык тот, у которого компилятор выдаст код с наименьшим количеством тактов за прогон.

Lewigh
18.11.2026 13:52Перед тем как выбирать самый "быстрый язык", неплохо бы было дать определение что автор подразумевает под этим.
По логике статьи самым быстрым языком может быть bash который запускает исполняемый файл написанный на asm под конкретную платформу. По мне это такой же фарс как Python который просто вызывает библиотеки на C и Rust.И тут вопрос очень не простой. По каким критериям можно сказать что именно решения заложенные в той или иной реализации языка быстрее?
Ну как минимум наверное чтобы сказать что язык быстрее нужно чтобы язык сам выполнил работу.Ок. Можно ли использовать все возможности языка или только адекватные? К примеру, можно на Java писать без аллокаций в куче, все храня в пред-выделенных массивах, использовать там свою память и так далее. Вот только эти возможности языка для него самого - это костыли и в целом неестественны, неудобны и выглядят как ахтунг.
В то же время для C#, тонкая работа с памятью - это абсолютная норма и поддержана удобно на уровне самого языка.Такой же вопрос, к примеру, насколько допустимо, например для языка который построен исключительно вокруг GC этот самый GC отключать.
Ну и разумеется, вопрос с библиотеками. Мы сравниваем языки или в совокупности с отдельными решениями в их экосистемах?
Поэтому мне кажется, в среднем вопрос сравнения скорости - такой себе. Я бы сравнивал скорей или по возможности из коробки получать хорошую производительности или насколько комфортно ее из языка выжимать.

Siemargl
18.11.2026 13:52В то же время для C#, тонкая работа с памятью - это абсолютная норма и поддержана удобно на уровне самого языка
Тат что то появилось кроме stackalloc?

romanti3172 Автор
18.11.2026 13:52много чего: Span/ReadOnlySpan, ref struct, ArrayPool, MemoryMarshal, inline arrays в C# 12, SearchValues в .NET 8 (поиск символов с SIMD под капотом), Vector128/256, все это используется: Span'ы по всему коду, SearchValues и Vector для поиска, буферы из ArrayPool. При этом unsafe и указатели не нужны, всё в рамках обычного безопасного кода

Siemargl
18.11.2026 13:52Понятно. Это все костыли и обвязка вокруг него (стека) .
Полезно, но сложно считать каким то прорывом то, что в других языках с рождения.

Mox
18.11.2026 13:52Тут тогда не очень понятно почему Python версия - это обертка вокруг Rust, а Ruby - нет

romanti3172 Автор
18.11.2026 13:52в ruby и чистый порт работает отлично, а вот чистый python так себе

misterzsm
18.11.2026 13:52Спасибо за мем в начале - теперь буду знать, какую библиотеку точно не стоит использовать для парсинга html

Rissiamur
18.11.2026 13:52А почему нельзя было написать одну нативную реализацию с логикой на Rust, а затем сделать биндинги на всех других, нужных языках?

romanti3172 Автор
18.11.2026 13:52чистые порты ставятся без компилятора и работают там, где нативное не подцепишь: JS в браузере, PHP на хостинге без своих расширений

cdriper
18.11.2026 13:52JS в браузере
так WASM же

romanti3172 Автор
18.11.2026 13:52можно и WASM, но там строку на каждый документ надо копировать из JS в память WASM и перекодировать в UTF-8

nagibat0r
18.11.2026 13:52Про Го - очень и очень спорно. Версия на Го заметно хуже оптимизирована. Например,
Nodeпочти вдвое тяжелее, после разбора весь массив узлов копируется и очищается, поиск<,=и>сделан простым побайтовым циклом, тогда как в том же Раст и C# используются специализированные процедуры. Замеры не честные
romanti3172 Автор
18.11.2026 13:52пнул ленивую лошадь, выкатил обнову: Node теперь 40 байт вместо 56, поиск символов в теге по 8 байт за раз. Копирование оставил — без него на замерах выходило медленнее, буфер горячий в кэше. А ещё нашёлся поиск имени тега через map. Итого Go-версия стала на 8–11% быстрее и ест на четверть меньше памяти. Спасибо

Siemargl
18.11.2026 13:52Вот скорее всего все тесты надо критически переоценивать после ии.
Потому что пишет он спустя рукава и делать на этой основе выводы....

romanti3172 Автор
18.11.2026 13:52Для этого код и открыт, после правок цифры сдвинулись на ~10%, а не в разы, так что общая картина та же

squd_akak
18.11.2026 13:52python который делегирует выполнение rust - быстрее чем сам rust - получается python это ускоритель для rust - звучит как стартап.

sanblch
18.11.2026 13:52C++ дает соизмеримые расту цифры

sanblch
18.11.2026 13:52
romanti3172 Автор
18.11.2026 13:52можно быстрее, на 15–25% быстрее в парсинге и в 1,7 раза на XPath ) Основная разница в memchr из MSVC CRT на SSE2. https://github.com/romanti3172/fasthtmlparser-cpp
v_0ver
в Rust =)
Akon32
Осталось попробовать делегировать из Python в Java, и, внезапно, получить почти ту же скорость, что и в Rust.