Sloppiler
Beyond Deterministic Compilation
“We didn’t reinvent the compiler. We asked an AI to guess what one looks like.”
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.
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.
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 a locally-running Ollama model, 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 synthesised ELF header so the kernel is at least willing to attempt execution. In optimistic mode, the model is instead asked to generate x86-64 assembly, which is then assembled with nasm and linked with ld the normal way — the LLM just replaces the front-end.
Both modes also support feedback loops: --loop N feeds nasm 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.
Usage
# build
go build -o sloppiler .
# core mode
./sloppiler -model codellama main.c -o hello
# optimistic mode (requires nasm + ld)
./sloppiler --optimistic -model codellama main.c -o hello
# with a remediation loop
./sloppiler --optimistic --loop 5 -model codellama main.c -o hello
# with a continuous improvement pipeline
./sloppiler --optimistic --force-iterate 3 -model codellama main.c -o hello
| Flag | Default | Description |
|---|---|---|
-model | llama3 | Ollama model to use |
-o | a.out | Output binary path |
-ollama | http://localhost:11434/api/generate | Ollama API URL |
--optimistic | false | Engage agentic assembly co-pilot |
--loop N | 0 | Closed-loop error remediation cycles |
--force-iterate N | 0 | Continuous improvement pipeline cycles |
Track record
| Mode | Model | Output | Result |
|---|---|---|---|
| default | phi3 | is nothealing.! wrapped in ELF | segfault |
| default | codellama | nested ELF headers | segfault |
| optimistic | phi3 | assembly on line 1 | nasm error |
| optimistic | codellama | valid binary, Hello, world! printed | worked! |
Model recommendations
| Model | Behaviour |
|---|---|
codellama | Strong binary output fidelity. Highest semantic alignment in --optimistic mode. Recommended. |
phi3 | Fastest inference. Highest creative latitude in output generation. Best for rapid iteration. |
llama3 | Verbose output with extensive reasoning traces. Prioritizes explanation over binary materialization. |
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.
This is clearly a joke and doesn’t really work well. I am not responsible for you bricking your pc.