Неделю назад я рассказывал на Хабре про 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 без
-
Время — медиана на вызов после прогрева. В 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
golang.org/x/net/html
10x / 9.6x
goquery
10x / 9.6x
Node.js
183 μs
htmlparser2
5.3x / 4.3x
cheerio
16x / 9.9x
PHP
360 μs
DomHTMLDocument (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
DomHTMLDocument (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 и DomHTMLDocument — это 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-дерево с объектом на каждый узел, создают неявные и
А теперь — почему каждая строчка этих таблиц оскорбит кого-нибудь из читателей.
Тезис 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, векторизованные 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%
DomHTMLDocument (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
-
Go: https://github.com/romanti3172/fasthtmlparser
-
Rust: https://github.com/romanti3172/fasthtmlparser-rs
-
Python: https://github.com/romanti3172/fasthtmlparser-py
-
Java: https://github.com/romanti3172/fasthtmlparser-java
-
TypeScript: https://github.com/romanti3172/fasthtmlparser-js
-
PHP: https://github.com/romanti3172/fasthtmlparser-php
-
Ruby: https://github.com/romanti3172/fasthtmlparser-rb
Источник: habr.com