# 04 — Building a Language Front End
This lesson shows how to use the modular multi-language framework in
`/lib/compiler` to build a compiler for any publicly known programming language.
See [`MULTI-LANGUAGE.FRAMEWORK.md`](../MULTI-LANGUAGE.FRAMEWORK.md) for the full
reference.
## The idea
A compiler for a language is a small SLeeLa front end that extends the common
`SLLanguageCompiler` contract. Many independent front ends are registered into
one shared `SLCompilerRegistry`. Every front end lowers its own language toward
the common SLeeLa IR and onward to a VM-ready artifact:
```
source -> front end -> SLeeLa IR -> VM lowering -> SLVM/SLJVM
```
Compilation is not execution: a produced artifact is only ever run later across
an explicit SLeeLa VM/OS and security boundary.
## Step 1 — declare identity and phases
Create `frontends//LanguageCompiler.sleela` and extend
`SLLanguageCompiler`. In `configure()`, declare the language identity and
`provide(...)` each pipeline phase you implement:
```
class CLanguageCompiler extends SLLanguageCompiler {
void configure() {
declare("C", "C-family", "C17", ".c", TARGET_SLVM);
provide(PHASE_SOURCE); provide(PHASE_LEX); provide(PHASE_PARSE);
provide(PHASE_RESOLVE); provide(PHASE_SEMANTIC); provide(PHASE_IR);
provide(PHASE_LOWER); provide(PHASE_CODEGEN);
}
}
```
## Step 2 — implement the phase hooks
Override only the phases you provide. The base returns whether the phase is
declared; your override drives the language-specific work (e.g. Python's
indentation-significant lexing, Rust's borrow checking in the semantic phase).
## Step 3 — register and plan
```
SLCompilerRegistry registry = new SLCompilerRegistry();
registry.add(new CLanguageCompiler());
SLCompileRequest request = new SLCompileRequest();
request.configure("C", "util.c", SLLanguageCompiler.TARGET_SLVM);
SLCompilePlan plan = new CLanguageCompiler().planCompile(request);
boolean ready = plan.isVMReady();
```
The plan is **fail-closed**: it reports the first missing phase and never
guesses. A front end that stops at IR can still reach the `SLIR` target but is
not VM-ready for `SLVM`; a `strict` request fails closed when any required phase
is absent; a reference-only module is never asked to emit.
## Targets
| Target | Use |
|---|---|
| `SLVM` | native SLeeLa VM artifact |
| `SLJVM` | JVM-family languages (e.g. Java) |
| `SLIR` | stop at SLeeLa IR for analysis/library work |
| `NATIVE` | native plan only; emission gated by the VM/OS boundary |
## Example and self-test
- Runnable example: [`examples/multi-language-registry.sleela`](examples/multi-language-registry.sleela)
- Native behavioral self-test: `make -C lib/compiler selftest`
**SLeeLa — MEARVK LLC — 2026**