Host Targets
Karkain detects the platform it runs on and reports it as a canonical short target triple.
karkain target
The Host: line of karkain target is the exact host triple from
pkg/target:
$ karkain target
Host: x86_64-windows
Supported targets:
native (host default; x86_64-windows)
c23 (C23 source output; x86_64-windows)
native-link (Phase 84 object/linker pipeline)
wasm32-wasi (WebAssembly WASI module)
x86_64-windows 64-bit little-endian; objects PE/COFF / executables PE/COFF; ...
aarch64-windows 64-bit little-endian; objects PE/COFF / executables PE/COFF; ...
x86_64-linux 64-bit little-endian; objects ELF / executables ELF; ...
aarch64-linux 64-bit little-endian; objects ELF / executables ELF; ...
riscv64-linux 64-bit little-endian; objects ELF / executables ELF; ...
x86_64-macos 64-bit little-endian; objects Mach-O / executables Mach-O; ...
aarch64-macos 64-bit little-endian; objects Mach-O / executables Mach-O; ...
wasm32-wasi 32-bit little-endian; objects WASM / executables WASM; ...
Default: native
The host triple names architecture, OS and environment/ABI
(arch-os-env). On the Windows x86_64 host that is x86_64-windows
(the GNU/MinGW-w64 toolchain flavor is implied).
The pkg/target model
Host detection lives in the Karkain-owned pkg/target package,
alongside the whole target model:
Architecture —
x86_64,aarch64,riscv64,wasm32(plusunknown)OS —
windows,linux,macos,wasiEnvironment/ABI —
gnu,msvc,musl(recognized but not buildable)Canonical short triples —
x86_64-windows,aarch64-windows,x86_64-linux,aarch64-linux,riscv64-linux,x86_64-macos,aarch64-macos,wasm32-wasi(see Target Triples)Long-form normalization —
x86_64-pc-windows-msvc,x86_64-unknown-linux-gnuand friends parse and normalize to the canonical short form; the vendor component is dropped``Features`` — the target data-layout model: pointer width (32/64 bits), endianness, object/executable formats (ELF, PE/COFF, WASM), ABI name, runtime variant and the external-C-toolchain requirement
``SameMachine`` — compares architecture + OS (machine kind), not triples:
x86_64-pc-windows-msvcandx86_64-windowsare the same machine even with different ABIs, whilex86_64-linuxcan never run on a Windows host``IsHost`` — whether a target equals the running toolchain’s platform
Why host detection matters
Host detection is used for exactly two things:
Deriving the implicit
nativetarget (the default when--targetis omitted).Deciding whether a cross-run is possible — cross-run restrictions compare machines via
SameMachine, never triples.
Host detection is never a substitute for an explicit target: the same-machine C-driver selection compiles
nativewith the historical host probe (byte-identical flags), and a foreign target is always compiled by cross-compiler discovery (Cross-Compilation). There is no silent host fallback for a foreign triple.
C-free native targets (native-x86_64-*)
In addition to the triples above, three C-free machine-code targets
exist. They emit a linked executable directly, with no C compiler on
PATH — no gcc, clang or cl. They are built from any host
for any of the three containers; run requires the host OS to match
the target OS and is refused elsewhere with the Phase-111 build-only
hint (exit 6).
Target |
Container |
Engine ownership |
|---|---|---|
|
PE32+ ( |
Self-hosted (kcc) and Go. Since Phase 151D kcc emits this
target itself, through the same whole-program driver that
|
|
ELF64 ( |
Self-hosted (kcc) and Go. Phase A1 wired the same whole-program driver to the Linux container, so the ELF is emitted by kcc through the same scan/plan/lower sequence as the other two targets. |
|
Mach-O PIE ( |
Self-hosted (kcc) and Go. Phase B wired the same driver to the
Mach-O container. The image is a real position-independent
executable ( |
All three targets are kcc-owned: kccNativeOwnedTargets has no member
left to refuse, and nothing refuses with error[K116] any more.
Engine selection vs. target ownership
Ownership of a native target and the default engine are two separate facts, and both are worth stating precisely:
The default engine is the self-hosted engine (kcc) unless
--engine goorKARKAIN_ENGINE=gosays otherwise.A native target requested under kcc is answered by kcc. Where kcc owns the target it emits it; where it does not, it refuses with
K116and names the target. It never hands the request silently to the Go backend — the earlier behaviour, measured indocs/audit/PHASE-151-BASELINE.md§1.1, produced a Go image with no signal that the engine had changed.The Go engine remains a supported, documented path for all three targets. It is the reference implementation the native differential compares against, not a required fallback.
Verified status of this claim
native-x86_64-windows is marked self-hosted because kcc-built
images have been executed and produced correct output
(pkg/cli/phase151_kcc_native_test.go). The Linux ELF is emitted by
kcc through the same driver and is compared byte for byte against the Go
oracle; its execution evidence comes from the Linux CI leg, because
this development host is windows/amd64 with no WSL and no Docker.
The macOS row is marked self-hosted on structural evidence only:
parseMachO validates MH_PIE, the segment set and protections,
page-aligned placement, the entry, and decodes the rebase stream, but no
Mach-O image has been executed, because this repository has no macOS
runner and no Intel-Mac host in its history. Every Mach-O claim since
increment 149 has been structural, and the v1.2.0 release does not change
that.
See also
Target — the karkain target command.
Target Triples — accepted triple forms and normalization.
Cross-Compilation — what builds where, and the honest matrix.