
Every Linux syscall table, across 27 architectures
syscall.sh is a free reference site for Linux system call tables across 27 architectures. It lists every system call with its number, arguments and registers per architecture, traces when each syscall appeared and was dropped across kernel releases (from Linux 3.3 onward), documents each architecture's calling convention (the instruction used to enter the kernel, the register holding the syscall number, argument registers and return register), and exposes the same data as JSON files and a public API. All data is generated directly from the kernel source — the syscall tables and SYSCALL_DEFINE macros of every mainline release it scans.
Syscall tables for 27 architectures (x64, x86, arm64, arm, riscv64, s390x, ppc/ppc64, all MIPS ABIs, SPARC, m68k, LoongArch, and more) showing syscall numbers, argument registers and the kernel-entry instruction.
For each architecture, documents the entry instruction (e.g. syscall, int 0x80, svc #0, ecall, sc), the register holding the syscall number (NR), registers ARG0–ARG5, and the register the result is returned in (RETURN).
Each architecture page has a kernel selector; records show when each syscall first appeared (since) and, for removed entries, the release that dropped it. Removed syscalls remain visible via an "all, with removed" option.
Every architecture's full table including per-entry history is available as plain JSON, e.g. /x64/syscalls.json.
An API (e.g. curl https://api.syscall.sh/v2/syscalls/x64/read) serves syscall data for any kernel release, diffs between releases and more.
A generator walks the actual syscall tables and SYSCALL_DEFINE macros of every mainline release scanned, so the numbers shown are the ones the kernel actually dispatches on.
Short syscall descriptions come from the Linux man pages project, and io_uring descriptions from liburing; the site is rebuilt from its syscall API whenever the data changes.
Pick one of the 27 architectures (e.g. x64 with 369 syscalls since 3.3, or arm with 426 since 4.10) to see its full syscall table with numbers, arguments and registers.
Use the kernel selector on each architecture page to view the table as of a specific kernel release, or choose "all, with removed" to see syscalls that were dropped and which release removed them.
Download the per-architecture JSON file (e.g. /x64/syscalls.json) or query the API endpoint for any kernel release or diffs between releases.
Free to use; syscall tables, JSON downloads and the API are publicly accessible. No paid plans are mentioned.
A reference site with every Linux syscall table grouped by architecture — syscall numbers, arguments and registers for 27 architectures, with history across kernel releases from Linux 3.3 onward, plus JSON downloads and a public API.
27 architectures, including x64, x86 (i386), arm64 (AArch64), arm (EABI), riscv64, ia32 and x32 ABIs on x86_64, loongarch64, ppc/ppc64, s390x, mips64/mipsn32/mipso32, alpha, arc, csky, hexagon, m68k, microblaze, nios2, openrisc, parisc, sh, sparc/sparc64 and xtensa.
Everything is read from the Linux kernel source itself: a generator walks the syscall table and SYSCALL_DEFINE macros of every mainline release it scans, so the numbers shown are what the kernel actually dispatches on.
Yes. Each architecture page has a kernel selector, and the JSON downloads record when each entry first appeared (since) and when it was dropped (removed_in). Removed syscalls stay visible via the "all, with removed" option.
Yes. For example, curl https://api.syscall.sh/v2/syscalls/x64/read returns syscall data; the API also supports any kernel release and diffs between releases. Per-architecture JSON files are also available directly, e.g. /x64/syscalls.json.
The site documents, per architecture, the kernel-entry instruction (e.g. syscall, int 0x80, svc #0, ecall, sc), the register holding the syscall number (NR), argument registers ARG0–ARG5, and the register the result is returned in (RETURN).
It's free — tables, JSON files and the API are publicly accessible with no pricing or plans mentioned.
The site is built from Linux kernel source data and the Linux man pages project, and is rebuilt from its syscall API when data changes; the page does not state that the site's own code is open source.