Netuoso/qwepus-dataset

Hand-written engineering conversations. Real problems, real constraints, code that builds.

Model · What's new in v1.5 · What's inside · Format · What's next

---

About

This is v1.5 of the dataset behind Qwepus. Same 96 conversations as v1, and now every one of them comes with an engineering rationale, the thinking behind the answer: what is really broken, which tradeoffs matter, and how to check the result.

It's small on purpose. Every conversation was written by hand, one at a time. Each one starts with a problem someone would actually bring to a senior engineer: a queue that drops messages under load, a flash sale that oversells, a regex that takes down production. The answer does what a good engineer does. It finds what's really broken, explains why the obvious fix won't work, writes the code, and shows how to check it.

No templates. No twenty variations of the same task. No "write a function that reverses a string".

The code compiles. All of it.

This is the rule we care about most. Before a conversation gets in, every code block is pulled out and run through the real toolchain: gcc and g++, rustc, go vet, tsc, node, pyflakes, a PostgreSQL parser for SQL, clang for eBPF, bash -n for scripts. If it doesn't build, it doesn't ship.

The only exceptions are a few short snippets quoted in the middle of an explanation (tagged ,ignore) and Unreal Engine code, which needs the engine's headers to build.

One more thing: the answers don't fake results. There are no made-up benchmark tables and no "all 12 tests passed" logs. Tests and benchmarks come as code plus the command to run them, and the answer explains what each test checks. We want the model to hand you a way to verify, not to claim it already did.

What's new in v1.5

v1.5 adds reasoning. The conversations, prompts and final answers are the same as in v1; nothing in them was rewritten.

• Reasoning for all 96 conversations. Each assistant answer now has a reasoning_content field with a hand-written engineering rationale, about 2.5k characters on average (~240k in total). It covers the invariants that matter, the design tradeoffs, the failure modes, how to verify the solution, and where the answer falls short.
• Honest about the answers. The rationales don't just justify the answer. Where an answer has a limitation (say, a queue bound that doesn't bound an out-of-order completion heap), the rationale says so.
• Ready for thinking models. dataset.jsonl keeps reasoning in a separate field. If your model expects a <think>...</think> prefix instead, it takes a few lines to convert; see Choosing an export for training.

What's inside

Conversations	96
Format	Chat-style JSONL: system, user, assistant; optional reasoning_content
Reasoning annotations	96 of 96, ~2.5k characters each
Average answer	~28k characters (reasoning not included)
Size	~3.1 MB
Language	English

12 conversations per language: C · C++ · Rust · Go · Python · TypeScript · SQL (PostgreSQL) · HTML + JS (Three.js)

Area	For example
Systems	lock-free queues, memory ordering, SIMD, custom allocators, unsafe Rust and FFI, C++20 coroutines
OS and runtimes	io_uring, epoll, eBPF, mmap and the page cache, Go GC tuning, the CPython C API
Reliability	data races, graceful shutdown, cancellation, retries and circuit breakers
Databases	isolation anomalies, query plans, WAL and LSM trees, online migrations, partitioning
Distributed systems	Raft, CRDTs, hybrid logical clocks, consistent hashing, rate limiting, the outbox pattern
Algorithms	segment trees, max flow, robust geometry, Aho–Corasick, numerical stability
Compilers	Pratt parsing, bytecode VMs, regex engines, SSA and SCCP, type-level TypeScript
Games and graphics	UE5 GAS, ECS, rollback netcode, interactive Three.js scenes
Security	constant-time code, JWT pitfalls, seccomp and Landlock sandboxing, row-level security
Reverse engineering	decompiler output to source, binary format recovery, paper pseudocode to code

Format

One conversation per line:

{"messages": [
  {"role": "system", "content": "You are Qwepus, an elite software architect and systems engineer. ..."},
  {"role": "user", "content": "I'm writing an audio engine in Rust. The real-time thread ..."},
  {"role": "assistant", "content": "## Model\n\n...\n\n```rust\n...", "reasoning_content": "The real-time requirement applies to the entire callback..."}
]}

All conversations share one system prompt. Answers are Markdown with fenced code blocks, and source files are named with title="...".

content is the final answer. The optional reasoning_content on the same assistant message holds an engineering rationale; it is not another conversation turn. Examples without reasoning omit the field entirely. The original user prompts and final answers are preserved.

Examples 001-096 have newly authored synthetic rationales: invariants, design tradeoffs, failure modes, validation plans, and limits of the proposed solutions. These are explanatory training annotations, not captured private model traces. They also call out limitations in the existing answers (for example, queue bounds do not bound an out-of-order completion heap); adding an annotation does not fix or certify the answer's code. No test or benchmark result is invented in the annotations.

Loading

from datasets import load_dataset

ds = load_dataset("Netuoso/qwepus-dataset", split="train")
print(ds[0]["messages"][1]["content"][:500])
print(ds[0]["messages"][2].get("reasoning_content") or "")

Choosing an export for training

dataset.jsonl uses the separate field. This keeps rationale and answer independently accessible, but reasoning_content is a dataset convention, not a universally supported chat/API field. A trainer or chat template that only reads content will silently omit the rationale unless adapted.

For a model that expects a textual thinking prefix, put the rationale in front of the answer:

def to_think(record):
    for message in record["messages"]:
        reasoning = message.pop("reasoning_content", None)
        if message["role"] == "assistant" and reasoning:
            message["content"] = f"<think>\n{reasoning}\n</think>\n\n{message['content']}"
    return record

ds = ds.map(to_think)

A reasoned assistant message then has only role and content:

{"role": "assistant", "content": "<think>\nThe engineering rationale.\n</think>\n\nThe final answer."}

Answer-only examples stay unchanged; no empty thinking blocks are inserted.

These tags are text delimiters, not HTML rendering instructions or a guarantee of special tokenizer tokens. Choose the representation expected by the target model's chat template, inspect a rendered training sample, and confirm that loss masking includes the rationale when intended. Avoid adding a second thinking wrapper in the trainer. Hugging Face loaders may represent absent nested fields as None, so consumers should use assistant.get("reasoning_content") or "".

Keep in mind

• The reasoning is written after the fact to explain the answer. It is a synthetic rationale, not a recorded model trace, and it's much shorter than the answers.
• 96 conversations is not a lot. The dataset teaches how to approach a problem, not every problem there is.
• Answers are long, some over 100k characters. Train with a long context or they'll get cut off.
• Compiling isn't the same as being correct. Every answer comes with tests, but tests can be wrong too.

What's next

This is v1.5, and it's far from finished. We'll keep working on it for a long time: more conversations, new areas, harder problems, and another pass over what's already here. Expect it to grow and change from version to version.

Found a mistake in an answer? Open a discussion. That helps more than you'd think.