Coder Legion - Recent posts tagged weekendchallenge

I built my girlfriend a local Gemma football analyst that won't make up the stats

Tue, 27 Oct 2026 02:20:22 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.

What I built

MatchMind is a local AI analyst for Brazilian football, built for Bruna Boaventura, my girlfriend.

Bruna had a hard time finding Brazilian clubs' results and historical data. So I built her one place to look things up — and a way to just ask.

MatchMind puts the numbers together and lets her ask questions in Portuguese to an AI that runs on her own computer. You pick a club and get:

the Brasileirão 2026 table, computed from the season's results, with all 20 crests;
recent form and the last three matches with possession, shots, corners, fouls, goal scorers, cards, stadium and referee;
a "Ver escalações" button that loads both line-ups: formation, coach, minutes and player ratings;
the squad with appearances, goals, assists and ratings;
20+ years of Série A history (2003–2024): titles, season-by-season position and coach, the club's top scorers, discipline, and head-to-head records with the scorers of the last meetings;
a chat with Gemma 3 4B running locally through Ollama, which answers only from that data and separates FATO (fact) from INTERPRETAÇÃO (interpretation).

The rule behind everything: the numbers come from data or from deterministic code, never from the model. If something is missing, MatchMind says "Indisponível" instead of guessing.

Demo

A real answer generated locally by Gemma 3 4B (CPU only):

Line-ups for a match, loaded on demand:

Série A history:

What Bruna said

"Interessante, pois traz dados históricos de 2003 até hoje, contendo gols e estatísticas."
("Interesting, because it brings historical data from 2003 until today, with goals and statistics.")

That was exactly the gap she had: the history is what made it useful for her. (To be precise about coverage: the historical dataset runs from 2003 to 2024, and the current 2026 season comes from a separate live source.)

Code

{% github Darrkkens/matchmind %}

Backend: Go (standard library + pgx for an optional PostgreSQL cache).
Frontend: Vue 3 + TypeScript, interface in Brazilian Portuguese.
AI: Gemma 3 4B through Ollama's /api/chat with structured JSON output.
MIT license, CI with go vet, go test -race and the frontend build, plus contributing guide and issue templates.

Quick start: ollama pull gemma3:4b, then go run ./cmd/server in backend/ and npm run dev in frontend/. No account and no API key are needed.

How I built it

OpenFootball (results, CC0)  ──┐
Série A history CSVs (GPL-2.0) ┼─► Go API ─► deterministic stats, table, form
Optional stats API + cache  ───┘      │
                                      ▼
                     compact JSON context for this question
                                      ▼
                        Gemma 3 4B via Ollama (local)
                                      ▼
            Go validates the JSON and adds FATO / INTERPRETAÇÃO

Data I can trust. Results come from OpenFootball (CC0). The 2003–2024 history comes from Adão Duque's Brasileirão dataset, downloaded at runtime. I computed every season's final table from the results, and the champions match the official list for all 22 seasons; the scorers file matches the final score in 100% of matches since 2015. Where the source has gaps (its 2016 and 2024 statistics are mostly zeros), MatchMind drops those averages instead of showing fake numbers.

Linking sources without guessing. Per-match statistics, scorers and line-ups come from an optional API. A match only receives that data when round, opponent, home/away side and final score all agree with OpenFootball. Line-ups abbreviate names ("G. Gómez") while player stats use full names ("Gustavo Gómez"), so I wrote a matcher that understands initials. It links 95% of starters; the rest (nickname vs. legal name) are shown without numbers rather than guessed. Every API response is cached — in PostgreSQL if you run docker compose up — so a finished match costs one request, ever.

Grounding the model. The browser never sends context. For each question, Go rebuilds the club snapshot and sends Gemma a JSON envelope that keeps the data separate from the question and is explicitly treated as untrusted. Gemma returns facts, interpretation and sources_used; Go validates the structure and the allowed source names and adds the labels itself.

What real testing taught me. Mocked tests passed, but running the real model exposed two problems:

Too slow. As I added history, line-ups and cards, a question on a CPU-only machine went past my 240-second timeout. The fix was to make the context depend on the question: the full table, the season history, the head-to-head records, the squad or the cards are only sent when the question is about them. The context for "where are we in the table and how many titles?" dropped from about 11,400 to 5,400 characters, and the answer came back in about three minutes.
Technically true, actually wrong. Gemma answered that Palmeiras "has 4 Brazilian titles". That's the count in the dataset, which only covers 2003–2024; Palmeiras has more. The prompt already said so, but a 4B model doesn't always follow a sentence buried in a prompt. So I renamed the field the model sees to serie_a_titles_2003_2024_only. The next answer said "4 Série A titles between 2003 and 2024" — the answer you see in the screenshot above. When a rule really matters (like flagging sample data from an API test key), Go appends the warning itself instead of trusting the model.

Why does open matter?

It runs on her machine and costs nothing. After ollama pull gemma3:4b, there's no per-question fee, no AI account and no key to protect. The football data sources used by default are open too.
Her questions stay local. With the default settings, the questions and the club data are processed on the same computer. Nothing goes to a model provider.
I control the whole stack. When the model was too slow, I didn't wait for a vendor: I changed what the model sees. When it phrased something misleadingly, I changed the data contract. I can swap in gemma3:12b on a stronger machine with one environment variable.
The trade-off is honest. A 4B model on a CPU is slow (1.5–3 minutes per answer) and can still omit something that is in its context. That's why the numbers on screen come from code, not from the model, and why every answer says which data it used. A big hosted model would answer faster, but it would cost money per question, need an account, and send everything off the machine — for a personal football tool, those trade-offs aren't worth it.

AI assistance

I built MatchMind with the help of an AI coding assistant (Claude Code), which I directed, reviewed and tested throughout. All data, screenshots and the model answer shown above come from running the real application.

Prize categories

Best Use of Gemma — Gemma 3 4B runs locally through Ollama as the analyst at the core of MatchMind. The project shapes its context per question, constrains it with structured JSON output, validates every answer in Go, and documents where the model still fails.

Interview Buddy: Private Interview Practice for a Friend’s First Developer Job

Mon, 26 Oct 2026 04:55:50 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built Interview Buddy for a friend preparing for their first software engineering job. The focus is junior .NET / full stack development, especially practising how to explain technical answers clearly and confidently.

The app turns a CV and job description into a short practice interview. You choose technical, behavioural, or mixed questions and a difficulty level, then answer one question at a time.

Each answer receives feedback covering:

What went well.
Technical mistakes or missing points.
How to explain the answer more clearly.
An example improved answer.
One relevant follow-up question.

You can retry a question and finish with a reflection on strengths, topics to revise, and suggested next practice. Behavioural coaching asks the model to use STAR without inventing a personal story. Improved answers must stick to supplied experience or clearly label hypothetical examples.

Privacy is part of the workflow: Save this session locally is optional and unchecked by default. Temporary sessions disappear on refresh. Saved sessions can be revisited or deleted individually, and there is a Delete all local data action. Users can also flag questionable feedback.

The interface uses a calm navy, green, and neutral palette, with readable questions, labelled controls, loading states, and a local-AI connection indicator. A clearly labelled synthetic demo previews the workflow without pretending to assess answers using live AI.

Actual friend feedback:

What helped: “Practising one question at a time made it easier to focus. The clearer answer examples helped me organise my explanations.”
What confused them: “I wasn’t sure whether flagging feedback would correct it or just mark it for review.”
What they would change: “I’d like a hint before answering and a way to practise only the topics I struggled with.”

Demo

Video walkthrough: Watch or download Interview Buddy on GitHub

Direct MP4 link · 74.5 seconds · 1080 × 1920 · silent, with explanatory text.

Created with Remotion using actual captures of the running app’s synthetic workflow: context, saving consent, answers, feedback, retry, flagging, summary, and restored history. This is an edited browser-capture walkthrough, not continuous native screen recording or live AI inference.

The app currently runs locally; it has not been publicly deployed. The repository includes startup instructions, synthetic sample inputs, and a short hand-off walkthrough. The synthetic demo can be explored without downloading a model.

Code

Interview Buddy repository

The repository is public. The Remotion source and synthetic capture assets are included in walkthrough/.

How I Built It

The app uses React and TypeScript for the frontend, Python FastAPI for the backend, and SQLite for sessions the user explicitly chooses to save.

The inference integration uses Ollama with Qwen2.5 7B Instruct, an open-weight model released under Apache 2.0. The model name and local endpoint are configurable. Only the backend sends inference requests to Ollama; there are no cloud AI calls.

The backend requests structured JSON and validates responses with Pydantic. Invalid output gets one repair attempt before a helpful error. The app handles missing models, unavailable Ollama, timeouts, and cancellation. CVs, job descriptions, and answers are treated as untrusted evidence rather than instructions.

I kept the architecture small: no agent framework. Docker Compose provides a convenient setup, and the README includes instructions for running without Docker.

Validation: six mocked tests passed, covering the API workflow, response validation, persistence and deletion, consent, repair, and failure handling. TypeScript checks, frontend formatting, Python lint, the production build, and Compose configuration validation also passed. The dependency audit reported zero vulnerabilities at the time of checking.

Current limits: real inference has not been tested because Ollama was unavailable in the build environment. Docker execution remains unverified. The synthetic workflow was checked in the browser, including retries, flagging, summary, saving, and history restoration. Saved SQLite data is unencrypted, and model feedback can be wrong. The app is intended for single-user localhost use; real friend testing is still pending.

The main lesson was that a focused workflow needs more than question generation: clear privacy choices, useful failure states, and honest feedback labels make practice easier to trust.

Why Does Open Innovation Matter?

CVs and interview answers can contain personal information. Open weights and local inference make it possible to practise without sending those details to a hosted AI provider, while retaining the freedom to inspect the integration and change models.

After dependencies and weights are downloaded, the app is designed to support the core workflow offline. That complete local workflow would not be possible with a hosted-only, closed AI API. It also avoids per-request cloud AI charges, though local hardware, electricity, and inference speed remain tradeoffs.

For this project, open innovation means control over where personal data goes and how the practice tool works. It makes a small, private app possible without tying its usefulness to a cloud service.

I Love Fragrances, So I Built a 6-Game Arcade + Concierge About My Obsession

Sun, 13 Sep 2026 12:02:18 +0000

Hi, my name's Ibrahim, I'm a university student, and I have a problem: I love fragrances way more than my bank account loves me for it.

It started small, the way these things always do. A cheap Middle Eastern attar someone gave me as a gift, the kind that costs less than a coffee but somehow smells like it belongs in a much fancier bottle. Then another. Then I started actually reading about notes, pyramids, accords, sillage, the whole rabbit hole. Fast forward through a lot of saved-up allowance and skipped nights out, and I've now got about 20 bottles on my shelf. Mostly affordable Middle Eastern gems (some of them genuinely punch way above their price), with a small handful of designer pieces I saved up for and treat like trophies.

If you're a fellow fragrance enthusiast, you already know the feeling: you don't just "wear" a scent, you collect them, you study them, you have opinions about whether a note is top, heart, or base and you will absolutely fight someone about it. That obsession is basically the entire reason this project exists.

So when I saw the DEV Weekend Challenge's "Passion" prompt, there was only one thing I could possibly build.

What I built: recommendmeafragrance

recommendmeafragrance is a browser arcade for fragrance nerds: six small daily games built around real perfume data (notes, brands, years, price tiers), plus an AI Concierge you can actually talk to about what you're in the mood for. Every game feeds into a personal "shelf" that tracks which fragrances you've discovered, plus streaks so you have a reason to come back tomorrow.

Here's the tour.

Scentle: Wordle, but for your nose

A new fragrance is picked every day (the same one for everyone, worldwide, no matter your timezone). You get 6 guesses, and after each one you get Wordle style feedback: was the brand exact or just the same house family, did the real answer come out earlier or later than your guess, is it pricier or cheaper, same gender, same concentration, how many notes do you actually share. You can even copy a little emoji share-grid at the end, because obviously.

There's now an Easy/Hard toggle: Easy leans on a famous, recognizable bottle for the day; Hard pulls from the deep catalog for people who want a real challenge.

Note Detective: reverse engineer a scent from its notes only

This one's my favorite. You're given nothing but notes, revealed one at a time in rotating order (one top, one heart, one base, cycling through the pyramid), and you have to guess the perfume before your score hits zero. Every note you reveal costs points, but the cost is calculated as a percentage of that specific perfume's total note count, so a fragrance with 6 notes and one with 16 notes both cost the same fair share to fully reveal. As you burn through reveals, letters of the name itself slowly uncover hangman-style, so there's a nice tension between "guess now" and "wait, I need one more hint."

Also has an Easy/Hard mode, same famous-vs-deep-catalog split as Scentle.

Build-a-Bottle — invent your own scent, find out what it actually is

Pick as many top, heart, and base notes as you want from a searchable list of hundreds of real notes, hit "invent," and the app runs a weighted similarity match (base notes count extra, since they carry a scent's identity the most) against the whole catalog to tell you what you basically just invented, plus two runner-up matches. It also treats closely related notes as the same family (so picking "vanilla" still matches perfumes listed under "Madagascar vanilla," etc.), because with hundreds of real notes in the system, exact-string-only matching would've been brutal.

Higher or Lower

Two perfumes, one question: which came out first, or which one's pricier? Keep guessing right to build a streak, one miss ends the run. Easy mode keeps the gap obvious and leans on famous bottles; Hard mode pulls from the deep catalog and can come down to a single year or price tier.

Scent Roulette

Set some dials (season, occasion, how much chaos you want), pull the lever, get a fragrance recommendation that actually respects your filters instead of just being random.

Swipe through fragrances blind, no brand or hype attached, just notes and vibe, and decide "buy" or "skip." At the end it tells you your "nose score," how many of your buys were actually the famous, universally-loved ones. Humbling, honestly.

Meet the Concierge

Alongside the games there's a chat-style AI Concierge, built to feel like the app's little mascot come to life: warm, encouraging, genuinely curious about what you like, not just a recommendation-spitting bot. Tell it "something warm and cozy for winter nights" and it'll actually ask a follow-up question before throwing fragrances at you, and when it does recommend something, it comes with a real, buyable card attached, not just a name typed in a chat bubble.

Bringing Google AI into it

This is where I'm submitting for the Best Use of Google AI category. The Concierge runs on a shared daily budget by default so everyone gets to try it for free, but I added a "bring your own Gemini API key" option: paste in a free key from Google AI Studio, and the Concierge switches over to running entirely on Gemini for you, with zero daily limit. The key never touches our servers, it lives only in your browser's local storage and gets sent along with your own requests, so you're fully in control of it. It felt like the right way to let people who want unlimited access get it, without me needing to foot an unlimited AI bill as a student running this on personal savings.

Real bottles, real links

None of this matters if it's just a trivia game, so every single fragrance in the catalog (over a thousand of them) is linked to a live, working offer through FragranceShop.com. Win a game, discover something in the Concierge, or just click "buy" on a card, and it adds to your personal shelf and takes you straight to a real product you can actually purchase. It's a small, honest way to make an app about a hobby self-sustaining without shoving ads in your face.

Try it

recommendmeafragrance.com

No pressure to sign up for anything just to poke around, though creating a free account (Google sign-in, ten seconds) saves your streaks and shelf across devices and unlocks the Concierge chat.

Closing thoughts

I've genuinely lost track of how many hours went into this between actual classwork, but every time I opened a new bottle from my (very modest, very Middle-Eastern-attar-heavy) collection for "research," it felt worth it. If you're even a little bit of a fragrance nerd, or you just like small, weird, well-made web games, I'd love for you to come play and tell me what your nose score is.

weekendchallenge #googleai #webdev #showdev

VOICE IMPLEMENTATION ArokoOro: Preserving Indigenous Languages with Gamification & ElevenLabs

Tue, 28 Jul 2026 01:29:50 +0000

https://dev.to/thegamersbaxechief/arokooro-preserving-indigenous-languages-with-gamification-elevenlabs-this-is-a-submission-for-1dl6

What I Built
For this weekend's challenge, I built ArokoOro a desktop Scrabble-style word game engineered to help users learn, practice, and preserve indigenous African languages (like Yoruba and Fula). The application challenges players to unscramble words, offering hints and scoring mechanics.

Passion is often about preserving where we come from and building tools that make learning engaging. I have a deep interest in gamification strategies and using interactive problem-solving to build engaging software. Indigenous languages carry so much history, but learning them from a textbook can be dry. I wanted to fuse the addictive loop of a word puzzle with cutting-edge Text-to-Speech technology. The passion here is cultural preservation through the lens of modern game development.

Demo
Here is a look at the ArokoOro interface in action!

Code

import os
import threading
import pygame
from tkinter import *
from random import choice, shuffle
from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs

--- API & Audio Setup ---

load_dotenv()
eleven_client = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))
pygame.mixer.init()

def play_word_audio(spoken_word):

"""Fetches the audio from ElevenLabs and plays it in the background."""
filename = "temp_word.mp3"
try:
    audio_stream = eleven_client.text_to_speech.convert(
        voice_id="pNInz6obpgDQGcFmaJgB", 
        output_format="mp3_44100_128",   
        text=spoken_word,                       
        model_id="eleven_multilingual_v2" 
    )

    with open(filename, "wb") as f:
        for chunk in audio_stream:
            if chunk:
                f.write(chunk)

    pygame.mixer.music.load(filename)
    pygame.mixer.music.play()
except Exception as e:
    print(f"ElevenLabs Error: {e}")

--- GUI Setup ---

root = Tk()
root.title('MajasWotdFlip')
root.geometry("600x400+-1900+100")

my_label = Label(root, text="", font=("Helvetica", 48))
my_label.pack(pady=20)

def shuffler():

hint_label.config(text='')
global hint_count
hint_count = 0
entry_answer.delete(0, END)
answer_label.config(text='')

states = ['Bawo ni?', 'No gonda?', 'Ẹ káàárọ̀ ','Jam tan','Ẹ káàsán', 'Jam wodi', 'Ẹ káalẹ́ ', 'Jam na foti', 'kúùjọkòó', 'No foti', 'Ẹ sé' , 'Ajaraama', 'Jọ̀ọ́ ', 'Jam aada', 'Mo ní fẹ́ ',  'Mi yewi', 'Báwo ni orúkọ rẹ', 'No honto', 'Orúkọ mi ni', 'Mi honto', 'Ọmọ', 'Baajo', 'Bàbá', 'Baaba', 'Màmá', 'Ndewo', 'Ẹ̀gbọ́n', 'Sedyo', 'Àbúrò', 'Gorko', 'Ọkùnrin', 'Naado', 'Obìnrin', 'Debbo', 'Ile', 'Wuro', 'Ilé ìwé', 'Daande', 'Ounje', 'Lewru', 'Òrò', 'Konngi', 'Omi', 'Ndiyam', 'Ẹbọ', 'Seeri', 'Ẹyin', 'Noowo', 'Isu', 'Ndiiw', 'Ẹran', 'Leela', 'Àṣọ', 'Daani', 'Ijò' , 'Daali', 'Igbẹ́ ', 'Seero', 'Ìgbẹ́ ', 'Leesi', 'Ọ̀dọ', 'Lawol', 'Ọ̀yà', 'Jamu', 'Moun', 'Òṣùpá', 'Lewru',  'Òun tímo fẹ́ ', 'Mi yewi', 'Ìròyìn', 'Hareey','Ọ̀rọ̀ tí ó ṣẹlẹ̀', 'Gorko', 'gbẹ́sẹ̀ ', 'Fott', 'Ète', 'Pulaar', 'Orí', 'Honto', 'ẹranko', 'Naado leela', 'Ẹṣin', 'Hiima', 'Iná' , 'Fire', 'Òtútù', 'Ngella', 'Òjò', 'Ruwa', 'Ìrìnàjò', 'Yellagol', 'Ẹ̀gbọ́n', 'Noddle', 'Ilé Ìgbéyàwó', 'Daande', 'marwo', 'Ìrẹ́jẹ', 'Lehru', 'Ẹsẹ́ ', 'Wale', 'Ìsọ́ra', 'Jam', 'Ẹ́lẹ́dàa', 'Mooso', 'Iwọ', 'Aadi', 'Ẹgbọ́n tímo fẹ́', 'Gorko yewi', 'Olúwa', 'Allah', 'Ilé iṣẹ́ ', 'Taare', 'Àṣá', 'Konngi', 'Ìjọba', 'Beegi', 'Ìlú', 'Dekkere', 'Ẹwá',' Deena', 'Oríkì', 'Wale', 'Àkọ́kọ́ ', 'Fettunde', 'Àtijọ', 'Daaɗi', 'Ìjẹ́wẹ̀ ', 'Luudo', 'Ojú', 'Wana', 'Ọgbọ́n', 'Siina', 'Ọgbọ́n tímo ní', 'Mi siina', 'Ìlu', 'Wuro', 'Ìfẹ́ ', 'Habbere', 'Ọ̀rẹ́ ', 'Maro', 'Òun tímo nse', 'Mi noggi', 'Orí ẹ̀yìn', 'Wani laawol', 'Ilé Ìgbéyàwó', 'Daande marwo', 'Igbéyàwo', 'Ndoorti', 'Ìjọba', 'Beegi' , 'Ìlú', 'Wuro', 'Àìní', 'Weeti', 'Ọkùnrin tímo ní', 'Mi naado',  'Obìnrin tímo ní', 'Mi debbo', 'Èda', 'Mooso', 'Òun tímo ní', 'Miɗo', 'Igi', 'Ndow', 'Ìfẹ́ ', 'Habbere', 'Ẹ̀jẹ́ ', 'Dentu', 'Orí', 'Wano', 'Ẹnu', 'Pene', 'Orí', 'Wana', 'Ẹ̀gbọ́n', 'tímo fẹ́ ', 'Gorko yewi', 'Ile', 'Wuro', 'Ọ̀dọ̀ ', 'Lewol', 'Òṣùpá', 'Lewru', 'Iná', 'Leela', 'Ìrìnàjò','Yellagol', 'Ẹ̀ṣẹ́ ', 'Wale', 'Oregon', 'California', 'Ohio', 'Nebraska', 'Colorado', 'Michigan', 'Massachusetts', 'Florida', 'Texas', 'Oklahoma', 'Hawaii', 'Alaska', 'Utah', 'New Mexico', 'North Dakota', 'South Dakota', 'West Virginia', 'Virginia', 'New Jersey', 'Minnesota', 'Illinois', 'Indiana', 'Kentucky', 'Tennessee', 'Georgia', 'Alabama', 'Mississippi', 'North Carolina', 'South Carolina', 'Maine', 'Vermont', 'New Hampshire', 'Connecticut', 'Rhode Island', 'Wyoming', 'Montana', 'Kansas', 'Iowa', 'Pennsylvania', 'Maryland', 'Missouri', 'Arizona', 'Nevada', 'New York', 'Wisconsin', 'Delaware', 'Idaho', 'Arkansas', 'Louisiana']

global word
word = choice(states)

break_apart_word = list(word)
shuffle(break_apart_word)

global shuffled_word
shuffled_word =  ''
for letter in break_apart_word:
    shuffled_word += letter

my_label.config(text=shuffled_word)

def answer():

if word == entry_answer.get():
    answer_label.config(text="Correct!!")
    threading.Thread(target=play_word_audio, args=(word,), daemon=True).start()
else:
    answer_label.config(text="Incorrect!!")

global hint_count
hint_count = 0

def hint(count):

global hint_count
hint_count = count
word_length = len(word)
if count < word_length:
    hint_label.config(text=f'{hint_label["text"]} {word[count]}')
    hint_count +=1

entry_answer = Entry(root, font=("Helvetica", 24))
entry_answer.pack(pady=20)

button_frame = Frame(root)
button_frame.pack(pady=20)

answer_button = Button(button_frame, text="Answer", command=answer)
answer_button.grid(row=0, column=0, padx=10)

my_button = Button(button_frame, text="Pick Another Word", command=shuffler)
my_button.grid(row=0, column=1, padx=10)

hint_button = Button(button_frame, text="Hint", command=lambda: hint(hint_count))
hint_button.grid(row=0, column=2, padx=10)

answer_label = Label(root, text='', font=("Helvetica", 18))
answer_label.pack(pady=20)

hint_label = Label(root, text='', font=("Helvetica", 18))
hint_label.pack(pady=10)

shuffler()
root.mainloop() -->
How I Built It
I built the game engine using Python, leveraging Tkinter for the lightweight graphical user interface and Pygame to manage the audio mixer and background thread playback.

To give the game its voice, I implemented the ElevenLabs Python SDK. Specifically, I used their multilingual_v2 model. This was a crucial technical decision because the model handles the subtle inflections of non-English words remarkably well, which is essential when the goal is teaching indigenous language pronunciation.

I love building in Linux environments, but developing this on my Acer Chromebook's Linux container (Crostini) threw some serious curveballs at me this weekend. I wanted to share the raw debugging journey because the errors were just as educational as the code itself!

The PEP 668 Guardrail: When I first tried to pip install elevenlabs, Linux hit me with the dreaded externally-managed-environment error.
The Deep Dive: At first, I thought my Python installation was broken. It turns out, this is a built-in safety feature (PEP 668) adopted by many Linux distributions, including the Debian container running on my ChromeOS. It is designed to prevent pip from accidentally overwriting or breaking core system-level Python tools.

python3 -m venv .venv
source .venv/bin/activate
Error Updating ElevenLabs

The Fix: I had to embrace the sandbox. I spun up a virtual environment (python3 -m venv .venv) to isolate my packages and keep my system's global Python installation safe. By activating the .venv, I redirected my shell to use the isolated binaries. After that, installing the ElevenLabs SDK, Pygame, and Python-Dotenv was completely frictionless.

The Sneaky 401 Unauthorized Error: Once the environment was set up, the code ran, but the audio failed, spitting out a status_code: 401.
I had written the code to fetch my API key securely using os.getenv("ELEVENLABS_API_KEY"). However, I had completely forgotten to actually build the vault it was trying to read from! Because the environment variable didn't exist, Python was sending a blank payload to the ElevenLabs server, and their API was rightfully slamming the door in my face.

Audio Input Failure

The Fix: I had hardcoded my environment variable call but forgot to actually build the .env vault! Moving the API key into a dedicated .env file and loading it with python-dotenv instantly fixed the authentication handshake.I created a dedicated .env file at the root of my project to store the key. A major lesson learned here was strict formatting: the .env file requires zero spaces around the equals sign and absolutely no quotation marks around the key. I also immediately added a .gitignore file to ensure my .env vault wouldn't be accidentally pushed to GitHub. Once python-dotenv loaded the hidden file, the authentication handshake succeeded instantly.

The Crostini Network Drop: Just when I thought I was at the finish line, I got hit with [Errno -3] Temporary failure in name resolution.

Error for bad api input

The Fix: This was a classic Chromebook Linux container quirk. The host device had Wi-Fi, but the container's DNS resolution had temporarily desynced after waking up. A quick container restart and a ping google.com to verify the connection, and the game finally spoke!

Maximizing ElevenLabs: The Future Roadmap
While the current integration is incredibly satisfying, the ElevenLabs API offers several advanced features that I plan to implement next to make this application even more robust for cultural preservation:

Custom Voice Design for Authentic Dialects
Right now, the game uses a default voice profile. Moving forward, I plan to utilize ElevenLabs' Voice Design and Voice Cloning features. By providing high-quality audio samples of native speakers or elders, I can generate a custom voice model that captures the exact regional dialect, cadence, and warmth of the indigenous language, rather than relying on a generic AI tone.

Pronunciation Dictionaries for Tonal Languages
Many African languages, such as Yoruba, are highly tonal—meaning a slight change in pitch completely alters the meaning of a word. If the AI slightly mispronounces a specific vowel grouping, I plan to implement ElevenLabs' Pronunciation Dictionaries. This will allow me to feed the API specific phonetic spellings (using the International Phonetic Alphabet - IPA) to force the engine to emphasize the exact tonal markings of complex indigenous words.

Direct Audio Streaming for Zero Latency
Currently, the application downloads the generated audio chunk, saves it to a local temp_word.mp3 file, and then triggers Pygame to read that file. To make the UI feel lightning-fast, I want to optimize the architecture to stream the ElevenLabs audio bytes directly into Pygame's memory buffer. This will eliminate the disk read/write step entirely, allowing the audio to play the exact millisecond the player hits the "Answer" button.

The Program runs with a welcome inBuilt Note " Bawo Ni " meaning "How are you? " Thanks to #ElevenLabs !! Imagine the possiblilties!

Coder Legion - Recent posts tagged weekendchallenge

I built my girlfriend a local Gemma football analyst that won't make up the stats

What I built

Demo

What Bruna said

Code

How I built it

Why does open matter?

AI assistance

Prize categories

Interview Buddy: Private Interview Practice for a Friend’s First Developer Job

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

I Love Fragrances, So I Built a 6-Game Arcade + Concierge About My Obsession

What I built: recommendmeafragrance

Scentle: Wordle, but for your nose

Note Detective: reverse engineer a scent from its notes only

Build-a-Bottle — invent your own scent, find out what it actually is

Higher or Lower

Scent Roulette

Blind Date

Meet the Concierge

Bringing Google AI into it

Real bottles, real links

Try it

Closing thoughts

weekendchallenge #googleai #webdev #showdev

VOICE IMPLEMENTATION ArokoOro: Preserving Indigenous Languages with Gamification & ElevenLabs

Code

--- API & Audio Setup ---

--- GUI Setup ---

Demo