Design, implementation, verification, documentation, code review, CI, releases, and the process rules that govern the next cycle.
100% AI-created · Human-managed · Rust + LLVM
Typed Python in.
Autonomous artifacts out.
pycc is an open-source ahead-of-time compiler project for standard Python 3.14. Its design contract is to check annotations at compile time, then emit a fast, autonomous deployment artifact—without inventing a new language. Native and pure builds emit standalone executables; planned permitted CPython interop emits a self-contained bundle with its pinned runtime. AI agents create the entire project; a human only manages direction, priorities, and constraints.
$ pycc check hello.py
Type-check typed Python · pre-alpha
def fib(n: int) -> int:
return n if n < 2 else fib(n - 1) + fib(n - 2)
def main() -> None:
print(fib("35"))
error[T0021]
compile-time
argument 1 of fib expects int, got str
5
print(fib("35"))
help: did you mean int("35")?
3.14
Standard Python target
Strict
Compile-time types
Native
Standalone output
No dialect
Python syntax stays Python
01 · Development model
Built entirely by AI.
Managed by a human.
pycc is an experiment in autonomous software development. AI agents create the specifications, every line of project code, tests, documentation, reviews, and release automation.
Only manages goals, constraints, priorities, product decisions, and the definition of success.
0 No project code is handwritten by a human.
02 · Why pycc
One tool should finish the whole job.
Type checkers stop before runtime. Packagers bundle an interpreter. Typed-subset compilers trade compatibility breadth for static optimization. Python-like compilers ask you to adopt a dialect.
pycc's design target combines hard type errors, standard Python syntax, native execution, and autonomous permitted-interoperability bundles in one compiler pipeline. Annotations are the contract—not optional hints.
The intended position
Design targets, not release claims| Tool | Static model | Output artifact | Language contract |
|---|---|---|---|
| >_ pycc | Hard annotations | Standalone target | CPython 3.14 target |
| LPython | Typed subset | AOT executable | CPython-compatible subset |
| Codon | Static language | Native code | Python-like language |
| Nuitka | None required | Executable | Standard Python |
| mypyc | Strict subset | C extension | Standard Python subset |
This table describes the intended position. The source-backed Python AOT compiler comparison separates current output models and pycc's pre-alpha status.
03 · Compiler pipeline
From source file to machine code.
-
01
.py
Parse
CPython 3.14 grammar, source spans preserved.
-
02
HIR
Check
Resolve names and enforce the typed contract.
-
03
MIR
Lower
Build typed IR for optimization and ownership analysis.
-
04
LLVM
Compile
Emit the native binary, or package the planned pinned CPython closure when permitted interop requires it.
04 · Honest status
The v0.1 and v0.2 frontend and native backend exist. The compiler is not ready for production.
pycc check now runs the v0.1 frontend:
parsing, HIR lowering, strict type checking, private-helper
inference, and stable human or JSON diagnostics. Native
build/run lower that implemented surface
through MIR, LLVM, the host linker, and the runtime. v0.1's
acceptance criteria are met: fib and
mandelbrot-ascii match pinned CPython output on all
five Tier-1 targets, pycc check clears its
<75ms/1000 LOC throughput floor, and diagnostic output matches the
stable CLI specification's example.
- Strict v0.1 frontend and diagnostic snapshots
- v0.1 native backend with documented gaps
- v0.1 acceptance criteria met (conformance verified on all five Tier-1 targets)
- v0.2 acceptance criteria also met; v0.3's class model core has landed
- The full conformance matrix and the rest of v0.3 are next
Read the code. Watch the agents work.
Follow an AI-built Python compiler from first slice to production.
A human manages the mission. AI agents execute, test, review, and evolve the project in public under the MIT license.
Visit the repository