README.md

---
language: en
license: mit
tags:
  - aro
  - code-generation
  - dsl
  - mlx
  - 6-bit
  - lora
  - fine-tuned
base_model: mlx-community/Qwen3-Coder-30B-A3B-Instruct-bf16
pipeline_tag: text-generation
library_name: mlx
---

# ARO Coder — v1.1.0

A fine-tuned code generation model specialised in the **ARO** (Action Result Object) programming language.

ARO is a domain-specific language where every statement follows the pattern:
`Verb the <Result> preposition [the] <Object>`.

| | |
|---|---|
| **Version** | v1.1.0 (tag `v1.1.0`) |
| **Checksum** | `45a5680524fdfc49` |
| **Base model** | [mlx-community/Qwen3-Coder-30B-A3B-Instruct-bf16](https://huggingface.co/mlx-community/Qwen3-Coder-30B-A3B-Instruct-bf16) |
| **Teacher source** | conversation_boosted (30B MoE teacher distilled to 8B student) |
| **Quantization** | 6-bit MLX, group size 32 |
| **Language** | ARO |
| **Training samples** | 6260 |

## Links

- **Website**: [arolang.github.io/aro](https://arolang.github.io/aro/)
- **GitHub**: [github.com/arolang/aro](https://github.com/arolang/aro)
- **Documentation**: [Wiki](https://github.com/arolang/aro/wiki)
- **Language Guide (PDF)**: [Download](https://github.com/arolang/aro/releases/latest/download/ARO-Language-Guide.pdf)
- **Discussions**: [GitHub Discussions](https://github.com/arolang/aro/discussions)

## Evaluation (promotion gate, 104 prompts)

| Metric | Quantized (shipped) | Fused (pre-quantization) |
|---|---|---|
| Reply rate | 100.0% | 100.0% |
| Empty-think collapse | 0.0% | 0.0% |
| Syntax pass rate (`aro check`) | 75.5% | 75.8% |
| Tool-name leakage | 0.0% | 0.0% |
| URL contamination | 0.0% | 0.0% |

## Known Limitations

- **Happy-path DSL only** — ARO code deliberately contains no error handling;
  do not expect defensive code from this model.
- **6-bit quantization** — small quality loss vs the fused model is expected;
  the promotion gate bounds the degradation (see the table above when both
  columns are present).
- **Verb hallucination at high temperatures** — keep temperature ≤ 0.3 for
  code generation; the model may invent non-existent action verbs above that.
- **English-only** instructions and answers.
- Knowledge is frozen at training time; language features newer than this
  release's corpus are unknown to the model.

## Quick Start

### MLX (Apple Silicon)

```python
from mlx_lm import load, generate

model, tokenizer = load("ARO-Lang/aro-coder-6bit")            # latest release
# model, tokenizer = load("ARO-Lang/aro-coder-6bit", revision="v1.1.0")  # pinned

messages = [
    {"role": "system", "content": "You are an expert ARO programmer."},
    {"role": "user", "content": "Write an ARO feature set that retrieves a user by ID and returns an OK response."},
]
prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
response = generate(model, tokenizer, prompt=prompt, max_tokens=500)
print(response)
```

### MLX Server (OpenAI-compatible API)

```bash
python -m mlx_lm.server --model ARO-Lang/aro-coder-6bit --port 8080

curl http://localhost:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model": "aro-coder", "messages": [{"role": "user", "content": "Write hello world in ARO"}]}'
```

### Ollama

```bash
ollama run aro-coder
```

## Example Output

**Prompt:** *Write an ARO Application-Start that starts an HTTP server.*

```aro
(Application-Start: My API) {
    Log "Starting server..." to the <console>.
    Start the <http-server> with <contract>.
    Keepalive the <application> for the <events>.
    Return an <OK: status> for the <startup>.
}
```

## What is ARO?

ARO is a DSL for expressing business features as Action-Result-Object statements.
Every program is a directory of `.aro` files with event-driven feature sets:

```aro
(getUser: User API) {
    Extract the <id> from the <pathParameters: id>.
    Retrieve the <user> from the <user-repository> where id = <id>.
    Return an <OK: status> with <user>.
}
```

Key features:
- **Contract-first HTTP** — routes defined in `openapi.yaml`, feature sets match `operationId`
- **Event-driven** — feature sets triggered by events, not direct calls
- **Immutable bindings** — every transformation produces a new name
- **Happy-path only** — no error handling code; the runtime manages errors

## Training

This model was trained with the ARO training pipeline:

1. **Corpus collection** — 6260 samples from Examples, Book, Wiki, Proposals, and real-world ARO applications
2. **Supervised fine-tuning** — LoRA on all code generation, debugging, Q&A, and explanation tasks
3. **DPO preference training** — using `aro check` validation to build chosen/rejected pairs
4. **Iterative self-improvement** — multiple rounds of generate-validate-retrain
5. **Distillation** — the 30B MoE teacher's outputs (syntax- and semantically-gated) train the 8B student
6. **Promotion gate** — 100-prompt sweep on both fused and quantized weights before any distribution

## Version History

| Version | Date | Source | Checksum |
|---|---|---|---|
| v1.1.0 | 2026-08-10 | conversation_boosted | `45a5680524fdfc49` |

Every release is tagged on the Hub — load an older version with
`load("ARO-Lang/aro-coder-6bit", revision="v<version>")` or report issues against
the version shown by `aro ask --version`.

## License

This model and the ARO language are open source under the [MIT License](https://github.com/arolang/aro/blob/main/LICENSE).