A full fine-tune of Qwen/Qwen3.5-0.8B that proofreads Spanish, one sentence at a time, offline on the CPU. It reads a sentence and writes it back with its spelling and grammar fixed (accents, typos, haber / a ver, echo / hecho, dequeísmo, agreement…), or unchanged if it is already correct. It is the model inside revisa, a free desktop proofreader for Windows and Linux: select text in any app, press a shortcut, review the edits, press Enter.
The revisa app on Windows: select text in an email, a chat or Notepad, press Ctrl+Alt+Space, review the edits and press Enter. Real recording with revisa-0.8b running on the CPU.
revisa-0.8b es un ajuste fino completo de Qwen3.5-0.8B que corrige la ortografía y la gramática
del castellano frase a frase, sin conexión y en la CPU. Recibe una frase y la devuelve corregida
(tildes, erratas, «haber» / «a ver», «echo» / «hecho», dequeísmo, concordancia…) o sin cambios si
ya es correcta; no cambia el estilo. Es el modelo de revisa, un corrector gratuito para
Windows y Linux: seleccionas texto en cualquier aplicación, pulsas Ctrl+Alt+Espacio, revisas los
cambios y los aceptas con Enter. En la app, el modelo solo propone: código determinista calcula las
ediciones palabra a palabra, les asigna un tipo y una explicación de un catálogo cerrado y, ante la
duda, no toca nada.
En el test de revisa-bench-es logra una F0.5 de 81,5 en ediciones reales de Wikipedia, de 80,0 en páginas de discusión de Wikipedia y de 92,0 en mensajes de trabajo sintéticos (correos, chats de equipo y notas), con un 1,8 %, un 2,4 % y un 0,9 % de falsas alarmas en los textos correctos: por encima de LanguageTool 6.6 y de Qwen3.5-9B sin ajustar en las tres partes. Tarda 138 ms por frase (mediana) en la CPU de un ordenador de sobremesa con 8 hilos, sin GPU. Pesa 529 MB (GGUF Q4_K_M).
The model is meant to be used inside the revisa app (or its CLI), where it only proposes a rewrite and deterministic code decides what reaches the user:
text ─► sentences ─► revisa-0.8b ─► word diff ─► classifier + catalog ─► guards ─► edits
(URLs, (rewrites the (original (31 error types, ("when in (type +
emails, sentence; vs fixed explanation doubt, explanation,
code… same text if rewrite) in Spanish; anything don't you accept
protected) correct) else is OTRO) touch") with Enter)
¿ and ¡, letter confusions (b / v, g / j, ll /
y, h), homophones such as hay / ahí / ay, echo / hecho, e / he, haber / a ver,
sino / si no, porque / por qué, dequeísmo and queísmo, impersonal haber (hubieron →
hubo), -stes past forms, laísmo, leísmo and loísmo, infinitive for imperative, common wrong
verb forms, gender and number agreement, and an extra comma between subject and verb.Not intended for: other languages, long-form rewriting or style editing, or as a chat model. It was trained only on the prompt below.
revisa is a small tray app for Windows and Linux that works in any application (webmail, Slack, Word, a terminal…) without plugins:
revisa check), a local HTTP server (revisa serve) and a
language server for editors (revisa lsp).The same flow on Linux. Real recording with revisa-0.8b running on the CPU.
Measured on the frozen test of revisa-bench-es, a Spanish proofreading benchmark in three parts that are reported separately (they are different kinds of text, so no single mixed number is given; a mean of the three is given, labeled as such). Each case is one to three sentences:
| Part | Source | Cases | With errors | Correct |
|---|---|---|---|---|
| A | Wikipedia edits: real corrections made by editors in the Spanish Wikipedia edit history (the "before" is the input) | 917 | 291 | 626 |
| B | Wikipedia talk pages: real informal text by native speakers of Spanish writing fast | 823 | 270 | 553 |
| C | Work messages (synthetic): work emails, team chat and instant messages, work notes, with realistic errors | 648 | 324 | 324 |
F0.5 is computed per edit (an edit counts only with the same span and the same replacement as the gold), so it rewards precision. False alarms are the share of correct cases that get at least one edit. Every LLM, revisa included, is scored through the same deterministic guards of the app (the "guard view"); LanguageTool is scored as is. Higher F0.5 and lower false alarms are better.
| System | Size | F0.5 A | F0.5 B | F0.5 C | Mean F0.5 | False alarms A / B / C |
|---|---|---|---|---|---|---|
| revisa-0.8b (this model, with the app's guards) | 0.8B | 81.5 | 80.0 | 92.0 | 84.5 | 1.8% / 2.4% / 0.9% |
| revisa-0.8b, model alone (no guards) | 0.8B | 77.4 | 75.8 | 91.7 | 81.6 | 2.4% / 6.0% / 0.9% |
| Qwen3.5-0.8B, untuned (the base) | 0.8B | 70.4 | 67.9 | 71.2 | 69.9 | 2.4% / 2.0% / 0.9% |
| Qwen3.5-2B, untuned | 2B | 73.8 | 66.9 | 81.2 | 74.0 | 3.7% / 2.0% / 0.0% |
| Qwen3.5-4B, untuned | 4B | 83.6 | 67.4 | 88.4 | 79.8 | 2.1% / 4.0% / 0.6% |
| Qwen3.5-9B, untuned | 9B | 79.8 | 69.6 | 91.2 | 80.2 | 4.3% / 3.8% / 0.6% |
| Gemma 4 E2B, untuned | 2B eff. | 65.5 | 65.5 | 94.1 | 75.0 | 8.6% / 9.2% / 0.3% |
| Gemma 4 E4B, untuned | 4B eff. | 74.4 | 79.0 | 95.1 | 82.8 | 7.0% / 3.8% / 0.6% |
| LanguageTool 6.6 (rules, default settings) | — | 24.1 | 52.8 | 74.1 | 50.4 | 39.0% / 25.1% / 11.1% |
| Frontier LLM 1 (proprietary, upper bound) | — | 98.0 | 91.8 | 98.2 | 96.0 | 0.2% / 1.1% / 0.0% |
| Frontier LLM 2 (proprietary, upper bound) | — | 98.7 | 92.3 | 98.4 | 96.5 | 0.2% / 1.8% / 0.0% |
Sizes: parameter counts; Gemma 4 E2B and E4B at their effective size (their files are larger).
Every LLM reference (the untuned open models and the two frontier LLMs) got the same instructions:
revisa's system prompt plus the benchmark criterion (sections 1–3 of
criterion.md: what to correct and what to leave alone), with
no examples. The open models ran with greedy decoding, quantized to Q4_K_M, through llama.cpp;
revisa-0.8b gets only its short system prompt.
Engine time per sentence on a desktop CPU with 8 threads, no GPU (Q4_K_M; model load excluded; a fixed sample of development cases of parts A and C, not the test):
| Decoding | p50 (median) | p95 |
|---|---|---|
| Greedy | 304.5 ms | 823.6 ms |
| Input-guided speculative (the app's default) | 138.2 ms | 321.7 ms |
A corrected sentence is mostly a copy of the input, so the revisa engine uses the input sentence itself as the draft and verifies it with the model in batches: a correct sentence is checked in one pass instead of being generated token by token. That makes it 2.2× faster at the median, below the 200 ms target, and it does not change the result: 99.4% of outputs are identical to greedy decoding (the rest are near-ties). This speed-up is part of the revisa engine; a plain llama.cpp server decodes greedily.
The revisa app builds the prompt itself; none of this is needed to use it. To call the model from your own code, follow this prompt format exactly (it is the only one the model was trained on). Reasoning is always off. Remember that the raw model only rewrites sentences: the edit list, the error types, the explanations and the guards live in the revisa app, not in the model.
The Qwen3.5 chat template with thinking disabled
(apply_chat_template(..., add_generation_prompt=True, enable_thinking=False)), with two turns
and no examples.
System prompt (exactly this text, in Spanish):
Corrige los errores de ortografía y gramática del texto según la norma del español. No cambies el estilo, el vocabulario ni el registro. Si el texto es correcto, devuélvelo igual. Responde solo con el texto.
("Correct the spelling and grammar errors of the text according to the Spanish norm. Do not change the style, the vocabulary or the register. If the text is correct, return it unchanged. Reply only with the text.")
User turn: one sentence (or a short segment), as is: trimmed, NFC-normalized, at most about 400 characters, with no quotes, labels or context. Split longer text into sentences first, and keep URLs, email addresses and code out of it.
Full prompt string (line breaks only for readability; \n are real newlines):
<|im_start|>system\n{system}<|im_end|>\n<|im_start|>user\n{sentence}<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n
Tokenize with special tokens parsed and without BOS.
Answer: the corrected sentence in plain text, then <|im_end|>, where generation stops. A
correct sentence comes back identical. Decode greedily, with a cap of
ceil(1.5 × input tokens) + 8 new tokens; if the cap is reached, discard the output and keep the
sentence as it was.
| Input | Output of revisa-0.8b |
|---|---|
Ya e echo el informe y creo de que te gustará. |
Ya he hecho el informe y creo que te gustará. |
Ayer no fuistes a la reunión y hubieron muchos problemas. |
Ayer no fuiste a la reunión y hubo muchos problemas. |
Los resultados de la encuesta son muy positivo. |
Los resultados de la encuesta son muy positivos. |
llama-server -m revisa-0.8b-Q4_K_M.gguf -ngl 0 --reasoning off -c 2048 --port 8080
-ngl 0 keeps everything on the CPU (a 0.8B model gains little from a GPU at one sentence at a
time); --reasoning off sets enable_thinking=false for the chat API.
Raw prompt with /completion (recommended: you control the exact string):
import json, urllib.request
SYSTEM = (
"Corrige los errores de ortografía y gramática del texto según la norma del español. "
"No cambies el estilo, el vocabulario ni el registro. Si el texto es correcto, "
"devuélvelo igual. Responde solo con el texto."
)
sentence = "Ya e echo el informe y creo de que te gustará."
prompt = (
f"<|im_start|>system\n{SYSTEM}<|im_end|>\n"
f"<|im_start|>user\n{sentence}<|im_end|>\n"
"<|im_start|>assistant\n<think>\n\n</think>\n\n"
)
# The app caps new tokens at ceil(1.5 × input tokens) + 8 and discards the output if the cap is hit.
body = {"prompt": prompt, "n_predict": 128, "temperature": 0, "top_k": 1,
"stop": ["<|im_end|>"]}
req = urllib.request.Request("http://127.0.0.1:8080/completion",
data=json.dumps(body).encode(),
headers={"Content-Type": "application/json"})
print(json.load(urllib.request.urlopen(req))["content"])
# Ya he hecho el informe y creo que te gustará.
Chat API with /v1/chat/completions (the server applies the chat template stored in the GGUF):
curl -s http://127.0.0.1:8080/v1/chat/completions -H 'Content-Type: application/json' -d '{"messages": [{"role": "system", "content": "Corrige los errores de ortografía y gramática del texto según la norma del español. No cambies el estilo, el vocabulario ni el registro. Si el texto es correcto, devuélvelo igual. Responde solo con el texto."}, {"role": "user", "content": "Ayer no fuistes a la reunión y hubieron muchos problemas."}], "chat_template_kwargs": {"enable_thinking": false}, "temperature": 0, "max_tokens": 128}'
Keep thinking disabled (--reasoning off on the server or enable_thinking: false in the
request): with thinking on, the prompt ends with an open <think> block, which the model was never
trained on.
| File | Quantization | Size (bytes) | SHA-256 |
|---|---|---|---|
revisa-0.8b-Q4_K_M.gguf |
Q4_K_M, with an importance matrix | 529 297 888 | 7ee833111c7574aa5b37eed9b292ab21c539b203d687250f8e8deee0cba9127b |
sha256sum revisa-0.8b-Q4_K_M.gguf
# 7ee833111c7574aa5b37eed9b292ab21c539b203d687250f8e8deee0cba9127b revisa-0.8b-Q4_K_M.gguf
The GGUF carries general.* metadata (name, version, license, base model, language). Its tensors
are byte-identical to the file evaluated on the benchmark; only that metadata differs.
| Base | Qwen/Qwen3.5-0.8B (revision 2fc06364715b967f1860aea9cf38778875588b17) |
| Method | Full fine-tune of all weights (no LoRA), supervised, loss on the answer only |
| Data | 40 000 training cases (48 474 sentence-level examples) and 1 000 validation cases with the same mix |
| Hyperparameters | lr 1e-5 (cosine, 3% warmup), effective batch 32, 2 epochs, max sequence length 384, fp32 master weights with bf16 autocast, 8-bit AdamW, seed 3407 |
| Export | GGUF, then Q4_K_M with an importance matrix computed on a sample of the training data (never the test) |
Data. Every example is a pair (text with errors, or correct text → corrected text) in the prompt format above, and about a third are correct sentences that must come back unchanged (the main lever against false alarms).
manuelgscom/revisa-bench-es (CC BY-SA 4.0), frozen with a SHA-256 before any
system was scored. Parts A and B come from Wikipedia revisions made after a cutoff date
(2026-03-01), from pages kept out of the training data; part C was written for the benchmark from
fixed slots (register, length, number and type of errors) and is disjoint from the training
slots. Each A and B case carries its attribution (page, revision id, date, URL).score.py, which reproduces the scores exactly.The model is released under Apache-2.0, the license of the base model
Qwen3.5-0.8B. The benchmark manuelgscom/revisa-bench-es is CC BY-SA 4.0. The revisa app is
open source (GitHub).
Made by Manuel García Sanz · https://manuelgs.com/en/ · revisa on GitHub · collection
Qwen/Qwen3.5-0.8B