GOKEN9CC

module

v0.0.0-...-e549ce5 Latest Latest Go to latest Published: Sep 23, 2026 License: MIT

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/ARYX/GOKEN9CC

Links

Open Source Insights

README ¶

goken9cc

goken9cc is a portable, multi-architecture toolchain — C compilers, assemblers, and linkers — together with a minimalist C library, rooted in Ken Thompson's legendary work on the Plan 9 and Inferno operating systems. First extended by Go developers, this toolchain now brings cross-platform support for Linux, macOS, and Windows while preserving the simplicity, elegance, and efficiency of the original Plan 9 tools.

See https://www.youtube.com/watch?v=E3iUpyqKvgk for a presentation of the project.

News

Q3 2026 — v0.4 (in progress): a big unification release.
- imported the arm and x86 toolchains (5a/5c/5l, 8a/8c/8l) from the Principia Softwarica project and fixed the many mismatches against the older kencc-derived variants (kept side by side as 5ak/8ak, etc.)
- fix native macOS (Mach-O) output for amd64 and arm64 (6l/7l)
- fix native Windows (PE) output for amd64 and x86 (6l/8l)
- early WebAssembly backend (ea/ec/el) fully written by Claude Code
- ported a large batch of 9front fixes (mostly Cinap lenrek work) into the mips and arm64 toolchains (va/vc/vl, 7a/7c/7l)
- brought up riscv64 for real (it was only commented-out stubs before)
- self-hosted libc.a derived from Plan 9 libc, built entirely by goken's own compilers with no gcc involved, for every Linux arch this project targets (arm64, amd64, 386, arm, mips, riscv, riscv64), with syscalls declared through a small Go-mksyscall.sh-inspired generator (see tests/c/hello_libc), and extended also to macOS and Windows
- fixed the arm and mips emulators (5i/vi) so they actually run their Plan 9 hello-world tests
- much richer test infra: tests now run for many architectures under qemu/Linux, and many operating systems with wine (for Windows) and Node (for wasm) all from Linux CI; also check output against expected.txt instead of just checking the build succeeds; new tests/s/variants and tests/c/variants compare the object files and executables produced by the principia vs. kencc lineages to catch mismatches
- bootstrapped: you can compile goken using goken on arm64 (7a/7c/7l)
- imported and brought up to date the alpha, powerpc, sparc, and m68k toolchains from Plan 9 4th edition supporting now ELF and Linux
Q2 2026 — v0.3: presented goken9cc at IWP9, the International Workshop on Plan 9.
Q1 2026 — v0.2: added Plan 9 pcc to compile legacy Unix programs (called APE in Plan 9); started using AddressSanitizer (configure -asan) to catch memory bugs in the toolchain itself; wrote up the project for an IWP9 paper submission.
Q4 2025 — v0.1: first working release — a Plan 9-style toolchain (compilers, assemblers, linkers for arm, x86, mips, and early riscv, plus an arm/mips emulator and the acid debugger) able to cross compile Principia Softwarica's own pc/pi operating system targets from Linux and macOS.
Q3 2025 — Beta: arm64 and arm32 ELF Linux binaries actually working; imported mk, rc, ed, and other core utilities from Principia Softwarica so the repo is self-contained.
Q2 2025 — Alpha: project started — forked the Go repository at its October 2010 commit, refocused on the C toolchain (keeping Go stuff for testing purpose), first (untested) imports of the mips (Plan 9), arm64 (Charles Forsyth), and riscv (Richard Miller) toolchains, first Docker/Nix/CI setup.

goken9cc's direct ancestor is fork-kencc, now deprecated in its favor:

2025 — fork-kencc v0.4: added a Dockerfile and CI.
2024 — fork-kencc v0.3: slow resume of the project with basic CI.
2019 — 2024: Hiatus (working on https://semgrep.dev)
2018 — fork-kencc v0.2: got it building also on Linux and Windows.
2014 — fork-kencc v0.1: project started — forked the kencc toolchain from Plan 9 (actually from https://code.google.com/p/ken-cc/ which was forked from inferno which itself derived from Plan 9), keep just the x86 and arm toolchains, got it building on macOS, and did a big code reorganization.

See changes.txt for the detailed changelog.

Features

Portable: It can build on Linux, macOS, and Windows (WSL, Cygwin) (TODO Plan 9 and xv6) using gcc or clang or a bootstrapped version of itself, on 32 bits or 64 bits machines
Multi-OS support: Link C and assembly programs that can run on Linux, macOS, Windows, and Plan 9 (TODO xv6)
Multi-architecture support: Build C and assembly programs targeting the i386 (a.k.a. x86), amd64 (a.k.a. x86_64), arm, arm64 (a.k.a. aarch64), riscv (a.k.a. riscv32), riscv64, mips, alpha, sparc, powerpc, and m68k architectures, plus experimental WebAssembly (wasm) support
Cross-compilers: Build C programs targeting different platforms from different platforms (e.g., you can build from a Linux x86 machine a binary for macOS arm64)
Compact and efficient: A lightweight compiler toolchain designed for speed and simplicity.
Heritage: Based on the Plan 9 and Inferno OS compilers developed by Ken Thompson and others.
Go-era improvements: Enhanced and extended by contributors from the Go language community for multi-platform support.
Open and extensible: Designed to be easy to understand, modify, and integrate into new projects, thanks to its reasonable size and the use of Literate programming, which explains the code in depth (see https://principia-softwarica.org); it takes more than a license to make code truly open.

Getting Started

Building from source

git clone https://github.com/aryx/goken9cc.git
cd goken9cc
./configure
./scripts/build-mk.sh
./scripts/promote-mk.sh
. env.sh
mk
mk install

You can also play with the $ostype and $objtype environment variables for cross compiling.

Architecture Naming Convention

goken9cc, like Plan 9, uses single-character codes for architectures. Each tool is prefixed with this code:

Code	Arch	Compiler	Assembler	Linker	Object ext
2	m68k	2c	2a	2l	.2
5	arm	5c	5a	5l	.5
6	amd64	6c	6a	6l	.6
7	arm64	7c	7a	7l	.7
8	i386	8c	8a	8l	.8
e	wasm	ec	ea	el	.e
i	riscv	ic	ia	il	.i
j	riscv64	jc	ja	jl	.j
k	sparc	kc	ka	kl	.k
q	powerpc	qc	qa	ql	.q
v	mips	vc	va	vl	.v
z	alpha	zc	za	zl	.z

Pipeline: .c → compiler (Xc) → assembler (Xa) → linker (Xl) → X.out

History

This repository was originally a fork of the assemblers, linkers, and C compilers as well as supporting libraries (e.g., lib9, libmach, pkg/runtime) in the Go repository in October 2010 at this precise commit: https://github.com/golang/go/commit/99a10eff16b79cfb8ccf36e586532a40b17a203c (see pad.org for an explanation of why I forked at this precise commit).

The C toolchain that was part of the Go repository was actually itself a fork of the "kencc" toolchain in inferno-os at https://github.com/inferno-os/inferno-os (in the utils/ subdirectory) as well as code from the plan9port https://github.com/9fans/plan9port which both were themselves forks of the kencc toolchain in the plan9 operating system at https://github.com/plan9foundation/plan9

The main improvements in the Go repository to the C toolchain compared to the original kencc toolchain in Plan 9 were the support for other operating systems such as Linux, macOS, and Windows (and not just Plan9), with the management of binary formats such as ELF (for Linux), machO (for macOS), and PE (for Windows) as well as the management of syscalls to those different operating systems. Another nice improvement was the support for the DWARF debugging format so the generated binaries could be debugged using gdb (instead of just the Plan9 acid debugger).

This fork was then further extended to add more architectures such as arm64 (thanks to the work of Charles Forsyth) and riscv (thanks to the work of Richard Miller) that were not in the Go repo but scattered around in "kencc-derived" repositories.

More work was done then to make all of this work together, to support the latest Linux, macOS, and Windows to reach a point where one could use goken9cc to compile goken9cc itself on many architectures and many operating systems.

AI disclaimer

95% of the code in goken9cc was written by humans (mostly Ken Thompson, Rob Pike, Charles Forsyth, Richard Miller, and other Plan 9 contributors), and for the most part written more than 30 years ago. What I did was essentially to package those old toolchains together and then use AI to write the remaining 5% so that the toolchains could work not just on Plan 9 for Plan 9 but also on and for Linux, macOS, and Windows (imitating for the most part what was done by Go developers for the Go language).

All the clerical work of finding the right syscall numbers for each architecture and operating systems for the multiplatform C library in goken9cc (see lib_core/libc/{arch,syscall,os}) was done by Claude Code, inspired by what Go developers did for Go (see the GO/pkg/{syscall,runtime} directories).

The entire wasm backend was written by Claude Code.

Most of the architecture and operating system bugfixes were done by Claude Code.

Most of the code written by AI is clearly marked with a special claude: comment at the front and part of a commit authored by Claude code. You can use the scripts/ai_percentage.py to get authorship LOC statistics across the different directories in goken9cc.

Environment variables

build time: objtype ostype

run time: for all: GOROOT (used for "#9/..." paths) for mk: MKSHELL for rc: RCMAIN for yacc: YACCPAR

Directories ¶

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

Path	Synopsis
GO
C/cmd/5a 5a is a version of the Plan 9 assembler.	5a is a version of the Plan 9 assembler.
C/cmd/5c 5c is a version of the Plan 9 C compiler.	5c is a version of the Plan 9 C compiler.
C/cmd/5l 5l is a modified version of the Plan 9 linker.	5l is a modified version of the Plan 9 linker.
C/cmd/6a 6a is a version of the Plan 9 assembler.	6a is a version of the Plan 9 assembler.
C/cmd/6c 6c is a version of the Plan 9 C compiler.	6c is a version of the Plan 9 C compiler.
C/cmd/6l 6l is a modified version of the Plan 9 linker.	6l is a modified version of the Plan 9 linker.
C/cmd/8a 8a is a version of the Plan 9 assembler.	8a is a version of the Plan 9 assembler.
C/cmd/8c 8c is a version of the Plan 9 C compiler.	8c is a version of the Plan 9 C compiler.
C/cmd/8l 8l is a modified version of the Plan 9 linker.	8l is a modified version of the Plan 9 linker.
C/cmd/ar Gopack is a variant of the Plan 9 ar tool.	Gopack is a variant of the Plan 9 ar tool.
C/cmd/cc This directory contains the portable section of the Plan 9 C compilers.	This directory contains the portable section of the Plan 9 C compilers.
C/cmd/cov Cov is a rudimentary code coverage tool.	Cov is a rudimentary code coverage tool.
C/cmd/ld This directory contains the portable section of the Plan 9 C linkers.	This directory contains the portable section of the Plan 9 C linkers.
C/cmd/nm Nm is a version of the Plan 9 nm command.	Nm is a version of the Plan 9 nm command.
C/cmd/prof Prof is a rudimentary real-time profiler.	Prof is a rudimentary real-time profiler.
cmd/5g 5g is the version of the gc compiler for the ARM.	5g is the version of the gc compiler for the ARM.
cmd/6g 6g is the version of the gc compiler for the x86-64.	6g is the version of the gc compiler for the x86-64.
cmd/8g 8g is the version of the gc compiler for the x86.	8g is the version of the gc compiler for the x86.
cmd/godefs Godefs is a bootstrapping tool for porting the Go runtime to new systems.	Godefs is a bootstrapping tool for porting the Go runtime to new systems.
cmd/gomake The gomake command runs GNU make with an appropriate environment for using the conventional Go makefiles.	The gomake command runs GNU make with an appropriate environment for using the conventional Go makefiles.
cmd/gotest Gotest is an automated testing tool for Go packages.	Gotest is an automated testing tool for Go packages.
misc/src/pkg/exp/4s command This is a simple demo of Go running under Native Client.	This is a simple demo of Go running under Native Client.
misc/src/pkg/exp/draw Package draw provides image composition functions.	Package draw provides image composition functions.
misc/src/pkg/exp/ebnf Package ebnf is a library for EBNF grammars.	Package ebnf is a library for EBNF grammars.
misc/src/pkg/exp/gui Package gui defines a basic graphical user interface programming model.	Package gui defines a basic graphical user interface programming model.
misc/src/pkg/exp/gui/x11 Package x11 implements an X11 backend for the exp/gui package.	Package x11 implements an X11 backend for the exp/gui package.
misc/src/pkg/exp/inotify Package inotify implements a wrapper for the Linux inotify system.	Package inotify implements a wrapper for the Linux inotify system.
misc/src/pkg/exp/spdy
misc/src/pkg/exp/sql Package sql provides a generic interface around SQL (or SQL-like) databases.	Package sql provides a generic interface around SQL (or SQL-like) databases.
misc/src/pkg/exp/sql/driver Package driver defines interfaces to be implemented by database drivers as used by package sql.	Package driver defines interfaces to be implemented by database drivers as used by package sql.
misc/src/pkg/exp/ssh Package ssh implements an SSH client and server.	Package ssh implements an SSH client and server.
misc/src/pkg/exp/terminal Package terminal provides support functions for dealing with terminals, as commonly found on UNIX systems.	Package terminal provides support functions for dealing with terminals, as commonly found on UNIX systems.
misc/src/pkg/exp/types PACKAGE UNDER CONSTRUCTION.	PACKAGE UNDER CONSTRUCTION.
misc/src/pkg/exp/winfsnotify Package winfsnotify allows the user to receive file system event notifications on Windows.	Package winfsnotify allows the user to receive file system event notifications on Windows.
misc/src/pkg/exp/wingui command
misc/src/pkg/image Package image implements a basic 2-D image library.	Package image implements a basic 2-D image library.
misc/src/pkg/image/bmp Package bmp implements a BMP image decoder.	Package bmp implements a BMP image decoder.
misc/src/pkg/image/color Package color implements a basic color library.	Package color implements a basic color library.
misc/src/pkg/image/gif Package gif implements a GIF image decoder.	Package gif implements a GIF image decoder.