TL;DR
Axis is a tiny systems programming language that uses Python-like syntax but compiles directly to x86-64 machine code and produces ELF64 executables without external linkers or runtime libraries. It targets Linux x86-64 and is currently an MVP lacking several language and runtime features such as multiplication, division, function parameters, and standard library support.
What happened
A new open-source project called AXIS presents a compact systems programming language that aims for predictable, C-level performance while keeping a Python-like surface syntax. The compiler pipeline is implemented in Python and emits raw x86-64 machine code and ELF64 executables; no external assembler, linker, or runtime library is required. AXIS enforces explicit typing with hardware-native integer types (i8–i64, u8–u64), a ptr type, and a bool represented as u8. The runtime model is minimal: executables include a small _start stub that calls main and invokes the exit syscall. Distribution includes a one-line installer that places the compiler in ~/.local/bin and an optional VS Code extension for syntax highlighting. The project is Linux x86-64 only and lists several unimplemented features in its MVP, including arithmetic operators (*, /), function parameters beyond main, structs, arrays, heap allocations, and standard I/O syscalls like write.
Why it matters
- Generates standalone ELF64 binaries without needing external toolchain components, simplifying deployment on supported Linux systems.
- Design choices favor predictable, low-level control and performance comparable to C, which may appeal to systems programmers who want transparency over abstraction.
- A very small, focused language and toolchain could make low-level compilation concepts more accessible for learning and experimentation.
- Platform and feature limitations mean adoption will be constrained to Linux x86-64 environments until more features are implemented.
Key facts
- AXIS compiles directly to x86-64 machine code and produces ELF64 executables; no external assembler, linker, or runtime library is required.
- Target platform: Linux x86-64 (Ubuntu, Debian, Fedora, Arch, openSUSE, etc.); not supported: Windows, macOS, ARM/ARM64.
- Implementation is in Python (requires Python 3.7+); the compilation pipeline uses files like tokenization_engine.py, syntactic_analyzer.py, semantic_analyzer.py, code_generator.py, and an ELF generator.
- Language enforces explicit typing; integer types provided: i8–i64 and u8–u64; also includes bool, ptr; no implicit conversions.
- Entry point for programs is main() returning i32; generated binaries include a small _start stub that calls main and issues the exit syscall.
- Calling convention follows System V AMD64: first six arguments in registers (rdi, rsi, rdx, rcx, r8, r9) and return value in rax/eax.
- Installer options: a one-line curl installer that installs to ~/.local/bin and configures PATH, or manual install via git clone and installer scripts.
- VS Code extension is available for .axis files and provides syntax highlighting and build-task integration.
- MVP limitations: multiplication and division operators not implemented; function parameters (only main without args works); no structs, arrays, pointer dereferencing, global variables, heap allocations, string literals, type casting, floating-point types, or a standard library; write/read syscalls are planned but not yet implemented.
What to watch next
- Implementation of multiplication (Mul) and related arithmetic ops listed on the project's roadmap (Phase 5).
- Addition of basic syscalls (write, read) currently marked as planned; these would enable standard I/O from compiled programs.
- Progress on function parameter support beyond main and other missing language features (structs, arrays, pointer dereferencing).
- Not confirmed in the source
Quick glossary
- ELF64: Executable and Linkable Format for 64-bit Unix-like systems; a common binary format for Linux executables.
- System V AMD64 calling convention: A standard function-call ABI on x86-64 Linux where the first six integer/pointer arguments are passed in registers and the return value uses rax/eax.
- Zero-cost abstractions: A design principle where high-level language features introduce no runtime overhead compared to equivalent low-level code unless those features are used.
- Syscall: A system call is an explicit request from user-space code to the operating system kernel to perform services like I/O or process management.
- MVP: Minimum Viable Product — an initial version of a project that includes a subset of intended features, used to validate design and iterate.
Reader FAQ
What platforms does AXIS support?
Linux x86-64 only (examples listed include Ubuntu, Debian, Fedora, Arch, openSUSE).
Does AXIS produce standalone binaries or require external tools?
It emits raw x86-64 machine code and generates ELF64 executables without needing an external assembler, linker, or runtime library.
Can I use multiplication, division, and function parameters?
Not in the current MVP: multiplication and division operators are not implemented, and only main() without arguments is supported for parameters.
Is a standard library or heap allocation available?
Not confirmed in the source.
AXIS A minimalist system programming language with Python-like syntax and C-level performance. AXIS compiles directly to x86-64 machine code without requiring external linkers, assemblers, or runtime libraries. ⚠️ Platform Requirements:…
Sources
- Show HN: Axis – A systems programming language with Python syntax
- Axis – A systems programming language with Python syntax
- Simple Programming Languages – Ryan Brewer
- Can a programming language have the simplicity of …
Related posts
- CacheKit: High-performance Rust library for cache policies and tiers
- Revup lets you upload once to create multiple related GitHub PRs
- How a 40-line fix closed a 400x JVM performance gap on Linux systems