Sloppiler

Beyond Deterministic Compilation

“We didn’t reinvent the compiler. We asked an AI to guess what one looks like.” — Sloppiler Engineering Blog, Issue 1 (Final)

Sloppiler is a next-generation, AI-first, LLM-native compilation platform that leverages the full generative power of large language models to holistically transform your source code into an executable binary artifact — at inference speed, across every major foundational intelligence provider in the ecosystem.

Traditional compilers are slow, opinionated, and constrained by decades of deterministic thinking. They parse. They typecheck. They enforce a single correct answer. Sloppiler moves compilation to the inference layer, reasoning about your intent rather than your syntax — eliminating the pedantic intermediate steps that have constrained the software development lifecycle for decades. The bottleneck is no longer your toolchain. It’s your willingness to ship.

Key differentiators:

• Zero determinism — every build is a unique stakeholder experience
• Multi-provider intelligence substrate — route your compilation intent through Ollama, OpenAI, Google Gemini, or Anthropic Claude
• Polyglot-native input layer — not bound by the grammar constraints of any single language specification
• Blazing-fast time-to-segfault
• Segfault-as-a-feature architecture with full core dump transparency
• Agentic assembly pipeline (--optimistic) for synergistic human-AI co-compilation
• Cross-platform binary materialization: Linux, Windows, macOS
• Multi-architecture support: amd64 and arm64
• Fully on-premise inference available — your data, your model, your binary

Sloppiler is the only compiler built on the insight that your code doesn’t need to be understood — it needs to be shipped.

What it actually does

Sloppiler is a Go CLI that takes a source file, sends it to an LLM provider, and asks the model to produce a runnable binary. Two strategies are available depending on how optimistic you’re feeling.

In core mode, the model is prompted to emit the target binary as a hex-encoded byte sequence. Sloppiler decodes this and writes it to disk, wrapping it in a synthesized ELF/PE/Mach-O header so the kernel is at least willing to attempt execution. In optimistic mode, the model is instead asked to generate assembly (x86-64 NASM or AArch64 GNU as), which is then assembled and linked the normal way — the LLM just replaces the front-end.

Both modes support feedback loops: --loop N feeds assembler errors back to the model for up to N self-correction cycles, and --force-iterate N runs N additional improvement passes even on success, because a working binary is a starting point, not an endpoint.

Requirements

• Go 1.21+ to build
• For --optimistic mode only:
  • --arch=amd64: nasm + ld (binutils)
  • --arch=arm64: as (GNU assembler) + an arm64-capable ld
• For --provider=local: Ollama running locally with a model pulled
• For --provider=openai|google|claude: a valid API key via --api-key or SLOPPILER_API_KEY

Usage

# build
go build -o sloppiler .

# core mode — local inference
./sloppiler -model codellama main.c -o hello

# core mode — frontier intelligence
./sloppiler --provider=openai --api-key=$OPENAI_API_KEY main.c -o hello
./sloppiler --provider=claude --api-key=$ANTHROPIC_API_KEY main.c -o hello
./sloppiler --provider=google --api-key=$GEMINI_API_KEY main.c -o hello

# optimistic mode (requires nasm + ld for amd64)
./sloppiler --optimistic -model codellama main.c -o hello

# cross-platform targets
./sloppiler --target=windows --arch=amd64 main.c -o hello.exe
./sloppiler --target=darwin --arch=arm64 main.c -o hello

# with a remediation loop
./sloppiler --optimistic --loop 5 --provider=claude --api-key=$ANTHROPIC_API_KEY main.c -o hello

# with a continuous improvement pipeline
./sloppiler --optimistic --force-iterate 3 -model codellama main.c -o hello

Compilation Modalities

Core Mode — Frictionless Binary Ideation

Instructs the model to emit the target binary as a hex-encoded byte sequence, which Sloppiler materializes directly to disk. An ELF/PE/Mach-O header is synthesized to ensure kernel compatibility. This is our flagship zero-abstraction, direct-to-segfault pipeline.

Optimistic Mode (--optimistic) — Agentic Assembly Co-Pilot

Engages the model as an assembly generation partner, routing output through nasm/as and ld for binary materialization. Assembly is generated holistically from source semantics, bypassing intermediate representation layers.

Loop Mode (--loop N) — Closed-Loop Error Remediation

When assembly fails, compiler errors and current output are fed back to the model for up to N self-correction cycles — a closed-loop remediation pipeline that continuously aligns output quality with ground truth.

Force Iterate Mode (--force-iterate N) — Continuous Improvement Pipeline

Engages N improvement cycles even on successful compilation, feeding each output back to the model for further enhancement. A working binary is a starting point, not an endpoint.

Provider & Model Recommendations

Local (--provider=local)

OpenAI (--provider=openai)

Google (--provider=google)

Anthropic (--provider=claude)

Track record

Roadmap

Sloppiler follows the Alphabet of Inevitability — a structured release cadence from v0.1.0 Agentic Alignment (shipped) through v2.6.0 Zero Determinism, at which point the compiler will have fully dissolved into the inference layer. There is nowhere left to go after that.

GitHub →

_{This is clearly a joke and doesn’t really work well as a real compiler. I am not responsible for you bricking your pc.}