DEV Community: Dzmitry Salavei

I stopped "studying" and started learning passively. Here's the app I built for it

Dzmitry Salavei — Thu, 04 Jun 2026 16:28:44 +0000

The study session problem

Most learning apps assume you'll sit down and study. Open the app, start a session, do your reps. It works - if you actually do it.

I never did it consistently. Not with Anki, not with Duolingo, not with flashcard sets I spent hours building. The habit kept breaking because it required a dedicated moment that kept not happening.

So I built something different.

Cards that come to you

LazyWords runs silently in the background and shows a small flashcard overlay on top of whatever you're doing - your browser, your editor, a spreadsheet, a video call. A card appears every few minutes, stays for a few seconds, then disappears.

You don't open it. You don't start a session. You just work, and the cards show up.

Think of it like background music. You're not focusing on it, but after a few weeks of it playing, you know all the words.

It's not just for language learning

LazyWords ships with English→Russian vocabulary and English definitions, but the real power is the import feature. Any CSV file with two columns works:

Medical students:

term,definition
Tachycardia,Heart rate exceeding 100 beats per minute
Dyspnea,Difficulty or labored breathing
Edema,Swelling caused by excess fluid in body tissues

Law students or paralegals:

term,definition
Tort,A civil wrong that causes harm or loss
Habeas corpus,Legal action requiring a person to be brought before a court
Injunction,Court order requiring a party to do or stop doing something

Developers learning a new stack:

term,definition
Idempotent,Operation that produces the same result no matter how many times it's applied
Race condition,Bug occurring when output depends on timing of uncontrollable events
Deadlock,Two processes each waiting for the other to release a resource

Preparing for a certification exam:

term,definition
VLAN,Virtual Local Area Network - logical grouping of devices on a network
NAT,Network Address Translation - maps private IPs to a public IP

Anything you need to absorb gradually - just make a CSV and import it.

How it fits into a real day

You open your laptop, LazyWords starts automatically. You work. Every few minutes a card appears in the corner of your screen - you glance at it, it's gone. After a few weeks you start noticing the words feel familiar. You didn't study. You just worked.

If a word sticks - press Ctrl+Shift+K to mark it as known. LazyWords stops showing it and moves on. That's the only interaction required.

What it doesn't do

No spaced repetition algorithm. No streaks to maintain. No guilt when you miss a day - because there's nothing to miss. It either runs or it doesn't.

This is a feature, not a limitation. The goal is zero friction, not optimal learning curves.

Try it

Free, Windows, no account required.

Download on GitHub · Microsoft Store

If you import it for something unusual - medical terms, legal vocab, a language that isn't English - I'd love to hear how it works for you.

I rewrote my Electron app in Tauri and cut the installer from 120MB to 8MB — here's what actually broke

Dzmitry Salavei — Sun, 31 May 2026 22:29:24 +0000

The problem with Electron

I built the first version of LazyWords in Electron. It worked. It also shipped a 120MB installer for an app whose entire job is showing a small floating flashcard every few minutes.

That felt wrong. So I rewrote it in Tauri v2.

Final result: 8MB installer, same functionality, noticeably less RAM. But the migration wasn't smooth — here's what actually bit me.

What is LazyWords

Before the technical stuff: LazyWords is a passive vocabulary app for Windows. It runs in the system tray and shows word flashcards as an always-on-top overlay over whatever you're working on. Cards appear every few minutes, stay a few seconds, disappear. No interaction required.

The idea was "radio for vocabulary" — you don't focus on it, but it's there, and things stick over time.

What broke during migration

1. Global shortcuts behaved differently

Electron's globalShortcut and Tauri's plugin handle edge cases differently. My main issue was Ctrl+Shift+N — show next card immediately. In the Electron version this was straightforward. In Tauri I needed the shortcut to both show a card and reset the timer interval, without triggering a double card.

The fix was a manual_trigger Tokio Notify in the timer loop:

tokio::select! {
    _ = tokio::time::sleep(Duration::from_secs(1)) => {}
    _ = manual_trigger.notified() => { break; }
}

When the shortcut fires, it notifies the trigger, the timer resets its interval. Clean, no double card.

2. Always-on-top + fullscreen detection

Getting a transparent frameless window that floats over normal apps but disappears during actual fullscreen (games, video players, presentations) had no built-in Tauri solution. I ended up calling winapi directly:

unsafe {
    let hwnd = GetForegroundWindow();
    let mut monitor_info: MONITORINFO = std::mem::zeroed();
    monitor_info.cbSize = std::mem::size_of::<MONITORINFO>() as u32;
    let monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
    GetMonitorInfoW(monitor, &mut monitor_info);
    // compare window rect to monitor rect
}

Not pretty, but it works reliably.

3. Settings window deadlock on first open

If you create the settings window on demand (on Ctrl+Shift+W), there's a subtle deadlock risk on the first call when AppState is involved. The fix was to pre-create the settings window hidden at startup:

// At startup — create hidden, never destroy
settings_window.hide()?;

// On shortcut — just show it
settings_window.show()?;
settings_window.set_focus()?;

Also intercepting CloseRequested with prevent_close() + hide() so the window is never destroyed — just hidden. This also fixed the window only being openable once.

4. Single-instance lock

Electron has this built in. In Tauri on Windows I handled it manually with a named mutex:

let mutex_name = windows::core::w!("LazyWords_SingleInstanceMutex");
let mutex = CreateMutexW(None, true, mutex_name)?;
if GetLastError() == ERROR_ALREADY_EXISTS {
    return Ok(());
}

Second launch exits immediately, first instance continues normally.

What worked better than expected

Multi-monitor positioning. Tauri's cursor_position() + available_monitors() just worked. The card always appears on whichever monitor the cursor is on, no hacks needed.

The async timer loop. Tokio's select! macro made the timer logic genuinely elegant — sleeping on interval OR manual trigger, whichever comes first. This would have been messier in Electron.

Bundle size. 8MB vs 120MB speaks for itself. Tauri uses the system WebView (WebView2 on Windows) instead of bundling Chromium.

The AI-assisted workflow

One more thing worth mentioning: this app was built almost entirely with Claude.

The workflow that worked for me:

Describe a feature or bug to Claude in chat
Claude produces a Markdown task spec — what to implement, edge cases, approach
Paste the spec into Claude Code in VS Code terminal
Claude Code implements it
Test, report results, iterate

The key insight: Claude chat is good at architecture and tradeoffs. Claude Code is good at executing a well-scoped task. Separating the two produced much better results than asking Claude Code to also design the solution.

I also keep a CLAUDE.md in the repo root that Claude Code reads at the start of every session — current architecture, known bugs, version history. Without it, context resets every session.

Result

	Before (Electron)	After (Tauri v2)
Installer size	~120MB	~8MB
RAM idle	~200MB	~30MB
Unit tests	0	27

Live on Microsoft Store and GitHub.

Repo: github.com/DemonazGH/LazyWords-Tauri

Happy to answer questions about any of the Tauri-specific solutions above.