سنجش روی ۴۲ برنامه‌ی یکسان، ۵ آبان ۱۴۰۵

سلام چقدر سریع است؟

برنامه‌های سلام مستقیم به کد ماشین ترجمه می‌شوند؛ بدون ماشین مجازی و بدون زباله‌روب. روی ۳۹ برنامه‌ای که در همه‌ی زبان‌ها الگوریتم یکسان دارند، میانگین سلام ۱۰٫۶ میلی‌ثانیه بود، C ۱۱٫۷ و Rust ۱۱٫۳ میلی‌ثانیه: یک رده، با فاصله‌های کوچک به هر دو سو. در برابر سریع‌ترینِ C، C++، Rust و Go در هر برنامه، سلام در ۶ برنامه جلوتر، در ۲۷ برنامه برابر و در ۶ برنامه عقب‌تر بود. زبان‌های تفسیری داستان دیگری دارند: پایتون ۵۶ برابر و PHP ۹٫۶ برابر زمان برد.

۵۶ برابرسریع‌تر از پایتون

۹٫۶ برابرسریع‌تر از PHP

۱٫۳ برابرسریع‌تر از Go

۱۰٫۶ / ۱۱٫۷میلی‌ثانیه، سلام / C، میانگین ۳۹ برنامه

۱۰٫۶ / ۱۱٫۳میلی‌ثانیه، سلام / Rust، همان ۳۹ برنامه

۶ · ۲۷ · ۶برنامه‌ی جلوتر، برابر و عقب‌تر از سریع‌ترین زبان کامپایلی

کار یک ثانیه‌ای سلام، در زبان‌های دیگر

اگر سلام کاری را در یک ثانیه انجام دهد، زبان‌های دیگر برای همان کار این‌قدر زمان لازم دارند:

سلام۱ ثانیه

Rust۱٫۰۶ ثانیه

C۱٫۱ ثانیه

Go۱٫۳ ثانیه

PHP۹٫۶ ثانیه

پایتون۵۶ ثانیه

در کنار سریع‌ترین زبان‌ها

میانگین هندسی سریع‌ترین اجرای هر برنامه، روی ۳۹ برنامه‌ای که همه‌جا الگوریتم یکسان دارند؛ نوار کوتاه‌تر یعنی سریع‌تر. فاصله‌ی چند درصدی در حد نوسان بین دو اجراست.

سلام۱۰٫۶۳ میلی‌ثانیه

Rust۱۱٫۲۹ میلی‌ثانیه

C۱۱٫۶۸ میلی‌ثانیه

C++۱۳٫۰۶ میلی‌ثانیه

Go۱۴٫۲۳ میلی‌ثانیه

PHP با ۱۰۲ و پایتون با ۵۹۸ میلی‌ثانیه در این نمودار جا نمی‌شوند. با هر ۴۲ برنامه هم ترتیب همین است: سلام ۱۰٫۹۳، Rust ۱۲٫۰۰، C ۱۲٫۱۰، C++ ۱۳٫۴۷ و Go ۱۵٫۰۷ میلی‌ثانیه.

جلوتر، برابر و عقب‌تر

اگر زمان سلام کمتر از ۵٪ (یا نیم میلی‌ثانیه) با سریع‌ترینِ C، C++، Rust و Go فاصله داشته باشد، آن برنامه «برابر» شمرده شده، چون فاصله‌ای به این کوچکی از اجرایی به اجرای دیگر عوض می‌شود. روی ۳۹ برنامه‌ی هم‌الگوریتم (زمان‌ها به میلی‌ثانیه):

جلوتر

فاصله‌ی ویرایشی ۴٫۵ در برابر ۷٫۸ (C)، بازی زندگی ۷٫۲ در برابر ۹٫۱ (C)، تجزیه‌ی ریشه‌ای ۸٫۱ در برابر ۹٫۸ (Rust)، جمع زیرمجموعه ۸٫۵ در برابر ۱۰٫۳ (C)، طولانی‌ترین زیردنباله‌ی صعودی ۹٫۷ در برابر ۱۰٫۸ (C)، مرتب‌سازی هرمی ۲۶٫۲ در برابر ۲۸٫۱ (C).

۲۷

برابر

فیبوناچی تکراری، عددهای اول، غربال، مرتب‌سازی سریع و ادغامی، مندلبرو، ضرب ماتریس، کار با رشته و برنامه‌های دیگر: در حد نوسانِ سریع‌ترین زبان کامپایلی.

عقب‌تر

عدد تصادفی LCG ۱۹٫۴ در برابر ۱۷٫۹ (C)، شمارش حلقه ۵٫۹ در برابر ۵٫۳ (C)، جستجوی دودویی ۶۶۷٫۷ در برابر ۵۸۳٫۹ (Rust)، n وزیر ۴۱٫۱ در برابر ۳۵٫۷ (C)، فیبوناچی بازگشتی ۳٫۱ در برابر ۲٫۴ (C)، چاپ یک خط، یک میلیون بار ۸٫۲ در برابر ۲٫۶ (Rust).

این عددها چه چیزی را نشان نمی‌دهند

بیشتر برنامه‌ها بین ۲ تا ۳۰ میلی‌ثانیه طول می‌کشند (میانه‌ی زمان C ۱۰٫۵ میلی‌ثانیه است)، پس راه‌اندازی خود فرایند بخشی از هر زمان است و یک میلی‌ثانیه سهم بزرگی دارد. یک نشانه‌اش: سلام وقتی با tcc و بدون بهینه‌ساز ساخته شود هم میانگین ۱۱٫۰ میلی‌ثانیه می‌گیرد، نزدیک به نسخه‌ی بهینه. این مجموعه زبان‌های کامپایلی را به‌روشنی از زبان‌های تفسیری جدا می‌کند؛ ولی میان زبان‌های کامپایلی آن را «یک رده» بخوانید، نه رتبه‌بندی.
هر زمان، سریع‌ترینِ ۱۰ اجرا روی یک ماشین مجازی اشتراکی GitHub Actions است. فاصله‌های کمتر از حدود ۵٪ ممکن است در اجرای بعدی برعکس شوند.
سه برنامه (۴۰ تا ۴۲) از کتابخانه‌ی ماتریس و تانسور خود سلام استفاده می‌کنند، در حالی که C، C++، Rust و Go حلقه‌های دست‌نویس دارند؛ پس این سه کتابخانه‌ها را می‌سنجند، نه کامپایلرها را، و در میانگین‌های بالا نیامده‌اند. سلام در دوتا جلوتر است (۱۴٫۳ در برابر ۴۲٫۵ میلی‌ثانیه‌ی C، و ۷٫۳ در برابر ۳۸٫۱ میلی‌ثانیه‌ی C++) و در سومی خیلی عقب‌تر (۳۶٫۴ در برابر ۴٫۱ میلی‌ثانیه‌ی C، چون gcc بیشتر کار حلقه را حذف می‌کند).
همه‌ی زبان‌ها یک الگوریتم و یک خروجی دارند و هر کدام به شیوه‌ی معمول همان زبان نوشته شده‌اند. این‌ها برنامه‌های کوچک‌اند؛ برنامه‌های بزرگ، کارهای سنگین روی حافظه یا زمان ساختِ یک پروژه‌ی بزرگ را نمی‌سنجند.

همه‌ی برنامه‌ها، همه‌ی عددها

سریع‌ترینِ ۱۰ اجرا به میلی‌ثانیه. عدد پررنگ، سریع‌ترین زبان کامپایلی در هر ردیف است.

جدول همه‌ی ۴۲ برنامه را نشان بده

برنامه	C	C++	Rust	Go	سلام	PHP	پایتون
`01_fib_recursive`	۲٫۴	۳٫۰	۳٫۱	۴٫۹	۳٫۱	۳۷٫۱	۶۰٫۲
`02_fib_iterative`	۱۵٫۲	۱۷٫۰	۱۵٫۹	۱۷٫۱	۱۵٫۱	۳۹٫۰	۴۱۵٫۸
`03_primes_count`	۳٫۸	۴٫۷	۳٫۷	۴٫۸	۳٫۷	۱۵٫۷	۱۰۷٫۵
`04_collatz`	۴٫۴	۵٫۱	۳٫۸	۶٫۱	۳٫۷	۴۲٫۲	۲۴۵٫۷
`05_sum_mod`	۹٫۹	۱۰٫۹	۱۰٫۳	۱۰٫۳	۹٫۵	۲۳٫۸	۲۵۴٫۲
`06_gcd_sum`	۱۴٫۹	۱۶٫۱	۱۳٫۰	۱۶٫۰	۱۳٫۵	۳۴٫۲	۹۵٫۳
`07_pow_mod`	۲٫۴	۳٫۱	۲٫۷	۳٫۹	۲٫۴	۱۸٫۹	۵۲٫۲
`08_digit_sum`	۳٫۵	۴٫۵	۳٫۸	۴٫۵	۳٫۷	۴۷٫۲	۲۷۸٫۲
`09_perfect_numbers`	۸٫۹	۱۰٫۰	۷٫۷	۱۰٫۶	۷٫۶	۳۱٫۱	۳۰۳٫۹
`10_pi_leibniz`	۴٫۹	۵٫۸	۵٫۱	۵٫۷	۴٫۹	۴۰٫۸	۳۸۸٫۴
`11_loop_count`	۵٫۳	۶٫۳	۵٫۵	۶٫۲	۵٫۹	۱۳٫۴	۸۸٫۱
`12_hello_print`	۱۷٫۷	۱۵٫۶	۲٫۶	۶٫۰	۸٫۲	۳۷۶٫۳	۷۵٫۸
`13_array_rw`	۲۱٫۳	۲۲٫۵	۲۲٫۲	۲۲٫۴	۲۱٫۹	۵۹٫۷	۷۰۹٫۱
`14_lcg_random`	۱۷٫۹	۱۹٫۰	۱۹٫۴	۲۳٫۳	۱۹٫۴	۶۰٫۴	۱٬۰۴۸٫۳
`15_matrix_mult`	۶٫۱	۶٫۹	۴٫۶	۷٫۶	۴٫۸	۱۳۰٫۳	۸۳۷٫۴
`16_quicksort`	۲۵٫۶	۲۶٫۲	۲۵٫۰	۲۵٫۵	۲۴٫۹	۱۳۲٫۸	۴۶۳٫۲
`17_n_queens`	۳۵٫۷	۳۷٫۸	۳۸٫۴	۳۹٫۸	۴۱٫۱	۳۱۷٫۹	۵۱۸٫۴
`18_sieve_eratosthenes`	۴٫۸	۵٫۶	۴٫۸	۵٫۶	۴٫۹	۱۱۳٫۲	۶۴۸٫۵
`19_mandelbrot`	۸٫۶	۹٫۵	۸٫۸	۹٫۶	۸٫۷	۷۵٫۷	۸۴۳٫۰
`20_monte_carlo_pi`	۲۲٫۹	۲۳٫۴	۱۲٫۴	۲۷٫۸	۱۲٫۴	۲۰۴٫۷	۲٬۵۸۵٫۹
`21_coin_change_dp`	۲٫۶	۳٫۳	۲٫۷	۳٫۱	۲٫۶	۱۴٫۰	۷۶٫۹
`22_knapsack_01`	۳٫۴	۴٫۱	۳٫۷	۵٫۴	۳٫۵	۷۶٫۹	۸۸۷٫۸
`23_caesar_cipher`	۱۰٫۵	۱۱٫۶	۱۰٫۴	۱۳٫۷	۱۰٫۴	۶۱٫۱	۷۶۸٫۲
`24_merge_sort`	۲۳٫۹	۲۴٫۸	۲۴٫۹	۲۹٫۳	۲۵٫۱	۱۸۲٫۹	۵۶۷٫۳
`25_palindrome_count`	۹٫۲	۱۰٫۲	۹٫۳	۱۱٫۹	۸٫۸	۱۷۱٫۷	۱٬۱۰۷٫۴
`26_ackermann`	۱٫۵	۲٫۱	۱٫۷	۲٫۴	۱٫۶	۸٫۵	۲۱٫۰
`27_edit_distance`	۷٫۸	۸٫۳	۸٫۴	۹٫۷	۴٫۵	۱۵۳٫۴	۱٬۵۷۲٫۸
`28_prime_factorization`	۸۱۳٫۶	۸۳۶٫۰	۷۰۱٫۴	۸۰۱٫۰	۷۰۴٫۸	۲٬۹۸۹٫۴	۳۵٬۳۷۳٫۰
`29_dot_product`	۲۹٫۴	۳۰٫۶	۲۹٫۹	۳۱٫۰	۲۹٫۷	۱۴۷٫۶	۱٬۸۰۱٫۶
`30_heap_sort`	۲۸٫۱	۲۸٫۱	۲۹٫۴	۳۵٫۹	۲۶٫۲	۳۰۶٫۷	۶۸۹٫۹
`31_binary_search_stress`	۷۳۰٫۶	۷۲۴٫۲	۵۸۳٫۹	۷۳۳٫۵	۶۶۷٫۷	۴٬۵۸۹٫۴	۲۶٬۱۱۹٫۹
`32_longest_increasing_subsequence`	۱۰٫۸	۱۲٫۱	۱۲٫۲	۱۲٫۸	۹٫۷	۲۰۲٫۳	۱٬۹۱۸٫۷
`33_subset_sum_reachability`	۱۰٫۳	۱۱٫۹	۱۸٫۶	۱۴٫۱	۸٫۵	۲۳۴٫۸	۱٬۸۲۶٫۵
`34_counting_sort`	۳۲٫۸	۳۴٫۲	۲۳٫۵	۳۵٫۴	۲۴٫۲	۱۸۲٫۶	۱٬۹۵۲٫۹
`35_run_length_stats`	۷٫۲	۷٫۴	۵٫۷	۷٫۸	۵٫۵	۸۴٫۷	۶۴۰٫۷
`36_array_rotation_reversal`	۱۹٫۹	۲۱٫۵	۱۹٫۹	۲۱٫۸	۱۹٫۲	۱۵۹٫۵	۷۰۵٫۹
`37_sqrt_decomposition`	۱۰٫۸	۱۲٫۴	۹٫۸	۱۶٫۰	۸٫۱	۲۴۷٫۷	۸۹۳٫۸
`38_game_of_life`	۹٫۱	۱۰٫۳	۲۴٫۶	۳۳٫۲	۷٫۲	۹۷۵٫۸	۶٬۷۲۲٫۱
`39_trapezoidal_integration`	۱۱٫۷	۱۴٫۳	۱۱٫۳	۱۴٫۴	۱۱٫۳	۲۹۲٫۱	۲٬۲۰۱٫۸
`40_matrix_stdlib_matmul`	۴۲٫۵	۴۳٫۸	۶۴٫۳	۴۷٫۲	۱۴٫۳	۹۹۵٫۴	۱۲۱٫۸
`41_matrix_stdlib_smallops`	۴٫۱	۵٫۰	۵٫۲	۱۵٫۹	۳۶٫۴	۳۷۵٫۹	۱٬۱۷۴٫۴
`42_tensor_stdlib_matmul`	۴۰٫۳	۳۸٫۱	۵۵٫۷	۴۳٫۰	۷٫۳	۸۵۹٫۶	۱۱۹٫۱

یک سنجش دیگر: مسیریاب HTTP

وب‌سرور سلام چقدر سریع است؟

نه هر سروری که مردم سراغش می‌روند به زبانی ترجمه‌شده نوشته شده. نه سرور به یک مسیر یکسان روی یک دستگاه و در یک اجرای درهم پاسخ دادند، یعنی هر مسیر پشت سر هم روی همه‌ی سرورها سنجیده شد: اچ‌تی‌تی‌پی خودِ سلام، مسیریاب کتابخانه‌ی استاندارد Go، سه چارچوب پرطرفدار Go (Fiber، Gin، Echo)، nginx، Apache، Node (نسخه‌ی پنجم Express) و سرور توکار PHP.

۱۱ از ۱۱مسیری که سلام در آن از Fiber درخواست بیشتری در ثانیه پاسخ داد

۱۶٪ تا ۵۲٪جلوتر از Fiber در میانگین هندسی: ۱۶٪ روی دستگاه آرام، ۵۲٪ در اجرای کامل زیر بار

۲٫۷ برابرسریع‌تر از net/http خودِ Go

۴٫۲ برابرسریع‌تر از Node/Express

در کنار همه‌ی سرورهای برنامه‌ای که سنجیده شدند

میانگین هندسی درخواست بر ثانیه روی هر ۱۱ مسیر؛ نوار بلندتر یعنی سریع‌تر. nginx و Apache ۴ مسیر از ۱۱ مسیر را پیاده‌سازی نمی‌کنند (توضیح در بخش روش)، پس مقایسه‌ی جداگانه‌ی خودشان را در بخش بعد دارند.

سلام۹۴٬۸۵۰ درخواست در ثانیه

Go، Fiber۶۲٬۴۹۳ درخواست در ثانیه

Go، Echo۳۵٬۲۳۸ درخواست در ثانیه

Go، Gin۳۴٬۹۹۹ درخواست در ثانیه

Go، net/http۳۴٬۹۸۷ درخواست در ثانیه

node/express۲۲٬۵۳۶ درخواست در ثانیه

php -S۱۱٬۹۹۲ درخواست در ثانیه

روی مسیرهایی که nginx خودش پاسخ می‌دهد

nginx به ۷ مسیر از ۱۱ مسیر مستقیم از پیکربندی یا پرونده‌ها پاسخ می‌دهد: /plaintext، /json، /cached، /file، /users/:id، /static و /. این نمودار میانگین هندسی همین ۷ مسیر است برای هر سروری که به همه‌شان پاسخ می‌دهد. Apache در آن نیست چون نمی‌تواند بخش /users/:id را جدا کند.

سلام۹۴٬۱۵۶ درخواست در ثانیه

Go، Fiber۶۹٬۶۵۳ درخواست در ثانیه

nginx۶۰٬۴۹۰ درخواست در ثانیه

Go، Gin۳۹٬۲۱۷ درخواست در ثانیه

Go، Echo۳۷٬۶۴۴ درخواست در ثانیه

Go، net/http۳۶٬۲۰۲ درخواست در ثانیه

node/express۲۱٬۵۸۵ درخواست در ثانیه

php -S۱۲٬۰۲۹ درخواست در ثانیه

جایی که فاصله بیشترین است، و جایی که نیست

جدول کامل یازده مسیر در پایین پیوند خورده تا هیچ عددی بدون سند نماند. سه ردیفی که ارزش خواندن دارند:

۱۰۵٪+

تجزیه‌ی پرسمان و ساخت فهرست

سلام ۹۹٬۱۴۳ درخواست در ثانیه روی /search، در برابر ۴۸٬۲۴۷ درخواست Fiber که نزدیک‌ترین رقیب بود؛ net/http خودِ Go به ۳۳٬۱۹۳ می‌رسد.

حافظه‌ی نهان

پرونده‌های ایستا

سلام پرونده‌های ایستا را بعد از اولین درخواست در حافظه نگه می‌دارد؛ nginx در این سنجش پرونده را در هر درخواست باز می‌کند (بدون open_file_cache). پس این ردیف به همان اندازه که سرور را می‌سنجد، حافظه‌ی نهان را هم می‌سنجد: سلام ۷۹٬۷۷۵، Fiber ۷۳٬۷۹۷ و nginx ۳۵٬۸۳۱ درخواست در ثانیه.

۴٪+

جایی که فاصله کم است

روی / سلام با ۹۱٬۱۳۶ درخواست در ثانیه تنها ۴٪ از ۸۷٬۶۵۱ درخواست Fiber جلوتر است. ساده و بدون پنهان‌کاری در یک میانگین.

این سنجش چطور اجرا شد

تاریخ	۶ آبان ۱۴۰۵ (2026-10-28)
دستگاه	محیط اشتراکی با ۶ پردازنده‌ی مجازی AMD EPYC، با میانگین بار حدود ۱۱ از کارهای دیگر
هسته‌ها	سرورها روی ۴ هسته، ابزار تولید بار روی ۲ هسته‌ی دیگر
بار	۶۴ اتصال keep-alive با ۲ رشته، ۱۰ ثانیه برای هر مسیر پس از ۳ ثانیه گرم‌کردن، مسیرها به‌نوبت روی همه‌ی سرورها
سلام	شاخه‌ی main همراه با مخزن کارگرهای epoll (#2473)، پشتیبان LLVM، ساخته‌شده با کامپایلر نسخه‌ی 0.5.9
Fiber	v2.52.16 روی Go 1.26.0، تنظیمات پیش‌فرض (بدون prefork)
nginx	1.28.3، ۴ کارگر، `access_log off`، `sendfile on`، بدون `open_file_cache`
بقیه	Gin v1.12.0 · Echo v4.16.2 · Apache 2.4.66 · Node 24.19.0 + Express 5.3.0 · PHP 8.5.4

جدول کامل هر مسیر، پیکربندی هر سرور و خودِ ابزار سنجش (همراه با داده‌های خام) در گیت‌هاب در BENCHMARK.md هستند. همه‌ی سرورها در بار پس‌زمینه شریک بودند، چون هر مسیر پشت سر هم روی همه‌شان سنجیده شد، ولی این بار به سرورهایی که رشته‌های کمی نگه می‌دارند، از جمله سلام، کمک می‌کند؛ برای همین هر دو عدد ۱۶٪ و ۵۲٪ آمده است. اعداد درخواست‌بر‌ثانیه‌ی دو سنجش این صفحه را با هم مقایسه نکنید و برای برنامه‌ریزی ظرفیت، آن را روی سخت‌افزار خودتان دوباره اجرا کنید.

ساخته‌شده با سلام، از سیستم‌عامل تا همین وب‌سایت

سرعت فقط در سنجش‌ها نیست؛ سلام همین حالا نرم‌افزارهای واقعی را اجرا می‌کند.

بیش از ۱۵۰ هزار کاربر روی یک سرور کوچک

سرویس‌هایی که با سلام طراحی شده‌اند، به‌راحتی به بیش از ۱۵۰ هزار کاربر خدمت می‌دهند؛ آن هم روی یک سرور کوچک.

یک سیستم‌عامل کامل با سلام

یک سیستم‌عامل به‌طور کامل با زبان سلام طراحی شده است؛ سلام برای پایین‌ترین لایه‌های نرم‌افزار هم آماده است.

سلام با خود سلام ساخته شده

کامپایلر سلام تماماً با زبان سلام نوشته شده است، نه با هیچ زبان دیگری: بیش از ۲۰۰ پرونده‌ی کد سلام که خودِ سلام را ترجمه می‌کنند.

همین وب‌سایت هم سلام است

برنامه‌ای که این وب‌سایت را می‌سازد، ابزار سنجش سرعتِ همین صفحه و قالب‌بند کد سلام، همه به زبان سلام نوشته شده‌اند.

روش سنجش

هر یک از ۴۲ برنامه با یک الگوریتم در C، C++، Rust، Go، پایتون، PHP و سلام نوشته شد و خروجی هر نسخه پیش از زمان‌گیری با خروجی C مقایسه شد. هر برنامه بعد از یک اجرای گرم‌کردنِ بی‌زمان، ۱۰ بار اجرا شد و سریع‌ترین اجرا ثبت شد؛ میانگین‌ها میانگین هندسی همین زمان‌ها هستند. C و C++ با gcc -O3، Rust با -C opt-level=3 و سلام با پشتیبان LLVM و -O3 ساخته شدند. دستور salam build بدون گزینه از tcc و بدون بهینه‌ساز استفاده می‌کند و روی همان ۳۹ برنامه میانگین ۱۱٫۰ میلی‌ثانیه گرفت.

تاریخ	۵ آبان ۱۴۰۵ (2026-10-27)، کامیت `8cfe206`
دستگاه	اجراکننده‌ی ubuntu-24.04 در GitHub Actions (ماشین مجازی اشتراکی ابری)، پردازنده‌ی AMD EPYC 9V45، درون یک ایمیج Docker با Alpine Linux
کامپایلرها و مفسرها	gcc 15.2.0 · rustc 1.96.1 · Go 1.26.10 · Python 3.14.10 · PHP 8.5.12 · Salam 0.6.0 (dev)
تعداد اجرا	۱۰ اجرای زمان‌دار برای هر برنامه پس از یک اجرای گرم‌کردن؛ سریع‌ترین ثبت شد
تعداد برنامه	۴۲ برنامه برای هر زبان؛ ۳۹ برنامه در میانگین‌ها

کد همه‌ی برنامه‌های سنجش، گزارش کامل و زمان خامِ تک‌تک اجراها در گیت‌هاب است و هر کسی می‌تواند آن‌ها را دوباره اجرا کند.

سرعت زبان‌های کامپایلی، با سادگی فارسی

سلام را نصب کنید یا همین حالا در مرورگر امتحانش کنید.

نصب سلام امتحان در مرورگر