ARO-Lang/aro-coder-4bit

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	aa6e67f1a5835ff2
Base model	mlx-community/Qwen3-Coder-30B-A3B-Instruct-4bit
Teacher source	distill_student (30B MoE teacher distilled to 8B student)
Quantization	4-bit MLX, group size 64
Language	ARO
Training samples	4365

Links

• Website: arolang.github.io/aro
• GitHub: github.com/arolang/aro
• Documentation: Wiki
• Language Guide (PDF): Download
• Discussions: GitHub Discussions

Evaluation (promotion gate, 102 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)	60.2%	60.4%
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.
• 4-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)

from mlx_lm import load, generate

model, tokenizer = load("ARO-Lang/aro-coder-4bit")            # latest release
# model, tokenizer = load("ARO-Lang/aro-coder-4bit", 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)

python -m mlx_lm.server --model ARO-Lang/aro-coder-4bit --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

ollama run aro-coder

Example Output

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

(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:

(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 — 4365 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-07-24	distill_student	aa6e67f1a5835ff2

Every release is tagged on the Hub — load an older version with load("ARO-Lang/aro-coder-4bit", 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.