---
license: apache-2.0
base_model: Qwen/Qwen3-Coder-30B-A3B-Instruct
tags:
  - verse
  - uefn
  - fortnite
  - unreal-editor-for-fortnite
  - code-generation
  - lora
  - peft
language:
  - en
library_name: peft
pipeline_tag: text-generation
---

# Verse-Coder-30B-v1 — a UEFN **Verse** code LoRA

🌴 **[verseisland.com](https://verseisland.com)** — learn Verse by exploring the island (built by the team behind this model)
· **[@TheVerseIsland on X](https://x.com/TheVerseIsland)** for v2 news and UEFN/Verse drops
· built by **[Biloxi Studios](https://biloxistudios.com)**


A LoRA adapter that teaches `Qwen3-Coder-30B-A3B-Instruct` to write **Verse**, the
programming language of **Unreal Editor for Fortnite (UEFN)**. Verse is scarce in
open pre-training data, so base coder models default to Python/C#-shaped guesses for
Verse prompts. This adapter fixes that — and it runs on a **single RTX 4090**.

> **Headline:** on a compile-gated benchmark (real UEFN compiler, raw first-pass, no
> retries), the adapter passes **20%** vs the identical base's **4%** — a **+400%
> relative improvement** at the same quantization and hardware.

## What it's for

Generating compilable Verse for UEFN gameplay: device scripts (`creative_device`),
scene-graph components, and HUD/widget code from a plain-English task + the devices
involved. It was built to power a Verse learning/authoring pipeline, and this V1 is
released so the community can run a capable Verse model locally.

## How it was trained

- **Base:** `Qwen/Qwen3-Coder-30B-A3B-Instruct` (Apache-2.0, MoE).
- **Method:** QLoRA (4-bit nf4), **r=32, α=64**, attention projections (`q/k/v/o_proj`), 2 epochs.
- **Data:** ~900 supervised pairs + a raw Verse corpus — all **compile-verified** or
  first-party: device/API reference articles whose examples passed the real UEFN
  compiler, an API-surface Q/A set built from the UEFN digests, and Verse source.
  No scraped/unverified code.
- **Final train loss ≈ 0.95** (from ~2.1), token-accuracy ≈ 0.79.

## Evaluation (the honest version)

Every candidate script is compiled on the **real UEFN compiler**. Metric = **raw
first-pass compile-pass rate, no escalation, no retries** — the hardest, least-flattering
bar. Test set = 50 device-diverse craft tasks spanning three paradigms (device-verse /
scene-graph / widget); the numbers below are n=25.

**The key control — same Q4 endpoint, LoRA on vs off (scale 0):**

| | compile-pass (raw first-pass, n=25) |
|---|---|
| **Verse-Coder-30B-v1 (LoRA ON)** | **20% (5/25)** |
| Qwen3-Coder-30B base (LoRA scale 0, same endpoint) | 4% (1/25) |
| **Δ (the adapter's contribution)** | **+16 pts / +400% relative** |

By paradigm (LoRA on): device-verse 22% · scene-graph 25% · widget 12% — it generalizes
past devices, not a device-only model.

For scale: on this same harness, Claude Sonnet passes ~80–100% (the frontier ceiling),
and a much larger production 35B base scores ~20% — i.e. this 4090-sized adapter matches a
model class above its weight on Verse specifically.

### What the adapter actually learned (one example)

A representative base failure — it doesn't know Verse's class syntax and writes it C#/Java-style:

```
# BASE (LoRA off):
class CountdownGame extends creative_device   # ← wrong language shape
→ Script error 3100: Unexpected "CountdownGame"
```

The adapter writes correct Verse:

```verse
# LoRA ON:
rune_portal_component := class(creative_device):
    @editable PortalTrigger : trigger_device = trigger_device{}
    OnBegin<override>()<suspends> : void =
        PortalTrigger.TriggeredEvent.Subscribe(OnPortalTriggered)
```

> **Caveat, stated plainly:** this is a **Q4_K_M** quant on a single 4090 — the
> accessible-hardware configuration, not a quality ceiling. fp16/higher-quant serving
> is expected to score higher. 20% raw-first-pass is a **floor**; with a single
> compiler-error fix loop, ~half the near-misses (err=1) resolve.

## Usage

Merge or apply the adapter to the base, or run the included **GGUF** (`~52 MB`) with
llama.cpp against a `Qwen3-Coder-30B-A3B` GGUF:

```bash
./llama-server -m Qwen3-Coder-30B-A3B-Instruct-Q4_K_M.gguf \
  --lora verse-coder30b-v1-lora.gguf --ctx-size 40960
```

Prompt with a clear task + the UEFN devices involved. Ground it in real device APIs where
you can — the model is strongest when told the exact device methods/events to use.

## Limitations

- Verse and UEFN evolve; APIs drift. Always compile in UEFN.
- Q4 first-pass ~20% — treat output as a strong draft to compile-check + fix, not
  guaranteed-correct code.
- Trained on gameplay-device Verse; niche APIs (advanced UI, scene-graph edge cases) are weaker.

## License & attribution

Adapter released under **Apache-2.0**, matching the base
`Qwen/Qwen3-Coder-30B-A3B-Instruct`. "Verse", "UEFN", and "Fortnite" are trademarks of
Epic Games; this is an independent community model, not affiliated with or endorsed by
Epic Games. Built by [Verse Island](https://verseisland.com) — a Biloxi Studios Inc project ([biloxistudios.com](https://biloxistudios.com)).