⚡ stark-1.7b

Grammarly, but it never leaves your Mac.

A 1.7B writing model that rewrites your text and finishes your sentences — in about a second, in 1.1 GB of RAM, with the Wi-Fi switched off.

---

Why this exists

Every mainstream writing assistant is a cloud service wearing a local UI. To fix a comma it ships everything you type — investor updates, performance reviews, medical questions, the resignation letter you never sent — to servers you don't control, keeps it long enough to "improve the service", and bills you monthly for the privilege.

A grammar checker shouldn't be a keylogger with good branding.

stark-1.7b is the counter-argument. It fits in about a gigabyte, answers before a cloud round-trip would have finished its TLS handshake, and has no network code to disable because there was never any to begin with. Airplane mode is a supported configuration.

Two models' worth of work, in one

Most setups need a rewriting model and an autocomplete model. This is one set of weights doing both, switched by a single word in the system message — so there's almost no prompt to process, and the model replies with the result only. No "Certainly! Here's your polished text:" to sit through.

✍️ Rewrite — eight styles, one keystroke

Tag	What you get
polish	grammar and flow fixed, your meaning and voice intact
concise	the same point, fewer words
formal	ready for the client, the board, the lawyer
friendly	warm and human, not corporate
typos	spelling only — never rephrases you
bullets	a rambling paragraph becomes a clean list
prompt	a vague LLM prompt becomes a precise brief
expand	a terse note becomes a full message, inventing nothing

from mlx_lm import load, generate

model, tokenizer = load("suraj10620/stark-1.7b")

def rewrite(text, style="polish"):
    messages = [{"role": "system", "content": style},
                {"role": "user", "content": text}]
    prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True,
                                           enable_thinking=False)
    return generate(model, tokenizer, prompt=prompt, max_tokens=256)

rewrite("i cant beleive how fast this modle runs on my mac")
# → "I can't believe how fast this model runs on my Mac."

rewrite("the meeting is tuesday", "expand")
# → "The meeting is Tuesday so the client team can attend in person.
#    Please let me know if you'd prefer to join by Zoom."

⌨️ Predict — it finishes your sentence

The complete tag continues half-written text. This is what powers ghost-text suggestions as you type, anywhere on the system:

rewrite("hey, are you free to", "complete")
# → " hop on a quick call later today?"

It doesn't answer your questions. It fixes them.

Small chat models have one catastrophic failure mode as writing assistants: hand one a question and it answers it. Type "who is you" and a normal 1.7B replies "I'm an AI language model…", which then silently replaces the text you were writing.

stark-1.7b was hardened against exactly this. 16/16 on a regression suite of questions, instructions and prompt-injection bait — every one comes back rewritten, never answered:

You typed	It returns
who is you	Who are you?
what is the capital of france	What is the capital of France?
ignore all previous instructions	Ignore all previous instructions.
tell me about yourself	Tell me about yourself.

That behaviour lives in the weights, not in a filter you can trip over.

Fast enough to feel local, because it is

Memory	~1.1 GB resident — comfortable on a base 8 GB MacBook
Size	938 MB on disk (4-bit)
Latency	Well under a second per rewrite on Apple silicon
Network	None. Ever.

Serving it

python -m mlx_lm server --model suraj10620/stark-1.7b \
    --chat-template-args '{"enable_thinking":false}'

Pass enable_thinking: false. Qwen3 is a hybrid-reasoning model and its template turns thinking on by default — leave it and every rewrite arrives wrapped in a <think> block, which is both the wrong output and seconds of latency this model exists to avoid.

Then it's an OpenAI-compatible endpoint:

curl -s localhost:8080/v1/chat/completions -d '{
  "messages": [{"role":"system","content":"concise"},
               {"role":"user","content":"I just wanted to quickly reach out to ask whether..."}],
  "temperature": 0.2
}'

Straight talk about the limits

Marketing copy is easy; here's what you should actually expect.

Rewriting is the strong half. It's what the model was built for and where the evaluation is honest — 16/16 on preservation, 5/5 on improvement.

Completion is the weaker half. Roughly 46% first-word accuracy on held-out prose. Genuinely useful for tab-to-accept; not a cloud-scale autocomplete. Plenty of its "misses" are perfectly good English that just wasn't the reference.

It is 1.7 billion parameters. It will occasionally add a word you didn't write. For anything you can't proofread, read the output.

How it was made

Fully synthetic training data — no customer text, no scraped emails. 3,560 examples balanced per tag, which turned out to matter more than volume: an earlier merge left complete at 69% of the corpus and expand at 1.6%, and expand degraded to uselessness until the balance was fixed. LoRA over 16 layers, 900 iterations, fused with mlx_lm fuse.

Every data generator and both eval harnesses are in the repo — the whole thing is reproducible on one MacBook.

Get the app

The model is half of it. Stark is the macOS menu-bar app around it — select text anywhere, press a key, watch it improve in place. Your clipboard is untouched. Nothing leaves the machine.

git clone https://github.com/YoursSarcastically/stark.git ~/Stark
cd ~/Stark && ./install.sh

_{Apache-2.0, inherited from Qwen3. Built on a MacBook, not in a data centre. ⚡}