A code editor that teaches · not an autocomplete
Learn a new language by building
the thing you actually want to build.
Midnight Oil is an editor with a teacher built in. You open your real project and write the code yourself — and it withholds the answer, bridging from a language you already know to the one you're learning, running your tests, and correcting you when you're wrong.
Cursor makes you a faster typist who learns nothing. Boot.dev teaches toy problems. This is the unoccupied middle.
The unoccupied middle
Every tool picks a side. Both sides fail the experienced dev.
Cursor & Copilot
Write the code for you. You ship faster and learn nothing — you become a faster typist, not a Rust developer.
Boot.dev & Exercism
Actually teach — but on toy problems you don't care about. The motivation and the real-world mess are missing.
Build the real thing
You build the project you actually want, in an editor that bridges from what you already know — and makes you do the work.
Transfer-teaching
It teaches you from the language you already speak.
You already know what you want to express — you just don't know how this language says it. Midnight Oil anchors every new concept to its equivalent in your source language, names the shared shape, then the divergence.
“In Java you'd reach fortry/catchhere. Rust doesn't have exceptions — it hasResult<T, E>. Same goal, different shape. You write the signature that returns one.”
JS → Go · Java → Rust · PHP → Elixir · or no source at all
The source→target bridge in the Tutor dock
Capture the Tutor dock showing a bridge pill (e.g. PHP → Rust) above a teaching message that explicitly references the source-language equivalent. Pick a moment where the analogy text is visible.
The signature feature
The assist-dial: turn down the help, turn up the learning.
One control in the status bar changes not just how much the tool helps, but what surface the help appears on. It only changes what's revealed — never who writes the code. It's concept-local: high-assist on the borrow checker while it's alien, low-assist on structs you already own.
Full idiomatic code
A copy-pasteable block. Only for boilerplate you already understand — don't re-learn the 3000th void return.
Cloze code block
Scaffolding filled in, the new-language idioms blanked out for you to complete. The heart of the tool.
A nudge
“Something here won't compile the way you think — want a hint?” You must engage to get more. Maximal retention.
Pure reviewer
Write freely; the tool critiques after. For when you just want to build and be spot-checked.
The cloze principle
Fill in what you know, blank out what you don't. For a transfer-learner the easy parts are whatever's the same as your old language; the hard parts are the new idioms — exactly what you're here to learn. So we blank the idiom and hand you the scaffolding. As your mastery rises, the blanks move to your new frontier.
A Medium-level cloze block
Capture the editor + Tutor dock with the assist-dial set to Medium: filled-in scaffolding plus one or two highlighted blanks (the cyan slots), and the status-bar dial showing Medium active.
The interface
An editor you build in. A teacher in the dock.
Midnight Oil is a full code editor — file tree, tabs, breadcrumb, command palette — built on CodeMirror and themed terminal-dark. You open your project and write in it. The teaching lives in a dockable Tutor panel beside your code; the assist-dial sits in the status bar.
The full editor window with the Tutor dock open
The hero shot. Capture the whole app window: activity bar + sidebar (Plan milestones over the Explorer file tree with git tags), a couple of open tabs (one with a dirty dot), the CodeMirror editor with a cloze block, the Tutor dock docked right showing the current lesson, and the status bar with the assist-dial + cargo state. Use the dark theme; fill every panel with realistic content.
File tree with git tags, tabs, breadcrumb, command palette (⌘K), fuzzy finder (Ctrl-P).
A dockable panel — right, bottom, or top — rendering the live lesson: bridge, cloze, hint, review.
In the status bar. Change how much is revealed without ever leaving your code.
Select anything and hit ⌘⇧E for an LSP-grounded explanation with citations.
Verification — status bar + Tutor review
Capture the moment compiler truth and idiom feedback land together: the status bar showing cargo state (✓ / ✖) with error/warning counts, and the Tutor dock showing a post-attempt review with an amber IDIOM callout (e.g. 'prefer is_empty()').
Hybrid verification
The compiler is a co-teacher.
Two signals feed every teaching turn. Deterministic ground truth from the tests and the compiler — the Rust borrow checker is a teacher — and an AI idiom-pass that catches working-but-unidiomatic code.
- PASS Did it compile? Did the test go green? Hard ground truth.
- IDIOM “It compiles, but you wrote it the Java way — here's the idiomatic Rust.”
- FAIL Compiler errors surfaced as lessons, reframed in transfer terms.
How a session works
Three ways in. One loop.
Plan-first
“Teach me Rust by building a CLI todo app.” It drafts teachable milestones; you execute them one at a time.
Bring your own project
Open an existing repo. It finds teachable moments as you work — no curriculum required.
Goal-first
“Teach me X by building Y.” It scaffolds a path from your stated goal to a real, working thing.
Stop autocompleting. Start owning the language.
For the side project, the deliberate upskill, the between-jobs study — the times you'd rather actually learn it.