TL;DR
Xcc700 is a compact, single-file C compiler that can run on and target ESP32 Xtensa chips. It produces REL ELF binaries that can be loaded by ESP-IDF's elf_loader, but it omits many C features and sacrifices optimization for simplicity.
What happened
A developer published xcc700, a minimalist C compiler implemented in a single .c file and totaling about 700 lines. The project can be built on a host with gcc and run as a cross-compiler, or compiled for the ESP32 to self-host; a precompiled 16 KB ELF is also provided. The tool parses a constrained subset of C (basic control flow, simple types, pointers, arrays, functions, arithmetic and bitwise ops) and emits REL ELF output plus a basic Xtensa bytecode emitter. Sample build metrics reported include ~700 input lines, ~7,977 tokens, around 27.7 KB of .text and a ~33 KB ELF, with performance figures measured on an esp32-s3. The author documents many missing or partial language features, minimal error checking, and a simple stack-machine code generation approach that forgoes register allocation. The source is MIT-licensed and the author invites forks for education and experimentation.
Why it matters
- Provides a tiny, inspectable compiler implementation suitable for learning compiler internals on modern MCU hardware.
- Generates ELF modules that can be dynamically linked into ESP-IDF firmware via elf_loader, enabling quick test/debug workflows or hotfixes.
- Small footprint makes it usable on low-cost hardware like ESP32 for coursework, hackathons, or embedded tinkering.
- Offers a minimal reusable ELF writer and a base Xtensa emitter that can be extended for custom toolchains or experiments.
Key facts
- Codebase is a single C source file totaling about 700 lines.
- Reported sample build: ~700 lines input, ~7,977 tokens, ~27.7 KB .text, ~33 KB ELF output.
- Two build modes: compile with host gcc as a cross-compiler, or build for ESP32 using xtensa-gcc; a prebuilt 16 KB ELF is provided.
- Supported C subset: while, if/then/else, limited int/char/pointer/array support, function calls/defs, basic arithmetic and bitwise operators.
- Omissions include: for/do, include/define, long/float/double, structs/unions/typedefs, switch/case, array initializers, .data section, multi-line comments, and many others.
- Error handling is minimal; the compiler has few checks and can crash on trivial errors.
- Code generation treats Xtensa as a stack machine with no register allocation or use of the sliding window, prioritizing simplicity over performance.
- Performance example: gcc-compiled run reported ~17,500 lines/sec and produces a ~16 KB binary; self-compiled on-device run reported ~3,900 lines/sec and a ~33 KB binary.
- Repository is published under the MIT License and the author encourages forks and educational use.
What to watch next
- Community forks and extensions that add missing language features or improve code generation (author explicitly invites forks).
- not confirmed in the source
- not confirmed in the source
Quick glossary
- ELF: Executable and Linkable Format, a common file format for executables, object code, shared libraries, and core dumps on Unix-like systems.
- Self-hosting compiler: A compiler that is capable of compiling its own source code.
- Xtensa: A configurable CPU architecture from Tensilica used in many Espressif microcontrollers, including some ESP32 variants.
- ESP-IDF elf_loader: An ESP-IDF component that can load and relocate ELF object files into a running ESP32 firmware image.
Reader FAQ
Can xcc700 compile itself?
Yes; the project notes it can be compiled with host gcc and can self-compile on ESP32 when built for that target.
How do I run xcc700?
Options include compiling with host gcc to use as a cross-compiler, compiling it for ESP32 with xtensa-gcc or using the provided prebuilt ELF with ESP-IDF elf_loader, or embedding/adapting its code inside firmware.
Does xcc700 implement full C99?
No. Many C features are missing or only partially implemented; the README lists numerous omissions and partial behaviors.
Is xcc700 production-ready?
Not recommended for production: error handling is minimal and the compiler can crash; it trades robustness and optimization for compactness and simplicity.
xcc700: Self-hosting mini C compiler for esp32 / Xtensa Why look into this project? A compiler you can fully grasp and tweak, on a modern platform where small is still…
Sources
- Show HN: Xcc700: Self-hosting mini C compiler for ESP32 (Xtensa) in 700 lines
- Self-hosting mini C compiler for ESP32 (Xtensa) in 700 lines
- Is ESP32 compiler xtensa-esp32-elf-g++ able to use a
- D on esp32/esp8266(llvm-xtensa+ldc) and how to get started
Related posts
- AutoLISP Interpreter Compiled to Rust/WebAssembly Brings CAD to Browser
- Unix “find” expressions compiled to bytecode — compiling find’s expression language
- LearnixOS: Step-by-step guide to building a POSIX OS in Rust