I didn't want to pay for expensive vocabulary apps that often start with beginner words while I am looking for advanced vocabulary, so I built it myself.

My partner and I do something similar for Korean & English (she’s Korean native and is fluent in English and I’m learning Korean). We actually built it out for ourselves and some friends and just released it yesterday[0].

Still working out some kinks, but it sends a question every weekday via email that you’d respond to. It then sends back feedback on vocab & grammar, all with spaced repetition baked in to keep track of words you learn/use as you continue.

It’s currently tailored towards those that can already read and have basics under their belt.

[0] https://dailytokki.com/?ref=hn

So going by the screenshot in the readme where you have vaststellen; https://hetnederlands.com/dictionary/vaststellen

The things you can do with language learning and LLMs is just incredible :)

I already spend all my time in the inbox and find it hard to ignore an email. Inbox zero habits would kick in and ensure that I do at least some memorization every day. A single Anki card in my inbox is far less daunting than the entire deck staring at me when I open the app.

Unfortunately Anki doesn't have a proper API and isn't easy to reverse engineer. I tried to build something using a scraper that logs in to the Anki web app, but it turned out to be very janky, and couldn't identify overdue cards. Somebody with better desktop app/python skills could probably do it locally, but I gave up.

The second one, I'd say either bepalen/beslissen (if you want to make a decision) or uitvinden ("out-finding", find out). The word from the screenshot, vaststellen (literally: "fixed setting", think of it as fixating), is still in common enough use, particularly in formal writing, but more of a word for "good to know" than to use in active vocabulary

No comments on the third one :) That's idiomatic use (though I'd have thought of, just like in English, "not falling over" as opposed to "work-life balance" as the defining meaning of the word)

The readme says the examples are generated using ChatGPT. Why not use an existing dataset instead of generating mediocre examples with lots of energy? Similar to what YouGlish(.com) does, you could get a lot of sentences spoken by native speakers from YouTube transcripts for example, or Wikipedia for written language, or other sources costing virtually no energy at all to find a word in and being better as well

I suppose a bank of words on a .CSV, a script which selects words, and a job triggered via a ChronJob which opens an issue does the trick. I had it so when an issue is opened, I got emailed.

The pro of this approach is you don’t have to deploy any infra. The con is that your emails never look as nice as you got it :’)

If I may ask you, how do you plan on building vocabulary from these e-mails? Do you use anki or some other method?

Seems a bit complex though, compared to doing a shell script showing a notification or sending yourself an email each morning when you open it?

Or just doing a light script on val.town?

For instance this could be an example val.town script that does something similar (just need to bind to a data source for the dictionary)

    import { sqlite } from "https://esm.town/v/stevekrouse/sqlite";
    import { OpenAI } from "https://esm.town/v/std/openai";
    import { email } from "https://esm.town/v/std/email";
    
    // Dutch words database
    const dutchWords = [
      { word: "boek", translation: "book" },
      { word: "huis", translation: "house" },
      { word: "boom", translation: "tree" },
      { word: "water", translation: "water" },
      { word: "kat", translation: "cat" },
      { word: "hond", translation: "dog" },
      { word: "appel", translation: "apple" },
      { word: "tafel", translation: "table" },
      { word: "school", translation: "school" },
      { word: "fiets", translation: "bicycle" }
    ];
    
    export default async function generateDutchWordLearning() {
      const KEY = new URL(import.meta.url).pathname.split("/").at(-1);
      const openai = new OpenAI();
    
      // Ensure SQLite table exists
      await sqlite.execute(`
        CREATE TABLE IF NOT EXISTS ${KEY}_dutch_words (
          word TEXT PRIMARY KEY,
          translation TEXT,
          example TEXT,
          timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
        )
      `);
    
      // Fetch words not previously used
      const usedWords = await sqlite.execute(`
        SELECT word FROM ${KEY}_dutch_words
      `);
    
      const availableWords = dutchWords.filter(
        w => !usedWords.rows.some(row => row.word === w.word)
      );
    
      if (availableWords.length < 3) {
        // Reset if we've used all words
        await sqlite.execute(`DELETE FROM ${KEY}_dutch_words`);
        availableWords = dutchWords;
      }
    
      // Randomly select 3 unique words
      const selectedWords = [];
      for (let i = 0; i < 3; i++) {
        const randomIndex = Math.floor(Math.random() * availableWords.length);
        selectedWords.push(availableWords.splice(randomIndex, 1)[0]);
      }
    
      // Generate example sentences with ChatGPT
      const wordDetails = await Promise.all(selectedWords.map(async (wordObj) => {
        const exampleResponse = await openai.chat.completions.create({
          model: "gpt-4o-mini",
          messages: [{
            role: "user", 
            content: `Geef een voorbeeld zin met het woord "${wordObj.word}" in het Nederlands.`
          }]
        });
    
        const example = exampleResponse.choices[0].message.content || "Geen voorbeeld gevonden";
    
        // Store in database
        await sqlite.execute(`
          INSERT INTO ${KEY}_dutch_words (word, translation, example) 
          VALUES (?, ?, ?)
        `, [wordObj.word, wordObj.translation, example]);
    
        return { ...wordObj, example };
      }));
    
      // Prepare HTML email
      const htmlContent = `
        <html>
          <body>
            <h2>Dutch Word Learning </h2>
            ${wordDetails.map(w => `
              <div>
                <h3>${w.word} (${w.translation})</h3>
                <p><em>Example:</em> ${w.example}</p>
              </div>
            `).join('')}
          </body>
        </html>
      `;
    
      // Send email
      await email({
        subject: "Your Daily Dutch Words ",
        html: htmlContent,
        text: wordDetails.map(w => 
          `${w.word} (${w.translation}): ${w.example}`
        ).join('\n')
      });
    
      return wordDetails;
    }

“Talk to me in <language> and point out my grammar errors in English”

I imagine it’s risky, learning bad habits. But it seems like it might be very convenient. I believe the biggest issue for me is actually using a language regularly. But I’m way too socially afraid to do one of those “speak to a random person live” things.

Or even some sort of, “translate all my emails to <language>, but show English when I mouse over.”

I bolstered my French by setting almost all my video games to French in university. It helped me a ton, and was accessible because I understood the context.

Translation tech has come a long way. Might not even need LLMs.

You could generalize this into all sorts of reminders , notices, affirmations, quotes.

What's the hardest European language to learn?

Dutch.

Why?

Because every time you speak to them in Dutch they respond to you in English.

It seems this is a way around that :-D

(I don't actually think it's the hardest language but have found that yes, many Dutch speak English very well)