Quip | Devpost

architecture
sample edit
benchmark

Inspiration

Generic writing tools fix grammar. They do not understand that your shorthands & habits, your teammate's name, or the paragraph open beside your draft may change what you meant.

Quip is our attempt at the next step: a Mac writing util backed by a local model that learns from the corrections you accept and uses nearby context.

What it does

Select Quip Native as a Mac input source and type normally in a real text field.
Quip reads a bounded typing burst plus optional local context, then asks a local model for up to five suggestions.
The candidate bar appears near the caret; accepting replaces only the tracked burst.
Accepted and dismissed suggestions become local learning signals for personal shorthand and future per-user adapters.

How we made it

We replaced the fragile Accessibility-first typing path with a Swift InputMethodKit source. Quip Native passes literal typing through, tracks the verified UTF-16 range and caret, and only applies a replacement after explicit selection.

The app itself is Tauri with a Rust composition engine. A loopback bridge connects the input method to the engine, and a persistent Rust sidecar calls local MLX model servers running Qwen3.5-2B plus the Freesolo-trained Global LoRA adapter.

For the model, we trained Quip-specific adapters with Freesolo Flash instead of relying on a generic base model. The training data teaches the model the behavior Quip needs: expand shorthand, fix messy typing, use context when it helps, and leave the user's text alone when there is nothing useful to change.

Challenges we ran into

macOS app coverage was the wall. Accessibility could inspect some fields, but not reliably enough across modern apps. We switched the main live-typing path to InputMethodKit and kept Accessibility for bounded window context and existing-text fallback.
The model had to be useful without being pushy. We made every completion return one full-text JSON suggestion, then filtered exact matches and ranked deduplicated candidates instead of auto-editing text.
Local inference had to be demoable. We moved to MLX loopback model servers, added health checks and latency tooling, and kept fixture mode as a fallback when model artifacts or startup time are risky.
Personalization can become creepy or noisy. Quip records accepted corrections and stable dismissals as compact local examples; it does not treat every keystroke as a training label.

Accomplishments that we're proud of

We built a real macOS input-method path instead of faking typing inside a web demo.
We trained and evaluated Freesolo LoRA adapters instead of wrapping a generic cloud autocomplete API.
We made the model contract strict: five schema-valid completions, exact-match filtering, deduplication, vote ranking, and explicit user selection.
We connected the product story end to end: local typing, local inference, bounded context, learning signals, and a credible per-user adapter path.

What we learned

On macOS, "works while typing" is an input-method problem, not just an Accessibility problem.
Correction quality is not only about fixing more text. A good writing model also needs to know when to leave the user's words alone.
Personalization is strongest when it comes from confirmed user choices, not passive scraping.

What's next for Quip

Harden Quip Native across TextEdit, Notes, Chrome, Safari, and common browser fields.
Finish the per-user adapter loop: package confirmed local examples, train a private Freesolo profile adapter, and load it next to the global adapter.
Improve local latency with more caching, better model warmup, and tighter prompt construction.
Polish installation so Quip feels like a normal Mac input source, not a hackathon setup script.