Mucc C Compiler

News

[October 14, 2026: Mucc 1.4.0 runs on and makes programs for 64-bit ARM Linux (the Raspberry Pi 4 and 5, Asahi Linux, ARM servers) as well as x86-64, natively or with --target=, starts several times faster, and fixes the bugs a deep review found. See the changelog. October 8, 2026: Mucc 1.3.0 fixes every wrong-code bug, the crash and the rejected valid code an outside test of 1.2.1 found, and needs no system as or ld for -Xlinker or for assembly files that use GNU as's common directives (.macro, .rept, .p2align, ...). Mucc 1.2.1 was the first release built by mucc alone.]

Features

ONE FILE! The compiler, preprocessor, assembler, linker, headers and C library (musl) are one static program of about 8.7 MB. Copy it onto any x86-64 or ARM64 Linux machine, an empty container or a USB stick, and build C programs with nothing else installed: no gcc, no binutils, no system headers.
FAST! It compiles and assembles about 2.6 times faster than gcc -O0 and 1.5 times faster than clang -O0.
REAL C! C17 by default, C23 with -std=c23, and the GNU extensions real code uses. SQLite, Lua, Redis, Tcl, jq and zlib build with it and pass their own test suites with the bundled musl; CPython, Git, libpng, QuickJS and TinyCC do with the system's glibc. Mucc of course compiles itself, byte for byte.
DEBUGGABLE! -g lets gdb show variables, types and lines, and -Wall, -Werror and -Wno-name work as with gcc.
BUILT BY ITSELF! Each release is compiled, assembled and linked by the one before it, with gcc and binutils nowhere in sight, and comes out the same bytes on any machine.
SMALL! About 33,000 lines of C, in sections, that one person can read from end to end.
ITS OWN TOOLCHAIN! Its assembler takes hand-written assembly with GNU as's common directives (.macro, .rept, .p2align, ...), its linker makes static programs, and mucc -ar makes static libraries.
It takes gcc's flags (-c, -S, -E, -o, -I, -D, -l, -std= and the rest), so build scripts work unchanged. Like clang, it says it is gcc 4.2.

The README is the full guide: how to use mucc day to day, every option, and what it doesn't do.

Compilation Speed

Compilation speed for mucc's own source. There are 32,137 lines; 56,252 lines (1.2 MBytes) are compiled because the same headers are included in many files. Mucc is about 2.6 times faster than GCC -O0, 1.5 times faster than Clang -O0, and 14 times faster than GCC -O2.

Compiler	Time(s)	lines/second	MBytes/second
Mucc 1.4.0	0.56	99000	2.2
Clang 21.1 -O0	0.84	66000	1.5
GCC 15.2 -O0	1.47	38000	0.84
Clang 21.1 -O2	5.46	10000	0.23
GCC 15.2 -O2	7.83	7200	0.16

Measures were done on an Intel Core i7-1185G7 laptop under WSL 2, one file at a time, best of 7, with the compilers taking turns. Real time is measured. Compilation time includes compilation and assembly. Code that mucc generates runs about 15% slower than code from gcc -O0 with glibc (--libc=system), and about 1.4 times slower again with the bundled musl: for the fastest programs, use gcc or clang. Run make bench to measure all of this on your own machine.

Download

The latest release is at github.com/Dom-Yan/Mucc/releases/latest. To install it on any x86-64 or ARM64 Linux (Ubuntu, Debian, Fedora, Arch, Alpine, WSL 2, Raspberry Pi OS and others):

mkdir -p ~/.local/bin
curl -Lo ~/.local/bin/mucc https://github.com/Dom-Yan/Mucc/releases/latest/download/mucc-$(uname -m)-linux
chmod +x ~/.local/bin/mucc
mucc -o hello hello.c && ./hello

Programs are linked statically against the musl inside mucc, so they run on any Linux for that CPU. To make programs for the other CPU, add --target=aarch64-linux or --target=x86_64-linux. To use the system's glibc and shared libraries instead, add --libc=system. Building mucc from source, with only mucc, is explained in the README.

What it doesn't do

Run anywhere but 64-bit Intel, AMD or ARM Linux (on Windows, WSL 2), or make programs for anything else.
Optimize beyond register allocation and constant folding: use gcc or clang where performance is crucial.
Some invalid programs that gcc rejects are accepted: it isn't a strict checker. The issue tracker lists the known bugs.
C++, _BitInt, gcc's nested functions, AVX and later vector instructions, or Intel-syntax assembly without the system's as.
Shared libraries and dlopen with the bundled musl: use --libc=system for those.

The README's Limitations has the full list.

Want to help?

Here are some suggestions:

Report bugs on the issue tracker, with a small C file that shows the problem, or pick one of the open issues and fix it.
Send fixes as pull requests. Run make test-all first, add a test for each fix, and make sure you have read and understood every line you send.

License

Mucc is distributed under the MIT License, as is musl, the C library inside it.

Dom-Yan - https://github.com/Dom-Yan - https://dom-yan.github.io/Mucc/